/*
 * $RCSfile: Client.java,v $
 * $Revision: 1.1.2.5.14.2 $ $Date: 2015/05/07 23:56:02 $
 *
 * Copyright 2009 Kabira Technologies, Inc. All rights reserved.
 */
package com.kabira.test.management;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.InetAddress;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.UnknownHostException;
import java.util.Map;
import java.util.HashMap;
import java.util.Map.Entry;
import java.lang.Throwable;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.management.AttributeList;
import javax.management.InstanceNotFoundException;
import javax.management.MBeanException;
import javax.management.MBeanServerConnection;
import javax.management.MalformedObjectNameException;
import javax.management.ObjectName;
import javax.management.ReflectionException;
import javax.management.RuntimeErrorException;
import javax.management.RuntimeMBeanException;
import javax.management.remote.JMXConnector;
import javax.management.remote.JMXConnectorFactory;
import javax.management.remote.JMXServiceURL;
import com.kabira.platform.Transaction;
import com.kabira.platform.Transaction.InvalidTransactionState;

/**
 * Provides a mechanism for calling administration targets from test code.
 */
public class Client
{
    /**
     * Create a new Client instance using the given userName and password.
     * @param userName a configured principal on the node
     * @param password the text credential for the principal
     */
    public Client(String userName, String password)
    {
        m_userName = userName;
        m_password = password;
    }

    /**
     * Execute an administration command.
     * All administration targets and commands are supported
     * except "load configuration", which is supported by the
     * nested Configuration class, and "loadactivate configuration", which is
     * not supported.
     * The administration target will always run on the same node as
     * the application calling runCommand.
     * 
     * @param command the command name
     * @param target the target name
     * @param parameters a map containing parameter names and values
     * @return The output of the command
     * @throws CommandFailed an unsupported command was specified or the 
     * invocation of the command failed.
     * @throws InvalidTransactionState called from a transactional context.
     */
    public String[] runCommand(
            final String command,
            final String target,
            final HashMap<String, String> parameters)
            throws CommandFailed, InvalidTransactionState
    {
        if (target.equals("configuration"))
        {
            if (command.equals("load"))
            {
                throw new CommandFailed("load configuration is not supported " +
                        "by runCommand.  Use loadConfigurationData() or " +
                        "loadConfigurationResource() instead.");
            }
            else if (command.equals("loadactivate"))
            {
                throw new CommandFailed(
                        "loadactivate configuration is not supported");
            }
        }

        jmxConnect();
        
        String[] params = null;

        if (parameters != null)
        {
            params = new String[parameters.size()];
            int i = 0;

            for (Entry entry : parameters.entrySet())
            {
                params[i++] = (String) entry.getKey() + "=" + (String) entry.
                        getValue();
            }
        }

        return invoke(command, target, params);
    }
        /**
         * performs cleanup action.
         * closes jmx connection, if not done already
         * this is generally called by finalize method which is called by garbage
         * collector to do cleanup;  
         * this is made public so that calling class can do cleanup to release 
         * resources without having to wait for garbage collector.
         */
        public  void tearDown()
        {
                try
                {
                        if(m_jmxConnector != null)
                        {
                                m_jmxConnector.close();
                        }
                }
                catch (IOException ex)
                {
                Logger l = Logger.getLogger("");
                l.log(Level.WARNING,
                        "Failed to close jmx connector file", ex);
                }
        }
        @Override
        protected void finalize() throws Throwable
        {
                super.finalize();
                tearDown();
        }
    /**
     * Provides a mechanism for loading and managing configuration data.
     */
    public final class Configuration
    {
        /**
         * Create a new Configuration instance to manage the supplied
         * configuration data 
         * @param url the URL of the configuration data.
         */
        public Configuration(final URL url)
        {
            m_url = url;
        }

        /**
         * Load configuration data.
         * @throws CommandFailed the URL could not be opened, or the
         * configuration failed audit.
         * @throws InvalidTransactionState called from a transactional context.
         */
        public void load() throws CommandFailed, InvalidTransactionState
        {
            jmxConnect();

            InputStream is;

            try
            {
                is = m_url.openStream();
            }
            catch (IOException ex)
            {
                throw new CommandFailed("failed to open URL " +
                        m_url.toString() + ": " + ex.getMessage());
            }

            String data = readInputStream(is);

            Object[] params = new Object[]
                {
                    m_url.toString(),
                    data,
                    new Boolean(false),
                    new Boolean(false),
                };

            String[] sig = new String[]
                {
                    "java.lang.String",
                    "java.lang.String",
                    "java.lang.Boolean",
                    "java.lang.Boolean",
                };

            String[] results = doInvoke(m_configurationName,
                        "loadNamedResource", params, sig);

            m_versionInfo = new HashMap<String, String>();

            for (String r : results)
            {
                String[]nv = r.replaceAll("\\s", "").split("=");
                m_versionInfo.put(nv[0], nv[1]);
            }

            assert(m_versionInfo.get("type") != null);
            assert(m_versionInfo.get("name") != null);
            assert(m_versionInfo.get("version") != null);

            m_parameters = new String[]
                {
                    "type=" + m_versionInfo.get("type"),
                    "name=" + m_versionInfo.get("name"),
                    "version=" + m_versionInfo.get("version")
                };
        }

        /**
         * Activate the current configuration.  Configuration must have been
         * loaded by this instance of Configuration.
         * @throws CommandFailed the configuration was not loaded by this
         * Configuration instance or the configuration is already active.
         * @throws InvalidTransactionState called from a transactional context.
         */
        public void activate() throws CommandFailed, InvalidTransactionState
        {
            checkLoaded();
            invoke("activate", "configuration", m_parameters);
        }

        /**
         * Deactivate the current configuration.  Configuration must have been
         * loaded by this instance of Configuration.
         * @throws CommandFailed the configuration was not loaded by this
         * Configuration instance or the configuration is not active.
         * @throws InvalidTransactionState called from a transactional context.
         */
        public void deactivate() throws CommandFailed, InvalidTransactionState
        {
            checkLoaded();
            invoke("deactivate", "configuration", m_parameters);
        }

        /**
         * Remove the current configuration. Configuration must have been
         * loaded by this instance of Configuration.
         * @throws CommandFailed the configuration was not loaded by this
         * Configuration instance or the configuration has already been
         * removed.
         * @throws InvalidTransactionState called from a transactional context.
         */
        public void remove() throws CommandFailed, InvalidTransactionState
        {
            checkLoaded();
            invoke("remove", "configuration", m_parameters);
        }

        /**
         *
         * Display the current Configuration. Configuration must have been
         * loaded by this instance of Configuration.
         * @return All available information about the configuration.
         * @throws CommandFailed the configuration was not loaded by this
         * Configuration instance.
         * @throws InvalidTransactionState called from a transactional context.
         */
        public String[] display() throws CommandFailed, InvalidTransactionState
        {
            checkLoaded();
            return invoke("display", "configuration", m_parameters);
        }

        /**
         * Export the current configuration.  Configuration must have been
         * loaded by this instance of Configuration.
         * @return The configuration data formatted as a kcs file.
         * @throws CommandFailed the configuration was not loaded by this
         * Configuration instance.
         * @throws InvalidTransactionState called from a transactional context.
         */
        public String[] export() throws CommandFailed, InvalidTransactionState
        {
            checkLoaded();
            return invoke("export", "configuration", m_parameters);
        }

        /**
         * Get the type of the currently-loaded configuration.
         * @return the type of the currently-loaded configuration.
         * @throws CommandFailed the configuration was not loaded by this
         * Configuration instance.
         */
        public String getType() throws CommandFailed
        {
            checkLoaded();
            return m_versionInfo.get("type");
        }

        /**
         * Get the name of the currently-loaded configuration.
         * @return the name of the currently-loaded configuration
         * @throws CommandFailed the configuration was not loaded by this
         * Configuration instance.
         */
        public String getName() throws CommandFailed
        {
            checkLoaded();
            return m_versionInfo.get("name");
        }

        /**
         * Get the version of the currently-loaded configuration.
         * @return the version of the currently-loaded configuration
         * @throws CommandFailed the configuration was not loaded by this
         * Configuration instance.
         */
        public String getVersion() throws CommandFailed
        {
            checkLoaded();
            return m_versionInfo.get("version");
        }

        /**
         * Get the state of the currently-loaded configuration.
         * @return the state of the currently-loaded configuration
         * @throws CommandFailed the configuration was not loaded by this
         * Configuration instance.
         * @throws InvalidTransactionState called from a transactional context.
         */
        public ConfigurationState getState()
            throws CommandFailed, InvalidTransactionState
        {
            checkLoaded();

            assert(m_parameters.length == 3);

            String[] parameters = new String[]
                    {
                        m_parameters[0],
                        m_parameters[1],
                        m_parameters[2],
                        "delimiter=|"
                    };

            String[] display = invoke("display", "configuration", parameters);

            assert(display.length == 2);

            String[] names = display[0].split("\\|");
            String[] values = display[1].split("\\|");

            assert(names.length == values.length);

            ConfigurationState state = null;

            for (int i = 0; i < names.length; i++)
            {
                if (names[i].equals("State"))
                {
                    if (values[i].equals("Active"))
                    {
                        state = ConfigurationState.Active;
                    }
                    else
                    {
                        state = ConfigurationState.Inactive;
                    }
                    break;
                }
            }

            return state;
        }

        private void checkLoaded() throws CommandFailed
        {
            if (m_parameters == null)
            {
                throw new CommandFailed("Configuration is not loaded");
            }
        }

        private URL m_url;
        private String[] m_parameters = null;
        private HashMap<String, String> m_versionInfo;
    }

    private String[] invoke(String command, String target,
            String[] parameters)
            throws CommandFailed, InvalidTransactionState
    {
        int numArgs = 2;

        if (parameters != null)
        {
            numArgs += 1;
        }

        Object result = null;
        Object[] params = new Object[numArgs];
        String[] sig = new String[numArgs];

        params[0] = new String(command);
        params[1] = new String(target);

        if (parameters != null)
        {
            String allargs = new String();

            for (String p : parameters)
            {
                if (!allargs.isEmpty())
                {
                    allargs += " ";
                }
                allargs += p;
            }
            params[2] = allargs;
        }

        for (int i = 0; i < numArgs; i++)
        {
            sig[i] = new String("java.lang.String");
        }

        return doInvoke(m_pluginServiceName, "execute", params, sig);

    }

    private String[] doInvoke(ObjectName name,
            String command, Object[] args, String[] sig)
            throws CommandFailed, InvalidTransactionState
    {
        //
        // fail if there is an active transaction
        //
        checkInTransaction();

        try
        {
            return (String[]) m_mbsc.invoke(name, command, args, sig);
        }
        catch (Exception ex)
        {
            throw new CommandFailed(ex);
        }
    }

    private String readInputStream(InputStream stream) throws CommandFailed
    {
        BufferedReader reader = new BufferedReader(
                new InputStreamReader(stream));

        StringBuffer stringBuffer = new StringBuffer();

        char[] buffer = new char[1024];
        int bytesRead;
        CommandFailed commandFailed = null;

        try
        {
            while ((bytesRead = reader.read(buffer, 0, buffer.length)) != -1)
            {
                stringBuffer.append(buffer, 0, bytesRead);
            }
        }
        catch (IOException ex)
        {
            commandFailed = new CommandFailed(ex);
        }

        try
        {
            stream.close();
        }
        catch (IOException ex)
        {
            if (commandFailed == null)
            {
                commandFailed = new CommandFailed(ex);
            }
        }

        if (commandFailed != null)
        {
            throw commandFailed;
        }

        return stringBuffer.toString();
    }

    private void jmxConnect() throws CommandFailed
    {
        if (m_mbsc != null)
        {
            return;
        }

        String host;
        String port = System.getProperty(
                        "com.kabira.management.jmxregistryport");

        if (port == null)
        {
            throw new CommandFailed("System property " +
                    "com.kabira.management.jmxregistryport is not available " +
                    "in this engine - is the adminservice component " +
                    "installed?");
        }

        try
        {
            host = InetAddress.getLocalHost().getHostName();
        }
        catch (UnknownHostException ex)
        {
            throw new CommandFailed(ex);
        }

        String addr = "service:jmx:rmi:///jndi/rmi://" +
                host + ":" + port + "/jmxrmi";

        JMXServiceURL url = null;
        try
        {
            url = new JMXServiceURL(addr);
        }
        catch (MalformedURLException ex)
        {
            throw new CommandFailed(ex);
        }

        HashMap<String, String[]> env = new HashMap<String, String[]>();

        env.put("jmx.remote.credentials",
            new String[] { m_userName, m_password });

        try
        {
            m_jmxConnector = JMXConnectorFactory.connect(url, env);
            m_mbsc = m_jmxConnector.getMBeanServerConnection();
        }
        catch (java.io.IOException ex)
        {
            throw new CommandFailed(ex);
        }

        try
        {
            m_pluginServiceName = new ObjectName(
                    "com.kabira.platform.management", "type", "Management");
            m_configurationName = new ObjectName(
                    "com.kabira.platform.management", "type", "Configuration");
        }
        catch (MalformedObjectNameException ex)
        {
            throw new CommandFailed(ex);
        }
        catch (NullPointerException ex)
        {
            throw new CommandFailed(ex);
        }
    }

    private void checkInTransaction() throws InvalidTransactionState
    {
        new Transaction()
        {
            public void run() throws Transaction.Rollback
            {
            }
        }.execute();
    }
  
    private String m_userName;
    private String m_password;
    private MBeanServerConnection m_mbsc = null;
    private ObjectName m_pluginServiceName = null;
    private ObjectName m_configurationName = null;
        private JMXConnector m_jmxConnector = null;
}