Subversion Repositories DevTools

package com.erggroup.buildtool.daemon;

import com.erggroup.buildtool.daemon.BuildDaemon;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import java.text.SimpleDateFormat;

import java.util.Calendar;

import java.util.LinkedHashMap;

import java.util.Map.Entry;

import java.net.ServerSocket;

import java.net.SocketTimeoutException;

import java.net.Socket;

import java.net.SocketException;

import java.io.*;

//----------------------------------------------------------------------------

// CLASS              : NagiosThread

//

// DESCRIPTION        : A class to provide Nagios support, with supplemental commands

//                      This is not an interactive command session

//                      It is intended to take one command and execute it

//                      The primary use is to provide nagios status

//

//

public class NagiosThread extends Thread {

    // Server socket

    private ServerSocket srv;

    // BuildDaemon

    private BuildDaemon mBuildDaemon;

    // Flag that indicates whether the poller is running or not.

    private volatile boolean isRunning = true;

    // Flag that indicates a request for an immediate kill.

    private volatile boolean mustDie = false;

    // Indicate the start time of the daemon

    //  Not nanosecond accurate, just an indication of when it was started

    //  Used to indicate when the daemon was started

    private final long startTime = System.currentTimeMillis();

    private final String startString = new SimpleDateFormat("dd-MM-yyyy HH:mm:ss").format(Calendar.getInstance().getTime());

    /**Logger

     * @attribute

     */

    private static final Logger mLogger = LoggerFactory.getLogger(NagiosThread.class);

    // Constructor.

    public NagiosThread(ServerSocket srv, BuildDaemon bd) {

        this.isRunning = true;

        this.srv = srv;

        this.mBuildDaemon = bd;

    }

    // Method for terminating the listener

    public void terminate() {

        mLogger.error("NagiosThread terminate");

        this.isRunning = false;

        try  {

            srv.close();

        }

        catch (IOException e) {

            mLogger.error("NagiosThread terminate Exception on srv.close: " + e.getMessage());

        }

    }

    /** 

     * Sleep and handle exceptions

     * @param time - Sleep duration in milliseconds

     */

    private void sleep(int time) {

        try {

            Thread.sleep(time);

        } catch (InterruptedException e) {

            Thread.currentThread().interrupt();

        }

    }

    /**

     * This method start the thread and performs all the operations.

     */

    @Override

    public void run() {

        mLogger.error("NagiosThread Run");

        setName("Nagios");

        // Wait for connection from client.

        // Process one command than then close the socket

        // This is not an interactive session

        //

        while (isRunning) {

            Socket socket;

            try {

                socket = srv.accept();

                mLogger.info("Nagios Socket Accepted");

                processSocketRequest(socket);

                try {

                    socket.close();

                } catch (IOException e) {

                    mLogger.error("NagiosThread Exception on socket opr: " + e.getMessage());

                    sleep(1000);

                }

            }

            catch (IOException e) {

                mLogger.error("NagiosThread Exception on srv.accept: " + e.getMessage());

                sleep(1000);

            }

        }

        //

        // Request to terminate this thread

        // If a mustDie request has been received, then wait 1 second and exit

        // This is a nasty thing to do

        //

        if (mustDie) {

            terminate();

            sleep(1000);

            System.exit(5);

        }

    }

/**

 * Process one request    

 * @param socket    - Socket with data to process

 */

    void processSocketRequest(Socket socket)

    {

        // Open a reader to receive possible input

        //      Set read Timeout on the socket to guard against misbehaving users

        //      Insert a dummy 'status' command if no input is received in 3 seconds

        //

        try {

            socket.setSoTimeout(3000);

        } catch (SocketException e) {

            mLogger.error("NagiosThread Exception on setSoTimeout: " + e.getMessage());

        }

        ;

        try {

            BufferedReader rd = new BufferedReader(new InputStreamReader(socket.getInputStream()));

            processRequest(socket, rd);

            rd.close();

        } catch (IOException e) {

            mLogger.error("NagiosThread Exception on getInputStream: " + e.getMessage());

        }

    }

    /** Process the request

     *  Have a BufferedReader that will contain the socket data

     *  @param socket - socket for writing response

     *  @param rd - BufferedReader for the socket data

     */

    void processRequest(Socket socket, BufferedReader rd) {

        String request = null;

        String[] requestTokens;

        String requestType = null;

        try

        {

            request = rd.readLine();

            mLogger.warn("Nagios request:" + request);

            if (request == null) {

                return;

            }

            //

            //  Simple sanity check on request

            //  First 3 chars must by alphabetic

            //

            if (!request.matches("^[A-Za-z]{3}.*")) {

                mLogger.warn("Nagios request not sane");

                return;

            }

            //  Handle restful requests as http requests

            //  Expect rest type url http://server:port/request/arg1/arg2

            //

            if (request.matches(".*\\s+HTTP/\\d\\.\\d$"))

            {

                try {

                    requestTokens = request.split("\\s+");

                    requestType = requestTokens[0];

                    requestTokens = requestTokens[1].substring(1).split("/");

                    request = requestTokens[0];

                }

                catch (IndexOutOfBoundsException e1) {

                    mLogger.error("NagiosThread cannot parse HTTP header");

                    return; 

                }

            }

        }

        catch ( SocketTimeoutException s)

        {

            mLogger.warn("Nagios Socket read timeout");

            request = "status";

        } catch (IOException e) {

            mLogger.error("NagiosThread Exception on processRequest: " + e.getMessage());

            return;

        }

        //  Process the users request and generate a response

        StringBuilder resp = new StringBuilder();

        generateResponse(request, resp);

        //

        //  Generate the output

        //  Wrap in an HTTP header if required

        //  Only really valid for 'estatus' as the content type may not be accurate

        //

        try 

        {

            BufferedWriter wr = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

            if(requestType != null)

            {

                wr.write("HTTP/1.0 200 OK\n");

                wr.write("Content-Type: application/json\n");

                wr.write("Content-length: "+ resp.length()+"\n");

                wr.write("\n");

            }

            wr.write (resp.toString());

            //  Flush out the input stream

            wr.flush();

            wr.close();

        } catch (IOException e) {

            mLogger.error("NagiosThread caught Exception writing to port:" + e.getMessage() );

        }

    }

    /**

     * Generate a response to the Nagios (or user ) request 

     * 

     * @param request - Request to process

     * @param resp - Build response into this StringBuilder

     */

void generateResponse(String request, StringBuilder resp) {

    if (request.equals("status"))

    {

        // Write the status message to the output stream

        // Currently this is too simple, but it is a start

        BuildDaemon.NagiosInfo nagInfo = new BuildDaemon.NagiosInfo();

        mBuildDaemon.checkThreads(nagInfo);

        int reasonCount = nagInfo.extendedReason.size();

        if (  reasonCount <= 0) {

            resp.append("Build Daemon status: OK\n");

        } else {

            resp.append("Build Daemon status: NOT HAPPY\n");

            mLogger.error("NagiosThread: NOT HAPPY");

            // Extended information - Reasons for being not happy

            if (reasonCount > 0)

            {

                resp.append("Reasons:" + "\n");

                for( int ii = 0; ii < reasonCount ;ii++)

                {

                    resp.append("    " + nagInfo.extendedReason.get(ii) + "\n");

                }

            }

        }

        resp.append("Version: "+ this.getClass().getPackage().getImplementationVersion() + "\n");

        resp.append("HostName: "+ BuildDaemon.mHostname + "\n");

        resp.append("Started: "+ startString + "\n");

        resp.append("UpTime (S): "+ (System.currentTimeMillis() - startTime) / 1000 + "\n");

        resp.append("Threads:" + nagInfo.threadCount + "\n");

        resp.append("Alive:" + nagInfo.threadAliveCount + "\n");

        resp.append("Masters:" + nagInfo.masterCount + "\n");

        resp.append("Slaves:" + nagInfo.slaveCount + "\n");

        if (BuildDaemon.mShutDown) {

            resp.append("Shutdown Request in Progress\n");

        }

        File cwd = new File(".");

        resp.append( "Usable space: " + cwd.getUsableSpace() + "\n");

    }

    else if ( request.equals( "help") ) {

        resp.append("Build Daemon Command Interface: Supported commands\n");

        resp.append("    status   - Nagios status\n");

        resp.append("    estatus  - Extended status\n");

        resp.append("    shutdown - shutdown buildtool\n");

        resp.append("    kill     - Immediate exit\n");

        resp.append("    help     - This message\n");

    }

    else if ( request.equals( "estatus") ) {

        LinkedHashMap<String, Object> basicStatus = new LinkedHashMap<String, Object>();

        BuildDaemon.NagiosInfo nagInfo = new BuildDaemon.NagiosInfo();

        mBuildDaemon.checkThreads(nagInfo);

        basicStatus.put("Vesion", this.getClass().getPackage().getImplementationVersion());

        basicStatus.put("HostName", BuildDaemon.mHostname );

        basicStatus.put("Start Text", startString );

        basicStatus.put("Start Time", Long.valueOf(startTime) );

        basicStatus.put("UpTime ", Long.valueOf(System.currentTimeMillis() - startTime) );

        basicStatus.put("Threads" , Integer.valueOf(nagInfo.threadCount) );

        basicStatus.put("Alive" , Integer.valueOf(nagInfo.threadAliveCount));

        basicStatus.put("Masters", Integer.valueOf(nagInfo.masterCount));

        basicStatus.put("Slaves", Integer.valueOf(nagInfo.slaveCount));

        basicStatus.put("UnHappy" , Integer.valueOf(nagInfo.extendedReason.size()) );

        basicStatus.put("mShutDown", Boolean.valueOf(BuildDaemon.mShutDown));

        LinkedHashMap<String, Object> dstatus = new LinkedHashMap<String, Object>();

        mBuildDaemon.extendedStatus(dstatus);

        LinkedHashMap<String, Object> status = new LinkedHashMap<String, Object>();

        status.put("Basic", basicStatus);

        status.put("Daemon", dstatus);

        String outBody = dumpJson(status, "");

        resp.append(outBody);

    }

    else if ( request.equals( "shutdown") ) {

        resp.append("Gracefull shutdown\n");

        mLogger.error("Gracefull shutdown requested");

        BuildDaemon.mShutDown = true;

    }

    else if ( request.equals( "kill") ) {

        resp.append("Will commit suicide\n");

        mLogger.error("Immediate program termination");

        mustDie = true;

        isRunning = false;

    }

    else {

        String eMgs = "Build Daemon Command Interface: Unknown command:" + request;

        mLogger.warn( eMgs );

        resp.append(eMgs);

        resp.append("\n");

    }

}

    /**Display a simple-ish hashmap as JSON

     * Only handles some basic types of data

     *      - Integers, Longs

     *      - Strings

     *      - Boolean

     *      - null

     *      - Hash Map (recursively)

     * 

     * @param estatus   Hash Map to display

     * @param indent    Indentation string

     * @return json encoded representation of the hashmap

     */

    @SuppressWarnings("unchecked")

    private String dumpJson(LinkedHashMap<String, Object> estatus, String indent)

    {

        StringBuilder s = new StringBuilder();

        String prefix = "";

        s.append(indent).append("{\n");

        for (Entry<String, Object> entry : estatus.entrySet()) {

            String key = entry.getKey();

            Object obj = entry.getValue();

            String objType = "";

            s.append(prefix);

            prefix = ",\n";

            s.append(indent).append('"').append(key).append('"').append(": ");

            if ( obj != null) {

                objType = obj.getClass().getName();

            }

            if ( obj == null ) {

                s.append("null");

            } else  if (objType.endsWith(".Integer") || objType.endsWith(".Long") ) {

                s.append(obj.toString());

            } else  if (objType.endsWith(".String") ) {

                s.append('"').append(obj.toString()).append('"');

            } else  if (objType.endsWith(".Boolean") ) {

                s.append(obj.toString());

            } else  if (objType.endsWith(".LinkedHashMap") ) {

                s.append(dumpJson((LinkedHashMap<String, Object>) obj, indent + "    "));

            } else {

                s.append('"').append("Unknown Class:").append(objType).append('"');

            }

        }

        s.append('\n').append(indent).append("}");

        return s.toString();

    }

}