Hallo Community,

um den lieben Hackern dieser Welt ein wenig entgegen zu setzten,
werde ich die Site am kommenden Wochenende aktualisieren.
Deshalb wird es am Samstag und am Sonntag (04. – 05.09.2010)
zeitweilig nicht möglich sein, die Seite zu nutzen.

Ab Montag sollte dann alles wieder wie gewohnt funktionieren.

Bitte schreibt mir eine Mail, falls ihr etwas findet, dass nach dem Update nicht funktioniert.

Danke und happy scripting
Rolf

Although Newspapers of the physically printed variety are dying all around us, the metaphor that is a newspaper fails to die. I’ve been playing a bit today with Paper.Li – one of those hundreds of sites that leverage Twitter and add value to your Twitter stream. I’ve created my own 'newspaper’ - http://paper.li/doctordns. This page is updated once every 24 hours and features links that Paper.Li has gleaned from my twitter feed.  It’s nicely laid out and features my own tweets, plus tabs I follow. In my case, the paper also includes tweets with the hash-tag #PowerShell. I’m kind of surprised I don’t see more Grateful Dead links, but we’ll see.

The papers that you can create with Paper.Li are one of three broad types: You and your tweet stream, hash tag, @people. The first is the model I noted above – Paper.Li parses your tweet feed/stream (tweets you get from those you follow and those you make) and makes a paper. The second makes the newspaper from tweets containing a particular hash tag. For example, the PowerShell hash tag is #PowerShell, and there’s a related newspaper  http://paper.li/tag/PowerShell.  The @people paper is based on a list of folks you create on Twitter. http://paper.li/jkavanagh58/powershell, for example, is a paper based on @jkavanagh58’s PowerShell twitter list.

(Get-QADUser -Identity FatBeard).employeeID

One might expect this to return the employeeID for Mr. FatBeard.  It doesn't and this is a desired behavior.  In order to maximize performance, the Quest cmdlets return a default list of attributes.  To see non-default attributes you have a few options:

- Use the -IncludeAllProperties parameter.  This will store ALL the attributes in the memory cache.

- Use the -IncludedProperties parameter.  For ad-hoc reporting, when all that is needed are a few attributes, this is the recommended way.
Get-QADUser -Identity FatBeard -IncludedProperties employeeID,logonCount | Select employeeID, logoncount

- Lastly, you can modify the default attributes that are returned.
$attributes = Get-QADPSSnapinSettings -DefaultOutputPropertiesForUserObject

$attributes += 'employeeID'

Set-QADPSSnapinSettings -DefaultOutputPropertiesForUserObject $attributes

(Get-QADUser -Identity FatBeard).employeeID #Success!

John Fullbright from NetApp

News

Execute commands and scripts from anywhere including the office and remote locations, as well as from a Web browser or smart phone with PowerGUI Pro from Quest Software. With the MobileShell feature, administrators can quickly run commands to troubleshoot problems or make changes, even when away from your desk! This gives teams more flexibility to work remotely while traveling, and to leverage admins from other offices in case of an emergency.

·         Execute queries remotely to determine if services or processes are running

·         Restart services, processes, or entire servers

·         Check mailbox settings

·         Unlock user accounts

·         Reset passwords

·         Run custom scripts

Visit quest.com/powerguipro and see why PowerShell and Quest PowerGUI are the ultimate Windows management tools.

• Bruce Payette says Windows PowerShell in Action, 2nd ed is almost finished
• Jeff Hicks did a video interview with TrainSignal at TechEd
• PowerShell user group meetings
  • 9/8/2010 - Syracuse - Upstate New York PowerShell User Group
  • Twin Cities - first meeting 10/12/2010
  • Tampa - 9/9/2010 - Moving Exchange 2007 Mailboxes

Interview

This segment is brought to you by SAPIEN Technologies.

Links

• Data ONTAP PowerShell toolkit
• Get started with POSH4ONTAP
• Create Visio diagram of your storage
• NetApp for Microsoft Environments blog

Notable Comments from the Chatroom

## Will the powershell toolkit do what perfstat does?

## What is planned for the 1.2 update?

• A cool script from Thomas Lee to get broken hardware
• Joel Bennett helps us understand scope
• Don Jones tells us what VBScripters must forget in PowerShell

Tips

• Fun Tricks with Format-Table and Select

I'm certified ;-)

I found the time to sit two of the betas and finish off the other two last week.

They were sensible exams, no stupidly esoteric questions and a fair test of your knowledge.

For today only, O’Reilly is offering the electronic version of the Windows PowerShell Cookbook for only $9.99. This gives you unrestricted access to DRM-free PDF, MOBI (Kindle, etc) and ePub versions of the book.

If you have an iDevice, the Stanza book reader (among several others) supports both the PDF and ePub file formats.

Get it while it’s hot!

Use code DDWPC http://oreil.ly/cFRco0

Introduction

I recently posted lists of links to Photoshop and CodeIgniter tutorials. I wrote a PowerShell script that takes a text file with URLs as input and creates the html for my blog post from it.

Example

For example the input URL looks like this:

http://net.tutsplus.com/tutorials/php/codeigniter-from-scratch-day-8-ajax/

The output looks like this.

Codeigniter from scratch day 8 ajax

The PowerShell script

The script parses the URL and generates the title of the anchor element with simple string operations.

$URLs = Get-Content -Path "CodeIgniterTutorialUrls.txt"

function Get-HTML($URL)
{ 
    $Result = $URL.Replace('-', ' ');
    $Result = $Result -replace  '/$', ''    
    $Result = $Result.Substring($Result.LastIndexOf('/') + 1)
    $FirstLetter = $Result[0].ToString().ToUpper();
    $Text = $FirstLetter + $Result.Substring(1);
    $HTML = '{1}
' -f $URL, $Text
    return $HTML   
}

Set-Content -Path "LinkHtml.txt" -Value "Links"

foreach($URL in $URLS)
{
    $HTML = Get-HTML $URL
    Add-Content -Path "LinkHtml.txt" -Value $HTML
    $HTML
}

Download

The script and sample data can be downloaded here: URLToHtml.zip

Ausblick

As always PowerShell is the Swiss Army Knife of Windows Cowboys :-).

Ungureanasu and Thomas Lee on Office Communications Server

On Friday, we wrapped up the final details of the PowerShell Cookbook, V2. O’Reilly has already made the electronic edition available, which is a great resource for searching, copying, pasting, and working with the content in its native form. If you or your company subscribes to Safari, it should be available shortly.

If you’re a fan of the printed version, it's off to the printers now, and has a scheduled "in-stock" date of 8/24: the date when it'll be in boxes in the shipping / receiving area of book stores. It takes about a week for books to migrate onto shelves, so the official "when can I get it" date is 8/31.

It's almost 900 pages now, despite my best efforts to keep it svelte :) I dropped the chapters on Exchange and MOM (since there are dedicated books and support materials for those now), and dropped a few appendixes that are now covered much more effectively in the in-box help. Since much of the V1 book is about filling "missing pieces" from V1, and we filled tons of "missing pieces" from V1, much of the new content directly replaced recipes that existed in the V1 book.

Dropping the chapters on Exchange and MOM was also done in response to feedback. While they provided cursory coverage of the technologies, they were intended primarily to introduce Admins to the wider PowerShell ecosystem. Now that there are entire books written to cover PowerShell-based products (i.e.: VMWare, Exchange, MOM, etc), the Cookbook can now focus on the core technology. Aside from the Exchange / MOM updates, the "Description" sections of many recipes have been beefed up in response to feedback. Most go into significantly more detail, or discuss more of the underpinnings of the recipe or what it covers.

And then, of course, there's the "new stuff". The book now has about 430 recipes, almost double what the first version had. It's sometimes easy to forget how transformative PowerShell V2 is, but it consisted of over two thousand source code checkins!

All-told, the second edition took about 560 hours. That's a lot, but what surprised me is that it ended up being only about an hour per print-ready page: including research, drafts, reviews, copy editing, and everything else wrapped in the project.

If you liked the first version of the PowerShell Cookbook, you’ll like this version even more :)

# Download the text file and create the array            
$web = New-Object System.Net.WebClient           
$url = "http://projecteuler.net/project/words.txt"           
$words = $web.DownloadString($url).replace("""","").split(",")           
          
# Generate a list of Triangular numbers           
[int[]]$triNums = @()           
for($r=1;$r -lt 500; $r++) {           
   $triNums += $r*($r+1)/2           
}           
          
# Create a hashtable for numeric lookup           
$lookup = @{}           
$i=1           
65..90 | Foreach {$lookup.add([Char]$_,$i++)}           
          
# Get the numeric value of a word           
function Get-WordValue($word) {           
$letters = $word.ToCharArray()           
$sum = 0           
foreach ($letter in $letters) {           
 $sum += $lookup[[char]$letter]           
}           
return $sum           
}           
          
# Count the Triangular words           
$Count = 0           
foreach ($word in $words) {           
if($triNums -contains (Get-WordValue $word)) {           
 #"{0}`t{1}" -f (Get-WordValue $word), $word           
       $Count++           
}            
}           
$count

Last post there was a question on how to upgrade From the previous version of PowerTab Jason already answered in the comments.

As I also had this planned as start of this series I explain a bit more, while I’m installing the new current version PowerTab 0.99.5.

To startup the PowerTab V1 installation added this block to the Profile ( Tip use ii $profile to open your profile)

:

################ Start of PowerTab Initialisatie Code ########################
#
#  added to Profile by PowerTab Setup For Loading of Custom TabExpansion,
#
# /\/\o\/\/ 2007
#
# http://ThePowerShellGuy.com
#

# Initialize PowerTab

& 'C:\Powertab\Init-TabExpansion.ps1' `

         -ConfigurationLocation 'C:\Users\morsouw.WW\Documents\WindowsPowerShell'

################ End of PowerTab Initialisatie Code ##########################

To disable PowerTab V1 we just remark out, to clean up a bit but keep the old version available I changed it like this :

# Old PowerTab

#& 'C:\Powertab\Init-TabExpansion.ps1' `
#     -ConfigurationLocation 'C:\Users\morsouw.WW\Documents\WindowsPowerShell'

Then we are ready to install, from here it is the same as the normal installation

I downloaded PowerTab-0.99.5.1.zip from http://powertab.codeplex.com/ and

* Important *

unblocked the ZIP file by right clicking it in Explorer –> properties –> Unblock

and extracted it, in the Zipfile there is a folder named PowerTab that you have to copy in your modules directory *documents\WindowsPowerShell\Modules.

tip you can easy open by using ii ( Split-Path $profile )

After that the installation is as simple as importing the module :

Import-Module powertab

Then the setup wizard will start (in 0.99.5 you can get the error The term 'Parse-Manifest' is not recognized as the name of a cmdlet, function, script file, or operable program, this can safely be ignored and will be fixed in next build) and create configuration file,( the working is described in the Documentation on Codeplex here Creating a Configuration File )

This setup still looks like the old setup and the easies way to configure Powertab is just hit enter till you see :

PowerTab version 0.99.5.1 PowerShell TabExpansion Library
Host: ConsoleHost
PowerTab Enabled: True

And ready !

* Update * It can be that the setup is not updating the profile, as can be seen in the setupinfo, a command like this will be added to the profile :

Import-Module "PowerTab" -ArgumentList "C:\Users\morsouw.WW\Documents\WindowsPowerShell\PowerTabConfig.xml"

 For now you have to copy that from the console into your profile by hand, of course in later version the setup will do this

But if you follow the setup information you find out that there is an extra option to store the Powertab config and database in Isolated Storage

Where should the PowerTab configuration file and database be saved?
Any existing PowerTab configuration will be overwritten.
[P] Profile Directory  [I] Installation Directory  [A] Application Data Directory  [S] Isolated Storage
[O] Other Directory[?] Help (default is "P"):

Detail information about the PowerTab configuration you can find here :

http://powertab.codeplex.com/documentation

a good place to start next.

and to see what functions are added by PowerTab V2 type :

Get-Command -Module powertab

Powertab V2 up and running, hence target of this post reached, more about the usage of PowerTab in the next part of this series, till then, when your new to PowerTab,  just hit Tab every time you think you might need completion and most of the time it will work ;)

And else take a look at the posts about Posts about PowerTab for PowerShell V1 on my blog, everything there still works (or is improved)

More about what is new in next post

Enjoy,

Greetings MOW

Just over 2 years ago, I created a new blog, The PowerShell Scripts blog over at http://pshscripts.blogspot.com. The idea was simple – a blog with single function PowerShell scripts. Scripts that demonstrated one (or at least a very small number) of things to do with PowerShell. I had in mind that since the blog was hosted by Google, they’d do a good job of indexing it, and providing links to it. Which is exactly what happened.

In the two years, I’ve had over 65,000 visitors to the blog. At present, I’m getting around 170 hits per day and just under 300 page hits per day on average over a week. However, this is very much a week day blog with Monday-Friday tending to be closer to 200+ hits/day during the week.

But the interesting, and gratifying, thing is the percentage of hits coming from the key search engines (Google and more recently Bing) and the search terms they are using. I’ve used a free traffic counter from sitemeter to measure the traffic, but I only see the last 1000 visitors and had not added a more permanent tracking system – but I’ve recently added Google Analytics the site. So far, the results from both sites show the same tends.

Looking at the Analytic's output for the past month. around 70% of all the traffic to the blog comes from Google and Bing with a bit more from PowerShell.com, TechNet and this blog. There are a few other search engines that send traffic, but Google and Bing are dominant.  Also, around 13% of the traffic comes from direct hits on http://pshscripts.blogspot.com. 

Looking at the search terms used is also interesting. PowerShell Scripts (and PowerShell script) make up 18% or all hits. Below those two, there’s a very long tail of relatively low numbers of hits over the past month. There were just around 1000 separate search terms used – and all but a handful more than once or twice. That shows that the narrow focus of each post has proven useful – you can search with a fairly narrow term, such as “PowerShell ipaddress wmi” or “powershell send udp” and see the blog at the top or near the top of the 1st page.

There were two discoveries that were curious. First, looking at the referring sites, I noticed one site had a relatively high number of pages per visit and a long time too on average time on site. The bounce rate for this traffic was also very very low. It turns out that an IT professor in Viet Nam has put a link to my blog and all the slides from the upcoming PowerShell V2 class. Not sure about the legality of putting the slides up – but see for yourself at http://hoanguyen40.ecoles.officelive.com/OSScripting.aspx.

The other amusing thing I found is that, when looking at the networks that send you traffic (think ISP). The top network listed was Microsoft!

All in all, a good first two years for this blog – getting several hundred hits a day is more than I expected.

After a long silence, a grand new version of PowerTab is there !

With thanks to Jason Archer who took up the job and converted PowerTab to a PowerShell V2 Module.

Next to that, he fixed the issues with PowerTab on V2.0 and made some fabulous additions to PowerTab too !

You can find PowerTab on Codeplex now : http://powertab.codeplex.com/

I’m using Jason’s version for the last weeks and do not want to go back, as some very annoying issues with PowerTab on V2.0 are fixed and I really love the new functionality, so if you are a PowerTab user and are on PowerShell V2.0, I recommend to upgrade as soon as possible to this new version, it is still in Beta and testers are wanted ( please use issue tracker on CodePlex to provide bug reports or other input), but it is much better already as my old version and everything works the same or better, hence also for normal daily usage I recommend :

Upgrade as soon as Possible ! 

Jason did an amazing Job.

I will follow up with a series about using PowerTab and the new features.

Enjoy,

Greetings /\/\o\/\/

Write your own PowerShell provider using only script, no C# required. Module definition is provided by a Windows PowerShell 2.0 Module, which may be pure script, binary or a mix of both.

Debugging is as easy as any ordinary ps1 script file:

All functions in backing module reflect the same signature as those found on MSDN. This means that you go to MSDN documentation on providers to learn about how to write the corresponding script.

Current Release PSProvider 0.4

Samples and Templates

• See Documentation

Roadmap

0.1

• ContainerCmdletProvider support through "ModuleBoundProvider" provider
• Demo provider included navigating a Hashtable
• Can be debugged in the debugger of your choice: console, ISE, PowerGUI.

0.2

• NavigationCmdletProvider support
• Providers rename to ContainerScriptProvider and TreeScriptProvider
• Container Sample & Tree Template modules
• Supports: Clear-Item, Copy-Item, Get-Item, Invoke-Item, Move-Item, New-Item, Remove-Item, Rename-Item, Set-Item

0.3

• IContentCmdletProvider support
• New Commands: New-ContentReader, New-ContentWriter implement IContentReader, IContentWriter
• Adds support for: Add-Content, Clear-Content, Get-Content, Set-Content

0.4 (Current Release)

• IPropertyCmdletProvider support
• Adds support for: Clear-ItemProperty, Copy-ItemProperty, Get-ItemProperty, Move-ItemProperty, New-ItemProperty, Remove-ItemProperty, Rename-ItemProperty, Set-ItemProperty

0.5

• Dynamic Parameter support

0.6

• Security Interfaces
• Adds support for: Get-ACL, Set-ACL

http://psprovider.codeplex.com/

Although I’m quite busy, I try to find time to try out new products when I can.  I’m especially excited when I can try out one of these new programs to help resolve a problem I’m having.

I don’t have any kind of personal script versioning setup, so finding what has changed from one version of one of my scripts to the next can depend on whether I’ve added change comments in my scripts.  In this particular case, I didn’t have any comments.  What to do?

Fortunately, I have access to Sapien’s PrimalMerge product, and could very quickly and easily see what the changes were between my 2 scripts.

It saved me big time in this case!

I’ve always been annoyed by my home server backup. It always starts when I start the PC and then it eats a lot of resources. I often either postpone the backup or change its priority to low which more importantly reduces the IO priority to low as well.

But why not automate the latter?

And that is easy:

• Start Event Viewer
• Find HomeBackup event 768 in the Application log
• Right-click specifying attach task to event
• Follow the wizard, specify powershell.exe as program and ‘-noprofile c:\IdleBackupEngine.ps1’ as argument.
• At the end of the wizard, select to open properties afterwards and change the task to use SYSTEM with highest privileges enabled
• Finally, create c:\IdleBackupEngine.ps1. It only contains a single line: (gps backupengine).priorityclass="idle"

Have fun – working *during* the backup

The Problem

This one cost me some hair. I had to write a script that would pass parameters to a .NET console application. The application used a command line parsing framework that uses the following notation:

/Parameter1:”Some string value” /Parameter2:”Some other value” etc.

An example command line would look like this:

ocp /in:”c:\my folder\my csv file.csv /out:”c:\my folder\the result.csv”

The following code snippets show a history of attempts. I created a simple application for debugging the command parameters that get passed by PowerShell. The application is called OCP (Output Command Line Parameters). The source code for this utility is attached together with the PowerShell script.

Try And Error

cd "C:\Users\Klaus\Documents\Visual Studio 2010\Projects\OCP\OCP\bin\Debug"

#Passes three arguments to OCP (expected)
./OCP this and that
#+++OUTPUT+++
#OCP-Parameter 
#OCP-Parameter 
#OCP-Parameter 

#I would expect one argument to be passed to OCP, but because of the two spaces in 
#the excaped string I am getting 3 arguments
./OCP "/in:`"C:\My Test\Your Input.csv`""
#+++OUTPUT+++
#OCP-Parameter 
#OCP-Parameter 
#OCP-Parameter 

#This one seems to work, but using the same command in CMD causes the split into 3 arguments again
./OCP "/in:C:\My Test\Your Input.csv"
#+++OUTPUT+++
#OCP-Parameter 

$p = '"this and that"', "other"
./OCP $p
#+++OUTPUT+++
#OCP-Parameter 
#OCP-Parameter 

#Works as needed
$p = '/in:C:\My Test\Your Input.csv', "other"
./OCP $p
#+++OUTPUT+++
#OCP-Parameter 
#OCP-Parameter 

#Doesn't work as expected
$p = '/in:"C:\My Test\Your Input.csv"', "other"
./OCP $p
#+++OUTPUT+++
#OCP-Parameter 
#OCP-Parameter 
#OCP-Parameter 
#OCP-Parameter 


#Using start-process finally solved my problem completely
$result = start-process -filePath "C:\Users\Klaus\Documents\Visual Studio 2010\Projects\OCP\OCP\bin\Debug\ocp" -ArgumentList "/in:`"C:\My Test\Your Input.csv`"", "Other" -NoNewWindow -RedirectStandardError "error.txt" -RedirectStandardOutput "output.txt" -wait -passthru

$result.HasExited
$result.ExitCode

$output = get-content "output.txt"
$output
#+++OUTPUT+++
#OCP-Parameter 
#OCP-Parameter 

$ErrorMessage = get-content "error.txt"
$ErrorMessage

The Solution

Using the Start-Process command let finally provided the correct and expected results. In the process of getting to this result I used temporarily the following workaround: I converted the long file names with spaces into short DOS 8.3 file names.

Download

The command line parameter debugging console application and the test script can be downloaded here: PowerShellStartProcessStringCmdlineParamet ers.zip

Ausblick

I am pretty sure that the command line parsing and passing system in PowerShell has a bug.

The TFPT PowerShell snapin is a nice start but it is missing a key cmdlet IMO and that is Get-TfsPermission.  Since TFS allows you to add individual users all over your directory structure, it can be quite hard rationalizing exactly who has access to what without traversing a bunch of directories in the Team Foundation client’s Source Control window, opening the Properties dialog and inspecting the Security settings.  Fortunately there is also a command line way to do this via TFS’s tf.exe utility.  Unfortunately the output of this command is just text and what’s worse is that this text is a pain to query over using PowerShell’s built-in querying cmdlets.  So I wrote the following function to convert this text into objects which enables easier querying:

<#
.SYNOPSIS
    Gets the Team Foundation server permissions for items based on the specified paths.
.DESCRIPTION
    Gets the Team Foundation server permissions for items based on the specified paths and outputs rich
    objects as opposed to text.
.PARAMETER Path
    The path to the Team Foundation server item.
.PARAMETER LiteralPath
    Specifies a path to one or more locations. Unlike Path, the value of LiteralPath is used exactly as it
    is typed. No characters are interpreted as wildcards. If the path includes escape characters, enclose
    it in single quotation marks. Single quotation marks tell Windows PowerShell not to interpret any
    characters as escape sequences.
.PARAMETER Recurse
    Gets permissions for the items at the specified location and in all child locations.
.EXAMPLE
    C:\PS> Get-TfsPermission C:\Tfs\Acme\Branches\Release\3.7 | Select ServerItem -exp Identities
    Get the permissions for the specified folder and expands the Identities array to show each identity.
    The server item corresponding to each identity object is tagged onto the object.
.EXAMPLE
    C:\PS> Get-TfsPermission C:\Tfs\Acme | Select ServerItem -expand Identities | Where {$_.Allow -match 'Checkin' } | Format-List ServerItem,Identity,Allow,Deny   
    This command looks for items where the 'checkin' privilege has been granted locally.
.NOTES
    Author: Keith Hill
    Date:   June 28, 2010   
#>
function Get-TfsPermission
{
    [CmdletBinding(DefaultParameterSetName="Path")]
    param(
        [Parameter(Mandatory=$true, Position=0, ParameterSetName="Path",
                   ValueFromPipeline=$true, ValueFromPipelineByPropertyName=$true,
                   HelpMessage="Path to workspace item")]
        [ValidateNotNullOrEmpty()]
        [string[]]
        $Path,
       
        [Alias("PSPath")]
        [Parameter(Mandatory=$true, Position=0, ParameterSetName="LiteralPath",
                   ValueFromPipelineByPropertyName=$true,
                   HelpMessage="Path to workspace item")]
        [ValidateNotNullOrEmpty()]
        [string[]]
        $LiteralPath,
       
        [Parameter()]
        [switch]
        $Recurse
    )

    Begin
    {
        Set-StrictMode -Version Latest
        $item = $null
    }

    Process
    {
        if ($psCmdlet.ParameterSetName -eq "Path")
        {
            # In the -Path (non-literal) case we may need to resolve a wildcarded path
            $resolvedPaths = @($Path | Resolve-Path | Convert-Path)
        }
        else
        {
            # Must be -LiteralPath
            $resolvedPaths = @($LiteralPath | Convert-Path)
        }
    
        foreach ($rpath in $resolvedPaths)
        {
            Write-Verbose "Processing $rpath"
           
            $tfargs = ''
            $tfargs += if ($Recurse) { '/r' }
           
            # Look at each line of TF PERMISSION output and use a regex to determine
            # what the data for the line is.
            switch -regex (tf permission $rpath $tfargs)
            {
                '^Server item:\s+(\S+)\s+\(Inherit:\s+(\w+)\)'
                {
                    # If previous object exists, output it before creating a new one
                    if ($item) { $item }
                    $item = new-object psobject  -property @{
                        ServerItem = $matches[1]
                        Inherits   = $matches[2] -eq 'yes'
                        Identities = @()
                    }
                    $item.psobject.TypeNames[0] = "TfsTools.VersionControl.ItemPermissions"  
                }
               
                '\bIdentity:\s+(.*)$'  
                {
                    $identityName = $matches[1]
                    $currentIdentity = new-object psobject -property @{
                        Identity = $identityName
                        Allow = ''
                        Deny = ''
                        InheritedAllow = ''
                        InheritedDeny = ''
                    }
                    $item.Identities += $currentIdentity
                }
               
                '\bAllow:\s*(.*)$'     
                {
                    $currentIdentity.Allow = $matches[1]
                }
               
                '\bDeny:\s*(.*)$'      
                {
                    $currentIdentity.Deny = $matches[1]
                }
               
                '\bAllow\s+\(Inherited\)\s*:\s*(.*)$'     
                {
                    $currentIdentity.InheritedAllow = $matches[1]
                }
               
                '\bDeny\s+\(Inherited\)\s*:\s*(.*)$'      
                {
                    $currentIdentity.InheritedDeny = $matches[1]
                }           
            }
        }
    }

    End
    {
        # Output the very last object
        if ($item) { $item }
    }
}

The output of this function isn’t great for viewing since it is primarily intended to enable querying of the permission info on each server item.  Note to the Team Foundation Power Tools devs, it sure would be nice to get this functionality into a future TFPT drop.

Hi. It has been a while as I have been busy with my new job. I’m now working LEGO as Senior Solution Architect for www.lego.com. Visit a great web site and any feedback is welcome.

Consequently, I’m not using PowerShell as much as I used – to at least not for so complicated solution. On the other hand I’m using it almost daily as is it so useful for test web related things.

But my new colleagues know that I know PowerShell so today Michael asked about how to get a few lines from a text file. This is easy, but if it was easy, Michael would have figured it out himself. The problem is that the file is huge (E.G. 1.5GB), so using Get-Content with Select-Object or similar would be very memory intensive and thus slow. I said that I would either call .Net directly or embed some C# code in a script.

Well, now it is evening and I’m watching the Italian-Paraguay match and – hey – why not do a little blogging while and again!

As thought, so done. Here’s my solution. It took as little more than an hour including help and validation. For newcomers, use Get-Line –? for displaying the help nicely formatted.

The script -

<#
.Synopsis
    Get line or lines from a text file
.Description
    Get one of more lines from the specified file. Line numbers are positive and the first line is number 1.
.Inputs
    Path
.Outputs
    Array of strings
.Example
    Get-Line $env:temp\lines.txt 23,897,45
    Get lines 23, 45 and 897. Lines are returned in increasing order. E.g. line 23 is returned first, then line 45 and finally, line 897
    
#>
param(
    [parameter(Mandatory=$true)]
    [alias("file")]
    [alias("fullname")]
    [alias("name")]
    [string]
    [ValidateScript({Test-Path $_})]
    # The path of the file to get the lines from
    $path,
    [Parameter(Mandatory=$true)]
    [alias("numbers")]
    [int64[]]
    [ValidateScript({$_ -gt 0})]
    # One or more line numbers (e.g. first line is 1) to retrieve from the file
    $lines
)

add-type -TypeDefinition @'
    using System;
    using System.Collections.Generic;
    using System.IO;

    namespace Per
    {
        public class FileFunctions
        {
            public List GetLines(string file, System.Collections.Generic.Queue lines)
            {
                FileStream fs;
                StreamReader sr;
                List linesFound = new List();
                using (fs = new System.IO.FileStream(file, FileMode.Open, FileAccess.Read, FileShare.Read, 10 * 1024 * 1024))
                {
                    using (sr = new System.IO.StreamReader(fs))
                    {
                        int lineCounter = 0;
                        int linesIndex = 0;
                        if (lines.Count == 0)
                        {
                            return new List();
                        }
                        long findLine = lines.Dequeue();
                        while (!sr.EndOfStream)
                        {
                            string line = sr.ReadLine();
                            lineCounter++;
                            if (lineCounter == findLine)
                            {
                                linesFound.Add(line);
                                linesIndex++;
                                if (lines.Count == 0)
                                {
                                    break;
                                }
                                findLine = lines.Dequeue();

                            }

                        }
                    }
                    sr.Close();
                }
                fs.Close();

                return linesFound;
            }
        }
    }

'@
$c=new-object Per.FileFunctions
[int64[]]$sortedLines=$lines | sort -unique | where {$_ -gt 0}
$c.GetLines((Resolve-Path $path),$sortedLines)

As always: Have fun!

I’m on my way back from my first ever TechEd.  What a great experience.  I was mostly working the PowerShell booth and trying to talk with vendors and attendees, but I did get to attend 2 PowerShell sessions.

It’s difficult to scan a big audience, but those 2 sessions had likely between 300-500 attendees each!

The impression I got from TechEd last year was attendees were mostly asking if they had to learn PowerShell…  This year, things have really turned around!  Most people I talked to were using it or actively wanting to learn it.

It’s no longer “do I have to learn PowerShell?”, but instead it’s “how do I learn PowerShell?”.

For lucky attendees, we even gave out (for free!) a few 100 copies of William Stanek’s “Windows PowerShell™ 2.0 Administrator's Pocket Consultant”.  The book is available HERE.

Hallo Community,

ein kleiner Tipp aus der interaktiven Session mit Jeffrey Snover:

http://www.bing.com/visualsearch?g=powershell_cmdlets&ve=dataset-(0009)&vsq=cmdlet&FORM=SGEWEB#

Have fun
Rolf

2 things

1. Google putting images on their search page and no way to turn them off!

2. Microsoft moving Sketchflow into Expression Studio Ultimate! Oh well, back to Balsamiq.

Stupid, stupid, stupid!

If you are dealing with an native executable that outputs UTF8 with no BOM (byte order marker) you will find that PowerShell garbles the input.  This is most likely an issue with how the .NET console code interprets the incoming byte stream.  Without a BOM it isn’t exactly easy to determine the proper encoding for a stream of bytes.  For example take the following simple native exe source code that is supposed to output this (BTW ignore the fact that the text says ‘ASCII’ – it is really UTF8):

ASCII outputᾹ

Contents of stdout.cpp:

#include  
 
void main() 
{ 
    char bytes[] = { 0x41, 0x53, 0x43, 0x49,  
                     0x49, 0x20, 0x6F, 0x75,  
                     0x74, 0x70, 0x75, 0x74, 
                     0xE1, 0xBE, 0xB9}; 
 
    for (int i = 0; i < 15; i++) 
    { 
        printf("%c", bytes[i]); 
    }                 
} 

If you pipe the output of this program into a PSCX utility called Format-Hex (alias is fhex), you can see the actual unicode byte stream that was created by .NET’s interpretation of the incoming byte stream.

PS> .\stdout.exe | fhex

Address:  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F ASCII
-------- ----------------------------------------------- ----------------
00000000 41 00 53 00 43 00 49 00 49 00 20 00 6F 00 75 00 A.S.C.I.I. .o.u.
00000010 74 00 70 00 75 00 74 00 DF 00 5B 25 63 25       t.p.u.t...[%c%

You might think you could pipe the output to Out-File –Encoding Utf8 but by the time the .NET strings hit the Out-File cmdlet the damage is already done.  As can be seen if you view the subsequent output in Notepad.exe:

ASCII outputᾹ

The solution to this problem is to provide a hint to the .NET console functionality about the encoding of the incoming bytes.  You can do this very simply:

PS> [System.Console]::OutputEncoding = [System.Text.Encoding]::UTF8

And it works:

6> .\stdout.exe | fhex

Address:  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F ASCII
-------- ----------------------------------------------- ----------------
00000000 41 00 53 00 43 00 49 00 49 00 20 00 6F 00 75 00 A.S.C.I.I. .o.u.
00000010 74 00 70 00 75 00 74 00 B9 1F                   t.p.u.t...

7> .\stdout.exe | Out-File good.txt -Encoding UTF8

If you open good.txt in notepad you get:

ASCII outputᾹ

And is as it should be.  However this may seem somewhat counter-intuitive (it did to me) since the problem is with PowerShell/.NET “reading” console input and not writing it.  Well one of the good folks on the PowerShell team pointed out to me that the Console OutputEncoding is probably inherited by child processes and a quick little experiment reveals this to be true.  So by setting the OutputEncoding this determines how .NET encodes console output which helps PowerShell/.NET determine the correct encoding when reading in this information via console input.

One last point on this approach is that you should stash the original value of [Console]::OutputEncoding and restore it after you’ve run a problematic exe like in this example.  I’ve found that the C# compiler will crash if you run it in PowerShell with the [Console]::OutputEncoding set to UTF8.

If you want to do this, you won’t really need much of an explanation as to why I’m posting this. As to the rest of you, never mind; stick with your BigEndian Unicode (hint: powershell console and other console applications prefer ASCII) :)

First up, create yourself a Windows ISE Profile script that will be loaded by default when ISE starts (and/or when you open a new “Tab”)

# run this one-liner from within ISE through the interactive window (command pane):
if (-not (test-path $profile)) { md -force (split-path $profile); "" > $profile; psedit $profile }

Now, put this one-liner (well, it could fit on one line) in your $profile:

# watch for changes to the Files collection of the current Tab
register-objectevent $psise.CurrentPowerShellTab.Files collectionchanged -action {
    # iterate ISEFile objects
    $event.sender | % {
         # set private field which holds default encoding to ASCII
         $_.gettype().getfield("encoding","nonpublic,instance").setvalue($_, [text.encoding]::ascii)
    }
}

Have fun!

Today I learned a little bit about how to get to some of the data stored within special shell folders.  You can get a list of all of the easy-to-get-to special folders here.  I noticed one folder in particular that a bunch of systems administrators I know want to read, and that’s the Nearby Computers page.  Here’s a quick 23-line function that will go and get all of the computers from the Nearby Computers page, ping them, and return the Win32_PingStatus objects.

function Get-ComputersNearMe            
{            
    <#
    .Synopsis
        Returns the Computers Near Me
    .Description
        Returns all of the computers listed in the "Computers Near Me" or "Access the computers and devices tht are on your network" shell
        namespace.  Uses the Shell.Application API to get the computers folder, and then uses Test-Connection to return the machines and their
        response times.
    .Example
        Get-ComputersNearMe
    #>            
    param()            
    $computersFolder = 0x12            
    $shell = New-Object -ComObject Shell.Application            
    $shell.NameSpace($computersFolder).Items() |            
        Where-Object { $_.Path -like "\\*" } |            
        ForEach-Object {             
            Test-Connection $_.Name -AsJob            
        } |             
        Wait-Job |            
        Receive-Job             
}

As you can see, the whole first half of the script is the help.  $computersFolder is set to one of the magic constants listed on the MSDN page, and then I simply use the COM Object Shell.Application (which should be familiar to anyone that’s done a decent amount of VBScript) to get the folder.  Two types of items will be returned from this:  UNC paths to a machine and links to specific devices (like a media player library).  I filter out only the UNC paths with Where-Object, and then I do Test-Connection –AsJob to try to ping the machines.  The last bit of the script waits for all of the pings to come back, and returns the results to the user.  Since Win32_PingStatus already has a formatter that displays the source, destination, IPV4 address, IPV6 address, and time to ping, so there’s really nothing else I want to add.

Get-ComputersNearMe should be easy enough to use in small businesses, workgroups, or wherever else you find yourself using that screen.

Hope this helps,

James

A nifty trick that you can do in WPK is create a WPF progress bar to show the Write-Progress output from a PowerShell script.  I was reminded that people actually wanted to do this when I ran across a question on StackOverflow, and posted this answer.

In case you don’t want to follow the link, here’s a quick script to show progress from a background runspace in WPK.  The top half set ups a bunch of data bindings that will bind to whatever DataContext is found, and the second half of the script is a small sample of Write-Progress output.

New-Grid -Columns 2 {            
    New-TextBlock -Margin 10 -TextWrapping Wrap -ZIndex 1 -HorizontalAlignment Left -FontWeight Bold -FontSize 12 -DataBinding @{            
        "Text" = "LastProgress.Activity"            
    }            
    New-TextBlock -Margin 10 -ZIndex 1 -TextWrapping Wrap -Column 1 -VerticalAlignment Bottom -HorizontalAlignment Right -FontStyle Italic -FontSize 12 -DataBinding @{            
        "Text" = "LastProgress.StatusDescription"            
    }            
    New-ProgressBar -ColumnSpan 2 -MinHeight 250 -Name ProgressPercent -DataBinding @{            
        "Value" = "LastProgress.PercentComplete"            
    }            
} -DataContext {            
    Get-PowerShellDataSource -Script {             
        foreach ($n in 1..100) {            
            Write-Progress "MajorProgress" "MinorProgress" -PercentComplete $n            
            Start-Sleep -Milliseconds 250            
        }            
    }            
} -AsJob            

Hope this Helps

James Brundage [MSFT]