(le message  d’erreur vient d’un fichier en cours d’écriture)

Après avoir mis cela au point sur la ligne de commande comme ci-dessus, je met cette commande dans un fichier de script pour la réutiliser plus tard :

On peut noter dans le script la barre verticale, indiquant un pipeline. Le pipeline passe la sortie de la première commande (la liste de fichier résultant de dir) à la deuxième commande qui consiste en un foreach. Dans le bloc du foreach on référence l’objet courant (le fichier) avec la variable spéciale $_.  foreach est un alias pour ForEach-Object (et peut encore se raccourcir en « % », comme dans l’exemple ci-dessous).

Simple, non ?

Un autre exemple dans la même veine consiste à supprimer les fichiers .DATA générés par mes expériences, mais pas trop tôt afin de ne pas interférer avec les analyses en cours – j’attends donc 30 minutes par exemple. Voici un script pour faire cela (j’ai encadré en rouge le calcul sur les dates) :

Voilà le résultat sur la console :

Il restera à mieux formater le taux de génération !

Le même script sous forme de code copiable, au cas où ca vous intéresse de le récupérer :

$DELAY=60*15

$total_deleted = 0

while ($True) {
    $deleted = 0
    dir c:\data -recurse -include *.data | % { 
        if ( ((get-date)-$_.LastWriteTime).TotalMinutes -gt 30) {
                del $_ ; $deleted += 1
        }
    }
    $total_deleted += $deleted
    $generation_rate = ($deleted / $DELAY) * 60
        
    write-host (get-date), `
                "total already deleted ", $total_deleted, `
                " generation rate ", $generation_rate, " / minute"
                
    Sleep -Seconds $DELAY        
}

Voilà des exemples que j’aurais été bien incapable de réaliser en DOS, et qui sont très faciles à faire en PowerShell.

Et vous, quels sont les scripts qui vous simplifient la vie ?

Malheureusement c’est un outil bien peu ergonomique, et assez fastidieux à régler (on peut tout de même sauver les paramètres dans un fichier .msc, afin de ne pas tout recommencer à zéro à chaque fois). En particulier je déteste le choix des compteurs dans des listes déroulantes minuscules

ainsi que le choix des échelles pour lesquelles il faut compter les chiffres à la main (pas bien agréable quand les compteurs sont dans les 10000000 ou les 1000000000) :

De plus on ne peut pas faire afficher des calculs complémentaires – souvent j’aimerais voir l’écart entre deux mesures successives, afin de connaître la « vitesse » de l’évolution du compteur.

Aussi j’utilise de plus en plus PowerShell pour mes activités de surveillance de processus. Voici par exemple un petit script qui suit la mémoire utilisée.

Tout d’abord j’ai mis au point le principe directement sur la ligne de commande (le processus à surveiller est nxServer.exe) :

Notez que PowerShell manipule directement 1GB, 1MB, 1KB, xKB. Bien pratique pour ne pas se prendre la tête avec les grands nombres.

Une fois satisfait du principe, j’ai sauvé la ligne de commande dans un fichier :

fichier que j’ai ensuite édité avec PowerGUI Script Editor pour ajouter quelques fonctionnalités supplémentaires (affichage à l’écran + sauvegarde dans un fichier, calcul de la différence entre deux mesures successives) :

Et voilà :

Bon d’accord ce n’est plus très utile de diviser par 1GB, j’ai corrigé la fuite mémoire qui faisait que l’on dépassait le Giga – mais je n’ai pas envie de la réintroduire juste pour la démo !

Pour montrer comment j’utilise PowerShell (le shell remplaçant DOS, et développé par Microsoft sur .NET), voici un petit exemple de lancement de programme en boucle. C’est le script que j’utilise en ce moment pour essayer de reproduire un gel d’un de nos logiciels qui est constaté chez un client.

[Contexte : ce gel arrive 2 à 3 fois par an, et uniquement chez ce client – la fréquence d’apparition est donc très faible, c’est pourquoi je suis conduit à faire des centaines de milliers d’exécution pour essayer de le reproduire – et c’est pourquoi l’automatisation via PowerShell est très utile]

Ce script maintient en exécution simultanée x instances d’un programme donné, jusqu’à ce qu’on parvienne à un nombre donné de lancements.

Ce premier fragment de code ci-dessous montre plusieurs aspects intéressants de PowerShell :

• on peut écrire des fonctions
• on dispose d’environnements de développement modernes, comme PowerGUI par exemple
• on a un accès direct au framework .NET, comme le montre l’appel [diagnostics.process]::start : comme il n’y a pas de commande équivalent dans le shell, on fait faire le travail par .NET directement
• on manipule des objets (voir les appels de méthodes comme .Count)
• les opérateurs booléens ne sont pas très naturels : -eq, -lt, -ge etc. C’est mon seul reproche à ce langage !

Note : quand je fais ces essais directement sur mon PC, j’ai constaté qu’il  était très utile de baisser un peu la priorité des processus, afin de garder un certain contrôle sur le PC. Voici comment faire :

Voici maintenant le reste du script qui utilise les fonctions ci-dessus, une simple boucle :

Le langage fournit donc tout ce que que l’on peut espérer d’un langage de programmation moderne. Il est sans doute possible de faire tout cela en DOS, mais explorer DOS m’a toujours paru au dessus de mes forces ! Dans le passé j’ai toujours préférer travailler avec cygwin pour profiter des possibilités de scripts à la Unix – ce n’est plus justifié aujourd’hui avec PowerShell, une bonne solution native sous Windows !

Note 27 janvier 2010 : merci à Laurent Dardenne de m’avoir signalé les liens erronés vers les images.

Vous savez sans doute que je suis un fan des langages de scripts : Python (utilisé avec succès dans certains satellites de nos applications comme un outil d’export générique, ou des extensions de calcul spécialisées), Ruby (pour apprendre le BDD avec Cucumber), mais ces derniers sont peu pratiques quand il s’agit d’interagir avec Windows.

C’est pourquoi je poursuis mon apprentissage de PowerShell : c’est un langage de script moderne complètement intégré à Windows, notamment parce qu’il accède facilement à .NET.

L’exemple du jour : je dois souvent nettoyer le journal d’événements Windows « Custom » (créé durant l’installation de nos logiciels pour permettre à nos applications de centraliser leurs événements).

Or c’est assez fastidieux depuis l’application Windows standard (et même avec l’application spécialisée Event Log Explorer que nous utilisons dans l’équipe Support) : il faut un clic droit, puis répondre Non à la question « voulez-vous sauver le journal avant de l’effacer ? ». Quand vous faites ca toute la journée c’est fatiguant. et puis on finit par oublier de faire ces opérations, le journal d’événements devient difficile à analyser, etc.

C’est là que PowerShell intervient : comme .NET fournit une classe EventLog bien pratique pour interagir avec les journaux d’événements, on peut y accéder en PowerShell :

J’ai utilisé Get-Member simplement pour me persuader que j’avais bien sous la main ce que je cherchais :

et donc ensuite j’ai appelé Clear() qui m’évite de faire l’opération à la main.

En fait il y a encore plus simple que mon idée de faire appel à une classe .NET. En effet PowerShell dispose directement de commandes pour interagir avec les journaux d’événements. Ce n’est pas étonnant car c’est quand même un outil d’administration Windows.

Voici donc la méthode la plus directe :

Et c’est donc la commande que je vais insérer au début de mes scripts de tests ! Fini les clics inutiles !

Note : j’ai trouvé l’idée du Clear-EventLog grâce à cet article sur ITPro.fr : Powershell, une ligne de commande qui a su se faire désirer – c’est aussi un très bon article pour démarrer avec PowerShell.