Introduction à PowerShell (nom de code Monad)

Testé avec Monad beta3 et PowerShell RC1, le Framework .NET 2.0 et Microsoft Visual Studio 2005 C# Express.
Version 1.0

I-A. Les prérequis▲

I-B. Les sources▲

I-C. Détails de la documentation US de PowerShell RC1▲

I-D. Obtenir de l'aide.▲

PowerShell est un langage de script et un shell interactif offrant une manière de traiter des tâches orientées commande. Les concepteurs ont suivi différentes approches afin que PowerShell soit :

• aussi interactif et composable que KSH ou BASH ;
• aussi programmable que PERL ou RUBY ;
• aussi orienté-production que VMS DCL ou AS400 CL.

PowerShell est compatible avec les précédents langages de scripting. En règle générale, PowerShell exécute tous les commandes et scripts existants. PowerShell n'interprète pas les fichiers .bat ou .cmd, il les dirige vers cmd.exe pour les exécuter.

PowerShell facilitera les tâches d'administration telles que la gestion du paramétrage des composants système imprimante, réseau, IE, la création de comptes utilisateur et les opérations associées…
Suite aux problèmes liés à la sécurité mis en évidence dans la Beta 1, PowerShell se base sur différents niveaux d'autorisation d'exécution. Par exemple avec le niveau AllSigned, seuls les scripts disposant d'une signature autorisée s'exécuteront.

Rien de bien nouveau, me direz-vous par rapport aux solutions existantes (Batch,VBScript,Cygwin…). Nous allons voir ça un peu plus dans le détail, ce qui vous permettra de vous faire une opinion.

PowerShell s'appuie sur la plateforme .NET plus particulièrement sur le Framework 2.0, ce qui signifie que tout est objet sous PowerShell (aussi nommé PS).
Bien que PowerShell.exe soit un programme Win32 il est plus proche d'un loader du runtime .NET, vous pouvez utiliser le débogueur fourni avec .NET 2.0 pour confirmer que PowerShell.exe est bien une application gérée.

Déclarons une variable contenant une chaîne de caractères, puis affichons son contenu, son type et enfin le nom du type :

MSH C:\Temp> $MaVariable="Une chaîne de caractères"
 
MSH C:\Temp> $MaVariable
Une chaîne de caractères
 
MSH C:\Temp> $MaVariable.GetType()
IsPublic IsSerial Name                                     BaseType
-------- -------- ----                                     --------
True     True     String                                   System.Object
 
MSH C:\Temp> $MaVariable.GetType().FullName
System.String

Ici GetType est une méthode de la classe .NET System.Object. On voit qu'il n'est pas nécessaire de déclarer le type de la variable pour l'utiliser ni d'appeler un constructeur pour l'initialiser, le shell se charge de ces opérations afin de nous faciliter l'écriture. Mais il est tout à fait possible d'expliciter ces opérations comme nous le verrons plus loin.

Sans rien déclarer, à part notre variable, nous accédons directement à la richesse du Framework. Toutes les classes accessibles sous .NET le sont donc sous PowerShell, sous réserve de les charger. Le langage de script ne permet pas de définir de nouvelles classes, mais permet d'enrichir une instance avec le système d'extension de type (ETS) qui n'a rien à voir avec les Extension Methods du C#3.0.
On utilisera un assembly pour déclarer de nouvelles classes.

Essayons de créer une fenêtre en appelant son constructeur par l'intermédiaire de la commande New-Object :

MSH C:\Temp> $form = new-object System.Windows.Forms.Form

Cette instruction provoque une erreur, car la classe utilisée n'est pas encore accessible, on doit donc auparavant charger l'assembly l'hébergeant :

MSH C:\Temp> [System.Reflection.Assembly]::LoadWithPartialName("System.Windows.Forms")

Où [System.Reflection.Assembly] est un nom de classe,
::LoadWithPartialName le nom d'une méthode statique effectuant le chargement et
System.Windows.Forms le nom de l'assembly hébergeant la classe Form.

Un autre aspect important concerne la manipulation des collections d'objets qui ici se fait simplement. Par exemple la commande Get-Process renvoie la liste des processus en cours d'exécution :

MSH C:\Temp> $ps=get-process
MSH C:\Temp> $ps[0]
MSH C:\Temp> $ps[0].processname

C'est le point le plus important sous PowerShell, les commandes (plus particulièrement les Cmdlet) manipulent et renvoient des instances de classes .NET. Dans une certaine mesure il n'est plus nécessaire de spécialiser les commandes puisque l'on accède à l'ensemble des informations disponibles de l'objet manipulé.

Ainsi traditionnellement dans un script, on appelait un premier programme pour récupérer le numéro de processus d'une application puis un second programme pour la supprimer. Ici sous PowerShell la méthode Kill de la classe System.Diagnostics.Process est accessible directement.

Le shell Monad (msh.exe) : ligne de commande basée caractères, hébergée par le moteur de Monad.
Le moteur de Monad (msh.dll) :

• Script/Parser : traite les constructions du langage telles que les scripts, les prédicats, les conditions, etc. ;
• Pipeline Processor : gère les communications entre les Cmdlet via des pipes ;
• Command Processor : gère l'exécution des Cmdlets, l'enregistrement et les métadonnées associées ;
• Session State : gère les ensembles de données utilisés par un Cmdlet lors de son exécution ;
• Error et Event Handler : gère les exceptions et les événements ;
• Extended Type System : fournit une interface commune d'accès aux propriétés, méthodes, etc. indépendante du type d'objet sous-jacent.

Remoting (WMX): Web services for Management eXtension, remplacé par (Windows Remote Management) ?

III-A. Qu'est-ce qu'un Cmdlet▲

get-command -Name [string] -Type [CommandTypes] -Verb [string] -Noun [string]

msh> get-command get-command
Command Type    Name                      Definition
------------    ----                      ----------
Cmdlet          get-command               get-command [-Verb String[]] [-Nou...

msh> get-command A B C

msh> get-command -Verb get
Command Type    Name                      Definition
------------    ----                      ----------
Cmdlet          get-command               get-command [-Verb String[]] [-Nou...

[Parameter(Mandatory=true, Position=0)]
public string[] FullName

III-B. Principe de nommage des Cmdlets▲

MSH C:\Temp> get-help object # Retrouve les noms de commande comportant le mot Object
Name                              Category         Synopsis
----                              --------         --------
foreach-object                    Command          Applies script blocks to each object...
where-object                      Command          This Cmdlet filters the input from t...
compare-object                    Command          Compares the properties of objects.
measure-object                    Command          Measures various aspects of objects ...
tee-object                        Command          Sends input objects to two places.
new-object                        Command          [-TypeName] type-name
select-object                     Command          Selects objects based on parameters ...
group-object                      Command          Groups the objects that contain the ...
sort-object                       Command          Sorts the input objects by property ...
write-object                      Command          Writes an object to the pipeline
 
MSH C:\Temp> get-commande -Verb new # Retrouve les noms de commande comportant le verbe New
 
Name                              Category         Synopsis
----                              --------         --------
new-drive                         Command          Installs a new drive on the machine.
new-item                          Command          Creates a new item in a namespace
new-property                      Command          Sets a new property of an item at a ...
new-service                       Command          Creates a new service
new-securestring                  Command          Creates a SecureString object
new-alias                         Command          Creates a new Cmdlet-alias pairing
new-timespan                      Command          Creates a timespan object
new-object                        Command          [-TypeName] type-name
new-variable                      Command          Creates a new variable.

III-C. Les providers▲

PowerShell vous offre la possibilité d'employer un ensemble cohérent de Cmdlets pour parcourir et naviguer sur différents types de structure de données telles que le système de fichiers, la base de registre, Active Directory ou WMI.
Par exemple, vous pouvez employer la même commande pour lister les dossiers d'un répertoire ou énumérer le contenu d'une clé de la base de registre.

Affichons le répertoire courant :

 

Sélectionnez

MSH C:\Temp> dir *.tmp
    Directory: Microsoft.Management.Automation.Core\FileSystem::C:\Temp
 
Mode                LastWriteTime     Length Name
----                -------------     ------ ----
d----        08/04/2006     17:58            SIT19021.tmp
-a---        07/04/2006     09:17        256 ZLT04666.TMP
-a---        10/04/2006     13:16      98304 ~DF2530.tmp

Modifions le provider courant pour celui de la base de registre :

 

Sélectionnez

MSH C:\Temp>  set-location hklm:
MSH HKLM:\> dir HARDWARE
   Hive: Microsoft.Management.Automation.Core\Registry::HKEY_LOCAL_MACHINE\HARDWARE
 
SKC  VC Name                           Property
---  -- ----                           --------
  4   0 ACPI                           {}
  1   0 DESCRIPTION                    {}
  6   0 DEVICEMAP                      {}
  3   0 RESOURCEMAP                    {}

Les providers du shell sont des interfaces logicielles qui présentent le contenu des différentes structures de données dans un format cohérent.
Un provider du shell n'est pas lui-même la structure de données, mais une manière d'accéder aux structures de données au travers des Cmdlets du noyau.
Quand un provider rend disponibles des structures de données, il le fait en créant un ou plusieurs lecteurs (drive) qui semblent contenir toutes ou certaines données stockées.

Par exemple, dans le cas du provider du système de fichiers, il crée un lecteur pour chaque disque de votre système. En conséquence, si vous avez un lecteur C et un lecteur D, le provider du système de fichiers créera des lecteurs PowerShell appelés C et D. En fait, toutes les fois qu'un nouveau lecteur est créé par Windows, y compris un lecteur partagé sur un serveur, le provider du système de fichiers crée un lecteur PowerShell avec le même nom.

Pour visualiser tous les lecteurs disponibles actuellement dans PowerShell, utilisez la commande suivante :

 

Sélectionnez

MSH C:\Temp> get-drive
Name       Provider      Root                  CurrentLocation
----       --------      ----                  ---------------
A          Microsoft.... A:\
Alias      Microsoft....
C          Microsoft.... C:\                   Temp
cert       Microsoft.... \
D          Microsoft.... D:\
E          Microsoft.... E:\
Env        Microsoft....
F          Microsoft.... F:\
Function   Microsoft....
HKCU       Microsoft.... HKEY_CURRENT_USER
HKLM       Microsoft.... HKEY_LOCAL_MACHINE
Variable   Microsoft....

Vous pouvez visualiser les Cmdlets du noyau par la commande Get-Help about_Core_Commands.

Image issue du SDK de PowerShell.

Note
Il est tout à fait possible d'appeler des scripts ou des Cmdlets dans vos applications (pour plus de détails).

III-C-1. ObjectSpace▲

Un espace d'objet est un ensemble d'objets organisés en hiérarchie. Cette hiérarchie est appelée un Drive.
La hiérarchie est composée d'un ensemble de positions identifiées par des chaînes de caractère appelées Path.
La syntaxe pour localiser une position précise est « Drive:Path ».
Il peut y avoir à chaque position un ou plusieurs des éléments suivants : Children, Item, Property, Content, Permission, Relation.

Ce modèle ne normalise pas, pour aucun de ces éléments, la syntaxe d'un chemin ou des structures de données. Les propriétés et le contenu d'une position dans la base de registre sont très différents de ceux d'un système de fichiers ou d'un document XML ou encore d'un chemin Active Directory.
Notez que les chemins peuvent être relatifs ou absolus.

III-D. Le pipelinening▲

echo off
 rem Insère la date système dans une variable 
 
 rem Récupère la date. Le paramètre /T renvoie une ligne contenant 2 "mots"
 rem  le premier = le nom du jour 
 rem  le second = la date 
 rem On place donc le deuxième dans la variable
for  /f "tokens=1-2 " %%A in ('Date /T') do set date=%%B
 
 rem Le séparateur de format de date par défaut est "/"
 rem ce caractère est interdit dans les noms de fichier.
 rem On utilise ce caractère séparateur pour parser la date JJ MM YYYY
 rem Enfin on reconstruit la date avec le nouveau séparateur
 rem On peut utiliser la variable DATE comme nom de fichier.
 rem Attention on code la date sur 10 caractères (2+1+2+1+4)
 rem SOUS XP DATE=jj/mm/aaaa
for  /f "tokens=1-3 delims=/" %%A in ('echo ?TE%') do set date=%%A-%%B-%%C

MSH C:\Temp> $Date=get-date -uformat "%d-%m-%y"

MSH C:\Temp> Get-Process | where { $_.handlecount -gt 400 } | Format-List

III-E. PowerShell et WMI▲

get-wmiobject win32_logicaldisk|format-table deviceid,size,freespace

III-F. L'affichage sur la console▲

Un alias est un raccourci d'un Cmdlet ou d'un exécutable, mais sans ces paramètres (dans la bêta 3 tout du moins). Ils peuvent faciliter l'accès à un exécutable ou associer un terme plus explicite à un Cmdlet. Par exemple la commande DIR est un alias du Cmdlet Get-ChildItem.

La commande Alias permet de retrouver la liste des alias déclarés. Utilisez Help Alias pour afficher les commandes de manipulation d'alias.

Les objets COM peuvent être instanciés par la commande New-Object en précisant le paramètre -com.

$app = new-object -com "Excel.Application"
 $Excel = get-process "EXCEL"
 $Excel.Close

PowerShell propose différents formats de présentation des données, par exemple XML :

   #Lignes en commentaire
   #Exporte les données au format XML
 get-process|Export-clixml MesProcess.XML
 
   #Récupère le contenu du fichier dans une variable
 $a=get-content MesProcess.xml

Voici le contenu du fichier créé :

<Objs Version="1.1" xmlns="http://schemas.microsoft.com/msh/2004/04">
<Obj RefId="RefId-0">
 <TN RefId="RefId-0">
  <T>System.Diagnostics.Process</T>
  <T>System.ComponentModel.Component</T>
  <T>System.MarshalByRefObject</T>
  <T>System.Object</T>
 </TN>
 <Props>
  <I32 N="BasePriority">8</I32>
  <B N="HasExited">false</B>
  <S N="Handle">3152</S>
  <I32 N="HandleCount">101</I32>
  <I32 N="Id">2924</I32>
  <S N="MachineName">.</S>
  ....

Vous pouvez utiliser les commandes Format-Table et Format-List pour manipuler le format CVS par exemple.

Le système d'extension de type (ETS) fournit aux développeurs de Cmdlets et de scripts un mécanisme d'accès uniforme leur permettant de manipuler facilement les différents objets qui transitent entre les Cmdlets, les fonctions, les filtres et les scripts.
En utilisant ETS, les développeurs de Cmdlets et de scripts peuvent manipuler des objets .Net et des données structurées en utilisant la même syntaxe que celle employée par des classes du CLR.

Le langage de script de PowerShell n'est pas typé (typeless), car une variable n'a pas besoin d'être déclarée dans un type particulier. Ceci signifie que les variables créées par un développeur sont par nature sans type. Cependant, le système de PowerShell est piloté par les types (type-driven) parce qu'il dépend des noms de type pour fonctionner.
Par conséquent un développeur de script a besoin de la capacité d'énoncer le type d'une de ses variables et de construire ses propres ensembles d'objets dynamiquement typés qui contiennent des propriétés et des méthodes et pouvant participer au système piloté par les types. ETS résout ce problème en fournissant un objet commun au langage de script qui a la capacité d'énoncer son type dynamiquement et d'ajouter des membres dynamiquement.

Dans certains cas ce système sera utilisé pour créer un alias de propriété sur une classe particulière afin d'homogénéiser l'accès aux données identiques, mais nommées différemment.
Par exemple certaines collections .NET possèdent une propriété nommée length pour déterminer le nombre d'éléments de la collection alors que d'autres ont une propriété nommée Count. Dans ce cas pour faciliter la manipulation de cette information on ajoutera dans le fichier Types.ps1xml l'extension suivante :

<Type>
    <Name>System.Array</Name>
    <Members>
        <AliasProperty>
            <Name>Count</Name>
            <ReferencedMemberName>Length</ReferencedMemberName>
        </AliasProperty>
    </Members>
</Type>

Cet exemple étend le type System.Array. L'affichage des membres du type renvoie désormais :

MSH> Get-Member -inputobject (1,2,3,4)
 
    TypeName: System.Object[]
 
Name               MemberType    Definition
----               ----------    ----------
Count              AliasProperty Count = Length
...
Length             Property      System.Int32 Length {get;}

Note
Ce mécanisme d'extension est possible, car chaque objet que vous employez est encapsulé dans une instance de la classe System.Management.Automation.PSObject.

MSH> $a=Dir
MSH> $a.MshObject
...

L'intégration d'un nouveau Cmdlet se fait soit à l'aide du programme Make-Shell.exe soit à l'aide du mécanisme appelé PSSnapIn.
Make-Shell construit un nouveau shell en intégrant les Cmdlets que vous avez créés. Ceci permet d'avoir plusieurs types de shell dédiés à la gestion des SGBDR, des services Web, etc. Notez que le shell primaire ne peut être modifié.

La commande suivante crée un Shell (exécutable) nommé newshell qui intègre le Cmdlet Get-String défini dans l'espace de nom PDC.Demos.

make-shell -out newshell -namespace PDC.Demos -reference get-string.dll

Il existe une autre possibilité d'extension du shell avec le Cmdlet PSSnapIns. Consultez la documentation de PowerShell pour plus de détails.

PowerShell intègre la vérification des scripts avant leur exécution. La politique de sécurité appliquée aux scripts ou à toutes autres commandes saisies devant être exécutée est régie par la clé de registre suivante :

  HKLM\Software\Microsoft\msh\ShellId\ExecutionPolicy

Pour d'autres informations, consultez l'aide en ligne :

get-help about_signing|more

Le globbing est le développement de caractères spéciaux de remplacement tels que *, ? ou [] utilisés dans une expression.
Cette notion est similaire aux expressions régulières qui elles sont accessibles via le Framework.

Prenons la commande suivante :

MSH> gps [a-c]*,[t-z]* -exclude *[d-t] | stop-process

On arrête ici les process dont le nom commence par abc et tuvwxyz sauf ceux dont le nom finit par les lettres de d à t.
Les shells traditionnels traitent le globbing sur des noms de dossier. Ici comme on travaille sur des objets et leurs propriétés nous avons un nombre de possibilités extraordinairement riches concernant le traitement de remplacement de caractères.

La version actuelle est assez pauvre en raccourcis-clavier espérons que la version 1.0 soit mieux fournie.

Touches de Fonction

Escape annule la saisie en cours.
F1 recopie caractère par caractère la dernière commande.
F2 copie jusqu'au caractère n°.
F3 affiche la dernière commande.
F4 supprime jusqu'au caractère n°.
F5 parcourt les dernières commandes vers le début comme la touche 'flèche vers le haut'.
F6 équivaut à la saisie de control ^Z (fin de fichier ASCII).
F7 liste dans une fenêtre les dernières commandes saisies.
F8 parcourt les dernières commandes vers la fin comme la touche 'flèche vers le bas'.
F9 numéro de commande, cf. F7.

Autres touches

haut de page première commande.
bas de page dernière commande.
tab complétion. c:\te + Tab complète avec le prochain nom fourni par le provider. Tab sans saisie affiche la première entrée fournie par le provider courant.
control-C annule la ligne.
+-!, passe en mode saisie de bloc.
} une accolade fermante suivie de deux retours chariot revient en mode 'commande'.

msh_Scriptomatic, générateur de script.

POWERSHELL ANALYZER RC1, projet autour de PowerShell.

A guided tour of the Microsoft Command Shell (Article très fourni).

Chapitre d'introduction du livre intitulé « Monad » chez OReilly (US).

Un jeu en PowerShell en mode caractères.

PowerShell et le remoting (PowerShell ne supporte pas pour le moment le remoting).

Providers pour Visual Source Safe et SharePoint 2003 sur le site Codeplex.com.