org.esigate.server.ControlHandler Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of esigate-server Show documentation
Standalone server for development. Can be run using java -jar esigate-server-<version>.jar -Desigate.config=<config file>
There is a newer version: 5.3
Show newest version
/* 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

package org.esigate.server;

import java.io.IOException;
import java.io.Writer;
import java.lang.management.ManagementFactory;
import java.util.Map;
import java.util.Map.Entry;
import java.util.TreeMap;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.eclipse.jetty.server.Request;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.handler.AbstractHandler;

import com.codahale.metrics.Counter;
import com.codahale.metrics.Gauge;
import com.codahale.metrics.Meter;
import com.codahale.metrics.MetricRegistry;
import com.codahale.metrics.Timer;

/**
 * Handle commands to the control port. Work in progress.
 * 
 * 
 * Commands
 * 

 * POST /shutdown
 * POST /status
 * 
 * 
 * @author Nicolas Richeton
 * 
 */
public class ControlHandler extends AbstractHandler {
    private static final String PREFIX_CONTEXT = "org.eclipse.jetty.webapp.WebAppContext.main.";
    private static final String PREFIX_THREAD_POOL = "org.eclipse.jetty.util.thread.QueuedThreadPool.esigate.";
    /**
     * Human-readable status
     */
    private static final String URL_STATUS = "/server-status";
    /**
     * Machine-readable status.
     * 
     * 
     * Sample :
     * 
     * 
     * Total Accesses: 157678
     * Total kBytes: 176421
     * CPULoad: .0190435
     * Uptime: 2214828
     * ReqPerSec: .071192
     * BytesPerSec: 81.5662
     * BytesPerReq: 1145.72
     * BusyWorkers: 1
     * IdleWorkers: 4
     * 
     */
    private final MetricRegistry registry;

    /**
     * Control handler for administration tasks.
     * 
     * @param registry
     *            metrics registry.
     */
    public ControlHandler(MetricRegistry registry) {
        this.registry = registry;
    }

    private static boolean fromControlConnection(Request serverRequest) {
        return EsigateServer.getControlPort() == serverRequest.getLocalPort();
    }

    /**
     * Perform shutdown.
     * 
     * @param port
     *            control handler port.
     */
    public static void shutdown(int port) {
        Http.doPOST("http://127.0.0.1:" + port + "/shutdown");
        return;
    }

    /**
     * Display status.
     * 
     * @param port
     *            control handler port.
     */
    public static void status(int port) {
        Http.doGET("http://127.0.0.1:" + port + URL_STATUS);
        return;
    }

    @Override
    public void handle(String target, Request serverRequest, HttpServletRequest request, HttpServletResponse response)
            throws IOException, ServletException {

        if (fromControlConnection(serverRequest)) {
            serverRequest.setHandled(true);

            switch (target) {

            case "/shutdown":
                if ("POST".equals(serverRequest.getMethod())) {
                    response.setStatus(HttpServletResponse.SC_OK);
                    stopServer();
                }
                break;

            case URL_STATUS:
                if ("GET".equals(serverRequest.getMethod())) {

                    if (request.getParameter("auto") != null) {
                        response.setStatus(HttpServletResponse.SC_OK);
                        try (Writer sos = response.getWriter()) {
                            Map status = getServerStatus();
                            for (String key : status.keySet()) {
                                sos.append(key + ": " + status.get(key) + "\n");
                            }
                        }

                    } else {
                        response.setStatus(HttpServletResponse.SC_OK);
                        try (Writer sos = response.getWriter()) {
                            sos.append("Esigate Server Status\n");
                            Map status = getServerStatus();
                            for (String key : status.keySet()) {
                                sos.append(key + ": " + status.get(key) + "\n");
                            }
                        }
                    }

                }
                break;

            default:
                response.setStatus(HttpServletResponse.SC_NOT_ACCEPTABLE);
                break;
            }

        }

    }

    private Map getServerStatus() {
        Map result = new TreeMap<>();

        Map counters = this.registry.getCounters();
        for (Entry c : counters.entrySet()) {
            result.put(cleanupStatusKey(c.getKey()), String.valueOf(c.getValue().getCount()));
        }

        Map meters = this.registry.getMeters();
        for (Entry c : meters.entrySet()) {
            result.put(cleanupStatusKey(c.getKey()), String.valueOf(c.getValue().getCount()));
            result.put(cleanupStatusKey(c.getKey()) + "PerSec", String.valueOf(c.getValue().getOneMinuteRate()));
        }

        Map gauges = this.registry.getGauges();
        for (Entry c : gauges.entrySet()) {
            result.put(cleanupStatusKey(c.getKey()), String.valueOf(c.getValue().getValue()));
        }

        Map timers = this.registry.getTimers();
        for (Entry c : timers.entrySet()) {
            result.put(cleanupStatusKey(c.getKey()), String.valueOf(c.getValue().getOneMinuteRate()));
        }

        // Get total accesses
        Long accesses =
                new Long(meters.get(PREFIX_CONTEXT + "1xx-responses").getCount()
                        + meters.get(PREFIX_CONTEXT + "2xx-responses").getCount()
                        + meters.get(PREFIX_CONTEXT + "3xx-responses").getCount()
                        + meters.get(PREFIX_CONTEXT + "4xx-responses").getCount()
                        + meters.get(PREFIX_CONTEXT + "5xx-responses").getCount());
        result.put("Total Accesses", accesses);

        // Get ReqPerSec
        Double reqPerSec =
                new Double(meters.get(PREFIX_CONTEXT + "1xx-responses").getOneMinuteRate()
                        + meters.get(PREFIX_CONTEXT + "2xx-responses").getOneMinuteRate()
                        + meters.get(PREFIX_CONTEXT + "3xx-responses").getOneMinuteRate()
                        + meters.get(PREFIX_CONTEXT + "4xx-responses").getOneMinuteRate()
                        + meters.get(PREFIX_CONTEXT + "5xx-responses").getOneMinuteRate());
        result.put("ReqPerSec", reqPerSec);

        // Get uptime
        result.put("Uptime", new Long(ManagementFactory.getRuntimeMXBean().getUptime()));

        // Get CPULoad
        Double cpuLoad = new Double(ManagementFactory.getOperatingSystemMXBean().getSystemLoadAverage());
        if (cpuLoad.doubleValue() >= 0d) {
            result.put("CPULoad", cpuLoad);
        }

        return result;

    }

    /**
     * Remove unnecessary prefix from Metrics meters id.
     * 
     * @param s
     * @return
     */
    private static String cleanupStatusKey(String s) {
        String result = s;
        if (s.startsWith(PREFIX_CONTEXT)) {
            result = s.substring(PREFIX_CONTEXT.length());

        }

        if (s.startsWith(PREFIX_THREAD_POOL)) {
            result = s.substring(PREFIX_THREAD_POOL.length());
        }

        return result;
    }

    /**
     * Start a new thread to shutdown the server
     */
    private void stopServer() {
        // Get current server
        final Server targetServer = this.getServer();

        // Start a new thread in order to escape the destruction of this Handler
        // during the stop process.
        new Thread() {
            @Override
            public void run() {
                try {
                    targetServer.stop();
                } catch (Exception e) {
                    // ignore
                }
            }
        }.start();

    }
}