Première approche de PowerShell

Comme indiqué dans le tutoriel cité, les providers proposent un accès à différentes informations sur un mode commun.
Par exemple déplaçons-nous dans l'espace de noms des variables d'environnement :

PS C:\WINDOWS\system32\windowspowershell\v1.0> Set-Location ENV:
PS Env:\> (get-location).provider

Name                 Capabilities                                      Drives
----                 ------------                                      ------
Environment          ShouldProcess                                     {Env}

Revenons dans l'espace de noms du disque C :

PS Env:\> Set-Location C:
PS C:\WINDOWS\system32\windowspowershell\v1.0> (Get-Location).Provider

Name                 Capabilities                                      Drives
----                 ------------                                      ------
FileSystem           Filter, ShouldProcess                             {C, G, D, E...}

PowerShell propose des alias de cmdlet facilitant leur prise en main. La liste complète est accessible via l'appel de Get-Alias :

PS C:\WINDOWS\system32\windowspowershell\v1.0> Get-Alias cd,dir

CommandType     Name                                                Definition
-----------     ----                                                ----------
Alias           cd                                                  Set-Location
Alias           dir                                                 Get-ChildItem
PS C:\WINDOWS\system32\windowspowershell\v1.0> Get-Alias|More
...

Sous PowerShell le cmdlet, ou commandelet, Get-Childitem retrouve les éléments et les éléments enfants gérés par le provider de l'emplacement courant.
Pour retrouver l'emplacement courant, on utilise Get-Location :

PS C:\WINDOWS\system32\windowspowershell\v1.0> Get-Location

Path
----
C:\WINDOWS\system32\windowspowershell\v1.0

Pour obtenir tous les fichiers du répertoire courant et de ses sous-répertoires, nous utiliserons Get-ChildItem avec l'option -recurse. Nous pouvons interroger l'aide en ligne afin de retrouver les paramètres et options que ce cmdlet met à notre disposition :

PS C:\Temp> help Get-ChildItem -detail

Sous PowerShell les paramètres sont ordonnés et attendent une valeur alors qu'une option influence le traitement du cmdlet sans pour autant être obligatoire.

Pour faciliter l'écriture et l'exécution de notre recherche, déclarons une variable, $MesFichiers, contenant notre suite d'instruction :

PS C:\Temp>  $MesFichiers=Get-ChildItem -recurse

Sous PowerShell il n'est pas nécessaire d'allouer les variables avant leur utilisation.
On déclare une variable par la saisie de son nom, MesFichiers, préfixé du signe $, suivi du signe = puis de son contenu. Enfin la saisie d'un retour chariot finalise sa déclaration.

Pour exclure un ou plusieurs types de fichiers, ajoutons cette fois-ci un paramètre -Exclude suivi des noms de fichiers :

PS C:\Temp>  $MesFichiers=Get-ChildItem -recurse -exclude *.tmp,*.bak

Comme vous avez pu le remarquer, les répertoires sont compris dans le résultat de notre recherche.
On doit donc trouver une particularité qui distingue un nom de fichier d'un nom de répertoire. PowerShell étant basé-objet nous pouvons interroger les objets manipulés. Pour retrouver une propriété d'un objet on utilise le cmdlet Get-Member, regardons ce qu'il nous propose :

PS C:\Temp> help Get-Member -detail

On peut donc filtrer l'affichage des membres d'une classe en utilisant le paramètre -MemberType :

PS C:\Temp>  Get-Childitem|Get-Member -Membertype *property

Le cmdlet nous renvoie le nom, le type et les propriétés définies dans la classe .NET sous-jacente correspondant aux objets manipulés.
Get-Member traite chaque occurrence des classes manipulées, à savoir les classes DirectoryInfo et FileInfo :

   TypeName: System.IO.DirectoryInfo
...
   TypeName: System.IO.FileInfo

Name              MemberType     Definition
----              ----------     ----------
PSChildName       NoteProperty   System.String PSChildName=certificate.format.ps1xml
...
Attributes        Property       System.IO.FileAttributes Attributes {get;set;}
...
Mode              ScriptProperty System.Object Mode {get=$catr = "";...
Name              Property       System.String Name {get;}

Remarquez que certaines propriétés sont en lecture seule {get;}.

Les propriétés de type NoteProperty de la classe FileInfo, jouent un rôle particulier, en dehors du fait qu'elles commencent toutes par PS, elles sont ajoutées par le provider pour faciliter les traitements.
La propriété PSIsContainer de type booléen détermine si l'instance, renvoyée par Get-Childitem, est un containeur ou pas. Cette propriété se retrouve pour chaque élément fourni par le provider manipulant un espace de noms. Ce qui est confirmé par les instructions suivantes :

PS C:\Temp> cd HKCU:;Get-Childitem|Get-Member -membertype *property;C:

Pour en revenir à notre propriété, filtrons les fichiers en l'utilisant :

PS C:\Temp> $MesFichiers=Get-ChildItem -recurse -exclude *.tmp,*.bak|Where-Object {$_.PSIsContainer -eq 0}

Where-Object, ou l'alias Where ou encore le raccourci %, filtre, sur une ou plusieurs propriétés, les objets reçus via le pipe.
Les caractères $_ représentent l'occurrence courante renvoyée par Get-ChildItem. Le code entre accolades est appelé un bloc de code (scriptblock).

Pour rechercher un objet répondant à un critère particulier, utilisons Where-Object.

II-C-1. Principe de base du Pipelining▲

Comme nous le dit la documentation fournie (C:\WINDOWS\system32\windowspowershell\v1.0\fr\userguide.rtf) :

… Un pipeline agit comme une série de segments de canal connectés. Les éléments qui parcourent le pipeline passent par chaque segment. Pour créer un pipeline dans Windows PowerShell, vous connectez des commandes au moyen de l'opérateur de pipeline (la barre verticale « | ») et la sortie de chaque commande est utilisée comme entrée de la suivante.

PowerShell est construit de telle manière que les données, c'est-à-dire des objets, transitent d'une commande à une autre sans être transformées au format texte. C'est seulement quand le texte est nécessaire qu'une conversion de l'objet est faite.

Reprenons l'objectif en cours, retrouver le nom complet du fichier. Le résultat de la commande précédente n'est pas très exploitable ainsi. Réutilisons la commande Get-Member en sélectionnant uniquement les propriétés (property), sans connaitre le Framework dotnet on peut sans trop se tromper se dire que la propriété FullName répond à notre besoin. Par prudence la consultation de la documentation nous confirmera son contenu.
Vérifions-le en ajoutant un second filtre :

PS C:\Temp> $MesFichiers=Get-ChildItem -recurse -exclude *.tmp,*.bak|where-object {$_.PSIsContainer -eq 0}|foreach {$_.Get_FullName()}

L'étape suivante consiste à retrouver la date du dernier accès d'un fichier, il s'agit de la propriété de la classe FileInfo nommée LastWriteTime, ajoutons-la en paramètre au dernier filtre :

PS C:\Temp> $MesFichiers=Get-ChildItem -recurse -exclude *.tmp,*.bak|where-object {$_.PSIsContainer -eq 0}|`
 foreach {$_.get_Fullname(), $_.LastWriteTime}

II-E-1. Une histoire de date▲

PS C:\Temp> Date

PS C:\Temp> Dir Alias:|Sort

PS C:\Temp> Dir Functions:|Sort

PS C:\Temp> Dir Variable:|Sort

PS C:\Temp> Set-psDebug -trace 2 -step

Active et désactive les fonctions de débogage, définit le niveau de suivi et active/désactive le mode strict.

PS C:\Temp> Voulez-vous continuer cette opération ?
   1+ date
[O] Oui  [T] Oui pour tout  [N] Non  [U] Non pour tout  [S] Suspendre  [?] Aide (la valeur par défaut est « O ») :

DÉBOGUER :    1+ date
 DÉBOGUER :    1+ if ($this.DisplayHint -ieq  "Date")
 DÉBOGUER :   11+                         "{0} {1}" -f $this.ToLongDateString(), $this.ToLongTimeString()
 DÉBOGUER :     ! CALL method 'System.String ToLongDateString()'
 DÉBOGUER :     ! CALL method 'System.String ToLongTimeString()'

PS C:\Temp> Set-psDebug -trace 0

Comme vous prenez goût aux tours et détours sous PowerShell, allons faire un tour cette fois-ci du côté de chez dotNET.
Maîtriser Powershell ne peut se faire qu'au travers de la connaissance des fonctionnalités de ce framework.
Pour retrouver notre information, nous utiliserons la classe DateTime. Inspectons cette classe comme nous l'avons déjà fait :

PS C:\Temp> DateTime|gm

On obtient l'erreur :

Le terme « datetime » n'est pas reconnu en tant qu'applet de commande, fonction, programme exécutable ou fichier de script. Vérifiez le terme et réessayez.

Bon ce n'est pas ça, essayons avec Get-Date :

PS C:\Temp> Get-Date|gm

C'est déjà mieux. Ah oui j'ai oublié de vous dire que le cmdlet Get-Date existait ;-) :

PS C:\Temp> Get-Command *Date*

Récupérons maintenant la date du jour, mais en utilisant la méthode statique Now, Get-Date renvoie une instance de la classe DateTime. L'affichage de Get-Member ne signalant pas par défaut les méthodes statiques, ajoutons l'option -static :

PS C:\Temp> [DateTime]|gm -static

Comme vous le voyez pour signaler l'accès aux informations d'une classe il faut placer son nom entre crochets.
Appelons la méthode statique Now :

PS C:\Temp> [DateTime].Now()

mais cet appel nous renvoie :

L'appel de la méthode a échoué parce que [System.RuntimeType] ne contient pas de méthode nommée « Now ».

Les concepteurs du langage ont préféré une syntaxe différente pour les appels des méthodes statiques, à la place du point on double le caractère deux-points :

PS C:\Temp> [DateTime]::Now

samedi 12 mai 2007 14:09:22

À y regarder de plus près, le résultat ne convient pas, car l'heure actuelle faussera les résultats. Essayons la méthode Today :

PS C:\Temp> [DateTime]::Today

C'est parfait, car l'heure est bien à 00.00.00, l'heure d'exécution de notre script n'entrera pas en ligne de compte dans le résultat final seulement la date. Dernier point, retrouver une date dans le passé. À première vue, en consultant la documentation .NET, nous avons la méthode AddDays :

PS C:\Temp> [DateTime]::Today.AddDays(7)

nous venons de découvrir le script qui manipule les fichiers de la semaine prochaine, d'un intérêt pratique quasi nul dans notre contexte, je vous l'accorde ;-)
Au cas où, vérifions la documentation de la classe DateTime :

value
A number of whole and fractional days. The value parameter can be negative or positive.

Bonne pioche !

PS C:\Temp> [DateTime]::Today.AddDays(-7)

PS C:\Temp> Set-ItemProperty -path FileSystem::C:\Temp\Test.txt -name LastWriteTime -value ([DateTime]::Now)

En regardant le résultat de Get-Member sur la classe DateTime, l'affichage des informations de la méthode ToDay indique que le type du résultat qu'elle renvoie est du même type que la classe qu'on manipule, c'est-à-dire DateTime :

Todays  Property   System.DateTime Now {get;}

Dans ce cas on peut donc appeler plusieurs méthodes sans avoir à utiliser de variable intermédiaire :

PS C:\Temp> [DateTime]::Today.AddDays(-7)

Il nous reste à réorganiser notre expression :

PS C:\Temp> $MesFichiers=Get-ChildItem -recurse -exclude *.tmp,*.bak|where-object {$_.PSIsContainer -eq 0}|`
 where {$_.LastWriteTime -ge [DateTime]::today.adddays(-7)}

Pensez à vous placer dans un répertoire contenant au moins un fichier modifié il y a une semaine.

La validation de cette instruction, par entrée, effectue le traitement, mais n'affiche pas le résultat, car il est mémorisé dans la variable $MesFichiers.

PS C:\Temp> $MesFichiers

    Répertoire : Microsoft.PowerShell.Core\FileSystem::C:\WINDOWS\Debug\UserMode

Mode                LastWriteTime     Length Name
----                -------------     ------ ----
-a---        07/05/2007     19:00     183776 userenv.log 
...

Cette variable contient une collection d'objets, ce que confirme l'appel de la méthode GetType (fournie par la classe Object) :

PS C:\Temp> $MesFichiers.GetType().FullName
System.Object[]

Chaque élément étant du type FileInfo :

PS C:\Temp> $MesFichiers[0].GetType().FullName
System.IO.FileInfo

On peut aussi retrouver le nombre d'éléments de cette collection :

PS C:\Temp> $MesFichiers[0].Length

Rappelez-vous que la variable $MesFichiers contient un résultat correct au moment de son exécution, mais le système de fichiers d'un serveur évolue rapidement.

System.Object[] # Tableau d'objets

Si on souhaite récupérer uniquement le nom complet du fichier, par exemple pour passer cette liste à un outil tiers, on utilisera la méthode Get_FullName de la classe FileInfo :

PS C:\Temp> Dir|ForEach {$_.Get_Fullname}

Ici il est nécessaire de préciser l'appel d'une méthode par l'ajout, après le nom de la méthode, de deux parenthèses :

PS C:\Temp> Dir|ForEach {$_.Get_Fullname()}

car dans le premier cas l'analyse lexicale de PowerShell considère l'instruction comme une recherche d'informations sur la méthode de la classe alors que dans le second elle la considère comme un appel à la méthode.

Il reste possible de mémoriser cette liste dans un fichier texte via le cmdlet Out-File qui se retrouvera toujours en dernière position tout simplement parce qu'il ne gère pas le pipelining :

PS C:\Temp> Out-File C:\Temp\Result.txt