opengrok/management/OGAgent.java

	OGAgent.java revision 639
830N/A/*
830N/A * CDDL HEADER START
830N/A *
830N/A * The contents of this file are subject to the terms of the
919N/A * Common Development and Distribution License (the "License").
919N/A * You may not use this file except in compliance with the License.
919N/A *
919N/A * See LICENSE.txt included in this distribution for the specific
919N/A * language governing permissions and limitations under the License.
830N/A *
919N/A * When distributing Covered Code, include this CDDL HEADER in each
919N/A * file and include the License file at LICENSE.txt.
919N/A * If applicable, add the following below this CDDL HEADER, with the
830N/A * fields enclosed by brackets "[]" replaced with your own identifying
919N/A * information: Portions Copyright [yyyy] [name of copyright owner]
919N/A *
919N/A * CDDL HEADER END
919N/A */
919N/A
919N/A/*
919N/A * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
830N/A * Use is subject to license terms.
830N/A */
830N/Apackage org.opensolaris.opengrok.management;
830N/A
830N/Aimport java.io.FileInputStream;
830N/Aimport java.io.IOException;
830N/Aimport java.io.InputStream;
830N/Aimport java.net.MalformedURLException;
830N/Aimport java.util.ArrayList;
830N/Aimport java.util.Date;
830N/Aimport java.util.HashMap;
830N/Aimport java.util.Properties;
830N/Aimport java.util.logging.Level;
830N/Aimport java.util.logging.Logger;
830N/Aimport javax.management.JMException;
830N/Aimport javax.management.MBeanServer;
830N/Aimport javax.management.MBeanServerFactory;
830N/Aimport javax.management.NotificationFilter;
830N/Aimport javax.management.ObjectName;
830N/Aimport javax.management.remote.JMXConnectorServer;
830N/Aimport javax.management.remote.JMXServiceURL;
830N/Aimport javax.management.remote.jmxmp.JMXMPConnectorServer;
830N/Aimport javax.management.remote.rmi.RMIConnectorServer;
830N/Aimport javax.management.timer.Timer;
830N/Aimport org.opensolaris.opengrok.Info;
import org.opensolaris.opengrok.OpenGrokLogger;

/**
 * OG Agent main class.
 * Class for starting the basic components:
 * Monitor and JMX and HTTP Connectors.
 * @author Jan S Berg
 */
public class OGAgent {

    private int connectorport = 9292;
    private final static Logger log = Logger.getLogger("org.opensolaris.opengrok");
    private static String cfgfile = null;
    private MBeanServer server = null;
    private static OGAgent oga = null;

    @SuppressWarnings("PMD.SystemPrintln")
    public static void main(final String args[]) {

        for (int i = 0; i < args.length; i++) {
            if (args[i].equals("-config")) {
                if (++i < args.length) {
                    cfgfile = args[i];
                } else {
                    System.err.println("-config, argument missing: config file");
                    System.exit(1);
                }
            }
        }

        oga = new OGAgent();
        try {
            oga.runOGA();
        } catch (MalformedURLException e) {
            log.log(Level.SEVERE, "Could not create connector server: " + e, e);
            System.exit(1);
        } catch (IOException e) {
            log.log(Level.SEVERE, "Could not start connector server: " + e, e);
            System.exit(2);
        } catch (Exception ex) {
            Logger.getLogger(OGAgent.class.getName()).log(Level.SEVERE, null, ex);
            System.exit(1);
        }
    }

    public final void runOGA() throws MalformedURLException, IOException, JMException {
        String machinename = java.net.InetAddress.getLocalHost().getHostName();
        String javaver = System.getProperty("java.version");

        Properties props = new Properties();

        // Load default values
        InputStream in = OGAgent.class.getResourceAsStream("oga.properties");
        if (in != null) {
            props.load(in);
            in.close();
        }

        // Load properties from config file, if one is specified
        if (cfgfile != null) {
            FileInputStream is = new FileInputStream(cfgfile);
            props.load(is);
            is.close();
        }

        // System properties should override default properties
        props.putAll(System.getProperties());

        createLogger(props);

        log.info("Starting " + Info.getFullVersion() +
                " JMX Agent, with java version " + javaver);
        //create mbeanserver

        String connprotocol = props.getProperty("org.opensolaris.opengrok.management.connection.protocol", "jmxmp");
        connectorport = Integer.parseInt(props.getProperty("org.opensolaris.opengrok.management.connection." + connprotocol + ".port", Integer.toString(connectorport)));
        log.fine("Using protocol " + connprotocol + ", port: " + connectorport);

        ArrayList mbservs = MBeanServerFactory.findMBeanServer(null);
        log.fine("Finding MBeanservers, size " + mbservs.size());
        if (mbservs.isEmpty()) {
            server = MBeanServerFactory.createMBeanServer();
        } else {
            server = (MBeanServer) mbservs.get(0);
        }

        //instantiate and register OGAManagement
        ObjectName manager = new ObjectName("OGA:name=Management");
        server.registerMBean(Management.getInstance(props), manager);

        //instantiate and register OGA:JMXConfiguration
        ObjectName config = new ObjectName("OGA:name=JMXConfiguration");
        JMXConfiguration jc = new JMXConfiguration();
        server.registerMBean(jc, config);

        //instantiate and register Timer service and resource purger
        createIndexTimer(props);
        log.info("MBeans registered");

        // Create and start connector server
        log.fine("Starting JMX connector");
        HashMap<String, Object> env = new HashMap<String, Object>();
        JMXServiceURL url = new JMXServiceURL(connprotocol, machinename, connectorport);
        JMXConnectorServer connectorServer = null;

        if ("jmxmp".equals(connprotocol)) {
            connectorServer = new JMXMPConnectorServer(url, env, server);
        } else if ("rmi".equals(connprotocol) || "iiop".equals(connprotocol)) {
            connectorServer = new RMIConnectorServer(url, env, server);
        } else {
            throw new IOException("Unknown connector protocol");
        }
        connectorServer.start();

        log.info("OGA is ready and running...");
    }

    private void createIndexTimer(Properties properties) throws IOException, JMException {

        //instantiate, register and start the Timer service
        ObjectName timer = new ObjectName("service:name=timer");
        server.registerMBean(new Timer(), timer);
        server.invoke(timer, "start", null, null);
        log.info("Started timer service");

        boolean enabled = Boolean.parseBoolean(properties.getProperty("org.opensolaris.opengrok.management.indexer.enabled"));
        int period = Integer.parseInt(properties.getProperty("org.opensolaris.opengrok.management.indexer.sleeptime"));
        log.fine("Indexer enabled: " + enabled);
        log.fine("Indexer period: " + period + " seconds");
        //instantiate and register resource purger
        ObjectName indexRunner = new ObjectName("OGA:name=AgentIndexRunner," + "source=timer");
        server.registerMBean(AgentIndexRunner.getInstance(enabled), indexRunner);
        // Add index notification to timer (read from org.opensolaris.opengrok.management.indexer.sleeptime property).
        Date date = new Date(System.currentTimeMillis() + Timer.ONE_SECOND * 5);
        Long longPeriod = Long.valueOf(period * Timer.ONE_SECOND);
        Integer id = (Integer) server.invoke(timer, "addNotification",
                new Object[]{"timer.notification", // Type
                    "Time to index again", // Message
                    null, // user data
                    date, // Start time
                    longPeriod, // Period
                },
                new String[]{String.class.getName(),
                    String.class.getName(),
                    Object.class.getName(),
                    Date.class.getName(),
                    "long",
                });

        // Add indexer as listener to index notifications
        NotificationFilter filter = new TimerFilter(id);
        server.addNotificationListener(timer, indexRunner, filter, null);
    }

    private void createLogger(Properties props) {
        String OGAlogpath = props.getProperty("org.opensolaris.opengrok.management.logging.path");

        Level loglevel = null;
        try {
            loglevel = Level.parse(props.getProperty("org.opensolaris.opengrok.management.logging.filelevel"));
        } catch (Exception exll) {
            loglevel = Level.FINE;
        }
        Level consoleloglevel = null;
        try {
            consoleloglevel = Level.parse(props.getProperty("org.opensolaris.opengrok.management.logging.consolelevel"));
        } catch (Exception excl) {
            consoleloglevel = Level.INFO;
        }

        OpenGrokLogger.setupLogger(OGAlogpath, loglevel, consoleloglevel);
    }
}