viveksharma.com: techlog

PowerShell Book Recommendations

2008-02-10T17:30:04-08:00:00

Someone asked me to recommend a few books, so here they are:

1) Windows PowerShell Cookbook by Lee Holmes (from PS Team)

2) Windows PowerShell in Action by Bruce Payette (from PS Team)

3) For Exchange specific stuff, I actually haven't tried any (makes sense as we were writing code most of the time :). Here are a few I dug up on the web, they look promising:

In fact, a few guys I know wrote a very nice book that should definitely be on the top of the list.

Here's to more books, fame and fortune from these fine authors!

ExchangeLabs will pwn you!

2007-10-12T01:10:58-07:00:00

So its been a long time since I last posted (last December actually!). A lot has happened since then: Exchange 2007 has shipped, Vista has shipped, Office 12 has shipped... and I've been working on, well, new stuff. Since Terry unveiled on the team blog that we have a program called Exchange Labs, I might as well reveal that http://exchangelabs.com also happens to be the new stuff that I'm working on.

I can't totally mention specifics, except that we are enabling a service at ** *** *, which by itself is really cool. And that's just the begining, we're also going to work on *******, *****, ***, **, ***, **, ***** ** ****, *** ****, and not to mention ******* **** *******! Apologies for ****'ing out some words, the censors around here are totally unreasonable :-) Given the new focus, I'll be posting more service and services related stuff on the blog.

But I still love and use powershell, so I'll continue to sprinkle odds and ends on the blog as well. Evan actually is a good guy to watch for more powershell goodies. Thanks for reading the blog and posting comments, I appreciate it very much! BTW: The title is a side-effect of me spending lots of time with Halo 3. Here is the wikipedia entry for 'pwn'.

Announcing the Exchange 2007 PowerShell Scriptacular demo pack!

2006-12-21T18:12:49-08:00:00

Dear Exchange 2007 Enthusiast(s),

I'd like to announce the Exchange 2007 PowerShell Scriptacular (download zipfile) demo pack. What is it you ask? Well... this collection of Exchange PowerShell scripts was developed by Mihai Jalobeanu and Vivek Sharma while they (we) developed the Exchange Management Shell. We had a lot of fun writing these scripts, and we used them to showcase the innovations in Exchange 2007 System Management--we also promised that when Exchange 2007 is released to the wild, that we'd make our favorite scripts available to everyone. So here they are!

If you want our exact demo setup: to get started, put everything in a directory (d:\scripts or something), and run generate. You need datafiles and you need to customize initvars.ps1. If you don't, the demo pack won't work.

Or you can just take a look at the scripts and learn from the bits and pieces that interest you.

Note: These are Microsoft copyrighted samples, are provided as-is and confer no warranties or rights.

Script Pack Contents:

addfakeservers.ps1 and removefakeservers.ps1

NOT standalone. Makes it looks like your demo setup has more than one server. We use a very useful feature of Exchange 2007 setup to make this work. Basically we use the /provisionedserver switch to create pre-provisioned servers (AD objects). The admin interface detects these as servers, even though the hardware has not been installed yet. This enables server delegation and pre-provisioning in Exchange topologies.
balancemailboxes.ps1

Standalone. This script shows how you can use PowerShell to easily load balance mailboxes by size across servers. Key thing is the use of get-mailboxstatistics and move-mailbox.
cleanup.ps1 and generate.ps1

NOT standalone. Cleanup.ps1 completely restores your demo environment to a basic-just-installed-Exchange state. New car smell not included. Generate kicks off everything else to generate the demo environment.
initvars.ps1

NOT standalone. Standard variables shared by all the scripts. Called by generate.ps1. MAKE SURE TO EDIT THIS FILE to customize this for your environment.
mailstorm.ps1 and mailstorm2.ps1

Standalone with caveats. What's a demo Exchange enviroment without some email? BTW: this is the one script that is likely to not just work automatically in your environment. This is because we assume some basic auth settings to make the Hub server accept mail. This step is done in generate.ps1 so make sure you do that if you plan to use this script by itself.
multi-matrix.ps1

Standalone. Totally totally useless. But cool damnit. This is the matrix unloaded ... er... powershelled.
out-email.ps1

Standalone, with caveats. Just like the name implies, sends content over mail. You can pipe text to it. get-content c:\sometext.txt | out-email -to jimmy@crackcornandidontcare.com -subject "Report". It uses the "from" from initvars.ps1 so make sure to copy those lines as needed to make it standalone.
out-html.ps1 and out-ie.ps1

Standalone. I already posted these to http://www.viveksharma.com/techlog earlier.

The datafiles are politician names, committees, standard drafts of the European Union. We've used US congress / house data in the past too---anything goes, it was publicly available data so it works great for demos.

The scripts (and their latest versions) can always be found at: http://www.viveksharma.com/techlog.

-Mihai Jalobeanu and Vivek Sharma

How to get DL membership in Exchange 2007

2006-10-22T23:10:33-07:00:00

Abshishek reminded me of this with his post on how to figure out Security Group membership using PowerShell. But Distribution Groups are a whole different beast. So how do you do it? One way is to use the GUI: the awesome Exchange Management Console already shows you group membership. And on the cmdline you can do this in Exchange 2007:

Using server side filtering (faster):

$filterid = (get-user Administrator).Identity get-group -filter { Members -eq $filterid }

Using client side filtering (slower):

get-group | where { $_.Members -like '*Admin*' }

This can be adapted to do nested membership as well---I'll leave it to you to figure out how.

How to record your shell session

2006-10-22T11:10:00-07:00:00

PS> Start-Transcript
PS> # do a bunch of stuff
PS> Stop-Transcript # or just quit the shell

This will create a file (by default in your My Documents folder) that is a verbatim copy of your shell session. No more copy and paste needed from the shell to notepad! A few other things of note:

This is the only way to capture verbose and warning information as those cannot be redirected from the shell like errors can (don't ask me why, but make sure to tell Jeffrey Snover about this)
You can start a transcript by default every time you start your shell by putting 'start-transcript' in your profile.ps1 file
There can change the location of the text file that is created. Look at get-help start-transcript for more details

Have fun!

Looking for feedback on PowerShell and Exchange

2006-10-20T10:10:21-07:00:00

Every once in a while its important to take a step back and see where we can improve---I already have a list of around ~150 things I'd like to improve in the Shell (Exchange and PowerShell), but I'd like to hear what you a) like about the shell and b) would like to see improved. You can leave comments, trackbacks on your own blogs, or mail me directly at (munging the address to defeat the spammers): vivek (at) thiswebpage'sdomainname.com Here are some examples I found recently:

Devin comments on how easy it is to move databases through cmdline and wonders why it isn't easy to move queues as well.
Newsgroup commentary from a user on how much it rocks to use the Exchange cmdlets to do management, and why AD management from PowerShell isn't just as easy (I don't work for AD team, but rest assured, I'm still working hard on making this happen).

So let us know what you like (or like a lot) so we can continue making it better and what you would like to see improved / fixed / added so we can plan for our future releases or work up some cool community snippets (after all, that is one huge advantage of the shell). Remember, if you don't speak up, I can't hear you, and thus I can't do anything about any issues :)

A strict shell is sometimes a good shell

2006-10-14T20:10:35-07:00:00

Sorry for yet another hiatus, times have been busy. To make up for it, here is one of my favorite improvements in PowerShell (BTW: this change was driven partly by REAL IT administrators at Microsoft---thanks folks, you rock!). So here goes. Do you know that in a normal session of PowerShell, unassigned variables are really "null" by default? This is an advantage for folks who love PERL and other Unix-y tools as they can use this assumption to their advantage. But, it also has potential pitfalls---let's say you make one minor mistake in a script and type $myvariabel instead of $myvariable. Well you can imagine the longer the script, the longer the debugging session. So, there is a mode available in PowerShell, thankfully, which lets you be more strict in how the shell treats unassigned variables. Note the behavior change: Default behavior:

PS> $foo
PS>
PS> $foo -eq $null
True

See the problem? No? Well, I'll let you write some complex scripts and get back to me on that one. Here's how you turn off this loose behavior:

PS> set-psdebug -strict
PS> $foo
The variable $foo cannot be retrieved because it has not been set yet. At line:1 char:4 + $foo <<<< PS> $foo "is the best variable!" The variable $foo cannot be retrieved because it has not been set yet. At line:1 char:4 + $foo <<<<

Use it to your advantage, but since it does change the way the shell interprets variables, learn to use it before turning it on everywhere. I recommend turning it on during scrip execution at first.

Sorting top users and then moving them (2003/2007)

2006-09-19T05:09:43-07:00:00

Brian asked in the comments: "... I am looking for a monad scipt/command that will allow me to sort user on e2k3 by size then move either the top or bottom X number of users..."

Try this on Exchange 2007, for 2003, you can use get-wmiobject cmdlet to read Exchange 2003 information using WMI. This is how you would get the top X users per server (you can optionally do this per database by passing in -database to get-mailboxstatistics):

get-mailboxstatistics -server Myserver | sort TotalItemSize -desc | select -first 10

Then you can move this list directly using move-mailbox:

get-mailboxstatistics -server Myserver | sort TotalItemSize -desc | select -first 10 | move-mailbox -target Server2\DataBase2

For 2003, its a bit more complicated as we don't have cmdlets for 2003, but fortunately you can use the excellent WMI compatability in PowerShell to read Exchange information. For example:

get-wmiobject -class Exchange_Mailbox -Namespace ROOT\MicrosoftExchangev2 -ComputerName MyServer | sort Size

This will return a list of mailboxes, which is then sorted, then you can apply the same tricks as before. The one big difference is that since we're dealing with WMI objects (as compared to get-mailboxstatistics objects as in Exchange 2007), you'll have to tweak the pipeline to make things work for moves:

get-wmiobject -class Exchange_Mailbox -Namespace ROOT\MicrosoftExchangev2 -ComputerName MyServer | sort Size -desc | select -first 10 | foreach { move-mailbox $_.LegacyDN -targetdatabase server2\database2 }

Now, a caveat.... I believe this should work but having upgraded all my servers to 2007, I can't quite test it :) Also, please refer to this post by Glen for more information. I believe I've given enough data to point you all in the right direction, so give it a shot and play around with it. Remember, you can always use -whatif and -validate in move-mailbox, which means you can run the commands without any fear :)

Guess who’s back… back again!

2006-09-16T17:09:49-07:00:00

As you can tell, I'm back from my month long vacation. It was great! I visited family in India and made my way to several awesome places and also visited Katy in Nepal, pictures to be posted later when I sort through all 1,000 of them!

Anyway, thought I'd kick off blogging again with some fun tricks. If you read the MS Exchange Team blog, you would have spotted the article on The Secret Decoder Ring. Long story short, the default admin group and routing group in Exchange 2007 are named quite oddly:

Exchange Administrative Group (FYDIBOHF23SPDLT)
Exchange Routing Group (DWBGZMFD01QNBJR)

I actually didn't know what they meant either... only a few people on the team knew. During a presentation by a fellow PM on the team on the subject, I decided to solve the puzzle using PowerShell. Here is how I got started.

#1. Assume the letters are the results of a cipher

In all ciphers, there is a generating function, so the goal is to guess the generating function. If you can guess the generating function, you can work backwards and construct the original message.

#2. Use PowerShell to examine each letter

We want to look at each letter in a sequence. There are several ways of doing this:

Boring standard way:

 $str = "FYDIBOHF23SPDLT" 
for($i =0; $i -lt $str.Length; $i++) { $str[$i] }

Cool powershell way. First examine what is available for you to use using get-member or gm:

"FYDIBOHF23SPDLT" | gm

You'll see that Strings have an interesting method:

GetEnumerator Method System.CharEnumerator GetEnumerator()

You see that it returns a CharEnumerator. What does this do? Best way to find out is to try it out:

 PS> "Test".GetEnumerator() 
T
e
s
t

As you can see, each character in the string is returned immediately as a seperate entity. Useful.

#3. Now that we know how to get to each letter in the coded message, its time to guess the generating function. We know that each letter represents an actual value, so it should be straightforward to automate "guessing" the function. From past experience I knew that text ciphers are generally based on a either a rotation scheme (each letter in a code represents another letter). So the best place to start is to write a script that takes the string and then strong arms the rotation (i.e. runs the text through different rotations):

"FYDIBOHF23SPDLT".getenumerator() | % { [char]([int]$_- 20 }

What is the above doing? Let me explain what's going on. The result of the call to GetEnumerator() returns characters, which are then passed to a foreach that basically rotates that letter by a given number (in this example it rotates each letter by 20). But that actually returns another list of characters, which is a little annoying. That's not the main problem, its still not automatable, but at least if we had pure human labor and this was a real code to crack, we could throw humans at the problem by letting them guess arbitrary numbers. The real world code crackers, however, rely on automation.

Another explanation of what [Char] [int] does. Each letter returned is a "char" which in technical lingo is a special type representing a readable or non-readable character (like "L"). Well we need to be able to operate on this as a number for our code cracking, so we need to cast it to a number or integer. This is done by applying [int] to the value we want to covert. In PowerShell all literals are either string or nums at the end of the day, so you have to be careful of this trick. For example:

[int]'f'

fails but:

[int][char]'f'

works. Can you figure out why? Anyway, back to the exercise, in our case remember that GetEnumerator() returns a CharEnumerator, which coincidentally is a char, so we just need to cast the current letter coming through the pipeline to a [int] and then operate on it, in our case rotating negatively (subtracting) the current char by the given rotation amount. For example: Rot = 1, letter = B, code = A. This is because if you walk back from B by one letter you get A.

#4. Automate the function to walk through a huge list of rotatations. Step #3 gave us a way to apply a rotation

 filter guesser
{
  $rot = $_ 
  "FYDIBOHF23SPDLT".getenumerator() | % { [char]([int]$_- $rot }  | &{
    process 
    {
      $local:s += $_ 
    }
    end
    {
      $s 
    } 
  } 
}

This looks complicated but really what its doing is defining a function that takes numbers and then applies those numbers as rotations to the code. So for example, this works:

 PS> 1..5 | guesser 
EXCHANGE12ROCKS
DWBG@MFD01QNBJR
CVAF?LEC/0PMAIQ
BU@E>KDB./OL@HP
AT?D=JCA-.NK?GO

And whoala, there's our secret right there. Looks like the code was using 1 as a rotation :)

To impress your friends (or scare away the ladies), knowing that the rotation is 1, in the future you could just do this:

"FYDIBOHF23SPDLT".getenumerator() | % { [char]([int]$_- 1 }

But wait, what about the other message DWBGZMFD01QNBJR? You'll find that 1..200 doesn't yield anything useful. But you should be able to figure that out without changing any of the functions above. Its a nice PowerShell trick that I will leave as an exercise.

Community Run Scripting Contest

2006-09-16T14:09:05-07:00:00

Thanks to Josh for organizing this. In addition to the offical Microsoft One-Liner contest for Exchange 2007, Josh has started his own scripting contest for PowerShell and Exchange. The best part about it is, that the winner gets a signed copy of the upcoming PowerShell book from Bruce Payette, one of the leading designers of PowerShell!

Wow, nice job Jeffrey and Josh. So go forth and submit some scripts to both the official contest and Josh's. To sweeten the deal, if you end up winning either contest, I'll put your name, company, winning entry etc. on the official team blog (2 million readers per month), my blog, the Exchange Wiki and the PowerShell team blog... the publicity and fame alone is worth at least a few thousand dollars of advertising money :)