Monitoramento e resposta 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 definem classes de consumidor permanentes. Cada consumidor padrão toma uma ação específica depois de receber uma notificação de evento. Por exemplo, você pode definir uma instância do ActiveScriptEventConsumer para executar um script quando o espaço livre em disco em um computador é 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 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 Grava 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, consulte log no log de eventos do 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, consulte 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 com uma ACL (lista de controle de acesso) forte para impedir que um usuário não autorizado substitua o executável por um executável diferente. Para obter mais informações, consulte Executar um programa na 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, script ou aplicativo MOF (Managed Object Format).

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 raiz\assinatura.

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

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

    Um consumidor pode incluir classes de evento localizadas em outros namespaces especificando o namespace na propriedade EventNamespace na consulta __EventFilter para 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 fazer referência diretamente a uma propriedade. Para obter mais informações, consulte Usando 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 de WSH e um valor EventID de 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 para eventos.

    No exemplo a seguir, o filtro monitora a chave do Registro em que os programas de inicialização são registrados. Monitorar essa chave do Registro pode ser importante porque um programa não autorizado pode se registrar sob a chave, o que faz com que ela seja iniciada 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 verificar se há um evento intrínseco ou extrínseco que usa. Por exemplo, use a classe RegistryTreeChangeEvent do provedor do Registro para monitorar 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, que fornece uma maneira 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. Esta instância determina que, quando ocorre um evento que corresponde ao filtro especificado, a ação especificada pelo consumidor deve ocorrer. __EventFilter, __EventConsumer e __FilterToConsumerBinding devem ter o mesmo SID (identificador de segurança individual) na propriedade CreatorSID . Para obter mais informações, consulte Associar um filtro de evento com 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 executada quando eventos que correspondem a um dos filtros ocorrem.

    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 solicitam o evento receberão notificação.
    • Se um evento for descartado, o WMI disparará __EventDroppedEvent.
    • Se você assinar esse evento, ele retornará o evento que foi descartado e uma referência ao __EventConsumer representará o consumidor com falha.
    • Se um consumidor falhar, o WMI disparará __ConsumerFailureEvent, que pode conter mais informações nas propriedades ErrorCode, ErrorDescription e ErrorObject .

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

Exemplo

O exemplo a seguir mostra o MOF para uma instância do 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 registra uma entrada no eventlog de 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;
};

Recebendo eventos com segurança