Monitorar e responder a eventos com consumidores padrão

Você pode usar as classes de consumidor padrão instaladas para executar ações com base em eventos em um sistema operacional. Os consumidores padrão são classes simples que já estão registradas e que definem classes de consumidor permanentes. Cada consumidor padrão executa uma ação específica depois de receber uma notificação de evento. Por exemplo, você pode definir uma instância de ActiveScriptEventConsumer para executar um script quando o espaço livre em disco em um computador for diferente de um tamanho especificado.

O WMI compila os consumidores padrão em namespaces padrão que dependem do sistema operacional, por exemplo:

• No Windows Server 2003, todos os consumidores padrão são compilados por padrão no namespace "Root\Subscription".

Observação

Para os namespaces e sistemas operacionais padrão específicos para cada classe do WMI, consulte as seções Comentários e Requisitos de cada tópico de classe.

 

A tabela a seguir lista e descreve os consumidores padrão do WMI.

Consumidor padrão	Descrição
ActiveScriptEventConsumer	Executa um script quando recebe uma notificação de evento. Para obter mais informações, consulte Executar um script com base em um evento.
LogFileEventConsumer	Escreve cadeias de caracteres personalizadas em um arquivo de log de texto quando recebe uma notificação de evento. Para obter mais informações, consulte Escrever em um arquivo de log com base em um evento.
NTEventLogEventConsumer	Registra uma mensagem específica no log de eventos do aplicativo. Para obter mais informações, confira Registrar em um log de eventos NT com base em um evento.
SMTPEventConsumer	Envia uma mensagem de email usando SMTP sempre que um evento é entregue a ele. Para obter mais informações, confira Enviar email com base em um evento.
CommandLineEventConsumer	Inicia um processo quando um evento é entregue a um sistema local. O arquivo executável deve estar em um local seguro ou protegido por uma ACL (lista de controle de acesso) forte para impedir que um usuário não autorizado substitua o executável por outro executável. Para obter mais informações, confira Executar um programa com a linha de comando com base em um evento.

 

O procedimento a seguir descreve como monitorar e responder a eventos usando um consumidor padrão. Observe que o procedimento é o mesmo para um arquivo MOF (Managed Object Format), um script ou um aplicativo.

Para monitorar e responder a eventos com um consumidor padrão

1. Especifique o namespace em um arquivo MOF usando o comando de pré-processador MOF #pragma namespace. Em um script ou aplicativo, especifique o namespace no código que se conecta ao WMI.

   O exemplo de código MOF a seguir mostra como especificar o namespace root\subscription.

   #pragma namespace ("\\\\.\\root\\subscription")
   

   A maioria dos eventos intrínsecos está associada a alterações nas instâncias de classe no namespace root\cimv2. No entanto, eventos do Registro, como RegistryKeyChangeEvent, são acionados no namespace root\default pelo Provedor do Registro do Sistema.

   Um consumidor pode incluir classes de evento localizadas em outros namespaces especificando o namespace na propriedade EventNamespace na consulta __EventFilter em busca de eventos. As classes de eventos intrínsecos, como __InstanceOperationEvent estão disponíveis em todos os namespaces.

2. Crie e preencha uma instância de uma classe de consumidor padrão.

   Essa instância pode ter um valor exclusivo na propriedade Name. Você pode atualizar um consumidor existente reutilizando o mesmo nome.

   InsertionStringTemplates contém o texto a ser inserido em um evento especificado em EventType. Você pode usar cadeias de caracteres literais ou se referir diretamente a uma propriedade. Para obter mais informações, consulte Usar modelos de cadeia de caracteres padrão e Instrução SELECT para consultas de evento.

   Use uma origem existente para o log de eventos que dê suporte a uma cadeia de caracteres de inserção sem texto associado.

   O exemplo de código MOF a seguir mostra como usar uma fonte existente do WSH e um valor EventID igual a 8.

   instance of NTEventLogEventConsumer as $Consumer
   {
       Name = "RunKeyEventlogConsumer";
       SourceName = "WSH";               
       EventID = 8;
       // Warning                              
       EventType = 2;
       // One string supplies the entire message          
       NumberOfInsertionStrings = 1;             
       // the %Hive% and %KeyPath% are properties of
       // the RegistryKeyChangeEvent instance 
       InsertionStringTemplates = 
           {"The key %Hive%\\%RootPath% has been modified."
           "Check if the change is intentional"};
   };
   

3. Crie uma instância de __EventFilter e defina uma consulta de eventos.

   No exemplo a seguir, o filtro monitora a chave do Registro em que os programas de inicialização são registrados. O monitoramento dessa chave do Registro pode ser importante porque um programa não autorizado pode se registrar na chave, podendo ser iniciado quando o computador é inicializado.

   instance of __EventFilter as $Filter
   {
   Name = "RunKeyFilter";
   QueryLanguage = "WQL"; 
   Query = "Select * from RegistryTreeChangeEvent"
       " where (Hive = \"HKEY_LOCAL_MACHINE\" and "
       "RootPath = \"Software\\\\Microsoft\\\\Windows"
       "\\\\CurrentVersion\\\\Run\")";
   
   // RegistryTreeChangeEvents only fire in root\default namespace
   EventNamespace = "root\\default";                       
   };
   

4. Identifique um evento para monitorar e criar uma consulta de evento.

   Você pode conferir se há um evento intrínseco ou extrínseco que usa. Por exemplo, use a classe RegistryTreeChangeEvent do provedor do Registro para monitorar as alterações no Registro do sistema.

   Se não existir uma classe que descreva um evento que você precisa monitorar, crie seu próprio provedor de eventos e defina novas classes de evento extrínsecas. Para obter mais informações, consulte Escrever um provedor de eventos.

   Em um arquivo MOF, você pode definir um alias para o filtro e o consumidor, obtendo uma forma fácil de descrever os caminhos da instância.

   O exemplo a seguir mostra como definir um alias para o filtro e o consumidor.

   instance of __EventFilter as $FILTER
   instance of LogFileEventConsumer as $CONSUMER
   

5. Crie uma instância de __FilterToConsumerBinding para associar o filtro e as classes de consumidor. Essa instância determina que, quando ocorrer um evento que corresponde ao filtro especificado, a ação especificada pelo consumidor deverá ocorrer. __EventFilter, __EventConsumer e __FilterToConsumerBinding devem ter o mesmo SID (identificador de segurança) individual na propriedade CreatorSID. Para obter mais informações, consulte Associando um filtro de evento a um consumidor lógico.

   O exemplo a seguir mostra como identificar uma instância pelo caminho do objeto ou usar um alias como uma expressão abreviada para o caminho do objeto.

   instance of __EventFilter as $FILTER
   instance of NTEventLogEventConsumer as $CONSUMER
   

   O exemplo a seguir associa o filtro ao consumidor usando aliases.

   instance of __FilterToConsumerBinding
   {
       Filter = $FILTER;
       Consumer = $CONSUMER;
   
   };
   

   Você pode associar um filtro a vários consumidores, o que indica que, quando ocorrem eventos correspondentes, várias ações devem ser executadas; ou você pode associar um consumidor a vários filtros, o que indica que a ação deve ser tomada quando ocorrem eventos que correspondem a um dos filtros.

   As seguintes ações são executadas com base na condição de consumidores e eventos:

   • Se um dos consumidores permanentes falhar, outros consumidores que solicitarem o evento receberão notificação.
   • Se um evento for descartado, o WMI disparará __EventDroppedEvent.
   • Se você assinar esse evento, ele retornará o evento descartado e uma referência à __EventConsumer representará o consumidor com falha.
   • Se um consumidor falhar, o WMI disparará __ConsumerFailureEvent, que poderá conter mais informações nas propriedades ErrorCode, ErrorDescription e ErrorObject.

   Para obter mais informações, consulte Associando um filtro de evento a um consumidor lógico.

Exemplo

O exemplo a seguir mostra o MOF de uma instância de NTEventLogEventConsumer. Depois de compilar esse MOF, qualquer tentativa de criar, excluir ou modificar um valor no caminho do Registro HKEY_LOCAL_MACHINE\ Software\Microsoft\Windows\CurrentVersion\Run registrará uma entrada no log de eventos do aplicativo, na origem "WSH".

#pragma namespace ("\\\\.\\root\\subscription")
 
instance of __EventFilter as $Filter
{
    Name = "RunKeyFilter";
    QueryLanguage = "WQL";
    Query = "Select * from RegistryTreeChangeEvent"
            " where (Hive = \"HKEY_LOCAL_MACHINE\" and "
            "KeyPath = \"Software\\\\Microsoft\\\\Windows"
            "\\\\CurrentVersion\\\\Run\")";

    // RegistryTreeChangeEvents only fire
    // in root\default namespace
    EventNamespace = "root\\default";   
};
 
instance of NTEventLogEventConsumer as $Consumer
{
    Name = "RunKeyEventlogConsumer";
    SourceName = "WSH";               
    EventID = 8;
    EventType = 2;                            // Warning
    Category = 0;
    NumberOfInsertionStrings = 1;

    // the %Hive% and %KeyPath% are properties
    // of the RegistryKeyChangeEvent instance 
    InsertionStringTemplates = {"The key %Hive%\\%RootPath% "
        "has been modified. Check if the change is intentional"};
};
 

// Bind the filter to the consumer
instance of __FilterToConsumerBinding
{
    Filter = $Filter;
    Consumer = $Consumer;
};

Tópicos relacionados

Receber eventos com segurança