I just read a blog post from Thomas Lee that talked about Paper.Li. I really like this site and thought I’d share as well. In particular, there is a feature to browse tweets by hashtag. I can see this as being really useful for me as I prepare the show notes for the PowerScripting Podcast (the #powershell tag, of course). Here’s a screenshot:

Go check out paper.li!

Need to determine what the uplink policy is for your DVSwitches? Here is a quick PowerCLI snippet to do that. I’d go into more detail but I don’t have time this moment. Consider this longer than a tweet, but shorter than my normal blog post.

Here is the corresponding screen in the vSphere Client (pardon the font issues, I’m running blind-person-size-font) with the relevant portion highlighted:

And the code:

PS> $pgName = 'Name of your DV port group'
PS> $pg = Get-View -ViewType DistributedVirtualPortgroup -Filter @{ Name = $pgName }
PS> $pg.Config.DefaultPortConfig.UplinkTeamingPolicy.UplinkPortOrder

ActiveUplinkPort  : {dvUplink1, dvUplink2}
StandbyUplinkPort :
Inherited         : True
DynamicType       :
DynamicProperty   :

There have been many book releases in the months since PowerShell V2 has been released, and there are several still in the works. It’s also neat to see all of the localized book projects—that really shows how important PowerShell is the entire world over. Here is a list of the books that I’ve heard about lately, in alpha order by title:

If you know of any that I have missed, please let me know in the comments.

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.

PowerShell.com just posted a tip today on how to create a range of letters. The tip looks like this:

65..90 | Foreach-Object { "$([char]$_):" }

That works fine, but I have another way to share with you in case you don’t want to look up the ASCII values every time. This is very similar to a technique used in my Random Letters post of not too long ago:

[char[]]([char]'a'..[char]'z')

[string]( [char[]]([char]'a'..[char]'z') )

"$([char[]]([char]'a'..[char]'z'))"

First, let me give credit up front that this tip was inspired by one or two recent Power Tips from PowerShell.com.

With that out of the way, I wanted to show you real quick that if you want the sort of information that you get from ipconfig.exe, then the command is even simpler:

PS > gwmi win32_networkadapterconfiguration | ? { $_.IPAddress }

DHCPEnabled      : True

IPAddress        : {151.140.143.41}

DefaultIPGateway : {151.140.142.1}

DNSDomain        : halr9000.com

ServiceName      : b57w2k

Description      : Broadcom NetXtreme Gigabit Ethernet - Packet Scheduler Miniport

Index            : 8

DHCPEnabled      : True

IPAddress        : {151.140.143.41}

DefaultIPGateway : {151.140.142.1}

DNSDomain        : whatever.local

 ServiceName      : AR5416

Description      : Broadcom NetXtreme Gigabit Ethernet - Packet Scheduler Miniport

Index            : 10

You can rely on the default output of the Win32_NetworkAdapterConfiguration WMI class to display some of the more important bits here—just like ipconfig. But what if you want more—in other words, “ipconfig /all”? That data is already in there, but it’s not displayed to the screen by default. To get at it, you can pipe to Format-List and stick an asterisk at the end to tell it to display everything, like so:

PS > gwmi win32_networkadapterconfiguration | ? { $_.IPAddress } | fl *

DHCPLeaseExpires             : 20100427081921.000000-240

Index                        : 8

Description                  : Broadcom NetXtreme Gigabit Ethernet - Packet Scheduler Miniport

DHCPEnabled                  : True

DHCPLeaseObtained            : 20100421081921.000000-240

DHCPServer                   : 165.130.252.36

...

I used a couple of aliases in the above examples because it saves typing. To be clear for those who don’t know them, here are the definitions:

gwmi = Get-WmiObject

? = Where-Object

fl = Format-List

If you are in the Southeast US, you may be interested in the upcoming Codestock event coming up in June in Knoxville, TN. It seems to be heavily slanted towards developers, but they are doing IT Pro and Entrepeneur tracks this year as well. I have submitted one session for my Managing VMware with PowerShell thing. If you have a minute, please go over to the site to register and vote my session up.

I’ve never been to Codestock before, but it looks like fun. In fact, it looks like a lot more fun than your typical canned vendor convention. I don’t plan on doing many speaker engagements this year aside from the occasional SMUG or APUG meeting here in Atlanta, but I thought going to Knoxville might be a neat excuse to get out an d see a new city. The drive to Knoxville from Atlanta is pretty nice if you go through Chattahoochee and Nantahala national forests, so we are looking forward to that.

(credit tfdavis on flickr)

When using PowerCLI, the first thing you have to do is to create a connection and authenticate yourself to your vSphere and/or vCenter servers. This is done with the Connect-VIServer cmdlet. Sometimes, this connection can be slow, taking ten or more seconds just to display a password prompt! That gets old pretty quickly.

There is a good reason for the slowness before you are prompted for credentials, and turns out, it’s a feature, not a bug. PowerCLI supports a single-sign-on (SSO) authentication when you attempt a connection to a vCenter server. What happens in the background is that your current Windows credentials are being passed on to the server and that is tried first, before even prompting you for credentials. This is great if you are sitting at the office and have a fast link to the vCenter server, and you happen to be logging into your workstation with a domain accont, and that domain account has vCenter rights. This transparent passing of credentials is definitely a timesaver under those circumstances.

But on the other hand, what if you are connecting from home over a slow link? What if you are on your home PC or a local account? What if, due to security policies at your company, your normal user account doesn’t even HAVE admin privileges? Yup, the authentication attempt fails (or simply takes a while), and you are left twiddling your thumbs, waiting for the “real” login prompt to appear.

Resolution

The fix is an easy one. Instead of typing this to connect:

Connect-VIServer vcenter.domain.com

…type something like this:

Connect-VIServer vcenter.domain.com -Credential (Get-Credential)

or the less-recommended, yet still quite functional:

Connect-VIServer vcenter.domain.com -user myuser -password mypass

By using one of these methods, you are instructing Connect-VIServer to explicitly use a set of credentials which you specify. This way, it won’t bother attempting to pass along your current credentials, thus saving you a few seconds and perhaps a gray hair or two.

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.

Please comment…

Logo1:

Logo 2:

This is a sample script that I created to show how you might create a relatively complex virtual farm environment. The hypothetical requirements for this farm are:

1. Add 10 ESX servers to a vCenter, one for each customer
2. Create a resource pool for each customer
3. Inside each of these, create a resource pool for each server role, and a specified number of virtual machines, based on previously-created VM templates
   1. 2 x proxy server
   2. 4 x web server
   3. 2 x app server
   4. 2 x database server

I hope you find the script useful!

Just a quick post to get your comments. What do you think about this slide? Am I missing anything that needs mentioning here?

P.S. Office “Smart Art” FTW

A co-worker today asked me how he could redirect output from an external executable into a variable. Seemed easy enough, you just do this:

$var = mycmd.exe

He tried it and got back a $null for his trouble. Turned out, the executable was writing to the error stream (STDERR) instead of STDOUT. Now, the question came up of how to capture that information.

We had to get a little old school because this is a DOS convention (well, much older than that but anyway) and has nothing to do with PowerShell. The answer wasn’t hard, but the response wasn’t what we expected. Observe:

PS > $a = netstat bob 2>&1 # cause intentional err and redirect
PS > $a.GetType()

IsPublic IsSerial Name                                     BaseType
-------- -------- ----                                     --------
True     True     Object[]                                 System.Array

PS > $a[0].GetType()

IsPublic IsSerial Name                                     BaseType
-------- -------- ----                                     --------
True     True     ErrorRecord                              System.Object

I used “2>&1” to redirect the STDERR stream to the STDOUT stream. Worked fine, however when we tried to work with the results we found that it wasn’t a string array. Instead, as you see above, it is an array of ErrorRecord objects! In hindsight, that made sense to me. I mean, what else would you expect in the error stream but errors?

Anyway, long story short, the way to access the text inside of these error objects is by accessing the Exception property. But it was slightly more complex, as what you get is TWO errors. One with the “powershelly” NativeCommandError, and the second with the text that we needed. For example:

PS > $a[0]
netstat.exe :
At line:1 char:13
+ $a = netstat <<<<  bob 2>&1 # cause intentional err and redirect
    + CategoryInfo          : NotSpecified: (:String) [], RemoteException
    + FullyQualifiedErrorId : NativeCommandError

PS > $a[1].Exception
Displays protocol statistics and current TCP/IP network connections.

NETSTAT [-a] [-b] [-e] [-n] [-o] [-p proto] [-r] [-s] [-v] [interval]

PowerShell is so cool…

I had no idea how to automate Outlook with COM before today. Took me about 5 minutes to learn how with PowerShell. I knew it could be done with VBS, right? That’s how viruses are made.

This won’t be a long blog unfortunately, but wanted to paste real quick a series of commands which I basically figured out in a shell interactively. I didn’t have to read any docs, Get-Member told me all I needed to know.

I did go back and add some comments. I hope you find it useful.

$ol = New-Object -com Outlook.Application # starts outlook

$ol.Reminders | select caption, nextreminderdate # show reminders

$ol | gm -mem method # show all methods (actions) on the com object

$n = $ol.CreateItem('olNoteItem') # creates a note

$n # display note object

$n.Body = 'test' # set body of note

$n | gm # display object members (methods & properties) of note

$n.Display() # show note

$n.Color # display color value

$n.Color = 4 # set color

1..5 | ForEach-Object { $n.Color = $_; sleep 1 } # change color of note 5 times

$m = $ol.CreateItem('olMailItem') # create mail object

$m # display mail object

$m | gm -mem property # show mail properties

$m.Subject = 'test' # set subject

$m.Body = 'test' # set body

$m.To = 'email@domain.com' # set to address

$m.Display() # display mail item on screen 

$m.Send() # send mail item

$ol # display outlook object

$ol | gm # display outlook methods

If you are seeing crashes in MSCORSVW.DLL, try this, it may help (and it won’t hurt):

Start-Job {
    Set-Alias ngen (dir (join-path ${env:\windir} "Microsoft.NET\Framework") ngen.exe -recurse |
    sort -descending lastwritetime
    )[0].fullName
    ngen executequeueditems
}

For more details, see this Connect bug:

• Uninstalling KB968380 RC in XP/Srv2003 causes .NET Runtime Optimization Service to crash

If you haven’t already, run, do not walk to the MSDN Code Gallery to grab the PowerShell Pack (a part of the upcoming Windows 7 Resource Kit).

As announced on the PowerShell team blog, and discussed at great length on Episode 88 of the PowerScripting Podcast, the PowerShell Pack is a set of ten modules, nested into one for ease of installation. There is a ton of great stuff in here. I wrote up a bit of code to list all of the included functions:

$m = Get-Module PowerShellPack

$n = $m.NestedModules | Where-Object { $_.Name -ne 'WPK' } 

foreach ( $module in $n ) {

    Write-Host -ForegroundColor Green "Module: $( $module.name )" -NoNewline

    $module.ExportedCommands.Values | Sort-Object Name | Format-Wide Name

}

As you see in the Where-Object clause there, I am excluding the WPK module. The reason is simply due to the nature of that module, it has hundreds of functions and is really deserving of its own blog post—or book for that matter.

I’m not going to list the full output because I think that’s just cheesy Google gaming, but I will leave you with a teaser:

PS > Get-Module powershellpack | select -ExpandProperty NestedModules

ModuleType Name                      ExportedCommands

---------- ----                      ----------------

Script     IsePack                   {Push-CurrentFileLocation, Select-CurrentTextAsVariable, C...

Script     TaskScheduler             {Remove-Task, Get-ScheduledTask, Stop-Task, Add-TaskTrigge...

Script     WPK                       {Get-DependencyProperty, New-ModelVisual3D, New-DiscreteVe...

Script     FileSystem                {Get-FreeDiskSpace, New-Zip, Resolve-ShortcutFile, Mount-S...

Script     DotNet                    {Get-CommandWithParameterType, Get-ProgID, Get-Type}

Script     PSImageTools              {Add-CropFilter, Add-RotateFlipFilter, Add-OverlayFilter, ...

Script     PSRss                     {Read-Article, New-Feed, Remove-Article, Remove-Feed...}

Script     PSCodeGen                 {New-Enum, New-ScriptCmdlet, New-PInvoke}

Script     PSUserTools               {Start-ProcessAsAdministrator, Get-CurrentUser, Test-IsAdm...

Script     PSSystemTools             {Test-32Bit, Get-USB, Get-OSVersion, Get-MultiTouchMaximum...

Update @ 3:58 pm: At risk of losing the one-liner nomenclature at a very worthwhile increase in speed, read below.

The One-Liner WMI Version

One-liner to retrieve the first IP address of the first adapter which has a default gateway set. This is a very reliable, yet not perfect technique for determining the "right" IP address. It will work well in all but the most complex of network configuration scenarios.

@( Get-WmiObject Win32_NetworkAdapterConfiguration | Where-Object { $_.DefaultIpGateway } )[0].IPAddress[0]

Note that I have used the @() array notation around the Get-WmiObject call so that I don’t have to worry about how many network adapters come back. If only one comes back, I have an array with one item. If I didn’t do this, then I would have to do an if statement to check whether it’s an array (meaning that the system has multiple NICs with default gateways—which is super-rare but possible).

The .NET Class Method

It’s no longer a single line, but honestly, length is not a measure of quality in scripting. I noticed that the above WMI call was noticeably sluggish. Measurements with Measure-Command cmdlet showed an average execution time of 455 milliseconds. Here’s a different way using the Net.NetworkInformation.NetworkInterface .NET class.

$allNIC = [system.Net.NetworkInformation.NetworkInterface]::GetAllNetworkInterfaces()

$PrimaryNIC = $allNIC | Where-Object { $_.GetIPProperties().GatewayAddresses }

$PrimaryNIC.GetIPProperties().UnicastAddresses[0].Address.IPAddressToString

New time averages 13 milliseconds on my system. That’s a huge difference which I was not surprised to see based on past experience.

David at the Holy VM! blog just put up an article with a script showing you how to create port groups using PowerCLI. He was kind enough to reference my book as inspiration, so the least I can do in return is link to it.

Be sure to follow David’s blog, I see several interesting posts on there recently about his experiences with vSphere.

If you were waiting for me to post the demo scripts from TA2650: Taking PowerCLI to the Next Level, then you wait is over! My co-presenter Luc Dekens actually buckled under the pressure and started his own blog.  He’s got four posts on it already, and they are:

• TA2650 scripts – Part 1 – Profiling your vSphere environment
• TA2650 scripts – Part 2 – Using the profile XML file for SDK programming
• TA2650 scripts – Part 3 – Checking cluster node configurations
• TA2650 scripts – Part 4 – NIC Teaming – “hidden” failure criteria

Enjoy!