Miesiąc: grudzień 2015

obsługa błędów

obsługa błędu może przyprawić nieco problemu, dla tego kilka zebranych tips’n’tricks, które mogą się przydać.

try/catch nie działa!

czasem nie działa. a to dla tego, że klauza catch zostanie wykonana dla błędów 'terminujących’. większość błędów natomiast jest 'zwykłymi’ błędami, nieterminującymi. zachowanie można zmienić albo zmieniając standardowe zachowanie poprzez globalnie ustawienie zmiennej

$ErrorActionPreference="stop"

co spowoduje nadpisanie wartości ustawionych dla commandletu.

można też po prostu dodać parametr ’-ea’ dla konkretnego wywołania. przykład. to nie zadziała zgodnie z oczekiwaniami:

try { gwmi -class win32_bios -ComputerName tralla} catch { echo 'TU NIE DZIAŁA'}

napis 'tu nie działa’ nigdy się nie pojawi. poprawiona wersja:

try { gwmi -class win32_bios -ComputerName tralla -ea stop} catch { echo "TU NIE DZIAŁA" }

zapytanie reqrsywne

problem z takim wymuszeniem jest w przypadq zapytań reqrsywnych. scenariusz: chciałbym wyszukać wszystkie katalogi, do których nie mam dostępu. robię reqrsywne przejście po katalogach i ustawiam błąd jako terminujący:

try { ls -Recurse -Directory C:\Windows\ -ea stop|out-null} catch { write-host "TU NIE DZIAŁA!" }

niby działa… ale, błąd jest terminujący. co oznacza, że po pierwszym wystąpieniu zakończy działanie wykonania. zobaczymy tylko pierwszy katalog, do którego nie mamy dostępu.

należy skorzystać z innej metody – przekazania błędów do zmiennej. uzysqje się to poprzez parametr 'ErrorValue’ [alias 'ev’]. wada jest taka, że zmienna zwracana jest po zakończeniu działania. tutaj już nie ma try/catch!

ls -Recurse -Directory C:\Windows\ -ev LISTINGERRORS|out-null
foreach($lerr in $LISTINGERRORS) {
    write-host "TU NIE DZIAŁA!"
    $lerr
}

oczywiście jeśli nie chce się oglądać błędów z przebiegu, to można sobie dodać ’-ea SilentlyContinue’ .

szczegóły błędu

na ekranie nadal będzie śmietnik. fajnie byłoby złapać tylko nazwy – i np. dla nich coś wykonać. dla tego warto zapoznać się z obiektem błędu:

   TypeName: System.Management.Automation.ErrorRecord

Name                  MemberType     Definition
----                  ----------     ----------
Equals                Method         bool Equals(System.Object obj)
GetHashCode           Method         int GetHashCode()
GetObjectData         Method         void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System....
GetType               Method         type GetType()
ToString              Method         string ToString()
CategoryInfo          Property       System.Management.Automation.ErrorCategoryInfo CategoryInfo {get;}
ErrorDetails          Property       System.Management.Automation.ErrorDetails ErrorDetails {get;set;}
Exception             Property       System.Exception Exception {get;}
FullyQualifiedErrorId Property       string FullyQualifiedErrorId {get;}
InvocationInfo        Property       System.Management.Automation.InvocationInfo InvocationInfo {get;}
PipelineIterationInfo Property       System.Collections.ObjectModel.ReadOnlyCollection[int] PipelineIterationInfo {g...
ScriptStackTrace      Property       string ScriptStackTrace {get;}
TargetObject          Property       System.Object TargetObject {get;}
PSMessageDetails      ScriptProperty System.Object PSMessageDetails {get=& { Set-StrictMode -Version 1; $this.Except...

teraz widać co mamy do dyspozycji. wyjątkowo ciekawe do obsługi będą 'FullyQualifiedErrorId’ pozwalający na zdefiniowanie logiki zależnie od rodzaju błędu, oraz 'TargetObject’ gdzie powinna znaleźć się informacja o obiekcie, który wygenerował błąd. proponuję przetestować, bo tak najlepiej się uczyć:

ls -Recurse -Directory C:\Windows\ -ev LISTINGERRORS -ea SilentlyContinue|out-null
foreach($lerr in $LISTINGERRORS) {
    write-host $lerr.TargetObject
}

nie wszystko jest błędem

i na koniec – nie wszystko co my uważamy za błąd, jest błędem. nie mam teraz przygotowanego przykładu, niemniej zdarzało mi się, że commandlet zwracał null lub informował o niepowodzeniu – co było jak najbardziej prawidłowym zachowaniem a nie błędem per se. w takim przypadq trzeba sobie obsłużyć błąd zwykłym if’em bo try/catch tego nie znajdzie.

eN.

PS Proxy Function

nie podoba Ci się w jaki sposób działa jakieś polecenie? nie chcesz/nie możesz grzebać w źródłowych plikach?

dziś Kacper pokaże, w jaki sposób nadpisać standardowe polecenie, przesilając je.

.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.

Tym razem dla odmiany najpierw skrypt, potem opis.

function Copy-Item {
    [CmdletBinding(DefaultParameterSetName='Path', SupportsShouldProcess=$true, ConfirmImpact='Medium', SupportsTransactions=$true, HelpUri='http://go.microsoft.com/fwlink/?LinkID=113292')]
    param(
        [Parameter(ParameterSetName='Path', Mandatory=$true, Position=0, ValueFromPipeline=$true, ValueFromPipelineByPropertyName=$true)]
        [string[]]
        ${Path},

        [Parameter(ParameterSetName='LiteralPath', Mandatory=$true, ValueFromPipelineByPropertyName=$true)]
        [Alias('PSPath')]
        [string[]]
        ${LiteralPath},

        [Parameter(Position=1, ValueFromPipelineByPropertyName=$true)]
        [string]
        ${Destination},

        [switch]
        ${Container},

        [switch]
        ${Force},

        [string]
        ${Filter},

        [string[]]
        ${Include},

        [string[]]
        ${Exclude},

        [switch]
        ${Recurse},

        [switch]
        ${PassThru},

        [Parameter(ValueFromPipelineByPropertyName=$true)]
        [pscredential]
        [System.Management.Automation.CredentialAttribute()]
        ${Credential},
    
        [switch]
        ${Unbuffered},
    
        [switch]
        ${Progress})

    begin
    {
        try {
            $outBuffer = $null
            if ($PSBoundParameters.TryGetValue('OutBuffer', [ref]$outBuffer))
            {
                $PSBoundParameters['OutBuffer'] = 1
            }
            $wrappedCmd = $ExecutionContext.InvokeCommand.GetCommand('Microsoft.PowerShell.Management\Copy-Item', [System.Management.Automation.CommandTypes]::Cmdlet)
            if($PSBoundParameters['Unbuffered']) {
                $null = $PSBoundParameters.Remove('Unbuffered')
                $scriptCmd = {& xcopy.exe $PSBoundParameters["Path"] $PSBoundParameters["Destination"] /Y /J}
                
                if($PSBoundParameters['Progress']) {
                    $null = $PSBoundParameters.Remove('Progress')

                    $ScriptBlock = {
                        $XcopyProcess = Start-Process -FilePath xcopy -ArgumentList "$($PSBoundParameters["Path"]) $($PSBoundParameters["Destination"]) /Y /J" -Wait:$false -NoNewWindow -PassThru
                        Write-Verbose -Message "Xcopy process PID: $($XcopyProcess.Id)"
                        $FileSize = (Get-Item $PSBoundParameters["Path"]).Length / 1MB
                   
                        function Get-IoCounterMb {
                            $Runspace = [runspacefactory]::CreateRunspace()
                            $PowerShell = [powershell]::Create()
                            $PowerShell.runspace = $Runspace
                            $Runspace.Open()

                            [void]$PowerShell.AddScript({
                                [math]::Round((Get-Counter -Counter "\Process(xcopy)\IO Write Bytes/sec").CounterSamples.CookedValue / 1MB,0)
                            })

                            $PowerShell.Invoke()
                            $PowerShell.Dispose()
                        }

                        $MBSum = 0
                        do
                        {
                            Write-Verbose -Message "Waiting for xcopy process..."
                            Start-Sleep -Seconds 1
                        }
                        until (Get-Process xcopy -ErrorAction SilentlyContinue)
                        while(Get-Process xcopy -ErrorAction SilentlyContinue) {
                            $MB = Get-IoCounterMb
                            $MBSum = $MBSum + [int]$MB
                            Write-Verbose "MB copied: $MBSum, MB all: $FileSize"
                            Write-Progress -activity "Copying file" -status "Percent finished: " -PercentComplete (($MBSum / $FileSize) * 100)
                            Start-Sleep -Milliseconds 1
                        }
                    }
                    $scriptCmd = {Invoke-Command -ScriptBlock $ScriptBlock}
                }
            } else {
                $scriptCmd = {& $wrappedCmd @PSBoundParameters }
            }
            $steppablePipeline = $scriptCmd.GetSteppablePipeline($myInvocation.CommandOrigin)
            $steppablePipeline.Begin($PSCmdlet)
        } catch {
            throw
        }
    }

    process
    {
        try {
            $steppablePipeline.Process($_)
        } catch {
            throw
        }
    }

    end
    {
        try {
            $steppablePipeline.End()
        } catch {
            throw
        }
    }
    <#

    .ForwardHelpTargetName Microsoft.PowerShell.Management\Copy-Item
    .ForwardHelpCategory Cmdlet

    #>
}

Jak widać, dzieje się i to dużo. Zaczynając od początku, to co widać powyżej to tzw. proxy function. Co bystrzejsze oko pewnie zauważyło, funkcja ma dokładnie taką samą nazwę jak jeden z domyślnych cmdletów powershellowych. Proxy function powstały właśnie po to, aby umożliwić modyfikowanie działania wbudowanych cmdletów, czy też rozbudowywanie ich o nowe możliwości. Kod wydaje się być dosyć skomplikowany, ale zdecydowana większość została wygenerowana automatycznie za pomocą poniższych komend:

$cmd = New-Object System.Management.Automation.CommandMetaData (Get-Command Copy-Item)
[System.Management.Automation.ProxyCommand]::Create($cmd)

Generują one szkielet cmdletu, który chcemy modyfikować. Całość trzeba jedynie umieścić w dowolnie nazwanej funkcji. Jeśli nie nazwiemy jej tak samo jak istniejący cmdlet to stworzymy wtedy jego kopię z nowymi funkcjonalnościami oraz nazwą.

Aby zdefiniować nowe parametry, należy dodać ich definicję w sekcji param(), tak jak przypadku zwykłej funkcji. W tym przypadku, jeśli podany zostanie nowy parametr -Unbuffered, zmienna scriptCmd, która decyduje o tym co faktycznie się wykona, zostanie zmodyfikowana tak, żeby uruchamiać narzędzie xcopy, które oferuje kopiowanie bez użycia bufora (przełącznik /J). Cmdlet Copy-Item domyślnie nie posiada takiej możliwości. Ale naprawdę ciekawie zaczyna się robić, dopiero po użyciu parametru -Progress. Najpierw uruchamiane jest narzędzie xcopy z poleceniem -PassThrough, dzięki czemu można zapisać wynik w zmiennej, a potem odczytać chociażby id stworzonego procesu.

Jednak najbardziej interesującym fragmentem w tej części kodu jest funkcja Get-IoCounterMb. Dlaczego powstała i dlaczego wygląda tak, a nie inaczej? Jako, że xcopy nie udostępnia żadnych informacji nt. postępu procesu kopiowania, stwierdziłem, że sprawdzę wielkość kopiowanego pliku, a potem będę w pętli odczytywać z performance counterów ilość megabajtów zapisywanych przez proces xcopy w danym momencie. Użyłem runspace’ów, ponieważ z nieznanych mi obecnie powodów powershell nie widział szukanego countera i zwracał błąd. Dopiero utworzenie nowego wątku, podczas tworzenia runspace’a, pozwoliło mi na odczytanie wartości countera dla procesu xcopy. Dlaczego nie użyłem jobów? Ponieważ joby tworzą nowy proces, a nie wątek w obrębie istniejącego procesu, a tym samym zużywają więcej zasobów. Potem scriptblock już tylko czeka na uruchomienie xcopy i od tego momentu pokazuje postęp za pomocą Write-Progress, dopóki proces nie przestanie istnieć. Okazało się, że nie da się tym sposobem zilustrować postępu kopiowania, ponieważ cmdlet Get-Counter, mimo ustawionego czasu odstępu na 1ms w pętli, nie jest w stanie tak szybko zwracać wyników. I tak, dla pliku o wielkości 16GB, pasek postępu kończy się na 12GB. Postanowiłem zostawić jednak ten fragment w celach dydaktycznych. :) Poza tym, w tym przypadku akurat chodziło mi o orientacyjną informację.

Jedna ważna rzecz na koniec. Jeśli proxy function ma taką samą nazwę jak oryginalny cmdlet to go nadpisuje. Dopiero w nowej sesji w której funkcja nie została załadowana będzie możliwe użycie domyślnej wersji cmdletu.

Kacper.

.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.

jako komentarz dodam trick: jeśli w PS komenda zostanie przesilona, to można zmusić PS do skorzystania z oryginału, podając pełną ścieżkę wraz z modułem. w tym przypadku będzie to:

Microsoft.PowerShell.Management\copy-item

na podobny problem natrafiłem przy SCVMM, który nadpisuje standardowe commandlety hyper-V. i tak aby skorzystać z oryginalnego get-vm trzeba go uruchamiać:

Hyper-v\get-vm

aby usunąć taką funkcję wystarczy … ją usunąć:

rm function:copy-item

w Internetach częściej wykorzystywanym sposobem jest napisanie własnego copy. tworzy się strumień, odczytuje się w chunkach po kilka KB i wyświetla progress bar [np. tu http://stackoverflow.com/questions/2434133/progress-during-large-file-copy-copy-item-write-progress] .pomysł z odczytem liczników wydajności – niezłe (:

niemniej nie mam zaufania to takich metod i pozostaje kwestia mechanizmów cache itd. biblioteka systemowa daje pewne gwarancje. na koniec na wszelki wypadek wolałbym sprawdzić CRC (;

eN.

Excel zamiast CSV

pliki CSV są u mnie w powszechnym użyciu. łatwe w obsłudze, nie wymagają żadnych dodatków, wystarczy podstawowa wersja PS nawet w starej wersji i można generować raporty, łatwy export z excel pozwala to tworzenie pliqw wsadowych z danych z innych działów. wygodnie.

czasem jednak fajnie byłoby ominąć konieczność przejścia xlsx -> csv ->xlsx i wykonać jakieś operacje bezpośrednio. można w tym celu wykorzystać obiekt DCOM. jest sporo doqmentów, opisów – może nie jest to super trywialne i trzeba się przegryźć przez dały model DOM, ale do przeżycia. no i ma podstawową wadę – wymaga zainstalowanego MSExcel na komputerze, na którym wykonuje się operację. na stacji roboczej to zazwyczaj nie problem. na serwerze na odwrót.

rozwiązaniem jest wykorzystanie otwartej biblioteki EPPlus dostępnej na codeplex. nie eliminuje to konieczności znajomości DOM – nadal jest to tylko biblioteka, która pozwala na otwarcie pliq.

jest też gotowy moduł PS, który pozwala wykorzystać ją bez znajomości budowy plików excel. ma oczywiście poważne ograniczenia, jednak implementuje podstawowe operacje, wystarczające do codziennego skryptowania. są nawet funkcje, które wstawiają do arkusza wykresy a więc bardzo dobra opcja dla skryptów raportujących – w pełni zautomatyzowany skrypt, działający na serwerze, bez konieczności instalacji Office, wysyłający raporty xlsx.

w PS5.o można moduł doinstalować bezpośrednio z galerii PS poleceniem

install-module importExcel

można też go zassać z GitHuba ręcznie, dla starszych wersji.

na blogu scripting guy znajdziecie bogatszy opis zaopatrzony w kilka przykładów.

eN.

wyciąganie notatek z kindle

dziś znów gościnnie Kacper ze skryptem w służbie codzienności. pomysły zastosowania PS nie tylko do zadań administracyjnych, a również w zwykłych domowych warunkach, są mocno inspirujące. ponieważ wpisy dotyczą wyrażeń regularnych, sugeruję zapoznanie się z podstawami – np. na stronie regular-expressions.

dziś skrypt automatyzujący wyciąganie 'clippingów’ z kindle… oddaję głos Kacprowi:

.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.

Od kiedy posiadam Kindle’a kupiłem tylko jedną książkę w wersji papierowej. Wśród wielu zalet Kindle ukrywa się jedna, która w szczególności przypadła mi do gustu. Nazywa się ona – My Clippings.txt. Czytniki Amazonu przechowują w tym pliku wszystkie notatki czy zaznaczenia związane z czytanymi książkami. Przykładowe wpisy w tym pliku wyglądają tak:

Mastering System Center 2012 R2 Configuration Manager (Santos Martinez, Peter Daalmans and Brett Bennett)
- Highlight on Page 183 | Loc. 5477-87  | Added on Friday, January 09, 2015, 03:46 AM

Some of the information that is accessible with this extra level of logging is so useful that it is common practice to configure verbose and debug logging as a standard across the environment. There is additional overhead because more data is written to the logs, but it is minimal and should cause no impact to the operation of the system. Enabling verbose and debug logging requires two registry changes. First, you enable verbose logging by navigating to [HKEY_LOCAL_MACHINE\software\microsoft\ccm\logging@global] and changing the value LogLevel to 0 (which will require a permissions change on the @GLOBAL key). To enable debug logging, create a registry key called DebugLogging directly under [HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\CCM\Logging] Inside this registry key create a string value named Enabled and set its value to True.
==========
Mastering System Center 2012 R2 Configuration Manager (Santos Martinez, Peter Daalmans and Brett Bennett)
- Highlight on Page 184 | Loc. 5519-22  | Added on Friday, January 09, 2015, 03:47 AM

smsdbmon.log This log shows all activities such as inserts, updates, drops, and deletes from the Configuration Manager 2012 R2 database. smsprov.log This log shows the SQL transaction calls made from the Configuration Manager console or automation scripts via the SDK.
==========

Jak widać, mamy tu do czynienia z pewnym schematem, a to daje nam możliwość przekształcenia tych danych na inny format. Zazwyczaj kiedy czytam książkę pierwszy raz, robię dużo zaznaczeń, żeby potem mieć możliwość przypomnienia sobie tych kwestii, które mnie najbardziej interesowały. Można oczywiście przeglądać sobie zawartość My Clippings.txt w celu odświeżenia pamięci, jednak Kindle wpisuje tam wszystko w sposób chronologiczny. Jeśli więc czytam w tym samym czasie dwie książki, to i zaznaczenia będą się przeplatały. Aby ułatwić sobie życie postanowiłem napisać skrypt, który przetworzy dane z pliku My Clippings.txt tak, żeby można było np. filtrować z której książki zaznaczenia chcemy wyświetlić.:

[CmdletBinding()]
Param
(
    # Path to My Clippings.txt file
    [Parameter(Mandatory=$true,
                ValueFromPipeline=$true,
                ValueFromPipelineByPropertyName=$true,
                Position=0)]
    [Alias('FullName')]
    [String[]]$Path
)

Begin
{
    $Clippings = @()
}
Process
{
    Foreach($File in $Path){
        $Content = Get-Content -Path $File
        $i = 0

        do{
            $Clipping = ""
            # Prepare clipping
            do{
                $Clipping += $Content[$i]
                if($Clipping.EndsWith('AM') -or $Clipping.EndsWith('PM')){
                    $Clipping += ';'
                }
                $i++
                Write-Verbose -Message "i: $i"
            } while ($Content[$i] -ne '==========')

            $i++
            Write-Verbose -Message "Clipping content: $Clipping"

            # Format clipping
            # Extract clipping type
            $Pattern = "- (.*?) "
            $Match = $Clipping -match $Pattern
            $ClippingType = $Matches[1]
            
            # Extract book title
            $Pattern = ".*(?=- )"
            $Match = $Clipping -match $Pattern
            $BookTitle = $Matches[0]

            # Extract clipping content
            $Pattern = "\;(.*)"
            $Match = $Clipping -match $Pattern
            $ClippingContent = $Matches[1]

            # Prepare object
            $Props = @{
                BookTitle = $BookTitle
                ClippingType = $ClippingType
                Content = $ClippingContent
            }
            $Object = New-Object PSObject -Property $Props

            # Add object to array
            $Clippings += $Object

        } while ($i -ne ($Content.Length))
    }
}
End
{
    # Return clippings array
    return $Clippings
}

Jak widać skrypt nie jest skomplikowany, a najciekawsze fragmenty to regexy, które pobierają określony typ danych.

Na samym początku wstawiam średnik pomiędzy samą zawartość wpisu, a metadane. Prawdopodobnie nie jest to konieczne, ale znacznie mi ułatwiło tworzenie regexa w sekcji oznaczonej komentarzem „Extract clipping content”. Potem za pomocą wyrażenia „- (.*?) ” wydobywany jest typ wpisu. Zastosowanie nawiasów tworzy tzw. capturing groups, dzięki którym zwracana jest sama nazwa bez otaczających znaków. Jest to alternatywna wersja zapisu [Regex]::Matches($Clipping, $Pattern), który omawiałem w poprzednim wpisie.

Przy zapisywaniu tytułu książki do zmiennej wykorzystuję wyrażenie „.*(?=- )”. Ten regex zawiera tzw. positive lookahead, który zwraca wszystko od początku stringa aż do wystąpienia sekwencji znaków „- „, nie uwzględniając samej sekwencji (za to jest odpowiedzialny positive lookahead właśnie).

Na sam koniec, ponownie korzystając z capturing groups, pobieram wszystko co jest za znakiem średnika i zapisuję w zmiennej ClippingContent. Dalej jest już tylko stworzenie obiektu przy pomocy hashtable’a i dodanie go do tablicy Clippings, która jest zwracana przez skrypt.

Kacper

.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.oOo.

eN.