Child pages
  • Biblioteca de Diagnóstico
Skip to end of metadata
Go to start of metadata

Introdução

Monitorar o estado dos recursos que um sistema utiliza é fundamental para o seu funcionamento. Tanto para informar para os administradores do sistema que um recurso não está disponível quanto para que ele próprio possa substituir o recurso com falha por outro.

A ideia principal desta biblioteca é facilitar o desenvolvimento de sistemas com a capacidade de monitorar o estado dos recursos dos quais é dependente.

Arquitetura

[Colocar figura]

  • Engine: mantém os estados dos recursos cadastrados. A intervalos regulares obtém o estado de um recurso através do monitor correspondente.
  • Monitor: obtém o estado de um recurso.
  • ProactiveMonitor: é uma especialização de Monitor que notifica a Engine sempre que ocorrer uma mudança de estado do recurso monitorado.

Criando monitores

A interface Monitor tem a seguinte especificação:

public interface Monitor {
    /**
     * Obtém o nome do recurso monitorado.
     *
     * @return nome do recurso monitorado.
     */
    public String getResourceName();
 
    /**
     * Obtém o estado do recurso monitorado.
     *
     * @return o estado do recurso monitorado.
     */
    public Status checkResource();
}

A interface ProactiveMonitor estende a interface Monitor e acrescenta um método:

public interface ProactiveMonitor extends Monitor {
    /**
     * Registra o monitor em um {@link Engine}.
     *
     * @param handler {@link UpdateHandler} no qual o monitor irá se registrar.
     */
    public void registerEngine(UpdateHandler handler);
}

Então para criar um monitor basta implementar uma destas duas interfaces.

Exemplo usando interface

public class SimpleProactiveMonitor implements ProactiveMonitor {
    private String resourceName;
    private Status status;
    private UpdateHandler handler;
 
    public SimpleProactiveMonitor(String resourceName) {
        this.resourceName = resourceName;
        ChangeStatusThread changeStatusThread = new ChangeStatusThread();
        changeStatusThread.start();
    }
 
    @Override
    public void registerEngine(UpdateHandler handler) {
        this.handler = handler;
    }
 
    @Override
    public String getResourceName() {
        return resourceName;
    }
 
    @Override
    public Status checkResource() {
        return status;
    }
 
    private class ChangeStatusThread extends Thread {
        @Override
        public void run() {
            while (true) {
                double op = Math.random();
                if (op < 0.4) {
                    status = new Status(StatusCode.OK, "Serviço operacional");
                } else if (op < 0.7) {
                    status = new Status(StatusCode.ERROR, "Serviço com erro");
                } else {
                    status = new Status(StatusCode.UNAVAILABLE, "Serviço indisponível");
                }
                handler.updateStatus(status);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

Outra forma é estender as classes AbstractMonitor e AbstractProactiveMontior que já possuem a implementacão de todos os métodos exceto o método checkResource, que é o método responsável por obter o estado no recurso.

Exemplo usando classe abstrata

public class OpenBusMonitor extends AbstractMonitor {
    private OpenBusContext busContext;
 
    public OpenBusMonitor(String resourceName, OpenBusContext busContext) throws InvalidMonitorParameter {
        super(resourceName);
        if (busContext == null) {
            throw new InvalidMonitorParameter("A referência do barramento informada está nula");
        }
        this.busContext = busContext;
    }
 
    public Status checkResource() {
        if (busContext.orb() == null) {
            return new Status(StatusCode.UNAVAILABLE, "Não há conexão com o barramento");
        }
        if (busContext.getOfferRegistry() == null) {
            return new Status(StatusCode.ERROR, "Serviço de registro do barramento indisponível");
        }
        return new Status(StatusCode.OK, "O barramento está disponível");
    }
}

Usando a biblioteca

Depois de criar os monitores de recursos é preciso criar um objeto Engine e registrar os monitores.

Engine engine = new Engine(5000);
 
OpenBusContext context = client.getContext();
 
engine.addMonitor(new OpenBusMonitor("OPENBUS_20", context));
 
engine.addMonitor(new ServiceMonitor("OPENDREAMS_20", context, "CSGrid", new String[]{"IDL:tecgraf/openbus/opendreams/IOpenDreams:1.0"}, null));
 
engine.addMonitor(new SimpleProactiveMonitor("SIMPLEMONITOR_1"));
engine.addMonitor(new SimpleProactiveMonitor("SIMPLEMONITOR_2"));
engine.addMonitor(new SimpleProactiveMonitor("SIMPLEMONITOR_3"));
engine.addMonitor(new SimpleProactiveMonitor("SIMPLEMONITOR_4"));
engine.addMonitor(new SimpleProactiveMonitor("SIMPLEMONITOR_5"));

API

A documentação da API está disponível em API 1.0.

Download

  • No labels