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!

I had a great time chatting with my vNeighbor Rich Brambley, Marc Farley, and Scott Herold on the Virtumania podcast the other day. Please go check out VIRTUMANIA 20 and be sure to download their other episodes.

From the blog post:

“This week’s discussion focuses on using Powershell in virtual environments instead of a GUI, compares learning scripting to learning the verbs and nouns of a new language such as Latin, and highlights several Powershell sites and tools that every administrator should check out.”

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   :

With the release of vSphere 4.1, we also get PowerCLI 4.1! Here’s a taste of the new stuff from the changelog.

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.

I just came across this intro to Chapter 7 of my book recently while looking up some information on PowerCLI. I had not re-read it in a while and I really forgot how *ahem* funny it was. Well, anyway, for your entertainment, a quote from my book:

Chapter 7

Troubleshooting and Problem Resolution

This chapter focuses on the fine art of troubleshooting. I won’t actually be teaching you this vaunted skill, oh no. That would require that you study in an IT Shop as Apprentice for four years (much of that on the helpdesk). Only then can you go out into the world to make your own way as a hard-working JourneyAdmin. Many stop there, never caring to put in the countless hours of after-hours work in lonely datacenters before daring to submit detailed Visio diagrams of the infrastructure they built over the years to the IT Masters for evaluation and much ridicule. It is a long road, I won’t lie to you. Yet, the rewards of attaining a MasterAdmin certification (you get a little trophy for your desk), are great and wondrous. Once you have your little trophy, you get to choose a symbol of your dedication to the IT practice—a totem if you will. Everyone seems to pick a Smartphone, lately, although some still choose the more traditional Commodore 64 Model 1541 5¼ inch floppy disk drive.

This chapter is actually much less glamorous than all that, I’m afraid. I will, however, provide you with a set of tools to assist you in the complicated and often perilous journey down that winding path. You know, stuff like how to read a log file, and how to monitor CPU usage.

I really should make a book to go along with that.

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.

Here is a roundup of several shows that I’ve been listening to, in alphabetical order:

Just thought I’d share this slide (draft) to see if the ‘net peoples have any interesting thoughts to share on the topic. Here’s my opening salvo:

Out of all of the above statements, I think the last is the most overlooked. Discuss.

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

From my Facebook wall:

June posted something on your Wall and wrote:
"function birthday
{
$bd = [datetime]"04/19"
if ((get-date) -eq $bd) {"Happy Birthday!"}
}
PS C:\> Happy Birthday from the PowerShell Team"

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)

This email arrived in my inbox today:

Just finished your book for the second time.  Man, have I learned a lot!  I am way ahead of the PowerShell curve for admins in general.  No one at my work can touch me!  SQl, AD, VMware, IIS, Group Policy, log extraction, etc…  I do it all with PowerShell.

A lot of people say, you can do all this stuff in the VMware client.  My reply is simply- no you can’t…  I have at least 30 automated PowerShell scripts that run throughout the week.  I don’t know how I lived without PowerShell. 

Again, your book rocked.  I actually paid for it!  I won’t let anyone borrow it either.  I need it way too much.  I tell them to BUY THEIR OWN!!!

G.B.

I really enjoyed reading it and wanted to share this with everyone. Very cool of him to take the time to send me the note.

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: