Another computer blog

Powershell (v2) - Read Gmail (More Proof of Concept than Anything)

2012-01-26T20:53:00.000-08:00

After reading through some forums and seeing someone have trouble with their gmail, but, no client to control the data I got curious. My research suggested there were lost of posts on how to use Powershell to send through gmail, but, not necessarily to read. A quick hunt for some C# led me to this ASP.NET snippet:

ASP.net Read Email

After scanning the code quickly I figured this could be ported into Powershell with little effort. Although I had some initial issues due to a misconfiguration (I put an smtp address in one spot where I needed pop address) it worked when I was done...to some extent. I still had trouble filtering out email strings, so, I hit the Technet board. As always mjolinor was the man with a regex to help me track down precisely what I needed:

Harvesting "from" addresses from my gmail account

Using what is listed below, I can pull email. But, what I don't fully understand is how, when I get email, it is often different, and, in no obvious order. Since this was really a proof of concept type post I haven't had much time to research the POP RFC. Nonetheless, I thought I would throw it out there for more talented souls than myself to save them the work. So, the next time you're lost on a desert island with perfect wifi, a laptop and an instance of Powershell...you can still check your email. How cool is that?

Clear-Host try { Write-Output "Creating new TcpClient." $tcpClient = New-Object -TypeName System.Net.Sockets.TcpClient # Connect to gmail $tcpClient.Connect("pop.gmail.com", 995) if($tcpClient.Connected) { Write-Output "You are connected to the host. Attempting to get SSL stream." # Create new SSL Stream for tcpClient Write-Output "Getting SSL stream." [System.Net.Security.SslStream] $sslStream = $tcpClient.GetStream() # Authenticating as client Write-Output "Authenticating as client." $sslStream.AuthenticateAsClient("pop.gmail.com"); if($sslStream.IsAuthenticated) { Write-Output "You have authenticated. Attempting to login." # Asssigned the writer to stream [System.IO.StreamWriter] $sw = $sslstream # Assigned reader to stream [System.IO.StreamReader] $reader = $sslstream # refer POP rfc command, there very few around 6-9 command $sw.WriteLine('USER myemail@gmail.com') # sent to server $sw.Flush() # send pass $sw.WriteLine('PASS JollyRodgersH@dACabin'); $sw.Flush() # this will retrive your first email $sw.WriteLine("RETR 1") $sw.Flush() $sw.WriteLine("Quit "); $sw.Flush(); [String] $str = [String]::Empty [String] $strTemp = [String]::Empty while (($strTemp = $reader.ReadLine()) -ne $null) { # find the . character in line if($strTemp -eq '.') { break; } if ($strTemp.IndexOf('-ERR') -ne -1) { break; } $str += $strTemp; } # Return raw data Write-Output "`nOutput email" $str -match 'From:(.+?)?<(.+?)?>.' | Out-Null } else { Write-Error "You were not authenticated. Quitting." } } else { Write-Error "You are not connected to the host. Quitting" } } catch { $_ } finally { Write-Output "Script complete. Here are your from addresses." $Matches[2] }

Powershell (v2) - Function: Get-COMObjects

2012-01-24T06:14:00.000-08:00

While looking at a post on Technet about saving files from InfoPath I realized I didn't know the COM object name (the easiest way to Office products in Powershell). I could have just searched the registry, but, instead, decided to find a function that would do it for me. Keith Hill's (long) one-liner linked in the post below did the trick to list every COM object on the local machine.

Vista - is there any script to get a list of COM Objects in a computer?

I decided to take it one step further and add a -match operator accessible via a -Name parameter. After tweaking it with my single parameter, it ended up looking like this:

function Get-COMObjects { <# .AUTHOR Will Steele (wlsteele@gmail.com) .DEPENDENCIES n/a .DESCRIPTION This script returns the names of all COM objects on the local machine. If a Name parameter is passed, the function performs a -match on the name. .EXAMPLE Get-COMObjects .EXAMPLE Get-COMObjects -Name Excel .EXTERNALHELP None. .FORWARDHELPTARGETNAME None. .INPUTS System.String .LINK http://learningpcs.blogspot.com/2012/01/powershell-v2-function-get-comobjects.html .NAME Get-COMObjects .NOTES None. .OUTPUTS System.String .PARAMETER Name An optional parameter used to specify a string used for -match comparison. .SYNOPSIS List all local machine COM objects. #> [CmdletBinding()] param( [Parameter( Mandatory = $false, Position = 0, ValueFromPipeline = $true )] [String] $Name = $null ) if($Name -eq $null) { Get-ChildItem -Path HKLM:\Software\Classes -ErrorAction 0 | ` Where-Object {$_.PSChildName -match '^\w+\.\w+$' -and ` (Get-ItemProperty "$($_.PSPath)\CLSID" -ErrorAction 0)} | ` Select-Object PSChildName } else { Get-ChildItem -Path HKLM:\Software\Classes -ErrorAction 0 | ` Where-Object {$_.PSChildName -match '^\w+\.\w+$' -and ` (Get-ItemProperty "$($_.PSPath)\CLSID" -ErrorAction 0)} | ` Where-Object {$_.PSChildName -match $Name} | ` Select-Object PSChildName } }

Powershell (v2) - IIS 7: Create New Website with IP Set to "All Unassigned"

2012-01-23T15:01:00.001-08:00

I couldn't find anything that was explicit on how to do this, so, I will throw it out there. The task is this: create a new website with the IP Address set to "All Unassigned". If you do this manually via the IIS Administration MMC it's pretty straightforward. In Powershell, however, I was unclear on how to do the "All Unassigned" part. This component essentially means using the wildcard (*) character for IP Address. To do this, make sure you have the WebAdministration module loaded, then, run this:

New-Website -Name "Test Website 1" -IPAddress "*" -HostHeader "www.testwebsite1.com" -PhysicalPath "C:\test"

When you run this command, you should get this result:

Name ID State Physical Path Bindings ---- -- ----- ------------- -------- Test Website 1 4 Started C:\test http *:80:www.testwebsite1.com

If you want to force the binding (the technical term for the IIS component specifying protocol, header, port, and, site name) use this approach. Notice the -SSL switch:

New-Website -Name "Test Website 2" -IPAddress "*" -HostHeader "www.testwebsite2.com" -PhysicalPath "C:\test" -SSL

With this approach, you should see this:

Name ID State Physical Path Bindings ---- -- ----- ------------- -------- Test Website 2 5 Stopped C:\test https *:80:www.testwebsite2.com

Be aware that you have to specify port 443 explicitly when you use the -SSL switch, otherwise, you will merely get a binding with the https protocol on port 80. This can work, but, is not standard practice. The appropriate command would be:

New-Website -Name "Test Website 3" -IPAddress "*" -HostHeader "www.testwebsite3.com" -PhysicalPath "C:\test" -SSL -Port 443

which, in turn, gives you this:

Name ID State Physical Path Bindings ---- -- ----- ------------- -------- Test Website 3 3 Started C:\test https *:443:www.testwebsite3.com

Note that I highlighted the binding and port in website 2 and website 3 to differentiate between the two.

COM - Getting Back to Old School (Shell.Application)

2012-01-19T18:05:00.000-08:00

After unsuccessfully fighting zip scripts all week I decided to reach out and see if I could get some info on the shell.application COM object. This is one used to do zipping when you're not using an executable. I've worked with it before, but, never really nailed it down. So, I was given several great links I want to record for posterity as another wave of projects is about to wash in and I can't research much at this point:

WinZip - Compression Rates for Common File Types (and some Powershell Calculation Functions)

2012-01-18T07:49:00.000-08:00

After a busy week of data management, file and folder manipulation I got a chance to sit down and do some analysis. While working on several data conversion projects I began to see patterns in the data compression rates of the documents I was working with. Plain .txt files zip extremely well, whereas .pdf files hardly zip compress at all.

To help be precise in my study, here are the basics of my system, as displayed via the WinZip | Help | About WinZip | View System Information form:

Windows 7 Enterprise Edition (Build 7600), 32-bit
Current date/time: 1/18/2012 7:55 AM
WinZip(R) 15.5 (9510) compiled: Jun 20 2011
Module name = C:\Program Files\WinZip\WINZIP32.EXE
Command line: "C:\Program Files\WinZip\WINZIP32.EXE" "C:\testing\zipping\txt.zip"
Total physical memory = 3109108 Kbytes
Physical memory available = 193828 Kbytes
Total virtual memory = 2097024 Kbytes
Virtual memory available = 1912060 Kbytes
Country code: 1
Language: English
Code-page: 1252

The document I used to test against was generated using Microsoft Word 2007's =lorem() function with parameters of 200 and 10 (it looks like this =lorem(200,10) when you put it in Word). This is an approach others can use and obtain similar results, so, it tends to fall under the umbrella of "scientific" research, for it's ability to be reproduced by others. When I analyzed this file it contained the following stats:

Pages: 27
Words: 12,505
Characters (no spaces): 73,476
Characters (with spaces): 85,781
Paragraphs: 200
Lines: 945

I saved this file in a variety of formats to get comparative figures for each file type. The list below includes:

the file type to which the original document was saved
the original file size
the compressed file size and
the compression ratio (compressed/original file size) - higher numbers suggest less compression

Below are the common file types you can save from Microsoft Word 2007.

.doc: 115200 - 9742 - 8.45%
.docm: 18397 - 15941 - 86.64%
.docx: 18370 - 15912 - 86.62%
.dotx: 18394 - 15928 - 86.59%
.htm: 123279 - 9657 - 7.83%
.mht: 133490 - 19249 - 14.42%
.odt: 10746 - 10575 - 98.41%
.pdf: 178468 - 161172 - 90.31%
.rtf: 139518 - 13362 - 9.57%
.txt: 86183 - 3285 - 3.81%
.wps (Works 6.0-9.0): 178688 - 8171 - 4.57%
.wps (Works 7.0): 178688 - 8167 - 4.57%
.xml (Word): 149435 - 8946 - 5.99%
.xml (Word 2003): 131751 - 6347 - 4.81%
.xps: 288370 - 271462 - 94.13%

As you can see from the list above, the binary files fare much more poorly than the simpler markup files. The next chance I get I'll do comparisons on various image file formats. If you read this and think of another file type you want checked out, let me know and I'll add it to the list. There are plenty I can think of, but, in this initial post, don't have time to explore. Also, I will try compression rates with other software (built in Windows, 7zip, etc).

For folks looking to understand how this can practically affect their daily work flow here are some things to consider. In a recent project, I was zipping .tif images. Our system handles .zip files best at a maximum of about 100kb in size. To determine how many files I can fit into a zip file I either have to calculate the size of the zip after every file iteration (which fails because it only stops after the threshold has been passed). Alternatively, I can run a predictive algorithm (a script) against a folder using these figures as estimates. Now, I know there will be variance in compression rates. If I included images or embedded objects in these files, it would skew the numbers completely. However, since we deal with common file types on large project, our file compression rates are pretty stable.

This may seem like an arbitrary thing to script, but, when you deal with significant quantities of data (read that to mean millions of files) at a time, sometimes it is wise to plan ahead and size up the mountain before you start the climb. If I were to approach this with Powershell, I could run a script like this against a folder to see what potential .zip file sizes might be using a simple switch statement:

function Calculate-CompressedSize { [CmdletBinding()] param( [Parameter( Mandatory = $true, ValueFromPipeline = $true )] $files ) foreach($file in $files) { switch ($file.extension) { .doc { return "$($file.Name): {0:N0}/{1:N0} ({2:P2})" -f ($file.Length * 0.0845), $file.Length, (($file.Length * 0.0845)/$file.Length) } .docm { return "$($file.Name): {0:N0}/{1:N0} ({2:P2})" -f ($file.Length * 0.8664), $file.length, (($file.Length * 0.8664)/$file.length) } .docx { return "$($file.Name): {0:N0}/{1:N0} ({2:P2})" -f ($file.Length * 0.8662), $file.length, (($file.Length * 0.8662)/$file.length) } .dotx { return "$($file.Name): {0:N0}/{1:N0} ({2:P2})" -f ($file.Length * 0.8659), $file.length, (($file.Length * 0.8659)/$file.length) } .htm { return "$($file.Name): {0:N0}/{1:N0} ({2:P2})" -f ($file.Length * 0.0783), $file.length, (($file.Length * 0.0783)/$file.length) } .mht { return "$($file.Name): {0:N0}/{1:N0} ({2:P2})" -f ($file.Length * 0.1442), $file.length, (($file.Length * 0.1442)/$file.length) } .odt { return "$($file.Name): {0:N0}/{1:N0} ({2:P2})" -f ($file.Length * 0.9841), $file.length, (($file.Length * 0.9841)/$file.length) } .pdf { return "$($file.Name): {0:N0}/{1:N0} ({2:P2})" -f ($file.Length * 0.9031), $file.length, (($file.Length * 0.9031)/$file.length) } .rtf { return "$($file.Name): {0:N0}/{1:N0} ({2:P2})" -f ($file.Length * 0.0957), $file.length, (($file.Length * 0.0957)/$file.length) } .txt { return "$($file.Name): {0:N0}/{1:N0} ({2:P2})" -f ($file.Length * 0.0381), $file.length, (($file.Length * 0.0381)/$file.length) } .wps { return "$($file.Name): {0:N0}/{1:N0} ({2:P2})" -f ($file.Length * 0.0457), $file.length, (($file.Length * 0.0457)/$file.length) } .xml { return "$($file.Name): {0:N0}/{1:N0} ({2:P2})" -f ($file.Length * 0.055), $file.length, (($file.Length * 0.055)/$file.length) } .xps { return "$($file.Name): {0:N0}/{1:N0} ({2:P2})" -f ($file.Length * 0.9413), $file.length, (($file.Length * 0.9413)/$file.length) } } } }

This is pretty and all, and, in my test case, it works great to give me basic information. However, the next step would be to sum the total of each file in the directory to give me an estimate of how much space would be used if I were to zip it all. This can be done like this:

function Calculate-CompressedSize { [CmdletBinding()] param( [Parameter( Mandatory = $true, ValueFromPipeline = $true )] $files ) foreach($file in $files) { switch ($file.extension) { .doc { return {0:N0} -f ($file.Length * 0.0845) } .docm { return {0:N0} -f ($file.Length * 0.8664) } .docx { return {0:N0} -f ($file.Length * 0.8662) } .dotx { return {0:N0} -f ($file.Length * 0.8659) } .htm { return {0:N0} -f ($file.Length * 0.0783) } .mht { return {0:N0} -f ($file.Length * 0.1442) } .odt { return {0:N0} -f ($file.Length * 0.9841) } .pdf { return {0:N0} -f ($file.Length * 0.9031) } .rtf { return {0:N0} -f ($file.Length * 0.0957) } .txt { return {0:N0} -f ($file.Length * 0.0381) } .wps { return {0:N0} -f ($file.Length * 0.0457) } .xml { return {0:N0} -f ($file.Length * 0.055) } .xps { return {0:N0} -f ($file.Length * 0.9413) } } } }

Next, I would iterate the contents of my directory (in this case, my test data) like so,

$zipsize = 0 dir | % { $zipsize += Calculate-CompressedSize $_}

And, to see what my result is,

$zipsize 578096

I know this is a stilted example (as I used my test data to predict the results), but, when I zipped the files, I got a .zip file with a size (not size on disk) of 579647. Calculating the margin of error I get 578096/579647 = 99.73%. If I can predict how much files will compress to within 1/4 of a percent with a simple function, I am going to be pretty happy when it comes time to start creating zips. The next step, for me, would be to write predictive functions calculating, as show, above, groupings for file sets that would match my .zip size limit. Theoretically, I would write something like this Analyze-File -MaxCompressionSize 100kb. This would return arrays of the filenames that match this, which, I would then pipe into my scripts. Using this approach, I could accurately control how much data is handled and in what ways.

Word 2007 - Generating Junk Data with =Rand() and =Lorem()

2012-01-18T05:35:00.000-08:00

To test some zip compression methods I needed to create dummy files. Knowing from past exploits in this direction I could do so in Word rather easily I Googled up this article describing two easter eggs: =rand() and =lorem().

Fun at Work: Microsoft Word "Easter Egg"

As noted in the article, you can automatically generate three paragraphs with five sentences each of junk text. These defaults, of 3 paragraphs and 5 sentences, can be overridden by passing in specific values. For example, if I want 10 paragraphs with 10 sentences to be generated, I use =rand(10,10) instead. In my example, this worked perfectly to help me quickly generate a lot of useless data for testing purposes.

And, if you're curious what it puts out (yes, there will be a lot of text), here are the outputs of the rand(10,10) and lorem(10,10) respectively. First up, =rand(10,10)

On the Insert tab, the galleries include items that are designed to coordinate with the overall look of your document. You can use these galleries to insert tables, headers, footers, lists, cover pages, and other document building blocks. When you create pictures, charts, or diagrams, they also coordinate with your current document look. You can easily change the formatting of selected text in the document text by choosing a look for the selected text from the Quick Styles gallery on the Home tab. You can also format text directly by using the other controls on the Home tab. Most controls offer a choice of using the look from the current theme or using a format that you specify directly. To change the overall look of your document, choose new Theme elements on the Page Layout tab. To change the looks available in the Quick Style gallery, use the Change Current Quick Style Set command. Both the Themes gallery and the Quick Styles gallery provide reset commands so that you can always restore the look of your document to the original contained in your current template. On the Insert tab, the galleries include items that are designed to coordinate with the overall look of your document.
You can use these galleries to insert tables, headers, footers, lists, cover pages, and other document building blocks. When you create pictures, charts, or diagrams, they also coordinate with your current document look. You can easily change the formatting of selected text in the document text by choosing a look for the selected text from the Quick Styles gallery on the Home tab. You can also format text directly by using the other controls on the Home tab. Most controls offer a choice of using the look from the current theme or using a format that you specify directly. To change the overall look of your document, choose new Theme elements on the Page Layout tab. To change the looks available in the Quick Style gallery, use the Change Current Quick Style Set command. Both the Themes gallery and the Quick Styles gallery provide reset commands so that you can always restore the look of your document to the original contained in your current template. On the Insert tab, the galleries include items that are designed to coordinate with the overall look of your document. You can use these galleries to insert tables, headers, footers, lists, cover pages, and other document building blocks.
When you create pictures, charts, or diagrams, they also coordinate with your current document look. You can easily change the formatting of selected text in the document text by choosing a look for the selected text from the Quick Styles gallery on the Home tab. You can also format text directly by using the other controls on the Home tab. Most controls offer a choice of using the look from the current theme or using a format that you specify directly. To change the overall look of your document, choose new Theme elements on the Page Layout tab. To change the looks available in the Quick Style gallery, use the Change Current Quick Style Set command. Both the Themes gallery and the Quick Styles gallery provide reset commands so that you can always restore the look of your document to the original contained in your current template. On the Insert tab, the galleries include items that are designed to coordinate with the overall look of your document. You can use these galleries to insert tables, headers, footers, lists, cover pages, and other document building blocks. When you create pictures, charts, or diagrams, they also coordinate with your current document look.
You can easily change the formatting of selected text in the document text by choosing a look for the selected text from the Quick Styles gallery on the Home tab. You can also format text directly by using the other controls on the Home tab. Most controls offer a choice of using the look from the current theme or using a format that you specify directly. To change the overall look of your document, choose new Theme elements on the Page Layout tab. To change the looks available in the Quick Style gallery, use the Change Current Quick Style Set command. Both the Themes gallery and the Quick Styles gallery provide reset commands so that you can always restore the look of your document to the original contained in your current template. On the Insert tab, the galleries include items that are designed to coordinate with the overall look of your document. You can use these galleries to insert tables, headers, footers, lists, cover pages, and other document building blocks. When you create pictures, charts, or diagrams, they also coordinate with your current document look. You can easily change the formatting of selected text in the document text by choosing a look for the selected text from the Quick Styles gallery on the Home tab.
You can also format text directly by using the other controls on the Home tab. Most controls offer a choice of using the look from the current theme or using a format that you specify directly. To change the overall look of your document, choose new Theme elements on the Page Layout tab. To change the looks available in the Quick Style gallery, use the Change Current Quick Style Set command. Both the Themes gallery and the Quick Styles gallery provide reset commands so that you can always restore the look of your document to the original contained in your current template. On the Insert tab, the galleries include items that are designed to coordinate with the overall look of your document. You can use these galleries to insert tables, headers, footers, lists, cover pages, and other document building blocks. When you create pictures, charts, or diagrams, they also coordinate with your current document look. You can easily change the formatting of selected text in the document text by choosing a look for the selected text from the Quick Styles gallery on the Home tab. You can also format text directly by using the other controls on the Home tab.
Most controls offer a choice of using the look from the current theme or using a format that you specify directly. To change the overall look of your document, choose new Theme elements on the Page Layout tab. To change the looks available in the Quick Style gallery, use the Change Current Quick Style Set command. Both the Themes gallery and the Quick Styles gallery provide reset commands so that you can always restore the look of your document to the original contained in your current template. On the Insert tab, the galleries include items that are designed to coordinate with the overall look of your document. You can use these galleries to insert tables, headers, footers, lists, cover pages, and other document building blocks. When you create pictures, charts, or diagrams, they also coordinate with your current document look. You can easily change the formatting of selected text in the document text by choosing a look for the selected text from the Quick Styles gallery on the Home tab. You can also format text directly by using the other controls on the Home tab. Most controls offer a choice of using the look from the current theme or using a format that you specify directly.
To change the overall look of your document, choose new Theme elements on the Page Layout tab. To change the looks available in the Quick Style gallery, use the Change Current Quick Style Set command. Both the Themes gallery and the Quick Styles gallery provide reset commands so that you can always restore the look of your document to the original contained in your current template. On the Insert tab, the galleries include items that are designed to coordinate with the overall look of your document. You can use these galleries to insert tables, headers, footers, lists, cover pages, and other document building blocks. When you create pictures, charts, or diagrams, they also coordinate with your current document look. You can easily change the formatting of selected text in the document text by choosing a look for the selected text from the Quick Styles gallery on the Home tab. You can also format text directly by using the other controls on the Home tab. Most controls offer a choice of using the look from the current theme or using a format that you specify directly. To change the overall look of your document, choose new Theme elements on the Page Layout tab.
To change the looks available in the Quick Style gallery, use the Change Current Quick Style Set command. Both the Themes gallery and the Quick Styles gallery provide reset commands so that you can always restore the look of your document to the original contained in your current template. On the Insert tab, the galleries include items that are designed to coordinate with the overall look of your document. You can use these galleries to insert tables, headers, footers, lists, cover pages, and other document building blocks. When you create pictures, charts, or diagrams, they also coordinate with your current document look. You can easily change the formatting of selected text in the document text by choosing a look for the selected text from the Quick Styles gallery on the Home tab. You can also format text directly by using the other controls on the Home tab. Most controls offer a choice of using the look from the current theme or using a format that you specify directly. To change the overall look of your document, choose new Theme elements on the Page Layout tab. To change the looks available in the Quick Style gallery, use the Change Current Quick Style Set command.
Both the Themes gallery and the Quick Styles gallery provide reset commands so that you can always restore the look of your document to the original contained in your current template. On the Insert tab, the galleries include items that are designed to coordinate with the overall look of your document. You can use these galleries to insert tables, headers, footers, lists, cover pages, and other document building blocks. When you create pictures, charts, or diagrams, they also coordinate with your current document look. You can easily change the formatting of selected text in the document text by choosing a look for the selected text from the Quick Styles gallery on the Home tab. You can also format text directly by using the other controls on the Home tab. Most controls offer a choice of using the look from the current theme or using a format that you specify directly. To change the overall look of your document, choose new Theme elements on the Page Layout tab. To change the looks available in the Quick Style gallery, use the Change Current Quick Style Set command. Both the Themes gallery and the Quick Styles gallery provide reset commands so that you can always restore the look of your document to the original contained in your current template.
On the Insert tab, the galleries include items that are designed to coordinate with the overall look of your document. You can use these galleries to insert tables, headers, footers, lists, cover pages, and other document building blocks. When you create pictures, charts, or diagrams, they also coordinate with your current document look. You can easily change the formatting of selected text in the document text by choosing a look for the selected text from the Quick Styles gallery on the Home tab. You can also format text directly by using the other controls on the Home tab. Most controls offer a choice of using the look from the current theme or using a format that you specify directly. To change the overall look of your document, choose new Theme elements on the Page Layout tab. To change the looks available in the Quick Style gallery, use the Change Current Quick Style Set command. Both the Themes gallery and the Quick Styles gallery provide reset commands so that you can always restore the look of your document to the original contained in your current template. On the Insert tab, the galleries include items that are designed to coordinate with the overall look of your document.

Here's the =lorem(10,10) output:

Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Maecenas porttitor congue massa. Fusce posuere, magna sed pulvinar ultricies, purus lectus malesuada libero, sit amet commodo magna eros quis urna. Nunc viverra imperdiet enim. Fusce est. Vivamus a tellus. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Proin pharetra nonummy pede. Mauris et orci. Aenean nec lorem.
In porttitor. Donec laoreet nonummy augue. Suspendisse dui purus, scelerisque at, vulputate vitae, pretium mattis, nunc. Mauris eget neque at sem venenatis eleifend. Ut nonummy. Fusce aliquet pede non pede. Suspendisse dapibus lorem pellentesque magna. Integer nulla. Donec blandit feugiat ligula. Donec hendrerit, felis et imperdiet euismod, purus ipsum pretium metus, in lacinia nulla nisl eget sapien.
Donec ut est in lectus consequat consequat. Etiam eget dui. Aliquam erat volutpat. Sed at lorem in nunc porta tristique. Proin nec augue. Quisque aliquam tempor magna. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Nunc ac magna. Maecenas odio dolor, vulputate vel, auctor ac, accumsan id, felis. Pellentesque cursus sagittis felis.
Pellentesque porttitor, velit lacinia egestas auctor, diam eros tempus arcu, nec vulputate augue magna vel risus. Cras non magna vel ante adipiscing rhoncus. Vivamus a mi. Morbi neque. Aliquam erat volutpat. Integer ultrices lobortis eros. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Proin semper, ante vitae sollicitudin posuere, metus quam iaculis nibh, vitae scelerisque nunc massa eget pede. Sed velit urna, interdum vel, ultricies vel, faucibus at, quam. Donec elit est, consectetuer eget, consequat quis, tempus quis, wisi.
In in nunc. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos hymenaeos. Donec ullamcorper fringilla eros. Fusce in sapien eu purus dapibus commodo. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Cras faucibus condimentum odio. Sed ac ligula. Aliquam at eros. Etiam at ligula et tellus ullamcorper ultrices. In fermentum, lorem non cursus porttitor, diam urna accumsan lacus, sed interdum wisi nibh nec nisl.
Ut tincidunt volutpat urna. Mauris eleifend nulla eget mauris. Sed cursus quam id felis. Curabitur posuere quam vel nibh. Cras dapibus dapibus nisl. Vestibulum quis dolor a felis congue vehicula. Maecenas pede purus, tristique ac, tempus eget, egestas quis, mauris. Curabitur non eros. Nullam hendrerit bibendum justo. Fusce iaculis, est quis lacinia pretium, pede metus molestie lacus, at gravida wisi ante at libero.
Quisque ornare placerat risus. Ut molestie magna at mi. Integer aliquet mauris et nibh. Ut mattis ligula posuere velit. Nunc sagittis. Curabitur varius fringilla nisl. Duis pretium mi euismod erat. Maecenas id augue. Nam vulputate. Duis a quam non neque lobortis malesuada.
Praesent euismod. Donec nulla augue, venenatis scelerisque, dapibus a, consequat at, leo. Pellentesque libero lectus, tristique ac, consectetuer sit amet, imperdiet ut, justo. Sed aliquam odio vitae tortor. Proin hendrerit tempus arcu. In hac habitasse platea dictumst. Suspendisse potenti. Vivamus vitae massa adipiscing est lacinia sodales. Donec metus massa, mollis vel, tempus placerat, vestibulum condimentum, ligula. Nunc lacus metus, posuere eget, lacinia eu, varius quis, libero.
Aliquam nonummy adipiscing augue. Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Maecenas porttitor congue massa. Fusce posuere, magna sed pulvinar ultricies, purus lectus malesuada libero, sit amet commodo magna eros quis urna. Nunc viverra imperdiet enim. Fusce est. Vivamus a tellus. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Proin pharetra nonummy pede. Mauris et orci.
Aenean nec lorem. In porttitor. Donec laoreet nonummy augue. Suspendisse dui purus, scelerisque at, vulputate vitae, pretium mattis, nunc. Mauris eget neque at sem venenatis eleifend. Ut nonummy. Fusce aliquet pede non pede. Suspendisse dapibus lorem pellentesque magna. Integer nulla. Donec blandit feugiat ligula.

Powershell (v2) - Simplify Logging with Functions to Save Typing

2012-01-16T19:03:00.000-08:00

As I work on my current project, I like to include comments at the beginning and end of each section. When I started off my scripts, they looked like this:

#region Parameters param( [Parameter( HelpMessage = 'You need to enter a path to store the transcript.', Mandatory = $true )] [ValidateNotNullOrEmpty()] [String] $TranscriptPath ) #endregion Parameters #region Functions function fuwdt { Get-Date -Format "HH:mm:ss" } #endregion Functions #region ScriptConfiguration #requires -Version 2.0 #requires -PSSnapIn PSCX #requires -PSSnapIn ServerManager #requires -PSSnapIn WebAdministration Set-StrictMode -Version 2.0 Start-Transcript -Path $TranscriptPath #endregion ScriptConfiguration #region ScriptBody #region Log Header # Output status to host Write-Output "" Write-Output "$('*' * 50)" Write-Output "* Beginning application configuration (using script: $(Join-Path $(Split-Path -parent $MyInvocation.MyCommand.Definition) $(Split-Path -Leaf $MyInvocation.MyCommand.Definition)))." Write-Output "* Script run on $(Get-Date)." Write-Output "$('*' * 50)" Write-Output "" #endregion Log Header #region Step 1) Create application pools #### NOTES: ################################# # # This step will create AppPools based on the configuration for dev. # ############################################# # Output status to host Write-Output "$(fuwdt): $('*' * 75)" Write-Output "$(fuwdt): * Step 1) Creating AppPools." Write-Output "$(fuwdt): $('*' * 75)" Write-Output "$(fuwdt):" ... Do some work ... # Output status to host Write-Output "$(fuwdt):" Write-Output "$(fuwdt): $('*' * 50)" Write-Output "$(fuwdt): * AppPools created." Write-Output "$(fuwdt): $('*' * 50)" Write-Output "$(fuwdt):" #endregion Step 1) Create application pools

So, this is all well and good, but, when I started having several sections to my scripts, I was repeating this pattern over and over,

# Output status to host Write-Output "$(fuwdt): $('*' * 75)" Write-Output "$(fuwdt): * Step 1) Creating AppPools." Write-Output "$(fuwdt): $('*' * 75)" Write-Output "$(fuwdt):" ... Do some work ... # Output status to host Write-Output "$(fuwdt):" Write-Output "$(fuwdt): $('*' * 50)" Write-Output "$(fuwdt): * AppPools created." Write-Output "$(fuwdt): $('*' * 50)" Write-Output "$(fuwdt):"

Kind of foolish I figured, so, I wrote these two functions, and, put them in a base.psm1 module. You could also include them in the Functions region.

function Close-Comments { param( $Comment ) Write-Output "$(fuwdt):" Write-Output "$(fuwdt): $('*' * 50)" Write-Output "$(fuwdt): * $($Comment)." Write-Output "$(fuwdt): $('*' * 50)" Write-Output "$(fuwdt):" } function Open-Comments { param( $Comment ) Write-Output "$(fuwdt): $('*' * 75)" Write-Output "$(fuwdt): * $($Comment)." Write-Output "$(fuwdt): $('*' * 75)" Write-Output "$(fuwdt):" }

With these two functions, I can rewrite my block this way,

# Output status to host Open-Comments "Step 1) Creating AppPools." ... Do some work ... # Output status to host Close-Comments "AppPools created."

Quite a bit less typing, and, definitely cuts down on redundant code.

Powershell (v2) - Permanently Add Environmental Variable (for Real)

2012-01-16T16:11:00.000-08:00

A while back I found a link that gave me an idea of how to do this:

Vista - how to set system's environment variable permanently

However, when I went to try this, it didn't actually take. After doing some more digging, I found this post,

Add Path Environment Variable in PowerShell

which referenced an MSDN .NET link:

Environment.SetEnvironmentVariable Method (String, String, EnvironmentVariableTarget)

with three parameters instead of two. After reading up on this, I tried this, and, it worked perfectly.

[Environment]::SetEnvironmentVariable("test","testvalue","Machine")

For more information on this third parameter (and what you can use with it) check out this link:

EnvironmentVariableTarget Enumeration

As noted in this link, there are three targets you can point to with the method:

Process: The environment variable is stored or retrieved from the environment block associated with the current process.

The user creates the environment variable in a set operation.
When the process terminates, the operating system destroys the environment variable in that process.
User: The environment variable is stored or retrieved from the HKEY_CURRENT_USER\Environment key in the Windows operating system registry.

When the user creates the environment variable in a set operation, the operating system stores the environment variable in the system registry, but not in the current process. If the user starts a new process, the operating system copies the environment variable from the registry to that process.

When the process terminates, the operating system destroys the environment variable in that process. However, the environment variable in the registry persists until the user removes it programmatically or by means of an operating system tool.
Machine: The environment variable is stored or retrieved from the HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager\Environment key in the Windows operating system registry.

When a user creates the environment variable in a set operation, the operating system stores the environment variable in the system registry, but not in the current process. If any user on the local machine starts a new process, the operating system copies the environment variable from the registry to that process.

When the process terminates, the operating system destroys the environment variable in that process. However, the environment variable in the registry persists until a user removes it programmatically or by means of an operating system tool.

Powershell (v2) - Unzip Files without an Application

2012-01-15T17:28:00.000-08:00

Some time ago I pulled together someone's post to come up with a function to zip files without using any third party tools. Looking back, it is very rough, and, could be revisited. Nonetheless, I've got a big project due in a couple of days and none of the unzipping snippets I have found work very well. Steve Schofield, of the IIS team, had this post, however, which works pretty well so far:

Unzip several files with PowerShell

The snippet, to save you the hop over, if you're in a hurry, looks like this:

function UnZipMe($zipfilename,$destination) { $shellApplication = new-object -com shell.application $zipPackage = $shellApplication.NameSpace($zipfilename) $destinationFolder = $shellApplication.NameSpace($destination) # CopyHere vOptions Flag # 4 - Do not display a progress dialog box. # 16 - Respond with "Yes to All" for any dialog box that is displayed. $destinationFolder.CopyHere($zipPackage.Items(),20) } $a = gci -Path C:\inetpub\iislogs3.com\wwwlogs -Filter *.zip foreach($file in $a) { Write-Host "Processing - $file" UnZipMe –zipfilename $file.FullName -destination $file.DirectoryName }

Post - The SysAdmin Ten Commandments

2012-01-14T06:39:00.000-08:00

This comment,

http://www.reddit.com/r/sysadmin/comments/ofpmz/the_sysadmin_ten_commandments/c3gvkna

was reported by Rich_Prescott yesterday and I found it worth saving. I tend to try and collect tidbits earned from hard experience and these seemed pretty valuable. Hopefully, I'll have my own list someday.

If it isn't broke, don't mess with it!
If you can't figure out the problem, export all the logs and reboot.
Never change anything late in the day.
Never change anything on Friday.
Always be able to undo what you are about to do.
If you don't understand it, don't mess with it on a production system.
A project is not done until it's tested by you and by end-users.
A project is not done until it's documented.
All projects take twice as long as you planned for.
Use default settings whenever possible.
Do not roll out new software without training end users.
If you're fighting fires all the time, find the source.
Avoid poor decisions from above. Manage upward.
Backups always work, restores never do. Have good backups and test restores.

What I didn't realize is that it was a comment to an even better list,

http://hacktux.com/sysadmin/ten/commandments

which goes like this...the first one is cleaner.

I. Thou shalt respect thy user
It is paramount that you respect the user and their data. Don't steal their MP3s, don't look at their p___. When working with email, look without reading. Respect them and they will respect you.

II. Thou shalt empower the user
The user is the customer. The system is not yours, it is theirs. Provide users the tools they need to be successful and they will be happy. Give them space to experiment, learn and create. Do not hold users back.

III. Thou shalt keep it simple
Keep It Simple, Stupid. The KISS principle will keep you from building barrels to keep a bottle's worth of wine. Do not mistake over-engineering for quality. Quality work is concise and scalable.

IV. Thou shalt expect catastrophe
Expect the worst surprises. Make your resources redundant, backup your data, test your backups, and then backup the backups. The s___ will hit the fan someday. Be prepared.

V. Thou shalt plan
Great work follows great plans. Stay on target by first identifying it. Plan your work carefully and surprises will be easier to handle.

VI. Thou shalt stay informed
Gather all the news, information, logs and statistics you can. Without the raw data to analyze, you cannot debug problems and you cannot forecast. Without new information, you cannot learn.

VII. Thou shalt share
No one is alone in this world. Pass your knowledge on to others. Give to others, contribute to the community and you will reap many rewards. It is not wise to horde knowledge. Don't be an a__hole.

VIII. Thou shalt automate
Do more, faster by automating tasks. You are the puppet master, do not waste your time with menial work. Work smarter, not harder.

IX. Thou shalt document
Always document your work, your code and your plans. Then document their execution and maintenance. Document for others and document for yourself. Documentation should be an extension of your mind and a resource for others.

X. Thou shalt respect thy organization
Without organization, there is no system, there is no user and there is no job. Understand the organization and its business. Respect it and help it thrive.

Powershell (v2) - Quickly Create 1000 Copies of a File

2012-01-13T13:22:00.000-08:00

If you ever need to create dummy data for testing uploads, disk IO, or, what not, here is a quick way to generate large volumes of files. Note: if the files are large, this will be a little slower, and, will quickly, eat up disk space. That's my shout out out of caveat emptor.

2..1000 | % { copy C:\testing\000001.pdf ("{0:00000.pdf"} -f $_) }

The notation I am using 1..1000 | % is something I got recently from Larry Weiss, my own personal Powershell guru in the cloud, on my Technet post:

How can I reduce memory usage in scripts that operate over large collections?

The alternative, as he points out in the post, was my original format:

for($i=2;$i -le 1000;$i++) { copy C:\testing\000001.pdf ("{0:00000.pdf"} -f $i) }

As Larry illustrated, you can use the .. notation for quick array generation. With this syntax, you specify the min and max of the array. Pipe this to a foreach loop, % {}, and use the copy command. On thing that I use which is a little bit of a short cut is the zero fill format specifier:

"{0:00000.pdf"} -f $_

It saves me a ton of work. What this does is takes the first value on the right of the -f, in this case, the pipelined value, and, fits it into the 5-digit string in front of .pdf. If you did this manually, without specifiers, it would look like this, and, be much slower,

2..9 | % { copy .\00001.pdf 0000$_.pdf} 10..99 | % { copy .\00001.pdf 000$_.pdf} 100..999 | % { copy .\00001.pdf 00$_.pdf}

Granted, this may be a simple script, but, if you need to do something odd, like generate 1000 identical copies of a file with sequential naming, hey, now you know what to do.

Powershell (v2) - PSCX : Write-Zip (Mass Zipping Files and Lots of Them)

2012-01-13T06:10:00.000-08:00

After nearly killing myself to figure out my own solution to writing zip files I decided to revisit the Write-Zip cmdlet in the PSCX module. As I started working with it I found the second example in their help useless as it contains switches that don't even exist. So, that left me with one working example. It took me a little while to figure out how it worked, but, I finally did. Next, was how to get it to work in large data sets. At present I have a project with a few million files I need to zip, as one of the intermediary steps, and, this seemed like the perfect opportunity to figure out how to pull this off. To test and be sure I got the syntax correct I made a dummy directory with *.txt files. To process it I wrote this command:

PS C:\testing\powershell\testfiles> foreach($dir in (Get-ChildItem .)) { cd $dir.fullname Write-Zip .\*.tif "$($dir.Name).zip" }

This example assumes PSCX is imported. As it loops through the subdirectories it looks for files matching the extension, in this case, *.tif, and copies them to a .zip file named after the current directory. For my production example this works perfectly as I named the folders sequentially to indicate the project and data set I was working on. Unfortunately, the original switch that allowed you to remove the original is not an option any longer. Nonetheless, I can accomplish the same thing after I run the previous command with one more line:

dir .\*.tif | Remove-Item

I had thought about running jobs to accelerate the process, but, wanted to really be sure this works as intended before I add another layer of complication/abstraction.

In my first actual production run I found I was zipping 1000 files in 14 seconds every time. Using my own concoction, not only did I have corrupted zips, if the process got interrupted, but, it took much, much longer (read hours). This way I might be able to finish my work in 1/20th of the time it took me before. Thank you again Powershell and PSCX crew.

Powershell (v2) - Using NoteProperty to Control Processing in Loop

2012-01-11T21:36:00.000-08:00

I am doing some conceptual testing, and, to help me iron out my own test script, I have been looking for ways to control my iterations. One thing has bugged me is the use of complex counters to monitor status of data. I thought to myself, why not use the object itself to tell me it's processed state instead of relying on some convoluted status structure to infer this property. So, using Add-Member I assigned a new NoteProperty value of $true to each object after it had been processed. This way, when I iterate through my collection, I can simply read the property from the file and automatically know what files have been touched, and, what files are in need of processing. In this case, I create a test folder, generate the files, and, assign groups (based on intervals of 1000) in a hashtable value where the filename is the key. I am trying to sort of out some code for larger processes tasks and really want to nail down some simple, but, effective techniques to monitor processing status. My brain just does not handle convoluted script mechanics well. This is much more intuitive.

function wdt { Get-Date -Format "yyyy-MM-dd hh:mm:ss" } # Clearing screen Clear-Host # Set up variables if(Get-Variable hashtable) { Clear-Variable hashtable } $hashtable = @{} $counter = 1 $path = 'C:\testing\powershell\testfiles\largefiletest' $hashtable = @{} $counter = 1 $group = 1 # Creating new files Write-Output "$(wdt) Creating new folder." # Creating new folder New-Item -Path $path -ItemType Directory -Force | Out-Null # Creating new files Write-Output "$(wdt) Creating new files." # Generate test files for ($i=1; $i -le 10000; $i++) { if( -not (Test-Path "$path\$($i.txt)")) { Write-Output "$(wdt) Creating $($i.txt)." New-Item -Path $Path -Name "$i.txt" -ItemType File -Value $i -Force } } # Get file info into variable $files = Get-ChildItem $path | Where-Object {( -not $_.PSIsContainer ) -and ( $_.Extension -eq '.txt' )} | Sort-Object -Property Name # Creating new files Write-Output "$(wdt) Iterate collection." # Group files into sets of 1000 foreach($file in $files) { Write-Output "$(wdt): Processing $($file.Name)." if($counter -le 1000) { if( -not $file.Processed ) { # Add file to hashtable - filename (key) $group (value) $hashtable.Add($file.FullName, $group) # Add NoteProperty to file object $file | Add-Member -MemberType NoteProperty -Name Processed -Value $true # Increment Counter $counter++ } } else { # Increment group $group++ # Reset counter $counter = 1 } } # Output status to screen Write-Output "$(wdt): Sorting hashtable." # Output collection for proof of concept $hashtable.GetEnumerator() | Sort-Object Value, Name | Format-Table -AutoSize

Powershell (v2) - Changing File Extensions on All Files in a Folder

2012-01-11T09:57:00.000-08:00

In a current work project we had a customer send us a ton of .tif images without extensions. After viewing the files binary data, I was able to identify they were in fact .tif files. To add extensions to these files I went searching for a script to help. After some hunting I ran across a PowerTip that got the job done.

Bulk-Changing File Extensions

After hacking the source code to see the full command, I was able to work with it a bit. In my own testing, I came up with this for my own specific needs:

dir | % { Rename-Item $_.FullName ([System.IO.Path]::GetFileNameWithoutExtension($_.fullname) + ".tif")}

By using the [System.IO.Path]::GetFileNameWithoutExtension() method you can simply chop off the extension and add whatever you like.

To suggest another direction this could go: if you wanted to get more elaborate with this, you could add a switch when you are expected specific files with varying extensions. By doing so, you could process a directory once and modify the extensions at once.

Powershell - Project: PoSH Server (Powershell based web server)

2012-01-11T08:45:00.000-08:00

Powershell MVP Yusef Ozturk has been working on a new project call PoSH Server. As noted in his site, PoSH Server is "a secure, flexible and lightweight web server to meet your requirements." When I downloaded the project and examined the files I found a shockingly small set of files. I expected there to be tons of code, and, it's anything but bloated. He gives instructions on how to set it up (very simple) and is actively working on getting it further developed.

Powershell (v2) - Select-Object: -ExpandProperty

2012-01-11T06:36:00.000-08:00

This morning I was looking at an Experts Exchange article which had this command courtesy of Chris Dent,

Get-Acl $Target | Select-Object -ExpandProperty Access | ForEach-Object { $_.IdentityReference.Value } | Get-Unique

As I read through it I wanted to see exactly what this did, so, I went through the command piece by piece. First, I did this:

Get-Acl C:\test

It returned this:

Directory: Microsoft.PowerShell.Core\FileSystem::C:\ Path Owner Access ---- ----- ------ test BUILTIN\Administrators BUILTIN\Administrators Allow FullCo...

Next, I added the | Select-Object access cmdlet to the pipeline. It now showed

Access ------ {System.Security.AccessControl.FileSystemAccessRule, System.Security.AccessControl.FileSystemAccessRule, System.Secu...

Great, I thought, another set of properties. What I didn't realize is that I was going to finally figure out something I should have know months ago: the beauty of -ExpandProperty. When I added this new parameter I saw the light bulb click on:

Get-Acl C:\test | Select-Object -ExpandProperty Access FileSystemRights : FullControl AccessControlType : Allow IdentityReference : BUILTIN\Administrators IsInherited : True InheritanceFlags : None PropagationFlags : None

Using -ExpandProperty iterates through a collection of object members. This only works if you are passing a collection to the Select-Object cmdlet's -ExpandProperty parameter. For instance, the following will still return a single value,

dir C:\test | Select-Object -ExpandProperty Name

because name is a deterministic property with a one-to-one mapping. This is good to know because you can use -ExpandProperty on an object that may have one or more member without fear of it blowing up if it only receives a singleton. So instead of having to create some iteration code to enumeration this collection's members, just use -ExpandProperty.

Powershell (v2) - Create New Folders and Move Files to Folders Based on File Names

2012-01-10T21:20:00.000-08:00

To solve an issue at work with some zip files in a folder, I needed to create new folders based on the .zip file names, then, once the new folders had been created, copy the .zip file to the newly named folder.

foreach($zip in ( Get-ChildItem 'C:\zipfiles' | Where {(-not $_.PSIsContainer) -and (-not $_.PSIsContainer)})) { New-Item -Path (Split-Path $zip.fullname) -Name (Split-Path $zip.fullname -Leaf).ToString().Replace(".zip","") -ItemType Directory Copy-Item -Path $zip.fullname -Destination "$(Split-Path $zip.fullname)\$((Split-Path $zip.fullname -Leaf).ToString().Replace('.zip',''))" }

Above is the script I used to accomplish this. Below is the breakdown of how it works. First, start by gathering a collection of zip file names. The command,

Get-ChildItem 'C:\zipfiles' | Where {(-not $_.PSIsContainer) -and (-not $_.PSIsContainer)}

excludes folders, and, returns only .zip files. The Foreach-Object loop iterates the collection into a variable named $zip. Once the loop starts going over the collection it creates a New-Item, in this case, a Directory, with this command.

New-Item -Path (Split-Path $zip.fullname) -Name (Split-Path $zip.fullname -Leaf).ToString().Replace(".zip","") -ItemType Directory

This command has several parts:

New-Item: creates a new item
-Path: specifies the path to the new object
(Split-Path $zip.fullname): returns the file path the file in the current iteration. In this case, we want the folderpath, not the file name
-Name: Specifies the name of the folder to create
(Split-Path $zip.fullname -Leaf).ToString().Replace(".zip",""): returns to the -Leaf (file name) of the $zip file currently being processed. It then converts the object to a string object, and, replaces .zip with nothing.
-ItemType: Directory specifies the object type to create. In this case, a folder

The second line of the command copies the zip file to the newly named folder,

Copy-Item -Path $zip.fullname -Destination "$(Split-Path $zip.fullname)\$((Split-Path $zip.fullname -Leaf).ToString().Replace('.zip',''))"

and has a similar number of parts:

Copy-Item: copies the item specified by the parameters
-Path: the path to the source object
$zip.fullname: the full path the current object
-Destination: the place the object is being copied to
"$(Split-Path $zip.fullname)\$((Split-Path $zip.fullname -Leaf).ToString().Replace('.zip',''))": this has several parts, so, I'll break them down, one by one:

double quotes: forces the contents to be evaluated. If I had used single quotes, it would be a literal. By using double quotes, Powershell parses the string looking for special characters.
$(Split-Path $zip.fullname): This notation forces the contents, Split-Path $zip.fullname to be evaluated. In this case, we want it to execute to return the path portion of the object $zip.fullname. The way to do this here is $().
As above, Split-Path $zip.fullname returns the path to the current object
\: this simply acts as a way to join the folder path and the file name. Another way to do thing would be to do Join-Path -Path -ChildPath. The \ is automatically inferred between the two objects.
$((Split-Path $zip.fullname -Lead).ToString().Replace('.zip','')): There are, again, several parts. I'll break them down as well.

The $(), again, represents a forced evaulation.
The first part, (Split-Path $zip.fullname -Leaf), similar to what is shown above, returns the file name when you specify the -Leaf switch.
.ToString() allows the .System.String.Replace() method to be called. Otherwise, I would get an error by trying to access a .Replace() method on a File object which does not exist.
.Replace('.zip',''): this causes the file extension, .zip, to be replaced with nothing. If we didn't do this, we'd have folders named after .zip files, instead of, as we want, the folder names to match the file names.

As I indicated earlier, there's a lot packed into this little script. But, it allows a lot to get done with very little work.

Powershell (v2) - IIS : Find Redirects on IIS 7

2012-01-10T20:44:00.000-08:00

While perusing the Technet forums, I saw Marco Shaw reply to a post

List HTTP redirects

indicating a way to locate Redirects in IIS 7 from Experts Exchange,

Powershell or vb script that finds the value in the Redirect To: field in IIS 6?

Within the post, this comment is made,

Get-WmiObject IIsWebVirtualDirSetting -Namespace root\MicrosoftIIsV2 -Filter "HttpRedirect<>''" ` -Authentication PacketPrivacy -Computer TheWebServer | Select-Object Name, HttpRedirect

Yet, when I tried that, simply by changing the computer name, it didn't run.

Get-WmiObject : Invalid namespace At line:1 char:14 + Get-WmiObject <<<< IIsWebVirtualDirSetting -Namespace root\MicrosoftIIsV2 -Filter "HttpRedirect<>''" ` + CategoryInfo : InvalidOperation: (:) [Get-WmiObject], ManagementException + FullyQualifiedErrorId : GetWMIManagementException,Microsoft.PowerShell.Commands.GetWmiObjectCommand

When I decided to look at the namespaces again I found this namespace was not present. As outlined in this post,

WMI Discovery using PowerShell

You can peruse a namespace, in this case, \\Root, to see what's available. To do this, I used this approach at first:

Get-WmiObject -Namespace root -Class __Namespace -Recurse

When I ran this, it returned all of the properties, many of which are simply internal classes (those prefixed with __).

__GENUS : 2 __CLASS : __NAMESPACE __SUPERCLASS : __SystemClass __DYNASTY : __SystemClass __RELPATH : __NAMESPACE.Name="subscription" __PROPERTY_COUNT : 1 __DERIVATION : {__SystemClass} __SERVER : MYSERVER __NAMESPACE : ROOT __PATH : \\ MYSERVER \ROOT:__NAMESPACE.Name="subscription" Name : subscription

After I ran this tweaked command (as outlined in my post on the Win32_Account class) by using the -ExcludeProperty parameter of the Select-Object cmdlet to disregard the system properties.

Get-WmiObject -Namespace root -Class __Namespace -Recurse | select * -ExcludeProperty "__*"

This way I get a lot more info:

Name Scope Path Options ClassPath Properties SystemProperties Qualifiers Site Container

Going back to the Name search I get this list:

Get-WmiObject -Namespace root -Class __Namespace -Recurse | select Name -ExcludeProperty "__*" Name ---- subscription DEFAULT CIMV2 Cli nap MicrosoftNLB SECURITY snmp RSOP WebAdministration WMI directory Policy Interop Hardware ServiceModel Microsoft aspnet

Before anyone else could get an answer, the original poster found their own answer:

$root = "IIS:\Sites\website" $all = get-childitem($root) $all | foreach { $fold_name = $_.name $cur_path = "$root" + "\" + "$fold_name" $enable = (get-webconfigurationproperty -filter /system.webserver/httpRedirect -PSPath "$cur_path"-name enabled).value If ($enable -eq $true) { $dest = (get-webconfigurationproperty -filter /system.webserver/httpRedirect -PSPath "$cur_path"-name destination).value }

Powershell - Using Transcript Cmdlets to Ensure All Host Interaction is Captured

2012-01-09T09:08:00.000-08:00

I can't even count how many times I have worked on something and realized, after I closed a session, "I should have recorded what I did." Either some train of thought could not be reproduced or I simply found something clever and couldn't do it again if I tried. While listening to Ed Wilson on last week's Thursday Powershell session he commented on something which gave me the idea to add something to my $profile to automatically generate logs when the session starts. After thinking about it a bit I came up with this snippet in my AllUsersAllHosts profile:

#region Configure automatic logging for all hosts $logpath = "C:\logs\powershell\$(Get-Date -Format "`yyyyMMdd_hhmmss`").log" if( -not ([System.IO.Directory]::Exists((Split-Path -Path $logpath)))) { New-Item -Path (Split-Path -Path $logpath) -ItemType Directory | Out-Null } Start-Transcript -Path $logpath -Force | Out-null #endregion Configure automatic logging for all hosts

To easily access this file, if it exists, you can use this command from within Powershell:

notepad $profile.AllHostsAllUsers

This will throw notify you if the file does not exist only after you open the file. When you attempt to save it, you are forced to renavigate to the path during the save command. I will write up a little script to automate this as well with a quick check before opening the command. Another nice addition for the $profile management module I'm working on.

EDIT: After I posted some extra details came to mind which should go in the file name. I added the host name (what is running Powershell) annd the username (the account) to the logfile name. This way, it's much easier to track whose logs correspond with which hosts.

$logpath = "C:\logs\powershell\$((Get-Host).Name)_$($env:USERNAME)_$(Get-Date -Format "`yyyyMMdd_hhmmss`").log"

T-SQL - Searching for Wildcard Characters as Literals with LIKE

2012-01-09T08:15:00.000-08:00

If you work with T-SQL long enough you will run into wildcards.

LIKE (Transact-SQL)

Now, wildcards are great. They allow you to find all sorts of things in SQL very easily, with minimal typing, and, work. However, if you want to search against a wildcard, it takes a different approach. This trick came to me via this post,

How do I search for special characters (e.g. %) in SQL Server?

In my case, I was running a search for a field that started with a pound sign, like this, #Report 114. If I ran this query it returned no results,

SELECT * FROM Reports WHERE Name LIKE '#%'

However, if I wrap the character that would normally be interpreted as a wildcard in brackets, [], I can perform the search as if the pound sign is a literal, not a wildcard. It would look like this,

SELECT * FROM Reports WHERE Name LIKE '[#]%'

Powershell (v2) - Getting Module Members

2012-01-07T08:25:00.000-08:00

As I work through some module definitions on my Base.psm1 module I have encountered a few warnings,

PS > Import-Module Base WARNING: Some imported command names include unapproved verbs which might make them less discoverable. Use the Verbose parameter for more detail or type Get-Verb to see the list of approved verbs

To try and figure out which verbs I was having issues with I went to the approved list of verbs and checked out each one to find the offenders using this command to list my basic command set,

PS > Get-Command -Module Base CommandType Name Definition ----------- ---- ---------- Function Add-NetworkingHostsEntry ... Function Copy-IOFile ... Function Copy-IOFolder ... Function Create-IISAppPool ... Function Create-IOFile ... Function Create-IOFolder ... Alias ifum Import-UtilityModules Function Import-UtilityModules ... Function Remove-IOFile ... Function Remove-IOFolder ... Function Test-IISAppPoolExists ... Function Test-IISAppPoolIsStarted ... Function Test-IOFileExists ... Function Test-IOFolderExists ... Function Validate-IISWebApplication ... Alias wfudt Write-UtilityDateTime Function Write-UtilityDateTime ...

Once I had my command set I was able to check each verb out.

PS > get-verb create PS > get-verb import Verb Group ---- ----- Import Data PS > get-verb test Verb Group ---- ----- Test Diagnostic PS > get-verb validate PS > get-verb write Verb Group ---- ----- Write Communications

To automate this further, I used this approach:

# Clear screen cls # Variables $validatedverbs = @{}; # Gather verbs $verbs = Get-Command -Module Base -CommandType Function | ` ForEach-Object { $_.Name.ToString().Split("-")[0] } | ` Select-Object -Unique; # Test verbs for validity foreach($verb in $verbs) { if((Get-Verb -verb $verb) -eq $null) { $validatedverbs.Add($verb, $false); } else { $validatedverbs.Add($verb, $true); } } $validatedverbs.GetEnumerator() | Sort-Object -Property Key

When I run it I get this clear list of what functions are not on the common verb list,

Name Value ---- ----- Add True Copy True Create False Import True Remove True Test True Validate False Wacky False Write True

Powershell (v2) - Parameter Aliases

2012-01-07T00:21:00.000-08:00

To help speed things up when working with functions you can alias long, unwieldy, or, just plain painful Parameter names. Accomplishing this can be as simple as adding,

[Alias("youralias")]

to your function param definition. For example, I am adding a parameter named "t" to my function test below:

function Test { param( [Alias("t")] $test ) return $test; } Test -T 1

When I run this I simply get back 1.

Powershell (v2) - Remove-Item (Passing Collections to Cmdlet)

2012-01-06T09:47:00.000-08:00

After working to get some quick file generation script, I added on this one to delete files quickly as a collection:

$files = dir .; $files | Remove-Item

I noted on Twitter that a cool hack would be doing something like this:

$files = dir .; $files.Remove()

Or, to shorten it up even more:

(dir .).Remove();

Ah, the power of imagination.

Powershell (v2) - Get-WmiObject: Get Class Definitions

2012-01-06T08:20:00.000-08:00

My past exploits have led me to become much more familiar with WMI than I had ever hoped to be. As a result, I know how to get around the information provided by WMI pretty well. Yet, this morning, I needed to figure out how large a given field for the Win32_LogicalDisk Description property could be and wasn't quite sure how to do it with Powershell. I tried a few approaches (listed below), but, none of them worked. You can walk through each to see what it returned as an exercise:

Get-WmiObject -Class Win32_LogicalDisk | select *
Get-WmiObject -Class Win32_LogicalDisk | Get-Member
Get-WmiObject -Class Win32_LogicalDisk | Get-Member | select *
Get-WmiObject -Class Win32_LogicalDisk | Get-Member | select * | ft -auto
Get-WmiObject -Class Win32_LogicalDisk | Get-Member | select * | Format-Wide
Get-WmiObject -list win32_logicaldisk
Get-WmiObject -class Win32_LogicalDisk | Get-Member -name Description
Get-WmiObject -class Win32_LogicalDisk | Get-Member -name Description | select *

At this point I decided to go a different route and look at the class definition itself. This link,

http://www.codeproject.com/KB/system/WQLByExample.aspx

helped me get the right query to figure out how to do that. The meta_class object had escaped memory. Once I had the appropriate reference

Get-WmiObject -Query "select * from meta_class where __Class = 'Win32_LogicalDisk'"

As noted in the article,

Schema queries are used to get information about WMI itself and its structure.

To illustrate how to use this, the author gives and example,

Select * From Meta_Class

and explains,

This is the most basic schema query. You can connect to any WMI namespace and use this query to get all the classes present in it. Meta_Class is a meta class used only in schema queries.

There are several other directions I could go with this, but, I don't want to get too far off into WMI details. When you run the query listed above to gather __Class details for Win32_LogicalDisk it returns specific properties and class definitions for each property. Here is my walkthrough to get the specific properties and their definitions:

PS > Get-WmiObject -Query "select * from meta_class where __Class = 'Win32_LogicalDisk'" NameSpace: ROOT\cimv2 Name Methods Properties ---- ------- ---------- Win32_LogicalDisk {SetPowerState, R... {Access, Availability, BlockSize, Caption...} PS > $Win32_LogicalDisk = Get-WmiObject -Query "select * from meta_class where __Class = 'Win32_LogicalDisk'" PS > $Win32_LogicalDisk.__CLASS Win32_LogicalDisk PS > $Win32_LogicalDisk | % {$_} NameSpace: ROOT\cimv2 Name Methods Properties ---- ------- ---------- Win32_LogicalDisk {SetPowerState, R... {Access, Availability, BlockSize, Caption...} PS > $Win32_LogicalDisk | % {$_.Properties} Name : Access Value : Type : UInt16 IsLocal : False IsArray : False Origin : CIM_StorageExtent Qualifiers : {CIMTYPE, read} Name : Availability Value : Type : UInt16 IsLocal : False IsArray : False Origin : CIM_LogicalDevice Qualifiers : {CIMTYPE, MappingStrings, read, ValueMap} Name : BlockSize Value : Type : UInt64 IsLocal : False IsArray : False Origin : CIM_StorageExtent Qualifiers : {CIMTYPE, MappingStrings, read} Name : Caption Value : Type : String IsLocal : False IsArray : False Origin : CIM_ManagedSystemElement Qualifiers : {CIMTYPE, MaxLen, read} Name : Compressed Value : Type : Boolean IsLocal : True IsArray : False Origin : Win32_LogicalDisk Qualifiers : {CIMTYPE, MappingStrings, read} Name : ConfigManagerErrorCode Value : Type : UInt32 IsLocal : False IsArray : False Origin : CIM_LogicalDevice Qualifiers : {CIMTYPE, read, ValueMap} Name : ConfigManagerUserConfig Value : Type : Boolean IsLocal : False IsArray : False Origin : CIM_LogicalDevice Qualifiers : {CIMTYPE, read} Name : CreationClassName Value : Type : String IsLocal : False IsArray : False Origin : CIM_LogicalDevice Qualifiers : {CIM_Key, CIMTYPE, read} Name : Description Value : Type : String IsLocal : False IsArray : False Origin : CIM_ManagedSystemElement Qualifiers : {CIMTYPE, read} Name : DeviceID Value : Type : String IsLocal : False IsArray : False Origin : CIM_LogicalDevice Qualifiers : {CIM_Key, CIMTYPE, key, MappingStrings...} Name : DriveType Value : Type : UInt32 IsLocal : True IsArray : False Origin : Win32_LogicalDisk Qualifiers : {CIMTYPE, MappingStrings, read} Name : ErrorCleared Value : Type : Boolean IsLocal : False IsArray : False Origin : CIM_LogicalDevice Qualifiers : {CIMTYPE, read} Name : ErrorDescription Value : Type : String IsLocal : False IsArray : False Origin : CIM_LogicalDevice Qualifiers : {CIMTYPE, read} Name : ErrorMethodology Value : Type : String IsLocal : False IsArray : False Origin : CIM_StorageExtent Qualifiers : {CIMTYPE, read} Name : FileSystem Value : Type : String IsLocal : True IsArray : False Origin : Win32_LogicalDisk Qualifiers : {CIMTYPE, MappingStrings, read} Name : FreeSpace Value : Type : UInt64 IsLocal : False IsArray : False Origin : CIM_LogicalDisk Qualifiers : {CIMTYPE, read} Name : InstallDate Value : Type : DateTime IsLocal : False IsArray : False Origin : CIM_ManagedSystemElement Qualifiers : {CIMTYPE, MappingStrings, read} Name : LastErrorCode Value : Type : UInt32 IsLocal : False IsArray : False Origin : CIM_LogicalDevice Qualifiers : {CIMTYPE, read} Name : MaximumComponentLength Value : Type : UInt32 IsLocal : True IsArray : False Origin : Win32_LogicalDisk Qualifiers : {CIMTYPE, MappingStrings, read} Name : MediaType Value : Type : UInt32 IsLocal : True IsArray : False Origin : Win32_LogicalDisk Qualifiers : {CIMTYPE, MappingStrings, read} Name : Name Value : Type : String IsLocal : False IsArray : False Origin : CIM_ManagedSystemElement Qualifiers : {CIMTYPE, read} Name : NumberOfBlocks Value : Type : UInt64 IsLocal : False IsArray : False Origin : CIM_StorageExtent Qualifiers : {CIMTYPE, MappingStrings} Name : PNPDeviceID Value : Type : String IsLocal : False IsArray : False Origin : CIM_LogicalDevice Qualifiers : {CIMTYPE, read} Name : PowerManagementCapabilities Value : Type : UInt16 IsLocal : False IsArray : True Origin : CIM_LogicalDevice Qualifiers : {CIMTYPE, read} Name : PowerManagementSupported Value : Type : Boolean IsLocal : False IsArray : False Origin : CIM_LogicalDevice Qualifiers : {CIMTYPE, read} Name : ProviderName Value : Type : String IsLocal : True IsArray : False Origin : Win32_LogicalDisk Qualifiers : {CIMTYPE, MappingStrings, read} Name : Purpose Value : Type : String IsLocal : False IsArray : False Origin : CIM_StorageExtent Qualifiers : {CIMTYPE, read} Name : QuotasDisabled Value : Type : Boolean IsLocal : True IsArray : False Origin : Win32_LogicalDisk Qualifiers : {CIMTYPE, read} Name : QuotasIncomplete Value : Type : Boolean IsLocal : True IsArray : False Origin : Win32_LogicalDisk Qualifiers : {CIMTYPE, read} Name : QuotasRebuilding Value : Type : Boolean IsLocal : True IsArray : False Origin : Win32_LogicalDisk Qualifiers : {CIMTYPE, read} Name : Size Value : Type : UInt64 IsLocal : False IsArray : False Origin : CIM_LogicalDisk Qualifiers : {CIMTYPE, read} Name : Status Value : Type : String IsLocal : False IsArray : False Origin : CIM_ManagedSystemElement Qualifiers : {CIMTYPE, MaxLen, read, ValueMap} Name : StatusInfo Value : Type : UInt16 IsLocal : False IsArray : False Origin : CIM_LogicalDevice Qualifiers : {CIMTYPE, MappingStrings, read, ValueMap} Name : SupportsDiskQuotas Value : Type : Boolean IsLocal : True IsArray : False Origin : Win32_LogicalDisk Qualifiers : {CIMTYPE, read} Name : SupportsFileBasedCompression Value : Type : Boolean IsLocal : True IsArray : False Origin : Win32_LogicalDisk Qualifiers : {CIMTYPE, MappingStrings, read} Name : SystemCreationClassName Value : Type : String IsLocal : False IsArray : False Origin : CIM_LogicalDevice Qualifiers : {CIM_Key, CIMTYPE, Propagated, read} Name : SystemName Value : Type : String IsLocal : False IsArray : False Origin : CIM_LogicalDevice Qualifiers : {CIM_Key, CIMTYPE, Propagated, read} Name : VolumeDirty Value : Type : Boolean IsLocal : True IsArray : False Origin : Win32_LogicalDisk Qualifiers : {CIMTYPE, MappingStrings, read} Name : VolumeName Value : Type : String IsLocal : True IsArray : False Origin : Win32_LogicalDisk Qualifiers : {CIMTYPE, MappingStrings, read, write} Name : VolumeSerialNumber Value : Type : String IsLocal : True IsArray : False Origin : Win32_LogicalDisk Qualifiers : {CIMTYPE, MappingStrings, read}

Powershell (v2) - Quick File/Folder Generation

2012-01-05T21:51:00.000-08:00

Problem: how do I quickly create bulk folders and/or files?

Quick Answer: use a for loop to repeat New-Item and specify whether you want File or Directory in the New-Item call.

Long Answer: I often am in a hurry, and, to test things, don't have time to go create dummy files (or folders) for validation some data management script. To quickly generate 100 files use this approach,

$path = "C:\testing\powershell\testfiles" if((Test-Path $path) -ne $true) { for($i=1;$i -le 100;$i++) { New-Item -Path $path -Name "$i.txt" -ItemType File -Value $i -Force } }

This script will generate 100 files in just a few seconds, where each file has a numeric name (with .txt extension) and the value in the .txt file matches the name. I use this in a pinch to have something I can manipulation where the test is really more about the file/folder management than the file content. In short, I just need something, nothing really, to work with.

To take this one step further, I wrote the following script to test out some folder/file management logic which I perfected in a post I made earlier today,

$path = "C:\testing\powershell\testfiles" if((Test-Path $path) -ne $true) { for($i=1;$i -le 100;$i++) { New-Item -Path $path -Name "$i.txt" -ItemType File -Value $i -Force } } # Split files into subdirectories $files = Get-ChildItem -Path $path | Where-Object {$_.PSIsContainer -ne $true}; for($i = 1; $i -lt (($files).Count); $i++) { $minifileset = $files | Select-Object -First 10; $newpath = $files.fullname; New-Item -Path $newpath -Name $i -ItemType Container -Force; foreach($file in $minifileset) { move $file.fullname "$newpath\$i" } }

The link I posted earlier can be found here,

Splitting up very large file sets into subfolders