This first post is about the form itself. The form is just a window on which we can put useful (or whatever) things to build a GUI. For the most part, the form is the easiest of the elements to work with, but you can get somewhat fancy with it. We’ll explore some different form scenarios.

The Simplest Form

There are only three things required to launch a form from PowerShell:

1.       You must load the System.Windows.Forms assembly (if not already done);

2.       You must create a new object of type system.windows.forms.form; and,

3.       You must call the ShowDialog() method on your new object. Note—don’t try calling the Show() method, unless you want your script to hang.

For example:

Add-Type -AssemblyName System.Windows.Forms

$Form = New-Object system.Windows.Forms.Form

$Form.ShowDialog()

Depending on your Windows shell environment, this is what your form might look like:

Of course, that’s not terribly useful, so we’ll keep going.

Adding Some Text

Text will be helpful in adding some purpose to our form. There are a couple of pieces of text we’ll add.

First, let’s add a window title for the form by setting the form’s Text property. This will show up in the top of the form and will also serve as the window title as shown in the task bar.

Then we’ll add some text in the main window by adding a label control. In order to add a label, we need to create a new Label object, set the relevant properties and add it to the Controls collection of the form. For now, we’ll set only two properties—Text and AutoSize. Enabling AutoSize will ensure that our label is large enough to display all our text.

Add-Type -AssemblyName System.Windows.Forms

$Form = New-Object system.Windows.Forms.Form

$Form.Text = "Sample Form"

$Label = New-Object System.Windows.Forms.Label

$Label.Text = "This form is very simple."

$Label.AutoSize = $True

$Form.Controls.Add($Label)

$Form.ShowDialog()

Note – Most forms will contain at least several controls. Usually there would be at least one button. We’ll add more controls later in this series, but for now we’ll just stick with a single label.

We might want to change the font used by the form. In order to change the font, we need to create a new font object with the appropriate properties and assign the new font object to the form’s Font property.

Add-Type -AssemblyName System.Windows.Forms

$Form = New-Object system.Windows.Forms.Form

$Form.Text = "Sample Form"

$Font = New-Object System.Drawing.Font("Times New Roman",18,[System.Drawing.FontStyle]::Italic)

# Font styles are: Regular, Bold, Italic, Underline, Strikeout

$Form.Font = $Font

$Label = New-Object System.Windows.Forms.Label

$Label.Text = "This form is very simple."

$Label.AutoSize = $True

$Form.Controls.Add($Label)

$Form.ShowDialog()

Now we have a bit of a problem because the text is too large to fit on the form in its default size. There are a few different ways we could address this:

·         Specify a form size – we could set a particular height and width that would be large enough. This would work, but it’s somewhat difficult to figure out what the appropriate size should be.

$Form.Width = 500

$Form.Height = 200

·         Enable scroll bars – By enabling AutoScroll, we allow the user to scroll over to see the remaining text. This is obviously not an optimum solution, but scroll bars are probably a good idea when necessary.

$Form.AutoScroll = $True

·         Enable AutoSize – This is a much better idea for our purposes.  By enabling AutoSize on the form, it will automatically resize to accommodate whatever controls we add to it.

$Form.AutoSize = $True

$Form.AutoSizeMode = "GrowAndShrink"

    # or GrowOnly

However, you should know that enabling AutoSize in this way will prevent the user from manually resizing the form.  The strategy you choose will depend on your specific requirements.

Here is the new form code:

Add-Type -AssemblyName System.Windows.Forms

$Form = New-Object system.Windows.Forms.Form

$Form.Text = "Sample Form"

Form.AutoScroll = $True

$Form.AutoSize = $True

$Form.AutoSizeMode = "GrowAndShrink"

    # or GrowOnly

Font = New-Object System.Drawing.Font("Times New Roman",24,[System.Drawing.FontStyle]::Italic)

    # Font styles are: Regular, Bold, Italic, Underline, Strikeout

$Form.Font = $Font

$Label = New-Object System.Windows.Forms.Label

$Label.Text = "This form is very simple."

$Label.AutoSize = $True

$Form.Controls.Add($Label)

$Form.ShowDialog()

It’s looking better.  Now let’s keep going.

Window Settings

There are a number of window settings we can customize for our form.  Here we’ll experiment with the following:

·         Disabling the minimize and maximize functionality

·         Setting the window state to normal (versus maximized or minimized)

·         Hiding the size grip (usually in the lower right corner of the window)

·         Setting the opacity to 70%, making the window partially transparent

·         Setting the window start position so that the window will open in the middle of the visible screen

Add-Type -AssemblyName System.Windows.Forms

$Form = New-Object system.Windows.Forms.Form

$Form.Text = "Sample Form"

Form.AutoScroll = $True

$Form.AutoSize = $True

$Form.AutoSizeMode = "GrowAndShrink"

    # or GrowOnly

$Form.MinimizeBox = $False

$Form.MaximizeBox = $False

$Form.WindowState = "Normal"

    # Maximized, Minimized, Normal

$Form.SizeGripStyle = "Hide"

    # Auto, Hide, Show

$Form.ShowInTaskbar = $False

$Form.Opacity = 0.7

    # 1.0 is fully opaque; 0.0 is invisible

$Form.StartPosition = "CenterScreen"

    # CenterScreen, Manual, WindowsDefaultLocation, WindowsDefaultBounds, CenterParent

Font = New-Object System.Drawing.Font("Times New Roman",24,[System.Drawing.FontStyle]::Italic)

    # Font styles are: Regular, Bold, Italic, Underline, Strikeout

$Form.Font = $Font

$Label = New-Object System.Windows.Forms.Label

$Label.Text = "This form is very simple."

$Label.AutoSize = $True

$Form.Controls.Add($Label)

$Form.ShowDialog()

Note – I’ve positioned this form over the well-known sample image penguins.jpg to demonstrate that the form is 30% transparent.

Visual Stimulation

Note – for this section, we’ll revert the window settings changes we made to the form in the previous section.

There are a few things we can do to make our form pop visually.  The easiest way to change the look and feed is to change the background color of the form.

Add-Type -AssemblyName System.Windows.Forms

$Form = New-Object system.Windows.Forms.Form

$Form.Text = "Sample Form"

$Form.AutoSize = $True

$Form.AutoSizeMode = "GrowAndShrink"

    # or GrowOnly

$Form.BackColor = "Lime"

    # color names are static properties of System.Drawing.Color

    # you can also use ARGB values, such as "#FFFFEBCD"

$Font = New-Object System.Drawing.Font("Times New Roman",24,[System.Drawing.FontStyle]::Italic)

    # Font styles are: Regular, Bold, Italic, Underline, Strikeout

$Form.Font = $Font

$Label = New-Object System.Windows.Forms.Label

$Label.Text = "This form is very simple."

$Label.AutoSize = $True

$Form.Controls.Add($Label)

$Form.ShowDialog()

Hmmm, interesting, but maybe not quite what we were looking for.

Let’s try adding a visually pleasing background image for our form.  In order to do that, we need to do the following:

·         Create a new system.drawing.image object from an image file (in this the sample picture “Oryx Antelope.jpg) and assign it to the BackgroundImage property of the form

·         Set the BackgroundImageLayout to None (The default is Tile, which tiles the image across the form as many times as it will fit.)

·         Remove the AutoSize feature from the form and instead set the size of the form to mage the image dimensions.

·         Configure the label so that it’s background is transparent, so as not to obstruct the picture

Add-Type -AssemblyName System.Windows.Forms

$Form = New-Object system.Windows.Forms.Form

$Form.Text = "Sample Form"

$Image = [system.drawing.image]::FromFile("$($Env:Public)\Pictures\Sample Pictures\Oryx Antelope.jpg")

$Form.BackgroundImage = $Image

$Form.BackgroundImageLayout = "None"

    # None, Tile, Center, Stretch, Zoom

$Form.Width = $Image.Width

$Form.Height = $Image.Height

$Font = New-Object System.Drawing.Font("Times New Roman",24,[System.Drawing.FontStyle]::Italic)

    # Font styles are: Regular, Bold, Italic, Underline, Strikeout

$Form.Font = $Font

$Label = New-Object System.Windows.Forms.Label

$Label.Text = "This form is very simple."

$Label.BackColor = "Transparent"

$Label.AutoSize = $True

$Form.Controls.Add($Label)

$Form.ShowDialog()

Very nice.

Finishing Touch

One last thing we can do to refine our form is to add a customized icon.  We can load an icon from an image file (in this case GRAPH.ICO which is part of Office).  A good resource for creating custom icon files is http://www.xiconeditor.com/. 

$Icon = New-Object system.drawing.icon ("C:\Program Files\Microsoft Office\Office14\GRAPH.ICO")

$Form.Icon = $Icon

Alternatively, we can extract an icon from an associated file, such as PowerShell.exe.

Add-Type -AssemblyName System.Windows.Forms

$Form = New-Object system.Windows.Forms.Form

$Form.Text = "Sample Form"

$Icon = [system.drawing.icon]::ExtractAssociatedIcon($PSHOME + "\powershell.exe")

$Form.Icon = $Icon

$Image = [system.drawing.image]::FromFile("$($Env:Public)\Pictures\Sample Pictures\Oryx Antelope.jpg")

$Form.BackgroundImage = $Image

$Form.BackgroundImageLayout = "None"

    # None, Tile, Center, Stretch, Zoom

$Form.Width = $Image.Width

$Form.Height = $Image.Height

$Font = New-Object System.Drawing.Font("Times New Roman",24,[System.Drawing.FontStyle]::Italic)

    # Font styles are: Regular, Bold, Italic, Underline, Strikeout

$Form.Font = $Font

$Label = New-Object System.Windows.Forms.Label

$Label.Text = "This form is very simple."

$Label.BackColor = "Transparent"

$Label.AutoSize = $True

$Form.Controls.Add($Label)

$Form.ShowDialog()

Beautiful. 

So we’ve seen most of the commonly used functionality of Windows Forms.  For more esoteric customization, start with http://msdn.microsoft.com/en-us/library/system.windows.forms.form.aspx.

Stay tuned for the next part in this series, which will dive into form controls.

First, I’d like to acknowledge an unknown scripter who created this script.  I tried to track down the original  author of the VBScript I started with.  This particular script is posted on a variety of forums with a number of edits along the way—presumably added by multiple people, and I was unable to locate the original source, but to this unknown person, thank you.

Now, I took this quite complex script which collects EDID information from the registry.  I converted it to PowerShell.  Like most VBScript to PowerShell conversions, the new script is greatly less complicated and more readable.

This script utilizes PowerShell Remoting (http://technet.microsoft.com/en-us/library/dd347744.aspx) if a computer list is supplied on the pipeline, so you would need to make sure that you have configured PowerShell for remoting.  If you don’t supply a computer list, the script block will be executed on the local computer.

There is an optional LogPath parameter.  You would run it as follows:

• .\Get-MonitorInfo.ps1
• "computer1","computer2","computer3" | .\Get-MonitorInfo.ps1 -LogPath
  .\monitorlist.csv

Param ([string] $LogPath)

$ComputerList = @()

# Computer names should be piped into the script (comma separated)

$input | ForEach-Object {$ComputerList += $_}

Function Main {

      If ($ComputerList){

            # If a list of computers was specified on the pipeline, execute

            # the scriptblock remotely against all in a single job

            $Job = Invoke-Command -ScriptBlock $ScriptBlock -AsJob `

                  -JobName EDIDInfo -ComputerName $ComputerList

            # Wait for the job to complete

            Wait-Job -Job $Job

            # Receive data from the job

            $Data = Receive-Job $Job

            # Once we have received the data, we can remove the job

            Remove-Job -Job $Job

      } Else {

            # If a computer list was not specified, we don't need a job. 

            # We can get the data directly by running the scriptblock

            Write-Warning ("A computer list was not specified.  The script " `

                  + "will run against the local computer.")

            $Data = (& $ScriptBlock)

      }

      If ($LogPath){

            # If a log path was specified (using the -LogPath parameter),

            # export the data to it.

            $Data | Export-Csv $LogPath -NoTypeInformation

      }

      # Display the collected data in the default host (usually the console)

      $Data | Format-Table PSComputerName,VendorID,ModelName,DeviceID `

            ,SerialNumber,ManufactureDate,EDIDVersion

}

$ScriptBlock = {

      # This script block will always run locally on the target

      # $EDIDByteArrays will hold all of the collected EDID values from the

      # registry.

      $EDIDByteArrays = @()

      # $KeysWithControl will contain the path to the key for each display

      # device whose "Control" subkey has an ActiveService value--meaning

      # that the device is currently being used.

      $KeysWithControl = (

            dir HKLM:\system\currentcontrolset\enum\display\*\*\control\ `

            | ForEach-Object{

                  $_.PsParentPath

            }

      )

      $KeysWithControl | ForEach-Object{

            # Enumerate the "Device Parameters" subkey for each key

            # identified above

            dir "$($_)\device parameters*" | ForEach-Object {

                  # The "EDID" value of the "Device Parameters" key contains

                  # the EDID data (byte array)

                  $EDIDByteArray = $_.GetValue("EDID")

                  # Add the current value to $EDIDByteArrays

                  # Since the value we're adding is a byte array and don't want

                  # to append it to the current array, we need to add a new

                  # element first and then assign the whole value to the new element

                  $EDIDByteArrays += ""

                  $EDIDByteArrays[($EDIDByteArrays.GetUpperBound(0))] = $EDIDByteArray                     

            }

      }

      # Now we will parse each EDID value.  For information about the data structure,

      # see http://en.wikipedia.org/wiki/Extended_display_identification_data

      # $Descriptors will contain the four prescribed descriptors

      $Descriptors = @("","","","")

      # A serial number descriptor starts with: 00 00 00 ff

      [Object[]] $SerialNumberHeader = ([byte]0x00,[byte]0x00,[byte]0x00,[byte]0xFF)

      # A model name descriptor starts with:          00 00 00 fc

      [Object[]] $ModelNameHeader = ([byte]0x00,[byte]0x00,[byte]0x00,[byte]0xFC)

      $EDIDByteArrays | Foreach-Object {

          $EDIDValue = $_

            # If this is a valid EDID value...

          If($EDIDValue){

                  # Populate the four descriptors with each subset of bytes

                  $Descriptors[0] = $EDIDValue[54..71]

                  $Descriptors[1] = $EDIDValue[72..89]

                  $Descriptors[2] = $EDIDValue[90..107]

                  $Descriptors[3] = $EDIDValue[108..125]

            # Initialize Values to "Not Found"

                  $SerialNumber           = "Not Found"

                  $ModelName              = "Not Found"

                  $ManufacturerID   = "Not Found"

                  $DeviceID               = "Not Found"

                  $ManufactureDate = "Not Found"

                  $EDIDVersion            = "Not Found"

                  $Descriptors | ForEach-Object {

                        # Get the header of the current descriptor to determin if it

                        # is a model name or serial number. These are two of several

                        # types of optional descriptors, and they may be in any order

                        # If the header is a match, the value will be at offset 5

                        $DescriptorHeader = $_[0..3]

                        If(($DescriptorHeader -join " ") -eq ($SerialNumberHeader -join " ")){

                              $SerialNumber =

                                    [System.Text.Encoding]::ASCII.GetString($_[5..17]).Trim()

                        }

                        If(($DescriptorHeader -join " ") -eq ($ModelNameHeader -join " ")){

                              $ModelName =

                                    [System.Text.Encoding]::ASCII.GetString($_[5..17]).Trim()

                        }

                  }

                  # The manufacture date is stored as follows: Week is byte 16. 

                  # Year (as offset from 1990) is byte 17.

                  $ManufactureWeek = $EDIDValue[16]

              $ManufactureYear = 1990 + $EDIDValue[17]

                  # Format "MM/yyyy"

              $ManufactureDate = (get-date "1/1/$($ManufactureYear)").AddDays(

                        7 * $ManufactureWeek).ToString("MM/yyyy")       

              # EDID version is stored in bytes 18 & 19

              $EDIDMajorVersion = $EDIDValue[18].ToString()

              $EDIDRevision = $EDIDValue[19].ToString()

              $EDIDVersion = "$($EDIDMajorVersion).$($EDIDRevision)"

                  # The manufacturerID is a three character id stored in a two

                  # bytes (8 & 9)

                  $ManufacturerIDEncoded = $EDIDValue[8..9]

                  # The easiest way to work with it is to convert it to a

                  # concatenated binary string

                  $ManufacturerIDBinaryString = ($ManufacturerIDEncoded | ForEach-Object{

                        [System.Convert]::ToString($_,2).PadLeft(8,"0")

                  }) -join ""

                  # Parse out the three five-byte character codes (1=A) and add

                  # 64 to get the real character code

                  $ManufacturerFirstLetterCode =

                        [system.convert]::ToInt32($ManufacturerIDBinaryString.substring(1,5),2) + 64

                  $ManufacturerSecondLetterCode =

                        [system.convert]::ToInt32($ManufacturerIDBinaryString.substring(6,5),2) + 64

                  $ManufacturerThirdLetterCode =

                        [system.convert]::ToInt32($ManufacturerIDBinaryString.substring(11,5),2) + 64

                  # Concatenate the three character codes into a byte array

                  [byte[]] $ManufacturerIDByteArray =

                        (    

                              $ManufacturerFirstLetterCode,

                              $ManufacturerSecondLetterCode,

                              $ManufacturerThirdLetterCode

                        )

                  # Convert the byte array to a string

                  $ManufacturerID =

                        [system.text.encoding]::Default.GetString($ManufacturerIDByteArray)

                  # The device id is stored in bytes 10 and 11 (16-bit little endian)

                  $DeviceID = ("{0:X}" -f $EDIDValue[11]).PadLeft(2,"0") `

                        + ("{0:X}" -f $EDIDValue[10]).PadLeft(2,"0")

                  # Put all of the values into a new custom object on the pipeline

                  $Properties = @{

                              VendorID=$ManufacturerID;

                              DeviceID=$DeviceID;

                              ManufactureDate=$ManufactureDate;

                              SerialNumber=$SerialNumber;

                              ModelName=$ModelName;

                              EDIDVersion=$EDIDVersion

                  }

                  New-Object psobject -Property $Properties

          }

      }

# end script block

}

Main

In my last post I promised to try to do something more fun.  For me that would mean some wicked algorithm, but I realize I’m in the minority on that one.  I decided instead to pull out a script I did a while back to resize an image.  I actually leveraged some .Net code I found on a blog which I can’t remember, so I acknowledge that some parts of this script I owe in large part to an unnamed donor.  Many thanks to whoever you are.  It wasn’t exactly what I was looking for, so the final product is mine—after a bit of effort.

Extraneous Background Information

When I wrote this script, I was working on a larger project where I had to create a boatload of very detailed performance metrics graphs for 100+ servers and make them available from a SharePoint site.  Each graph would be displayed on its own page in full resolution, but it also needed to be displayed in lower resolution on a summary page.  The images had to be clear enough that a user could spot trends on individual servers and make a decision about whether or not to look at the individual graph for further investigation.  It quickly became clear that I needed to generate thumbnail versions of all of my images.  So that’s the challenge that motivated me to write this script.

The Script

Param( [System.IO.FileInfo[]] $InputFile                 ,

                              $Suffix      = "_Resized"  ,

                              $NewWidth    = 225         ,

                              $NewHeight   = 150            )

If (-not $InputFile) { $ScriptInputFile = $Input }

Else {$ScriptInputFile = $InputFile}

[Reflection.Assembly]::LoadWithPartialName("System.Drawing") | Out-Null

$ScriptInputFile | %{

    $FileImage = ([System.Drawing.Image]::FromFile("$($_.FullName)"))

    $Bitmap = New-Object -TypeName System.Drawing.Bitmap `

        -ArgumentList $NewWidth,$NewHeight,$FileImage.PixelFormat

    $Graphic = [System.Drawing.Graphics]::FromImage($Bitmap)

    $Graphic.SmoothingMode = `

         [System.Drawing.Drawing2D.SmoothingMode]::HighQuality

    $Graphic.InterpolationMode = `

         [System.Drawing.Drawing2D.InterpolationMode]::HighQualityBicubic

    $Graphic.DrawImage($FileImage, 0, 0, $Bitmap.Width, $Bitmap.Height)

    $FileType = $_.FullName.Split(".")[-1]

    $Bitmap.Save($_.FullName.Replace(".$FileType","$Suffix.$FileType"), `

         [System.Drawing.Imaging.ImageFormat]::Jpeg)

    $Graphic.Dispose()

}

Parameters

-InputFile <Image File or files>

You can run the script specifying a single file or a collection of FileInfo objects.  If you specify a string, it will attempt to convert the string to a valid FileInfo object.

-Suffix <Suffix string>

This gets appended to your newly resized file name.  Default is “_Resized.”

-NewWidth <New width>

Specify the new width in pixels.  Default is 225.

-NewHeight <New height>

Specify the new width in pixels.  Default is 150.

Seeing it in Action

Given the following sample image (object in browser are larger than the appear—the original size of this image is 1024x683):

The first line here will resize the file and return the FileInfo object.  The second command will actually display the shrunken file in the default application.

[PS] > Set-Image.ps1 -InputFile "C:\Users\Public\Pictures\Sample Pictures\tulip.jpg" -Suffix ".Tiny" -NewWidth 25 -NewHeight 16

    Directory: C:\Users\Public\Pictures\Sample Pictures

Mode                LastWriteTime     Length Name

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

-a---          6/2/2009  12:35 AM        817 tulip.Tiny.jpg

[PS] > & (Set-Image.ps1 -InputFile "C:\Users\Public\Pictures\Sample Pictures\tulip.jpg" -Suffix ".Tiny" -NewWidth 25 -NewHeight 16)

Challenge!

Note that it will match your NewWidth and NewHeight parameters and skew the image if necessary.  I can imagine it wouldn’t be that difficult to modify the script to prevent skewing or to specify a percentage to use, so the new image would be 75% or 200% of the original.  The System.Drawing.Image object has Height and Width properties that would give you the dimensions of the original image.  Hint, hint!

It actually took me quite a while to figure this out—although after the fact I kicked myself… hard.  This used to be simple with VBScript.  You could just get any old WMI instance object and call the Refresh_ method, which came from the SWbemObjectEx interface.  Unfortunately this much needed method isn’t present in System.Management.ManagementObject.   Before I get to that, I’ll show you the complicated script I wrote to get this done the long way—this one is an earlier version which just stops services in a particular order, but you’ll see what I mean.

The Ugly Way

#### Stop Services sequentially

#### List your servers individually

$Servers = ("Localhost","127.0.0.1")

#### ...or read them in from a file

# $Servers = (type c:\serverlist.txt)

#### You must specify a timeout (in seconds) or the script could potentially never end

$TimeOut = 10

#### Use this line to get all services matching a pattern.

# $ServiceFilters = "name like 'msex%'"

#### This will stop a single service on all servers in sequence

# $ServiceFilters = "name = 'spooler'"

#### This is just a more complex filter but the sequence is not guarateed

# $ServiceFilters = "(name = 'spooler' OR name = 'msdtc')"

#### Specifying individual filters in sequence will guarantee the order or services to stop

$ServiceFilters = "(name = 'spooler')","(name = 'msdtc')"

$Servers | %{

      $Server = $_

      $Locator = new-object -com "WbemScripting.SWbemLocator"

      $WMI = $Locator.ConnectServer($Server, "root\cimv2")

      $ServiceFilters | %{

            $ThisFilter = $_

            (Get-WmiObject -Class Win32_Service -ComputerName $Server -filter "$ThisFilter AND state='running'") | %{

                  $Service = $_

                  $Refresher = new-object -comobject "WbemScripting.SWbemRefresher"

                  $FreshObject = $Refresher.Add($WMI,$Service.__RELPATH)

                  $Refresher.Refresh()

                  $Then = Get-Date

                  :Checking Do {

                        $Service.StopService() | out-null

                        $Refresher.Refresh()

                        if (($FreshObject.Object.properties_ | ?{$_.name -eq "state"}).value -eq "Stopped") {

                              "Stopped $Service on $Server";

                              break :Checking;

                        } Else {

                              If (((Get-Date) - $Then).seconds -ge $TimeOut){

                                    "!!! TIMEOUT - $Service on $Server";

                                    break :Checking;

                              }

                        }

                  } While ($True)

            }

      }

}

"Services are all stopped"

I was never really a fan of the SWbemRefresher object.  It always seemed a bit counter-intuitive and require me to jump through too many hoops, like using the SWbemLocator object.  Ugh.

As it turns out there is a method I can use from System.Management.ManagementObject which refreshes the instance data.  I was looking for something named Refresh or similar, but the actual method is called Get().  Sure it makes sense now—I can hear the condescension across space/time.  And this allows me to make the script a lot friendlier.

The Much Nicer Version

Aside from removed the dreadful SWbemLocator, I also cleaned the script up a bit and made it more flexible.

Arguments

-Operation <start|stop>

This makes the script work for either starting or stopping services.  If you don’t provide an operation, the script will just return the current state of all services that match the filter.

-ServiceFilters <Filter String(s)>

This is where you specify which services and in what order to process.  We’re taking one or more filter strings here to make the script more flexible.  Some potential ServiceFilters values are:

• "Name = 'spooler'"
• "Name like 'msex%'"
• "StartMode = 'Auto'"
• "Name = 'spooler'","Name = 'msdtc'"

Note that in order to guarantee the order of processing, you should specify each filter string separately, as it the last example.

-Servers <ServerList>

Specify one or more servers by any name that will resolve—Netbios, DNS, IP.  If you don’t specify a server, then the script will assume the local machine.

-TimeOutSeconds <NumberOfSeconds>

Specify how many seconds to wait before timing out processing the service.  Default is 10 seconds.  Once the timeout expires, it will just move on to the next service.

#### Stop Services sequentially

Param ( $Operation                    ,

        $ServiceFilters = "(name='')" ,

        $Servers        = "Localhost" ,

        $TimeOutSeconds = 10             )

Switch ($Operation) {

    {$_ -like "start*"} {

        $Method       = "StartService";

        $DesiredState = "Running";

    }

    {$_ -like "stop*"}  {

        $Method       = "StopService";

        $DesiredState = "Stopped";

    }

    Default             {

        $Method       = $Null;

        $DesiredState = "*";

    }

}

$Servers | %{

      $Server = $_

      $ServiceFilters | %{

            $ThisFilter = $_

            (Get-WmiObject -Class Win32_Service `

                           -ComputerName $Server `

                           -filter "$ThisFilter AND state!='$DesiredState'") | %{

                  $Service = $_

                  $Then = Get-Date

                  :Checking Do {

                        If ($Method) {

                              $ErrorCode = $Service.PSBase.InvokeMethod($Method,$Null)

                        }

                        $Service.Get()

                        if ($Service.State -like "$DesiredState") {

                              "$($Service.State) on $Server - $($Service.caption) ($($Service.name))" | out-host;

                              break :Checking;

                        } Else {

                              If (((Get-Date) - $Then).seconds -ge $TimeOutSeconds){

                                    "!!! TIMEOUT - $Service on $Server" | out-host;

                                    break :Checking;

                              }

                        }

                  } While ($True)

            }

      }

}

Here’s the code in action.  Notice what happens if I set the timeout too short.

[PS] .\Set-BulkService.ps1 -operation start -servicefilters "(name = 'spooler')","(name = 'msdtc')" -servers 127.0.0.1 -timeout 2

Running on 127.0.0.1 - Print Spooler (Spooler)

Running on 127.0.0.1 - Distributed Transaction Coordinator (MSDTC)

[PS] .\Set-BulkService.ps1 -operation start -servicefilters "(name = 'spooler')","(name = 'msdtc')" -servers 127.0.0.1 -timeout 0

!!! TIMEOUT - \\STEPHAP1\root\cimv2:Win32_Service.Name="Spooler" on 127.0.0.1

!!! TIMEOUT - \\STEPHAP1\root\cimv2:Win32_Service.Name="MSDTC" on 127.0.0.1

[PS]

So that’s that.  My greatest hope for this post is that someone is searching for the Refresh_ method and PowerShell, and they happen upon this code and save themselves some time.

Unfortunately…

I wrote the previous scripts on Windows 7 using PowerShell v2 where it worked like a champ, but when I tried the latter script on my Windows 2003 Exchange 2007 server, it wasn’t so happy.  I’m not sure whether it’s Windows or PowerShell, but the Get() method was not available there.  I had to go back and use reflection to get at it as well as make a couple of other changes that for whatever reason were necessary to make it work.  Here is the safer version of the script that worked in both locations:

#### Stop Services sequentially

Param ( $Operation                    ,

        $ServiceFilters = "(name='')" ,

        $Servers        = "Localhost" ,

        $TimeOutSeconds = 10             )

Switch ($Operation) {

    {$_ -like "start*"} {

        $Method       = "StartService";

        $DesiredState = "Running";

    }

    {$_ -like "stop*"}  {

        $Method       = "StopService";

        $DesiredState = "Stopped";

    }

    Default             {

        $Method       = $Null;

        $DesiredState = "*";

    }

}

$Servers | %{

      $Server = $_

      $ServiceFilters | %{

            $ThisFilter = $_

             $Services = `
            (Get-WmiObject -Class Win32_Service `
                           -ComputerName $Server `
                           -filter "$ThisFilter AND state!='$DesiredState'")
            $Services | %{

                  $Service = $_

                  $Then = Get-Date

                  :Checking Do {

                        If (-not $Service) { Break :Checking; }

                        If ($Method) {

                              $ErrorCode = $Service.PSBase.InvokeMethod($Method,$Null)

                        }

                        $ObjectType = $Service.GetType()
                        $GetProperty = [reflection.bindingflags]::InvokeMethod
                        $ObjectType.InvokeMember("Get", $GetProperty,$Null,$Service,$Null)
                        if ($Service.State -like "$DesiredState") {

                              "$($Service.State) on $Server - $($Service.caption) ($($Service.name))" | out-host;

                              break :Checking;

                        } Else {

                              If (((Get-Date) - $Then).seconds -ge $TimeOutSeconds){

                                    "!!! TIMEOUT - $Service on $Server" | out-host;

                                    break :Checking;

                              }

                        }

                  } While ($True)

            }

      }

}

That was quite a journey you took with me.  Thanks for sticking around all the way to the end.  You must be really into scripting.  I hope you weren’t too disappointed.  Next time I’ll do something fun—I promise.

The reason I was so stoked about writing this is that it involves one of my favorite things.  Forget raindrops on roses—I love writing a recursive script.  For those not educated in the ways of the geek, a recursive script calls itself.  It’s like a video of a person in standing in front of a TV playing the live video of that person—or parallel mirrors where you see 50 reflections of yourself.  (Oh, I’m getting excited just explaining the concept!)  Generally you use recursion when working with a hierarchy of some sort.  So you inspect a root object and get a list of it’s children, then you would call the same procedure (script, function, whatever) again, this time a child node becomes the root.

A Word of Warning

As you might guess, recursion can be somewhat dangerous.  They can lead to stack overflows or memory exhaustion.  For this reason, PowerShell limits the call depth to 1000.  So once your script is 1001 levels deep into itself you’ll get an error:

The script failed due to call depth overflow.  The call depth reached 1001 and the maximum is 1000.
At line:0 char:0

Still you should be careful because if your script consumes enough memory, you just might run out of resources well before you get 1001 levels deep. 

Arguments

-RootNode <LDAP Path of Root Node>

Specifies the container object where you want to begin your search.  If you don’t specify a RootNode, the script returns False, and that’s that.

-OutputFile <Path to file>

If you specify an output file, the DNs of the effectively empty OUs will be written to this file.  Should probably be a txt file, but it doesn't really matter.

-Verbose

This switch if specified will have the script echo to the console every OU that it’s currently checking so you can monitor the progress.

-Quiet

Using this switch means that when the script finds an empty OU, it will still write the DN to the file (if specified) but will not echo it to the console.

* You may use –Verbose and –Quiet together if you feel you must.

** If you’re only interested in a single OU, but you want to know whether it contains any nested users, you can specify only the -RootNode and use the –Quiet switch with no –OutputFile.  This will return only a True or False value indicating whether that single OU is effectively empty.

The Script

Param ( [ADSI]               $RootNode   ,
        [system.io.fileinfo] $OutputFile ,
        [switch]             $Verbose    ,
        [switch]             $Quiet         )

$UsersExist = $False;

If ($Verbose) { write-host "CHECKING:  $($RootNode.distinguishedName)" }

$UserObjects = (
    $RootNode.PSBase.Children | ?{
        $_.objectCategory -like "CN=Person,*" `
        -and $_.distinguishedName -notlike "CN=Admin@*" `
        -and $_.distinguishedName -notlike "CN=CSRAdmin@*";
    }
)

If ($UserObjects) {
    $UsersExist = $True;
}

$ChildNodes = ($RootNode.PSBase.Children | ?{

    $_.objectCategory -like "CN=Organizational-Unit,*"

});
$ChildNodes | %{
    $ChildNode = $_;
   If ($ChildNode){
        & $MyInvocation.InvocationName -RootNode $ChildNode `

                                       -out $OutputFile     `

                                       -verbose:$Verbose    `

                                       -Quiet:$Quiet         | %{
           If ($_) {
                $UsersExist = $True;
            } Else {
                If (-not $Quiet) {

                    write-host "*** $($ChildNode.distinguishedName) HAS NO USERS";

                }
                If ($OutputFile) {
                    $ChildNode.distinguishedName | `

                        out-file $Outputfile -append -encoding ascii;
                }
            }
        }
    }
}

$UsersExist;

Other Uses

For my non-hosting folks out there, this script has a host of other uses.  For instance you want to Find all the OUs that have computer objects in them.  You can change this script up a bit to accomodate that.  You’ll want to change the filter a bit and reverse the logic, but you can do it.  Have fun!

A typical XML file created by ExchDump (http://www.microsoft.com/downloads/details.aspx?familyid=d88b807d-964e-4bf8-9344-754892e9f637&displaylang=en) for one of these hosters might be 500MB+, while the HTML file will be almost as large and completely indigestible--if somehow you have enough system resources to open it in Internet Explorer.

I set about to break the XML into sections that I could actually use to gain some useful information.  Naturally I turned to PowerShell.  The first thing I tried was to load the file by foolishly casting the contents of the file to System.XML.XMLDocument.  After waiting several minutes I realized what a dumb move that was.  Thank you CTRL+C.   From that point the task became all about text parsing.

Param ( $FilePath = "C:\Data" )

$SubPath = "$FilePath\ExchDumpObjects"

If(-not (Test-Path "$SubPath")){

   mkdir $SubPath

}

$ObjectString = @()

type "$FilePath\ExchDump_*.xml" |
   %{ 
      if($_.trim() -eq "<ADSI-Object>") {
#### "Start new Object!!!"
         $ObjectString = @()
         $ObjectClass = ""
         $ObjectName = ""
         $ObjectString += $_
      }
      elseif($_.trim() -eq "</ADSI-Object>"){
#### "End object"
         $ObjectString += $_
         $TickCount = (get-date).ticks
         If(-not (Test-Path ("$SubPath\" + $ObjectClass))){

            mkdir ("$SubPath\" + $ObjectClass)

         }
         $ObjectString | out-file `

           "$SubPath\$ObjectClass\$($ObjectClass)_$ObjectName.$TickCount.xml"
      } else {
#### "Continue object"
         $ObjectString += $_
         If($_ -match "ADSI_Obj_Class"){
            $ObjectClass = $_.Trim().Replace("<ADSI_Obj_Class>","")

            $ObjectClass = $ObjectClass.Replace("</ADSI_Obj_Class>","")

            $ObjectClass = $ObjectClass.Trim()
         }
         ElseIf($_ -match "ADSI_Obj_Name"){
            $ObjectName = $_.Trim().Replace("<ADSI_Obj_Name>","")

            $ObjectName = $ObjectName.Replace("</ADSI_Obj_Name>","")

            $ObjectName = $ObjectName.Replace("CN=","").Trim()
         }
      }
   }

So to run the script, you can do one of two things—either place your xml file in the folder C:\Data which is the default directory where the script will look for it, or pass in the file folder as an argument.

When you’re done, you’ll have a subfolder in the same folder with the ExchDump output named ExchDumpObjects.  Inside that folder will be subfolders for each type of AD object that ExchDump gathered.  Inside those folders, there will be a single XML file for each object collected by ExchDump.  For instance if I wanted to find a particular OAB Object named “Demo OAL”, I would look for a file like “C:\Data\ExchDumpObjects\msExchOAB\msExchOAB_Demo OAL.*.xml”.  You might find that ExchDump outputs the object multiple times.  I’m not sure why that is, but the objects tend to be for the most part identical when that happens.

Once you’ve found the object you’re looking for, you may want to use PowerShell to parse it as well.  This is sort of tricky because the XML which ExchDump uses isn’t the absolute best of formats.  Here’s a snippet you can use for getting attributes out of those files:

[PS] $FP = "C:\Data\ExchDumpObjects\msExchOAB\msExchOAB_Demo OAL.*.xml"

[PS] $OAB = [xml] (type $FP)

[PS] $Atr = $oab."ADSI-Object".attribute | ?{$_.innertext -like "*offlineABContainers*"}

[PS] $Atr.attrib_val

 "CN=Demo AL,CN=All Address Lists,CN=Address Lists Container,CN=hmc,CN=Microsoft Exchange,CN=Services,CN=Configuration,DC=fabrikam,DC=net"

[PS] $Atr = $oab."ADSI-Object".attribute | ?{$_.innertext -like "*offlineABServer*"}

[PS] $Atr.attrib_val

 "CN=OAB01,CN=Servers,CN=Exchange Administrative Group (FYDIBOHF23SPDLT),CN=Administrative Groups,CN=hmc,CN=Microsoft Exchange,CN=Services,CN=Configuration,DC=fabrikam,DC=net "

(As a side note, yes, a lot of my scripts will be just as esoteric as this one.  It’s super fantastic if you find yourself in the same exact predicament as me, but that’s not very likely unless you are supporting a very large e-mail hoster.  The same sort of technique may apply to other scenarios where you have very large XML files, but for the most part this is a niche script.)

My objective for the tentatively named "Something About Scripting" is to share some of my experiences and scripts with whomever might be interested in them.  I've spent almost my whole career in Product Support, so my scripts are generally of a certain flavor--building labs for reproducing proplems, diagnosing problems, collecting wide swaths of information to understand problems, etc.  You get the picture.  Every now and again I might have something a little more fun and a little less practical in the IT space.

Hope this helps someone.