/*

 * Copyright (c) 2004, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package sun.jvmstat.monitor;

import java.util.*;

import java.net.*;

import java.lang.reflect.*;

import sun.jvmstat.monitor.event.HostListener;

/**

 * An abstraction for a host that contains instrumented Java Virtual

 * Machines. The class provides abstract factory methods for creating

 * concrete instances of this class and factory methods for creating

 * {@link MonitoredVm} instances. Concrete implementations of this class

 * provide methods for managing the communications protocols and provide

 * for event notification.

 *

 * @author Brian Doherty

 * @since 1.5

 *

 * @see HostIdentifier

 * @see VmIdentifier

 * @see MonitoredVm

 * @see HostListener

 */

public abstract class MonitoredHost {

    private static Map<HostIdentifier, MonitoredHost> monitoredHosts =

                new HashMap<HostIdentifier, MonitoredHost>();

    /*

     * The monitoring implementation override mechanism. The value of

     * this property is used as the class name for the concrete MonitoredHost

     * subclass that implements the monitoring APIs.  Setting this property

     * will cause the remaining override mechanisms to be ignored. When

     * this mechanism is used, the HostIdentifier scheme name, which

     * indicates the communications protocol, is not used to locate a

     * the protocol specific package. However, the HostIdentifier is

     * still passed to the corresponding single arg constructor.

     * This property is not expected to be set in normal circumstances.

     */

    private static final String IMPL_OVERRIDE_PROP_NAME =

            "sun.jvmstat.monitor.MonitoredHost";

    /*

     * The monitoring package name override mechanism. The value

     * the this property is used as base package name for the

     * monitoring implementation package. This property is not

     * expected to be set under normal circumstances.

     */

    private static final String IMPL_PKG_PROP_NAME =

            "sun.jvmstat.monitor.package";

    private static final String IMPL_PACKAGE =

            System.getProperty(IMPL_PKG_PROP_NAME, "sun.jvmstat.perfdata");

    /*

     * The default optimized local protocol override mechanism. The value

     * of this property is used to construct the default package name

     * for the default optimized local protocol as follows:

     *        <IMPL_PACKAGE>.monitor.<LOCAL_PROTOCOL>

     * This property is not expected to be set under normal circumstances.

     */

    private static final String LOCAL_PROTOCOL_PROP_NAME =

            "sun.jvmstat.monitor.local";

    private static final String LOCAL_PROTOCOL =

            System.getProperty(LOCAL_PROTOCOL_PROP_NAME, "local");

    /*

     * The default remote protocol override mechanism. The value of

     * this property is used to construct the default package name

     * for the default remote protocol protocol as follows:

     *        <IMPL_PACKAGE>.monitor.protocol.<REMOTE_PROTOCOL>

     * This property is not expected to be set under normal circumstances.

     */

    private static final String REMOTE_PROTOCOL_PROP_NAME =

            "sun.jvmstat.monitor.remote";

    private static final String REMOTE_PROTOCOL =

            System.getProperty(REMOTE_PROTOCOL_PROP_NAME, "rmi");

    /*

     * The default class name of the MonitoredHost implementation subclass.

     * There is no override mechanism for this variable, other than the

     * IMPL_OVERRIDE_PROP_NAME override, which is larger in scope. A concrete

     * instance of this class is expected to be found in:

     *     <IMPL_PACKAGE>.monitor.protocol.<protocol>.<MONITORED_HOST_CLASS>

     */

    private static final String MONITORED_HOST_CLASS = "MonitoredHostProvider";

    /**

     * The HostIdentifier for this MonitoredHost instance.

     */

    protected HostIdentifier hostId;

    /**

     * The polling interval, in milliseconds, for this MonitoredHost instance.

     */

    protected int interval;

    /**

     * The last Exception encountered while polling this MonitoredHost.

     */

    protected Exception lastException;

    /**

     * Factory method to construct MonitoredHost instances to manage

     * connections to the host indicated by <tt>hostIdString</tt>

     *

     * @param hostIdString a String representation of a {@link HostIdentifier}

     * @return MonitoredHost - the MonitoredHost instance for communicating

     *                         with the indicated host using the protocol

     *                         specified in hostIdString.

     * @throws MonitorException  Thrown if monitoring errors occur.

     * @throws URISyntaxException Thrown when the hostIdString is poorly

     *                            formed. This exception may get encapsulated

     *                            into MonitorException in a future revision.

     */

    public static MonitoredHost getMonitoredHost(String hostIdString)

                  throws MonitorException, URISyntaxException {

        HostIdentifier hostId = new HostIdentifier(hostIdString);

        return getMonitoredHost(hostId);

    }

    /**

     * Factory method to construct a MonitoredHost instance to manage the

     * connection to the Java Virtual Machine indicated by <tt>vmid</tt>.

     *

     * This method provide a convenient short cut for attaching to a specific

     * instrumented Java Virtual Machine. The information in the VmIdentifier

     * is used to construct a corresponding HostIdentifier, which in turn is

     * used to create the MonitoredHost instance.

     *

     * @param vmid The identifier for the target Java Virtual Machine.

     * @return MonitoredHost - The MonitoredHost object needed to attach to

     *                         the target Java Virtual Machine.

     *

     * @throws MonitorException Thrown if monitoring errors occur.

     */

    public static MonitoredHost getMonitoredHost(VmIdentifier vmid)

                 throws MonitorException {

        // use the VmIdentifier to construct the corresponding HostIdentifier

        HostIdentifier hostId = new HostIdentifier(vmid);

        return getMonitoredHost(hostId);

    }

    /**

     * Factory method to construct a MonitoredHost instance to manage the

     * connection to the host indicated by <tt>hostId</tt>.

     *

     * @param hostId the identifier for the target host.

     * @return MonitoredHost - The MonitoredHost object needed to attach to

     *                         the target host.

     *

     * @throws MonitorException Thrown if monitoring errors occur.

     */

    public static MonitoredHost getMonitoredHost(HostIdentifier hostId)

                  throws MonitorException {

        /*

         * determine the class name to load. If the system property is set,

         * use the indicated class. otherwise, use the default class.

         */

        String classname = System.getProperty(IMPL_OVERRIDE_PROP_NAME);

        MonitoredHost mh = null;

        synchronized(monitoredHosts) {

            mh = monitoredHosts.get(hostId);

            if (mh != null) {

                if (mh.isErrored()) {

                    monitoredHosts.remove(hostId);

                } else {

                    return mh;

                }

            }

        }

        hostId = resolveHostId(hostId);

        if (classname == null) {

            // construct the class name

            classname = IMPL_PACKAGE + ".monitor.protocol."

                        + hostId.getScheme() + "." + MONITORED_HOST_CLASS;

        }

        try {

            // run the constructor taking a single String parameter.

            Class<?> c = Class.forName(classname);

            Constructor cons = c.getConstructor(

                new Class[] { hostId.getClass() }

            );

            mh = (MonitoredHost)cons.newInstance(new Object[] { hostId } );

            synchronized(monitoredHosts) {

                monitoredHosts.put(mh.hostId, mh);

            }

            return mh;

        } catch (ClassNotFoundException e) {

            // from Class.forName();

            throw new IllegalArgumentException("Could not find " + classname

                                               + ": " + e.getMessage(), e);

        } catch (NoSuchMethodException e) {

            // from Class.getConstructor();

            throw new IllegalArgumentException(

                "Expected constructor missing in " + classname + ": "

                + e.getMessage(), e);

        } catch (IllegalAccessException e) {

            // from Constructor.newInstance()

            throw new IllegalArgumentException(

                "Unexpected constructor access in " + classname + ": "

                + e.getMessage(), e);

        } catch (InstantiationException e) {

            throw new IllegalArgumentException(classname + "is abstract: "

                                               + e.getMessage(), e);

        } catch (InvocationTargetException e) {

            Throwable cause = e.getCause();

            if (cause instanceof MonitorException) {

                throw (MonitorException)cause;

            }

            throw new RuntimeException("Unexpected exception", e);

        }

    }

    /**

     * Method to resolve unspecified components of the given HostIdentifier

     * by constructing a new HostIdentifier that replaces the unspecified

     * components with the default values.

     *

     * @param hostId the unresolved HostIdentifier.

     * @return HostIdentifier - a resolved HostIdentifier.

     *

     * @throws MonitorException Thrown if monitoring errors occur.

     */

    protected static HostIdentifier resolveHostId(HostIdentifier hostId)

                     throws MonitorException {

        String hostname = hostId.getHost();

        String scheme = hostId.getScheme();

        StringBuffer sb = new StringBuffer();

        assert hostname != null;

        if (scheme == null) {

            if (hostname.compareTo("localhost") == 0) {

                scheme = LOCAL_PROTOCOL;

            } else {

                scheme = REMOTE_PROTOCOL;

            }

        }

        sb.append(scheme).append(":").append(hostId.getSchemeSpecificPart());

        String frag = hostId.getFragment();

        if (frag != null) {

            sb.append("#").append(frag);

        }

        try {

            return new HostIdentifier(sb.toString());

        } catch (URISyntaxException e) {

            // programming error - HostIdentifier was valid.

            assert false;

            throw new IllegalArgumentException("Malformed URI created: "

                                               + sb.toString());

        }

    }

    /**

     * Return the resolved HostIdentifier for this MonitoredHost.

     *

     * @return HostIdentifier - the resolved HostIdentifier.

     */

    public HostIdentifier getHostIdentifier() {

        return hostId;

    }

    /* ---- Methods to support polled MonitoredHost Implementations ----- */

    /**

     * Set the polling interval for this MonitoredHost.

     *

     * @param interval the polling interval, in milliseconds

     */

    public void setInterval(int interval) {

        this.interval = interval;

    }

    /**

     * Get the polling interval.

     *

     * @return int - the polling interval in milliseconds for this MonitoredHost

     */

    public int getInterval() {

        return interval;

    }

    /**

     * Set the last exception encountered while polling this MonitoredHost.

     *

     * @param lastException the last exception encountered;

     */

    public void setLastException(Exception lastException) {

        this.lastException = lastException;

    }

    /**

     * Get the last exception encountered while polling this MonitoredHost.

     *

     * @return Exception - the last exception occurred while polling this

     *                     MonitoredHost, or <tt>null</tt> if no exception

     *                     has occurred or the exception has been cleared,

     */

    public Exception getLastException() {

        return lastException;

    }

    /**

     * Clear the last exception.

     */

    public void clearLastException() {

        lastException = null;

    }

    /**

     * Test if this MonitoredHost is in the errored state. If this method

     * returns true, then the Exception returned by getLastException()

     * indicates the Exception that caused the error condition.

     *

     * @return boolean - true if the MonitoredHost instance has experienced

     *                   an error, or false if it hasn't or if any past

     *                   error has been cleared.

     */

    public boolean isErrored() {

        return lastException != null;

    }

    /**

     * Get the MonitoredVm for the given Java Virtual Machine. The default

     * sampling interval is used for the MonitoredVm instance.

     *

     * @param id the VmIdentifier specifying the target Java Virtual Machine.

     * @return MonitoredVm - the MonitoredVm instance for the target Java

     *                       Virtual Machine.

     * @throws MonitorException Thrown if monitoring errors occur.

     */

    public abstract MonitoredVm getMonitoredVm(VmIdentifier id)

                                throws MonitorException;

    /**

     * Get the MonitoredVm for the given Java Virtual Machine. The sampling

     * interval is set to the given interval.

     *

     * @param id the VmIdentifier specifying the target Java Virtual Machine.

     * @param interval the sampling interval for the target Java Virtual Machine.

     * @return MonitoredVm - the MonitoredVm instance for the target Java

     *                       Virtual Machine.

     * @throws MonitorException Thrown if monitoring errors occur.

     */

    public abstract MonitoredVm getMonitoredVm(VmIdentifier id, int interval)

                                throws MonitorException;

    /**

     * Detach from the indicated MonitoredVm.

     *

     * @param vm the monitored Java Virtual Machine.

     * @throws MonitorException Thrown if monitoring errors occur.

     */

    public abstract void detach(MonitoredVm vm) throws MonitorException;

    /**

     * Add a HostListener. The given listener is added to the list

     * of HostListener objects to be notified of MonitoredHost related events.

     *

     * @param listener the HostListener to add.

     * @throws MonitorException Thrown if monitoring errors occur.

     */

    public abstract void addHostListener(HostListener listener)

                         throws MonitorException;

    /**

     * Remove a HostListener. The given listener is removed from the list

     * of HostListener objects to be notified of MonitoredHost related events.

     *

     * @param listener the HostListener to add.

     * @throws MonitorException Thrown if monitoring errors occur.

     */

    public abstract void removeHostListener(HostListener listener)

                         throws MonitorException;

    /**

     * Return the current set of active Java Virtual Machines for this

     * MonitoredHost. The returned Set contains {@link Integer} instances

     * holding the local virtual machine identifier, or <em>lvmid</em>

     * for each instrumented Java Virtual Machine currently available.

     *

     * @return Set - the current set of active Java Virtual Machines associated

     *               with this MonitoredHost, or the empty set of none.

     * @throws MonitorException Thrown if monitoring errors occur.

     */

    public abstract Set<Integer> activeVms() throws MonitorException;

}