簡単に拡張できる軽量なモニタリングフレームワークの構築

public interface Info {
    //checks the status 
    //returns true if ok 
    //throws Exception if it could not be monitored
    public boolean isOk() throws Exception;
    //handles corrective action
    public boolean process();
}

public class StatusMonitor extends Thread {
    private final int monInterval; //in milliseconds
    private final Monitorable[] monArray;
    public void run() {
        while(true) {
           for(int cnt = 0; cnt < Integer.MAX_VALUE;
               cnt++) {
               //iterate through the array
               for(int i = 0; i < monArray.length; i++) {
                   //check if counter expired
                   if((cnt % monArray[i].getCounter()) 
                       == 0) monArray[i].monitor();
               }
           }
           try { 
               sleep(monInterval);
           } catch(InterruptedException ie) {}
        }
    }
}

public class Monitorable {
    private int counter;
    private byte criticality;
    private byte prevStatus;
    private StatusManager manager;
    private Info info;
    public void monitor() {
        byte currentStatus = NOT_OK;
        try {
            if(info.isOk()) {
               currentStatus = Monitorable.OK;
            }
        } catch(Exception ex) { 
            currentStatus = 
               Monitorable.COULD_NOT_BE_MONITORED;
        }
        //call setchanged if there is change in status
        //or if status is not ok or cud not be monitored
        if((currentStatus != prevStatus) || 
                currentStatus != StatusManager.OK) {
            synchronized(this) {
                prevStatus = currentStatus;
            }
            manager.setChanged(this);
        }
    }

    //return the last monitored status
    public synchronized byte getStatus() {
        return prevStatus;
    }

    //recovery action
    public void execute() {
        info.process();
    }
}

public class StatusManager extends Thread {
    //add to the queue and
    //notify that the status of monitorable has changed
    public synchronized void setChanged
        (Monitorable monitorable)
        monQueue.add(monitorable);
        notifyAll();
    }
    
    //get the Monitorable object from the queue
    public synchronized Monitorable getMonitorable() {
        // return the object from the queue    
        while(monQueue.isEmpty()) {
            try {
                wait();
            } catch(Exception ex) {}
        }
        return (Monitorable) monQueue.remove(0);
    }

    //report or execute corrective action
    private void processChange() {
        Monitorable monitorable = getMonitorable();

        //take corrective action
        if(monitorable.getStatus() == NOT_OK) {
            monitorable.execute();
        }

        //log or report the status
    }

    public void run() {
        while(true) processChange();
    }
}  

public class ProcessInfo implements Info
{
    ProcessInfo(String processName, String execName){ ..}
   //check if process is running or not
    boolean isOk() throws Exception {..} 
   //re-launch process
    boolean process() {..}; 
}

public boolean isOk() throws Exception {
    String[] cmdArray = new String[] 
        {“CheckProcess.exe”, “apache.exe”};
    Process proc = Runtime.getRuntime().exec(cmdArray);
    BufferedReader br = new BufferedReader(new 
        InputStreamReader(proc.getInputStream()));
    String status = br.readLine();
    if(status.equals("TRUE")) return true;
    return false;
}

public class TestClient {
    public static void main(String[] args) 
        throws Exception {
        ProcessInfo p = new ProcessInfo(“apache.exe”,
                 “<Path>/apache.exe”);
        int counter = 10; //10 seconds
        byte criticality = LWMFramework.HIGH; 

        LWMFramework lwmf = new LWMFramework();
        //set minimum monitorable frequency 1 second
        lwmf.setMonitorInterval(1);
        //add info object
        lwmf.add(p, counter, level);
        //start the framework
        lwmf.start();

        Thread.currentThread().join();
    }
}

<MonitorServer interval="1" > 
<!-- The interval determines unit value of counter in seconds,
 if this value is 60 then minimum frequency of monitoring is
 60 sec or 1 min !-->
<MONITORABLE name = "Apache Webserver" class = "ProcessInfo"
    counter = "1000" criticality = "HIGH">
<!-- ProcessInfo specific configuration !-->
<process name="apache.exe" exec="C:/Apache.exe"/>
</MONITORABLE>
<MONITORABLE name = "Tomcat" class = "ProcessInfo"
    counter = "1000" criticality = "HIGH">
<process name="tomcat.exe" exec="path../tomcat.exe"/>
</MONITORABLE>
<MONITORABLE name = "C Drive" class = "FileSystemInfo"
    counter = "100000" criticality = "HIGH">
<filesystem path="C:" threshold="80" exec="C:/../diskcleanup.exe"/>
</MONITORABLE>
<MONITORABLE name = "app server" class = "ConnectivityInfo"
    counter = "1000" criticality = "HIGH">
<connectivity host="198.168.1.10"/>
</MONITORABLE>
<MONITORABLE name = "LocalMachine" class = "CPUInfo"
    counter = "10000" criticality = "LOW">
<Threshold value="80"/>
</MONITORABLE>
</MonitorServer>