Question [Astuce]Cmt surveiller plusieurs événements WMI ?

Pour surveiller des événéments sous .NET on utilise un objet de la classe ManagementEventWatcher mais il ne surveille qu'un type d'événément, pour en surveiller plusieurs on doit déclarer un evenwatcher par type d'événement.
Sous PS v1 la gestion des événements WMI ne peut se faire nativement qu'en mode synchrone, ce qui fait que le déroulement du script est bloqué tant qu'un événement WMI n'est pas délivré.
On peut se baser sur ce script qui paramètre un timeout d'écoute sur l'eventwatcher afin qu'il rende la main même si aucun événement attendu ne survient pendant le laps de temps défini.

Ce qu'il faut également savoir est que WMI place dans une mémoire tampon les événements reçus afin de les délivrer à tous les clients qui y sont abonnés.
Une fois ce mécanisme enclenché on est assuré de ne pas perdre d'événements, sous réserve que WMI puisse traiter tous ces événements (cf. pooling).
Ainsi les nombreux appel à WaitForNextEvent() au sein d'une boucle revoivent bien tous les événements même si l'eventwatcher n'est pas en écoute au moment où un événement attendu survient.

Ce n'est pas l'appel à la méthode Start() de l'eventwatcher qui démarre la mise en tampon mais le premier appel à WaitForNextEvent().
Ce qui fait que le code suivant est possible :
[code:1]
...
while ($true) {
trap [System.Management.ManagementException] {continue}
$e=$watchProcess.WaitForNextEvent()
$e2=$watchTempDir.WaitForNextEvent()
$e3=$watchEventLog.WaitForNextEvent()
...
[/code:1]
On surveille trois événements WMI :
1-la création de process,
2-la création d'une entrée dans un eventlog,
3-la création de fichier dans le répertoire c:\temp

Une chose importante, l'arrêt et la finalisation :
[code:1]
$watchProcess.Stop()
$watchTempDir.Stop()
$watchEventLog.Stop()

$watchProcess.Dispose()
$watchTempDir.Dispose()
$watchEventLog.Dispose()
[/code:1]
On informe WMI qu'on se désabonne puis on libére les ressources utilisées (objet COM). Sans cela on peut provoquer l'erreur WBEM_E_QUOTA_VIOLATION lors de l'appel à Start().
Voir aussi .

L'accès à certaines classes WMI, par exemple Win32_NTLogEvent, nécessitent l'activation de droits que l'on définit ainsi :
[code:1]
$Evntwatcher.Scope.Options.EnablePrivileges = $true
[/code:1]
Ceci ne donne pas plus de droits que ceux définis pour le compte utilisé, on active seulement ceux dont il dispose.

Le script d'écoute :
[code:1]
Function TestWMIEvents
{ #Surveille trois événements WMI :
# 1-la création de process
# 2-la création d'une entrée dans un eventlog
# 3-la création de fichier dans le répertoire c:\temp

function Get-OwnerOfFile([string]$FullPathName)
{ #Retrouve le propriétaire d'un fichier/directory.
#La syntaxe du nom de fichier est celle de WMI,
#les caractères '\' y sont dupliqués.
gwmi -query \"ASSOCIATORS OF {Win32_LogicalFileSecuritySetting=`\"$FullPathName`\"} WHERE AssocClass=Win32_LogicalFileOwner ResultRole=Owner\"
}


function Pause ($Message=\"Pressez une touche pour continuer...\"«»)
{
Write-Host -NoNewLine $Message
$null = $Host.UI.RawUI.ReadKey(\"NoEcho,IncludeKeyDown\"«»)
Write-Host \"\"
}


function New-EventWatcher($Query,$Path=\"root\cimv2\",[switch]$EnablePrivileges,[switch]$Start)
{ #Crée un eventwatcher avec une requête d'événement

$scope = New-Object System.Management.ManagementScope $Path
$Evntwatcher = New-Object System.Management.ManagementEventWatcher $scope,$query
$options = New-Object System.Management.EventWatcherOptions
# La surveillance s'arrête au bout d'une seconde
$options.TimeOut = [TimeSpan]\"0.0:0:1\"
$Evntwatcher.Options = $Options
if ($EnablePrivileges)
#Certaines classes WMI nécessitent plus de droits
{$Evntwatcher.Scope.Options.EnablePrivileges = $true}
if ($Start)
#Démarre la surveillance
# L'appel à start ne déclenche pas la mise en tampon des événements
{$Evntwatcher.Start()}
$Evntwatcher
}
#Gestion de la touche escape ou 'Q' du clavier
$ESCkey = 27
$Qkey = 81

#Il est préférable que la clause WITHIN ([TimeSpan]\"0:0:1\"«») ait la même valeur
$Query=New-object System.Management.WqlEventQuery(\"__InstanceCreationEvent\", [TimeSpan]\"0:0:1\",'TargetInstance isa \"Win32_Process\" and TargetInstance.Name = \"notepad.exe\"')
$watchProcess=New-EventWatcher $Query -Start

$Query = New-object System.Management.WqlEventQuery(\"__InstanceCreationEvent\", [TimeSpan]\"0:0:1\",'TargetInstance isa \"Win32_NTLogEvent\"')
$watchEventLog=New-EventWatcher $Query -EnablePrivileges -Start

$RepAMonitorer = \"C:\Temp\".Replace(\"\\", \"\\\\\"«»)
$WhereClause=(\"Targetinstance ISA 'CIM_DirectoryContainsFile' and TargetInstance.GroupComponent='Win32_Directory.Name=`\"{0}`\"'\" -F $RepAMonitorer)
$Query = New-object System.Management.WqlEventQuery(\"__InstanceCreationEvent\", [TimeSpan]\"0:0:1\",$WhereClause)
$watchTempDir=New-EventWatcher $Query -Start

while ($true) {
trap [System.Management.ManagementException] {continue}
$e=$watchProcess.WaitForNextEvent()
$e2=$watchTempDir.WaitForNextEvent()
$e3=$watchEventLog.WaitForNextEvent()

#Si aucun événement n'est délivré on reçoit $null
if ($e -ne $null)
{
write-host (\"Le process {0} a été crée, son chemin est : {1}\" -F $e.TargetInstance.Name,$e.TargetInstance.ExecutablePath)
$e=$null
}

if ($e2 -ne $null)
{
if ($e2.TargetInstance.PartComponent -match '^(.*)=\"(.*)\\"$')
{
#Nom de fichier complet normé WMI
$WMIFullName=$matches[2]
#Nom de fichier complet normé Windows
$FullName=$WMIFullName.Replace('\\','\')
#Nom de fichier uniquement
$FileName=Split-Path $FullName -Leaf
$AccountName=(Get-OwnerOfFile $WMIFullName).AccountName
Write-Host (\"Le compte {0} a créé le fichier : {1}\" -f $AccountName,$FileName)
}
$e2=$null
}

if ($e3 -ne $null)
{
write-host \"Eventlog détecté: $($e3.targetInstance.Message)\"
$e3=$null
}

if ($host.ui.RawUi.KeyAvailable)
{
#On gére la touche escape,
#la combinaison \"Control-C\" ne peut être trappée
$key = $host.ui.RawUI.ReadKey(\"NoEcho,IncludeKeyUp\"«»)
if (($key.VirtualKeyCode -eq $ESCkey) -OR ($key.VirtualKeyCode -eq $Qkey))
{
Write-host \"Arrêt de la surveillance et finalisation\"
$watchProcess.Stop()
$watchTempDir.Stop()
$watchEventLog.Stop()
#On libére les ressources .NET et WMI sinon possible
#erreur WBEM_E_QUOTA_VIOLATION (0x8004106C ) lors de
#l'appel à Start()
$watchProcess.Dispose()
$watchTempDir.Dispose()
$watchEventLog.Dispose()
break
}
}#if KeyAvailable
}#while
}

TestWMIEvents
[/code:1]
Le script de tests a exécuter dans une seconde console PowerShell :
[code:1]
#Ne pas oublier de créer les deux fonctions utilisées.

#ATTENTION à ne pas remplir l'eventlog sélectionné ;«»-)
function New-EventLogEntryType([string]$EventLogName=\"Application\"«»)
{ #crée un événement de test dans l'eventlog $EventLogName

$Event=new-object System.Diagnostics.EventLog($EventLogName)
$Event.Source=\"TestEventWatcher\"
$Event.WriteEntry(\"Test événement WMI sous PowerShell\",[System.Diagnostics.EventLogEntryType]::Information)
}

function Start-Process([string]$Path)
{
[diagnostics.process]::«»start($Path)
}

#puisqu'on écoute la création de fichier on supprime les fichiers de tests existants.
del c:\temp\PSTest*.txt
1..10|% {Start-Process Notepad.exe;\"test\" > \"c:\temp\PSTest$_.txt\";New-EventLogEntryType}
[/code:1]
Selon le paramètrage de la clause WQL Within (ex: Within 10) on peut recevoir des événements désynchronisés et par rafale.
On peut placer des temporisation pour y remédier plus ou moins :
[code:1]
...
#Permet de constater la mémorisation des événements
#start-sleep 2

#Si on recoit des événements désynchronisés et par rafale, le délai de 200 ms permet de les \"resynchroniser\", à-peu-prés.
#start-sleep -m 200
#start-sleep -s 2 les \"resynchronise\" complètement
if ($host.ui.RawUi.KeyAvailable)
...
[/code:1]
Pour tracer le déroulement vous pouvez également modifier cette partie du script :
[code:1]
Write-Warning \"Début d'écoute\"
$d1=get-date
# La première écoute déclenche la mise en tampon des événements
$e=$watchProcess.WaitForNextEvent()
$e2=$watchTempDir.WaitForNextEvent()
$e3=$watchEventLog.WaitForNextEvent()
\"Temps d'attente : $(((get-date)-$d1).Seconds) s\"
Write-Warning \"Fin d'écoute\"
[/code:1]
Ou encore ajouter des compteurs pour contrôler la réception de chaque type d'événéments :
[code:1]
if ($e -ne $null)
{
$j++
write-host \"[Notepad $j]\"
$e=$null
}
[/code:1]
Une solution telle que PSEventing est certes plus élégante et d'une conception plus approprié à la surveillance, mais cette solution est native et démontre certaines limites de PowerShell.
Je n'ai pas testé l'exécution de ce script sur plusieurs jours ce qui permettrait de vérifier s'il provoque des erreurs de quotas WMI.



[edit]
On crée une source d'événement ainsi :
[code:1][System.Diagnostics.EventLog]::CreateEventSource(\&quot;TestEventWatcher\&quot;,'Application')[/code:1]<br><br>Message édité par: Laurent Dardenne, à: 29/06/09 16:47

En utilisant les runspaces , on peut simplifier le code tout en cloisonnant la gestion de chaque événement.
[code:1]
#Flag d'arrêt
[boolean]$StopRSWatchProcess=$False

#Référence sur le flag d'arrêt
Set-Variable -name isRSWatchProcess -value ([ref]$StopRSWatchProcess) -option readOnly -scope global -description \&quot;Pointeur sur `$StopRSWatchProcess\&quot;

$RSWatchProcess=New-RunSpace -interactWithHost {
#Lit une variable dans le runspace ayant crée ce code, c'est à dire PowerShell.exe
$Stop=$executionContextProxy.SessionState.PsVariable.Get(\&quot;isRSWatchProcess\&quot;«»).Value
if ($Stop.Value)
{return}

$Query =New-object System.Management.WqlEventQuery(
\&quot;__InstanceCreationEvent\&quot;,
[TimeSpan]\&quot;0:0:1\&quot;,
'TargetInstance isa \&quot;Win32_Process\&quot;')
$Scope = New-Object System.Management.ManagementScope \&quot;root\cimv2\&quot;
$Watcher = New-Object System.Management.ManagementEventWatcher $Scope,$Query
$Options = New-Object System.Management.EventWatcherOptions
# Quitte l'écoute après 5 seconde d'attente
$Options.TimeOut = [timespan]\&quot;0.0:0:5\&quot;
$Watcher.Start()

While ($Stop.Value -eq $False) {
$Event = $watcher.WaitForNextEvent()
Write-Host $(\&quot;Le processus {0} a été créé. Son path est : {1}\&quot; -F $Event.TargetInstance.Name, $Event.TargetInstance.ExecutablePath)
} #While

#Annule l'abonnement
$Watcher.Stop()
#Libére les ressources
$Watcher.Dispose()
Write-host \&quot;Fin de la surveillance\&quot;
} #$RSWatchProcess

$RSWatchProcess.InvokeAsync($RSWatchProcess.Command);
sleep 1
[void][diagnostics.process]::«»start(\&quot;cmd\&quot;,\&quot;/C ping ServerInconnu\&quot;«»)
sleep 1
[void][diagnostics.process]::«»start(\&quot;cmd\&quot;,\&quot;/C ping ServerInconnu\&quot;«»)

#Termine le runspace lors de la prochaine exécution de la boucle
$StopRSWatchProcess=$true

# On attend 5+1 secondes avant de clore le runspace
Sleep 6
$RSWatchProcess.Runspace.Close()
[/code:1]