PauerSchell

Search for Firefox Bookmarks with given combination of 1 to 3 keywords

2011-04-27T05:08:00.000-07:00

When I found that Firefox stores its bookmarks in a sqlite database places.sqlite I wrote the following PowerShell script to search for bookmark by keyword combination.

Here is the code:

ipmo WPK            
            
if (! $sqlitedll)            
{            
    $sqlitedll = [System.Reflection.Assembly]::LoadFrom("C:\Program Files\System.Data.SQLite\bin\System.Data.SQLite.dll")             
}            
            
$ConnectionString = "Data Source=C:\Var\sqlite_ff4\places.sqlite"            
            
$conn = new-object System.Data.SQLite.SQLiteConnection             
$conn.ConnectionString = $ConnectionString             
$conn.Open()             
            
function Invoke-sqlite            
{            
    param( [string]$sql,            
           [System.Data.SQLite.SQLiteConnection]$connection            
           )            
    $cmd = new-object System.Data.SQLite.SQLiteCommand($sql,$connection)            
    $ds = New-Object system.Data.DataSet            
    $da = New-Object System.Data.SQLite.SQLiteDataAdapter($cmd)            
    $da.fill($ds) | Out-Null            
    return $ds.tables[0]            
}            
            
function Show-Bockmarks ($resource) {            
    New-Grid -Rows 2 -Columns 1 -width 1400 -hight 1000  {            
            
        New-StackPanel -Orientation horizontal -column 0 -row 0 -Children {            
             New-Label    '1. Keyword'            
             New-TextBox  -Name tag1 -width 200            
             New-Label    '2. Keyword'            
             New-TextBox  -Name tag2 -width 200            
             New-Label    '3. Keyword'            
             New-TextBox  -Name tag3 -width 200            
             New-Button -Name Search "search" -On_Click {            
            $text1 = $window | Get-ChildControl Tag1            
            $tag1 = $text1.Text            
            $text2 = $window | Get-ChildControl Tag2            
            $tag2 = $text2.Text            
            $text3 = $window | Get-ChildControl Tag3            
            $tag3 = $text3.Text            
            if ( $tag2 -ne '') {            
$clause2 = @"            
    join moz_bookmarks l2 on b.fk = l2.fk and b.id <> l2.id
    join moz_bookmarks t2 on l2.parent = t2.id and  t2.parent = 4 and upper(t2.title) = upper('$tag2')
"@                                    
            } else { $clause2 = '' }                    
            
            if ( $tag3 -ne '') {            
$clause3 = @"            
    join moz_bookmarks l3 on b.fk = l3.fk and b.id <> l3.id
    join moz_bookmarks t3 on l3.parent = t3.id and  t3.parent = 4 and upper(t3.title) = upper('$tag3')
"@                                    
            } else { $clause3 = '' }                    
            
$ff_sql = @"
SELECT b.title, datetime (b.dateAdded / 1000000, 'unixepoch', 'localtime') dateAdded , p.url
    from moz_bookmarks b
    join moz_bookmarks l1 on b.fk = l1.fk and b.id <> l1.id
    join moz_bookmarks t1 on l1.parent = t1.id and  t1.parent = 4 and upper(t1.title) = upper('$tag1')
    join moz_places p  on b.fk = p.id $clause2 $clause3
where b.title is not null and b.type = 1
"@            
            $conn = $resource.conn            
            $window.Title = "$($conn.database) Database Browser"            
            $TableView = $window | Get-ChildControl TableView            
            $TableView.ItemsSource = @(Invoke-sqlite -sql $ff_sql -connection $conn)            
             }             
             New-Button -Name Cancel "Close" -On_Click {$window.Close()}             
        }            
        New-ListView -Column 0 -Row 1 -Name TableView -View {            
           New-GridView -AllowsColumnReorder -Columns {            
               New-GridViewColumn "title"             
               New-GridViewColumn "dateAdded"             
               New-GridViewColumn "url"             
           }            
        }   -On_SelectionChanged {            
             start $this.selecteditem.url            
        }            
        #}            
            
    } -asjob -Resource $resource            
}            
            
Show-Bockmarks -resource @{conn = $conn}

You have to install System.Data.SQLite
from http://system.data.sqlite.org/index.html/doc/trunk/www/downloads.wiki

I had problems when I checked the install in GAC option. Therefore I installed it without that option and supply the absolute path in my script.

Note: You can't open places.sqlite while Firefox is running. I copied it and coded the path of the copy into my script.

Now I can enter a keyword, press search and the grid fills. Double clicking starts the bookmark in the default browser.

Eval-Selection in ISE editor, result in editor pane

2010-11-20T23:46:00.000-08:00

Here is a little demo showing, who to use ISEs editor pane to display untruncated, unwrapped results.

Run the script in ISE.
Open a new editor.
Tpye dir and press F7:

            
            
function Eval-Selection            
{            
    # Bernd Kriszio 2010-11-21            
    # http://pauerschell.blogspot.com/            
    # twitter @bernd_k            
                
                    
    $editor = $psise.CurrentFile.Editor            
            
    if ($editor.SelectedText)            
    {            
        $inputScript = $editor.SelectedText            
        $editor.InsertText('')            
        $editor.InsertText($inputScript)            
        $result = Invoke-expression $inputScript | out-String            
        $editor.insertText("`r`n")            
        $editor.InsertText($result)            
            
    }            
    else            
    {            
        $inputScript = $editor.Text            
        $EndLine =  $editor.LineCount             
        $EndColumn = $editor.GetLineLength($EndLine) + 1            
        $editor.SetCaretPosition($EndLine, $EndColumn)            
        $result = Invoke-expression $inputScript | out-String            
        $editor.insertText("`r`n")            
        $editor.InsertText($result)            
    }            
}                    
                    
             
$psISE.CurrentPowerShellTab.AddOnsMenu.Submenus.Add("Eval-Selection", {Eval-Selection} ,  'f7')

Edited
After playing a while, I modified the rules for the case, when nothing is selected. Now I use just the single line, the caret is in. Further I added the -width 1000 parameter to make it realy an improvement about usual output-pane results.

And I have a lot of crazy ideas, what to do if the caret is in an empty line. I don't implement them. Next month I wouldn't remember them myself.

Keep things simple

Bernd

This is the version, I added to my profile:

function Eval-Selection            
{            
    # Bernd Kriszio 2010-11-21            
    # http://pauerschell.blogspot.com/            
    # twitter @bernd_k            
                
                    
    $editor = $psise.CurrentFile.Editor            
                
    # if nothing is selected just use the line the caret is in            
    if (!$editor.SelectedText)            
    {            
        $caretLine = $editor.CaretLine            
        $caretLineEnd = $editor.GetLineLength($caretLine) + 1                
                    
        $editor.Select($caretLine, 1, $caretLine, $caretLineEnd)            
    }            
            
    # if something is selected use it.            
    if ($editor.SelectedText)            
    {            
        $inputScript = $editor.SelectedText            
        $editor.InsertText('')            
        $editor.InsertText($inputScript)            
        $result = Invoke-expression $inputScript | out-String -width 1000            
        if ($editor.CaretColumn -ne 1)            
        {            
            $editor.insertText("`r`n")            
        }            
        $editor.InsertText($result)            
            
    }            
}

Determine Start and End of a Selection in PowerShell Ise

2010-11-16T22:33:00.000-08:00

Hello, I' m just working on a new inline outpout mode for SQLPSX a very ambious project to access SQL databases based on PowerShell.

There ISEs Output pane doesn't always satisfy my needs, because it truncates and wraps output but you can put your Output into the current or new Editor panes and that works fine. Today I focus on using the current editor pane.

My goal is to insert the output exactly at the starting of the line below the selection if there is one or at the end of the editor.

First I found it difficult to get the start and end of a selection, but than I found a clever work around. I can even determine, if a selection was done from left to right or from right to left.

But don't use this possibility. It would be really confusing.

Here is my test code, with which I designed (honestly redesigned) the logic to evaluate the output location in SQLPSX (next release).

Have fun studying it. Just put the code below it into an ISE editor, select some text (or nothing) and press F5.

Bernd

function Get-InfoAboutCurentFilesEditor            
{            
    $editor          = $psIse.CurrentFile.Editor            
    $LineCount       = $editor.LineCount            
    $CaretLine       = $editor.CaretLine            
    $caretColumn     = $editor.CaretColumn            
    $CaretLineLength = $editor.GetLineLength($CaretLine)            
    $CaretAtLineEnd  = $caretColumn -eq $CaretLineLength + 1            
    $CaretInLastLine = $CaretLine -eq $LineCount            
    $SelectedText    = $editor.SelectedText            
    $hasSelection    = $SelectedText -ne ''            
                
    if ($hasSelection)            
    {            
        # delete selected text            
        $editor.InsertText('')            
        $StartLine =  $editor.CaretLine            
        $StartColumn = $editor.CaretColumn            
        # reinsert the text            
        $editor.InsertText($SelectedText)            
        $EndLine =  $editor.CaretLine            
        $EndColumn = $editor.CaretColumn            
        # restore the selection            
        $editor.select($StartLine, $StartColumn, $EndLine, $EndColumn)             
        $reverse =  $CaretLine -eq  $StartLine -and $caretColumn -eq $StartColumn            
    }            
    else            
    {            
        $StartLine =  $EndLine = $LineCount            
        $StartColumn = $EndColumn = $editor.GetLineLength($EndLine) + 1            
        $reverse = $False            
    }            
                
    if (  $EndLine -lt  $LineCount)            
    {            
        $outputLine = $EndLine + 1            
        $outputColumn = 1            
        $NeedsNewLine = $False            
    }            
    else            
    {            
        $outputLine = $EndLine            
        $outputColumn = $EndColumn            
        if ($EndColumn -ne 1)            
        {            
            $NeedsNewLine = $True            
            $outputColumn = $editor.GetLineLength($EndLine) + 1            
        }            
        else            
        {            
            $NeedsNewLine = $False            
        }            
    }            
@"
DisplayName:     $($psIse.CurrentFile.DisplayName) 
LineCount:       $LineCount

CaretLine:       $CaretLine
CaretColumn:     $caretColumn
CaretLineLength: $CaretLineLength
CaretAtLineEnd:  $CaretAtLineEnd
CaretInLastLine: $CaretInLastLine

hasSelection:    $hasSelection
reverse:         $reverse

outputLine:      $outputLine
outputColumn:    $outputColumn
NeedsNewLine:    $NeedsNewLine
"@            
}            
            
Get-InfoAboutCurentFilesEditor

New ISE work arounds -- determine start and end of textselection

2010-11-15T06:54:00.000-08:00

I just guess that ISE is made by some Trappist monks. One never hears anything about future versions.
At most some closed Change Request at Microsoft Commit.
I get a little tired hoping, they will release anything soon.
If I need something, I'm going to write some dirty workaround.
Current problem: you can select text within the editor from left to right or from right to left ending with the caret at different positions.
Only the holy men didn't publish the API to get the start and the end of the selection. You can query only the caret position.
What I want acchieve, is to be able to insert in the line just below the current selection.
Well the following work around sets the caret to the beginning of the selection.
Put the code into an ise editor select testa and press f5, than repeat it by selecting the tesxt in the oposite direction and press again f5:

$editor = $psise.CurrentFile.Editor            
 $currentselection = $editor.SelectedText            
 if ($currentselection)            
 {            
    $initialCaretLine = $editor.CaretLine            
    $initialCaretColumn = $editor.CaretColumn            
    $editor.InsertText('')            
    $selstartline  = $editor.CaretLine            
    $selstartColumn = $editor.CaretColumn             
    $editor.InsertText($currentselection)            
    $selEndline  = $editor.CaretLine            
    $selEndColumn = $editor.CaretColumn             
    $editor.Select($selstartline, $selstartColumn, $selEndline, $selEndColumn)            
                
    "Selection is ($selstartline, $selstartColumn, $selEndline, $selEndColumn)"            
    "Initial Caret Position ($initialCaretLine, $initialCaretColumn)"            
 }            
            
            
# testa            
# testb

Hope this really helps

Bernd

I can code Bad Influenced style too

2010-11-14T09:21:00.000-08:00

I hope there is a better way to do this, but if PowerShell enforces the use of work arounds, I'll use them.
Please, if you find something more elegant, please drop a note.

Well to make SQLPSX one of the most powerfull tools to extract data from SQL-Server or Oracle databases I just want to transform a datarow into a tabular representation.

$datarow | Format-Table -auto

seems a good start, but as described in http://poshoholic.com/2010/11/11/powershell-quick-tip-creating-wide-tables-with-powershell/

you need to pass the result to Out-String -width 10000 or as many characters you want.
Sorry can't say -1 for unlimited. (Perhaps in V3, if we cry load enough?)

Oops not all columns included, lets add -property *

$datarow | Format-Table -auto -property * | Out-String -width 10000

Oops what happens now? At the end you get some unwanted addition columns:

RowError, RowState, Table, ItemArray, HasErrors

A problem well described in https://connect.microsoft.com. With no work around supplied.

Go there and vote for it.

And here is the code, that gives me the wanted result. I agree, it is ugly, but its result is fine:

$columns = ''            
            
                            foreach ($i in 0.. ($res[0].Table.columns.count -1))            
                            {            
                                if ($columns) { $columns +=  ', '+ $res[0].Table.Columns[$i].ColumnName }            
                                else { $columns = $res[0].Table.Columns[$i].ColumnName}            
                            }            
            
                            $c = '($res | ft -Property ' + $columns + ' -auto | Out-string -width 10000 -stream ) -replace " *$", ""-replace "\.\.\.$", "" -join "`r`n" '            
                            $text = Invoke-expression $c

I hope this helps

Bernd

SQLPSX Release 2.3 is real tool for SQL-Server

2010-11-13T06:16:00.000-08:00

Well it took some time, until Chad Miller published the current version of SQLPSX.
Concerning SQL-Server I dare say, it is a real tool to work with, with some unique features.

You get a lot of options for output format, e.g. list, which showes you the contents of the columns above each other. That helps, if you have varchar fields containing multiple lines. While the usual grid format only displays the first line and the text format looses column alignment, here you get nearly the complete content.
Nearly? Yes using ISE Output window, some wise man desided that truncating the output to current width of the Output window is what users have to want.

OK. With the limitations of the output window you have two options. First you can tweet about this last millenium decision. Second you can pray to Microsoft Connect and send a change Request for an option to programmatically set the witdth of the output pane).
Or you just ignore the two options and write a workaround.

The workaround I invented is the output format isetab. (Yes you find it in SQLPSX 2.3)
The trick is not using the Output pane for displaying the result, but to create a new editor and display it there in its whole witdh.

Working with the new mode, I soon end with lots of ofen editors and nearly as a joke to a coworker I designed the idea of an inline output format. I put the result into the calling editor, just below the calling selection or at the end, if there is none.

First trial was just 4 lines and it just felt good.

You can adjust the princip, if you have a function, which you invoke by ISE menu, which produces some wide output. Instead of sending the output to the output pane, you can use something similar to:

$text = "your code goes here>"            
         $editor = $psise.CurrentFile.Editor            
         $caretLine = $editor.CaretLine            
         $lineCount = $editor.LineCount            
         if (-not $selectedEditor.SelectedText)            
         {            
            $lineend = $editor.GetLineLength($lineCount) + 1            
            # Write-Host "Nothing Selected  Linecount: $lineCount LineEnd: $lineend"            
            if ($lineend -eq 0) {$lineend = 1}            
            # set selection to the end of the editor            
            $editor.Select($lineCount, $lineend, $lineCount, $lineend)            
         }            
         elseif ($caretLine -lt $lineCount)            
         {            
            # Write-Host "Usual case"            
            # set selection to the start of the next line            
            $editor.Select($caretLine + 1, 1, $caretLine + 1, 1)            
         }            
         else            
         {            
            $lineend = $editor.GetLineLength($lineCount) + 1            
            # Write-Host "At end  Linecount: $lineCount LineEnd: $lineend"            
            if ($lineend -eq 0) {$lineend = 1}            
            # set selection to the end of the editor            
            $editor.Select($lineCount, $lineend, $lineCount, $lineend)            
         }            
         $editor.InsertText($text)

You can load this into an ISE editor and run it using F5. You see the line your code goes here added at the end.

Bernd

A Problem with Remove-Item $folder -recurse -force

2010-05-28T00:09:00.000-07:00

I'm working with some testsenario, where I have repeatedly to remove a folder structure of about 3500 files of depth 8.

Remove-Item $folder -recurse -force

sometimes does not remove all the files. In some cases it yields the message, that a folder can't be deleted, because it is not empty, but when checking the folder is empty. In other not all files are removed.

To reach a clean state, I wrote the following script:

function Remove-ItemRecursiveBruteForce            
{            
    param(            
        [Parameter(Position = 0, Mandatory=$true, ValueFromPipeline=$false)]            
        [string]$folder,            
        [Parameter(Position = 1, Mandatory=$False, ValueFromPipeline=$false)]            
        $maxiterations = 20            
    )            
            
    $iteration = 0            
    while (  $iteration++ -lt   $maxiterations)            
    {            
        if (Test-Path $folder)            
        {            
            Remove-Item $folder -recurse -force -EA SilentlyContinue            
        }            
        else            
        {            
            "$folder deleted in $iteration iterations"            
            break            
        }            
    }            
    if (Test-Path $folder)            
    {            
        "$folder not empty after $iteration iterations"            
    }            
            
}

I observe that it needs randomly between 2 and 11 iterations to remove my folder.

I'm using W7-32 bit and use PowerShell-ISE to run the script.

Is this problem just me, or is it OS specific. Any explanations?

1. Attemp to use .NET isolated storage with modeless WPK windows

2010-05-19T01:12:00.000-07:00

The following attempt is not working with modeless windows (replace -show #-asjob by -asjob). Using -show it works. Please run the code, do some selection within GUI, finally call Get-value to check the result.

ipmo WPK                        
            
                        
$env:WPKResult = "auto"            
            
function action            
{            
    param (            
        $value            
    )            
    $env:WPKResult = $value            
                
    $changedProperty = $value            
    Write-Host "Value of $changedProperty changed to $value"                        
            
    try {            
    $useriStorage = [System.IO.IsolatedStorage.IsolatedStorageFile]::GetUserStoreForAssembly()            
    $file = New-Object System.IO.IsolatedStorage.IsolatedStorageFileStream("SQLSettigs.xml",[System.IO.FileMode]::Create,$useriStorage)            
    $xml = New-Object System.Xml.Serialization.XmlSerializer($changedProperty.GetType())            
    $xml.Serialize($file,$changedProperty)            
    $file.Close()            
    $useriStorage.Close()            
    }            
    catch {            
        $env:WPKResult = 'error'            
    }            
            
}            
                          
New-StackPanel {                        
    New-RadioButton -Content "auto"     -GroupName Results -IsChecked $True -On_Click { action "auto" }                        
    New-RadioButton -Content "list"     -GroupName Results -On_Click { action "list" }                        
    New-RadioButton -Content "table"    -GroupName Results -On_Click { action "table" }            
    New-RadioButton -Content "grid"     -GroupName Results -On_Click { action "grid" }            
    New-RadioButton -Content "variable" -GroupName Results -On_Click { action "variable" }            
    New-RadioButton -Content "csv"      -GroupName Results -On_Click { action "csv" }            
    New-RadioButton -Content "file"     -GroupName Results -On_Click { action "file" }            
} -show #-asjob                        
                        
            
function Get-value            
{            
    $useriStorage = [System.IO.IsolatedStorage.IsolatedStorageFile]::GetUserStoreForAssembly()            
    try {            
        $file = New-Object System.IO.IsolatedStorage.IsolatedStorageFileStream("SQLSettigs.xml",[System.IO.FileMode]::Open,$useriStorage)            
    }            
    catch {            
        Write-Host "UISettings.xml is not found"            
        return            
    }                        
    $xmlReader = New-Object System.Xml.XmlTextReader($file)            
    $xml = New-Object System.Xml.Serialization.XmlSerializer('abc'.GetType())            
    $newISEOptions = $xml.Deserialize($xmlReader)            
    $newISEOptions            
}

Please help - I want to send back a keystroke to the ISE window

2010-05-16T08:03:00.000-07:00

Hello WPF friends, I need a little help. I want to add a button which sends F7 keystroke to the ISE-window from which I run this little WPK script.

ipmo WPK                        
                        
$env:WPKResult = "auto"                          
New-StackPanel {                        
    New-RadioButton -Content "auto"     -GroupName Results -IsChecked $True -On_Click { $env:WPKResult = "auto" }                        
    New-RadioButton -Content "list"     -GroupName Results -On_Click { $env:WPKResult = "list" }                        
    New-RadioButton -Content "table"    -GroupName Results -On_Click { $env:WPKResult = "table" }            
    New-RadioButton -Content "grid"     -GroupName Results -On_Click { $env:WPKResult = "grid" }            
    New-RadioButton -Content "variable" -GroupName Results -On_Click { $env:WPKResult = "variable" }            
    New-RadioButton -Content "csv"      -GroupName Results -On_Click { $env:WPKResult = "csv" }            
    New-RadioButton -Content "file"     -GroupName Results -On_Click { $env:WPKResult = "file" }            
    New-Button -Content "execute Sql"  -On_click { New-Button "I want to send F7 key-stroke to calling ISE" -show }                        
} -asjob

This script is intended to be run in ISE and to add some cool GUI to SQLPSX.

Thanks

Bernd

A try in WPK (one way and only once)

2010-05-12T11:54:00.000-07:00

The best I found in WPK seems to be the the following:

ipmo WPK            
            
$option = "To File" # this value might be prompted by the user            
             
             
New-StackPanel {            
    New-RadioButton -Content "To Text" -GroupName Results -IsChecked $True -On_Click {             
        $Resource.Result = "To Text"             
        $info = $window | Get-ChildControl info            
        $info.text = $Resource.Result            
        $env:WPKResult = $Resource.Result            
        }            
    New-RadioButton -Content "To Grid" -GroupName Results -On_Click {              
        $Resource.Result = "To Grid"             
        $info = $window | Get-ChildControl info            
        $info.text = $Resource.Result            
        $env:WPKResult = $Resource.Result            
        }            
    New-RadioButton -Content "To File" -GroupName Results -On_Click {              
        $Resource.Result = "To File"             
        $info = $window | Get-ChildControl info            
        $info.text = $Resource.Result            
        $env:WPKResult = $Resource.Result            
    }            
    New-RadioButton -Content "To CSV" -GroupName Results -On_Click {              
        $Resource.Result = "To CSV"             
        $info = $window | Get-ChildControl info            
        $info.text = $Resource.Result            
        $env:WPKResult = $Resource.Result            
    }            
    New-textBox -Name info             
    } -On_Loaded {            
            $info = $window | Get-ChildControl info            
            $info.text = $Resource.Result            
    }-asjob -resource @{Result = $option}

I can modify the value within GUI and query it outside

$env:WPKResult

I misuse the processes environment, which is shared between the runspaces. Hmm better than pidgeon carrying USB sticks, but it is restricted to strings.

I guess I have to really dive into PowerBoots (and that is the polite version ;-) of my opinion about WPK)

Have some fun trying to find further work arounds.

Bernd

A small Async PowerBootsWindow

2010-05-12T10:04:00.000-07:00

Hello,
here I'll show a little async PowerBoots Gui, which is able to modify variables in the main thread.

ipmo PowerBoots            
            
$options = @{ "Results" = "To Text" }            
             
Boots {             
    StackPanel {            
        RadioButton -Content "To Text" -GroupName Results -IsChecked $True -On_Click { $options.Results = "To Text" }            
        RadioButton -Content "To Grid" -GroupName Results -On_Click {  $options.Results = "To Grid" }            
        RadioButton -Content "To File" -GroupName Results -On_Click {  $options.Results = "To File" }            
        RadioButton -Content "To CSV" -GroupName Results -On_Click {  $options.Results = "To CSV" }            
                }            
      } -async

Is it possible to do the same thing with WPK?

A viewer for Crystal Reports with PowerShell (partially working)

2010-05-12T00:15:00.000-07:00

Hello,
this time I tried to build a small Report Viewer using the components from Visual Studio 2008 with PowerShell. It shows that using PowerShell here makes some things rather easy.

I'm using this to display old Reports made with Crystal Reports 8.5 using ODBC Datasources to SQL-Server.

Reports based on views works fine, I can set database and formulars.

But I have still a problem with reports based on stored procedures. Setting $table.location doesn't work anymore as in the past. I go the error table not found. Any hints welcome.

And here is the code if you want to try something like this:

Function Show-CrystalReport            
{            
    param(            
        $reportPath,             
        $servername,             
        $databasename,             
        $userId,             
        $password,            
        $RecordSelectionFormula,            
        $formulas,            
        $parameters            
        )            
                    
            
    [reflection.assembly]::LoadWithPartialName('CrystalDecisions.Shared')            
    [reflection.assembly]::LoadWithPartialName('CrystalDecisions.CrystalReports.Engine')            
    [reflection.assembly]::LoadWithPartialName('CrystalDecisions.Windows.Forms')            
            
    $report = New-Object CrystalDecisions.CrystalReports.Engine.ReportDocument            
    $report.load($reportPath)            
            
    $report.ParameterFields | % {             
        if ($parameters.keys -contains $_.Name)            
        {            
            $report.SetParameterValue($_.Name, $parameters[$_.Name])            
        }            
     }               
            
    $report.DataDefinition.FormulaFields | % {            
        if ($formulas.keys -contains $_.Name)            
        {            
            $_.Text = $formulas[$_.Name]            
        }            
    }            
            
    if ($RecordSelectionFormula) {            
        $report.RecordSelectionFormula = $RecordSelectionFormula            
    }            
            
    foreach ($Table in $report.Database.Tables)            
    {            
        $table            
        $tli = $Table.LogonInfo            
        $li = $tli.ConnectionInfo            
        Write-host "location : $($table.location)"            
                    
        $li.ServerName = $servername            
        $li.DatabaseName = $databasename             
        $li.UserID = $userId            
        $li.Password = $password            
        $Table.ApplyLogOnInfo($tli)            
        # the following doesn't work as in the past            
        if ( $table.location -contains '.')            
        {            
            $table.location -match  '(.*)\.(.*)'            
            $table.location = "$($databasename).dbo.$($matches[2])"            
        }            
        $table.location             
                   
    }            
            
    $rv = New-Object CrystalDecisions.Windows.Forms.CrystalReportViewer            
    $rv.ReportSource = $report            
    $rv.Dock = [System.Windows.Forms.DockStyle]::Fill            
            
            
    $form = New-Object Windows.Forms.Form            
                 
    $form.Height = 810            
    $form.Width= 1210            
    $form.Controls.Add($rv)            
    $rv.Show()            
    $form.ShowDialog()            
            
    $rv.Dispose()            
    $report.Dispose()            
    $form.Dispose()            
            
}

WPF Linkcollection for PowerShell

2010-04-24T04:03:00.000-07:00

During the last time I played with some ways to present GUI from PowerShell. I spend some time collection links, which I want to share now.

First there are two toolkits between you can select.

WPK which is part of PowerShellPack and Powerboots.

WPK is created by James brundage
and it comes with some examples in the Modules\WPK\Examples folder.

Videos:
A Brief Introduction to using WPF-Containers
Multitouch Fingerpaint in 30 Lines of PowerShell Script

Some blog postings:
Hey, Scripting Guy! Using the Windows Presentation Foundation PowerShell Kit to Create a GUI
PowerShell Picture Viewer using WPF and WPK
Write-Progress & WPK

Test-Spelling

Projects using WPK:
SQLPSX
Try PowerShell (currently only in source not released)

PowerBoots is created by Joel Bennett (Jaykul) of HuddledMasses.org
and when installed, you find the examples in ...\Modules\PowerBoots\Samples\Samples.ps1

Some Blogs about it:
PowerBoots 0.2
PowerShell Picture Viewer using PowerBoots

Jaykuls tagged WPF

Posts Tagged ‘WPF’
PowerBoots: The tutorial walkthrough
PowerBoots: Loading XAML Windows in PowerShell 1.0 or 2.0

Creating GUI with Powershell and WPF was possible without the aid of toolkits, even in the dark adges of CTP 2 and CTP 3. Code from that early time needs to be adopted to run today, but for the curious, you find interessting stuff in it too.
Thanks to Max Trinidad for his post containing a link to the old trasures.

and here is th eearly serie from James Brundage:
Part 1
Part 2
Part 3
Part 4
Part 5
Part 6
Part 7

To make the examples run in PowerShell V2 you need help from the following posts
Windows PowerShell CTP2 to CTP3 Conversion Guide by James Brundage
PowerShell 2.0 CTP3 has arrived! by Oisin Grehan

Look for WPF tag in PowerShell Team Blog

finally you may want to look at some general WPF links
WPF Tutorial by Christian Mosers
WPF and XAML Tutorials by Josh Smith

Now have some fun, exploring WPF by yourself.

Bernd

PowerShell modules are funny guys (III)

2010-04-02T01:26:00.000-07:00

Today I continue to write about some advanced features, you only touch when you are importing some modules and than to remove some of them again.

To demonstate I create two modules, the first to be used as submodule by the second. I call it mod_s

$script:state_s = 0            
Write-host "Executing mod_s"            
            
$mInfo = $MyInvocation.MyCommand.ScriptBlock.Module            
$mInfo.OnRemove = { Write-Host "Removing module mod_s" }            
            
function Get-State            
{            
    return $script:state_s            
}            
            
function Set-State ($x)            
{            
    $script:state_s = ($x)            
}            
            
function Set-ModSUnremovable            
{            
    $mInfo = $MyInvocation.MyCommand.ScriptBlock.Module            
    $mInfo.AccessMode = "readonly"            
}            
            
function Set-ModSremovable            
{            
    $mInfo = $MyInvocation.MyCommand.ScriptBlock.Module            
    $mInfo.AccessMode = "ReadWrite"            
}

Se second is used to import this module, I call it mod_a:

Write-host "Executing mod_a"            
Import-Module mod_s.psm1            
Write-host "Old state $(Get-state)"            
Set-state 11            
            
function Get-StateA            
{            
    return Get-State            
}            
            
function Set-StateA ($x)            
{            
    Set-State $x            
}

Now let us see what happens, when I first import mod_s and than mod_a and finally remove mod_s

1]10:33:45 C:\Var\bin (FileSystem)
ipmo mod_s
Executing mod_s

_____________________________________________________________________________________________________
[2]10:33:50 C:\Var\bin (FileSystem)
ipmo mod_a
Executing mod_a
Old state 0

_____________________________________________________________________________________________________
[3]10:33:57 C:\Var\bin (FileSystem)
rmo mod_a
Removing module mod_s

_____________________________________________________________________________________________________
[4]10:34:02 C:\Var\bin (FileSystem)
gmo

ModuleType Name ExportedCommands
---------- ---- ----------------
Script ISECreamBasic {get-AvailableModuleList, Remove-IseMenu, Add-IseMenu}

_____________________________________________________________________________________________________
[5]

Let us remember, that mod_s is removed and the global reference to mod_s is removed.

Next let us keep a referenc to mod_s before removing mod_a:

[1]10:39:04 C:\Var\bin (FileSystem)
ipmo mod_s
Executing mod_s

_____________________________________________________________________________________________________
[2]10:40:52 C:\Var\bin (FileSystem)
$a = gmo mod_s

_____________________________________________________________________________________________________
[3]10:40:58 C:\Var\bin (FileSystem)
ipmo mod_a
Executing mod_a
Old state 0

_____________________________________________________________________________________________________
[4]10:41:03 C:\Var\bin (FileSystem)
rmo mod_a
Removing module mod_s

_____________________________________________________________________________________________________
[5]10:41:07 C:\Var\bin (FileSystem)
$a

ModuleType Name ExportedCommands
---------- ---- ----------------
Script mod_s {Set-ModSUnremovable, Set-State, Set-ModSremovable, Get-State}

_____________________________________________________________________________________________________
[6]10:41:12 C:\Var\bin (FileSystem)
gmo

ModuleType Name ExportedCommands
---------- ---- ----------------
Script ISECreamBasic {get-AvailableModuleList, Remove-IseMenu, Add-IseMenu}

_____________________________________________________________________________________________________
[7]

Here you see, that mod_s doesn't execute its termination code. I get the impression, that they use some sort of reference count to modules and when it drops down to 0. The module gets unloaded from memory.

The fact that the reference to the global scope is removed, by removing a submodul makes it difficult to ensure that some modules are imported.

Lets study Bruce Payette. He has a section Controlling when modules can be unloaded.

Let's try:

[1]10:49:09 C:\Var\bin (FileSystem)
ipmo mod_s
Executing mod_s

_____________________________________________________________________________________________________
[2]10:49:15 C:\Var\bin (FileSystem)
Set-ModSUnremovable

_____________________________________________________________________________________________________
[3]10:49:23 C:\Var\bin (FileSystem)
Set-ModSremovable

_____________________________________________________________________________________________________
[4]10:49:30 C:\Var\bin (FileSystem)
Set-ModSUnremovable

_____________________________________________________________________________________________________
[5]10:49:39 C:\Var\bin (FileSystem)
ipmo mod_a
Executing mod_a
Old state 0

_____________________________________________________________________________________________________
[6]10:49:45 C:\Var\bin (FileSystem)
rmo mod_a
Remove-Module : Unable to remove module 'mod_s' because it is read-only. Use the -force flag to remove r
ead-only modules.
At line:1 char:4
+ rmo <<<< mod_a
+ CategoryInfo : PermissionDenied: (mod_s:PSModuleInfo) [Remove-Module], InvalidOperationE
xception
+ FullyQualifiedErrorId : Modules_ModuleIsReadOnly,Microsoft.PowerShell.Commands.RemoveModuleComman
d

_____________________________________________________________________________________________________
[7]10:49:49 C:\Var\bin (FileSystem)
Set-ModSremovable
The term 'Set-ModSremovable' is not recognized as the name of a cmdlet, function, script file, or operab
le program. Check the spelling of the name, or if a path was included, verify that the path is correct a
nd try again.
At line:1 char:18
+ Set-ModSremovable <<<<
+ CategoryInfo : ObjectNotFound: (Set-ModSremovable:String) [], CommandNotFoundException
+ FullyQualifiedErrorId : CommandNotFoundException

_____________________________________________________________________________________________________
[8]

Anyone not calling this a bug around ?

Bernd

PowerShell modules are funny guys (II)

2010-03-30T23:00:00.000-07:00

Here I'll focus on the irritating feature. The following script creates 2 modules in your user modul folder.
The second module imports the first module.

Import the first module, then the second. Both modules are imported.
Now remove the second module (that which imports the other too) and both are gone.

$modpath1 = ($env:PSModulepath -split ';')[0]            
mkdir $modpath1\submod -force            
mkdir $modpath1\testmod -force            
            
            
            
@'
$script:state_s = 0

function Get-State
{
    return $script:state_s
}

function Set-State ($x)
{
    $script:state_s = ($x)
}
'@ > "$modpath1\submod\submod.psm1"            
            
            
@'
Import-Module submod.psm1


function Get-StateY
{
    return Get-State
}

function Set-StateY ($x)
{
    Set-State $x
}
'@ > "$modpath1\testmod\testmod.psm1"            
            
ipmo submod            
ipmo testmod            
Write-host '------------'            
gmo            
Write-host '------------'            
rmo testmod            
gmo

Do you agree, that is to be called a bug?

Bernd

How to Organize Modules you Develop in Projects

2010-03-29T02:51:00.000-07:00

Today I want to tell about the ways I organise my modul development.

When you start to develop PowerShell modules it is relative easy. Just add a folder under

(Split-path $profile) + '\Modules'

say MyMod.
Then put a file MyMod.psm1 into it

Write-host "mymod loaded"

When you type ipmo Mymod, which is the alias for Import-Module you get

mymod loaded

With rmo Mymod , which is the short for Remove-Module you get rid of your module.

To check that it is removed, you can type
gmo or gmo Mymod, which is the alias for Get-Module

Now you shouldn't see it anymore.

Here I'm not going to tell you, what to put into your module file.

Best link for this I know is this post from Bruce Payette.

My focus here is, how to organise your system, when you have written something usefull and uploaded your module to some project.

I guess that you checkout your module from the project to some place, which is not in your modules folders. To ckeck where your system searches for modules just type

$env:PSModulePath -split ';'

Next I tried to be clever. I put the following into my profile:

$env:PSModulePath += ";\D:\MysharedProject\modules"

Now I can load the modules from this project by simple calles of ipmo myModule.

It really took some time to discover that I was too clever.

I'm using ISE for nearly all my PowerShell task and some time ago I discovered the menu New PowerShell Tab with the short-cut CTRL+T.

Each time you invoke this, you get a new PowerShell session and your PowerShell Profiles are executed.

But all these PowerShell session live in your current Windows session and each time the PSModulePath variable of the Windows environment will be modified. It gets longer and longer.

OK here now my final solution, this is the start of my profile.ps1

write-host "================== generall ($env:USERDOMAIN.$env:username) ==========================="            
            
$AdditionalModulPathes = @(            
"D:\someProjectBleedingEdge\Modules"            
"D:\someProjectRelease\Modules"            
# "D:\MyCopyOfSomeProject\Modules"            
)            
            
            
foreach ($path in ($AdditionalModulPathes| Get-unique) )            
{            
    if (($env:PSModulePath -split ';') -notcontains $path)            
    {            
        $env:PSModulePath += ";" + $path            
    }            
}            
            
# $env:PSModulePath -split ';'

Now I modify the evironment only once.
And here is the location, where I select whether I use the stable release, the current development version or my own unpublished work.

I hope this give you some ideas.

Bernd

BTW: ISE-Cream has reached release 0.1
If you are thinking about extending ISE, take a look at it

PowerShell modules are funny guys

2010-03-25T03:19:00.000-07:00

Ed Wilson says Windows PowerShell 1.0 was the vision, Windows PowerShell 2.0 is the reality [ from the preface of LeeHolmes Windows PowerShell Cookbook
I dare say PowerShell 2.0 ISE and Modules are still a vision.

When a module depends on a another module like SQLISE on ICECreamBasic or WPK it seems natural
to use within the .psm1 file

import-module ISECreamBasic            
import-module SQLParser            
import-module adolib            
import-module WPK

When I write a second module OracleIse, I can do similar

import-module ISECreamBasic            
import-module OracleClient            
import-module WPK

Seems OK so far.

Next modules can be removed using Remove-module and that fires even an event to do some clean up as removing ISE addons menu items

$mInfo = $MyInvocation.MyCommand.ScriptBlock.Module            
$mInfo.OnRemove = {            
    Write-Host "$($MyInvocation.MyCommand.ScriptBlock.Module.name) removed on $(Get-Date)"            
    Remove-IseMenu OracleIse            
}

Now emove on of these modules an see, which modules are left using

get-module

You see, that the removed modul removed the modules imported within too, without tribute to the fact that the other module depends on WPK and ISECreamBasic too.

Conclusion. Better do not use import-module to import module from within your modules. Import the needed modules in advance.

Have some fun trying to find work arounds for this issue.

Bernd

Removing a specific Item from a Powershell ISE Addon menu

2010-03-25T02:50:00.000-07:00

Well in ISECreamBasic I had written the function Remove-IseMenu to remove Toplevel menus.
Thanks to Shay Levi and Jaykul it became a nice advanced function with parametersets.

You can find the code in the ISE-Cream project

Just when I finished writing the header comments Ravi wanted to use the function not restricted to toplevel menu items.

First attemps tried to search the tree, but there can be more subitems with the same name hidden in the menu structure. To get it clear I designed the following function, which requires the complete path to the item to delete:

function Remove-IseMenuItem {            
            
    $submenu = $psise.CurrentPowerShellTab.AddOnsMenu.Submenus            
            
    for ($j = 0; $j -lt $args.count; $j++)            
    {            
        $name = $args[$j]            
        $count = $submenu.count            
        #Write-host "arg0: $name $count"            
        for ($i = 0; $i -lt $submenu.count; $i++)            
        {            
            $found = $false            
            if ($Submenu[$i].DisplayName -eq $name)            
            {            
                #Write-host "found toplevel menu $name"            
                $found = $True            
                if ( $j -eq ($args.count - 1))            
                {            
                    Write-host 'Removing'            
                    $null = $submenu.remove($Submenu[$i])            
                }            
                else            
                {            
                    $submenu =  $Submenu[$i].submenus            
                }            
                break            
            }            
        }            
        if (! $found)            
        {            
            Write-host "Menuitem  not found"            
            break            
        }            
                    
    }            
}            
            
Remove-IseMenuItem Edit Pad            
            
#               Remove-Child  $Submenu[$i] $Name | out-null

But this looks like an old PowerShell V1 coding style. It doesn't check that all arguments are strings. Please can someone show me, how to set up a PowerShell V2 advanced function parameter declaration for this.

ISE and PowerShell Modules

2010-03-14T07:19:00.000-07:00

The last days searched a bit the current links about PowerShell modules.

There are the two new links by Bruce Payette

http://dotnetslackers.com/articles/net/Converting-a-PowerShell-Script-into-a-Module.aspx
http://dotnetslackers.com/articles/net/Converting-a-PowerShell-Script-into-a-Module-part2.aspx

and in PowerShellPack there are lots of examples.

When you have a script module, that is one with a .psm1 file, it is easy to create a personal variant of it, be just copying it to a new folder within PSmodulePath and rename its .psm1 file to correspond to the new foldername.

There might be .psd1 and .ps1xml files which require similar and further adaptions. The modules I'm working on don't have them.

But being modules that extend ISE, they use the addons menu and the current defacto standard to build such menus is the use of the Add-IseMenu from ISEpack.

The original version from James Brundage has some shortcomings, but I succeeded in writing a compatible extension, which you find in ISE-Cream. The main advantage, is that it only warns when shortcut keys are used and just builds the menu ignoring them.

That makes it easy to copy a module, rename the top menu name in one of them and load them side by side.

At first the menus look good, but when you try them, they seem to use the function from the last imported module.
When 2 modules export the same function name, the name is rebound to the function from the last imported module. Usually menus call their functions just by name and do not hard weir the modulename into the call.
In the end both menus call the functions from the last imported module.

Of course you can take the risk and edit the modul into all function calls, but that is a lot of work and seems error phrone.
Ignorant to the possibility to prefix the calls with the module name, I added a module parameter to the ICE-Cream version of Add-IseMenu, so that I have to set it at a single point.

Whenever I see the following code:

import-module IsePack

I replace it with

if (! (test-path function:Add-IseMenu ) ) {import-module IsePack }

Did I mention, that in the ISE-Cream version, you can predefine the order of the entries?

Bernd

PS:
I noticed, that undersores in modulnames will not be displayed. Better don't use them

PauerSchell Bernd joined SQLPSX

2010-03-14T05:16:00.000-07:00

Hello database and PowerShell folks,

some days ago Chad Miller released SQLIse and soon afterwards Steven Murawski joined the SQLPSX project.

From the SQLIse project you can learn a lot about using PowerShell modules and building GUI with WPK. SQLIse uses System.Data.SqlClient, that is Ado.NET to access databases.

In the past I did some unpublished work using System.Data.OracleClient aka ODL on the database side.
In the old CTP3 days I joined the PowerShell ISE-Cream project, which did suffer a bit by the incompatible changes, which came with the PowerShell V2 RTM version.

But motivated by the execellent postings of Ravikanth Chaganti about PowerShell remoting, we began to revive that project and I learned a lot about working with multiple tabs (= PowerShell Sessions) and tuning the addons-menu.

Now I joined SQLPSX too.

I'm going to add the Connect and Invoke-ExecuteSql functions adapted to Oracle the next days.

The interface to procedure calls will take a bit longer as the coresponding SQL-Server functions aren't yet called by menu in the current version.

And as far as I know there is nothing comparable to SMO for Oracle.

One of the features I miss most on the current Oracle tools, is the fact, that they do help to display multiline fields in a wellformatted manner. Grid views tend to show only the first line and text views loose alignment. With PowerShell's Format-List cmdlet and Steves 'Result to variable' option, we can do better.

That's for now database folks, I have to do some PowerShell basics.

Bernd

PowerShell and Network Drives

2010-03-07T03:17:00.000-08:00

Hello again,
PSDrives behave something different then mapped network drives and until now I still used a cmd script to map and unmap network drives.

But I just stumbled about some posts from The scripting guys and went back to Guy's Scripting Ezine 3 - Map Network Drive
where is told how to do it in vbs.

Finally I put it all together and translated it into the modern scripting language:

            
function New-NetworkDrive            
{            
<#
.synopsis  
    A function to create Networkdrives
.Example
    New-NetworkDrive 'x' '\\localhost\C$'
.Example
    New-NetworkDrive 'Y:' '\\localhost\C$\Windows'      
#>            
    Param(            
        [string]$Drive,            
        [string]$Unc            
        )            
    $net = New-Object -com WScript.Network            
    if ($Drive.length -eq 1) { $Drive = $Drive +':' }            
    "$Drive $UNC"            
    $net.mapnetworkdrive($Drive, $Unc)            
    # ToDo -- currently I don#t need it            
    #$net.mapnetworkdrive($Drive+ ':',$Unc, $bProfile, $User, $password)            
}            
            
            
function Get-NetworkDrives            
{            
<#
.synopsis  
    A function to list the currently mapped Networkdrives
.Example
    Get-NetworkDrives
#>            
    $mappedDrives = @{}            
    $net = New-Object -com WScript.Network             
    $a = $net.EnumNetworkDrives()            
    $anz = $a.count()            
                
    for ($i = 0; $i -lt $anz; $i = $i + 2)            
    {            
        $drive = $a.item($i)            
        $path = $a.item($i+1)            
        $mappedDrives[$drive] = $path            
    }            
    $mappedDrives            
}            
            
function Remove-NetworkDrive($Drive)            
{            
<#
.synopsis  
    A function to remove Networkdrives
.Example
    Remove-NetworkDrive X
.Example
    Remove-NetworkDrive Y:      
#>            
    $net = New-Object -com WScript.Network            
    if ($Drive.length -eq 1) { $Drive += ':' }            
    $net.removenetworkdrive($Drive)            
}            
            
             
# see also            
# http://www.computerperformance.co.uk/Logon/Logon_MapNetworkDrive.htm            
# http://www.computerperformance.co.uk/Logon/LogonScript_enumnetworkdrives.htm#EnumNetworkDrives_Syntax            
            
# http://www.computerperformance.co.uk/powershell/index.htm                 
# http://blogs.technet.com/heyscriptingguy/

2nd improvement to Add-IseMenu

2010-02-15T08:22:00.000-08:00

This time I further extend Add-IseMenu, so that I have control about the order of the items. This function is compatible to the original and has extended capacibilities. This version is prove of concept. I'm still working on it.

BTW: Does anybody know how to embed seperators in ISE addon menu or has improvments to the code?

Thanks in advance.

code updated

function Add-IseMenu1 {            
    <#
    .Synopsis
        Helper function to add menus to the ISE
    .Description
        Makes adding menus to the Windows PowerShell Integrated Scripting Environment (ISE)
        easier.  Add-IseMenu accepts a hashtable of menus.  
        Each key is the name of the menu.
            Keys are automatically alphabetized, unless the 
        Each value can be one of three things:
            - A Script Block
                Selecting the menu item will run the script block
            - A Hashtable
                The value will be used to create a nested menu
            - A Script Block with a note property of ShortcutKey
                Selecting the menu item will run the script block.
                The ShortcutKey will be used to assign a shortcut key to the item
    .Example
        Add-IseMenu -Name "Get" @{
            "Process" = { Get-Process } 
            "Service" = { Get-Service } 
            "Hotfix" = {Get-Hotfix}
        }
    .Example
        Add-IseMenu -Name "Verb" @{
            Get = @{
                Process = { Get-Process }
                Service = { Get-Service } 
                Hotfix = { Get-Hotfix } 
            }
            Import = @{
                Module = { Import-Module } 
            }
        }
    .Example
        Add-IseMenu -Name "Favorites" @{
            "Edit Profile" = { psedit $profile } | 
                Add-Member NoteProperty ShortcutKey "CTRL + E" -PassThru
        }
    #>            
    param(            
        #The name of the menu to create             
        [Parameter(Mandatory=$true)]            
        [String]            
        $Name,            
        # The contents of the menu            
        [Parameter(Mandatory=$true)]            
        [Hashtable]$Menu,            
        # The root of the menu.  This is used automatically by Add-IseMenu when it             
        # creates nested menus.            
        $Root,            
        # If PassThru is set, the menu items will be outputted to the pipeline            
        [switch]$PassThru,            
        # If Merge is set, menu items will be merged with existing menus rather than            
        # recreating the entire menu.            
        [switch]$Merge                    
    )            
                
    Set-StrictMode -Off            
    if (-not $psise) { return }            
    if (-not $root) {             
        $root = $psise.CustomMenu            
        if (-not $root) {            
            $root = $psise.CurrentPowerShellTab.AddOnsMenu            
        }            
        if (-not $root) {            
            $root = $psise.CustomMenu            
        }                
    }            
    $iseMenu = $root.Submenus | Where-Object {            
        $_.DisplayName -eq $name            
    }            
    if (-not $iseMenu) {            
        $iseMenu = $root.Submenus.Add($name, $null, $null)            
    }            
    if (-not $merge) {            
        $iseMenu.Submenus.Clear()            
    }            
            
            
    $sorted = @{}            
    $menu.keys | % {             
        $order = ($menu[$_]).order            
        If ([int]$order -lt 0 ) { $order = 1000 + $order }            
        If ($order -eq $null) { $order = 500 }            
        $order = "{0,3}{1}" -f $order, $_            
        $sorted[$order] = $_ , ($menu[$_]).ShortcutKey, $menu[$_]            
        }            
    $sorted.GetEnumerator()   |             
        Sort-Object Key |             
        ForEach-Object {            
            $itemname, $ShortcutKey, $value = $_.Value            
            switch ($value) {            
                { $_ -is [Hashtable] } {            
                    # Nested menu, recurse            
                    $subMenu = $iseMenu.SubMenus.Add($itemName, $null, $null)            
                    Add-IseMenu1 $itemName $_ -root $iseMenu -passThru:$passThru            
                }            
                { $ShortcutKey } {            
                    $scriptBlock= [ScriptBlock]::Create($_)            
                    try {            
                        $m = $iseMenu.Submenus.Add($itemName, $scriptBlock, $_.ShortcutKey)            
                        }            
                    catch                
                        {            
                        Write-Host "Shortcut $($_.ShortcutKey) already in use. Menu item created without shortcut"            
                        $m = $iseMenu.Submenus.Add($itemName, $scriptBlock, $null)            
                        }            
                    if ($passThru) { $m }            
                }            
                default {            
                    $scriptBlock= [ScriptBlock]::Create($_)            
                    $m= $iseMenu.Submenus.Add($itemName, $scriptBlock, $null)            
                    if ($passThru) { $m }            
                }                             
            }            
        }            
}            
            
            
            
Add-IseMenu1 -Name "Get" @{            
    "Process" = { Get-Process }             
    "Service" = { Get-Service }             
    "Hotfix" = {Get-Hotfix}            
}            
            
            
Add-IseMenu1 -Name "Get2" @{            
    "Process" = { Get-Process } | Add-Member NoteProperty order  2 -PassThru            
    "Service" = { Get-Service } | Add-Member NoteProperty order  1 -PassThru            
    "Hotfix" = {Get-Hotfix}     | Add-Member NoteProperty order  3 -PassThru             
}

1st improvement to Add-IseMenu

2010-02-14T09:24:00.000-08:00

I hope that all users of Powershell V2 did try ISEpack from the PowerShellPack.

In the ISEpack module there is a function Add-IseMenu for creating addon menus.

On of its shortcomings is that it is not tolerant in case when a short-cut is alredy in use.

Just replace

$m = $iseMenu.Submenus.Add($itemName, $scriptBlock, $_.ShortcutKey)

with

try {            
    $m = $iseMenu.Submenus.Add($itemName, $scriptBlock, $_.ShortcutKey)            
    }            
catch                
    {            
    Write-Host "Shortcut $($_.ShortcutKey) already in use. Menu item created without shortcut"            
    $m = $iseMenu.Submenus.Add($itemName, $scriptBlock, $null)            
    }

and that know-all behaviour is past. Now in case of clashes, it just creates the menu item without the short cut and emits a message.

For the second shortcoming, no control about the order of the items, I have not yet a compatible idea.

Bernd

Which files are loaded in PowerShell ISE

2010-02-14T06:52:00.000-08:00

Here is a small function to give you information about the state of the files you have loaded into the different tabs and editors of ISE:

function Get-ISELoadedFiles () {            
    $tabcount = 0            
    foreach ($Tab in  $psise.PowerShellTabs)            
    {            
        if ($Tab -eq $psise.CurrentPowerShellTab) { $currentTab = '*' } else { $currentTab = ' ' }            
        $filecount = 0            
        if ($tab.CanInvoke) { $tabmarker = " $tabcount "} else { $tabmarker = "($tabcount)"}            
        "{0} -----{1} {2} ----- {3}" -f $currentTab, $tabmarker, $Tab.DisplayName, $tab.Prompt            
        $Tab.Files  | %{             
            if ($_ -eq $psIse.CurrentFile)  { $currentFile = '*' } else { $currentFile = ' ' }            
            if ($_.IsSaved) {$filemarker = "$filecount " } else  {$filemarker = "$filecount*" }            
            "{0}       {1} {2}" -f $currentFile, $filemarker, $_.fullpath            
            $filecount++             
        }            
        $tabcount++            
    }            
            
}

It seems to be a little difficult to find out whether a tab is local or remote and if remote to which machine it is connected. Please drop a coment, if you have hints.

Thanks

Bernd
(or on twitter @bernd_k)

Ise Menu for Backgroud Jobs

2010-02-12T01:54:00.000-08:00

And here is the working version. Thanks to hints from Shay Levi.

function Update-PSJobMenu()            
{            
    $jobs        = Get-Job             
            
    if ($jobs)            
    {            
        $receive_Job_items = @{}            
        $stop_job_items    = @{}            
        $remove_job_items  = @{}            
        $jobs | % {            
            $receive_job_items[$_.name] =     "Get-Job    -id  $([int] $_.Id) | Receive-Job "            
            $stop_job_items[$_.name]    =     "Stop-Job   -id  $([int] $_.Id) | Stop-Job "            
            $remove_job_items[$_.name]  =     "Remove-Job -id  $([int] $_.Id) | Receive-Job ; Update-PSJobMenu "            
        }            
    }            
            
    $items = @{            
    "Get-Info"                     = { Get-Job }             
            
    "Run as Job"                   = {            
                                        $cmd = [scriptblock]::create($psIse.CurrentFile.Editor.Text)            
                                        Invoke-Command -computer localhost -ScriptBlock $cmd  -asJob            
                                        Update-PSJobMenu              
                
                                     }            
    "Run selection as Job"         = {            
                                        $cmd = [scriptblock]::Create($psIse.CurrentFile.Editor.SelectedText)            
                                        Invoke-Command -computer localhost -ScriptBlock $cmd  -asJob            
                                        Update-PSJobMenu              
                                     }            
                                                 
    "Stop-Job"                     = $stop_job_items            
    "Remove-Job"                   = $remove_job_items            
            
    "Receive-Job id"               = $receive_job_items            
    "Refresh Menu"                 = { Update-PSJobMenu }            
    }            
            
    Add-IseMenu -name PSJobs $items            
}            
            
            
Update-PSJobMenu

Ise Menu for Backgroud Jobs (Trial)

2010-02-11T23:10:00.000-08:00

The following code is inspired by the planned articels from Ravikanth Chaganti about Background Jobs. If 'Run as Job' and 'Run selection as Job' would run it would be cool. But I don't see the difference to 'local background job (demo)' which is running. As in previous post get Add-IseMenu from ISEPack.

function Update-PSJobMenu()            
{            
    $jobs        = Get-Job             
            
    if ($jobs)            
    {            
        $receive_Job_items = @{}            
        $stop_job_items    = @{}            
        $remove_job_items  = @{}            
        $jobs | % {            
            $receive_job_items[$_.name] =     "Get-Job    -id  $([int] $_.Id) | Receive-Job "            
            $stop_job_items[$_.name]    =     "Stop-Job   -id  $([int] $_.Id) | Stop-Job "            
            $remove_job_items[$_.name]  =     "Remove-Job -id  $([int] $_.Id) | Receive-Job ; Update-PSJobMenu "            
        }            
    }            
            
    $items = @{            
    "Get-Info"                     = { Get-Job }             
            
    # temporary until the next 2 are working and renamed to a common path            
    "local background job (demo)"  = {             
                                        Invoke-Command -computer localhost -ScriptBlock {(Get-ChildItem C:\windows -Recurse).Count} -asJob            
                                        Update-PSJobMenu              
                                     }            
    # not working, but would be very cool            
    "Run as Job"            = {            
                                        $cmd = $psIse.CurrentFile.Editor.Text            
                                        Invoke-Command -computer localhost -ScriptBlock {$cmd } -asJob            
                                        Update-PSJobMenu              
                
                                     }            
    # not working, but would be very cool            
    # gci C:\windows -rec            
    "Run selection as Job"  = {            
                                        $cmd = $psIse.CurrentFile.Editor.SelectedText            
                                        Invoke-Command -computer localhost -ScriptBlock {$cmd } -asJob            
                                        Update-PSJobMenu              
                                     }            
                                                 
    "Stop-Job"                     = $stop_job_items            
    "Remove-Job"                   = $remove_job_items            
            
    "Receive-Job id"               = $receive_job_items            
    "Refresh Menu"                 = { Update-PSJobMenu }            
    }            
            
    Add-IseMenu -name PSJobs $items            
}            
            
            
Update-PSJobMenu

I tell me would what I have to do to fix this. Many thanks in advance.

Bernd

PSRemoting & ISE (I)

2010-02-10T22:44:00.000-08:00

If you weant to learn about PSRemoting read Ravikanth's PowerShell 2.0 remoting guide.

When you have

Enter-PSSession -ComputerName localhost

running (cf. part 3) and you have PowerShell V2 with ISE running check whether you haveISEPack installed.

Then you can try the following function which puts some remoting commands to you addon menu:

Add-IseMenu -name    Remoting  @{            
    "Get-PSSessionConfiguration"   = { Get-PSSessionConfiguration }             
            
    "Enter-PSSesion localhost"     = { Enter-PSSession localhost  }            
    "Enter-PSSession "             = {            
                                         Enter-PSSession -ComputerName (Read-Host "Enter computerName: ")            
                                         if (! $?){             
                                            Enter-PSSession -ComputerName (Read-Host "Enter computerName: ") -Credential (Get-Credential)            
                                         }            
                                      }            
    "Enter Session Id 1"           = { Enter-PSSession -Session (Get-PSSession -Id 1)}            
    "Enter Session Id 2"           = { Enter-PSSession -Session (Get-PSSession -Id 2)}            
            
    "Exit-PSSession"               = { Exit-PSSession             }            
    "Get-PSSession"                = { Get-PSSession              }            
    "New-PSSession localhost"      = { New-PSSession localhost    }            
    "New-PSSession "               = {             
                                         New-PSSession -ComputerName (Read-Host "Enter computerName: ")            
                                         if (! $?){             
                                           New-PSSession -ComputerName (Read-Host "Enter computerName: ") -Credential (Get-Credential)            
                                         }            
                                     }            
            
#    "background cmd test 1"        = { Invoke-Command -Session (Get-PSSession -Id 1) -ScriptBlock {(Get-ChildItem C:\var -Recurse).Count} -asJob  }            
    "background cmd local"         = { Invoke-Command -computer localhost -ScriptBlock {(Get-ChildItem C:\var -Recurse).Count} -asJob  }            
    "Get-Job"                      = { Get-Job                     }            
    "Get-Job 1"                    = { Get-Job -id 1 | Receive-Job }            
    "Import Session1 "             = {Import-PSSession -Session  (Get-PSSession -Id 1) -Prefix RS }            
}

I think this is rather basic. Most of it runs in the local session.
But note the Exit-PSSession entry, which is prepared in the local session, but invoked from the remote session.

Generally while in remote session, you can't acces $psISE (or I didn't yet find a work around).
So while in remote session you can not modify the addon menu.
( For dynamic modifying of the addon menu see my module loader http://pauerschell.blogspot.com/ )

I hope that helps you play with PSRemoting using ISE.

Just extended the code. Thanks to Ravi.

Out-ISEFile (V 0.91)

2010-02-01T09:23:00.000-08:00

Just posted an improved version at poshcode.

Note the filter Remove-TrailingBlanks, which uses regex to remove embedded trailing blanks.

And note the way I build back a collection from the objects running down the input pipeline.

Having back the object I can sen it to Out-String which has a width parameter (Snoopy dance).

For one thing I miss the option to pass the value 0 meaning unlimited and on the other side I'm not going to ask for the rationale of emiting trailing blanks to pad to the width. I guess this is a rudiment from the last millenium.

Finally note the -fl switch. I'm planning to implement some word wrapping, when this switch is selected.

Out-ISEFile (V 0.9)

2010-01-31T06:26:00.000-08:00

Just read the following tweet:

@MaxTrinidad Need the path to the various profile scripts on a system? Try $profile.psextended | Format-List (Try it in #PowerShell ISE too)

from @alexandair.

As I'm using ISE all day long, I tried it immedeatly and here is my result:

AllUsersAllHosts : C:\Windows\System32\WindowsPowerShell\v1.0\profile.ps1
AllUsersCurrentHost : C:\Windows\System32\WindowsPowerShell\v1.0\Microsoft.PowerShellISE_pro
file.ps1
CurrentUserAllHosts : C:\Users\berndk.MMEDVNT\Documents\WindowsPowerShell\profile.ps1
CurrentUserCurrentHost : C:\Users\berndk.MMEDVNT\Documents\WindowsPowerShell\Microsoft.PowerShe
llISE_profile.ps1

Oops again the PowerShells f***ing wrapping behavior. It's time to write a work around:

function Out-IseFile            
{            
            
    [CmdletBinding()]            
    param (            
        [Parameter(Position = 0, Mandatory = $True,  ValueFromPipeline = $True)]                    
        $msg,             
        [Parameter(Position = 1, Mandatory = $False, ValueFromPipeline = $False)]                    
        $path = $null,            
        [switch]$fl            
    )            
    if ($fl)            
    {            
        $msg = $msg |  Format-list | out-string -width 2000             
    }            
                
    $count   = $psise.CurrentPowerShellTab.Files.count            
    $null    = $psIse.CurrentPowerShellTab.Files.Add()            
    $Newfile = $psIse.CurrentPowerShellTab.Files[$count]            
    if ($path)            
    {                
        $NewFile.SaveAs($path)            
        $NewFile.Save([Text.Encoding]::default)            
    }            
    $Editor = $Newfile.Editor            
    #$Editor.SetCaretPosition($Editor.LineCount, 1)            
                
    $ar = $msg -split "`r`n" | %{ $_  -replace '\s*$', '' }            
            
    $msg = $ar -join  "`r`n"            
            
    $msg = $msg +  "`r`n"            
    $Editor.InsertText($msg)            
    $Newfile            
            
}            
            
            
$null = $profile.psextended | out-IseFile -fl

To use it just type:

$null = $profile.psextended | out-IseFile -fl

Please note: this is work in progress.
The main trick is to use Out-String with a long width parameter, that suppresses the unwanted wrapping.
For some reason (I guess it's just what we call in German Gedankenlosigkeit) Out-String emits trailing blanks. I included code to get rid of it.

Because Format-List seams rather frequent, I added the fl switch.

Remeber when ISE-Output pane behaves naughty ( and that is quite often) just send your output to a fresh editor. That makes it easy to edit and save it, if you want.

Have fun extending ISE.

Bernd

PS: Thanks to JS who made it extendable.

Remove-DuplicateFile the ISE Way

2010-01-24T04:52:00.000-08:00

The last days I spent checking some PowerShell scripts for finding and deleting duplicate files.

First we need to define which files are equal.
For most big files the criteria is simple: they are equal, when they are true copies of each other.
The second group contains text files you have edited. Here you often want to ignore some insignificant differences like trailing blanks etc. Take a look at the options of the old fc command

Let us focus today on the first approach. The best solution I found on the web is from Jason Stangroome. From him I copied the idea to use the Get-MD5 function, which closes the streams.

Without it you have some fun googling for 'The Process cannot access the file because a it is being used by another process'. Yes there seems to be ways to close files even in PowerShell, but PowerShell documentation is somewhat biased.

Using those Get-MD5 function, there is no problem in invoking Remove-item on the File you found, if you are decided to delete it.

I would prefer to use the delete method of the [System.IO.FileInfo], but I get 'Exception calling "Delete" with "0" argument(s): "Access to the path 'xxx.ps1' is denied.'
On the other side

Remove-item $($file.Fullname) -force

works fine.

I'm not following Jason in sorting the files acording to there length, but keep to a simpler design of comparing the files in the order they are output by Get-Childitem.

Instead of using -whatif I chose a different way. I just output the commands and some comments to a new ISE-file.

There I can check, whether I want to perform the delete or not and at the same time I have a fine log of the files I deleted.

The following code assumes you use PowerShell V2' ISE:

function Get-MD5([System.IO.FileInfo] $file = $(throw 'Usage: Get-MD5 [System.IO.FileInfo]'))            
{            
    # This Get-MD5 function sourced from:            
    # http://blogs.msdn.com/powershell/archive/2006/04/25/583225.aspx            
    $stream = $null;            
    $cryptoServiceProvider = [System.Security.Cryptography.MD5CryptoServiceProvider];            
    $hashAlgorithm = new-object $cryptoServiceProvider            
    $stream = $file.OpenRead();            
    $hashByteArray = $hashAlgorithm.ComputeHash($stream);            
    $stream.Close();            
            
    ## We have to be sure that we close the file stream if any exceptions are thrown.            
    trap            
    {            
        if ($stream -ne $null) { $stream.Close(); }            
        break;            
    }            
            
    return [string]$hashByteArray;            
}            
            
function New-IseFile ($path)            
{            
    $count   = $psise.CurrentPowerShellTab.Files.count            
    $null    = $psIse.CurrentPowerShellTab.Files.Add()            
    $Newfile = $psIse.CurrentPowerShellTab.Files[$count]            
    $NewFile.SaveAs($path)            
    $NewFile.Save([Text.Encoding]::default)            
    $Newfile            
            
}            
            
function Write-IseFile($file, $msg)            
{            
    $Editor = $file.Editor            
    $Editor.SetCaretPosition($Editor.LineCount, 1)            
    $Editor.InsertText(($msg  + "`r`n"))            
}            
            
            
function Remove-DuplicateFile            
{            
    [CmdletBinding()]            
    param (             
        $path      = ”.\”,             
        $extension = ”*.*”,            
        [switch]$delete              
    )            
            
                
    $Newfile = New-IseFile "$(get-location)\Delete-DuplicateFiles_$(get-date -f "yyyy-MM-dd-HH").ps1"            
            
    $hashtable = new-object system.collections.hashtable            
            
#    $global:filesToDelete = @()            
    $global:totalLength = 0            
                
    get-childitem -path $path $extension -recurse | where-object { ! $_.PSIsContainer } |             
         % {             
            $file = $_             
            $hashvalue = Get-MD5 $file            
            $length = $_.Length            
            trap {            
                $global:totalLength += $length            
$msg = @"

# current  {0} Byte   total: {1,8:f3} MB"  
# Remove-Item `'$($hashtable[$hashvalue])`' -force 
  Remove-Item `'$($file.Fullname)`' -force
"@ -f $length, $($global:totalLength/ 1MB)            
                $msg            
                Write-IseFile $Newfile $msg                    
 #               $global:filesToDelete  += $file.Fullname            
                if ($delete)            
                {            
                    Remove-item  $($file.Fullname) -force            
                    #$file.delete()            
                                
                }            
                continue             
            }            
              $hashTable.Add($hashvalue, $file.FullName)            
         }            
                     
#     Write-Host "`r`nFiles to delete`r`n"            
                 
#     foreach ($f in $filesToDelete) {            
#        Write-Host "Remove-Item `'$f`' -force"            
#     }            
    $NewFile.Save()            
}

Now you I call it with something like

Remove-DuplicateFile D:\myFiles,D:\mybackup

and get the new new ISE-Editor.

Attention using the -delete parameter the deletes where executed immediately.

My Diskqueue Problem

2010-01-17T03:40:00.001-08:00

I'm running Windows 7 and every now and than my system is nonresponsive for 60 seconds.
The esource monitor shows something like the following. Most of my current PowerShell scripts are attemps to trace down this problem.

Any ideas ?

Eval-Min, Eval-Max, $null Part II

2010-01-17T02:28:00.000-08:00

# The following relations are valid            
# All PowerShellStatements eval to True            
            
# -2 < -1 < NULL < 0 < 1 < 2            
            
-2    -lt -1            
-1    -lt $null             
$null -lt 0             
 0    -lt 1            
 1    -lt 2            
            
$null -lt 1            
            
# 2 > 1 > 0 >  NULL  > -1 > -2            
            
2     -gt 1            
1     -gt 0            
0     -gt $null            
$null -gt -1            
-1    -gt -2            
            
1     -gt $null            
            
            
# 0 is not NULL            
            
0     -ne $null            
$null -ne 0            
            
function Eval-Max             
{            
    $max = $null            
    foreach ($i in $args){            
        if ($i -ne $null){            
            if( $i -gt $max -or $max -eq $null){            
                $max = $i            
            }            
         }            
    }            
    $max            
}            
            
function Eval-Min             
{            
    $min = $null            
    foreach ($i in $args){            
        if ($i -ne $null){            
            if( $i -lt $min -or $min -eq $null){            
                $min = $i            
            }            
         }            
    }            
    $min            
}            
            
# $null handeled korrect            
            
Eval-Min $null -1            
Eval-Max $null -1            
Eval-Min -1 $null            
Eval-Max -1 $null            
            
            
# The following seem wrong             
            
Eval-Min -2 -1            
Eval-Max -2 -1

To understand what happens look at

function Show-Type (){             
    ($args[0]).gettype()            
 }             
 Show-type 1             
 Show-type -1

IsPublic IsSerial Name                                     BaseType                        
-------- -------- ----                                     --------                        
True     True     Int32                                    System.ValueType                
True     True     String                                   System.Object

I find this different behaviour is rather confusing. May we call it a bug?

When you cast the arguments to integers, you get the expected result.

Eval-Min $([int]-2) $([int]-1)            
             
 -2

When you are working with properly typed input, the functions work as aspected.

Eval-Min, Eval-Max, $null

2010-01-16T23:01:00.000-08:00

When you want to determine the minimum or maximum of some property of all items in a pipeline, you can use Measure-Object.

But when you want to do some kind of performance monitoring, you want to eval the min or max so far, without stoping the running pipeline.

Primary to improve readability in my script I wrote the following two functions.

Attention I just found wrong results for negative arguments. I'm still checking. Look at the follow-ups.

function Eval-Max             
{            
    $max = $null            
    foreach ($i in $args){            
        if ($i -gt $max){            
            $max = $i            
         }            
    }            
    $max            
}            
            
            
function Eval-Min             
{            
    $min = $null            
    foreach ($i in $args){            
        if (($i -ne $null -and $i -lt $min) -or $min -eq $null){            
            $min = $i            
         }            
    }            
    $min            
}

Note that the two functions are not symmetric. Unlike SQL here in PowerShell we have

$null -lt 1            
True            
            
$null -gt 1            
False

PowerShell $null seems to have funny mathematical behaviour. It is less than 0 but greater than each negative number. In any case it is different from SQL NULL. be warned. Me functions here follow the SQL pattern. Therefore

Eval-Min $null 1            
1

Please if you know of earlier similar PowerShell functions drop a comment.

Use PowerShell to get openfiles with handle.exe

2010-01-04T10:10:00.000-08:00

You find handle.exe at http://technet.microsoft.com/en-us/sysinternals/bb896655.aspx.

You can use the following script to store a snapshot of the open files in a grid. You have to adapt the path to handle.exe.

C:\Usr\sysint\handle.exe | foreach{            
    if ($_ -match '^(?<program>\S*)\s*pid: (?<pid>\d*)\s*(?<user>.*)$') {            
        $matches | %{             
        $id = $_.pid            
        $program = $_.program            
        $user = $_.user            
        }            
    }            
    if ($_ -match '^\s*(?<handle>[\da-z]*): File  \((?<attr>...)\)\s*(?<file>(\\\\)|([a-z]:).*)') {            
        #$_            
        $matches | select @{n="Pid";e={$id}}, @{n="Program";e={$program}}, @{n="User";e={$user}}, @{n="Handle";e={$_.handle}}, @{n="attr";e={$_.attr}}, @{n="Path";e={$_.file}}            
    }            
                
} | out-Gridview

I would like to fetch just the files in the current disk queue.

2010-01-16 Edited. I had a problem with html escape characters. Thanks for the comment.

Compare-Object & get-wmiobject win32_process does it right

2009-12-28T06:52:00.000-08:00

Hello
the fasted way to have lots of processes with the same ProcessName is use Chrome, which opens for each tab its own process and uses a few of it's own. I heard rumours that firefox will use seperate processes in future versions too. But here I'm not going to start any process vs. thread discussion. Here I will play with processes with the same name. You can just start Notepad for this purpose.

get-process | ? {$_.Name -eq 'Notepad' } | Kill            
            
            
Notepad            
Notepad            
notepad            
notepad            
            
$gp_a = get-process notepad             
$gwmip_a = get-wmiobject win32_process | ? {$_.Name -eq 'notepad.exe'}

The code above just ensures, that there are 4 instances of notepad running.
Next close one of the first 3 instances and take fresh snapshots.

$gp_b = get-process notepad             
$gwmip_b = get-wmiobject win32_process | ? {$_.Name -eq 'notepad.exe'}

Let's look at them:

$gp_a

Initially there where 4 processes:


PS C:\Var\bin> $gp_a

Handles  NPM(K)    PM(K)      WS(K) VM(M)   CPU(s)     Id ProcessName                                                        
-------  ------    -----      ----- -----   ------     -- -----------                                                        
     69       3      992       7612    72            1492 notepad                                                            
     69       3      976       4220    55            2272 notepad                                                            
     68       3      972       4096    55            3368 notepad                                                            
     13       1      284         60     2            5480 notepad

$gp_b

In second snapshot there are 3 processes (PID 2272 got killed)


PS C:\Var\bin> $gp_b

Handles  NPM(K)    PM(K)      WS(K) VM(M)   CPU(s)     Id ProcessName                                                        
-------  ------    -----      ----- -----   ------     -- -----------                                                        
     72       3     1012       7852    59            1492 notepad                                                            
     72       3     1012       7800    59            3368 notepad                                                            
     72       3     1020       7960    59            5480 notepad

Compare-Object $gp_a $gp_b |             
    Where-object {$_.SideIndicator -ne '=='} |             
    Select  -ExpandProperty InputObject

Trying to use Compare-Object on the results of get-Process, as recommended in http://technet.microsoft.com/en-us/library/ee156812.aspx I get a wrong result


PS C:\Var\bin> Compare-Object $gp_a $gp_b | 
    Where-object {$_.SideIndicator -ne '=='} | 
    Select  -ExpandProperty InputObject


Handles  NPM(K)    PM(K)      WS(K) VM(M)   CPU(s)     Id ProcessName                                                        
-------  ------    -----      ----- -----   ------     -- -----------                                                        
     13       1      284         60     2            5480 notepad

(Compare-Object $gwmip_a $gwmip_b |             
    Where-object {$_.SideIndicator -ne '=='}).Inputobject |            
    Select ProcessId, Name

while good old WMI gives the correct answer


PS C:\Var\bin> (Compare-Object $gwmip_a $gwmip_b | 
    Where-object {$_.SideIndicator -ne '=='}).Inputobject |
    Select ProcessId, Name


                                                     ProcessId Name                                                          
                                                     --------- ----                                                          
                                                          2272 notepad.exe

The documentation of Compare-Object contains the funny sentense:

The result of the comparison indicates whether a property value appeared only in the object from the Reference set (indic
ated by the <= symbol), only in the object from the Difference set (indicated by the => symbol) or, if the IncludeEqual p
arameter is specified, in both objects (indicated by the == symbol).

Does it chose a property by incident and in the case of Get-Process, does it use ProcessName instead of Id ?

Is there someone who can tell more about the logic Compare-Object uses to determine whether two objects are the same.

Small Get-Process Puzzle

2009-12-27T05:31:00.000-08:00

Hello PowerShell folks,

here I have a small puzzle for you. Please start only one instance of PowerShell odr PowerShell_ISE and run the following script.

$p1 = get-process powershell*             
$p2 = get-process powershell*             
            
$p1            
$p2            
            
$p1 -eq $p2            

Compare-Object $p1 $p2 -IncludeEqual

This time I'm not confuesed, that Compare-Object tells that both processes are equal. This time I wonder why $p1 is not equal To $p2.

When you invoke $p1 a number of times, you will see that the value CPU(s) increases. My natural expectation here is same PID same process.

Is this a PowerShell or a .NET issue ?
Do I better keep using WMI?

I get the rather strange feeling 'The more I learn, the less I know'.

Bernd

Compare-Object works different

2009-12-25T09:13:00.000-08:00

Sorry Mr. Snover. I don't grock the way Compare-Object is intented to work.

Or I'm just misinterpreting the examples in http://technet.microsoft.com/en-us/library/ee156812.aspx for a second time.

The first time I was led to think, that Compare-Object is a good basis to produce diffs of text files. It hardly is capable to tell whether they are equal or different.

This time I thought it adequat to determine the processes which where started between two calls of GET-Process.
Well it correctly tells the name of the processes involved, but having a lot of chrome processes
(Chrome Plus to be precise) I do not get the PID of correct chrome process stopped.
And for me a process is it primary it's PID and not it's name.

With a little work around I get Compare-Object to work here as expected.

function Get-ProcessProperty ( )            
{            
    [CmdletBinding()]            
    PARAM(            
        $process = '*',             
        $timestamp = "{0:T}" -f (Get-Date)            
        )            
                
    $hash1 = @{}            
    Get-Process -Name $process | % {            
        $hash2 = @{}            
        #$hash2['Time'] =  $timestamp             
        $hash2['Name'] =  $_.name            
        #$hash2['CPU']  =  $_.CPU            
        #$hash2['PM']   =   "{0,3:f0}" -f ( $_.PM  / 1MB )            
        #$hash2['NPM']  =   "{0,4:f1}" -f ( $_.NPM  / 1KB )            
        #... add further properties above            
        $hash1[($_.Id)] =  $hash2            
    }            
    $hash1            
}            
            
            
$psold = get-ProcessProperty            
            
(            
'\PhysicalDisk(_total)\Current Disk Queue Length',              
'\PhysicalDisk(_total)\Disk Transfers/sec'            
) | Get-Counter -cont -sample 1 |% {            
    $timestamp = "{0:T}" -f $_.Timestamp            
            
    $diskQueue =  ($_.CounterSamples[0]).CookedValue            
    $transfer  =  ($_.CounterSamples[1]).CookedValue             
                
    $msg = "{0}  {1,4:f0} {2,4:f0}" -f $timestamp, $diskQueue, $transfer            
            
    $psnew = get-ProcessProperty            
                
    # Show Processes that started or stopped            
    Compare-Object @($psold.keys) @($psnew.keys) |%{            
        $Id  = $_.inputObject            
        if ($_.Sideindicator -eq '=>')            
        {            
            $Name = ($psnew[$id]).Name            
            "$timestamp Start   $Id $Name"            
        }            
        if ($_.Sideindicator -eq '<=')            
        {            
            $Name = ($psold[$id]).Name            
            "$timestamp         $Id $Name   stop"            
        }            
    }            
    $psold = $psnew            
            
    # the following code is special to a problem on my Windows 7 installation                
    # my problem is, when Current Disk Queue Length > 0, but Disk Transfers/sec 0             
    if ($diskQueue -gt 0 -and  $transfer -eq 0)            
    {            
        $msg            
    }                    
}

Using PowerShell to log Start and Stop of Processes and watch some counters

2009-12-25T03:03:00.000-08:00

Merry Christmas everyone.

Today I show a little of PowerShell script, which logs when processes start and when they end.

I wrote it, because I have a very unique problem with my Windows 7. Every now and then (that may be between 10 minutes and 4 hours, my system becomes unresponsive for about 60 seconds, while the the hard drive does some mystic thing.
After a lot of logging with PowerShell I came to the conclusion, that there is a definite correspondance between the length of the Current Disk Queue Length and my problem. Especially when Disk Transfers/sec stays at 0.

The current script helps me to determine the exact time when the problem occurs.
But I didn't yet find any corresponding entries in the event-log nor could I determine the process causing this issue.

           
          
$psold = get-Process           
          
(           
'\PhysicalDisk(_total)\Current Disk Queue Length',             
'\PhysicalDisk(_total)\Disk Transfers/sec'           
) | Get-Counter -cont -sample 1 |% {           
   $timestamp = "{0:T}" -f $_.Timestamp           
          
   $diskQueue =  ($_.CounterSamples[0]).CookedValue           
   $transfer  =  ($_.CounterSamples[1]).CookedValue            
              
   $msg = "{0}  {1,4:f0} {2,4:f0}" -f $timestamp, $diskQueue, $transfer           
          
   $psnew = get-Process           
              
   # Show Processes that started or stopped           
   Compare-Object $psold $psnew |%{           
       $ipo  = $_.inputObject           
       $Name = $ipo.ProcessName           
       $Id   = $ipo.Id           
       if ($_.Sideindicator -eq '=>')           
       {           
           "$timestamp Start   $Id $Name"           
       }           
       if ($_.Sideindicator -eq '<=')           
       {           
           "$timestamp Stop    $Id $Name"           
       }           
   }           
   $psold = $psnew           
          
   # the following code is special to a problem on my Windows 7 installation               
   # my problem is, when Current Disk Queue Length > 0, but Disk Transfers/sec 0            
   if ($diskQueue -gt 0 -and  $transfer -eq 0)           
   {           
       $msg           
   }                   
}

A typical output on my system looks like this

PS C:\Var\bin> C:\Var\bin\topics\Perfmon\disk2.ps1
11:49:28 Start 7840 MultipleFirefoxLoader
11:49:30 Start 7036 firefox
11:49:30 Stop 7840 MultipleFirefoxLoader
11:50:16 Stop 6176 SearchFilterHost
11:50:16 Stop 3664 SearchProtocolHost
11:50:31 Stop 7036 firefox
11:50:44 Stop 1936 WmiPrvSE
11:51:23 1 0
11:52:44 1 0
11:54:44 1 0
11:54:47 1 0
11:54:48 1 0
11:54:49 1 0
11:54:51 4 0
11:54:52 4 0
11:54:53 9 0
11:54:54 9 0
11:54:55 10 0
11:54:56 10 0
11:54:57 10 0
11:54:59 10 0
11:55:00 11 0
11:55:01 11 0
11:55:02 11 0
11:55:03 11 0
11:55:04 11 0
11:55:05 11 0
11:55:06 11 0
11:55:08 11 0
11:55:09 11 0
11:55:10 11 0
11:55:11 12 0
11:55:12 15 0
11:55:13 Start 3252 audiodg
11:55:13 16 0
11:55:14 17 0
11:55:16 17 0
11:55:17 17 0
11:55:18 17 0
11:55:19 18 0
11:55:20 Start 5028 svchost
11:55:20 19 0
11:55:21 19 0
11:55:23 19 0
11:55:24 20 0
11:55:25 20 0
11:55:26 20 0
11:55:27 20 0
11:55:28 20 0
11:55:29 20 0
11:55:31 20 0
11:55:32 20 0
11:55:33 21 0
11:55:34 21 0
11:55:35 21 0
11:55:36 21 0
11:55:37 22 0
11:55:38 22 0
11:55:40 22 0
11:55:41 22 0
11:56:12 Stop 7712 chrome
11:56:28 Start 7712 chrome

In Resource Monitor that looks like this:

Using PowerShell to filter the eventlog

2009-12-05T01:12:00.000-08:00

Since I'm using Windows 7 in a domain where we use Microsoft Forefront Client Security I have a little problem. About every 60 minutes my computer becomes unresponsive for about 60 seconds, the hard disk led is on.

In the Application Eventlog I find pairs of Events 21268, 21269. Googling around I seem to be the only one with this special problem.

Some hints say my domain admin has to change some settings, so that my local computer can increase a local buffer. Chances to convince the forefront guys that they do some real nonsence here ( why not just ask me, whether I allow to increase the buffer) or to convince my admin to get some advice from his forefront consultant seem very low.

What the hell fills the buffer. Looking at the Security log, I see that there are lots of audit Failures.

OK, I'm not interessted in audit fails, I don't want to log them. No chance some domain policy doesn't allow me to switch off auditing of rejected packages.

Oh funny thing: I'm allowed to disable the firewall. I'm not going to try this option.

It's time to look deeper into Microsoft Eventlogs.

Seems they are very legacy application, like ipconfig and inifiles. Main information is returned as name:value pairs in plan text.

The Windows Filtering Platform has blocked a connection.

Application Information:
Process ID: 1020
Application Name: \device\harddiskvolume2\windows\system32\svchost.exe

Network Information:
Direction: Inbound
Source Address: 192.168.1.33
Source Port: 60100
Destination Address: 168.143.162.100
Destination Port: 443
Protocol: 0

Filter Information:
Filter Run-Time ID: 212121
Layer Name: Receive/Accept
Layer Run-Time ID: 44

It's time to use a little PowerShell, to convert eventlog data to properties of PowerShell objects, which can be grouped etc.

function Convert-PairToProperty2            
{            
    process             
    {            
        $hash = @{}            
                 
        $_ -split "`r?`n" | %  {            
            if (.{$m = [regex]::Matches($_,'(\w.*?):\s*(.*)');$m[0]})             
            {            
    #             Write-Host  $m[0].groups[1].value            
    #             Write-Host $m[0].groups[2].value            
                $hash[ ($m[0].groups[1].value)] = ($m[0].groups[2].value)            
            }            
         }            
        New-Object PSObject -Property $hash            
    }            
}            
            
if ($False)            
{            
'abc:123
efg:456' |Convert-PairToProperty2            
}            
            
if (!  $seclog_1000)            
{            
    Write-host "Collecting last 1000 packets rejected"            
    (Measure-Command{$seclog_1000 = get-Eventlog security -InstanceId 5152 -newest 1000 | select message }).Milliseconds            
}            
else            
{            
    'Using $seclog_1000'            
}            
$time_property2 = Measure-Command { $property2 = ($seclog_1000 | Convert-PairToProperty2) }            
            
"needed $($time_property2.Milliseconds) for property2"            
            
$property2 |group-object -property 'Source Address' -noelement |Sort-object count -desc

If you are taking a closer look, you see that I used http://blogs.msdn.com/powershell/archive/2009/12/05/new-object-psobject-property-hashtable.aspx to convert a hash to properties.

I tried different variants, but performance measurements don't show clear preferences for one or the other.

What I got is clear information which ip address causes most rejected packages.

And now using the data to generate sql INSERT-statements

2009-11-26T10:57:00.000-08:00

Before SQL-Serve 2008 sql bulks of SQL Insert-Statements are so redundant, that they are not readable.
Of corse, if you are too clever you ommit the column list after INSERT INTO.
Try it and learn it the hard way.

One of my common tasks is generating Insert Statements. Perhaps this way:

$list = (             
    ( 1, 'PS',      'PowerShell is the most inovative scripting language'),            
    ( 2, 'Python',  'has the most concise formating'),            
    ( 3, 'Algol60', 'the mother of quoted identifiers'),            
    ( 4, 'Algol68', 'the root of array slicing'),            
    ( 5, 'c#',      'if only you were caseinsentitiv casesensitivity is ORACLE''s greates fault'),            
    ( 6, 'SQL',     'has an Insert syntax which is worse than Street Basic''s Data-Statement 
                        (where we put the assembler code you remember)')             
)            
            
foreach ($item in $list)            
{            
    $id, $code, $note = $item            
    $note = $note -replace "'", "''"  # you have to double embedded apostrophes            
    "insert into Computer_Languages ( Id, Code, Note) values ( $id, '$code', '$note')"            
}

Background to problem with nested data structures

2009-11-26T08:59:00.000-08:00

Thanks Jeff for the quick response. For some reasons I memorized the following pattern:

$list = @(            
    (1,2)            
    (3,4)            
)            
$list.count

which flattens the structure and yields 4 instaed of the correct syntax

$list = (            
(1,2),            
(3,4)            
)            
$list.count

which yields 2

Once using the wrong pattern there is no escape without help.

In Python it would be basic. in PowerShell ???

2009-11-26T07:10:00.000-08:00

I hope there is a better solution in Powershell to build $list

$list = @()            
            
function add-Tupple            
{            
    $index = $list.count            
    $global:list += 1            
    $global:list[$index] = $args            
}            
            
            
add-Tupple 'Ps'     'has object pipelines'             
add-Tupple 'Python' 'has natural nested datastructures'                
            
$list.count            
            
foreach ($item in $list)            
{            
    $code, $name = $item            
    "Code: $code"            
    "Name: $name"            
}            
            
# in python (('Ps', 'has object pipelines'), ('Python', 'has natural nested datastructures'))

Manage Modules The ISE Way

2009-11-15T03:55:00.000-08:00

Hello again

Last month we got a lot of modules to try. Example given PowerShellPack or BSonPosh Powershell Module.

Of corse you do not want to add all the modules you find to your profile.
To be honest isepack is the only module I load in my profile.
I just added a smal script to my personal toolbox of ISE Add-On Extensions.

It adds and removes modules, list the currently loaded and shows the files of a module.

Pleae be warned, not all modules are writen to be removed, e.g. ispack does not remove its menus, when removed. But you have a starting point to play with.

And thanks again to James Brundage, whoes Copy-ColoredHTML (it's in the ISEpack module of the PowerShellPack) makes posting PowerShell code so easy.

function Update-ModuleMenu()            
{            
    $all_modules    = get-module -list            
    $loaded_modules = get-module             
            
    $remove_items =  @{}            
    $loaded_modules | % {            
        $name = $_.name            
        $remove_items[$_.name] = "Remove-module $name; Update-ModuleMenu"            
    }            
            
    $add_items = @{}            
    $all_modules | ? {! ($loaded_modules -contains $_ )} |            
    % {            
        $name = $_.name            
        $add_items[$_.name] = "Import-module $name; Update-ModuleMenu"            
            
    $list_items = @{}            
    $all_modules | % {            
        $list_items[$_.name] = "gci (split-path (get-module $_ -list).Path) | select Name"            
    }            
            
    $items = @{             
                "  loaded" = {Get-Module      | Sort-object | select name, path | fl}            
                " add"    = $add_items            
                " remove" = $remove_items             
                "files" = $list_items            
                }            
    }            
            
    #$items            
            
    Add-IseMenu -name 'Module' $items            
}            
            
            
Update-ModuleMenu