I thought I’d share another slide with you tonight. This is also from my upcoming Train Signal vSphere Pro video. Before tackling a set of PowerCLI cmdlets, I like to give you a good base understanding of the concepts.

As evidenced by the slide I’m working on at the moment for the upcoming TrainSignal vSphere Pro Series lesson titled “Performance with PowerCLI”.

I really wanted to use stars for the difficulty level and make them vibrate like they do in the game, but I was spending too much time on this slide as it was.

I needed some source text to test a regular expression pattern, so my goal tonight was to generate some. The regex pattern in question finds email addresses, so I needed to be sure to embed real-looking email addresses inside of gibberish. Step number one: I need some random letters. PowerShell v2’s Get-Random cmdlet comes to the rescue!

Get-Random has two modes. The first mode allows you to return random numbers, and you can specify a min and max range. The second mode will return random items from a list, and as an added bonus, you can specify the number of items to return. I plan on using both modes in this exercise.

In order to build gibberish words or email addresses, I need to start with a list of allowable characters. Let’s keep it simple and restrict things to lowercase letters, although adding in numbers would be simple.

You all remember ASCII, right? This is a conversion table that has been used to represent numeric values for letters (and every other character on you keyboard, plus others) for a long, LONG time. You are slowly seeing ASCII encoding supplanted by Unicode as that table has a much larger address space and can handle non-Latin alphabets, but ASCII suits me just fine. We are going to use ASCII values and PowerShell’s range operator (..) to generate the list of allowable characters.

If you have worked with Vbscript, then you might know how to to ASCII conversions with the Chr() function. You give that function a number, and it spits out the ASCII value. The reverse is done with the Asc() function. In PowerShell, it’s not done the same way at all, so just forget that. Instead, what we are going to do is to convert back and forth between a “char” (character) .NET type. Chars are really sort of an in-between data type. They look like strings (i.e., it’s a letter), but they are very easily converted into integers.

So let’s take that knowledge and combine it with a technique called “casting”. To cast in PowerShell means to state that you want a particular value to be a certain data type. For example, if I have a number, and I want to make sure it is treated like a string in my script, I can cast it as a string like so:

[string]12

If you pipe that to Get-Member, you’ll see that the result is a string object, with all of the properties and methods which that type has, as opposed to the much more basic [int] type.

Moving on, let’s take the letter “a”, and the letter “z”, and turn it into a range containing all of the letters in between. PowerShell’s range operator can be used here, but it only works with integers. I could ask a search engine for an ASCII chart to get the numbers I need, but there’s no need, I’ll just convert from the letters directly.

Here’s how to convert a single letter into its ASCII number representation:

PS > [int][char]'a'

97

What I am doing here is casting twice. Anything surrounded by single or double quotes is a string. I can convert any single letter (or symbol, or whatever) to a char data type by casting it as you can see. Then I take that char and cast it immediately to an integer, and as I said before, that’s an easy conversion for PowerShell to do because that’s the way chars types are wired.

Now we have our first integer. Just replace the ‘a’ with a ‘z’ and we have the second.

PS > [int][char]'z'

122

These integers are going to be perfect as input to the Get-Random cmdlet. Here’s how to return random letters using Get-Random’s first mode:

PS > $min = [int][char]'a'

PS > $max = [int][char]'z'

PS > Get-Random -Minimum $min -Maximum $max

104

PS > [char](Get-Random -Minimum $min -Maximum $max)

l

PS > [char](Get-Random -Minimum $min -Maximum $max)

q

PS > [char](Get-Random -Minimum $min -Maximum $max)

r

As you can see, turning an integer back into a letter is pretty simple, you just cast it to a [char]. (The parentheses are necessary.) And you can also see a new random letter popping up at each execution of Get-Random. Great! So how do we make random words? Well, in the context of this blog post, a word consists of an array of characters. That makes sense, right? There are a few ways to go from here to create the requisite [char] array. I could create a for loop, and run the above command inside the loop.

However, there is an easier way. Let’s go back a step and have a look at Get-Random’s second mode. Here is a table showing the two parameter sets (output created with my Get-Parameter script):

   ParameterSet: RandomNumberParameterSet

Name    Type       IsMandatory Pipeline
----    ----       ----------- --------
SetSeed Nullable`1       False    False
Maximum Object           False    False
Minimum Object           False    False

   ParameterSet: RandomListItemParameterSet

Name        Type       IsMandatory Pipeline
----        ----       ----------- --------
SetSeed     Nullable`1       False    False
InputObject Object[]          True     True
Count       Int32            False    False

We used Minimum and Maximum in the first mode. Now we are going to use InputObject and Count. This mode is really handy because you can supply an array of items (letters in this case) as input, and tell it how many random items to return as output! That means no loop, so the code is going to be much simpler.

First, let’s build an array of all lowercase letters. We already know the numeric values to use in the range, so let’s use those. I’m going to use a little trick to take the integer range and cast it in one step to an array of characters, which is exactly what we want:

PS > $alpha = [char[]]($min..$max)

PS > $alpha | Select-Object -First 3

a

b

c

We build the range with “$min..$max” and put that in parentheses. Then we cast it, but not as a single [char], but as an array of [char]’s by adding an empty set of brackets []. Now, the variable $alpha contains our input to Get-Random. The next step is easy, just pass this variable to the cmdlet and give it a count:

PS > $alpha | Get-Random -Count 5

t

f

a

b

c

Presto! A five-letter word! Well…sorta. What we have is a series of characters, one per line. To turn this into adjacent characters we can cast the whole thing as a string.

PS > [string]( $alpha | Get-Random -Count 5 )

i h s p z

Almost there, we just have to get rid of those extra spaces. The spaces are generated because of something called the “output format separator”, otherwise known as $OFS. This is a variable predefined by PowerShell to be a single space, but you can change it to whatever you want. Here’s that final step:

PS > $ofs = ''

PS > [string]( $alpha | Get-Random -Count 5 )

qfzwg

PS > [string]( $alpha | Get-Random -Count 5 )

dnhbq

Now I am just a hop, skip, and a jump from generating random email addresses, but that’s enough for tonight.

From the SMUG blog:

The Southeast Management User Group invites you to attend the next SMUG meeting scheduled for November 14^th, 2008 for a day of great presentations, discussions, and networking, at the Alpharetta Microsoft Campus.

REGISTRATION LINK

http://msevents.microsoft.com/CUI/InviteOnly.aspx?EventID=5B-11-D1-1D-08-92-D8-84-78-E1-CD-6A-5C-13-92-AA&Culture=en-US

DATE & TIME

November 14^th, 2008
9:00 AM – 4:00 PM

I’ll be there with bells on.  Or something.

(This post is the second in my Solving Problems with PowerShell series.)

Problem: Extract list of IP addresses and ping them

So I had a bunch of text in a webpage form which looked like this:

[172.16.16.139] (2.0.39)
[172.16.16.31] (2.0.40)
[172.16.16.189] (2.0.40)
[172.16.16.156] (2.0.45)
[172.16.15.89] (2.0.46)
[172.16.16.81] (2.0.46)
[172.16.16.73] (2.0.47)
[172.16.16.31] (2.0.48)
[172.16.15.106] (2.0.49)
[172.16.16.238] (2.0.49)
[172.16.15.14] (2.0.54)
[172.16.15.79] (2.0.54)

My goal was to ping each host to see if they were alive.  Here’s how I went about that process.

Step One – Get the data into PowerShell

After copying the above into the clipboard, I used PowerShell’s “here-string” feature to quickly get the list into a variable.  I just typed this into a console window:

$a = @"

Then I hit enter, then ctrl-V, followed by another enter (so that its on a line by itself) and this:

"@

Now, $a contains the string I want to match against.

Step Two – Parse the text

This one was easier than you may think because I had done some prep some months ago for just such an occasion.  There’s this really cool tool Expresso (website appears down, uh oh!  google similar results to the rescue!) which helps you to graphically create a regular expression which can then be used to for parsing text.  That tool came with a library of commonly used regular expressions, one of which was made to match IP addresses.  To save time for when I might need to use it, I have this in my profile which loads when PowerShell is started:

New-Variable -Name RegexIP -Force `
    -Description "A regular expression object which matches and validates IP addresses." `
    -Value ([regex]'(?<First>2[0-4]\d|25[0-5]|[01]?\d\d?)\.(?<Second>2[0-4]\d|25[0-5]|[01]?\d\d?)\.(?<Third>2[0-4]\d|25[0-5]|[01]?\d\d?)\.(?<Fourth>2[0-4]\d|25[0-5]|[01]?\d\d?)')

With that in hand, here’s how I parsed the text which was now in the $a variable:

97# $regexip.Matches($a) | select value

Value
-----
172.16.16.139
172.16.16.170
172.16.16.31
172.16.16.189
172.16.16.57
172.16.16.156
172.16.15.89
172.16.16.81
172.16.16.73
172.16.16.31
172.16.16.80
172.16.15.106
172.16.16.238
172.16.15.14
172.16.15.79

Step Three – Ping the male progeny of female dogs!

And lastly, pipe the mess to the Ping-Computer cmdlet which is available from SAPIEN’s PowerShell Extensions (PshX-SAPIEN).

PS > $regexip.Matches($a) | select -ExpandProperty value | Ping-Computer

ComputerName                        StatusCode           ResponseTime ProtocolAddress
------------                        ----------           ------------ ---------------
172.16.16.139                                0                      0 172.16.16.139
172.16.16.170                                0                      0 172.16.16.170
172.16.16.31                                 0                      0 172.16.16.31
172.16.16.189                                0                      0 172.16.16.189
172.16.16.57                                 0                      1 172.16.16.57
172.16.16.156                                0                      0 172.16.16.156
172.16.15.89                                 0                      0 172.16.15.89
172.16.16.81                                 0                      0 172.16.16.81
172.16.16.73                                 0                      0 172.16.16.73
172.16.16.31                                 0                      0 172.16.16.31
172.16.16.80                                 0                      0 172.16.16.80
172.16.15.106                                0                      0 172.16.15.106
172.16.16.238                                0                      0 172.16.16.238
172.16.15.14                                 0                      0 172.16.15.14
172.16.15.79                                 0                      0 172.16.15.79

Instead of using Select-Object –ExpandProperty, I could have used the Foreach-Object cmdlet in a loop like this:

PS > $regexip.Matches($a) | % { Ping-Computer $_.Value }

Same end result, but I have been using select –exp a lot lately and have gotten used to that technique.  To each his own.

So that’s it!  I hope this walkthrough helps you out with a problem that you need to solve.

This is a screencast to show you how to use the excellent program launcher
Launchy, to quickly execute PowerShell commands.

Karl says he’ll be blogging the steps required today sometime (it might be up by the time you see this).

Portable PowerShell from karl prosser on Vimeo.

Enjoy! You can find BGShell at Codeplex but be forewarned it has some bugs. Definitely a project to watch.

Here’s a brief experiment using a very cool tool called Jing. The application in this video is PowerShell Plus.

(If the video does not appear below, you can find it here.)

I’ve got lots of home improvement projects that I’m working on lately:

* rear deck
* additional kitchen cabinetry
* (someday) wooden playground set

Since I’m seriously left-brained, I often have trouble coming up with creative solutions to problems, or even getting started when the plan is somewhat clear. To really “get it”, I need a detailed plan. I’m not much of a sketch artist either, so of course, I look to the computer to solve my problems.

I’ve written about Google Sketchup before. It’s a 3D CAD program but…how to say this…you don’t need to know what a spline or a bump map is. It’s really easy to get into and be productive right away.

My first drawing was a fantasy castle. It wasn’t to scale and I had to really experiment to figure out how line up the objects and workaround some quirks of the program. Next, I wanted to redesign the office. I took measurements and made a room. Then needed to think about the desk. One of the cool features of Sketchup is the portal where Google hosts contributed 3D models. I searched there for a particular Ikea desk and didn’t find it, although there was other Ikea furniture there.

So, I went to Ikea and took measurements of the desk. It has a funky shape that I really wanted to take into account, so I had to measure several points. Then I set to work making a scale model of the desk. I was pretty happy with the end result:

Here it is laid out in my office:

There’s a ton of benefits to taking the time to make these 3D models. For me the biggest thing was the ability to see very clearly with no confusion exactly how a given piece of furniture would fit in a room. Would I have enough space to walk around the desk and pull out the chair? What if I wanted to have someone standing or sitting next to me looking at my monitor? Having the option to play out these scenarios was extremely valuable.

Next post I’ll show how my wife and I worked on a kitchen remodeling plan and start getting into techniques you can use. Then later I’ll get into the deck and cabinet projects. Let me know if you find this useful to you.