windows powershell™ - pr · outlook, sql server, visual basic, windows, windows nt, windows...

Windows PowerShell™Przewodnik po skryptach

Ed Wilson

Windows PowerShell™ – Przewodnik po skryptachEdycja polska Microsoft Press

Original English language edition © 2008 by Ed WilsonTytuł oryginału: Windows PowerShell™ Scripting Guide

Polish edition by APN PROMISE Sp. z o. o. Warszawa 2008

APN PROMISE Sp. z o. o., biuro: 00-108 Warszawa, ul. Zielna 39tel. (022) 355-16-00; fax (022) 355-16-99

e-mail: [email protected]

Wszystkie prawa zastrzeżone. Żadna część niniejszej książki nie może być powielana ani rozpowszechniana w jakiejkolwiek formie i w jakikolwiek sposób (elektroniczny,

mechaniczny), włącznie z fotokopiowaniem, nagrywaniem na taśmy lub przy użyciu innych systemów bez pisemnej zgody wydawcy.

Microsoft, Microsoft Press, Active Directory, ActiveX, Excel, Internet Explorer, MSDN, MSN, Outlook, SQL Server, Visual Basic, Windows, Windows NT, Windows PowerShell, Windows

Server, Windows Vista oraz Zune są zarejestrowanymi znakami towarowymi Microsoft Corporation.

Wszystkie inne nazwy handlowe i towarowe występujące w niniejszej publikacji mogą być znakami towarowymi zastrzeżonymi lub nazwami zastrzeżonymi odpowiednich firm

odnośnych właścicieli.

Przykłady firm, produktów, osób i wydarzeń opisane w niniejszej książce są fikcyjne i nie odnoszą się do żadnych konkretnych firm, produktów, osób i wydarzeń. Ewentualne

podobieństwo do jakiejkolwiek rzeczywistej firmy, organizacji, produktu, nazwy domeny, adresu poczty elektronicznej, logo, osoby, miejsca lub zdarzenia jest przypadkowe i niezamierzone.

APN PROMISE Sp. z o. o. dołożyła wszelkich starań, aby zapewnić najwyższą jakość tej publikacji. Jednakże nikomu nie udziela się rękojmi ani gwarancji.

APN PROMISE Sp. z o. o. nie jest w żadnym wypadku odpowiedzialna za jakiekolwiek szkody będące następstwem korzystania z informacji zawartych w niniejszej publikacji, nawet jeśli

APN PROMISE została powiadomiona o możliwości wystąpienia szkód.

ISBN: 978-83-7541-033-4

Przekład: Krzysztof Szkudlarek,Jowita Chościłowicz, Barbara Piątkowska, Tomasz Sochacki

Redakcja: Marek WłodarzKorekta: Ewa Swędrowska

Skład i łamanie: MAWart Marek Włodarz

Spis treści

Podziękowania ............................................................................................................................... xiWstęp .............................................................................................................................................. xiii

1 Powłoka programu Windows PowerShell ................................................................ 1Instalowanie programu Windows PowerShell ........................................................................ 1

Sprawdzanie instalacji za pomocą skryptu w języku VBScript ..................................... 1Wdrażanie programu Windows PowerShell ...................................................................... 2

Interakcja z powłoką ..................................................................................................................... 4Omówienie narzędzi wiersza poleceń typu Cmdlet ............................................................. 6Konfi gurowanie programu Windows PowerShell .................................................................. 7

Tworzenie profi lu programu Windows PowerShell ......................................................... 7Konfi gurowanie opcji uruchamiania programu Windows PowerShell....................... 7

Kwestie bezpieczeństwa w programie Windows PowerShell ............................................. 8Kontrolowanie działania poleceń typu Cmdlet ................................................................ 8Potwierdzanie poleceń ..........................................................................................................10Zawieszanie potwierdzeń wykonywania poleceń typu Cmdlet .................................12

Przekazywanie opcji dla poleceń typu cmdlet .....................................................................14Korzystanie z polecenia Get-Help (Pobierz pomoc) ...........................................................15Praca z aliasami i przypisywanie skróconych nazw poleceniom typu cmdlet .............18Dodatkowe zastosowania poleceń typu cmdlet ..................................................................19

Korzystanie z polecenia Get-ChildItem .............................................................................21Formatowanie wyjścia ...........................................................................................................21Stosowanie polecenia cmdlet Get-Command ................................................................29Eksploracja obiektów przy użyciu polecenia Get-Member .........................................32

Podsumowanie ..............................................................................................................................36

2 Skrypty programu Windows PowerShell ................................................................37

Dlaczego warto korzystać ze skryptów? ................................................................................37Konfi gurowanie zasady obsługi skryptów .............................................................................40Uruchamianie skryptów programu Windows PowerShell .................................................43Stosowanie zmiennych ...............................................................................................................44Stosowanie stałych .......................................................................................................................45Używanie instrukcji sterujących ................................................................................................46

Dodawanie parametrów do polecenia ForEach-Object ...............................................47Stosowanie parametru Begin ...............................................................................................47Stosowanie parametru Process ...........................................................................................48Stosowanie parametru End ..................................................................................................48

Używanie instrukcji For ...............................................................................................................48Używanie instrukcji służących do podejmowania decyzji .................................................49

Używanie instrukcji If … Elseif … Else .................................................................................50Używanie instrukcji Switch ...................................................................................................51

Spis treści v

Praca z typami danych ................................................................................................................55Odkrywamy możliwości wyrażeń regularnych .....................................................................59Używanie argumentów podawanych w wierszu poleceń .................................................63Podsumowanie ..............................................................................................................................64

3 Zarządzanie dziennikami ..................................................................................................65

Identyfi kowanie dzienników zdarzeń .....................................................................................65Odczytywanie dzienników zdarzeń .........................................................................................66

Eksportowanie do pliku tekstowego .................................................................................67Eksportowanie do pliku w formacie XML ........................................................................69

Przeglądanie ogólnych plików dzienników ..........................................................................71Analizowanie kilku dzienników ...........................................................................................72Pobieranie pojedynczego wpisu z dziennika zdarzeń ..................................................73

Przeszukiwanie dziennika zdarzeń ..........................................................................................76Filtrowanie zdarzeń według właściwości ..........................................................................77Wybór źródła zdarzeń ...........................................................................................................77Wybór stopnia ważności zdarzeń .......................................................................................78Wybieranie komunikatów ....................................................................................................78

Zarządzanie dziennikiem zdarzeń ...........................................................................................79Identyfi kowanie źródeł zdarzeń .........................................................................................79Modyfi kowanie ustawień dziennika zdarzeń ..................................................................80

Analizowanie dziennika zdarzeń podsystemu WMI ...........................................................84Zmienianie poziomu rejestrowania podsystemu WMI .................................................84Korzystanie z programu narzędziowego do obsługi zdarzeń

systemu Windows – Windows Event Command-Line Utility .................................85Zapisywanie informacji w dziennikach zdarzeń ...................................................................86

Tworzenie źródła zdarzeń ....................................................................................................86Umieszczanie w dzienniku wyników zwracanych przez polecenia typu cmdlet ...87

Tworzenie własnych dzienników zdarzeń ..............................................................................89Podsumowanie ..............................................................................................................................90

4 Zarządzanie usługami .........................................................................................................91

Dokumentowanie istniejących usług ......................................................................................91Praca z działającymi usługami ............................................................................................92Zapisywanie wyników w pliku tekstowym .......................................................................93Zapisywanie wyników w bazie danych .............................................................................96

Ustawianie konfi guracji usług ................................................................................................ 106Akceptowanie argumentów podawanych w wierszu poleceń ................................ 108Zatrzymywanie usług .......................................................................................................... 109Poprawne zatrzymywanie usług ...................................................................................... 110Uruchamianie usług ............................................................................................................ 113Poprawne uruchamianie usług ........................................................................................ 114

Utrzymywanie pożądanej konfi guracji usług .................................................................... 120Sprawdzanie, czy właściwe usługi są zatrzymane ....................................................... 121Odczytywanie pliku i sprawdzanie stanu usług ........................................................... 122Sprawdzanie, czy właściwe usługi są uruchomione ................................................... 122

vi Spis treści

Sprawdzanie konfi guracji usług ............................................................................................ 123Tworzenie raportu o wyjątkach ............................................................................................. 124Podsumowanie ........................................................................................................................... 126

5 Zarządzanie udziałami ..................................................................................................... 127

Dokumentowanie udziałów ................................................................................................... 127Dokumentowanie udziałów użytkownika ..................................................................... 134Zapisywanie informacji o udziałach w pliku tekstowym ........................................... 137Dokumentowanie udziałów administracyjnych .......................................................... 138Zapisywanie informacji o udziałach w bazie danych programu

Microsoft Access ............................................................................................................. 139Prowadzenie inspekcji udziałów ........................................................................................... 143Modyfi kowanie udziałów ........................................................................................................ 146

Używanie w skrypcie parametrów .................................................................................. 147Tłumaczenie kodu powrotu .............................................................................................. 148

Tworzenie nowych udziałów .................................................................................................. 150Tworzenie kilku udziałów ........................................................................................................ 155Usuwanie udziałów ................................................................................................................... 157Usuwanie tylko niedozwolonych udziałów ........................................................................ 159Podsumowanie ........................................................................................................................... 160

6 Zarządzanie drukarkami ................................................................................................. 161

Tworzenie spisu zainstalowanych drukarek ....................................................................... 161Odpytywanie wielu komputerów .................................................................................... 163Rejestrowanie do pliku ....................................................................................................... 164Zapisywanie informacji w bazie danych programu Microsoft Access ................... 166

Raportowanie portów drukarek ............................................................................................ 172Identyfi kowanie sterowników drukarek .............................................................................. 177Instalowanie sterowników drukarek ..................................................................................... 179

Instalowanie znalezionych na komputerze sterowników drukarki ........................ 180Instalowanie sterowników drukarek, których nie znaleziono na komputerze .... 182

Podsumowanie ........................................................................................................................... 184

7 Bieżące administrowanie komputerami osobistymi ..................................... 185

Utrzymywanie właściwego stanu komputerów osobistych ........................................... 185Tworzenie spisu dysków ..................................................................................................... 185Zapisywanie informacji o konfi guracji dysków, w bazie danych programu

Microsoft Access ............................................................................................................. 189Praca z partycjami ............................................................................................................... 193Dopasowywanie dysków i partycji .................................................................................. 195Praca z dyskami logicznymi .............................................................................................. 198

Monitorowanie stopnia wykorzystania przestrzeni dyskowej ...................................... 203Rejestrowanie informacji o zajętości przestrzeni dyskowej, w bazie danych ...... 207Monitorowanie czasu życia plików ................................................................................. 211

Monitorowanie wydajności..................................................................................................... 214Korzystanie z klas liczników wydajności ........................................................................ 215

Spis treści vii

Identyfi kowanie źródeł błędów stronicowania ............................................................ 219Podsumowanie ........................................................................................................................... 220

8 Praca z siecią .......................................................................................................................... 221

Praca z ustawieniami sieci ....................................................................................................... 221Raportowanie ustawień sieci ............................................................................................ 221Odczytywanie konfi guracji kart sieciowych.................................................................. 226Filtrowanie tylko właściwości posiadających wartość ................................................ 232

Konfi gurowanie ustawień karty sieciowej........................................................................... 237Wykrywanie obecności kilku kart sieciowych .............................................................. 237Zapisywanie informacji o kartach sieciowych w arkuszu kalkulacyjnym

programu Microsoft Excel ............................................................................................ 238Identyfi kowanie podłączonych kart sieciowych .......................................................... 242Ustawianie statycznego adresu IP ................................................................................... 244Włączanie obsługi protokołu DHCP ............................................................................... 249

Konfi gurowanie zapory ogniowej systemu Windows ..................................................... 254Raportowanie ustawień zapory ogniowej .................................................................... 254Konfi gurowanie ustawień zapory ogniowej ................................................................. 256

Podsumowanie ........................................................................................................................... 257

9 Konfi gurowanie ustawień pulpitu ............................................................................ 259

Problemy związane ustawieniami konfi guracyjnymi pulpitu ........................................ 259Konfi gurowanie wygaszaczy ekranu .................................................................................... 259

Prowadzenie inspekcji wygaszaczy ekranu ................................................................... 260Wyświetlanie tylko właściwości posiadających wartość ............................................ 267Tworzenie raportów z informacjami o zabezpieczonych wygaszaczach ekranu .. 271

Zarządzanie opcjami zasilania komputerów osobistych ................................................ 278Modyfi kowanie schematu zasilania ...................................................................................... 284Podsumowanie ........................................................................................................................... 290

10 Rozwiązywanie problemów występujących po zakończeniu wdrożenia ................................................................................................................................ 291

Konfi gurowanie daty i godziny ............................................................................................. 291Zdalne konfi gurowanie daty i godziny .......................................................................... 292Rejestrowanie rezultatów w dzienniku zdarzeń .......................................................... 298

Konfi gurowanie źródła czasu ................................................................................................. 303Korzystanie z polecenia Net Time Command .............................................................. 304Sprawdzanie źródła czasu poprzez odpytywanie rejestru systemu ....................... 307

Włączanie kont użytkowników .............................................................................................. 312Tworzenie lokalnego konta użytkownika ........................................................................... 317

Tworzenie użytkownika lokalnego .................................................................................. 318Tworzenie lokalnej grupy użytkowników ...................................................................... 321

Konfi gurowanie wygaszacza ekranu .................................................................................... 324Zmienianie nazwy komputera ............................................................................................... 331Wyłączanie lub ponowne uruchamianie komputera zdalnego ................................... 334Podsumowanie ........................................................................................................................... 338

viii Spis treści

11 Zarządzanie danymi użytkowników ........................................................................ 339

Praca z kopiami zapasowymi ................................................................................................. 339Konfi gurowanie plików trybu offl ine ................................................................................... 342Włączenie funkcji plików trybu offl ine ................................................................................ 346Praca z punktami przywracania systemu ............................................................................ 354

Odczytywanie ustawień funkcji przywracania systemu ............................................. 355Wyświetlanie listy dostępnych punktów przywracania systemu ............................ 358

Podsumowanie ........................................................................................................................... 362

12 Rozwiązywanie problemów związanych z systemem Windows ............ 363

Rozwiązywanie problemów związanych z uruchamianiem systemu .......................... 363Sprawdzanie konfi guracji rozruchowej .......................................................................... 363Sprawdzanie konfi guracji usług uruchamianych podczas

uruchamiania systemu................................................................................................... 366Wyświetlanie zależności pomiędzy usługami .................................................................... 369

Sprawdzanie konfi guracji sterowników urządzeń uruchamianych podczas uruchamiania systemu................................................................................................... 375

Analizowanie procesów uruchamianych za pomocą grupy Autostart ................. 379Analizowanie problemów sprzętowych .............................................................................. 383Rozwiązywanie problemów związanych z funkcjonowaniem sieci ............................. 388Podsumowanie ........................................................................................................................... 391

13 Zarządzanie kontami użytkowników domeny ................................................ 393

Tworzenie jednostek organizacyjnych ................................................................................. 393Tworzenie kont użytkowników domeny ............................................................................. 396Modyfi kowanie atrybutów użytkownika ............................................................................ 400

Modyfi kowanie ogólnych informacji o użytkowniku ................................................. 400Modyfi kowanie atrybutów dostępnych na zakładce Address (Adres) .................. 402Modyfi kowanie atrybutów dostępnych na zakładce Profi le (Profi l) ...................... 403Modyfi kowanie atrybutów dostępnych na zakładce Telephone ............................ 404Modyfi kowanie atrybutów dostępnych na zakładce Organization ....................... 405Modyfi kowanie pojedynczych atrybutów użytkowników ........................................ 406

Tworzenie kont użytkowników na podstawie pliku w formacie .csv ........................... 409Ustawianie hasła ................................................................................................................... 409Włączanie konta użytkownika ........................................................................................ 410

Tworzenie grup domenowych ............................................................................................... 411Dodawanie użytkownika do grupy domenowej ............................................................... 414Dodawanie wielu użytkowników z wieloma atrybutami ................................................ 416Podsumowanie ........................................................................................................................... 420

14 Konfi gurowanie usługi klastrowania ...................................................................... 421

Analizowanie konfi guracji sklastrowanych serwerów ..................................................... 421Tworzenie raportu z informacjami o konfi guracji klastra ......................................... 428Tworzenie raportu z informacjami o konfi guracji węzła .......................................... 432Odpytywanie kilku klas związanych z usługą klastra ................................................. 437

Zarządzanie węzłami ................................................................................................................ 448

Spis treści ix

Dodawanie i wykluczanie węzłów ................................................................................... 448Usuwanie klastra .................................................................................................................. 454

Podsumowanie ........................................................................................................................... 459

15 Zarządzanie internetowymi usługami informacyjnymi .............................. 461

Włączanie możliwości zarządzania internetowymi usługami informacyjnymi ........ 461Tworzenie raportu z informacjami o konfi guracji usługi IIS .......................................... 463

Tworzenie raportów z informacjami o konfi guracji witryny .................................... 463Tworzenie raportów z informacjami o konfi guracji puli aplikacji .......................... 466Tworzenie raportów z informacjami o wartościach domyślnych puli aplikacji .. 469Tworzenie raportów z informacjami o limitach witryny ........................................... 472Tworzenie listy katalogów wirtualnych .......................................................................... 476

Tworzenie nowej witryny webowej ...................................................................................... 478Tworzenie nowej puli aplikacji ............................................................................................... 484Uruchamianie i zatrzymywanie witryn webowych ........................................................... 487Podsumowanie ........................................................................................................................... 491

16 Praca z magazynem certyfi katów ............................................................................. 493

Lokalizowanie certyfi katów w magazynie certyfi katów ................................................. 493Wyświetlanie listy certyfi katów ........................................................................................ 499Lokalizowanie wygasłych certyfi katów .......................................................................... 503Identyfi kowanie certyfi katów, których ważność wygaśnie wkrótce ...................... 508

Zarządzanie certyfi katami ....................................................................................................... 513Inspekcja certyfi katu ........................................................................................................... 513Importowanie certyfi katu .................................................................................................. 517Usuwanie certyfi katów ....................................................................................................... 521

Podsumowanie ........................................................................................................................... 528

17 Zarządzanie usługami terminalowymi .................................................................. 529

Konfi gurowanie instalacji usług terminalowych ............................................................... 529Dokumentowanie konfi guracji usług terminalowych ................................................ 529Wyłączanie możliwości logowania się ........................................................................... 533Modyfi kowanie właściwości klienta ................................................................................ 537

Zarządzanie użytkownikami ................................................................................................... 542Włączanie użytkownikom możliwości korzystania z serwera .................................. 544Konfi gurowanie ustawień klienta .................................................................................... 548

Podsumowanie ........................................................................................................................... 560

18 Konfi gurowanie usług sieciowych ............................................................................ 561

Tworzenie raportów z informacjami o ustawieniach serwera DNS ............................. 561Konfi gurowanie ustawień rejestrowania dla serwera DNS ....................................... 568Tworzenie raportów z informacjami o wskazówkach dotyczących

serwerów głównych ....................................................................................................... 577Odpytywanie rekordów typu „A” ..................................................................................... 578

Konfi gurowanie ustawień serwera DNS .............................................................................. 584Tworzenie raportów z informacjami o strefach DNS....................................................... 590

x Spis treści

Tworzenie stref DNS ................................................................................................................. 593Zarządzanie serwerami WINS i DHCP ................................................................................. 598Podsumowanie ........................................................................................................................... 604

19 Praca z systemem Windows Server 2008 Server Core ................................ 605

Konfi guracja początkowa ........................................................................................................ 605Podłączanie serwera do domeny .................................................................................... 606Konfi gurowanie adresu IP ................................................................................................. 614Konfi gurowanie ustawień DNS ........................................................................................ 620Zmiana nazwy serwera ....................................................................................................... 628

Zarządzanie systemem Windows Server 2008 Server Core........................................... 634Monitorowanie serwera ..................................................................................................... 635Odpytywanie dziennika zdarzeń ..................................................................................... 637

Podsumowanie ........................................................................................................................... 640

A Konwencja nazw dla narzędzi typu cmdlet ........................................................ 641

B Nazwy dostawców obiektów danych typu ActiveX ...................................... 645

C Często zadawane pytania .............................................................................................. 647

D Wskazówki dotyczące tworzenia skryptów........................................................ 655

Ogólna konstrukcja skryptu ................................................................................................... 655Funkcje należy umieszczać w skryptach, które je wywołują .................................... 655Należy stosować pełne nazwy poleceń typu cmdlet oraz pełne nazwy

parametrów ...................................................................................................................... 656Należy używać polecenia Get-Item, przekształcając tekstowe ścieżki

do plików we wszechstronne obiekty ....................................................................... 657Ogólna czytelność skryptu ..................................................................................................... 657Formatowanie kodu.................................................................................................................. 658

Praca z funkcjami ................................................................................................................. 660Tworzenie plików z szablonami ....................................................................................... 662Pisanie funkcji ....................................................................................................................... 662Tworzenie i nazywanie zmiennych oraz stałych .......................................................... 662

E Ogólne wskazówki dotyczące rozwiązywania problemów ....................... 665

1

Rozdział 1

Powłoka programu Windows PowerShellPo ukończeniu tego rozdziału Czytelnik będzie potrafi ł: ■ Instalować i konfigurować program Windows PowerShell. ■ Radzić sobie z problematyką bezpieczeństwa w programie Windows PowerShell. ■ Zrozumieć podstawy działania i korzystania z poleceń typu cmdlet. ■ Używać aliasów do przypisywania skróconych nazw poleceniom typu cmdlet. ■ Uzyskiwać pomoc dotyczącą korzystania z programu Windows PowerShell.

Na dysku CD Wszystkie używane w tym rozdziale skrypty znajdują się na towarzyszącej tej książce płycie CD-ROM w folderze \scripts\chapter01.

Instalowanie programu Windows PowerShellPonieważ domyślnie program Windows PowerShell nie jest instalowany w żadnym syste-mie operacyjnym firmy Microsoft, dlatego bardzo ważne jest, aby przed przystąpieniem do wdrażania rzeczywistych skryptów lub poleceń sprawdzić, czy program Windows PowerShell został zainstalowany na danej platformie. Najprościej można to zrobić próbu-jąc wykonać jedno z poleceń programu Windows PowerShell i sprawdzając, czy polecenie to nie zwróci błędów. Zadanie to można z łatwością zrealizować z poziomu pliku wsado-wego, sprawdzając wartość zmiennej %errorlevel%.

Sprawdzanie instalacji za pomocą skryptu w języku VBScriptBardziej złożone podejście do zadania polegającego na sprawdzeniu, czy w systemie ope-racyjnym zainstalowany został program Windows PowerShell, polega na użyciu skryptu korzystającego z obiektu WMI (Windows Management Instrumentation – Instrumentacja zarządzania systemu Windows), o nazwie Win32_QuickFixEngineering. Przykład wyko-rzystania obiektu Win32_QuickFixEngineering w języku Microsoft Visual Basic Scripting Edition (VBScript) do wykrycia instalacji programu Windows PowerShell znajduje się w skrypcie FindPowerSell.vbs.

Skrypt FindPowerShell.vbs wykorzystuje alternatywną nazwę (ang. moniker) systemu WMI do utworzenia instancji obiektu klasy SwbemServices, a następnie wykonuje zapy-tanie, korzystając z metody execquery. Zapytanie w języku WQL (WMI Query Language – Język zapytań systemu WMI) używa operatora like, do pobrania listy poprawek typu hotfix, z wartością identyfikatora 928439, która w systemie Windows XP, Windows Vista, Windows Server 2003 oraz Windows Server 2008 oznacza identyfikator poprawki będącej

2 Windows PowerShell – przewodnik po skryptach

programem Windows PowerShell. Po zidentyfikowaniu poprawki skrypt ten po prostu wypisuje nazwę komputera, informując o zainstalowaniu na nim programu Windows PowerShell. Przykład takiego komunikatu został pokazany na rysunku 1-1.

Rysunek 1-1 Wyskakujące okno dialogowe, wyświetlone przez skrypt FindPowerShell.vbs, z informacją o znalezieniu w systemie programu Windows PowerShell.

Jeśli wskazana poprawka nie zostanie odnaleziona, wówczas skrypt wyświetli informację, że program PowerShell nie został zainstalowany. Skrypt FindPowerShell.vbs można bardzo łatwo zmodyfikować dodając do niego nową funkcjonalność, która może być potrzebna w danej sieci. Przykładowo może pojawić się potrzeba uruchamiania tego skryptu dla wielu różnych nazw komputerów. W tym celu można przekształcić obiekt strComputer w tablicę i wpisać od razu kilka nazw komputerów. Nazwy komputerów można również odczytać z pliku tekstowego lub pobrać je za pomocą zapytania skierowanego do usługi katalogo-wej Active Directory. Wynik działania skryptu można również skierować do pliku, zamiast tworzyć wyskakujące okno dialogowe.

FindPowerShell.vbsConst RtnImmedFwdOnly = &h30 strComputer = "." wmiNS = "\root\cimv2" wmiQuery = "Select * from win32_QuickFixEngineering where hotfixid like '928439'"

Set objWMIService = GetObject("winmgmts:\\" & strComputer & wmiNS) Set colItems = objWMIService.ExecQuery(wmiQuery,,RtnImmedFwdOnly)

For Each objItem in colItems Wscript.Echo "Program PowerShell jest zainstalowany na " & objItem.CSName Wscript.quit Next Wscript.Echo „Program PowerShell nie został zainstalowany”

Wdrażanie programu Windows PowerShellPo pobraniu programu Windows PowerShell z witryny http://www.microsoft.com/downloads można go wdrożyć w posiadanym środowisku przy użyciu dowolnej, aktualnie używanej, standardowej metody wdrażania oprogramowania. Do metod używanych przez klientów do wdrażania programu Windows PowerShell należą między innymi:

■ Utworzenie pakietu Microsoft SMS (Systems Management Server – Serwer zarządza-nia systemami) i anonsowanie go w odpowiedniej jednostce organizacyjnej (OU) lub kolekcji.

■ Utworzenie w kartotece Active Directoty obiektu zasad grupy (GPO – Group Policy Object) i połączenie go z odpowiednią jednostką organizacyjną (OU).

Rozdział 1: Powłoka programu Windows PowerShell 3

■ Uruchomienie programu wykonywalnego za pomocą skryptu logowania.

Jeśli wdrożenie programu Windows PowerShell nie dotyczy całego przedsiębiorstwa, prawdopodobnie najprostszym sposobem instalacji będzie po prostu dwukrotne kliknięcie odpowiedniego pliku wykonywalnego i wykonanie kolejnych kroków, zgodnie z instruk-cjami kreatora instalacji.

Należy w tym miejscu podkreślić, że program Windows PowerShell jest instalowany za pomocą technologii poprawek typu hotfix. Oznacza to, że program Windows PowerShell ma postać aktualizacji systemu operacyjnego, a nie dodatkowego programu. Takie podej-ście ma kilka zalet, włącznie z możliwością oferowania aktualizacji i poprawek dla pro-gramu Windows PowerShell za pomocą pakietów serwisowych systemu operacyjnego oraz za pomocą witryny Windows Update. Niestety ma ono również kilka minusów wynikają-cych z faktu, że deinstalacja poprawek typu hotfix musi przebiegać w odwrotnej kolejności do ich instalacji. Np. jeśli program Windows PowerShell zostanie zainstalowany w syste-mie Windows Vista, a później w systemie tym zainstalowana zostanie seria aktualizacji oraz pakiet Service Pack 1, to, jeśli zdecydujemy się nagle na usunięcie z systemu pro-gramu Windows PowerShell, konieczne będzie odinstalowanie w odpowiedniej kolejności najpierw pakietu Service Pack 1, a potem wszystkich zainstalowanych poprawek typu hotfix (osobiście w takiej sytuacji zdecydowałbym się raczej na wykonanie kopii zapaso-wej wszystkich swoich danych, sformatowanie dysku twardego i ponowne zainstalowanie systemu Windows Vista. Sądzę, że takie rozwiązanie byłoby szybsze. Ale i tak scenariusz taki jest mocno dyskusyjny, ponieważ zwykle nie spotkamy się z potrzebą odinstalowania programu Windows PowerShell).

Czym jest program Windows PowerShell

Jednym z problemów związanych z programem Windows PowerShell jest niewłaściwe zro-zumienie, czym jest ten program. Gdy po raz pierwszy spotkałem się Jeffreyem Snoverem, głównym architektem programu Windows PowerShell, jedną z pierwszych usłyszanych od niego rzeczy było pytanie: „W jaki sposób opisałbyś program Windows PowerShell swoim klientom?”.

A więc czym jest program Windows PowerShell? Mówiąc najprościej, Windows PowerShell to oferowana przez firmę Microsoft nowa powłoka wiersza poleceń i język skryptowy, który może zastąpić zarówno nieco już leciwy interpreter poleceń Cmd.exe, jak i język skryptowy VBScript.

Ta dwoista natura stwarza pewne problemy dla wielu administratorów sieci, którzy przywy-kli do automatyzowania zadań administracyjnych za pomocą interpretera poleceń Cmd.exe, z jego słabo rozwiniętym językiem wsadowym oraz wszechstronnego (lecz zawiłego) języka skryptowego VBScript. Nie są to złe narzędzia, ale obecnie często są wykorzystywane w spo-sób niezgodny z ich przeznaczeniem określonym ponad dekadę temu, gdy oba te narzędzia dopiero powstawały. Interpreter poleceń Cmd.exe jest w zasadzie następcą okna wiersza poleceń systemu DOS, a język VBScript został zaprojektowany, w większym lub w mniejszym stopniu, z myślą o stronach webowych. Żadne z tych narzędzi nie zostało stworzone od pod-staw z myślą o administratorach sieci.


Interakcja z powłokąPo uruchomieniu programu Windows PowerShell można z niego korzystać w taki sam spo-sób, jak z interpretera poleceń Cmd.exe. Np. posługując się poleceniem dir można uzyskać listę zawartości katalogu. Można również najpierw zmienić katalog bieżący za pomocą polecenia cd, a następnie sprawdzić jego zawartość za pomocą polecenia dir, zupełnie w taki sam sposób, jak podczas korzystania z powłoki CMD. Rezultaty użycia wymienio-nych poleceń ilustruje zamieszczony poniżej przykładowy plik UsingPowerShell.txt.

UsingPowerShell.txtPS C:\Users\edwils> dir

Directory: Microsoft.PowerShell.Core\FileSystem::C:\Users\edwils

Mode LastWriteTime Length Name ---- ------------- ------ ---- d-r-- 11/29/2006 1:32 PM Contacts d-r-- 4/2/2007 12:51 AM Desktop d-r-- 4/1/2007 6:53 PM Documents d-r-- 11/29/2006 1:32 PM Downloads d-r-- 4/2/2007 1:10 AM Favorites d-r-- 4/1/2007 6:53 PM Links d-r-- 11/29/2006 1:32 PM Music d-r-- 11/29/2006 1:32 PM Pictures d-r-- 11/29/2006 1:32 PM Saved Games d-r-- 4/1/2007 6:53 PM Searches d-r-- 4/2/2007 5:53 PM Videos

PS C:\Users\edwils> cd music PS C:\Users\edwils\Music> dir

Oprócz możliwości korzystania z tradycyjnych poleceń interpretera poleceń możliwe jest także korzystanie z nowszych narzędzi wiersza poleceń, takich jak prezentowany poniżej program Fsutil.exe. Należy przy tym pamiętać, że korzystanie z programu Fsutil.exe wymaga posiadania uprawnień administracyjnych. Uruchomienie powłoki Windows PowerShell z poziomu grupy programów Windows PowerShell nie zapewnia posiadania uprawnień administracyjnych i próba skorzystania z programu Fsutil.exe zakończy się wygenerowaniem błędu pokazanego na rysunku 1-2.

Rysunek 1-2 Program Windows PowerShell podlega mechanizmom kontroli konta użytkownika i domyślnie jest uruchamiany z uprawnieniami zwykłego użytkownika. Próby wykonywania poleceń wymagających wyższego poziomu uprawnień mogą wówczas kończyć się błędami.


Fsutil.txtPS C:\Users\edwils> sl c:\mytest PS C:\mytest> fsutil file createNew c:\mytest\myNewFile.txt 1000 File c:\mytest\myNewFile.txt is created PS C:\mytest> dir

Directory: Microsoft.PowerShell.Core\FileSystem::C:\mytest

Mode LastWriteTime Length Name ---- ------------- ------ ---- -a--- 5/8/2007 7:30 PM 1000 myNewFile.txt

PS C:\mytest>

PS C:\Users\edwils> sl c:\mytest PS C:\mytest> fsutil file createNew c:\mytest\myNewFile.txt 1000Plik c:\mytest\myNewFile.txt został utworzonyPS C:\mytest> dir

Katalog: Microsoft.PowerShell.Core\FileSystem::C:\mytest

Mode LastWriteTime Length Name---- ------------- ------ -----a--- 2008-06-10 21:35 1000 myNewFile.txt

PS C:\mytest>

Wskazówka Zalecane jest utworzenie dwóch skrótów do programu Windows PowerShell i zapisanie ich na pasku Quick Launch (Szybkie uruchamianie). Jeden z tych skrótów powinien uruchamiać program z uprawnieniami zwykłego użytkownika a drugi z uprawnieniami admini-stracyjnymi. Domyślnie należy korzystać ze skrótu uruchamiającego program z uprawnieniami zwykłego użytkownika, dokumentując te przypadki, które wymagają używania uprawnień administracyjnych.

Po zakończeniu pracy z plikami i z folderem można bardzo łatwo usunąć plik za pomocą polecenia del. Aby uniknąć konieczności wpisywania całej nazwy pliku, można posłużyć się znakami uogólniającymi, np. *.txt. Jest to wystarczająco bezpieczne, ponieważ wcześniej sprawdziliśmy za pomocą polecenia dir, że w danym folderze znajduje się tylko jeden plik tekstowy. Po usunięciu pliku, używając polecenia rd, można również usunąć sam katalog. Jak pokazano w poniższym przykładzie DeleteFileAndFolder.txt, polecenia te działają dokładnie tak samo jak podczas korzystania z okna wiersza poleceń.

DeleteFileAndFolder.txtPS C:\> sl c:\mytest PS C:\mytest> dir

Directory: Microsoft.PowerShell.Core\FileSystem::C:\mytest

Mode LastWriteTime Length Name ---- ------------- ------ ---- -a--- 5/8/2007 7:30 PM 1000 myNewFile.txt


PS C:\mytest> del *.txt PS C:\mytest> cd c:\ PS C:\> rd c:\mytest PS C:\> dir c:\mytest Get-ChildItem : Cannot find path 'C:\mytest' because it does not exist. At line:1 char:4 + dir <<<< c:\mytest PS C:\>

...PS C:\> dir c:\mytest Get-ChildItem : Nie można odnaleźć ścieżki 'C:\mytest', ponieważ ona nie istnieje.Plik: wiersz; wiersz: 1; znak: 4+ dir <<<< c:\mytest PS C:\>

W pokazanych powyżej przykładach program Windows PowerShell używany był w sposób interakcyjny. Jest to jedno z głównych zastosowań tego programu. Zespół tworzący pro-gram Windows PowerShell zakładał, że około 80% użytkowników będzie korzystać z tego programu w sposób interakcyjny, traktując go po prostu jako lepszą wersję okna wier-sza poleceń. Użytkownicy będą otwierać wiersz poleceń programu Windows PowerShell i wpisywać tekst poleceń. Polecenia mogą być wpisywane pojedynczo lub grupowane, w podobny sposób jak w plikach wsadowych typu .bat. Możliwość ta zostanie opisana w dalszej części tej książki, ponieważ domyślnie jest ona wyłączona.

Omówienie narzędzi wiersza poleceń typu CmdletOprócz możliwości korzystania z tradycyjnych programów i poleceń znanych z interpre-tera poleceń Cmd.exe, możliwe jest także używanie specjalnych narzędzi wiersza poleceń (tzw. poleceń typu cmdlet), które są wbudowane w program Windows PowerShell. Cmdlet to nazwa utworzona przez zespół programistów tworzących program Windows PowerShell, oznaczająca tego rodzaju natywne polecenia. Polecenia te są podobne do programów wykonywalnych, ale ponieważ korzystają z funkcji wbudowanych w program Windows PowerShell, są łatwiejsze do napisania. Nie są to skrypty, które zawierają nieskompilowany kod, ponieważ do ich tworzenia używane są usługi specjalnej przestrzeni nazw platformy Microsoft .NET Framework. Z powodu swojej odmiennej natury programiści z zespołu tworzącego program Windows PowerShell utworzyli dla tych poleceń nowy termin cmdlet. Program Windows PowerShell oferuje ponad 120 narzędzi typu cmdlet, zaprojektowanych z myślą o umożliwieniu konsultantom i administratorom sieci łatwego korzystania z możli-wości oferowanych przez program PowerShell, bez konieczności uczenia się języka skryp-towego Windows PowerShell. Narzędzia te zostały wymienione w dodatku A, zatytułowa-nym „Konwencja nazw dla narzędzi typu cmdlet”. Generalnie nazwy narzędzi typu cmdlet tworzone są zgodne ze standardową konwencją nazw, np. Get-Help (Uzyskaj pomoc), Get-EventLog (Uzyskaj dziennik zdarzeń) lub Get-Process (Pobierz proces). Polecenia, których nazwy zaczynają się od członu "get" (pobierz/uzyskaj), wyświetlają informacje o elemencie wskazanym w drugim członie ich nazwy (z prawej strony znaku myślnika). Polecenia o nazwach zaczynających się od członu „set” (ustaw) służą do modyfikowania lub do konfigurowania elementów wskazanych w drugim członie nazwy. Przykładem pole-cenia typu „set” jest cmdlet Set-Service (Ustaw usługę), który umożliwia zmianę trybu


uruchamiania usług. Pełne objaśnienie konwencji nazw dla poleceń typu cmdlet znajduje się w dodatku A, zatytułowanym „Konwencja nazw dla narzędzi typu cmdlet”.

Konfigurowanie programu Windows PowerShellPo zainstalowaniu programu Windows PowerShell na danej platformie, nadal pozo-staje do rozwiązania jeszcze kilka kwestii związanych z konfiguracją. Częściowo wynika to ze sposobu, w jaki programiści firmy Microsoft z zespołu tworzącego program Windows PowerShell wyobrażają sobie sposób korzystania z tego narzędzia. Otóż zakładają oni, że 80% użytkowników programu Windows PowerShell nie będzie korzystać z funkcji skryptowych tego programu, a więc funkcjonalność obsługi skryptów jest domyślnie wyłą-czona. Więcej informacji na temat włączania obsługi skryptów przez program Windows PowerShell znajduje się w rozdziale 2, zatytułowanym „Skrypty programu Windows PowerShell”.

Tworzenie profilu programu Windows PowerShellIstnieje wiele ustawień, które można przechowywać w profilu programu Windows PowerShell. Elementy te można zapisać w pliku psconsole. W celu eksportowania pliku z konfiguracją konsoli należy użyć polecenia cmdlet o nazwie Export-Console (Eksportuj konsolę), w pokazany poniżej sposób:

PS C:\> Export-Console myconsole

Plik psconsole domyślnie zapisywany jest w katalogu bieżącym i posiada rozszerzenie .psc1. Plik psconsole zapisywany jest w formacie XML. Poniżej pokazana została zawartość pliku z konfiguracją zwykłej konsoli:

<?xml version="1.0" encoding="utf-8"?> <PSConsoleFile ConsoleSchemaVersion="1.0"> <PSVersion>1.0</PSVersion> <PSSnapIns /> </PSConsoleFile>

Konfigurowanie opcji uruchamiania programu Windows PowerShell

Istnieje kilka możliwych sposobów uruchamiania programu Windows PowerShell. Np. jeśli komuś przeszkadza logo wyświetlane po kliknięciu domyślnej ikony programu Windows PowerShell, to program ten można uruchomiać bez niego. Możliwe jest uruchamianie programu Windows PowerShell przy użyciu różnych profili, a nawet wykonywanie poje-dynczego polecenia powłoki Windows PowerShell i kończenie jej działania. Jeśli istnieje potrzeba uruchomienia określonej wersji programu Windows PowerShell, można to zrobić podając odpowiednią wartość dla parametru version. Poniższa lista ilustruje każdą z tych możliwości.

■ Uruchomienie programu Windows PowerShell bez baneru startowego, przy użyciu argumentu -nologo:


PowerShell -nologo

■ Uruchomienie konkretnej wersji programu Windows PowerShell, przy użyciu argu-mentu -version:

PowerShell -version 1.0

■ Uruchomienie programu Windows PowerShell przy użyciu konkretnego pliku konfigu-racyjnego, wskazanego za pomocą argumentu -psconsolefile:

PowerShell -psconsolefile myconsole.psc1

■ Uruchomienie programu Windows PowerShell, wykonanie określonego polecenia i zakończenie działania, używając argumentu -command. Polecenie do wykonania musi być poprzedzone znakiem ampersand (&) i ujęte w nawiasy klamrowe:

powershell -command "& {get-process}"

Kwestie bezpieczeństwa w programie Windows PowerShell

Podobnie jak w przypadku każdego narzędzia, które jest równie wszechstronne jak program Windows PowerShell, pojawiają się pewne obawy dotyczące bezpieczeństwa. Bezpieczeństwo było jednak jednym z celów od początku uwzględnianym podczas two-rzenia programu Windows PowerShell.

Po uruchomieniu programu Windows PowerShell otwiera on folder użytkownika Użytkownicy\NazwaUżytkownika. Gwarantuje to, że katalog bieżący będzie katalogiem wobec którego użytkownik posiada uprawnienia potrzebne do wykonywania pewnych akcji oraz działań. Taka technika jest znacznie bezpieczniejsza niż uruchamianie programu w głównym katalogu dysku lub otwieranie głównego katalogu systemowego.

Nie można automatycznie zmienić katalogu i przejść o jeden poziom wyżej – katalog docelowy dla operacji zmiany katalogu musi zostać wskazany w sposób jawny (ale możliwe jest używanie notacji kropkowej w połączeniu z poleceniem cmdlet o nazwie Set-Location (Ustaw lokalizację), jak np. Set-Location ..).

Możliwość uruchamiania skryptów jest domyślnie wyłączona, ale można to łatwo zmie-nić za pomocą zasad grupy lub skryptów logowania.

Kontrolowanie działania poleceń typu CmdletCzy kiedykolwiek Czytelniku zdarzyło Ci się otworzyć okno interpretera poleceń CMD, wpisać tekst polecenia i nacisnąć klawisz Enter, aby po prostu zobaczyć co się stanie? Gdyby tym poleceniem było akurat polecenie Format C:\, to czy na pewno zamierzałeś sformatować swój dysk C? Istnieje kilka argumentów, które można przekazywać do pole-ceń typu cmdlet celem kontrolowania sposobu ich działania. Argumenty te zostaną szerzej omówione poniżej.

Wprawdzie nie wszystkie polecenia typu cmdlet obsługują omawiane tutaj argumenty, ale są one obsługiwane przez większość poleceń typu cmdlet, stanowiących część programu Windows PowerShell. Trzy sposoby kontrolowania działania polecenia typu cmdlet to argu-menty -whatif (co jeśli) i -confirm (potwierdzenie) oraz akcja suspend (wstrzymanie). Akcja


Suspend nie jest argumentem przekazywanym do polecenia typu cmdlet, lecz akcją, którą można podjąć w odpowiedzi na monit z żądaniem potwierdzenia, a więc można ją uznać za jeszcze jeden sposób kontrolowania sposobu działania poleceń typu cmdlet.

Wskazówka Większość poleceń typu cmdlet programu Windows PowerShell obsługuje tryb „prototypowy”, który można aktywować za pomocą parametru -whatif (co jeśli). O imple-mentacji przełącznika whatif może decydować osoba tworząca dane cmdlet. Zespół twórców programu Windows PowerShell zaleca jednak programistom implementowanie przełącznika -whatif, jeśli tworzony przez nich cmdlet dokonuje jakichkolwiek zmian w systemie.

Chcąc skorzystać z opcji -whatif, należy najpierw wpisać w oknie wiersza poleceń pro-gramu Windows PowerShell nazwę i parametry polecenia typu cmdlet, a następnie dopisać na końcu parametr -whatif. Zastosowanie argumentu -whatif ilustruje zamieszczony poniżej przykład z pliku Whatif.txt. Pierwsza linia zawiera polecenie uruchomienia programu Notatnik. W tym celu wystarczy pisać słowo notepad, tak jak to pokazano na przykładzie. Następnie użyty został cmdlet o nazwie Get-Process (Pobierz proces), za pomocą którego wyszukano wszystkie procesy o nazwach rozpoczynających się od note. Kolejne polecenie to użycie polecenia typu cmdlet o nazwie Stop-Process (Zatrzymaj proces), do zatrzyma-nia procesu o nazwie notepad, ale, ponieważ nie znamy jeszcze rezultatów działania tego polecenia, użyty został parametr -whatif. Dzięki użyciu tego parametru dowiedzieliśmy się, że wykonanie polecenia spowodowałoby zabicie dwóch procesów, z których każdy ma nazwę notepad, a także uzyskaliśmy wartości identyfikatorów tych procesów pozwa-lające na zweryfikowanie, czy zabite zostałyby właściwe procesy. Już tylko dla zabawy, następne polecenie to ponowne użycie polecenia o nazwie Stop-Process (Zatrzymaj proces) do zatrzymania wszystkich procesów o nazwach zaczynających się na literę n. Tym razem również roztropnie użyty został parametr whatif, dzięki czemu mogliśmy się przekonać, co by się stało, gdyby to polecenie zostało wykonane.

WhatIf.txtPS C:\Users\edwils> notepad PS C:\Users\edwils> Get-Process note*

Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName ------- ------ ----- ----- ----- ------ -- ----------- 45 2 1044 3904 53 0.03 3052 notepad 45 2 1136 4020 54 0.05 3140 notepad

PS C:\Users\edwils> Stop-Process -processName notepad -WhatIf What if: Performing operation "Stop-Process" on Target "notepad (3052)". What if: Performing operation "Stop-Process" on Target "notepad (3140)".

PS C:\Users\edwils> Stop-Process -processName n* -WhatIf What if: Performing operation "Stop-Process" on Target "notepad (3052)". What if: Performing operation "Stop-Process" on Target "notepad (3140)".

...

PS C:\users\edwils> Stop-Process -processName notepad -WhatIfWhatIf Wykonywanie operacji "Stop-Process" na elemencie docelowym "notepad (2368)".WhatIf Wykonywanie operacji "Stop-Process" na elemencie docelowym "notepad (2636)".


PS C:\users\edwils> Stop-Process -processName n* -WhatIfWhatIf Wykonywanie operacji "Stop-Process" na elemencie docelowym "notepad (2368)".WhatIf Wykonywanie operacji "Stop-Process" na elemencie docelowym "notepad (2636)".WhatIf Wykonywanie operacji "Stop-Process" na elemencie docelowym "ntfrs (404)".

A co się stanie, jeśli przełącznik whatif nie został zaimplementowany? Przypadek ten został zilustrowany w zamieszczonym poniżej przykładzie Whatif2.txt. W przypadku użycia pole-cenia typu cmdlet o nazwie New-Item (Nowy element), do utworzenia w katalogu głów-nym nowego katalogu o nazwie myNewtest, przełącznik whatif został zaimplementowany i pokazuje, że to polecenie faktycznie spowoduje utworzenie katalogu C:\myNewtest.

Zwróćmy jednak uwagę, co się stanie, jeśli spróbujemy użyć przełącznika whatif w połączeniu z poleceniem typu cmdlet o nazwie Get-Help (Uzyskaj pomoc). Można by oczekiwać, że użycie tego parametru spowoduje wyświetlenie komunikatu w rodzaju "What if: Retrieving help information for Get-Process cmdlet" (Co jeśli: pobieranie informacji pomocy dla polecenia typu cmdlet – Get-Process (Pobierz proces)). Tylko jaka byłaby zasadność takiego działania? Ponieważ użycie polecenia Get-Help (Uzyskaj pomoc) nie stwarza żadnego zagrożenia dla systemu, więc w jego przypadku nie ma potrzeby implementowania przełącznika whatif.

WhatIf2.txtPS C:\Users\edwils> New-Item -Name myNewTest -Path c:\ -ItemType directory -WhatIf What if: Performing operation "Create Directory" on Target "Destination: C:\myNewTest".

PS C:\Users\edwils> get-help Get-Process -whatif Get-Help : A parameter cannot be found that matches parameter name 'whatif'. At line:1 char:28 + get-help Get-Process -whatif <<<<

PS C:\users\edwils> New-Item -Name myNewTest -Path c:\ -ItemType directory -WhatIfWhatIf Wykonywanie operacji "Utwórz katalog" na elemencie docelowym "Miejsce docelowe: C:\myNewTest".

PS C:\users\edwils> Get-Help Get-Process -WhatIfGet-Help : Nie można odnaleźć parametru pasującego do nazwy parametru 'WhatIf'.Plik: wiersz; wiersz: 1; znak: 28+ Get-Help Get-Process -WhatIf <<<<

Najlepsze rozwiązanie Stosowanie parametru -whatif należy traktować jako jedno z pod-stawowych narzędzi w arsenale administratora sieci. Używanie tego parametru do pozoro-wania działania poleceń przed ich faktycznym wykonaniem może zaoszczędzić każdego roku wiele godzin pracy.

Potwierdzanie poleceńJak pokazaliśmy w poprzedniej części, użycie przełącznika -whatif pozwala na utworzenie w programie Windows PowerShell prototypu polecenia typu cmdlet. Jest to bardzo uży-teczna możliwość pozwalająca na sprawdzenie, co zrobi dane polecenie. Jeśli jednak przed wykonaniem polecenia powinien zostać wyświetlony odpowiedni monit, to należy użyć


przełącznika -confirm. W praktyce przełącznik -whatif można generalnie zastąpić prze-łącznikiem -confirm, ponieważ powoduje on wyświetlenie odpowiedniego monitu przed wykonaniem właściwej akcji. Zostało to pokazane w zamieszczonym poniżej przykładzie ConfirmIt.txt.

Pierwszym poleceniem w pliku ConfirmIt.txt jest uruchomienie programu Kalkulator (Calc.exe). Ponieważ plik z tym programem znajduje się na ścieżce systemowej, nie ma potrzeby podawania pełnej ścieżki do tego pliku ani jego rozszerzenia. Następnym polece-niem jest użycie narzędzia typu cmdlet o nazwie Get-Process (Pobierz proces) oraz wzorca uogólniającego c* do odszukania wszystkich procesów, których nazwa zaczyna się na literę c. Należy zwrócić uwagę, że na wynikowej liście znajdują się nazwy kilku takich procesów. Kolejny krok to pobranie informacji dotyczących tylko procesu Calc.exe. To polecenie zwraca bardziej odpowiedni zbiór wynikowy. Następnie użyty został cmdlet Stop-Process (Zatrzymaj proces) z przełącznikiem -confirm. Jego uruchomienie powoduje zwrócenie następujących informacji:

Confirm Are you sure you want to perform this action? Performing operation "Stop-Process" on Target "calc (2924)". [Y] Yes [A] Yes to All [N] No [L] No to All [S] Suspend [?] Help (default is "Y"):

PotwierdźCzy na pewno chcesz wykonać tę akcję?Wykonywanie operacji "Stop-Process" na elemencie docelowym "calc (1016)".[T] Tak [W] Tak na wszystko [N] Nie [S] Nie na wszystkie [M] Wstrzymaj Pomoc [?](wartość domyślna to "T"):

Jak można zauważyć, informacje te są w zasadzie takie same, jak w przypadku użycia przełącznika whatif, z tą jednak różnicą, że w tym przypadku oferowana jest również możli-wość wykonania żądanej akcji. Podczas wykonywania bardzo dużej liczby poleceń pozwala to na znaczną oszczędność czasu.

Confi rmIt.txtPS C:\Users\edwils> calc PS C:\Users\edwils> Get-Process c*

Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName ------- ------ ----- ----- ----- ------ -- ----------- 43 2 1060 4212 54 0.03 2924 calc 1408 7 3364 6556 81 372 casha 1132 16 23156 34680 129 3084 CcmExec 599 5 1680 4956 88 620 csrss 480 10 15812 20500 195 688 csrss

PS C:\Users\edwils> Get-Process calc

Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName ------- ------ ----- ----- ----- ------ -- ----------- 43 2 1060 4212 54 0.03 2924 calc

PS C:\Users\edwils> Stop-Process -Name calc -Confirm

Confirm


Are you sure you want to perform this action? Performing operation "Stop-Process" on Target "calc (2924)". [Y] Yes [A] Yes to All [N] No [L] No to All [S] Suspend [?] Help (default is "Y"): y PS C:\Users\edwils> Get-Process c*

Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName ------- ------ ----- ----- ----- ------ -- ----------- 1412 7 3364 6556 81 372 casha 1154 16 23224 34740 130 3084 CcmExec 598 5 1680 4956 88 620 csrss 477 10 15812 20488 195 688 csrss

...

PS C:\users\edwils> Stop-Process -name calc -confirm

PotwierdźCzy na pewno chcesz wykonać tę akcję?Wykonywanie operacji "Stop-Process" na elemencie docelowym "calc (1016)".[T] Tak [W] Tak na wszystko [N] Nie [S] Nie na wszystkie [M] Wstrzymaj Pomoc [?](wartość domyślna to "T"): tPS C:\users\edwils> Get-Process c*...

Zawieszanie potwierdzeń wykonywania poleceń typu CmdletMożliwość wyświetlania monitów z prośbą o potwierdzenie zamiaru wykonania danego polecenia typu cmdlet jest wyjątkowo użyteczna i czasami może mieć zasadnicze znaczenie dla zachowania wysokiego poziomu dostępności systemu. Może się np. zdarzyć, że po wpi-saniu długiego polecenia przypomnimy sobie o konieczności uprzedniego wykonania innej procedury. W takim przypadku można po prostu zawiesić wykonywanie tego polecenia. Polecenia użyte podczas zawieszonego wykonywania programu narzędziowego typu cmdlet oraz generowany przez te polecenia strumień wyjściowy pokazane zostały w zamieszczo-nym poniżej przykładzie SuspendConfirmation.txt.

W przykładowym pliku SuspendConfirmation.txt najpierw uruchomiony zostaje program Microsoft Paint (Mspaint.exe). Ponieważ program Mspaint.exe znajduje się na ścieżce systemowej, nie ma potrzeby umieszczania w tym pliku żadnych dodatkowych informacji dotyczących ścieżki. Następnie przy pomocy polecenia typu cmdlet o nazwie Get-Process (Pobierz proces) oraz wzorca uogólniającego ms* pobrana zostaje lista wszyst-kich procesów, których nazwy zaczynają się na litery ms. Po zidentyfikowaniu właściwego procesu, użyty został cmdlet Stop-Process (Zatrzymaj proces) z przełącznikiem confirm. Zamiast odpowiadać yes (tak) na monit z prośbą o potwierdzenie, można po prostu zawie-sić wykonywanie danego polecenia, co pozwoli na wykonanie innego polecenia (np. jeśli zapomnieliśmy, jaka jest wartość identyfikatora procesu). Po zakończeniu wykonywania tego dodatkowego polecenia należy wpisać polecenie exit, co spowoduje powrót z zagnież-dżonego monitu z powrotem do zawieszonego polecenia. Po zabiciu procesu programu mspaint można to potwierdzić używając ponownie polecenia cmdlet Get-Process (Pobierz proces).


SuspendConfi rmation.txtPS C:\Users\edwils> mspaint PS C:\Users\edwils> Get-Process ms*

Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName ------- ------ ----- ----- ----- ------ -- ----------- 98 4 5404 10492 72 0.09 3064 mspaint

PS C:\Users\edwils> Stop-Process -id 3064 -Confirm

Confirm Are you sure you want to perform this action? Performing operation "Stop-Process" on Target "mspaint (3064)". [Y] Yes [A] Yes to All [N] No [L] No to All [S] Suspend [?] Help (default is "Y"): s PS C:\Users\edwils>>> Get-Process ms*

Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName ------- ------ ----- ----- ----- ------ -- ----------- 97 4 5404 10496 72 0.09 3064 mspaint

PS C:\Users\edwils>>> exit

Confirm Are you sure you want to perform this action? Performing operation "Stop-Process" on Target "mspaint (3064)". [Y] Yes [A] Yes to All [N] No [L] No to All [S] Suspend [?] Help (default is "Y"): y PS C:\Users\edwils> Get-Process ms*

...

PS C:\users\edwils> Stop-Process -id 1028 -confirm

PotwierdźCzy na pewno chcesz wykonać tę akcję?Wykonywanie operacji "Stop-Process" na elemencie docelowym "mspaint (1028)".[T] Tak [W] Tak na wszystko [N] Nie [S] Nie na wszystkie [M] Wstrzymaj Pomoc [?](wartość domyślna to "T"): mPS C:\users\edwils>>> Get-Process ms*

Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName------- ------ ----- ----- ----- ------ -- ----------- 167 7 2912 6928 62 1,15 3292 msdtc 80 4 2696 7444 72 3,45 1028 mspaint

PS C:\users\edwils>>> exit

PotwierdźCzy na pewno chcesz wykonać tę akcję?Wykonywanie operacji "Stop-Process" na elemencie docelowym "mspaint (1028)".[T] Tak [W] Tak na wszystko [N] Nie [S] Nie na wszystkie [M] Wstrzymaj Pomoc [?](wartość domyślna to "T"): tPS C:\users\edwils> Get-Process ms*PS C:\users\edwils>


Przekazywanie opcji dla poleceń typu cmdletJak już pokazano w poprzednich częściach tego rozdziału, do kontrowania działania pro-gramów poleceń typu cmdlet można używać parametrów -whatif oraz -confirm. Jednym z pytań często zadawanych mi przez studentów jest pytanie „Skąd wiadomo, jakie opcje są w ogóle dostępne?”. Odpowiedź na to pytanie jest taka, że zespół tworzący program Windows PowerShell utworzył zbiór pewnych standardowych opcji. Te standardowe opcje nazywane są parametrami wspólnymi (common parameters). Przeglądając opisy składni róż-nych poleceń typu cmdlet często można zauważyć informację, że dany cmdlet obsługuje tzw. wspólne parametry. Poniżej pokazany został przykład takiego opisu dla polecenia cmdlet Get-Process (Pobierz proces):

SYNTAX Get-Process [[-name] <string[]>] [<CommonParameters>]

Get-Process -id <Int32[]> [<CommonParameters>]

Get-Process -inputObject <Process[]> [<CommonParameters>]

Jedną z użytecznych cech programu Windows PowerShell jest standaryzacja składni uży-wanej przez programy polecenia typu cmdlet. Pozwala to na poważne uproszczenie pro-cesu poznawania nowej powłoki i nowego języka. Wspólne parametry zostały zebrane w tabeli 1-1. Należy jednak pamiętać, że nie wszystkie z tych parametrów są obsługiwane przez wszystkie programy narzędziowe typu cmdlet. Jeśli jednak dany parametr jest uży-wany, to będzie on interpretowany w taki sam sposób przez wszystkie polecenia typu cmdlet, ponieważ ich interpretacją zajmuje się motor programu Windows PowerShell.

Tabela 1-1 Parametry wspólne

Parametr Znaczenie

-whatif Instruuje cmdlet, aby nie wykonywać danej akcji. Zamiast tego cmdlet informuje, co by się stało, gdyby faktycznie został on uruchomiony.

-confirm Instruuje cmdlet, aby przed wykonaniem polecenia wyświetlić monit z prośbą o potwierdzenie.

-verbose Instruuje cmdlet, aby wyświetlał więcej szczegółowych informacji o swoim działaniu, niż bez tego parametru.

-debug Instruuje cmdlet, aby wyświetlił informacje pomocne przy debugowaniu.

-erroraction Instruuje cmdlet, aby w razie wystąpienia błędu wykonał określoną akcję. Dopuszczalne akcje to: continue (kontynuuj), stop (zatrzymaj), SilentlyContinue (Kontynuuj po cichu) oraz inquire (zapytaj).

-errorvariable Instruuje cmdlet, aby do przechowywania informacji o błędach używać wskazanej zmiennej. Zmienna ta stanowić będzie uzupełnienie dla stan-dardowej zmiennej $error.

-outvariable Instruuje cmdlet, aby informacje ze strumienia wyjściowego umiesz-czane były we wskazanej zmiennej.


Tabela 1-1 Parametry wspólne

Parametr Znaczenie

-outbuffer Instruuje cmdlet, aby przed wywołaniem następnego polecenia typu cmdlet w potoku zgromadzić określoną ilość obiektów.

Korzystanie z polecenia Get-Help (Pobierz pomoc)Korzystanie z programu Windows PowerShell jest łatwe i intuicyjne – nauka może odby-wać się po prostu poprzez korzystanie z tego programu. Bezpośredni dostęp do systemu pomocy jeszcze bardziej ułatwia korzystanie z programu. Z systemu pomocy programu Windows PowerShell można korzystać na kilka różnych sposobów. Chcąc uzyskać infor-macje na temat korzystania z programu Windows PowerShell należy użyć programu narzę-dziowego typu cmdlet o nazwie Get-Help (Uzyskaj pomoc), tak jak to zostało pokazane poniżej:

get-help get-help

Powyższe polecenie powoduje wypisanie tekstu pomocy dotyczącego polecenia cmdlet Get-Help (Uzyskaj pomoc). Informacje zwrócone przez ten cmdlet zostały pokazane poniżej:

NAME Get-Help

SYNOPSIS Displays information about Windows PowerShell cmdlets and concepts.

SYNTAX Get-Help [[-name] <string>] [-component <string[]>] [-functionality <string []>] [-role <string[]>] [-category <string[]>] [-full] [<CommonParameters>]

Get-Help [[-name] <string>] [-component <string[]>] [-functionality <string []>] [-role <string[]>] [-category <string[]>] [-detailed] [<CommonParamete rs>]

Get-Help [[-name] <string>] [-component <string[]>] [-functionality <string []>] [-role <string[]>] [-category <string[]>] [-examples] [<CommonParamete rs>]

Get-Help [[-name] <string>] [-component <string[]>] [-functionality <string []>] [-role <string[]>] [-category <string[]>] [-parameter <string>] [<Comm onParameters>]

DETAILED DESCRIPTION The Get-Help cmdlet displays information about Windows PowerShell cmdlets and concepts. You can also use "Help {<cmdlet name> | <topic-name>" or "<cmd let-name> /?". "Help" displays the help topics one page at a time. The "/?" displays help for cmdlets on a single page.

RELATED LINKS Get-Command


Get-PSDrive Get-Member

REMARKS For more information, type: "get-help Get-Help -detailed". For technical information, type: "get-help Get-Help -full".

PS C:\users\edwils> get-help get-help

NAZWA Get-Help

STRESZCZENIE Wyświetla informacje o cmdletach i koncepcjach powłoki Windows PowerShell.

SKŁADNIA Get-Help [[-name] <string>] [-component <string[]>] [-functionality <string[]>] [-role <string[]>] [-category <string[]>] [-full] [<CommonParameters>]

Get-Help [[-name] <string>] [-component <string[]>] [-functionality <string[]>] [-role <string[]>] [-category <string[]>] [-detailed] [<CommonParameters>]

Get-Help [[-name] <string>] [-component <string[]>] [-functionality <string[]>] [-role <string[]>] [-category <string[]>] [-examples] [<CommonParameters>]

Get-Help [[-name] <string>] [-component <string[]>] [-functionality <string[]>] [-role <string[]>] [-category <string[]>] [-parameter <string>] [<CommonParameters>]

SZCZEGÓŁOWY OPIS Cmdlet Get-Help wyświetla informacje o cmdletach i koncepcjach powłoki Windows PowerShell. Można również użyć polecenia "Help {<nazwa cmdletu> | <nazwa-tematu>" lub "<nazwa-cmdletu /?". Polecenie "Help" wyświetla tematy pomocy po jednej stronie na raz. Symbol "/?" wyświetla pomoc dla cmdletów na jednej stronie.

ŁĄCZA POKREWNE Get-Command Get-PSDrive Get-Member

UWAGI Aby uzyskać więcej informacji, wpisz polecenie: "get-help Get-Help -detailed". Aby uzyskać informacje techniczne, wpisz polecenie: "get-help Get-Help -full".

Wyjątkową właściwością systemu bezpośredniej pomocy programu Windows PowerShell jest fakt, że system ten nie tylko potrafi wyświetlać informacje pomocy dotyczące różnych poleceń, ale także to, że oferuje trzy różne poziomy wyświetlania tych informacji: nor-mal (normalny), detailed (szczegółowy) oraz full (pełen). Ponadto możliwe jest uzyskanie pomocy na temat koncepcji i pojęć stosowanych przez program Windows PowerShell. Ta ostatnia możliwość jest równoważna posiadaniu instrukcji obsługi dostępnej w trybie online. W celu uzyskania listy wszystkich artykułów pomocy dotyczących różnych pojęć należy użyć polecenia Get-Help about*, tak jak to pokazano poniżej:

get-help about*


Przypuśćmy, że nie pamiętamy dokładnej nazwy polecenia typu cmdlet, z którego zamie-rzaliśmy skorzystać, ale pamiętamy, że był to cmdlet o nazwie zaczynającej się na „get”. Pełną nazwę tego polecenia można uzyskać posługując się znakami uogólniającymi (takim jak *). Np.:

get-help get*

Tę technikę wykorzystywania operatów uogólniających można rozszerzyć jeszcze dalej. Jeśli pamiętamy, że potrzebny cmdlet był narzędziem z grupy „get”, którego nazwa rozpoczy-nała się na literę p, to nazwę tego narzędzia można uzyskać przy pomocy następującego polecenia:

get-help get-p*

Przypuśćmy jednak, że znamy dokładną nazwę polecenia typu cmdlet, ale nie pamię-tamy szczegółów jego składni. W takiej sytuacji można skorzystać z argumentu -examples (przykłady). W celu uzyskania kliku przykładów użycia polecenia cmdlet Get-PSDrive można skorzystać z polecenia Get-Help (Pobierz pomoc) z argumentem -examples, tak jak to zostało pokazane poniżej:

get-help get-psdrive -examples

Jeśli chcemy, aby tekst pomocy wyświetlany był kolejno, po jednej stronie, to można użyć funkcji pomocy wyświetlającej tekst pomocy poprzez funkcję more. Jest to bardzo przy-datna możliwość, jeśli chce się uniknąć ciągłego przewijania tekstu pomocy w górę i w dół. Przykład takiego polecenia pokazany został poniżej:

get-help get-help | more

Strumień wyjściowy tego polecenia, sformatowany za po mocą funkcji more, pokazany został na rysunku 1-3.

W celu uzyskania szczegółowej pomocy na temat plecenia cmdlet Get-Help (Pobierz pomoc) należy użyć argumentu -detailed, tak jak to pokazano poniżej:

get-help get-help -detailed

Jeśli potrzebować będziemy technicznych informacji na temat polecenia cmdlet Get-Help (Pobierz pomoc), to należy użyć argumentu -full. Odpowiedni przykład znajduje się poniżej:

get-help get-help -full

Ciągłe wpisywanie nazwy Get-Help może być męczące. W końcu jest to aż 8 znaków, w tym jeden myślnik. Rozwiązaniem może być utworzenie dla polecenia Get-Help tzw. aliasu. Alias to skrócona kombinacja znaków, której wpisanie spowoduje uruchomienie żądanego programu lub polecenia typu cmdlet. Tworząc alias dla polecenia Get-Help można np. przypisać ten cmdlet do kombinacji liter gh.


Rysunek 1-3 Stosowanie funkcji more umożliwia wyświetlanie długich tematów kolejno, po jednej stronie.

Wskazówka Przed utworzeniem nowego aliasu dla polecenia typu cmdlet należy sprawdzić za pomocą polecenia Get-Alias (Pobierz alias), czy nie istnieje już inny alias o takiej samej nazwie. Następnie korzystając z polecenia cmdlet Set-Alias (Ustaw alias) można przypisać wybrany cmdlet do unikalnej kombinacji znaków.

Praca z aliasami i przypisywanie skróconych nazw poleceniom typu cmdlet

Aliasy umożliwiają przypisywanie skróconych nazw do programów narzędziowych typu cmdlet. Pozwala to na poważne uproszczenie korzystania z wiersza poleceń programu Windows PowerShell i umożliwia dostosowanie składni poleceń do własnych preferencji. Jako przykład załóżmy, że chcemy utworzyć alias dla polecenia cmdlet Get-Help (Pobierz pomoc). Prawdopodobnie większość osób wolałaby wpisywać litery gh, zamiast całego słowa Get-Help. Aby uniknąć nieporozumień, najpierw należy sprawdzić, czy żądanej kombinacji znaków nie został już przypisany inny alias. Kolejna rzecz, którą warto zrobić, to zapoznanie się z tekstem pomocy dla polecenia Set-Alias (Ustaw alias). Po wykonaniu tych czynności należy wywołać cmdlet Set-Allias przekazując mu nową nazwę dla tworzo-nego aliasu oraz nazwę polecenia typu cmdlet, którego dotyczyć ma ten alias. Po utworze-niu aliasu można sprawdzić jego poprawność, korzystając z polecenia Get-Alias (Pobierz alias). Pełny kod przykładów z tej części znajduje się na towarzyszącej tej książce płycie CD-ROM, w pliku GhAlias.txt z katalogu chapter01.


1. Pobierz alfabetyczną listę wszystkich aktualnie zdefiniowanych aliasów i sprawdź, czy widnieje na niej alias przypisany do polecenia cmdlet Get-Help lub do kombinacji zna-ków gh. Polecenie pozwalające na wykonanie tego zadania zostało pokazanie poniżej:

get-alias |sort

2. Po sprawdzeniu, że nie istnieje żaden alias dla polecenia cmdlet Get-Help oraz że żaden alias nie został przypisany do kombinacji liter gh, zapoznaj się ze składnią polecenia Set-Alias (Ustaw alias). Użyj do tego celu polecenia Get-Help z argumentem -full. Odpowiednie polecenie zostało pokazane poniżej:

get-help set-alias -full

3. Używając polecenia cmdlet Set-Alias (Ustaw alias) przypisz kombinację liter gh do pole-cenia Get-Help. W tym celu należy wykonać następujące polecenie:

set-alias gh get-help

4. Używając polecenia cmdlet Get-Alias (Pobierz alias) sprawdź poprawność utworzenia aliasu. W celu celu należy wykonać następujące polecenie:

Get-Alias gh

Wskazówka Jeśli składnia polecenia cmdlet Set-Alias jest dla kogoś nieco dezorientująca, to zamiast stosowanego domyślnie pozycyjnego wiązania parametrów można posługiwać się parametrami nazwanymi. Ponadto zalecane jest użycie przełącznika whatif albo confirm. Możliwe jest także podanie opisu dla tworzonego aliasu. Zmodyfikowana składnia dla tego polecenia wyglądać będzie w następujący sposób:

Set-Alias -Name gh -Value Get-Help -Description "mred help alias" -WhatIf

Jak zatem widać, program Windows PowerShell może być używany jako zamiennik inter-pretera poleceń CMD. Zawiera on także dużą liczbę wbudowanych programów narzędzio-wych typu cmdlet, które umożliwiają wykonywanie mnóstwa różnych działań. Te polecenia typu cmdlet mogą być używane albo jako narzędzia autonomiczne, albo można je urucha-miać razem jako jedną grupę.

Dodatkowe zastosowania poleceń typu cmdletPo zaznajomieniu się ze sposobem korzystania z polecenia cmdlet oferującego dostęp do systemu pomocy oraz sposobu korzystania z aliasów, nadeszła pora na zapoznanie się z innymi sposobami wykorzystywania narzędzi typu cmdlet, oferowanych przez program Windows PowerShell.

Wskazówka Aby przyspieszyć wpisywanie nazw poleceń typu cmdlet, wystarczy wpisać tylko tyle znaków, ile potrzeba do jednoznacznego rozróżnienia danego polecenia, a następnie wci-snąć klawisz Tab. Jaki będzie tego rezultat? Wciśnięcie klawisza Tab spowoduje uzupełnienie nazwy polecenia typu cmdlet. Taka technika działa również w przypadku nazw argumentów oraz innych procedur. Warto nieco poeksperymentować z tą doskonałą oszczędzającą czas techniką. Dzięki niej już nigdy nie trzeba będzie wpisywać np. get-command!


Uruchamianie programu Windows PowerShell

Po zainstalowaniu programu Windows PowerShell jest on natychmiast gotowy do użytku. Jednak konieczność jednoczesnego naciskania klawisza R oraz klawisza z logo systemu Windows lub posługiwania się myszą w celu otwarcia za pomocą menu Start okna dialo-gowego Uruchom i wpisywania w tym oknie za każdym razem PowerShell z pewnością jest dość uciążliwe. Z tego względu utworzyłem skrót do programu Windows PowerShell i umieściłem go na pulpicie. Biorąc pod uwagę sposób, w jaki pracuję, jest to dla mnie idealne rozwiązanie. W rzeczywistości jest to na tyle użyteczne, że napisałem skrypt wyko-nujący tę operację. W celu automatycznego utworzenia odpowiedniego skrótu na pulpicie skrypt ten można uruchomić za pośrednictwem skryptu logowania. Skrypt ten nosi nazwę CreateShortCutToPowerShell.vbs:

CreateShortCutToPowerShell.vbs

Option Explicit Dim objshell Dim strDesktop Dim objshortcut Dim strProg strProg = "powershell.exe"

Set objshell=CreateObject("WScript.Shell") strDesktop = objshell.SpecialFolders("desktop") set objShortcut = objshell.CreateShortcut(strDesktop & "\powershell.lnk") objshortcut.TargetPath = strProg objshortcut.WindowStyle = 1 objshortcut.Description = funfix(strProg) objshortcut.WorkingDirectory = "C:\" objshortcut.IconLocation= strProg objshortcut.Hotkey = "CTRL+SHIFT+P" objshortcut.Save

Function funfix(strin) funfix = InStrRev(strin,".") funfix = Mid(strin,1,funfix) End function

Ponieważ polecenia typu cmdlet zwracają obiekty, a nie „wartości tekstowe”, możliwe jest uzyskanie dodatkowych informacji o zwróconych obiektach. Te dodatkowe informacje nie byłyby dostępne w przypadku korzystania wyłącznie z danych tekstowych. W celu uzyska-nia dodatkowych informacji należy użyć symbol potoku (|), a następnie pobrać informacje z jednego polecenia typu cmdlet i przekazać je do drugiego. Może wydawać się, że jest to skomplikowane, ale w rzeczywistości jest bardzo proste. Pod koniec tego rozdziału taka procedura powinna wydawać się już całkiem naturalna.

Rozpatrzmy najbardziej podstawowy przykład: uzyskiwanie i formatowanie listy zawar-tości katalogu. Po uzyskaniu listy zawartości katalogu może pojawić się potrzeba sforma-towania sposobu wyświetlania tej listy, np. jako tabeli abo jako zwykłej listy. Jak zatem widać, mamy tu do czynienia z dwiema osobnymi operacjami: pobieraniem listy zawartości


katalogu oraz formatowaniem tej listy. Zadanie formatowania realizowane jest po prawej stronie symbolu potoku, po zgromadzeniu listy zawartości katalogu. Jest to zwykły sposób działania potoków. Przyjrzymy się im teraz w działaniu, na przykładzie polecenia cmdlet Get-ChildItem (Pobierz element potomny).

Korzystanie z polecenia Get-ChildItemWe wcześniej części tego rozdziału, do pobrania listy wszystkich plików z katalogu bieżą-cego używane było polecenie dir. Było to możliwe, ponieważ program Windows PowerShell posiada wbudowany alias przypisujący cmdlet Get-Childltem (Pobierz element potomny) do kombinacji liter dir. Można to sprawdzić posługując się poleceniem cmdlet Get-Alias (Pobierz alias), co zostało pokazne w przykładzie z pliku GetDirAlias.txt.

GetDirAlias.txtPS C:\> Get-Alias dir

CommandType Name Definition ----------- ---- ---------- Alias dir Get-ChildItem

W rzeczywistości program Windows PowerShell nie zawiera polecenia typu cmdlet o nazwie dir ani nie korzysta z polecenia dir. Alias dir został po prostu skojarzony z poleceniem cmdlet Get-Childltem (Pobierz element potomny). To dlatego wynik polecenia dir jest inny w oknie programu Windows PowerShell niż w oknie interpretera poleceń Cmd.exe. O tym, że polecenie dir jest w istocie aliasem, można się przekonać po rozszyfrowaniu skojarzenia za pomocą polecenia Get-Alias.

Wskazówka Jeśli korzystając z polecenia Get-Childltem chcemy, aby lista zawartości kata-logu zawierała również ukryte oraz systemowe pliki i foldery, to należy użyć przełącznika force (Wymuś). Całe polecenie będzie wówczas wyglądać następująco: Get-ChildItem -Force.

Formatowanie wyjściaProgram Windows PowerShell zawiera cztery polecenia formatujące typu cmdlet. Trzy spo-śród nich, Format-List (Format listy), Format-Wide (Forma szeroki) oraz Format-Table (Format tabeli), są używane rutynowo. Czwarty cmdlet, Format-Custom (Format niestan-dardowy), może wyświetlać dane wyjściowe w sposób niebędący ani listą, ani tabelą, ani formatem szerokim. Cmdlet ten realizuje to wykorzystując plik *.format.ps1xml. Możliwe jest wykorzystywanie domyślnych widoków zawartych w plikach *.format.ps1xml albo zdefiniowanie własnych plików typu format.ps1xml.

Przyjrzyjmy się zatem formatowaniu strumienia wyjściowego przy użyciu pozosta-łych trzech poleceń formatujących, zaczynając od najbardziej użytecznego z tej trójki: Format-List.


Format-List

Cmdlet Format-List jest jednym z podstawowych poleceń typu cmdlet, które będzie bardzo często używane przez każdego administratora. Np. używając polecenia Get-WmiObject (Pobierz obiekt WMI) do odczytania właściwości klasy Win32_LogicalDisk otrzymamy jedy-nie minimalną listę domyślnych właściwości tej klasy. Odpowiedni przykład przedstawiony został poniżej:

PS C:\> Get-WmiObject Win32_LogicalDisk

DeviceID : C: DriveType : 3 ProviderName : FreeSpace : 10559041536 Size : 78452355072 VolumeName : Sea Drive

Wprawdzie w wielu przypadkach takie działanie jest odpowiednie, ale czasami możemy być zainteresowani również innymi właściwościami tej klasy. Pierwszą rzeczą, którą należy wykonać podczas sprawdzania dostępności innych właściwości, jest użycie znaku uogól-niającego *. Spowoduje to wyświetlenie listy wszystkich właściwości, tak jak to zostało pokazane poniżej:

PS C:\> Get-WmiObject Win32_LogicalDisk | Format-List *

Status : Availability : DeviceID : C: StatusInfo : __GENUS : 2 __CLASS : Win32_LogicalDisk __SUPERCLASS : CIM_LogicalDisk __DYNASTY : CIM_ManagedSystemElement __RELPATH : Win32_LogicalDisk.DeviceID="C:" __PROPERTY_COUNT : 40 __DERIVATION : {CIM_LogicalDisk, CIM_StorageExtent, CIM_LogicalDevice, CIM_LogicalElement...} __SERVER : M5-1875135 __NAMESPACE : root\cimv2 __PATH : \\M5-1875135\root\cimv2:Win32_LogicalDisk.DeviceID="C:" Access : 0 BlockSize : Caption : C: Compressed : False ConfigManagerErrorCode : ConfigManagerUserConfig : CreationClassName : Win32_LogicalDisk Description : Local Fixed Disk DriveType : 3 ErrorCleared : ErrorDescription : ErrorMethodology : FileSystem : NTFS FreeSpace : 10559041536


InstallDate : LastErrorCode : MaximumComponentLength : 255 MediaType : 12 Name : C: NumberOfBlocks : PNPDeviceID : PowerManagementCapabilities : PowerManagementSupported : ProviderName : Purpose : QuotasDisabled : QuotasIncomplete : QuotasRebuilding : Size : 78452355072 SupportsDiskQuotas : False SupportsFileBasedCompression : True SystemCreationClassName : Win32_ComputerSystem SystemName : M5-1875135 VolumeDirty : VolumeName : Sea Drive VolumeSerialNumber : F0FE15F7

Po zapoznaniu się z listą wszystkich właściwości dostępnych dla danej klasy można następ-nie wybrać tylko te z nich, które są dla nas interesujące. Znak uogólniający * należy zastą-pić nazwami właściwości wybranych z poprzedniej listy. Ta technika została zilustrowana poniżej:

PS C:\> Get-WmiObject Win32_LogicalDisk | Format-List Name, FileSystem, FreeSpace

Name : C: FileSystem : NTFS FreeSpace : 10559029248

Zamiast wpisywać długą listę nazw właściwości, korzystając ze znaków uogólniających można określić żądany przedział właściwości. Np. aby wyświetlić tylko te właściwości, których nazwy zaczynają się na literę f, można posłużyć się pokazaną poniżej techniką:

PS C:\> Get-WmiObject Win32_LogicalDisk | Format-List f*

FileSystem : NTFS FreeSpace : 10558660608

Jeśli interesują nas właściwości o nazwach zaczynających się na literę n lub na literę f, to należy posłużyć się nawiasami kwadratowymi, tak jak to pokazano poniżej:

PS C:\> Get-WmiObject Win32_LogicalDisk | Format-List [nf]*

FileSystem : NTFS FreeSpace : 10558238720 Name : C: NumberOfBlocks :


Wszystkie te polecenia wraz z kompletnymi wynikami ich działania można znaleźć w pliku Format-List.txt, znajdującym się na towarzyszącej tej książce płycie CD-ROM, w katalogu chapter01.

Format-Table

Cmdlet Format-Table oferuje kilka funkcji sprawiających, że narzędzie to szczególnie dobrze nadaje się do realizacji zadań związanych z zarządzaniem siecią. W szczególności potrafi ono tworzyć kolumny danych, w sposób umożliwiający ich szybkie przegląda-nie. Podobnie jak w przypadku poleceń Format-List i Format-Wide, istnieje możliwość wyboru właściwości, które mają być wyświetlane, i eliminowania w ten sposób rozprasza-jących uwagę danych pochodzących ze zbyt rozwlekłych strumieni wyjściowych niektó-rych poleceń typu cmdlet. W pokazanym poniżej przykładzie najpierw przeszukiwany jest cały dysk twardy w poszukiwaniu wszystkich plików dzienników (tj. plików z rozsze-rzeniem .log). Pełen strumień wyjściowy tego polecenia jest dość znacznych rozmiarów i poniżej pokazany został tylko jego przykładowy wycinek. W pokazanym poniżej przy-kładzie cmdlet Format-Table został użyty do uformowania danych wyjściowych polecenia Get-Childltem:

PS C:\> Get-ChildItem c:\ -Recurse -Include *.log | Format-Table

Directory: Microsoft.PowerShell.Core\FileSystem::C:\Backup_Extras_92705

Mode LastWriteTime Length Name ---- ------------- ------ ---- -a--- 8/3/2004 6:34 PM 3931872 setupapi.log -a--- 8/2/2004 9:32 PM 206168 Windows Update.log -a--- 6/8/2004 12:41 AM 170095 wmsetup.log

Oprócz polegania na domyślnym sposobie działania tego polecenia typu cmdlet, możliwe jest wybieranie konkretnych właściwości. Jednym z problemów ujawniających się przy takim podejściu jest fakt, że do formatowania danych wyjściowych używana jest dostępna rozdzielczość ekranu, co często może prowadzić do pokazanej poniżej sytuacji, w której część kolumn wypada po przeciwnej stronie okna. Taki format może być akceptowalny dla szybkiego wyświetlania mocno zróżnicowanych kolumn, ale nie nadaje się do zapisywania danych.

PS C:\> Get-ChildItem c:\ -Recurse -Include *.log | Format-Table -Property name, length, lastWriteTime

Name Length LastWriteTime ---- ------ ------------- setupapi.log 3931872 8/3/2004 6:34:53 PM Windows Update.log 206168 8/2/2004 9:32:06 PM wmsetup.log 170095 6/8/2004 12:41:32 AM Debug.log 0 8/23/2006 8:10:38 PM


AVCheck.Log 191694 5/8/2007 9:28:05 AM AVCheckServer.Log 7762 5/8/2007 9:28:05 AM

W celu utworzenia listy, wykorzystującej dostępny rozmiar okna w bardziej efektywny sposób, można zastosować przełącznik autosize. Korzystając z przełącznika autosize należy tylko pamiętać o jednej rzeczy: użycie tego przełącznika wymaga, aby znana była długość najdłuższego elementu w każdej kolumnie. Oznacza to, że cmdlet musi zaczekać na zakoń-czenie enumeracji wszystkich elementów, a następnie wyznaczyć maksymalną długość każdej kolumny oraz rozmiar całej listy. Może to powodować zablokowanie wykonywa-nia polecenia do czasu dostarczenia wszystkich elementów, co może zająć nieco czasu. Administrator może jednak nie mieć czasu, aby po użyciu przełącznika autosize czekać na zakończenie enumeracji dużej kolekcji obiektów, np. gdy pracuje nad problemem powo-dującym przestój serwera. Dla małych zbiorów obiektów negatywny wpływ na wydajność jest pomijalny, jednak w przypadku poleceń, których wykonanie zajmuje dużo czasu, takich jak pokazane w tym przykładzie, różnica może być istotna. Jednak uzyskiwana tym kosztem różnica w strumieniu wyjściowym jest również istotna (i większość administrato-rów prawdopodobnie zgodzi się, że warto dłużej zaczekać na bardziej czytelne wyniki).

PS C:\> Get-ChildItem c:\ -Recurse -Include *.log | Format-Table -Property name, length, lastWriteTime -AutoSize

Name Length LastWriteTime ---- ------ ------------- setupapi.log 3931872 8/3/2004 6:34:53 PM Windows Update.log 206168 8/2/2004 9:32:06 PM wmsetup.log 170095 6/8/2004 12:41:32 AM Debug.log 0 8/23/2006 8:10:38 PM AVCheck.Log 191694 5/8/2007 9:28:05 AM

Ostatnią rzeczą, na którą warto zwrócić uwagę w przypadku polecenia Format-Table, jest połączenie go z poleceniem Sort-Object (Sortowanie obiektów). Cmdlet Sort-Object umożliwia porządkowanie danych według ich właściwości i ich wyświetlanie w posorto-wany sposób. W pokazanym poniżej przykładzie użyty został alias polecenia Sort-Object (sort), co pozwala na zredukowanie ilości potrzebnych do wpisania znaków. Pomimo tego, całe polecenie jest nadal dość długie i dla poprawy jego czytelności zostało umieszczone w dwóch liniach (nawiasem mówiąc, jeśli polecenie staje się na tyle długie, to zwykle przekształcam je w skrypt). Analizując przedstawione poniżej polecenie należy zwrócić uwagę, że dane są sortowane przed przekazaniem ich do polecenia Format-Table. Należy również pamiętać, że domyślnym porządkiem sortowania dla polecenia Sort-Object jest porządek rosnący (od najmniejszego do największego). Jeśli istnieje taka potrzeba, można użyć przełącznika -descending, aby uzyskać dane wyjściowe uporządkowane w kolejności od największego do najmniejszego.

PS C:\>Get-ChildItem c:\ -Recurse -Include *.log | Sort -Property length | Format-Table name, lastwriteTime, length -AutoSize Name LastWriteTime Length ---- ------------- ------ PASSWD.LOG 5/10/2007 2:44:58 AM 0 sam.log 11/29/2006 1:14:33 PM 0


poqexec.log 2/1/2007 6:50:49 PM 0 ChkAcc.log 5/10/2007 2:45:00 AM 0 Debug.log 8/23/2006 8:10:38 PM 0 setuperr.log 3/16/2007 7:18:17 AM 0 setuperr.log 4/4/2007 6:34:54 PM 0 netlogon.log 2/1/2007 7:04:44 PM 3

Istnieją również inne sposoby sortowania danych. Listę plików dzienników można np. posortować w kolejności mającej, według daty ich modyfikacji. W ten sposób na początku listy znajdą się ostatnio zmodyfikowane pliki dzienników. Wykonanie takiej procedury wymaga zmodyfikowania obiektu sortującego. Pozostała część polecenia pozostaje bez zmian. Część wyników tego polecenia została pokazana poniżej. Warto w tym miejscu zwrócić uwagę na fakt, że większość ze znalezionych plików dzienników została zmodyfi-kowana podczas procesu logowania się w systemie.

PS C:\> Get-ChildItem c:\ -Recurse -Include *.log | Sort -Property lastWriteTime -descending | Format-Table name, lastwriteTime, length -AutoSize Name LastWriteTime Length ---- ------------- ------ mtrmgr.log 5/10/2007 4:56:52 AM 1538364 LocationServices.log 5/10/2007 4:56:26 AM 830557 StateMessage.log 5/10/2007 4:55:00 AM 129595 Scheduler.log 5/10/2007 4:55:00 AM 393352 StatusAgent.log 5/10/2007 4:53:24 AM 723564 edb.log 5/10/2007 4:51:49 AM 131072 PolicyEvaluator.log 5/10/2007 4:51:25 AM 1672613 ClientLocation.log 5/10/2007 4:51:24 AM 330046 FSPStateMessage.log 5/10/2007 4:51:18 AM 228879 CBS.log 5/10/2007 4:46:55 AM 28940091 CertificateMaintenance.log 5/10/2007 4:42:17 AM 206472 CcmExec.log 5/10/2007 4:00:51 AM 537177 wmiprov.log 5/10/2007 3:03:11 AM 19503 PolicyAgentProvider.log 5/10/2007 2:54:02 AM 252866 UpdatesHandler.log 5/10/2007 2:53:19 AM 108552 CIAgent.log 5/10/2007 2:53:19 AM 99114 ScanAgent.log 5/10/2007 2:53:18 AM 354939 UpdatesDeployment.log 5/10/2007 2:53:18 AM 1106297 SrcUpdateMgr.log 5/10/2007 2:53:02 AM 151452 smssha.log 5/10/2007 2:52:02 AM 107104 execmgr.log 5/10/2007 2:52:02 AM 150942 InventoryAgent.log 5/10/2007 2:52:02 AM 34034 ServiceWindowManager.log 5/10/2007 2:52:02 AM 139955 SdmAgent.log 5/10/2007 2:49:46 AM 172101 UpdatesStore.log 5/10/2007 2:49:43 AM 64787 WUAHandler.log 5/10/2007 2:49:39 AM 14590 CAS.log 5/10/2007 2:49:35 AM 198955 PeerDPAgent.log 5/10/2007 2:49:35 AM 7900 PolicyAgent.log 5/10/2007 2:49:35 AM 246873 RebootCoordinator.log 5/10/2007 2:49:35 AM 20420 InternetProxy.log 5/10/2007 2:49:34 AM 85825 ClientIDManagerStartup.log 5/10/2007 2:49:34 AM 158351 WindowsUpdate.log 5/10/2007 2:46:46 AM 1553462 edb.log 5/10/2007 2:46:43 AM 65536 setupapi.dev.log 5/10/2007 2:46:38 AM 6469237


setupapi.app.log 5/10/2007 2:46:38 AM 2722285 WMITracing.log 5/10/2007 2:45:57 AM 16777216 ChkAcc.log 5/10/2007 2:45:00 AM 0 PASSWD.LOG 5/10/2007 2:44:58 AM 0

Przeglądając plik Format-Table.txt z katalogu chapter01 można zauważyć, że plik ten zawiera wiele błędów. Wynika to z faktu, że przeszukując dysk cmdlet Get-ChildItem próbował otwierać również chronione pliki i katalogi powodując generowanie komunika-tów o odmowie dostępu. W fazie tworzenia skryptu błędy te mogą być bardzo pomocne, ponieważ dzięki nim wiadomo, że pewne pliki i foldery są niedostępne, jednak po prze-analizowaniu danych ich użyteczność staje się problematyczna. Poniżej pokazany został przykład jednego z takich błędów:

Get-ChildItem : Access to the path 'C:\Windows\CSC' is denied. At line:1 char:14

Get-ChildItem : Odmowa dostępu do ścieżki 'C:\Windows\CSC'.Plik: wiersz; wiersz: 1; znak: 14

Przydatność komunikatu błędu polega na wskazaniu w nim nazwy polecenia typu cmdlet, które spowodowało wystąpienie błędu oraz akcji, która doprowadziła do tego błędu. Tego typu błędy można wyeliminować dodając do polecenia Get-ChildItem wspólny parametr -ErrorAction ze słowem kluczowym SilentlyContinue. Zmodyfikowana linia z tym pole-ceniem została pokazana poniżej:

PS C:\> Get-ChildItem c:\ -Recurse -Include *.log -errorAction SilentlyContinue | Sort -Property lastWriteTime -descending | Format-Table name, lastwriteTime, length -AutoSize

Format-Wide

Cmdlet Format-Wide nie jest już tak użyteczny jak polecenia Format-Table lub Format-List. Wynika to z ograniczenia pozwalającego na wyświetlanie tylko jednej wła-ściwości każdego obiektu. Możliwość tworzenia tego typu list może być jednak przydatna. Przypuśćmy np., że chcemy uzyskać tylko listę działających na komputerze procesów. Można do tego celu wykorzystać cmdlet Get-Process (Pobierz proces) i skierować poto-kiem otrzymane obiekty wynikowe do polecenia cmdlet Format-Wide, tak jak to zostało pokazane poniżej:

PS C:\> Get-Process | Format-Wide

ApMsgFwd ApntEx Apoint audiodg casha CcmExec csrss csrss dwm explorer FwcAgent Idle InoRpc InoRT InoTask lsass lsm mobsync MSASCui powershell powershell PowerShellIDE rundll32 SearchFilterHost SearchIndexer SearchProtocolHost


services SLsvc smss spoolsv SRUserService svchost svchost svchost svchost svchost svchost svchost svchost svchost svchost svchost svchost svchost svchost svchost System taskeng taskeng ThpSrv ThpSrv TODDSrv wininit winlogon WINWORD wmdc WmiPrvSE WmiPrvSE

Wyniki wypisane przez to polecenie, choć użyteczne, zajmują jednak mnóstwo linii na kon-soli, marnując przy tym sporą część ekranu. Lepszy rezultat można otrzymać używając parametru -column. Przykład ilustrujący użycie tego parametru został pokazany poniżej:

PS C:\> Get-Process | Format-Wide -Column 4

Wprawdzie zastosowanie 4 kolumn wyjściowych skraca długość całej listy o połowę, ale nadal nie prowadzi do maksymalnego wykorzystania całej dostępnej powierzchni ekranu. Choć możliwe jest napisanie skryptu wyznaczającego optymalną wartość parametru -column, takiego jak zamieszczony poniżej skrypt DemoFormatWide.ps1, to jednak takie przedsięwzięcie nie jest warte czasu oraz wysiłku niezbędnego do jego realizacji.

DemoFormatWide.ps1function funGetProcess() { if ($args) { Get-Process | Format-Wide -autosize } else { Get-Process | Format-Wide -column $i } }

cls $i = 1 for ($i ; $i -le 10 ; $i++) { Write-Host -ForegroundColor red "`$i jest równe $i" funGetProcess } Write-Host -ForeGroundColor red "Teraz użyte zostało polecenie format-wide z parametrem -autosize" funGetProcess("auto")


Lepszym sposobem znalezienia optymalnej konfiguracji ekranu dla polecenia cmdlet Format-Wide będzie użycie przełącznika -autosize, tak jak to pokazano poniżej:

PS C:\> Get-Process | Format-Wide -AutoSize

Stosowanie polecenia cmdlet Get-CommandIstnieją trzy polecenia typu cmdlet, które można porównać do trzech podstawowych przypraw używanych w kuchni Cajun. Potrawy kuchni Cajun można przygotowywać w dowolny sposób, o ile tylko pamięta się o soli, pieprzu i papryce. Chcesz przygotować zieloną fasolkę a’la Cajun? Dodaj trochę soli, pieprzu i papryki. Chcesz pracować z pro-gramem Windows PowerShell? A więc pamiętaj o trzech poleceniach cmdlet typu „Cajun”: Get-Help (Pobierz pomoc), Get-Command (Pobierz polecenie) oraz Get-Member (Pobierz element członkowski). Opierając się na tych trzech poleceniach można w pełni opanować posługiwanie się programem Windows PowerShell. Ponieważ cmdlet Get-Help został już omówiony wcześniej, zajmiemy się teraz omówieniem polecenia Get-Command.

Najprostszym zastosowaniem polecenia Get-Command jest utworzenie listy poleceń dostępnych z poziomu programu Windows PowerShell. Jest to przydatna możliwość, jeśli chcemy szybko sprawdzić, jakie polecenia cmdlet są aktualnie dostępne. To elementarne zastosowanie polecenia Get-Command zostało pokazane poniżej. Warto w tym miejscu zwrócić uwagę na fakt, że definicja poleceń ma formę skróconą.

PS C:\> Get-Command

CommandType Name Definition ----------- ---- ---------- Cmdlet Add-Content Add-Content [-Path] <String[]> [-Value] <Object[... Cmdlet Add-History Add-History [[-InputObject] <PSObject[]>] [-Pass... Cmdlet Add-Member Add-Member [-MemberType] <PSMemberTypes> [-Name]... Cmdlet Add-PSSnapin Add-PSSnapin [-Name] <String[]> [-PassThru] [-Ve... Cmdlet Clear-Content Clear-Content [-Path] <String[]> [-Filter <Strin... Cmdlet Clear-Item Clear-Item [-Path] <String[]> [-Force] [-Filter ...

Domyślnie polecenie Get-Command zwraca listę tylko poleceń typu cmdlet i dlatego pole CommandType (Typ polecenia) nie wnosi żadnej nowej informacji. Ładniejszy format tej listy można uzyskać tworząc potok kierujący wyniki do polecenia Format-List i pozo-stawiając jedynie pola z nazwą oraz z definicją. Działanie takie zostało pokazane poniżej. Jak widać na tym przykładzie, taka forma prezentacji wyników jest znacznie łatwiejsza do odczytania i dostarcza definicji składni każdego polecenia:

PS C:\> Get-Command | Format-List name, definition

Name : Add-Content Definition : Add-Content [-Path] <String[]> [-Value] <Object[]> [-PassThru] [-Filter <String>] [-Include <String[]>] [-Exclude <String[]>] [-Force] [-Credential<PSCredential>] [-Verbose] [-Debug] [-ErrorAction <ActionPreference>]


[-ErrorVariable<String>] [-OutVariable <String>] [-OutBuffer <Int32>] [-WhatIf] [-Confirm][-Encoding <FileSystemCmdletProviderEncoding>] Add-Content [-LiteralPath] <String[]> [-Value] <Object[]> [-PassThru][-Filter <String>] [-Include <String[]>] [-Exclude <String[]>] [-Force] [-Credential<PSCredential>] [-Verbose] [-Debug] [-ErrorAction <ActionPreference>] [-ErrorVariable <String>] [-OutVariable <String>] [-OutBuffer <Int32>] [-WhatIf] [-Confirm] [-Encoding <FileSystemCmdletProviderEncoding>]

Name : Add-History Definition : Add-History [[-InputObject] <PSObject[]>] [-Passthru] [-Verbose] [-Debug] [-ErrorAction <ActionPreference>] [-ErrorVariable <String>] [-OutVariable String>] [-OutBuffer <Int32>]

Dotychczas pokazane zostało zwykle zastosowanie polecenia cmdlet Get-Command. Bardziej interesująca metoda korzystania z tego polecenia opiera się na znajomości cza-sowników i rzeczowników, składających się na nazwy poleceń typu cmdlet. Posiadając taką wiedzę można np. wyszukać wszystkie polecenia typu cmdlet zawierające w nazwie rzeczownik process (proces). Odpowiednie polecenie mogłoby wyglądać w następujący sposób:

PS C:\> Get-Command -Noun process

CommandType Name Definition ----------- ---- ---------- Cmdlet Get-Process Get-Process [[-Name] <String[]>] [-Verbose] [-De... Cmdlet Stop-Process Stop-Process [-Id] <Int32[]> [-PassThru] [-Verbo...

Jeśli zechcemy uzyskać listę poleceń, których rzeczownikowa część nazwy zaczyna się na literę p, to możemy skorzystać z tej procedury posługując się znakami uogólniającymi. Pozwala to zredukować liczbę koniecznych do wpisania znaków i jednocześnie pomaga zapoznać się z dostępnymi poleceniami typu cmdlet. Przykład takiego polecenia został pokazany poniżej:

PS C:\> get-command -Noun p*

CommandType Name Definition ----------- ---- ---------- Cmdlet Add-PSSnapin Add-PSSnapin [-Name] <String[]> [-PassThru] [-Ve... Cmdlet Convert-Path Convert-Path [-Path] <String[]> [-Verbose] [-Deb... Cmdlet Get-PfxCertificate Get-PfxCertificate [-FilePath] <String[]> [-Verb... Cmdlet Get-Process Get-Process [[-Name] <String[]>] [-Verbose] [-De... Cmdlet Get-PSDrive Get-PSDrive [[-Name] <String[]>] [-Scope <String... Cmdlet Get-PSProvider Get-PSProvider [[-PSProvider] <String[]>] [-Verb... Cmdlet Get-PSSnapin Get-PSSnapin [[-Name] <String[]>] [-Registered] ... Cmdlet Join-Path Join-Path


[-Path] <String[]> [-ChildPath] <Strin... Cmdlet New-PSDrive New-PSDrive [-Name] <String> [-PSProvider] <Stri... Cmdlet Out-Printer Out-Printer [[-Name] <String>] [-InputObject <PS... Cmdlet Remove-PSDrive Remove-PSDrive [-Name] <String[]> [-PSProvider <... Cmdlet Remove-PSSnapin Remove-PSSnapin [-Name] <String[]> [-PassThru] [... Cmdlet Resolve-Path Resolve-Path [-Path] <String[]> [-Credential <PS... Cmdlet Set-PSDebug Set-PSDebug [-Trace <Int32>] [-Step] [-Strict] [... Cmdlet Split-Path Split-Path [-Path] <String[]> [-LiteralPath <Str... Cmdlet Stop-Process Stop-Process [-Id] <Int32[]> [-PassThru] [-Verbo... Cmdlet Test-Path Test-Path [-Path] <String[]> [-Filter <String>] ... Cmdlet Write-Progress Write-Progress [-Activity] <String> [-Status] <S...

Domyślnie polecenie Get-Command wyświetla tylko polecenia typu cmdlet, ale może ono zwracać również nazwy innych elementów, nawet plików .exe lub .dll. Polecenie Get-Command może wyświetlać informacje o każdym elemencie, który można uruchomić z poziomu programu Windows PowerShell. Poniżej pokazany został przykład polecenia zwracającego listę wszystkich poleceń zawierających w nazwie słowo file (plik). Należy przy tym pamiętać, że wyświetlane są tylko te elementy, które dostępne są dla programu Windows PowerShell.

PS C:\> get-command -Name *file*

CommandType Name Definition ----------- ---- ---------- Application avifile.dll C:\Windows\system32\avifile.dll Application filemgmt.dll C:\Windows\system32\filemgmt.dll Application FileSystem.format.ps1xml C:\Windows\System32\WindowsPowerShell\v1.0\FileS... Application filetrace.mof C:\Windows\System32\Wbem\filetrace.mof Application forfiles.exe C:\Windows\system32\forfiles.exe

Działanie pokazanego powyżej przykładu można łatwo skorygować używając parametru -commandType i ograniczając za jego pomocą listę wyników wyłącznie do poleceń typu cmdlet. Zmodyfikowana wersja tego polecenia została pokazana poniżej:

PS C:\> get-command -Name *file* -CommandType cmdlet

CommandType Name Definition ----------- ---- ---------- Cmdlet Out-File Out-File


[-FilePath] <String> [[-Encoding] <Stri

Powyższe przykłady ilustrują możliwe sposoby wyszukiwania poleceń typu cmdlet za pomocą polecenia Get-Command. Wszystkie pokazane powyżej polecenia wraz z wyge-nerowanymi przez nie informacjami wyjściowymi znajdują się na towarzyszącej tej książce płycie CD-ROM w pliku Get-Command.txt z katalogu chapter01.

Eksploracja obiektów przy użyciu polecenia Get-MemberTrzecim ważnym poleceniem typu cmdlet, oferowanym przez program Windows PowerShell, jest polecenie Get-Member (Pobierz element członkowski). Gdy przedsta-wiam swoim studentom cmdlet Get-Member jako jedno z trzech poleceń „Cajun”, część z nich podchodzi do tego z nieufnością. Jeden ze studentów podniósł nawet rękę i zapytał, do czego nadaje się to polecenie. Jest to bardzo słuszne pytanie. Użyteczność polecenia Get-Member polega na tym, że może ono dostarczać informacji o tym, jakie właściwości i metody są obsługiwane przez dany obiekt. Jeśli przypomnimy sobie, że w programie Windows PowerShell wszystko jest obiektem, to będziemy mogli sami dojść, dlaczego polecenie to jest tak użyteczne. Prawdopodobnie wartość tego polecenia najlepiej będzie zilustrować na prostym przykładzie.

Jeśli posiadamy folder o nazwie mytest i użyjemy polecenia Get-Item do pobrania obiektu reprezentującego ten folder, to wskaźnik do tego obiektu będzie można zapisać w zmiennej o nazwie $a. Zostało to pokazane poniżej:

PS C:\> $a = Get-Item c:\mytest

Gdy zmienna $a zawiera już wskaźnik do egzemplarza obiektu reprezentującego folder, można zapoznać się z metodami oraz właściwościami tego obiektu kierując go poprzez potok na wejście polecenie Get-Member. Odpowiednie polecenie wraz z wygenerowanym przez nie strumieniem wyjściowym zostało pokazane poniżej:

PS C:\> $a | Get-Member

TypeName: System.IO.DirectoryInfo

Name MemberType Definition ---- ---------- ---------- Create Method System.Void Create(), System.Void Create(DirectorySecurity directorySecurity) CreateObjRef Method System.Runtime.Remoting.ObjRef CreateObjRef(Type requestedType) CreateSubdirectory Method System.IO.DirectoryInfo CreateSubdirectory(String path), System.IO.Director... Delete Method System.Void Delete(), System.Void Delete(Boolean recursive) Equals Method System.Boolean Equals(Object obj) GetAccessControl Method System.Security.AccessControl.DirectorySecurity GetAccessControl(), System GetDirectories Method System.IO.DirectoryInfo[] GetDirectories(), System.IO.DirectoryInfo[GetFiles Method System.IO.FileInfo[] GetFiles(String searchPattern), System.IO.FileInfo[] G...


GetFileSystemInfos Method System.IO.FileSystemInfo[] GetFileSystemInfos(String searchPattern), System... GetHashCode Method System.Int32 GetHashCode() GetLifetimeService Method System.Object GetLifetimeService() GetObjectData Method System.Void GetObjectData *(SerializationInfo info, StreamingContext context) GetType Method System.Type GetType() get_Attributes Method System.IO.FileAttributes get_Attributes() get_CreationTime Method System.DateTime get_CreationTime() get_CreationTimeUtc Method System.DateTime get_CreationTimeUtc() get_Exists Method System.Boolean get_Exists() get_Extension Method System.String get_Extension() get_FullName Method System.String get_FullName() get_LastAccessTime Method System.DateTime get_LastAccessTime() get_LastAccessTimeUtc Method System.DateTime get_LastAccessTimeUtc() get_LastWriteTime Method System.DateTime get_LastWriteTime() get_LastWriteTimeUtc Method System.DateTime get_LastWriteTimeUtc() get_Name Method System.String get_Name() get_Parent Method System.IO.DirectoryInfo get_Parent() get_Root Method System.IO.DirectoryInfo get_Root() InitializeLifetimeService Method System.Object InitializeLifetimeService() MoveTo Method System.Void MoveTo(String destDirName) Refresh Method System.Void Refresh() SetAccessControl Method System.Void SetAccessControl(DirectorySecurity directorySecurity) set_Attributes Method System.Void set_Attributes(FileAttributes value) set_CreationTime Method System.Void set_CreationTime(DateTime value) set_CreationTimeUtc Method System.Void set_CreationTimeUtc(DateTime value) set_LastAccessTime Method System.Void set_LastAccessTime(DateTime value) set_LastAccessTimeUtc Method System.Void set_LastAccessTimeUtc(DateTime value) set_LastWriteTime Method System.Void set_LastWriteTime(DateTime value) set_LastWriteTimeUtc Method System.Void set_LastWriteTimeUtc(DateTime value) ToString Method System.String ToString() PSChildName NoteProperty System.String PSChildName=mytest PSDrive NoteProperty System.Management.Automation.PSDriveInfo PSDrive=C PSIsContainer NoteProperty System.Boolean PSIsContainer=True PSParentPath NoteProperty System.String PSParentPath=Microsoft.PowerShell.Core\FileSystem::C:\ PSPath NoteProperty System.String PSPath=Microsoft.PowerShell.Core\FileSystem::C:\mytest PSProvider NoteProperty System.Management.Automation.ProviderInfo PSProvider=Microsoft.PowerShell.C... Attributes Property System.IO.FileAttributes Attributes {get;set;} CreationTime Property System.DateTime CreationTime {get;set;} CreationTimeUtc Property System.DateTime CreationTimeUtc {get;set;} Exists Property System.Boolean Exists {get;}


Extension Property System.String Extension {get;} FullName Property System.String FullName {get;} LastAccessTime Property System.DateTime LastAccessTime {get;set;} LastAccessTimeUtc Property System.DateTime LastAccessTimeUtc {get;set;} LastWriteTime Property System.DateTime LastWriteTime {get;set;} LastWriteTimeUtc Property System.DateTime LastWriteTimeUtc {get;set;} Name Property System.String Name {get;} Parent Property System.IO.DirectoryInfo Parent {get;} Root Property System.IO.DirectoryInfo Root {get;} Mode ScriptProperty System.Object Mode {get=$catr = "";...

Na liście elementów składowych obiektu typu folder znajduje się między innymi wła-ściwość parent (element nadrzędny). Właściwość tę można wykorzystać do odszukania folderu nadrzędnego dla folderu mytest. Odpowiedni przykład został pokazany poniżej:

PS C:\> $a.parent

Mode LastWriteTime Length Name ---- ------------- ------ ---- d--hs 5/11/2007 2:39 PM C:\

Być może interesować nas będzie, kiedy po raz ostatni korzystano z danego folderu. Możemy wówczas skorzystać z właściwości LastAccessTime, tak jak to zostało pokazane poniżej:

PS C:\> $a.LastAccessTime

Friday, May 11, 2007 2:39:12 PM

PS C:\users\edwils> $a.LastAccessTime

10 czerwca 2008 21:35:41

Jeśli natomiast zechcemy sprawdzić, czy obiekt zapisany w zmiennej w $a faktycznie jest folderem, to możemy skorzystać z właściwości PsIsContainer. Z poprzednich wyników pole-cenia Get-Member wiemy, że właściwość PsIsContainer jest właściwością logiczną (typu Boolean), a więc mogą przyjmować wartości True (prawda) lub False (fałsz). Odpowiednie polecenie zostało pokazane poniżej:

PS C:\> $a.PsIsContainer True

Możemy również skorzystać z jednej ze zwróconych na liście metod. Np. metoda moveTo (Przenieś do) pozwala na przeniesie folderu do innej lokalizacji. Z wyników zwróconych poprzednio przez polecenie Get-Member wiemy, że metoda moveTo wymaga podania argumentu wejściowego typu łańcuch tekstowy, zawierającego wskazanie katalogu docelo-wego. Przenieśmy więc folder mytest do folderu c:\movedFolder, a następnie sprawdźmy za pomocą polecenia Test-Path, czy folder mytest faktycznie został przeniesiony do nowej lokalizacji. Odpowiednie polecenia zostały pokazane poniżej:

PS C:\> $a.MoveTo("C:\movedFolder") PS C:\> Test-Path c:\movedFolder True PS C:\> Test-Path c:\mytest False PS C:\>


Korzystając z właściwości Name możemy teraz sprawdzić nazwę folderu reprezentowanego przez obiekt przechowywany w zmiennej $a. Odpowiednie polecenie wraz z wygenerowa-nym przez nie wynikiem zostało pokazane poniżej:

PS C:\> $a.name movedFolder

Jeśli zechcemy usunąć ten folder, możemy skorzystać z metody delete, tak jak to pokazano poniżej. Aby przekonać się, że folder ten został faktycznie usunięty, można skorzystać z polecenia dir m*. Polecenia te zostały pokazane poniżej. Należy zauważyć, że po ich wykonaniu folder faktycznie został usunięty.

PS C:\> $a.Delete() PS C:\> dir m*

Directory: Microsoft.PowerShell.Core\FileSystem::C:\

Mode LastWriteTime Length Name ---- ------------- ------ ---- d---- 4/21/2007 4:56 PM Maps d---- 5/5/2007 3:51 PM music -a--- 2/1/2007 6:17 PM 54 MASK.txt

Wszystkie te polecenia wraz z wygenerowanymi przez nie informacjami wyjściowymi znaj-dują się na towarzyszącej tej książce płycie CD-ROM, w pliku Get-Member.txt w katalogu chapter01.

Praca ze środowiskiem .NET Framework

Warto w tym miejscu zauważyć, że polecenia te faktycznie pochodzą ze środowiska .NET Framework. Właściwie nie są to wcale polecenia programu Windows PowerShell. Oczywiście polecenia Get-Item, Get-Member i Test-Path są poleceniami typu cmdlet programu Windows PowerShell, ale obiekt System.IO.DirectoryInfo nie jest obiektem wywodzącym się z programu Windows PowerShell. Oznacza to, że korzystając z programu Windows PowerShell używamy tych samych metod i właściwości, z których korzystają profesjonalni programiści używający języka Visual Basic .NET lub C#. Oznacza to także, że wiele dodatkowych informacji można znaleźć w biuletynach MSDN (Microsoft Developer Network) oraz w pakietach typu Windows SDK (Software Development Kit). Dobra wiadomość dla wszystkich administratorów: jeśli potrzebnych informacji nie można znaleźć przy użyciu systemu pomocy online (za pomocą polecenia Get-Help), zawsze można skorzystać z internetowej witryny MSDN lub z doku-mentacji towarzyszących pakietom typu Windows SDK.


PodsumowanieW rozdziale tym omówione zostały różne sposoby sprawdzania, czy program Windows PowerShell został zainstalowany na komputerze oraz kroki związane z konfigurowaniem tego programu do zastosowań w środowiskach korporacyjnych. Omówiono proces two-rzenia profili programu Windows PowerShell oraz różne metody uruchamiania programu Windows PowerShell i wykonywania poleceń tego programu. Omówione zostały również metody rozszerzania funkcjonalności programu Windows PowerShell poprzez tworzenie niestandardowych aliasów i funkcji. Na zakończenie omówione zostały dokładniej trzy polecenia typu cmdlet programu Windows PowerShell: Get-Help, Get-Command oraz Get-Member.

161

Rozdział 6

Zarządzanie drukarkamiPo ukończeniu tego rozdziału Czytelnik będzie potrafi ł: ■ Tworzyć spis zainstalowanych drukarek. ■ Instalować i zarządzać sterownikami drukarek. ■ Udostępniać drukarki.

Na dysku CD Wszystkie używane w tym rozdziale skrypty znajdują się na towarzyszącej tej książce płycie CD-ROM, w folderze \scripts\chapter06.

Tworzenie spisu zainstalowanych drukarekKto wie, ile drukarek jest zainstalowanych w sieci? Kto może nadążyć za udostępnianymi indywidualnie drukarkami, pojawiającymi się stale w grupach roboczych lub w biurach zewnętrznych? Z całym szacunkiem dla twórców sterowników drukarek trzeba stwier-dzić, że dla większości administratorów sieci zarządzanie drukarkami stanowi poważny problem.

Dla wielu administratorów to pozornie proste zadanie może okazać się beznadziejnie zniechęcające. Rozsądne zastosowanie programu Windows PowerShell oraz modelu instru-mentacji zarządzania systemem Windows (WMI – Windows Management Instrumentation) pozwala jednak na szybkie uzdrowienie sytuacji i zastąpienie chaosu porządkiem. Możliwość taką ilustruje skrypt ListPrinters.ps1. W skrypcie ListPrinters.ps1 zmienna $class służy do przechowywania łańcucha znakowego Win32_Printer, który będzie wyko-rzystywany w zapytaniu WMI. Zmienna $computer służy natomiast do przechowywania nazwy komputera, z którego mają zostać pobrane informacje o zainstalowanych na nim drukarkach. W zmiennej $wmi przechowywane będą obiekty zwrócone przez zapytanie wykonane za pomocą polecenia Get-WmiObject, które pobiera informacje o drukarkach zainstalowanych na komputerze wskazanym przez wartość zmiennej $computer. Drukarki wymienione na liście utworzonej przez skrypt ListPrinters.ps1 są tymi samymi drukar-kami, które wyświetlane są przez aplet Printers (Drukarki) z Panelu sterowania, co poka-zano na rysunku 6-1.

Po zwróceniu przez cmdlet Get-WmiObject kolekcji obiektów z podsystemu WMI, do sformatowania danych wyjściowych użyty został cmdlet Format-Table. W wywoła-niu polecenia Format-Table do wyboru właściwości mających znaleźć się w tworzonym raporcie użyty został argument -property. W omawianym przykładzie wybrane zostały właściwości Name (Nazwa), SystemName (Nazwa systemowa) oraz ShareName (Nazwa udziału). Argument -groupby służy do grupowania wyników wyjściowych według sterow-nika, a argument -inputobject użyty został do wskazania wejściowych obiektów dla tego polecenia. W tym przypadku użyte zostaną obiekty utworzone jako rezultat działania pole-


cenia Get-WmiObject. Obiekty te zostały zapisane w zmiennej $wmi. Pełna treść skryptu ListPrinters.ps1 została pokazana poniżej.

ListPrinters.ps1$class = "win32_printer" $computer = "localhost" $wmi = Get-WmiObject -Class $class -computername $computer format-table -Property name, systemName, shareName -groupby driverName ` -inputobject $wmi -autosize

Rysunek 6-1 Panel sterowania z systemu Windows Vista pokazujący zainstalowane na komputerze drukarki.

Poniżej przedstawiono przykładowy rezultat działania skryptu ListPrinters.ps1. Należy zwrócić uwagę na fakt, że każda lista poprzedzana jest nazwą sterownika. Jest to rezultat użycia argumentu -groupby. Użycie tego argumentu może dawać istotne korzyści w przy-padku uruchomienia skryptu na mocno obciążonym serwerze, na którym zdefiniowano wiele drukarek.

driverName: Microsoft XPS Document Writer

name systemName shareName ---- ---------- --------- Microsoft XPS Document Writer M5-1875135

driverName: IBM 4029 LaserPrinter PS39

name systemName shareName ---- ---------- --------- IBM 4029 LaserPrinter PS39 M5-1875135

Rozdział 6: Zarządzanie drukarkami 163

Odpytywanie wielu komputerówCzasami może zachodzić potrzeba jednoczesnego odpytania kilku komputerów lub serwe-rów. Najprościej można to zrobić modyfikując skrypt ListPrinters.ps1 i dodając do niego możliwość wskazywania jednego lub kilku komputerów docelowych. Wymagać to będzie zmiany sposobu traktowania zmiennej $computer. Aby umożliwić iterację poprzez tablicę z nazwami komputerów, należy użyć instrukcji foreach, a zmienną $computer użyć jako zmienną licznikową pętli. Tak więc wcale nie będzie trzeba wykonywać wielu zmian w skrypcie. Wystarczy utworzyć nową zmienną o nazwie $arycomputer i użyć jej do prze-chowywania listy nazw komputerów, które należy odpytać. Następnie należy dodać instruk-cję foreach i użyć jej do przetworzenia kolekcji nazw komputerów, wpisanych w definicji zmiennej $arycomputer. Gotowy skrypt ListPrintersFromMultipleComputers.ps1 poka-zany został poniżej.

ListPrintersFromMultipleComputers.ps1$class = "win32_printer" $arycomputer = "localhost", "loopback" foreach( $computer in $aryComputer) { Write-Host "Pobieranie informacji o drukarkach z komputera: $computer ..." $wmi = Get-WmiObject -Class $class -computername $computer format-table -Property name, systemName, shareName -groupby driverName ` -inputobject $wmi -autosize }

Każde uruchomienie skryptu ListPrintersFromMultipleComputers.ps1 powodować będzie łączenie się ze wszystkimi komputerami wymienionymi w zmiennej $arycomputer. Ponieważ może to być całkiem duża liczba komputerów, potrzebny będzie jakiś sposób jednoznacznego identyfikowania tego, które drukarki są skojarzone z którymi kompute-rami. W tym celu należy użyć polecenia Write-Host i przed pobraniem listy zdefiniowa-nych na komputerze drukarek wypisywać wartość zmiennej $comptuer. Poniżej pokazany został przykład otrzymywanych wówczas rezultatów, a na rysunku 6-2 pokazane zostały właściwości przykładowej drukarki.

Pobieranie informacji o drukarkach z komputera: localhost ...





Pobieranie informacji o drukarkach z komputera: loopback ...






Rysunek 6-2 Przykład właściwości drukarki.

Rejestrowanie do plikuChcąc zachować informacje otrzymane w wyniku wykonania zapytania WMI w jakiś bar-dziej trwały sposób, można zapisywać te informacje w pliku tekstowym. Takie postępo-wanie ma także inne zalety. Tekstowe pliki ASCII są łatwe do użycia, zajmują bardzo nie-wiele miejsca i można je wymieniać pomiędzy różnymi aplikacjami, włącznie z aplikacjami z pakietu Microsoft Office.

W skrypcie ListPrintersFromMultipleComputersWriteToFile.ps1 najpierw deklaro-wana jest zmienna $filePath, w której przechowywana będzie ścieżka do pliku tworzo-nego za pomocą polecenia Out-File. Do przechowywania nazwy klasy WMI, która będzie używana do pobierania informacji o drukarkach, służy zmienna $class. Używaną w tym skrypcie klasą WMI jest klasa Win32_Printer. Następnie należy utworzyć tablicę zawierającą nazwy komputerów, z którymi chcemy się połączyć w celu odczytania z nich informacji o drukarkach. W omawianym przykładzie użyte zostały dwie nazwy, w obydwu przy-padkach odnoszące się do komputera lokalnego: localhost i loopback. Stosowanie tych nazw stanowi wygodny sposób na przetestowanie działania skryptu z kilkoma nazwami komputerów.


Praca z plikami

Program Windows PowerShell zawiera wiele różnych poleceń typu cmdlet umożliwiają-cych współdziałanie z plikami tekstowymi, do których należą między innymi: polecenie Get-Content, które odczytuje zawartość pliku, oraz polecenie Out-File, które tworzy pliki tekstowe. Pliki tekstowe posiadają tę zaletę, że są niewielkie i łatwo można je tworzyć, mody-fikować i usuwać. Wbudowane polecenia typu cmdlet z programu Windows PowerShell jeszcze bardziej ułatwiają korzystanie z plików tekstowych. W tabeli 6-1 zebrane zostało zestawienie poleceń typu cmdlet umożliwiających manipulowanie plikami tekstowymi.

Tabela 6-1 Plecenia typu cmdlet umożliwiające manipulowanie plikami

Cmdlet Zastosowanie

Out-File Tworzy pliki. Może zmieniać szerokość pliku i korzystać z różnych sche-matów kodowania znaków: Unicode, UTF 7,8,32, BigEndianUnicode oraz ASCII. Domyślnym schematem jest kodowanie Unicode.

Get-Content Zwraca strumień zapisanych w pliku danych. Odczytuje kolejno po jed-nej linii z pliku i dla każdej linii zwraca osobny obiekt. W razie potrzeby umożliwia także określenie poświadczeń tożsamości oraz sposobu kodo-wania pliku.

Add-Content Dodaje tekst do pliku.

Set-Content Zastępuje tekst w pliku. W razie potrzeby polecenie Set-Content może być również używane do dodawania do pliku jego początkowej zawartości.

Clear-Content Usuwa dane z pliku, ale nie kasuje samego pliku.

Poszczególne elementy tablicy przetwarzane są za pomocą instrukcji foreach. Następnie należy utworzyć zmienną $computer, która będzie spełniać funkcję zmiennej licznikowej wskazującej na kolejne nazwy komputerów zapisane w tablicy $aryComputer. Dysponując już zmienną licznikową należy wypisać za pomocą polecenia Write-Host odpowiedni komunikat informujący użytkownika o tym, z którym komputerem będziemy się łączyć oraz że z komputera tego pobrane zostaną informacje o zainstalowanych na nim drukarkach.

Do połączenia się z działającą na wskazanym komputerze usługą WMI i pobrania infor-macji o zainstalowanych drukarkach należy użyć polecenia Get-WmiObject. Korzystając z polecenia Get-WmiObject należy podać nazwę używanej klasy WMI oraz nazwę kom-putera, z którym należy się połączyć. Zwrócony w wyniku wykonania tego polecenia zarzą-dzający obiekt WMI należy zapisać w zmiennej $wmi.

Otrzymany obiekt zarządzający WMI zostaje przekazany do polecenia Format-Table przy użyciu parametru -inputobject. Z obiektu tego wybrane zostają właściwości Name (Nazwa), SystemName (Nazwa systemowa) oraz ShareName (Nazwa udziału). Należy jeszcze pogrupować tworzoną listę według sterownika oraz użyć parametru -autosize, aby uzyskać tabelę sformatowaną w przyjemny dla oka sposób. Otrzymane obiekty wynikowe zostają przekazane na wejście polecenia Out-File, do którego jako wartość parametru -filepath zostaje także przekazana ścieżka zapisana w zmiennej $filePath. W poleceniu tym użyto


także parametru -encoding, ponieważ chcemy, aby plik wyjściowy był zwykłym plikiem ASCII. Całość skryptu ListPrintersFromMultipleComputersWriteToFile.ps1 została pokazana poniżej.

ListPrintersFromMultipleComputersWriteToFile.ps1$filePath = "c:\fso\printers.txt" $class = "win32_printer" $arycomputer = "localhost", "loopback" foreach( $computer in $aryComputer) { Write-Host "Pobieranie informacji o drukarkach z komputera: $computer ..." $wmi = Get-WmiObject -Class $class -computername $computer format-table -Property name, systemName, shareName -groupby driverName ` -inputobject $wmi -autosize | Out-File -FilePath $filePath -encoding ASCII }

Zapisywanie informacji w bazie danych programu Microsoft Access

Kontynuując tematykę zapisywania informacji konfiguracyjnych przy użyciu technologii bazodanownych (zapoczątkowaną w rozdziale 4, zatytułowanym „Zarządzanie usługami”), do zapisania uzyskanych informacji o drukarkach użyjemy bazy danych programu Access. Format tej bazy danych w programie Access pokazany został na rysunku 6-3.

Rysunek 6-3 Widok tabeli bazy danych programu Access w trybie projektowania.

Przy okazji korzystania z trybu projektowania tabeli bazy danych programu Access należy zwrócić uwagę również na projektanta raportów. Może się bowiem zdarzyć, że jeden z ele-mentów graficznego układu raportu dyktować będzie sposób zapisywania informacji w bazie danych. Wygląd projektanta raportów programu Access pokazany został na rysunku 6-4.


Rysunek 6-4 Projektant raportów bazy danych programu Access pomaga w rozmieszczeniu pól raportu.

Działanie skryptu WritePrinterInfoToAccess.ps1 rozpoczyna się od utworzenia zmiennej $strComputer, w której przechowywana będzie nazwa komputera. W celu pobrania nazwy komputera należy utworzyć za pomocą polecenia New-Object instancję obiektu klasy wshNetwork. Obiekt klasy wshNetwork jest obiektem typu COM, o identyfikatorze pro-gramu wscript.network. Znaki nawiasów zostały użyte w tym poleceniu po to, aby wymu-sić najpierw utworzenie obiektu COM, a potem wybrać właściwość ComputerName tego obiektu. Odczytana w ten sposób nazwa komputera zostaje następnie zapisana w zmiennej $strComputer.

Następnie przy pomocy tego samego obiektu oraz tej samej metodologi zostaje pobrana nazwa domeny. Nazwa domeny zapisana jest we właściwości UserDomain, obiektu klasy wsh-Network. Po pobraniu danych wartość właściwości UserDomain zostaje zapisana w zmien-nej $strDomain. Do przechowywania tekstu zapytania, przesyłanego do podsystemu WMI, należy utworzyć zmienną o nazwie $strWMIQuery. Użyte w tym skrypcie zapytanie WMI powoduje pobranie wszystkich właściwości skojarzonych z obiektami drukarek.

Dla określenia metodologii używanej podczas łączenia się z bazą danych należy utwo-rzyć zmienne $adOpenStatic oraz $adLockOptimistic. Do przechowywania ścieżki do bazy danych użyta zostanie zmienna $strDB. Ponieważ zamierzamy pracować z bazą danych pro-gramu Access, należy podać ścieżkę do faktycznie używanego pliku typu .mdb. Zmienna $strTable służyć będzie natomiast do przechowywania nazwy tabeli, w której będziemy zapisywać dane.

Wykonanie połączenia z bazą danych programu Access i zapisywanie w niej danych wymaga utworzenia dwóch obiektów typu COM. Pierwszym z tych obiektów jest obiekt o nazwie connection (Połączenie). Obiekt ten zapewnia możliwość otwarcia bazy danych. Podczas tworzenia instancji obiektu klasy connection należy przekazać do polecenia New-Object identyfikator programu ADODB.Connection. Obiekt zwrócony przez cmdlet New-Object przechowywany będzie w zmiennej $objConnection.


Kolejnym obiektem typu COM, który należy utworzyć, jest obiekt klasy recordset (Zbiór rekordów). Podczas tworzenia obiektu klasy recordset należy przekazać do polecenia New-Object identyfikator programu ADODB.RecordSet.

Po utworzeniu obiektów klasy connection i recordset można przystąpić to procesu „otwierania” połączenia. Pierwszym krokiem będzie otwarcie połączenia z bazą danych. Wymaga to określenia dwóch elementów: nazwy dostawcy oraz ścieżki do pliku bazy danych. Korzystając z bazy danych programu Access należy wskazać dostawcę Jet OLEDB. Odpowiednie polecenie otwierające połączenie z bazą danych zostało pokazane poniżej:

$objConnection.Open("Provider = Microsoft.Jet.OLEDB.4.0; ` Data Source= $strDB")

Po utworzeniu połączenia z bazą danych należy użyć metody open, obiektu klasy recordset. Metoda open wymaga podania czterech parametrów: -zapytanie, -połączenie, -sposób_połą-czenia oraz -blokowanie. Parametry te zostały pokazane poniżej:

$objRecordSet.Open("SELECT * FROM $strTable", ` $objConnection, $adOpenStatic, $adLockOptimistic)

Po otwarciu połączenia z bazą danych należy użyć polecenia Write-Host i wypisać komu-nikat informujący użytkownika o przystąpieniu do pobierania informacji o drukarkach. Należy przy tym użyć parametru -foregroundcolor, aby wypisać ten komunikat w kolorze żółtym.

Po wyświetleniu komunikatu informującego użytkownika o pobieraniu informacji o dru-karkach należy użyć instrukcji foreach i przeprowadzić iterację poprzez otrzymaną kolekcję obiektów drukarek. W trakcie przetwarzania kolekcji obiektów drukarek funkcję zmiennej licznikowej, wskazującej na aktualnie przetwarzany obiekt, pełnić będzie zmienna $prin-ter. Następnie należy otworzyć nowy blok kodu i użyć metody addnew(), z utworzonego wcześniej obiektu klasy recordset. Dostęp do poszczególnych pól zdefiniowanych w tabeli bazy danych programu Access i wskazanych w tekście zapytania WMI realizowany jest za pomocą metody item(). Wymaga to skojarzenia źródła danych pochodzącego z zapytania WMI, z odpowiednimi polami tabeli bazy danych. Ta część kodu jest dość długa i łatwo w niej o pomyłkę. Po przypisaniu wszystkich właściwości pobranych za pomocą zapyta-nia WMI do pól zdefiniowanych w tabeli bazy danych należy użyć metody update(), aby wymusić zapisanie tych informacji z powrotem do bazy danych programu Access. Ta część kodu została pokazana poniżej:

$objRecordSet.AddNew() $objRecordSet.Fields.item("TimeStamp") = Get-Date $objRecordSet.Fields.item("strComputer") = $strComputer $objRecordSet.Fields.item("strDomain") = $strDomain $objRecordSet.Fields.item("averagePagesPerMinute") = ` $printer.averagePagesPerMinute $objRecordSet.Fields.item("caption") = $printer.caption $objRecordSet.Fields.item("default") = $printer.default $objRecordSet.Fields.item("comment") = $printer.comment $objRecordSet.Fields.item("averagePagesPerMinute") = ` $printer.averagePagesPerMinute $objRecordSet.Fields.item("description") = $printer.description $objRecordSet.Fields.item("deviceID") = $printer.deviceID $objRecordSet.Fields.item("direct") = $printer.direct


Parametry określające kolor dla polecenia Write-Host

Istnieje 16 wartości umożliwiających określanie koloru komunikatów wypisywanych za pomocą polecenia Write-Host. Kolory te mogą być używane zarówno z parametrem -foreground (kolor liter), jak i z parametrem -background (kolor tła). Rozsądne stosowanie kolorów może znacz-nie poprawić wizualną stronę wypisywanych na konsoli wyników. Istnieją jednak przypadki wymagające zachowania pewnej ostrożności. Ponieważ program Windows PowerShell jest bar-dzo elastyczny i można go skonfigurować w bardzo różny sposób, nigdy nie możemy mieć pewności, jakie kolory zostały aktualnie skonfigurowane dla konsoli tego programu. Można by sądzić, że wypisywanie błędów w kolorze czerwonym jest sensowne, aczkolwiek zdarzyło mi się spotkać użytkowników, który używali koloru czerwonego jako koloru tła. W takiej sytuacji komunikaty błędów wypisywane w kolorze czerwonym będą niewidoczne dla użyt-kownika. Istnieją dwa sposoby na rozwiązanie tego problemu. Jednym z nich jest definiowanie dla komunikatów zarówno koloru liter, jak i koloru tła. Wprawdzie może to wyglądać bardzo nieładnie, ale sprawi, że wyświetlane komunikaty będą widoczne. Bardziej złożone podejście polega na wykrywaniu aktualnego koloru tła konsoli, a następnie dobieraniu do niego odpo-wiednio kontrastowego i przyciągającego uwagę koloru liter. Wartości stałych określających kolory, które można przekazywać do polecenia Write-Host, są następujące:

Black (Czarny) DarkBlue (Ciemny niebieski)

DarkGreen (Ciemny zielony)

DarkCyan (Ciemny niebieskozielony)

DarkRed (Ciemny czerwony)

DarkMagenta (Ciemna fuksja)

DarkYellow (Ciemny żółty)

Gray (Szary)

DarkGray (Ciemno szary)

Blue (Niebieski) Green (Zielony) Cyan (Niebieskozielony)

Red (Czerwony) Magenta (Fuksja) Yellow (Żółty) White (Biały)

Jeśli nie mamy pewności, jak będą wyglądać poszczególne kolory dla wybranego koloru tła, to można skorzystać z jednowierszowego skryptu, pokazanego na rysunku 6-5, który wypisuje tekst we wszystkich możliwych kolorach i aktualnie obowiązującym kolorem tła. Skrypt ten, DemoWriteHostColors.ps1, można znaleźć na towarzyszącej tej książce płycie CD-ROM, w folderze extras.

Rysunek 6-5 Skrypt DemoWriteHostColors.ps1 ilustruje użycie wszystkich kolorów dostępnych dla polecenia Write-Host.


$objRecordSet.Fields.item("doCompleteFirst") = $printer.doCompleteFirst $objRecordSet.Fields.item("driverName") = $printer.driverName $objRecordSet.Fields.item("enableBIDI") = $printer.enableBIDI $objRecordSet.Fields.item("enableDevQueryPrint") = $printer.enableDevQueryPrint $objRecordSet.Fields.item("extendedPrinterStatus") = ` $printer.extendedPrinterStatus $objRecordSet.Fields.item("hidden") = $printer.hidden $objRecordSet.Fields.item("horizontalresolution") = $printer.horizontalresolution $objRecordSet.Fields.item("verticalresolution") = $printer.verticalresolution $objRecordSet.Fields.item("local") = $printer.local $objRecordSet.Fields.item("keepprintedjobs") = $printer.keepprintedjobs $objRecordSet.Fields.item("network") = $printer.network $objRecordSet.Fields.item("printerstate") = $printer.printerstate $objRecordSet.Fields.item("printerstatus") = $printer.printerstatus $objRecordSet.Fields.item("printjobdatatype") = $printer.printjobdatatype $objRecordSet.Fields.item("printprocessor") = $printer.printprocessor $objRecordSet.Fields.item("priority") = $printer.priority $objRecordSet.Fields.item("published") = $printer.published $objRecordSet.Fields.item("queued") = $printer.queued $objRecordSet.Fields.item("spoolenabled") = $printer.spoolenabled $objRecordSet.Fields.item("systemname") = $printer.systemname $objRecordSet.Fields.item("workoffline") = $printer.workoffline $objRecordSet.Update()

Po zaktualizowaniu zawartości rekordu w bazie danych można przejść do następnego obiektu WMI, dodać nowy rekord do bazy danych i ponownie uaktualnić zawartość tego rekordu. Przetwarzanie w pętli informacji pobieracych z podsystemu WMI będzie kon-tynuowane aż do osiągnięcia końca kolekcji. Aby dostarczyć użytkownikowi wskaźnika obrazującego postęp w działaniu skryptu, można użyć polecenia Write-Host wypisującego w jednej linii serię znaków /\. Każda para znaków /\ oznaczać będzie jeden obiekt drukarki. Ta linia kodu została pokazana poniżej:

write-host -foregroundColor yellow "/\" -noNewLine

Po zaktualizowaniu zawartości bazy danych konieczne jest jeszcze zamknięcie obiektu klasy connection oraz obiektu klasy recordset. Te dwie ostatnie linie skryptu zostały poka-zane poniżej:

$objRecordSet.Close() $objConnection.Close()

Całość skryptu WritePrinterInfoToAccess.ps1 została pokazana poniżej.

WritePrinterInfoToAccess.ps1$StrComputer = (New-Object -ComObject WScript.Network).computername $StrDomain = (New-Object -ComObject WScript.Network).userDomain $strWMIQuery = "Select * from win32_printer" $objprinters = get-wmiobject -query $strWMIQuery

$adOpenStatic = 3 $adLockOptimistic = 3 $strDB = "c:\fso\configurationmaintenance.mdb" $strTable = "printers" $objConnection = New-Object -ComObject ADODB.Connection


$objRecordSet = new-object -ComObject ADODB.Recordset $objConnection.Open("Provider = Microsoft.Jet.OLEDB.4.0; ` Data Source= $strDB") $objRecordSet.Open("SELECT * FROM $strTable", ` $objConnection, $adOpenStatic, $adLockOptimistic)

write-host -foreGroundColor yellow "Pobieranie informacji o drukarkach ..."

foreach ($printer in $objprinters) { $objRecordSet.AddNew() $objRecordSet.Fields.item("TimeStamp") = Get-Date $objRecordSet.Fields.item("strComputer") = $strComputer $objRecordSet.Fields.item("strDomain") = $strDomain $objRecordSet.Fields.item("averagePagesPerMinute") = ` $printer.averagePagesPerMinute $objRecordSet.Fields.item("caption") = $printer.caption $objRecordSet.Fields.item("default") = $printer.default $objRecordSet.Fields.item("comment") = $printer.comment $objRecordSet.Fields.item("averagePagesPerMinute") = ` $printer.averagePagesPerMinute $objRecordSet.Fields.item("description") = $printer.description $objRecordSet.Fields.item("deviceID") = $printer.deviceID $objRecordSet.Fields.item("direct") = $printer.direct $objRecordSet.Fields.item("doCompleteFirst") = $printer.doCompleteFirst $objRecordSet.Fields.item("driverName") = $printer.driverName $objRecordSet.Fields.item("enableBIDI") = $printer.enableBIDI $objRecordSet.Fields.item("enableDevQueryPrint") = $printer.enableDevQueryPrint $objRecordSet.Fields.item("extendedPrinterStatus") = ` $printer.extendedPrinterStatus $objRecordSet.Fields.item("hidden") = $printer.hidden $objRecordSet.Fields.item("horizontalresolution") = $printer.horizontalresolution $objRecordSet.Fields.item("verticalresolution") = $printer.verticalresolution $objRecordSet.Fields.item("local") = $printer.local $objRecordSet.Fields.item("keepprintedjobs") = $printer.keepprintedjobs $objRecordSet.Fields.item("network") = $printer.network $objRecordSet.Fields.item("printerstate") = $printer.printerstate $objRecordSet.Fields.item("printerstatus") = $printer.printerstatus $objRecordSet.Fields.item("printjobdatatype") = $printer.printjobdatatype $objRecordSet.Fields.item("printprocessor") = $printer.printprocessor $objRecordSet.Fields.item("priority") = $printer.priority $objRecordSet.Fields.item("published") = $printer.published $objRecordSet.Fields.item("queued") = $printer.queued $objRecordSet.Fields.item("spoolenabled") = $printer.spoolenabled $objRecordSet.Fields.item("systemname") = $printer.systemname $objRecordSet.Fields.item("workoffline") = $printer.workoffline $objRecordSet.Update() write-host -foregroundColor yellow "/\" -noNewLine }

$objRecordSet.Close() $objConnection.Close()


Raportowanie portów drukarekPorty drukarek mają bardzo duże znaczenie, ponieważ ludzie często nie wiedzą, czym tak naprawdę są te porty. Rozumując w sposób ogólny mogłoby się wydawać, że porty druka-rek to te niejednoznacznie nazwane rzeczy, które mają jakiś związek z adresami IP. Należy jednak pamiętać, że nieprawidłowe skonfigurowanie portu drukarki może powodować znikanie zadań wydruku w odmętach cyberprzestrzeni.

Rysunek 6-6 przedstawia listę aktualnie skonfigurowanych na serwerze portów drukarek.

Rysunek 6-6 Przykład skonfigurowanych portów drukarek.

Skrypt ListPrinterPorts.ps1 definiuje dwa parametry wiersza poleceń, $strComputer oraz $help, które służą do konfigurowania sposobu działania skryptu w chwili jego urucha-miania. Jeśli do skryptu nie zostaną przekazane żadne parametry, to skrypt wypisze listę portów drukarek zdefiniowanych na komputerze lokalnym. Przy pomocy tego skryptu możliwe jest jednak łączenie się ze wskazanym komputerem zdalnym i pobieranie listy portów drukarek zdefiniowanych na tym komputerze.

Działanie skryptu ListPrinterPorts.ps1 rozpoczyna się od użycia słowa kluczowego param do zdefiniowania dwóch nazwanych parametrów. Pierwszy z tych parametrów, $strComputer, otrzymuje domyślną wartość localhost, która jest jednym z kilku aliasów oznaczających komputer lokalny. Drugim nazwanym parametrem jest parametr $help, który może być używany do generowania tekstu pomocy.

Ważne Używając słowa kluczowego param do definiowania nazwanych parametrów skryptu należy pamiętać, że słowo param musi znajdować się w pierwszej linii skryptu niebędącej komentarzem.


Po zdefiniowaniu nazwanych argumentów skryptu należy utworzyć funkcję o nazwie fun-help. Funkcja ta zostanie wywołana, jeśli skrypt zostanie uruchomiony z parametrem -help. Co ciekawe, choć we wszystkich podawanych przykładach użycia parametru -help poda-wana jest forma -help ?, to znak zapytania można zastąpić dowolną wartością. Dzieje się tak dlatego, ponieważ pokazana poniżej instrukcja if sprawdza tylko fakt istnienia zmiennej $help, a nie jej wartość:

if($help) { "Wypisywanie tekstu pomocy..." ; funHelp }

Część skryptu odpowiedzialna za wykonanie zapytania WMI składa się z zaledwie trzech linii kodu. W pierwszej linii następuje określenie klasy WMI, która zostanie użyta do wyko-nania zapytania. W omawianym skrypcie jest to klasa WMI Win32_TcpIpPrinterPort. W drugiej linii następuje pobranie za pomocą polecenia Get-WmiObject informacji pod-systemu WMI o portach drukarek, zdefiniowanych na komputerze wskazanym w zmiennej $strComputer. Otrzymany w wyniku wykonania tego polecenia zarządzający obiekt WMI zostaje następnie oczyszczony za pomocą polecenia Format-List z wszelkich niedrukowal-nych znaków. Ten fragment kodu został pokazany poniżej:

$class = "Win32_TcpIpPrinterPort" Get-WmiObject -Class $class -computername $strcomputer | format-list [a-z]*

Poniżej zamieszczono kompletną treść skryptu ListPrinterPorts.ps1.

ListPrinterPorts.ps1param($strComputer="localhost", $help)

function funHelp() { $helpText=@" NAZWA: ListPrinterPorts.ps1 Tworzy listę portów drukarek na komputerze lokalnym lub zdalnym.

PARAMETRY: -computerName Określa nazwę komputera, którego dotyczyć ma działanie skryptu -help Wypisuje tekst pomocy

SKŁADNIA: ListPrinterPorts.ps1 -comptuerName MunichServer Wyświetla listę wszystkich portów drukarek istniejących na komputerze o nazwie MunichServer

FindPrinterPorts.ps1 -help ? Wypisuje tekst pomocy zapisany w zmiennej $helpText

"@ $helpText exit }

if($help) { "Wypisywanie tekstu pomocy..." ; funHelp } $class = "Win32_TcpIpPrinterPort" Get-WmiObject -Class $class -computername $strcomputer | format-list [a-z]*


Tworzenie funkcji pomocy dla skryptu

Jednym ze sposobów uczynienia tworzonych przez siebie skryptów bardziej przyjaznymi dla użytkowników jest dodanie do nich funkcji pomocy. Przykład takiej funkcji został pokazany w skrypcie ListPrinterPorts.ps1. Istnieją jednak przynajmniej trzy sposoby wyświetlania tek-stu pomocy. W skrypcie ListPrinterPorts.ps1 zdefiniowany został parametr o nazwie $help. Komunikat zdefiniowany w funkcji pomocy zostanie wyświetlony, jeśli skrypt zostanie uru-chomiony z parametrem -help ?. Funkcja pomocy powinna dostarczać przynajmniej trzech informacji: opisu skryptu, opisu parametrów oraz opisu prawidłowej składni wraz z kilkoma przykładami. Dlatego warto utworzyć sobie odpowiedni szablon. Szablon taki ułatwi standa-ryzację składni oraz uprości tworzenie funkcji pomocy.

Drugim sposobem wyświetlania tekstu pomocy jest wykorzystanie nienazwanego argu-mentu oraz instrukcji switch, do zbadania tablicy $args. Przykład wyświetlania tekstu pomocy w ten sposób pokazany został w skrypcie ArgsShare.ps1 z rozdziału 2, zatytułowanego „Skrypty programu Windows PowerShell”. Przykład działania skryptu ArgsShare.ps1 poka-zany został na rysunku 6-7.

Rysunek 6-7 Wyświetlanie tekstu pomocy dla brakujących argumentów ułatwia korzystanie ze skryptu.

Trzecim sposobem wyświetlania tekstu pomocy jest wywoływanie funkcji pomocy z braku-jącym parametrem skryptu. Przypuśćmy np., że nasz skrypt wymaga podania dwóch para-metrów: nazwy udziału oraz ścieżki udziału. Nie można utworzyć udziału sieciowego nie określając jednocześnie nazwy udziału oraz udostępnianego folderu. W przypadku braku jednego lub drugiego parametru można wyświetlić tekst pomocy, który będzie odpowiednio dostosowany do tej sytuacji. Przykład wyświetlania pomocy w ten sposób pokazany został w skrypcie CreateShare.ps1 z rozdziału 5, zatytułowanego „Zarządzanie udziałami”.

Decydując się na dodanie do własnych skryptów funkcji pomocy, zachowanie spójnej konwencji nazywania parametrów niesamowicie poprawi zarówno czytelność, jak i użytecz-ność tych skryptów. Oczywiście jeśli dany skrypt będzie wykorzystywany tylko w jednym, określonym celu, to prawdopodobnie nie warto tworzyć dla niego funkcji pomocy. Tworząc jednak skrypty narzędziowe, które będą wykorzystywane przez różne osoby z działu pomocy technicznej lub przez innych administratorów, to utworzenie funkcji pomocy, a także doda-nie do skryptu odpowiednich komentarzy, będzie jak najbardziej uzasadnione. Osobiście uważam, że jeśli jakiś skrypt używa więcej niż jednego parametru, to dobrym zwyczajem jest zastosowanie w nim kombinacji pierwszej oraz trzeciej z opisywanych przed chwilą technik wyświetlania tekstu pomocy.


Z portami drukarek związane są także inne problemy. Ponieważ serwery wydruku często są komputerami posiadającymi kilka kart sieciowych, na których zdefiniowano drukarki przeznaczone dla różnych sieci, możemy chcieć mieć możliwość pobierania informacji tylko o tych drukarkach, które zostały skonfigurowane dla konkretnej sieci. Możliwość taka może być przydatna zarówno podczas zarządzania siecią, jak i podczas rozwiązywania problemów.

Skrypt FindPrinterPorts.ps1 jest zmodyfikowaną wersją skryptu ListPrinterPorts.ps1, umożliwiającą stosowanie dodatkowego parametru w wierszu poleceń: -network. Parametr -network określa identyfikator sieci, który będzie używany do identyfikowania portów dru-karki. Domyślną wartością tego parametru jest wartość 192.168, oznaczająca powszechnie stosowany adres sieci wewnętrznej. Wartość tę można odpowiednio modyfikować poprzez edycję samego skryptu albo z poziomu wiersza poleceń uruchamiając skrypt z argumentem -network.

Działanie parametru -help jest dokładnie takie samo, jak w skrypcie ListPrinterPorts.ps1 (omówienie tej części skryptu znajduje się we wcześniejszej części tego rozdziału).

Aby wyświetlać tylko te porty drukarek, które znajdują się w sieci o adresie określonym za pomocą parametru -network, należy użyć polecenia Where-Object i sprawdzać adres sieci przy użyciu wyrażeń regularnych. Odpowiednie filtrowanie można osiągnąć używając w poleceniu Where-Object parametru -match.

Po wyszukaniu wszystkich drukarek lokalnych należy wypisać odpowiedni komuni-kat za pomocą polecenia Write-Host. Następnie korzystając z polecenia Get-WmiObject należy pobrać ze wskazanego komputera instancję klasy Win32_TcpIpPrinterPort i przeka-zać otrzymany rezultat na wejście polecenia Where-Object. W bloku kodu skojarzonym z poleceniem Where-Object używana jest zmienna automatyczna $_, reprezentująca aktu-alnie przetwarzany w potoku obiekt, i przeprowadzana jest operacja porównywania łań-cuchów tekstowych, z użyciem wyrażeń regularnych oraz wartości określonej za pomocą parametru -network. Ta część kodu została pokazana poniżej:

Write-Host -foregroundColor Yellow "Poniżej znajduje się lista portów drukarek z zakresu sieci $network :`n" Get-WmiObject -class $class -computername $strcomputer | Where-object { $_.name -match $network }

Uwaga Czasami do uzyskania informacji o drukarkach preferowane może być zastosowa-nie protokołu SNMP (Simple Network Management Protocol – Prosty protokół zarządzania siecią). Protokół SNMP jest użytecznym standardem przemysłowym, którego działanie opiera się na przesyłaniu komunikatów do centralnych systemów, skonfigurowanych jako odbiorcy tych komunikatów. Hasła używane w tego typu systemach noszą nazwę łańcuchów znakowych społeczności (ang. community string). W niektórych sieciach stosowanie protokołu SNMP może naruszać przyjęte standardy w zakresie bezpieczeństwa, ponieważ komunikaty tego protokołu są transmitowane w formie jawnej.

Jeśli używane drukarki zostały skonfigurowane w taki sposób, że przesyłają do aplika-cji zarządzającej informacje o swoim stanie (takie jak „brak papieru” lub „niski poziom tonera”) za pomocą protokołu SNMP, to znaczy, że obsługa protokołu SNMP została na nich włączona. Jeśli dana drukarka obsługuje protokół SNMP, to nie uzasadnia to jeszcze umieszczania wśród danych wyjściowych skryptu tego typu informacji o stanie drukarki.


Dla poprawienia czytelności generowanych przez skrypt wyników generalnie sprawdzana będzie tylko wartość właściwości SNMPEnabled (Obsługuje protokół SNMP) i na jej podsta-wie wypisywane będą tylko te informacje, które mają zastosowanie dla danego urządzenia. Ta część kodu została pokazana poniżej:

if($($_.SNMPEnabled)) { Write-Host -foregroundColor yellow "`tObsługa protokołu SNMP jest włączona dla następujących drukarek" Write-Host "`t$($_.name), $($_.portNumber), $($_.SNMPCommunity, $($_.SNMPDevIndex)`n" } ELSE { Write-Host -foregroundColor yellow "`tObsługa protokołu SNMP NIE jest włączona dla następujących drukarek`n" write-host "`t$($_.name), $($_.portNumber)" } }

Wskazówka Po przeniesieniu warunku sprawdzającego wartość właściwości SNMPEnabled do pętli if … else, wartość tej właściwości przestała być poprawnie rozwijana. Gdy wypisywana była w sposób bezpośredni, wypisywana była prawidłowa wartość. Aby wymusić sprawdzenie tej właściwości przed jej wypisaniem na wyjściu, konieczne było użycie dodatkowego symbolu $, tak jak w następującym wyrażeniu: $($_.SNMPEnabled). Warto pamiętać o tej technice, ponieważ z pewnością istnieją również inne sytuacje, w których wartości nie będą rozwijane zgodnie z naszymi oczekiwaniami.

Kod skryptu kończy się zamknięciem wszystkich nawiasów klamrowych i wypisaniem odpowiednich informacji o portach drukarki. Całość skryptu FindPrinterPorts.ps1 została przedstawiona poniżej.

FindPrinterPorts.ps1param( $strcomputer="localhost", $network="192.168", $help) function funHelp() { $helpText=@" OPIS: NAZWA: FindPrinterPorts.ps1 Umożliwia zarządzanie portami drukarek na komputerze lokalnym lub zdalnym.

PARAMETRY: -computerName Określa nazwę komputera, którego dotyczyć ma działanie skryptu -help Wypisuje tekst pomocy -network Adres IP albo jeden, dwa lub trzy oktety

SKŁADNIA: FindPrinterPorts.ps1 -comptuerName MunichServer Wyświetla listę wszystkich portów drukarek istniejących na komputerze o nazwie MunichServer

FindPrinterPorts.ps1 -help ?


Wyświetla tekst pomocy dla skryptu

FindPrinterPorts.ps1 -computername MunichServer -network "10" Ustawia na zdalnym serwerze MunichServer adres 10 sieci klasy A. Zwrócone zostaną informacje tylko o portach drukarek przypisanych do zakresu adresów 10.x.x.x

FindPrinterPorts.ps1 Zwraca informacje o portach drukarek z zakresu 192.168.x.x na komputerze lokalnym

"@ $helpText exit }

if($help) { "Wypisywanie tekstu pomocy..." ; funHelp } $class = "Win32_TcpIpPrinterPort"

Write-Host -foregroundColor Yellow "Poniżej znajduje się lista portów drukarek z zakresu sieci $network:`n" Get-WmiObject -class $class -computername $strcomputer | Where-object { $_.name -match $network } | foreach($_){ if($($_.SNMPEnabled)) { Write-Host -foregroundColor yellow "`tObsługa protokołu SNMP jest włączona dla następujących drukarek" Write-Host "`t$($_.name), $($_.portNumber), $($_.SNMPCommunity, $($_.SNMPDevIndex)`n" } ELSE { Write-Host -foregroundColor yellow "`tObsługa protokołu SNMP NIE jest włączona dla następujących drukarek`n" write-host "`t$($_.name), $($_.portNumber)" } }

Identyfikowanie sterowników drukarekJedną z podstawowych części procesu zarządzania siecią jest praca ze sterownikami druka-rek. Sprawdzanie plików ze sterownikami drukarek stanowi podstawę dobrego zarządza-nia. W systemie Windows Vista zainstalowanych jest już wiele domyślnych sterowników drukarek. Dodanie nowej drukarki korzystającej z jednego z tych domyślnych sterowników nie jest niczym trudnym. Jeśli jednak odpowiedniego sterownika nie ma jeszcze w syste-mie, to cały proces staje się nieco bardziej skomplikowany.

Skrypt FindPrinterDrivers.ps1 pobiera za pomocą polecenia Get-ChildItem listę zain-stalowanych w systemie plików typu .inf, zawierających w nazwie litery prn. Do pobra-nia wartości zmiennej systemowej %systemroot% użyty został wirtualny dysk programu PowerShell, env:\. Użycie parametru -exclude spowoduje, że polecenie to nie będzie zwracać plików z rozszerzeniem .pnf.


Na rysunku 6-8 przedstawiony został widok katalogu inf, znajdującego się na kompute-rze pracującym z systemem Windows Vista. Należy zwrócić uwagę na liczbę plików znajdu-jących się w tym folderze. To właśnie dlatego w skrypcie użyty został parametr -exclude.

Rysunek 6-8 Na komputerach pracujących z systemem Windows Vista lub Windows Server 2008 informacje o sterownikach znajdują się w katalogu inf.

Dysponując już kolekcją złożoną z obiektów plików informacyjnych należy przekazać rezultaty na wejście polecenia Where-Object. Do wyszukiwania w nazwie pliku liter prn użyte zostało wyrażenie regularne. Otrzymana w ten sposób lista plików zostanie posorto-wana za pomocą polecenia Sort-Object i przekazana na wejście polecenia Format-Table, które wybierze z otrzymanych obiektów właściwości Name (Nazwa), Length (Długość), CreationTime (Czas utworzenia) oraz LastWriteTime (Czas ostatniego zapisu). Całość skryptu FindPrinterDrivers.ps1 została pokazana poniżej.

FindPrinterDrivers.ps1Get-ChildItem ((Get-Item Env:\systemroot).value+"\inf") -Exclude *.pnf | Where-Object { $_.name -match "prn" } | Sort-Object -Property name | format-table -Property name, length, creationTime, lastWriteTime

Wprawdzie skrypt FindPrinterDrivers.ps1 dostarcza listę plików typu .inf zawierających opis sterowników drukarek, ale nie pokazuje, które sterowniki drukarek są faktycznie dostępne. Skrypt ReportAvailableDrivers.ps1 przetwarza wszystkie pliki drukarek typu .inf, wyszukując w nich ciągu oznaczającego określony model drukarki. Pozwala to poli-czyć liczbę zainstalowanych w systemie sterowników dla każdego typu drukarki.

Pierwszą czynnością wykonywaną przez skrypt ReportAvailableDrivers.ps1 jest inicja-lizacja siedmiu zmiennych i przypisanie im domyślnej wartości równej 0. Zmienne te będą używane do zliczania liczby sterowników drukarek, a ich wartości zostaną wykorzystane w sekcji wyjściowej skryptu do wypisania informacji dla użytkownika. Za pomocą polece-nia Get-ChildItem zostaje utworzona ścieżka do katalogu inf, znajdującego się w głównym katalogu systemowym. Każdy plik typu .inf, którego nazwa zawierać będzie litery prn,


zostanie otwarty za pomocą instrukcji switch i przy użyciu wyrażeń regularnych zostanie sprawdzona obecność w tym pliku nazw interesujących nas modeli drukarek. Każde zna-lezienie w pliku nazwy modelu drukarki powoduje zwiększenie wartości odpowiedniej zmiennej. Następnie w pętli zostaje otwarty następny plik typu .inf i cały proces zostaje powtórzony od początku.

Po przetworzeniu wszystkich dotyczących drukarek plików typu .inf nastę-puje wypisanie rezultatów za pomocą polecenia Write-Host. Pełna treść skryptu ReportAvailableDrivers.ps1 została pokazana poniżej.

ReportAvailableDrivers.ps1$hp=$ibm=$lexmark=$star=$text=$ps=$generic=0 Get-ChildItem ((Get-Item Env:\systemroot).value+"\inf") -Exclude *.pnf | Where-Object { $_.name -match "prn" } | foreach-object($_){ switch -regex -file $_.fullname { 'hp' { $hp++ } 'ibm' { $ibm++ } 'lexmark' { $lexmark++ } 'star' { $star++ } 'text' { $text++ } 'ps' { $ps++ } 'generic' { $generic++ } } } " Aktualnie w systemie dostępne są następujące sterowniki drukarek: Sterowniki dla drukarek HP: $hp Sterowniki dla drukarek IBM: $ibm Sterowniki dla drukarek Lexmark: $lexmark Sterowniki dla drukarek Star: $Star Sterowniki dla drukarek tekstowych: $text Sterowniki dla drukarek PS: $ps Ogólne (generyczne) sterowniki drukarek: $generic "

Instalowanie sterowników drukarekKolejnym zadaniem po zainstalowaniu systemu Windows Vista lub Windows Server 2008 jest skonfigurowanie drukarek. W terminologii systemu Windows fizyczna drukarka nazy-wana jest urządzeniem drukującym, a drukarką nazywana jest skonfigurowana na kompu-terze kolejka wydruku. Za przekształcanie serii bitów w fizyczny kawałek papieru, będący dokładną reprezentacją informacji wyświetlanych na ekranie komputera, odpowiada ste-rownik drukarki. Takie przekształcenie określane bywa skrótem WYSIWYG (od słów „What You See Is What You Get”, oznaczających „To co widzisz jest tym co otrzymasz”, a sam skrót należy wymawiać jako „weeseewig” (łiisiiłing :-) )). Poza zapobieganiem występowa-niu feralnych „niebieskich ekranów”, poprawne funkcjonowanie sterownika drukarki ma zasadnicze znaczenie dla poprawnego formatowania informacji, wyświetlanych na ekranie przez aplikacje pakietu Microsoft Office. W rzeczywiści brak zainstalowanego w systemie


poprawnego sterownika drukarki może doprowadzić nawet do zawieszania się progra-mów Microsoft Word i Microsoft Excel lub do nieprawidłowego dzielenia dokumentów na strony.

Instalowanie znalezionych na komputerze sterowników drukarki

Zarówno system Windows Vista, jak i Windows Server 2008 dostarczany jest razem z licz-nymi sterownikami, pozwalającymi na współpracę systemu z szeroką gamą różnych urzą-dzeń i drukarki nie są pod tym względem wyjątkiem. Te sterowniki drukarek znajdują się w katalogu %systemroot%\inf. Wszystkie pliki sterowników drukarek mają rozszerzenie .inf i zawierają w nazwie litery prn. Uzbrojeni w tę informację możemy utworzyć listę plików typu .inf dla dołączonych do systemu sterowników drukarek. Zadanie to wykony-wane jest przez skrypt FindPrinterDrivers.ps1. Dysponując tą informacją zainstalowanie odpowiedniego sterownika w systemie Windows Vista lub Windows Server 2008 nie jest już niczym trudnym.

Zaletą procesu instalowania na komputerze sterowników drukarek jest ułatwienie zwy-kłym użytkownikom dodawania drukarek do własnych profili, bez konieczności posiada-nia przywileju seLoadDriverPrivilege. Jak pokazano na rysunku 6-9, wybór istniejącego sterownika jest bardzo łatwy.

Rysunek 6-9 Systemy Windows Vista i Windows Server 2008 wykrywają fakt zainstalowania już w systemie wymaganego sterownika i proponują użytkownikowi jego użycie.

Skrypt InstallPrinterDriver.ps1 umożliwia instalowanie w profilu użytkownika sterowni-ków drukarek, które znajdują się już na komputerze z systemem Windows. Sterowniki takie znajdują się już na dysku, ale nie zostały jeszcze rozpakowane ani załadowane. Pierwszą rzeczą, jaką należy wykonać, jest połączenie się z klasą WMI Win32_PrinterDriver. W tym


celu należy posłużyć się akceleratorem typu [wmiclass]. Ta linia kodu została pokazana poniżej:

$objWMI = [wmiclass]”Win32_PrinterDriver”

Po zapisaniu w zmiennej $objWMI instancji obiektu klasy System.Management.Manage-mentClass, należy przy pomocy metody CreateInstance() utworzyć w pamięci nową instan-cję klasy Win32_PrinterDriver. Klasa ta będzie używana do przekazywania informacji do zapisanego w zmiennej $objWMI obiektu klasy zarządzającej poprzez wywołanie metody AddPrinterDriver().

Uwaga Czasami podsystem WMI działa w bardzo szczególny sposób. Używanie metody AddPrinterDriver() z podsystemu WMI wymaga utworzenia najpierw nowej instancji klasy WMI Win32_PrinterDriver. Wynika to z faktu, że metoda AddPrinterDriver() wymaga przeka-zania jej sterownika drukarki jako instancji klasy Win32_PrinterDriver. Dlatego przed użyciem metody AddPrinterDriver() klasy Win32_PrinterDriver konieczne jest utworzenie nowej klasy Win32_PrinterDriver.

Dysponując obiektem klasy zarządzającej, zapisanym w zmiennej $objWMI, można użyć metody CreateInstance() i utworzyć pustą kopię klasy Win32_PrinterDriver. Odpowiednia linia kodu tworzącego nową instancję klasy Win32_PrinterDriver została pokazana poniżej:

$objDriver=$objWMI.CreateInstance()

Pusta kopia klasy umożliwia określenie wartości wszystkich właściwości klasy WMI, jeśli zajdzie taka potrzeba. Do działania skryptu InstallPrinterDriver.ps1 potrzebna jest jedy-nie nazwa sterownika drukarki, ponieważ wszystkie pozostałe potrzebne pliki wskazywane będą przez lokalnie zainstalowane pliki typu .inf. Jak pokazano poniżej, przypisanie nazwy sterownika do właściwości Name odbywa się poprzez zwykłe przypisanie wartości:

$objDriver.name = "Generic / Text Only"

Po podaniu wszystkich wartości potrzebnych do utworzenia sterownika drukarki należy użyć metody AddPrinterDriver(). Metoda ta posiada jeden argument, którym jest obiekt zawierający instancję klasy Win32_PrinterDriver. W skrypcie InstallPrinterDriver.ps1 obiekt ten znajduje się w zmiennej $objDriver. Ta linia kodu została pokazana poniżej:

$rtnCode = $objwmi.addPrinterDriver($objDriver)

Aby sprawdzić, czy wywołanie metody AddPrinterDriver() zakończyło się sukcesem, należy wypisać kod powrotu z tej metody. Skrypt InstallPrinterDriver.ps1 zapisuje obiekt klasy error w zmiennej o nazwie $rtnCode. Obiekt klasy error posiada właściwość o nazwie ReturnValue. Wartość 0 tej właściwości oznacza pomyślne wykonanie polecenia. Linia wypi-sująca wartość właściwości ReturnValue obiektu klasy error została pokazana poniżej:

$rtncode.returnValue

Poniżej przedstawiona została całość skryptu InstallPrinterDriver.ps1.


InstallPrinterDriver.ps1$objWMI = [wmiclass]"Win32_PrinterDriver" $objDriver=$objWMI.CreateInstance()

$objDriver.name = "Generic / Text Only" $rtnCode = $objwmi.addPrinterDriver($objDriver) $rtncode.returnValue

Instalowanie sterowników drukarek, których nie znaleziono na komputerze

Jeśli potrzeby sterownik drukarki nie znajduje się jeszcze na dysku komputera, to insta-lowanie takiego sterownika jest nieco trudniejsze. Jak widać w tabeli 6-2, klasa Win32_PrinterDriver posiada zdefiniowanych wiele różnych właściwości. Wprawdzie nie wszyst-kie właściwości muszą być zdefiniowane dla wszystkich sterowników drukarek, ale i tak wymaga to nieco pracy.

Tabela 6-2 Właściwości klasy Win32_PrinterDriver

Właściwość Definicja

Caption System.String Caption {get;set;}

ConfigFile System.String ConfigFile {get;set;}

CreationClassName System.String CreationClassName {get;set;}

DataFile System.String DataFile {get;set;}

DefaultDataType System.String DefaultDataType {get;set;}

DependentFiles System.String[] DependentFiles {get;set;}

Description System.String Description {get;set;}

DriverPath System.String DriverPath {get;set;}

FilePath System.String FilePath {get;set;}

HelpFile System.String HelpFile {get;set;}

InfName System.String InfName {get;set;}

InstallDate System.String InstallDate {get;set;}

MonitorName System.String MonitorName {get;set;}

Name System.String Name {get;set;}

OEMUrl System.String OEMUrl {get;set;}

Started System.Boolean Started {get;set;}

StartMode System.String StartMode {get;set;}

Status System.String Status {get;set;}

SupportedPlatform System.String SupportedPlatform {get;set;}

SystemCreationClassName System.String SystemCreationClassName {get;set;}

SystemName System.String SystemName {get;set;}

Version System.UInt16 Version {get;set;}


Jeśli zechcemy przekonać się, jak wyglądają właściwości takiego sterownika, to możemy skorzystać z apletu Printers (Drukarki), z panelu sterowania systemu Windows Vista lub Windows Server 2008. Właściwości przykładowego sterownika drukarki zostały pokazane na rysunku 6-10.

Rysunek 6-10 Właściwości sterownika drukarki.

W skrypcie InstallPrinterDriverFull.ps1 najpierw użyty został akcelerator [wmiclass] dla klasy WMI Win32_PrinterDriver, za pomocą którego stworzony został obiekt zarządzający, umożliwiający korzystanie z metod klasy Win32_PrinterDriver. Otrzymany w ten sposób obiekt zostaje zapisany w zmiennej $objWMI.

Obiekt zarządzający System.Management.ManagementObject dla klasy Win32_PrinterDriver zawiera metodę CreateInstance(). Po utworzeniu nowej instancji klasy Win32_PrinterDriver obiekt wynikowy zostaje zapisany w zmiennej $objDriver. Ta nowa kopia klasy Win32_PrinterDriver zostanie użyta w metodzie AddPrinterDriver() oryginalnego obiektu zarządza-jącego, przechowywanego w zmiennej $objWMI.

Nowa instancja klasy sterownika drukarki zostaje zapisana w zmiennej $objDriver. Ten nowy egzemplarz klasy wymaga określenia wszystkich wartości dla wymaganych właści-wości. Należy poinformować tę nową instancję, gdzie można znaleźć wszystkie potrzebne pliki. W skrypcie InstallPrinterDriverFull.ps1 użyte zostały tylko podstawowe właściwo-ści tej klasy. Pełna treść skryptu InstallPrinterDriverFull.ps1 została pokazana poniżej.

InstallPrinterDriverFull.ps1$objWMI = [wmiclass]"Win32_PrinterDriver" $objDriver=$objWMI.CreateInstance()

$objDriver.name = "Generic / Text Only" $objDriver.DriverPath = "C:\WINDOWS\System32\spool\DRIVERS\W32X86\3\UNIDRV.DLL" $objDriver.ConfigFile = "C:\WINDOWS\System32\spool\DRIVERS\W32X86\3\UNIDRVUI.DLL" $objDriver.DataFile = "C:\WINDOWS\System32\spool\DRIVERS\W32X86\3\TTY.GPD" $objDriver.DependentFiles ="C:\WINDOWS\System32\spool\DRIVERS\W32X86\3\TTYRES.DLL", ` "C:\WINDOWS\System32\spool\DRIVERS\W32X86\3\TTY.INI", ` "C:\WINDOWS\System32\spool\DRIVERS\W32X86\3\TTY.DLL", ` "C:\WINDOWS\System32\spool\DRIVERS\W32X86\3\TTYUI.DLL", ` "C:\WINDOWS\System32\spool\DRIVERS\W32X86\3\UNIRES.DLL", ` "C:\WINDOWS\System32\spool\DRIVERS\W32X86\3\TTYUI.HLP", `


"C:\WINDOWS\System32\spool\DRIVERS\W32X86\3\STDNAMES.GPD" $objDriver.HelpFile = "C:\WINDOWS\System32\spool\DRIVERS\W32X86\3\UNIDRV.HLP"

$rtnCode = $objwmi.addPrinterDriver($objDriver) $rtncode.returnValue

PodsumowanieW tym rozdziale zapoznaliśmy się z problemami związanymi z drukowaniem. Podczas korzystania z drukarek każde zadanie rozpoczyna się od sterownika drukarki. Istotnie nie da się niczego wydrukować na urządzeniu drukującym bez odpowiedniego sterownika dru-karki. Sterowniki drukarek mogą pochodzić z dwóch źródeł. Albo zostały one dołączone do systemu Windows Vista lub Windows Server 2008, albo dostarczane są bezpośrednio przez producenta danego urządzenia, który albo umożliwia pobranie ich z sieci Internet, albo dołącza do sprzedawanych drukarek. W każdym z tych przypadków sterownik taki musi zostać załadowany do systemu Windows. Po zapoznaniu się z problemami związanymi z wdrażaniem sterowników drukarek omówiona została tematyka udostępniania urządzeń drukujących. Omówione zostało także raportowanie istniejących ustawień, a także konfi-guracja różnych aspektów udostępniania urządzeń drukujących.

641

Dodatek A

Konwencja nazw dla narzędzi typu cmdletNazwy wszystkich poleceń typu cmdlet, instalowanych razem z programem Windows PowerShell, tworzone są według jednej, standardowej konwencji nazewniczej. Dostępne są np. cztery polecenia o nazwach zaczynających się od czasownika Add (Dodaj). Można w tym miejscu zapytać: „Dodaj, ale co?”. Odpowiedzi na to pytanie udziela rzeczownik będący drugim członem nazwy, np. Add-Content (Dodaj zawartość), Add-History (Dodaj historię), Add-Member (Dodaj element członkowski) oraz Add-PSSnapin (Dodaj przy-stawkę PowerShell). Tworząc własne polecenia typu cmdlet należy starać się przestrzegać tej samej konwencji nazewniczej. Znajomość tej konwencji pomaga w poznawaniu poleceń cmdlet, oferowanych razem z programem Windows PowerShell.

W tabeli A-1 znajduje się zestawienie liczby poleceń z danej grupy (kolumna Liczba), czasownika będącego pierwszym członem nazwy poleceń z danej grupy (kolumna Czasownik) oraz krótkiego opisu zastosowań (kolumna Przykładowe zastosowanie), dla wszystkich poleceń typu cmdlet stanowiących obecnie część programu Windows PowerShell. Kompletną listę wszystkich poleceń typu cmdlet można uzyskać wydając w oknie konsoli programu Windows PowerShell polecenie get-command.

Tabela A-1 Konwencja nazw poleceń typu cmdlet

Liczba Czasownik Przykładowe zastosowanie

4 Add (Dodaj) Add-Content (Dodaj-Zawartość), Add-History (Dodaj-Historię), Add-Member (Dodaj-Element członkowski)

4 Clear (Wyczyść) Clear-Content (Wyczyść-Zawartość), Clear-Item (Wyczyść-Element)

1 Compare (Porównaj)

Compare-Object (Porównaj-Obiekt)

1 ConvertFrom (Przekształć z)

ConvertFrom-SecureString (Przekształć z-Ciąg bezpieczny)

1 Convert (Przekształć)

Convert-Path (Przekształć-Ścieżkę)

2 ConvertTo (Przekształć na)

ConvertTo-Html (Przekształć na-Html), ConvertTo-SecureString (Przekształć na-Ciąg bezpieczny)

2 Copy (Kopiuj) Copy-Item (Kopiuj-Element), Copy-ItemProperty (Kopiuj-Właściwość elementu)

4 Export (Eksportuj) Export-Alias (Eksportuj-Alias), Export-Clixml (Eksportuj-Clixml), Export-Console (Eksportuj-Konsolę)

1 ForEach (Dla każdego)

ForEach-Object (Dla każdego-Obiektu)




4 Format (Format) Format-Custom (Format-Niestandardowy), Format-List (Format-Lista), Format-Table (Format-Tabela)

29 Get (Pobierz) Get-Acl (Pobierz-Listę ACL), Get-Alias (Pobierz-Alias)

1 Group (Grupuj) Group-Object (Grupuj-Obiekt)

3 Import (Importuj) Import-Clixml (Importuj-Clixml), Import-Csv (Importuj-CSV)

3 Invoke (Wywołaj) Invoke-Expression (Wywołaj-Wyrażenie), Invoke-History (Wywołaj-Historię)

1 Join (Połącz) Join-Path (Połącz-Ścieżkę)

2 Measure (Zmierz) Measure-Command (Zmierz-Polecenie), Measure-Object (Zmierz-Obiekt)

2 Move (Przenieś) Move-Item (Przenieś-Element), Move-ItemProperty (Przenieś-Właściwość elementu)

8 New (Utwórz nowy)

New-Alias (Utwórz nowy-Alias), New-Item (Utwórz nowy -Obiekt), New-ItemProperty (Utwórz nowy-Właściwość)

6 Out (Wyprowadź) Out-Default (Wyprowadź-Domyślne), Out-File (Wyprowadź-Plik), Out-Host (Wyprowadź-Hosta)

1 Pop (Połóż na stos) Pop-Location (Połóż na stos-Lokalizację)

1 Push (Zdejmij ze stosu)

Push-Location (Zdejmij ze stosu-Lokalizację)

1 Read (Odczytaj) Read-Host (Odczytaj-Hosta)

5 Remove (Usuń) Remove-Item (Usuń-Element), Remove-ItemProperty (Usuń-Właściwość elementu)

2 Rename (Zmień nazwę)

Rename-Item (Zmień nazwę-Elementu), Rename-ItemProperty (Zmień nazwę-Właściwości elementu)

1 Resolve (Rozwiąż) Resolve-Path (Rozwiąż-Ścieżkę)

1 Restart (Uruchom ponownie)

Restart-Service (Uruchom ponownie-Usługę)

1 Resume (Wznów) Resume-Service (Wznów-Usługę)

2 Select (Wybierz) Select-Object (Wybierz-Obiekt), Select-String (Wybierz-Łańcuch znakowy)

13 Set (Ustaw) Set-Acl (Ustaw-Listę ACL), Set-Alias (Ustaw-Alias)

1 Sort (Posortuj) Sort-Object (Posortuj-Obiekt)

1 Split (Podziel) Split-Path (Podziel-Ścieżkę)

3 Start (Uruchom) Start-Service (Uruchom-Usługę), Start-Sleep (Uruchom-Uśpienie), Start-Transcript (Uruchom-Transkrypcję)

Dodatek A: Konwencja nazw dla narzędzi typu cmdlet 643



3 Stop (Zatrzymaj) Stop-Process (Zatrzymaj-Proces), Stop-Service (Zatrzymaj-Usługę), Stop-Transcript (Zatrzymaj-Transkrypcję)

1 Suspend (Wstrzymaj)

Suspend-Service (Wstrzymaj-Usługę)

1 Tee (Rozdziel) Tee-Object (Rozdziel-Obiekt)

1 Test (Testuj) Test-Path (Testuj-Ścieżkę)

1 Trace (Śledź) Trace-Command (Śledź-Polecenie)

2 Update (Aktualizuj)

Update-FormatData (Aktualizuj-Dane formatowania), Update-TypeData (Aktualizuj-Dane typu)

1 Where (Gdzie) Where-Object (Gdzie-Obiekt)

7 Write (Zapisz) Write-Debug (Zapisz-Debug), Write-Error (Zapisz-Błąd), Write-Host (Zapisz-Hosta)

645

Dodatek B

Nazwy dostawców obiektów danych typu ActiveXPodczas otwierania połączenia z bazą danych lub z innym źródłem danych można korzy-stać z usług kilku różnych dostawców danych. Lista tych dostawców znajduje się w tabeli B-1. Lista ta nie jest ani kompletna, ani wyczerpująca. Wynika to z faktu, że wielu nieza-leżnych producentów oprogramowania tworzy swoich własnych dostawców danych.

Podczas otwierania połączenia ze źródłem danych można użyć nazwy dowolnego z tych dostawców. Kod wykonujący taką operację wyglądać będzie podobnie do pokazanego poni-żej przykładu:

$strDB = "c:\fso\configurationmaintenance.mdb" $objConnection = New-Object -ComObject ADODB.Connection $objConnection.Open("Provider = Microsoft.Jet.OLEDB.4.0; ` Data Source= $strDB")

Jako przykład skryptu używającego obiektu Microsoft ADO (ActiveX Data Objects) do komunikowania się z bazą danych programu Access może posłużyć skrypt AuditScreenSaverWriteToAccess.ps1, który został omówiony w rozdziale 9, zatytułowa-nym „Konfigurowanie ustawień pulpitu”.

Korzystając z technologii ADO, nazwy dostawców wymienione w tabeli B-1, mogą być używane do łączenia się z całą gamą różnorodnych źródeł danych.

Tabela B-1 Nazwy dostawców ADO Provider Names

Nazwa dostawcy Dostawca

ADSDSOObject Usługa katalogowa Active Directory

Microsoft.Jet.OLEDB.4.0 Bazy danych typu Microsoft Jet

MSDAIPP.DSO.1 Microsoft Internet Publishing

MSDAORA Bazy danych Oracle

MSDAOSP Zwykłe pliki tekstowe

MSDASQL Dostawca Microsoft OLE DB dla technologii ODBC

MSDataShape Microsoft Data Shape

MSPersist Lokalnie zapisane pliki

SQLOLEDB Serwer Microsoft SQL Server

647

Dodatek C

Często zadawane pytania

Dodatek ten porusza mnóstwo różnych zagadnień. Wszystkie zamieszczone w nim pyta-nia pojawiły się w ciągu mniej więcej ostatniego roku, kiedy to prowadziłem na całym świecie szereg szkoleń dotyczących korzystania z programu Windows PowerShell. Sądzę, że przyjęta tu forma pytań i odpowiedzi będzie interesująca dla czytelnika. Mam nadzieję, że przeglądanie tej listy od czasu do czasu zaoszczędzi czytelnikom setek godzin, które musiałem spędzić starając się znaleźć odpowiedzi na zamieszczone tutaj pytania. Jeśli przy niektórych pytaniach figuruje więcej niż jedna odpowiedź, to dlatego, że niektóre pytania posiadają więcej niż jedną poprawną odpowiedź (to nie egzamin, na którym poprawna jest tylko jedna odpowiedź).

P. Ile poleceń typu cmdlet dostępnych jest w domyślnej instalacji programu Windows PowerShell?

O. 129

P. Jak można sprawdzić, ile poleceń typu cmdlet dostępnych jest w domyślnej insta-lacji programu Windows PowerShell?

O. Wszystkie trzy pokazane poniżej polecenia zwracają taki sam wynik:

(Get-Command).length (Get-Command -CommandType cmdlet).count Get-Command -CommandType cmdlet | foreach($_) { $i++ }

P. Jaka jest różnica pomiędzy zmienną typu tylko-do-odczytu a stałą?O. Zmienna typu tylko-do-odczytu posiada zawartość, którą można tylko odczytywać.

Wartość tę można jedna zmodyfikować za pomocą polecenia Set-Variable z parametrem -force. Zmienną tego typu można także usunąć za pomocą polecenia Remove-Variable z parametrem -force. Stałej nie można usunąć ani zmodyfikować, nawet używając para-metru -force.

P. Jakie są trzy najważniejsze polecenia typu cmdlet?O. Trzy najważniejsze polecenia typu cmdlet to: Get-Command, Get-Help oraz Get-

Member.

P. Których poleceń typu cmdlet można używać do pracy z dziennikami zdarzeń?O. Do pracy z dziennikami zdarzeń służy cmdlet Get-Eventlog.

P. W jaki sposób można ustalić, że do pracy z dziennikiem zdarzeń służy właśnie to polecenie?

O. Polecenie to można znaleźć za pomocą następującej komendy:

Get-Command -Noun eventlog.


P. Jaka klasa środowiska .NET Framework jest wykorzystywana przez cmdlet Get-Eventlog?

O. Cmdlet Get-Eventlog używa klasy System.Diagnostics.EventLogEntry.

P. W jaki sposób można uzyskać powyższą informację?O. Informację tę można uzyskać wykonując następujące polecenie:

Get-Eventlog application | Get-Member

P. Jakie polecenie programu Windows PowerShell oferuje największe możliwości?O. Najbardziej wszechstronnym poleceniem programu Windows PowerShell jest instrukcja

switch, ponieważ umożliwia ona testowanie różnych warunków i nadawanie właściwego kierunku działania skryptu.

P. Do czego służy kombinacja znaków `t ?O. Ta kombinacja znaków służy do tworzenia znaku tabulacji.

P. Jak można wyświetlać w skrypcie tabulację poprzez stosowanie kombinacji znaków `t?

O. W celu wyświetlenia przez skrypt znaku tabulacji należy użyć następującej kombinacji: “`thi”.

P. Składnia podana w powyższym przykładzie wygląda bardzo nieładnie. Co się sta-nie, jeśli pomiędzy literami t i h wstawiona zostanie spacja, np.: “`t hi”?

O. Umieszczenie spacji pomiędzy literami t i h spowoduje, że skrypt wypisze jeden znak tabulacji, a po nim jeden znak dodatkowej spacji.

P. Czy w poleceniu `t (np. “`thi:”) rozróżniane są małe i duże litery?O. Tak. To polecenie stanowi jeden z nielicznych przypadków, w których program Windows

PowerShell rozróżnia małe i duże litery. Zamiana małej litery na dużą w wyrażeniu`t, np. “`Thi”, spowoduje wyświetlenie liter Thi obok siebie.

P. Jak można uruchomić skrypt, w którego nazwie występuje spacja?O. Należy użyć pokazanego poniżej przykładowego kodu:

PS > c:\my`folder\myscript.ps1 PS> &("c:\my folder\myscript.ps1")

P. Jaki jest najprostszy sposób utworzenia tablicy?O. Tablicę najprościej można utworzyć w następujący sposób:

$array = "1","2","3","4"

P. W jaki sposób można wyświetlać wartości obliczane (tzn. np. megabajty zamiast bajtów) pochodzące z zapytania WMI, gdy jego wyniki przekazywane są na wejście polecenia Format-Table?

O. Należy utworzyć tzw. tablicę mieszającą (ang. hash table) na pozycji, na której mają być wyświetlane obliczane dane i wykonać wymagane obliczenia wewnątrz bloku

Dodatek C: Często zadawane pytania 649

ujętego w znaki nawiasów klamrowych. Rezultat obliczeń należy przypisać do parame-tru expression. Odpowiedni przykład został pokazany poniżej:

gwmi win32_logicaldisk -Filter "drivetype=3" | ft -Property name, @{ Label="freespace"; expression={$_.freespace/1MB}}

P. Który z parametrów polecenia Get-WmiObject zastępuje klauzulę WHERE z języka WQL?

O. Klauzulę tę zastępuje parametr -filter, co zostało pokazane w poniższym przykładzie:

Get-wmiobject win32_logicaldisk -filter "drivetype = 3"

P. Które polecenie, jeśli zostanie wpisane na początku skryptu, spowoduje ignoro-wanie przez program Windows PowerShell wszystkich błędów i kontynuowanie wykonywania kodu?

O. Poleceniem tym jest polecenie:

$erroractionpreference=SilentlyContinue

P. Jak można wyświetlić tylko bieżący rok?O. W celu wyświetlenia tylko bieżącego roku należy użyć pokazanej poniżej linii kodu

(należy zauważyć, że litery yyyy zostaną zastąpione przez aktualny rok).

Get-Date -format yyyy

P. Jak używając mniej niż 35 słów opisać, czym jest program Windows PowerShell?O. Program Windows PowerShell stanowi oferowaną przez firmą Microsoft następną gene-

rację okna wiersza poleceń oraz języka skryptowego. W większości przypadków pro-gram ten może być zamiennikiem dla języka skryptowego VBScript oraz dla tradycyj-nego okna wiersza poleceń.

P. Jak można sprawdzić, czy w powyższym opisie rzeczywiście użyto mniej niż 35 słów?

O. Za pomocą następującego fragmentu kodu:

$a = "Program Windows PowerShell stanowi oferowaną przez firmą Microsoft następną generację okna wiersza poleceń oraz języka skryptowego. W większości przypadków program ten może być zamiennikiem dla języka skryptowego VBScript oraz dla tradycyjnego okna wiersza poleceń." Measure-Object -InputObject $a -Word

P. Jakie są dwa sposoby odpytywania kartoteki Active Directory z poziomu programu Windows PowerShell?

O. Użycie technologii ADO i wykonanie zapytania w dialekcie LDAP lub użycie technologii ADO i wykonanie zapytania w dialekcie języka SQL.

P. Jak można wyświetlić ilość wolnego miejsca na dysku twardym, podając ją w MB z dokładnością do dwóch miejsc po przecinku?

O. Należy użyć pokazanej poniżej specyfikacji formatu:

"{0:n2}"-f ((gwmi win32_logicaldisk -Filter "drivetype='3'").freespace/1MB)


P. Konieczne jest zastąpienie wartości 2 w zmiennej $array, zdefiniowanej jako $array = "1","2","3","4", wartością 12. Jak można to zrobić?

O. Zamianę łańcuchów znakowych można wykonać w następujący sposób:

$array=[regex]::replace($array,"2","12")

P. W skrypcie znajduje się pokazana poniżej instrukcja switch. Jak można zapobiec wykonywaniu ostatniej linii z tego przykładu (Write-Host “po instrukcji switch”)?

$a = 3 switch ($a) { 1 { "wykryto jedynkę" } 2 { "wykryto dwójkę" } } Write-Host "po instrukcji switch"

O. Należy dodać do instrukcji switch klauzulę default z instrukcją exit tak, jak to pokazano poniżej:

$a = 3 switch ($a) { 1 { "wykryto jedynkę" } 2 { "wykryto dwójkę" } DEFAULT { exit} } Write-Host "po instrukcji switch"

P. Jak można używając polecenia Get-WmiObject przekazać alternatywne poświad-czenia tożsamości dla zdalnego wywołania metody podsystemu WMI?

O. Należy użyć parametru -credential, w pokazany poniżej sposób:

Get-WmiObject Win32_BIOS -ComputerName Server01 -Credential (get-credential Domain01@User01)

Parametru -credential można również użyć w następujący sposób:

$c = Get-Credential Get-WmiObject Win32_DiskDrive -ComputerName Server01 -Credential $c

P. W jaki sposób można wygenerować liczbę losową?O. Należy skorzystać z klasy środowiska .NET Framework o nazwie System.Random i wywo-

łać jej metodę next() tak, jak to zostało pokazane poniżej:

([random]5).next()

P. W jaki sposób można wygenerować liczbę losową z przedziału od 1 do 10?O. Należy skorzystać z klasy środowiska .NET Framework o nazwie System.Random i wywo-

łać jej metodę next() tak, jak to zostało pokazane poniżej :

([random]5).next("1","10")

P. Które z poleceń programu Windows PowerShell obsługują wyrażenia regularne?


O. Wyrażeń regularnych można używać w poleceniu Where-Object z parametrem -match, w pokazany poniżej sposób:

get-process | where-object { $_.ProcessName -match "^p.*" }

Wyrażeń regularnych można również używać w instrukcji switch z opcją -regex, co zostało pokazane poniżej:

switch -regex ("Hi there") { "hi" { "found" } }

P. Jak można utworzyć plik inspekcji rejestrujący wszystkie polecenia wpisywane podczas sesji programu Windows PowerShell?

O. Należy użyć polecenia Start-Transcript w pokazany poniżej sposób:

Start-transcript -Path c:\fso\mylog.txt -Force

P. Jak można sprawdzić, ile sekund trwa pobieranie obiektów z dziennika aplikacji?O. Używając następującego polecenia:

(Measure-Command { Get-EventLog application }).totalseconds

P. Po otwarciu konsoli programu Windows PowerShell na serwerze, na którym zainstalowano oprogramowanie serwera Exchange 2007, nie są dostępne żadne z poleceń typu cmdlet z grupy Microsoft Exchange. Czym jest spowodowany ten problem i jak można go rozwiązać?

O. Problem polega na tym, że nie została załadowana przystawka Exchange Management Shell. Rozwiązanie polega na otwarciu okna konsoli programu Windows PowerShell i wpisaniu następującego polecenia:

add-psSnapin -Name microsoft.exchange.management.powershell.admin

P. Jak można uzyskać listę wszystkich przystawek zarejestrowanych na komputerze w programie Windows PowerShell?

O. W oknie konsoli programu Windows PowerShell należy wpisać następujące polecenie:

Get-PSSnapin -Registered

P. Jak można utworzyć tekstowy plik ASCII zawierający rezultaty zwracane przez polecenie Get-Process?

O. Należy utworzyć potok, kierując rezultaty na wejście polecenia Out-File z parametrem -encoding, określającym standard kodowania ASCII.

P. Podobno polecenie Write-Host umożliwia wypisywanie tekstów w kolorze. Chciałbym zobaczyć kilka przykładów poprawnej składni stosowania kolorów.

O. Przykłady składni:

write-host -ForegroundColor 12 "hi" write-host -ForegroundColor 12 "hi" -BackgroundColor white write-host -ForegroundColor blue -BackgroundColor white write-host -ForegroundColor 2 hi


write-host -backgroundcolor 2 hi write-host -backgroundcolor ("{0:X}" -f 2) hi for($i=0 ; $i -le 15 ; $i++) { write-host -foregroundcolor $i "hi" }

P. Jak można sprawdzić, czy dane polecenie zostało wykonane poprawnie i bez błędów?

O. Należy sprawdzić wartość zmiennej automatycznej $error. Jeśli wyrażenie $error[0] nie zwraca żadnych informacji, to znaczy, że nie wystąpiły żadne błędy. Można również sprawdzać wartość zmiennej automatycznej $?. Jeśli zmienna $? mieć będzie wartość true, to znaczy, że wykonywanie ostatniego polecenia zakończyło się powodzeniem.

P. Jak można podzielić pokazany poniżej łańcuch znakowy, zapisany w zmiennej $a?

$a = "atl-ws-01,atl-ws-02,atl-ws-03,atl-ws-04"

O. Należy użyć metody split:

$b = $a.split(",")

P. Jak można połączyć ze sobą elementy tablicy, np. takiej jak ta zapisana w pokaza-nej poniżej zmiennej $a?

$a = "h","e","l","l","o"

O. Należy użyć statycznej metody join z klasy string, w pokazany poniżej sposób:

$b = [string]::join("", $a)

P. Jak można utworzyć ścieżkę prowadzącą do katalogu Windows\System32?O. Ścieżkę taką można utworzyć za pomocą pokazanego poniżej kodu:

Join-Path -path (g-t-item env:\windir).value -ChildPa-h system32

P. Jak można wyświetlić wartość zmiennej środowiskowej %systemroot%?

A: Wartość tę można wyświetlić za pomocą pokazanego poniżej kodu:

(get-item Env:\systemroot).value $env:systemroot

P. Jak można wyświetlić listę uruchamianych procesów w oknie konsoli programu Windows PowerShell, zapisując ją jednocześnie w pliku tekstowym?

O. Należy posłużyć się następującym fragmentem kodu:

Get-process | Tee-Object -FilePath c:\fso\proc.txt

P. Jak można wyświetlić znak ASCII o kodzie 56?O. Za pomocą następującego kodu:

[char]56

P. Jak można utworzyć i zapisać w zmiennej $a tablicę elementów typu System.Diagnostics.Processes?


O. Za pomocą następującego kodu:

[diagnostics.process[]]$a=get-process

P. Jak można wyświetlić liczbę 1234 jako wartość heksadecymalną?O. Za pomocą następującego kodu:

"{0:x}" -f 1234

P. Jak można wyświetlić wartość dziesiętną liczby heksadecymalnej 0x4d2?O. Za pomocą następującego kodu:

0x4d2

P. Jak można sprawdzić, czy w pokazanym poniżej łańcuchu znakowym, zapisanym w zmiennej $a, występuje litera m?

$a="northern hairy-nosed wombat"

O. Aby sprawdzić, czy łańcuch znakowy zawiera np. literę m, należy posłużyć się pokaza-nym poniżej kodem:

[string]$a.contains("m") $a.contains("m") [regex]::match($a,"m") ([regex]::match($a,"m")).success

P. Jak można odczytywać dane wprowadzane przez użytkownika?O. Za pomocą polecenia Read-Host, w pokazany poniżej sposób:

$in = Read-host "wprowadź dane"

P. Czy dane wejściowe odczytywane za pomocą polecenia Read-Host można prze-chowywać w zmiennej o nazwie $input?

O. Zmienna $input jest zmienną automatyczną używaną w blokach skryptowych wyko-nywanych w środku potoku, a więc wybór takiej nazwy dla własnej zmiennej będzie bardzo nieodpowiedni. Zmienną taką można nazwać $userInput (lub podobnie), ale w żadnym razie nie należy nazywać jej $input!

P. Jak można spowodować wygenerowanie przez skrypt błędu w przypadku nieza-deklarowania zmiennej?

O. Należy umieścić w dowolnym miejscu skryptu polecenie Set-PSDebug -strict. Każda próba skorzystania z niezadeklarowanej zmiennej spowoduje wówczas wygenerowanie błędu.

P. Jak można zwiększyć rozmiar bufora używanego przez polecenie Get-History?O. Należy przypisać żądaną wartość do zmiennej automatycznej $MaximumHistoryCount

tak, jak to pokazano poniżej:

$MaximumHistoryCount = 65


P. Jak można zapisać liczbę 1 jako tablicę złożoną z 16 bitowych liczb całkowitych?O. Za pomocą następującego kodu:

$a=[int16[]][int16]1

P. W łańcuch znakowym: "to`"jest łańcuch znakowy" należy zastąpić znak cudzysłowu (") pustym miejscem, nie spacją, lecz właśnie pustym miejscem. Czyli efektyw-nie należy usunąć znak cudzysłowu (") z tego łańcucha znakowego. Jak można to zrobić?

O. Należy „anulować” znak cudzysłowu za pomocą znaku odwróconego apostrofu (`).

P. Jak za pomocą metody replace można usunąć znaki cudzysłowu z łańcucha znako-wego zapisanego w zmiennej o nazwie $arr? Rezultat powinien wyglądać nastę-pująco: to jest łańcuch znakowy.

O. Należy użyć metody replace z klasy środowiska .NET Framework System.String, w poka-zany poniżej sposób:

$arr.Replace("`"","")

Można również posłużyć się kodem ASCII znaku cudzysłowu, używając metody replace w następujący sposób:

$arr.Replace([char]34,"")

P. Jak można użyć polecenia Invoke-Expression do uruchomienia skryptu z poziomu programu Windows PowerShell, jeśli ścieżka do tego skryptu zawiera znaki spacji?

O. Należy „zamaskować” znaki spacji przy pomocy znaku odwróconego apostrofu (`) i ująć całą ścieżkę wraz z nazwą skryptu w znaki nawiasu tak, jak to pokazano poniżej:

Invoke-Expression ('h:\LABS\extras\Run` With` Spaces.ps1')

P. Jak można utworzyć tablicę bajtów zawierającą wartości heksadecymalne?O. Należy użyć ograniczenia typu [byte], ujmując całość w dodatkową parę znaków

([]), np.: [byte[]]. Do zapisu liczb heksadecymalnych należy stosować format 0x. Poniżej pokazany został odpowiedni przykład umożliwiający osiągnięcie wymaganego rezultatu:

[byte[]]$mac = 0x00,0x19,0xD2,0x72,0x0E,0x2A

P. Jak można zainstalować przystawkę Microsoft Exchange Management Shell na komputerze pracującym z systemem Windows Vista?

O. Nie można. Przystawkę Exchange Management Shell można zainstalować tylko na ser-werze, na którym zainstalowano oprogramowanie serwera Exchange Server 2007. Więcej informacji na ten temat można uzyskać wyszukując w witrynie webowej Microsoft Help and Support (Centrum pomocy i obsługi technicznej) artykułu KB 931903.

655

Dodatek D

Wskazówki dotyczące tworzenia skryptówW tym dodatku przedstawione zostaną szczegółowe wskazówki dotyczące pisania skryp-tów. Wskazówki te zostały zebrane przez kilkunastu twórców skryptów z całego świata. Większość z nich jest pracownikami firmy Microsoft, aktywnie zaangażowanymi w świecie programu Windows PowerShell. Część z nich nie pracuje w firmie Microsoft. Są to np. administratorzy sieci i konsultanci, którym codzienne korzystanie z programu Windows PowerShell pozwala na poświęcanie większej ilości czasu na życie osobiste. Nie każdy skrypt jest zgodny z prezentowanymi tu wskazówkami, jednak im ściślej będą one prze-strzegane, tym łatwiejsze będzie zrozumienie działania skryptu oraz jego konserwacja. Stosowanie się do opisywanych wskazówek może wcale nie ułatwiać pisania skryptów, ale powinno ułatwić zarządzanie nimi i znacznie obniżyć wskaźnik TCO (Total Cost of Ownership – Całkowity koszt posiadania) dla rozwiązań skryptowych. Ostatecznie stawiam przed skryptami tylko trzy wymagania: powinny być one czytelne, łatwe do zrozumienia i łatwe w utrzymywaniu.

Ogólna konstrukcja skryptuW tej części przedstawione zostaną pewne generalne uwarunkowania, jakie powinna spełniać ogólna konstrukcja skryptu. Obejmują one sposób stosowania funkcji oraz inne uwarunkowania.

Funkcje należy umieszczać w skryptach, które je wywołująWprawdzie program Windows PowerShell umożliwia korzystanie z funkcji włączania pliku (ang. include file lub dot source), ale ich stosowanie może zmienić się w koszmar w razie potrzeby uzyskania pomocy technicznej. Jeśli wiadomo, jakiej funkcji potrzebujemy, lecz nie wiadomo, w którym skrypcie znajduje się ta funkcja, konieczne jest jej wyszukanie. Jeśli skrypt zawiera potrzebną nam funkcję, ale jednocześnie zawiera także inne elementy, które w danej sytuacji są niepożądane, to wybranie i wyodrębnienie właściwej funkcji z pliku skryptu może być trudne. Ponadto należy zachować dużą ostrożność w kwestii konwencji nazywania zmiennych, ponieważ łatwo można znaleźć się w sytuacji konfliktu pomiędzy nazwami zmiennych. Zastosowanie funkcji włączania pliku oznacza, że skrypt staje się nieprzenośny. Przenosząc taki skrypt na inne komputery zawsze musi towarzyszyć mu biblioteka używanych funkcji.

W swoich skryptach często stosuję funkcje, ponieważ poprawia to czytelność skryptu oraz ułatwia jego utrzymywanie. Gdyby funkcje te zostały zapisane w osobnych plikach, a następnie włączone do skryptu za pomocą konwencji kropka źródło (ang. dot source), to faktycznie nie spełniałyby żadnego z dwóch wymienionych przez mnie celów stosowania funkcji.


Istnieje także jeszcze jeden czynnik. Jeśli jeden skrypt odwołuje się do innego, zewnętrz-nego skryptu zawierającego funkcje, to pomiędzy tymi skryptami istnieje relacja, której nie można zaburzyć. Np. decydując się na aktualizację funkcji możemy nie pamiętać, ile zewnętrznych skryptów korzysta z tej funkcji i jaki będzie wpływ aktualizacji tej funkcji na wydajność tych skryptów oraz sposób ich działania. Jeśli istnieje tylko jeden skrypt wywołujący daną funkcję, wówczas sprawa jest prosta: należy po prostu skopiować tę funk-cję do korzystającego z niej skryptu.

Należy stosować pełne nazwy poleceń typu cmdlet oraz pełne nazwy parametrów

Istnieje kilka zalet stosowania pełnych nazw poleceń typu cmdlet i unikania stosowania w skryptach ich aliasów. Po pierwsze taka technika sprawia, że tworzone skrypty są prawie samodokumentujące się i znacznie czytelniejsze. Po drugie uodparnia to skrypt na zmiany aliasów dokonywane przez użytkownika i poprawia jego zgodność z przyszłymi wersjami programu Windows PowerShell.

Stosowanie aliasów

W programie Windows PowerShell istnieją trzy rodzaje aliasów: aliasy kompatybilności, aliasy kanoniczne oraz aliasy definiowane przez użytkownika.

Aliasy kompatybilności można zidentyfikować za pomocą następującego polecenia:

Get-childitem alias: | where-object {$_.options -notmatch "Readonly" }

Aliasy kompatybilności istnieją w programie Windows PowerShell po to, by ułatwić prze-chodzenie z innych, starszych języków skryptowych. Wszystkie aliasy kompatybilności można usunąć za pomocą następującego polecenia:

Get-childitem alias: | where-object {$_.options -notmatch "Readonly" } | remove-item

Aliasy kanoniczne zostały utworzone specjalnie w celu ułatwienia stosowania wybranych poleceń typu cmdlet w oknie konsoli programu Windows PowerShell. Głównymi czyn-nikami decydującymi o utworzeniu aliasów kanonicznych była krótka nazwa i łatwość ich wpisywania. Listę aliasów kanonicznych można uzyskać za pomocą następującego polecenia:

Get-childitem alias: | where-object {$_.options -match "Readonly" }

Jeśli konieczne jest użycie aliasu, należy stosować wyłącznie aliasy kanoniczne

Stosowanie w skrypcie aliasów kanonicznych jest względnie bezpieczne, jednak znacznie utrudnia odczytywanie skryptu, a ponieważ często istnieje kilka aliasów dla tego samego polecenia typu cmdlet, więc każdy użytkownik programu Windows PowerShell może mieć swoje ulubione aliasy. Ponadto pomimo tego, że aliasy kanoniczne mają status „tylko

Dodatek D: Wskazówki dotyczące tworzenia skryptów 657

do odczytu”, nawet one mogą zostać usunięte lub co gorsza, użytkownik może radykalnie zmienić ich znaczenie.

Tworząc alias zawsze należy używać właściwości Description (Opis)

Dodając aliasy do własnego profilu można używać opcji read-only lub constant. W przy-padku osobistych aliasów należy zawsze stosować właściwość Description (Opis), podając w miarę stały i niezmienny opis. Poniżej pokazany został przykład zaczerpnięty z mojego osobistego profilu programu Windows PowerShell:

New-Alias -Name gh -Value Get-Help -Description "mred alias" New-Alias -Name ga -Value get-alias -Description "mred alias"

Należy używać polecenia Get-Item, przekształcając tekstowe ścieżki do plików we wszechstronne obiekty

Jest to bardzo przydatny trick. Pracując z listami plików można używać polecenia Get-Content do odczytywania kolejnych linii i używać tych linii jako ścieżek do kolej-nych plików. Jednak stosując polecenie Get-Item otrzymamy obiekt posiadający wszystkie odpowiednie właściwości i metody, z których można korzystać podczas pracy z plikami. Funkcjonalność tę demonstruje zamieszczony poniżej przykład:

$files = Get-Content "filelist.txt" | Get-Item $files | Foreach-object { $_.Fullname }

Ogólna czytelność skryptuIstnieje kilka rzeczy pozwalających na zapewnienie jak największej czytelności skryptu. W tej części przyjrzymy się kilku najważniejszym elementom.

■ Tworząc alias należy stosować parametr -description (opis) i używać go do wyszukiwnia swoich osobistych aliasów. Odpowiedni przykład został pokazany poniżej:

Get-Alias | where-object { $_.description -match 'mred' } | Format-Table -Property " ",name, definition -autosize ` -hideTableHeaders

■ Wszystkie skrypty powinny akceptować parametr -help, powodujący wyświetlenie tek-stu pomocy. Parametr -help można zaimplementować jako parametr nazwany:

Param($help)

■ Alternatywnie parametr -help można zaimplementować jako przełącznik (przy użyciu słowa kluczowego switch). Przełącznik można najłatwiej zaimplementować w następu-jący sposób:

Param([switch]$help)

■ Wszystkie procedury powinny rozpoczynać się od krótkiego komentarza wyjaśniają-cego ich przeznaczenie i sposób działania. Opis ten nie powinien zawierać szczegółów implementacji (tzn. w jaki sposób realizowana jest dana funkcjonalność), ponieważ


wraz z upływem czasu często ulegają one zmianom, stwarzając niepotrzebnie koniecz-ność aktualizowania komentarzy lub co gorsza powodując, że zamieszczone w skrypcie komentarze stają się błędne.

■ Przekazywane do funkcji argumenty powinny być opisywane, jeśli ich przeznaczenie nie jest oczywiste lub jeśli funkcja oczekuje, że wartości argumentów będą się mieścić w określonym przedziale.

■ Wartości zwracane za pomocą modyfikowanych przez funkcję zmiennych powinny rów-nież być opisywane na początku każdej funkcji.

■ Deklaracji każdej ważnej zmiennej powinien towarzyszyć komentarz, opisujący w tej samej linii przeznaczenie zmiennej, jeśli nie wynika ono w oczywisty sposób z nazwy zmiennej.

■ Zmiennym i funkcjom należy nadawać jasne i zrozumiałe nazwy tak, by stosowanie komentarzy uzupełniających było konieczne tylko w przypadku skomplikowanych funkcji.

■ Tworząc skomplikowane funkcje złożone z wielu bloków kodu, po każdym klamrowym nawiasie zamykającym (}) należy umieścić odpowiedni komentarz (w tej samej linii).

■ Na początku każdego skryptu należy umieścić krótkie podsumowanie opisujące sam skrypt, ważniejsze z używanych w nim obiektów i poleceń typu cmdlet oraz wszelkie unikalne wymagania danego skryptu.

■ Tworząc nazwy funkcji należy stosować konstrukcje złożone z połączeń czasownik-rzeczownik, podobne do stosowanych w nazwach poleceń typu cmdtel, pomijając jednak znak myślnika. Pozwala to na wyraźne rozróżnianie funkcji i poleceń typu cmdlet. Pozwoli to także uniknąć dezorientacji, dlaczego funkcja uzupełniania nazw poleceń za pomocą klawisza tabulacji działa dla jednych poleceń typu „cmdlet”, a dla innych nie.

■ Jeśli skrypt używa więcej niż jednego argumentu, to należy zastosować parametry nazwane. Stosowanie nienazwanych argumentów jest odpowiednie tylko dla skryptów używających tylko jednego argumentu.

■ Należy zawsze zakładać, że nasz skrypt zostanie skopiowany przez użytkownika i przy-stosowany przez niego do swoich własnych wymagań. Należy więc umieszczać w kodzie komentarze, które będą ułatwiać ten proces.

■ Nigdy nie należy opierać działania skryptu na ścieżce bieżącej. Zawsze należy stosować pełne ścieżki absolutne, konstruowane albo przy użyciu zmiennych środowiskowych, albo podawane w sposób jawny.

Formatowanie koduPodczas pisania skryptów należy starać się maksymalnie oszczędzać miejsce na ekranie zachowując jednak formatowanie kodu odzwierciedlające logiczną strukturę kodu oraz zagnieżdżanie bloków. Poniżej podano kilka sugestii dotyczących formatowania:

■ Dla standardowych zagnieżdżeń bloków należy stosować wcięcie o dwie spacje.

■ Komentarze z ogólnym opisem funkcji należy formować w jeden blok.


■ Instrukcje najwyższego poziomu należy formować w jeden blok, a dla każdego bloku zagnieżdżonego należy stosować wcięcie o dwie dodatkowe spacje.

■ Otwierające i zamykające nawiasy klamrowe należy zawsze wyrównywać do tej samej kolumny. Ułatwia to śledzenie toku działania kodu.

■ Należy unikać umieszczania bloków kodu w pojedynczej linii. Ułatwi to nie tylko śledze-nie toku działania kodu, ale także wyszukiwanie brakujących nawiasów klamrowych.

■ Należy rozbijać wszystkie potoki na osobne linie. Symbole potoku należy pozostawiać po prawej stronie.

■ Należy starać się unikać stosowania symbolu kontynuacji linii (odwróconego apostrofu). Wyjątek stanowią instrukcje, których przeczytanie wymagałoby od użytkownika prze-wijania zawartości ekranu, czyli generalnie dłuższe od około 90 znaków.

■ Przy tworzeniu w skryptach długich nazw zmiennych należy stosować się do tzw. zasady „camel case” (InterCapping).

■ W skryptach, których wykonywanie trwać będzie dłużej niż jedną lub dwie sekundy, należy stosować polecenie cmdlet Write-Progress.

■ Należy rozważyć zastosowanie we własnych funkcjach oraz skryptach parametrów --whatif i -confirm, zwłaszcza wówczas gdy będą one zmieniać stan systemu. Przykład zastosowania parametru -whatif został pokazany poniżej. Jako kompletny przykład zastosowania tego parametru posłużyć może skrypt AddNodeEvictNode.ps1 z roz-działu 14, zatytułowanego „Konfigurowanie usługi klastrowania”.

param( [switch]$whatif )

function funwhatif() { "what if: Wykonana zostanie operacja xxxx" } if($whatif) { funwhatif #wywołanie funkcji funwhatif() }

■ Jeśli tworzony skrypt nie dopuszcza zmiennej liczby argumentów, należy sprawdzić war-tość wyrażenia $args.count i wywołać funkcję pomocy, jeśli liczba użytych argumentów jest niewłaściwa. Poniżej pokazany został prosty przykład:

if($args.count -ge 0) { "niewłaściwa liczba argumentów" Funhelp #wywołanie funkcji funhelp() }

■ Jeśli tworzony skrypt nie akceptuje żadnych argumentów, to należy zastosować kon-strukcję pokazaną poniżej:

If($args -ge 0) { funhelp }


Praca z funkcjamiFunkcje w programie Windows PowerShell stwarzają możliwość wyodrębniania w osobną jednostkę pewnych fragmentów kodu. Funkcje mogą być wykorzystywane do rozszerzania możliwości programu Windows PowerShell lub jedynie do aranżacji treści skryptu w bar-dziej czytelny sposób. W każdym z tych przypadków istnieje kilka wskazówek, których warto przestrzegać podczas pracy z funkcjami.

■ Funkcje powinny sprawdzać użycie parametrów obowiązkowych. Poniżej pokazany został odpowiedni przykład:

Function GetProcess ($name = ($paramMissing=$true)) { if($local:paramMissing) { throw "USAGE: GetProcess Name <name>" } #$local:paramMissing Get-Process -name $name } #end function GetProcess()

■ Funkcje o charakterze narzędziowym lub udostępniane dla więcej niż jednego skryptu należy umieszczać w bibliotekach funkcji współdzielonych, a następnie włączać je do skryptów (za pomocą notacji kropka źródło – ang. dot source). Należy przy tym stosować format nazwy plików Library-<rzeczownik lub nazwa realizowanej funkcjonal-ności>.ps1. Poniżej pokazano odpowiedni przykład:

. c:\lib\Library-WmiFunctions.ps1

■ Tworząc skrypt będący biblioteką funkcji należy rozważyć stosowanie takich nazw funk-cji i zmiennych, które będą unikalne, minimalizując jednocześnie prawdopodobieństwo wystąpienia konfliktu z innymi nazwami używanymi w skrypcie korzystającym z danej biblioteki.

■ Należy rozważyć wprowadzenie obsługi parametru -erroraction. Umożliwi to łatwiejsze przekazywanie parametru do wywoływanej funkcji. Poniżej pokazano przykład:

function getProcess ( $name, $ErrorAction=$ErrorActionPreference ) { $private:ErrorActionPreference = $ErrorAction Get-Process -Name $name "local error action preference is $ErrorActionPreference" #debug } #end getProcess()

getProcess -name notepad -ErrorAction "stop"

■ Należy rozważyć wprowadzenie obsługi wspólnego parametru -verbose. Umożliwi to tworzenie wewnątrz funkcji dwóch poziomów szczegółowości wyświetlanych wyni-ków. Odpowiedni przykład został pokazany poniżej:

Function GetProcess ( $name, [switch]$verbose


) { If($verbose) { Get-Process -Name $name | Format-List * } ELSE { Get-Process -Name $name } } #end getprocess()

getprocess -name notepad -verbose

■ W przypadku funkcji zmieniających stan systemu należy rozważyć wprowadzenie obsługi wspólnego parametru -confirm. Odpowiedni przykład został pokazany poniżej:

Function StopProcess ( $name, [switch]$confirm ) { If($confirm) { $response = Read-Host -Prompt ` "Czy na pewno chcesz zatrzymać proces $name ? < t(ak) n(ie) > " switch($response) { "t" { Stop-Process -Name $name } "n" { "Proces $name nie zostanie zatrzymany." } } } ELSE { Stop-Process -Name $name } } #end getprocess()

stopprocess -name notepad -confirm


Tworzenie plików z szablonamiNależy utworzyć szablony, których będzie można używać do tworzenia różnych rodzajów skryptów. Mogą to być np. szablony dla skryptów opartych na podsystemie WMI, inter-fejsie ADSI lub obiektach ADO. Podczas tworzenia takich szablonów należy uwzględnić następujące elementy:

■ Do szablonu należy dodać regularnie używane funkcje.

■ Nie należy trwale wpisywać konkretnych wartości, które mogą być wymagane w łańcu-chach znakowych opisujących połączenia, takich jak nazwa serwera, ścieżka do pliku wejściowego itp. Zamiast tego wartości tego typu należy określać przy pomocy zmiennych.

■ W szablonach nie należy umieszczać trwałej informacji o numerze wersji.

■ W miejscach, które wymagają modyfikacji, aby szablon stał się użyteczny, należy koniecznie umieszczać odpowiedni komentarz.

Pisanie funkcjiPoniżej przedstawiono kilka sugestii, które należy uwzględniać podczas pisania własnych funkcji:

■ Należy tworzyć wysoko specjalizowane funkcje. Dobra funkcja robi dobrze tylko jedną rzecz.

■ Tworzone funkcje powinny być całkowicie samowystarczalne. Dobra funkcja powinna być przenośna.

■ W miarę możliwości należy umieszczać funkcje wewnątrz skryptu w kolejności alfabe-tycznej. Poprawia to zarówno czytelność skryptu, jak i możliwości jego utrzymywania.

■ Należy stosować opisowe nazwy funkcji, takie jak np. funhelp, funline lub funcompute-percentage. Osobiście lubię poprzedzać nazwy funkcji przedrostkiem fun, aby uniknąć możliwości przypadkowego użycia jako nazwy funkcji słowa kluczowego, a także aby poprawić widoczność i czytelność funkcji. Można również stosować całe słowo function, ale sądzę, że jest ono zbyt długie.

■ Każda funkcja powinna posiadać jeden punkt wejścia.

■ Każda funkcja powinna posiadać jeden punkt wyjściowy (końcowy).

■ Należy stosować parametry, aby uniknąć problemów związanych z zasięgiem zmiennych lokalnych i globalnych.

■ W miarę możliwości należy implementować typowe parametry: -verbose, -debug, -whatif i -confirm, co ułatwi ponowne wykorzystywanie tego samego kodu.

Tworzenie i nazywanie zmiennych oraz stałychPodczas tworzenia i nazywania zmiennych i stałych należy uwzględniać następujące uwagi:


■ Należy unikać stosowania „magicznych liczb”. Należy także unikać stosowania literałów używanych wprost w wywołaniach metod lub funkcji. Zamiast tego należy utworzyć stałą, której nazwa będzie na tyle opisowa, że każda osoba czytająca kod będzie mogła się domyśleć, jakie jest jego przeznaczenie. Np. w skrypcie ServiceDependencies.ps1 występuje liczba odpowiedzialna za szerokość wcięcia wyświetlanych wyników. Wartość tej liczby jest określana poprzez pozycję określonego znaku w wyświetlanych wynikach. Zamiast więc określić tę liczbę po prostu jako +14, została utworzona stała o opisowej nazwie. Więcej informacji na temat tego skryptu znajduje się w rozdziale 12, zatytu-łowanym „Rozwiązywanie problemów związanych z systemem Windows”. Omawiany fragment tego skryptu został przytoczony poniżej:

New-Variable -Name c_padline -value 14 -option constant Get-WmiObject -Class Win32_DependentService -computername $computer | Foreach-object ` { "=" * ((([wmi]$_.dependent).pathname).length + $c_padline)

■ Nie należy „ponownie wykorzystywać” zmiennych. Zmienne użyte ponownie do innych celów nazywane są zmiennymi rozproszonymi (ang. unfocused variables). Każda zmienna powinna służyć tylko do jednego celu. Takie zmienne nazywane są zmiennymi skoncentrowanymi (ang. focused variables).

■ Należy nadawać zmiennym opisowe nazwy.

■ Należy minimalizować zasięg zmiennych. Jeśli dana zmienna ma być używana tylko wewnątrz pewnej funkcji, to należy ją zadeklarować wewnątrz tej funkcji.

■ Zamiast stałych należy starać się stosować zmienne przeznaczone tylko do odczytu. Należy pamiętać, że stałej nie można usunąć ani zmienić jej wartości.

■ Należy unikać bezpośredniego wpisywania wartości w wywołaniach metod lub w robo-czej części skryptu. Zamiast tego należy stosować zmienne o odpowiedniej wartości.

■ W miarę możliwości należy starać się grupować w jedną sekcję wszystkie zmienne występujące na tym samym poziomie skryptu.

■ Należy unikać stosowania „notacji węgierskiej” – nie ma bowiem takiej potrzeby. Należy pamiętać, że w programie Windows PowerShell praktycznie wszytko jest obiektem, a więc nadawanie zmiennej np. nazwy $objWMI nie wnosi do skryptu żadnej dodatko-wej wartości.

■ Istnieją jednak przypadki, w których dobrze jest poprzedzać nazwy zmiennych przed-rostkami w rodzaju: bln, int, dbl, err, dte lub str. Wynika to z faktu, że program Windows PowerShell posiada bardzo silną kontrolę typów, choć na podstawie jego działania można by sądzić, że takiej kontroli nie posiada.

■ Należy unikać w skryptach tworzenia zmiennych globalnych. Zamiast tego należy starać się stosować przekazywanie zmiennych do funkcji przez referencję [ref].

665

Dodatek E

Ogólne wskazówki dotyczące rozwiązywania problemówW dodatku tym zebrane zostały różne wskazówki dotyczące rozwiązywania problemów. Kolejność prezentowania tych wskazówek niekoniecznie stanowi odzwierciedlenie ich ważności.

Należy pamiętać, że pisownia jest ważna. Zawsze należy sprawdzać, czy nie popełniono żadnych błędów w pisowni nazw poleceń typu cmdlet, nazw właściwości, nazw wywoływa-nych metod itp. Jedna z cech programu Windows PowerShell polega na tym, że nie gene-ruje on błędów po uruchomieniu skryptu zawierającego nieprawidłowo zapisaną nazwę właściwości. Po uruchomieniu pokazanego poniżej fragmentu kodu należy zwrócić uwagę, że nie generuje on żadnych komunikatów ani żadnych błędów. Nic nie wskazuje więc, że użyta została niewłaściwa nazwa właściwości klasy WMI Win32_Service.

PS C:\> $wmi = Get-WmiObject -Class win32_service PS C:\> $wmi.badproperty PS C:\>

Nie należy przerywać potoku Jest to szczególnie łatwy do popełnienia błąd. Zwykle zaczyna się on od wpisania polecenia w oknie konsoli programu Windows PowerShell. Jeśli użytkownik zdecyduje się na dodanie do tego polecenia czegoś jeszcze, może użyć klawisza ze strzałką skierowaną w górę i dodać na końcu polecenia symbol potoku. Jeśli polecenie będzie szczególnie użyteczne, użytkownik może zechcieć umieścić je w skryp-cie, a więc jego następnym krokiem będzie „oczyszczenie” wyników ze zbędnych kolumn i dodanie na początku nagłówków (co spowoduje przerwanie potoku). Zostało to pokazane na zamieszczonym poniżej przykładzie. Linia z instrukcją Get-WmiObject kończy się zna-kiem potoku, po którym następuje wywołanie funkcji wyświetlającej nazwę komputera. Problem jest następujący: taka operacja spowoduje przerwanie potoku i skrypt wypisze tylko jedną linię: „Zależności pomiędzy usługami na komputerze localhost”. Ponieważ w tym przykładzie miało miejsce wywołanie funkcji, więc skrypt nie wygeneruje żadnego błędu.

Param($computer = "localhost")

function funline ($strIN) { $num = $strIN.length for($i=1 ; $i -le $num ; $i++) { $funline = $funline + "=" } Write-Host -ForegroundColor yellow $strIN Write-Host -ForegroundColor darkYellow $funline }

Get-WmiObject -Class Win32_DependentService -computername $computer | funline("Zależności pomiędzy usługami na komputerze $($computer)") Foreach-object `


{ [wmi]$_.Antecedent [wmi]$_.Dependent }

Z drugiej strony, gdyby skrypt nie wywoływał funkcji, to zostałby wygenerowany błąd. Zostało to zademonstrowane na pokazanym poniżej przykładzie. Należy zauważyć, że w tym przypadku, tak samo jak w poprzednim, linia z poleceniem Get-WmiObject kończy się znakiem potoku. Przerwanie potoku następuje poprzez wypisanie tekstu „Usługi zależne na komputerze lokalnym”.

Get-WmiObject -Class Win32_DependentService | "Usługi zależne na komputerze lokalnym" Foreach-object ` { [wmi]$_.Antecedent [wmi]$_.Dependent }

Uruchomienie pokazanego powyżej fragmentu kodu spowoduje wygenerowanie błędu. Treść tego błędu informuje użytkownika, że nie można stosować wyrażeń w środku potoku, co oczywiście miało miejsce w tym przypadku.

Expressions are only permitted as the first element of a pipeline. At C:\Users\EDWILS~1.NOR\AppData\Local\Temp\temp.ps1:4 char:44 + "Usługi zależne na komputerze lokalnym" <<<<

Wyrażenie może być tylko pierwszym elementem potoku.Plik: wiersz; wiersz: 1; znak: 88+ "Usługi zależne na komputerze lokalnym" <<<<

Należy korzystać z instrukcji debugujących umożliwiających sprawdzanie, co dzieje się wewnątrz skryptu podczas jego wykonywania. Jeśli skrypt generuje dziwne rezul-taty, należy wyświetlać wartości używanych w nim zmiennych. Osobiście zawsze staram się umieszczać po każdym użyciu zmiennej instrukcję debugującą, którą można bezpiecz-nie usunąć po zakończeniu testowania. W pokazanym poniżej przykładzie wykonywana jest operacja dodawania dwóch liczb. Chcemy jednak mieć pewność, że wyświetlany rezultat jest prawidłowy. W tym celu należy użyć instrukcji debugującej, która umożliwi sprawdzenie, czy wynik jest faktycznie poprawny. Po poprawieniu ewentualnych błędów lub potwierdzeniu prawidłowego działania skryptu należy usunąć z niego linie z instruk-cjami debugującymi. Jeśli zawsze używać się będzie takich samych instrukcji debugujących, to będą one łatwe do wyszukania. Można wówczas oczyścić skrypt za pomocą funkcji Find (Znajdź) i Replace (Zamień) programu Notepad (Notatnik). Odpowiedni przykład został pokazany poniżej:

$a = 5 $b = 4 '$a is ' + $a # debug '$b is ' + $b # debug $c = $a + $b "Wynik `$a + `$b wynosi $c"

Dodatek E: Ogólne wskazówki dotyczące rozwiązywania problemów 667

Podczas pracy z obiektami lub plikami należy sprawdzać za pomocą polecenia Test-Path, czy dany obiekt lub plik faktycznie istnieje. Oczywiście jeśli to polecenie nie stanowi istotnej części skryptu, należy umieścić za nim instrukcję debugującą. Przykład techniki polegającej na stosowaniu polecenia Test-Path został pokazany poniżej:

$script = "c:\fso\mydebugscript.ps1" Test-Path $script # debug $debug = "# debug"

switch -regex -file $script { "debug" { $switch.current } }

Należy zawsze inicjować zmienne, nadając im w razie potrzeby wartość $null lub 0. Stosowanie w tej samej sesji programu Windows PowerShell zmiennych służących do zliczania różnych elementów może prowadzić do otrzymywania nieoczekiwanych rezul-tatów, jeśli zmienne te nie będą poprawnie inicjowane. Przykład takiej sytuacji został zade-monstrowany w pokazanym poniżej skrypcie ParseAppLog.ps1. Skrypt ParseAppLog.ps1 znajduje się na towarzyszącej tej książce płycie CD, w folderze \scripts\extras.

ParseAppLog.ps1$tcp=$udp=$dns=$icmp=$PdnsServer=$SdnsServer=$web=$ssl=$null

$fwlog = get-content "C:\Windows\system32\LogFiles\Firewall\firewall.log" switch -regex ($fwlog) { "65.53.192.15" { $PdnsServer+=1 } "65.53.192.14" { $SdnsServer+=1 } "tcp" { $tcp+=1 } "udp" { $udp+=1 } "icmp" { $icmp+=1 } "\s53" { $dns+=1 } "\s80" { $web+=1 } "\s443" { $ssl+=1 ; $switch.current} }

"`$PdnsServer $Pdnsserver" "`$SdnsServer $SdnsServer" "`$tcp $tcp" "`$udp $udp" "`$icmp $icmp" "`$dns $dns" "`$web $web" "`$ssl $ssl"

Należy używać zmiennej $erroractionpreference do określania akcji podejmowanej podczas wypisywania danych przez skrypt za pomocą polecenia Write-Error lub przez cmdlet albo dostawcę. W tworzonych skryptach należy sprawdzać warunek $erroractionpreference = „SilentlyContinue”. Domyślnie program Windows PowerShell wypi-suje komunikat błędu w chwili wystąpienia tego błędu. Jeśli działanie skryptu powinno być kontynuowane bez wyświetlania komunikatu błędu, należy ustawić dla zmiennej


automatycznej programu Windows PowerShell o nazwie $erroractionpreference wartość SilentlyContinue (Kontynuuj po cichu).

Należy korzystać ze zmiennej $error zapewniającej dostęp do obiektu klasy błędów. Obiekt $error zawiera zapis wszystkich błędów, które wystąpiły dotychczas podczas bieżącej sesji programu Windows PowerShell. Poniżej pokazany został przykład pracy z błędami:

$erroractionpreference = "SilentlyContinue" $a = New-Object foo # powoduje wystąpienie błędu $b = New-Object bar # powoduje wystąpienie jeszcze jednego błędu if ($error.count -eq 1) {"Dotychczas wystąpił 1 błąd"} else {"Dotychczas wystąpiło " + $error.count + " błędów"}

for ($i = 0 ; $error.count ; $i++) {$error[$i].CategoryInfo $error[$i].ErrorDetails $error[$i].Exception $error[$i].FullyQualifiedErrorId $error[$i].InvocationInfo $error[$i].TargetObject}

Należy korzystać z polecenia Set-PSDebug, które umożliwia włączanie i wyłączanie funkcji debugowania skryptów, ustawianie poziomu śledzenia oraz przełączanie trybu ścisłego. Poniżej pokazany został przykład:

C:\PS>set-psdebug -step; foreach ($i in 1..3) {$i}

To polecenie włącza tryb wykonywania krokowego, a następnie uruchamia skrypt wyświe-tlający liczby 1, 2 i 3.

DEBUG:1+ Set-PsDebug -step; foreach ($i in 1..3) {$i} Continue with this operation? 1+ Set-PsDebug -step; foreach ($i in 1..3) {$i} [Y] Yes [A] Yes to All [N] No [L] No to All [S] Suspend [?] Help (default is "Y"):a DEBUG:1+ Set-PsDebug -step; foreach ($i in 1..3) {$i} 1 2 3

Należy pamiętać, że nie wszystkie obiekty tworzy się w jednakowy sposób. Z faktu, że stare obiekty typu COM posiadały metodę o nazwie create() (utwórz), nie wynika jeszcze, że metoda ta istnieje również dla klas programu Windows PowerShell.