Unlock-PowerShell

PowerShell V3 Console improvement

Karl Mitschke — Sat, 07 Jan 2012 03:18:00 +0000

This may not seem earth shattering, but it’s major news in my world (I’m a 1 finger typist)

In the V3 CTP, you now have the ability to use autocomplete in the console, in the middle of a line without losing the rest of the line.

This allows you to do this:

Get-Mailbox |Select-Object Name, Alias, Office, Database
WARNING: By default, only the first 1000 items are returned. Use the ResultSize parameter to specify the number of
items returned. To return all items, specify “-ResultSize Unlimited”.

Now, a normal typist would probably type in the whole ResultSize parameter, but I’m lazy, so I just go back to the Get-Mailbox and insert a -R to select from the available “R” parameters.
Of course, I still need to type “Unlimited” after the ResultSize, so perhaps this isn’t the best example

Play with the within the console, and see what you think.

Print from PowerShell’s Integrated Scripting Environment

Karl Mitschke — Sat, 31 Dec 2011 01:39:00 +0000

Since I started working with the PowerShell V# CTP, I have been using the ISE instead of PowerGUI’s script editor, as PowerGUI does not yet support .Net version 4, which is required by PowerShell V3.

One feature that is missing in the ISE is the ability to print a script.

Jeffry Hicks has a solution at http://jdhitsolutions.com/blog/2011/09/friday-fun-add-a-print-menu-to-the-powershell-ise/, but it uses notepad which in my opinion is severely limited (it’s monochrome, for one thing)

Since I was already copying scripts to colorized html (see previous posts, as well as scripts on powergui.org), I decided to go in another direction.

This script will create an html version of the current script (or current selection) in the ISE or the specified file using an Internet Explorer com object.

The html object includes line numbers.

Once the html is built, and the IE window is opened, you can print using IE’s print functions.

This script is extracted from a module I use to provide basic functions in the ISE that I miss from PowerGUI, or which I had added as script editor add-ons to PowerGui.

This is based on Lee Holmes Set-ClipboardScript located here: http://www.leeholmes.com/blog/2009/02/03/more-powershell-syntax-highlighting/

001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
022
023
024
025
026
027
028
029
030
031
032
033
034
035
036
037
038
039
040
041
042
043
044
045
046
047
048
049
050
051
052
053
054
055
056
057
058
059
060
061
062
063
064
065
066
067
068
069
070
071
072
073
074
075
076
077
078
079
080
081
082
083
084
085
086
087
088
089
090
091
092
093
094
095
096
097
098
099
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235

<#
.SYNOPSIS
    Copy-ToPrinter – Prints the current script from the ISE or a file passed the the Path parameter from the console.
.DESCRIPTION
This script prints a PowerShell script.
.NOTES
    File Name: Copy-ToPrinter.ps1
    Author: Karl Mitschke
    Requires: Powershell V2
    Created: 09/20/2011
.LINK
    “http://unlockpowershell.wordpress.com/2010/PrintFromISE/”
    “http://gallery.technet.microsoft.com/Script-to-copy-the-c55f0106″
    “http://www.leeholmes.com/blog/2009/02/03/more-powershell-syntax-highlighting/”

.INPUTS
Requires a file be open in the ISE, or a file path and name passed to the Path parameter.
.OUTPUTS
    This script outputs a formatted HTML version of the script with line numbers.
.EXAMPLE
    .\Copy-ToPrinter.ps1
    __________
    Prints the contents of the current PowerShell ISE tab.
.EXAMPLE
    .\Copy-ToPrinter.ps1 -Path C:\scripts\Find-EmptyGroups.ps1
    __________
    Prints the contents of the file C:\scripts\Find-EmptyGroups.ps1.
.EXAMPLE
    Get-ChildItem -Path C:\scripts\Find-DisabledMailbox.ps1 | .\Copy-ToPrinter.ps1
    __________
    Prints the contents of the file C:\scripts\Find-DisabledMailbox.ps1.
#>

param(
[Parameter(
Position = 0,
ValueFromPipeline=$true,
Mandatory = $false,
HelpMessage = "The path of the file"
)]
[string] $Path
)
Set-StrictMode -Version 2
$tokenColours = @{
    ‘Attribute’ = ‘DarkCyan’
    ‘Command’ = ‘Blue’
    ‘CommandArgument’ = ‘Magenta’
    ‘CommandParameter’ = ‘DarkBlue’
    ‘Comment’ = ‘DarkGreen’
    ‘GroupEnd’ = ‘Black’
    ‘GroupStart’ = ‘Black’
    ‘Keyword’ = ‘DarkBlue’
    ‘LineContinuation’ = ‘Black’
    ‘LoopLabel’ = ‘DarkBlue’
    ‘Member’ = ‘Black’
    ‘NewLine’ = ‘Black’
    ‘Number’ = ‘Magenta’
    ‘Operator’ = ‘DarkGray’
    ‘Position’ = ‘Black’
    ‘StatementSeparator’ = ‘Black’
    ‘String’ = ‘DarkRed’
    ‘Type’ = ‘DarkCyan’
    ‘Unknown’ = ‘Black’
    ‘Variable’ = ‘Red’
}
function Append-HtmlSpan ($block, $tokenColor){
    if (($tokenColor -eq ‘NewLine’) -or ($tokenColor -eq ‘LineContinuation’)){
        if($tokenColor -eq ‘LineContinuation’){
            $null = $codeBuilder.Append(‘`’)
        }
        $null = $codeBuilder.Append(“
`r`n”)
        $null = $lineBuilder.Append(“{0:000}
” -f $currentLine)
$SCRIPT:currentLine++
}
    else{
        $block = [System.Web.HttpUtility]::HtmlEncode($block)
        if (-not $block.Trim()){
            $block = $block.Replace(‘ ‘, ‘ ’)
        }
        $htmlColor = $tokenColours[$tokenColor].ToString().Replace(‘#FF’, ‘#’)
        if($tokenColor -eq ‘String’ -or $tokenColor -eq ‘Comment’ ){
            $lines = $block -split “`r`n”
            $block = “”
            $multipleLines = $false
            foreach($line in $lines){
                if($multipleLines){
                    $block += “
`r`n”
                    $null = $lineBuilder.Append(“{0:000}
” -f $currentLine)
$SCRIPT:currentLine++
                }
                $newText = $line.TrimStart()
                $newText = “ ” * ($line.Length - $newText.Length) + $newText
                $block += $newText
                $multipleLines = $true
            }
        }
        $null = $codeBuilder.Append(“$block”)
    }
}
function GetHtmlClipboardFormat($html, $Caller){
$header = @”
Version:1.0
StartHTML:0000000000
EndHTML:0000000000
StartFragment:0000000000
EndFragment:0000000000
StartSelection:0000000000
EndSelection:0000000000
SourceURL:file:///about:blank

HTML Clipboard

    width:950; border:0px solid black; padding:5px’> 

    padding:5px; background:#cecece’> 
__LINES__ 

    padding:5px; background:#fcfcfc’> 
__HTML__

“@
    $header = $header.Replace(“__LINES__”, $lineBuilder.ToString())
    $startFragment = $header.IndexOf(“”) +
        “”.Length + 2
    $endFragment = $header.IndexOf(“”) +
        $html.Length - “__HTML__”.Length
    $startHtml = $header.IndexOf(“)
    $endHtml = $header.Length + $html.Length - “__HTML__”.Length
    if ($Caller -eq “Print”){
        $header = $header.Replace(“Version:1.0″,“”)
        $header = $header.Replace(“StartHTML:0000000000″,“”)
        $header = $header.Replace(“EndHTML:0000000000″,“”)
        $header = $header.Replace(“StartFragment:0000000000″,“”)
        $header = $header.Replace(“EndFragment:0000000000″,“”)
        $header = $header.Replace(“StartSelection:0000000000″,“”)
        $header = $header.Replace(“EndSelection:0000000000″,“”)
        $header = $header.Replace(“SourceURL:file:///about:blank”,“”)
        #$header = $header.Replace(“HTML Clipboard”, (Split-Path -Path $Path -Leaf))
    }
    else{
        $header = $header -replace “StartHTML:0000000000″, (“StartHTML:{0:0000000000}” -f $startHtml)
        $header = $header -replace “EndHTML:0000000000″, (“EndHTML:{0:0000000000}” -f $endHtml)
        $header = $header -replace “StartFragment:0000000000″, (“StartFragment:{0:0000000000}” -f $startFragment)
        $header = $header -replace “EndFragment:0000000000″, (“EndFragment:{0:0000000000}” -f $endFragment)
        $header = $header -replace “StartSelection:0000000000″, (“StartSelection:{0:0000000000}” -f $startFragment)
        $header = $header -replace “EndSelection:0000000000″, (“EndSelection:{0:0000000000}” -f $endFragment)
    }
    if($Host.Name -eq ‘Windows PowerShell ISE Host’){
        #$header = $header.Replace(“HTML Clipboard”,$psise.CurrentFile.DisplayName)
    }
    $header = $header.Replace(“__HTML__”, $html)
    Write-Verbose $header
    $header
}
function Copy-ToPrinter{

    Add-Type -Assembly PresentationCore
    Add-Type -Assembly System.Web
    $SCRIPT:currentLine = 1
    if($Host.Name -eq ‘Windows PowerShell ISE Host’){
        if ($psise.CurrentFile.Editor.SelectedText.Length -eq 0){
    $text = $psise.CurrentFile.Editor.Text
    }
        else{
     $text = $psise.CurrentFile.Editor.SelectedText
    }
    }
    elseif($Path){
        $text = (Get-Content $Path) -join “`r`n”
    }
    trap { break }
    # Do syntax parsing.
    $errors = $null
    $tokens = [system.management.automation.psparser]::Tokenize($Text, [ref] $errors)
# Initialize HTML builder.
    $codeBuilder = new-object system.text.stringbuilder
    $lineBuilder = new-object system.text.stringbuilder
    $null = $lineBuilder.Append(“{0:000}
” -f $currentLine)
$SCRIPT:currentLine ++
# Iterate over the tokens and set the colors appropriately.
    $position = 0
    foreach ($token in $tokens){
        if ($position -lt $token.Start){
    $block = “Second”
            $block = $text.Substring($position, ($token.Start - $position))
            $tokenColor = ‘Unknown’
            Append-HtmlSpan $block $tokenColor
        }
$block = “First”
        $block = $text.Substring($token.Start, $token.Length)
        $tokenColor = $token.Type.ToString()
        Append-HtmlSpan $block $tokenColor
        $position = $token.Start + $token.Length
    }
    $code = $codeBuilder.ToString()
    $html = GetHtmlClipboardFormat $code “Print”
    $IEApplication = New-Object -ComObject InternetExplorer.Application
    $IEApplication.Navigate2(“about:blank”,14)
    $IEApplication.Visible = $false
    if($Host.Name -eq ‘Windows PowerShell ISE Host’){
        $IEApplication.Document.frames.document.title = $psise.CurrentFile.DisplayName
    }
    Else{
        $IEApplication.Document.frames.document.title = (Split-Path -Path $Path -Leaf)
    }
    $IEApplication.Document.body.innerHTML = $html
    while ($IEApplication.busy) {Start-Sleep -Seconds 1}
    $IEApplication.ExecWB(7,2)
    #region cleanup
    while ($IEApplication.busy) {Start-Sleep -Seconds 1}
    $IEApplication.Quit()
    #endregion
}
Copy-ToPrinter -Path $Path

I suggest saving the script to a local path (say c:\scripts) and adding a reference to your PowerShell ISE profile such as:

$psISE.CurrentPowerShellTab.AddOnsMenu.Submenus.Add(“Print Script”,{c:\scripts\Copy-ToPrinter.ps1},”Alt+Shift+P”) | Out-Null

You can either copy the script from above, or download it from TechNet

PowerShell WMI Gather DNS settings for all Servers

Karl Mitschke — Sat, 24 Dec 2011 03:19:00 +0000

A question came up on TechNet:

“I am new to PowerShell and need a wmi script to query all the servers on my network for there dns settings and dump it out to a text file. Would someone be able to help me get started?”

This was a fairly long script, so I decided to post it here.

*EDIT*

This script receives an inordinate amount of comments, mostly requesting that I send people a copy, so I have decided to place a copy on TechNet: http://gallery.technet.microsoft.com/Gather-DNS-settings-from-fec23eaa I am also pasting the new version below:

<#
.SYNOPSIS
    Get-ServerDNS – Gathers DNS settings from computers.
.DESCRIPTION
    This script gathers DNS settings from the specified computer(s)
.NOTES
    File Name: Get-ServerDNS.ps1
    Author: Karl Mitschke
    Requires: Powershell V2
    Created: 05/12/2010
    Modified: 12/23/2011
.LINK
    “http://unlockpowershell.wordpress.com/2010/05/12/powershell-wmi-gather-dns-settings-for-all-servers-2/”
    “http://gallery.technet.microsoft.com/Gather-DNS-settings-from-fec23eaa”

.EXAMPLE
C:\PS>.\Get-ServerDNS.ps1
Description
———–
Gathers DNS settings from the local computer.
.EXAMPLE
C:\PS>.\Get-ServerDNS.ps1 -Computer Exch2010
Description
———–
Gathers DNS settings from the computer Exch2010.
.EXAMPLE
C:\PS> Get-ExchangeServer | Get-ServerDNS.ps1
Description
———–
Gathers DNS settings on all Exchange servers.
.EXAMPLE
C:\PS> $cred = Get-Credential -Credential mitschke\karlm
C:\PS>.\Get-ServerDNS.ps1 -ComputerName (Get-Content -Path ..\Servers.txt) -Credential $cred
Description
———–
Gathers DNS settings on all servers in the file Servers.txt.
.PARAMETER ComputerName
The Computer(s) to Gather DNS settings from. If not specified, defaults to the local computer.
.PARAMETER Credential
The Credential to use. If not specified, runs under the current security context.
#>

[CmdletBinding(SupportsShouldProcess=$false, ConfirmImpact='Medium')]
param (
[parameter(
Mandatory=$false,
ValueFromPipeline=$true)
]
[String[]]$ComputerName=$Env:ComputerName,
[Parameter(
Position = 1,
Mandatory = $false
)]
$Credential
)
BEGIN{
   #region PSBoundParameters modification
    if ($Credential -ne $null -and $Credential.GetType().Name -eq “String”){
        $PSBoundParameters.Remove(“Credential”) | Out-Null
        $PSBoundParameters.Add(“Credential”, (Get-Credential -Credential $Credential))
    }
    #endregion
    $AllServers = @()
    $ServerObj = @()
    $Member = @{
        MemberType = “NoteProperty”
        Force = $true
    }
}
PROCESS{
    $PSBoundParameters.Remove(“ComputerName”) | Out-Null
    foreach ($StrComputer in $ComputerName){
        $NetItems = $null
        Write-Progress -Status “Working on $StrComputer” -Activity “Gathering Data”
        $ServerObj = New-Object psObject
        $ServerObj | Add-Member @Member -Name “Hostname” -Value $StrComputer
        $NetItems = @(Get-WmiObject -Class Win32_NetworkAdapterConfiguration -Filter “IPEnabled = ‘True’” -ComputerName $StrComputer @PSBoundParameters)
        $intRowNet = 0
        $ServerObj | Add-Member -MemberType NoteProperty -Name “NIC’s” -Value $NetItems.Length -Force
        [STRING]$MACAddresses = @()
        [STRING]$IpAddresses = @()
        [STRING]$DNS = @()
        [STRING]$DNSSuffix = @()
        foreach ($objItem in $NetItems){
            if ($objItem.IPAddress.Count -gt 1){
                $TempIpAdderesses = [STRING]$objItem.IPAddress
                $TempIpAdderesses = $TempIpAdderesses.Trim().Replace(” “, ” ; “)
                $IpAddresses += $TempIpAdderesses
            }
            else{
                $IpAddresses += $objItem.IPAddress +“; “
            }
            if ($objItem.{MacAddress}.Count -gt 1){
                $TempMACAddresses = [STRING]$objItem.MACAddress
                $TempMACAddresses = $TempMACAddresses.Replace(” “, ” ; “)
                $MACAddresses += $TempMACAddresses +“; “
            }
            else{
                $MACAddresses += $objItem.MACAddress +“; “
            }
            if ($objItem.{DNSServerSearchOrder}.Count -gt 1){
                $TempDNSAddresses = [STRING]$objItem.DNSServerSearchOrder
                $TempDNSAddresses = $TempDNSAddresses.Replace(” “, ” ; “)
                $DNS += $TempDNSAddresses +“; “
            }
            else{
                $DNS += $objItem.{DNSServerSearchOrder} +“; “
            }
            if ($objItem.DNSDomainSuffixSearchOrder.Count -gt 1){
                $TempDNSSuffixes = [STRING]$objItem.DNSDomainSuffixSearchOrder
                $TempDNSSuffixes = $TempDNSSuffixes.Replace(” “, ” ; “)
                $DNSSuffix += $TempDNSSuffixes +“; “
                }
            else{
                $DNSSuffix += $objItem.DNSDomainSuffixSearchOrder +“; “
                }
                $SubNet = [STRING]$objItem.IPSubnet[0]
            $intRowNet = $intRowNet + 1
        }
        $ServerObj | Add-Member @Member -Name “IP Address” -Value $IpAddresses.substring(0,$ipaddresses.LastIndexOf(“;”))
        $ServerObj | Add-Member @Member -Name “IP Subnet” -Value $SubNet
        $ServerObj | Add-Member @Member -Name “MAC Address” -Value $MACAddresses.substring(0,$MACAddresses.LastIndexOf(“;”))
        $ServerObj | Add-Member @Member -Name “DNS” -Value $DNS
        $ServerObj | Add-Member @Member -Name “DNS Suffix Search Order” -Value $DNSSuffix
        $ServerObj | Add-Member @Member -Name “DNS Enabled For Wins” -Value $objItem.DNSEnabledForWINSResolution
        $ServerObj | Add-Member @Member -Name “Domain DNS Registration Enabled” -Value $objItem.DomainDNSRegistrationEnabled
        $ServerObj | Add-Member @Member -Name “Full DNS Registration Enabled” -Value $objItem.FullDNSRegistrationEnabled
        $ServerObj | Add-Member @Member -Name “DHCP Enabled” -Value $objItem.DHCPEnabled
        $ServerObj | Add-Member @Member -Name “DHCP Lease Obtained” -Value $objItem.DHCPLeaseObtained
        $ServerObj | Add-Member @Member -Name “DHCP Lease Expires” -Value $objItem.DHCPLeaseExpires
        $AllServers += $ServerObj
    }
}
END{
    Write-Output -InputObject $AllServers
}

Copy and save the script as Get-ServerDNS.ps1, or download it from TechNet.

PowerShell V.Next: Simplified Where-Object and ForEach-Object

Karl Mitschke — Wed, 21 Dec 2011 03:28:00 +0000

I was perusing the samples that come with the PowerShell V3 CTP (Samples\WindowsPowerShell) when I noticed a folder called “Simplified Foreach and Where”

Lo and behold, you no longer need curly braces “{}” or the $_ to refer to the current object in the ForEach-Object and Where-Object cmdlets!

The sample is incredibly simple, but quickly shows the power of this new feature:

001
002
003
004
005
006
007
008
009
010

# Suggestion: Simplified Where and Foreach
# This is the same demo that we showed during the Summit Preview live meeting
# We just like it so much that we want to show it again
# You no longer need {} and $_ to do Where-Object
Get-Process | where Name -eq powershell
# Same thing with Foreach-Object
notepad;notepad;notepad;
Get-Process | where name -eq notepad
Get-Process | where name -eq notepad | foreach kill
Get-Process | where name -eq notepad

Share-Story | Win-Prize

Karl Mitschke — Tue, 20 Dec 2011 01:20:00 +0000

PowerShell Magazine is currently soliciting articles for a series called “How I Learned to Stop Worrying and Love Windows PowerShell”.

Anyone can submit an article and potentially win a TrainSignal PowerShell course.

Check it out at PowerShell Magazine, and help new users!

PowerShell V 3.0 CTP Export-Csv now has an Append parameter!

Karl Mitschke — Sat, 17 Dec 2011 02:23:00 +0000

Great news for all those folks who rely on Export-Csv and who have been wanting an Append parameter! The latest CTP of PowerShell 3.0 now provides the parameter.

It’s not perfect, but it’s close – if the data you are exporting does not match the current data, you will receive an error:

If you rerun the previous example, with the Force switch, the current directories list of files will be in the “Name” column of the csv file.

If you don’t use the Force, and you DO know what you are doing, this does come in very handy – you can gather data on a daily (or weekly) basis and append it to one file with ease

Let’s hope Microsoft keeps this in the RTM of PowerShell V3

To get the latest CTP of PowerShell V 3.0, head to the Microsoft Download Center

One note – Don’t forget to uninstall CTP 1 if you have it! I failed to do this, and had to spend quite a bit of time recovering from my inability to read the Instructions.

Guest blog post on Hey, Scripting Guy! blog

Karl Mitschke — Wed, 14 Dec 2011 03:38:00 +0000

Shortly after the Windows 2.0 PowerShell Bible came out, I was contacted by Ed Wilson of Microsoft Scripting Guy fame.

He asked all of the authors if we’d like to contribute a guest blog post to the Hey, Scripting Guy! blog. I am pleased to say that mine is now published. I extended a script from the book, so it was a fairly easy article for me.

The article is available at the Hey, Scripting Guy! blog, and the script is available in the Scripting Guys Script Repository (You have to download the script after agreeing to the license terms)

I may contribute more guest posts in the future (I have a partial chapter on Internet Explorer), or I may post more script enhancements here….

Windows PowerShell 2.0 Bible now available!

Karl Mitschke — Thu, 29 Sep 2011 23:20:00 +0000

The book is now available at Amazon and Barnes & Noble in the US.

Looks like it will take a day or two to make it overseas.

Updated CopyAsColorizedHTML module–Supports PowerGUI, PowerShell ISE, PowerShell Console

Karl Mitschke — Thu, 29 Sep 2011 03:09:00 +0000

In a previous post (http://unlockpowershell.wordpress.com/2010/10/30/copytocolorizedhtmlscript-editor-add-on-for-powergui/), I discussed the add-on that I created for PowerGUI, which I use to copy scripts into colorized HTML. I am now using PowerShell V3, and though you can “break” PowerGUI to work with PowerShell V3 (http://csharpening.net/?p=588), I need my add-ons!

I couldn’t really abandon PowerShell V3, but I can temporarily put aside PowerGUI. I know they will have an updated SDK.dll soon though.

in the mean time, I’ve updated my CopyAsColorizedHTML module to work with PowerGUI, the PowerShell ISE, and the PowerShell console.I’ve posted the updated version on PowerGUI.org: http://powergui.org/entry.jspa?externalID=3021&categoryID=387

If you are running the PowerShell ISE, I’d suggest adding this to your Microsoft.PowerShellISE_profile.ps1 script:

001	$psISE.CurrentPowerShellTab.AddOnsMenu.Submenus.Add(“Copy As Colorized HTML”,{Copy-ColorizedHTML},“Ctrl+Shift+C”) \| Out-Null

If you are running PowerShell V3, that’s all you need to do, other than add the module to your Modules path – PowerShell V3 will load the module as needed.

Windows PowerShell 2.0 Bible–Quick Update

Karl Mitschke — Tue, 27 Sep 2011 12:40:19 +0000

Wiley now have the Description, Table of Contents, Author Information, and Downloads for the PowerShell Bible

You can also read excerpts in PDF format.

http://www.wiley.com/WileyCDA/WileyTitle/productCd-1118021983.html

I wrote Chapters 3, 5, 7, 8, 9, and 12.

The physical book should be hitting shelves shortly!