/*
    * Created on Feb 3, 2004
    *
    */
   
   package org.neo.swarm.config;
   
   import java.io.IOException;
   import java.net.BindException;
  import java.net.InetAddress;
  import java.net.UnknownHostException;
  import java.util.HashMap;
  import java.util.Map;
  
  import javax.management.AttributeNotFoundException;
  import javax.management.InstanceAlreadyExistsException;
  import javax.management.InstanceNotFoundException;
  import javax.management.MBeanException;
  import javax.management.MBeanRegistrationException;
  import javax.management.MBeanServer;
  import javax.management.MBeanServerFactory;
  import javax.management.MalformedObjectNameException;
  import javax.management.NotCompliantMBeanException;
  import javax.management.ObjectName;
  import javax.management.ReflectionException;
  import javax.management.remote.JMXConnectorServer;
  import javax.management.remote.JMXConnectorServerFactory;
  import javax.management.remote.JMXServiceURL;
  import javax.naming.Context;
  
  import mx4j.adaptor.http.HttpAdaptor;
  import mx4j.adaptor.http.XSLTProcessor;
  import mx4j.log.Log;
  
  import org.neo.swarm.ApplicationContext;
  import org.neo.swarm.SwarmContainer;
  import org.neo.swarm.interceptor.jmx.Jmx;
  
  /***
   * Same as SimpleConfig but uses JMX orthogonal aspects for JMX Management wih MX4J.
   * 
   * @author navery
   */
  public class JMXConfig extends DynamicConfig {
  
  	int jmxPort;
  	InetAddress multicastAddress;
  	int multicastPort = 5000;
  	int bindSleepPeriod = 3 * 1000;
  	private MBeanServer jmxServer;
  	private int namingPort = 8999;
  
  	public JMXConfig(String uri, InetAddress myAddress, int myPort, int JmxPort, boolean loggingEabled) {
  		super(uri, myAddress, myPort, loggingEabled);
  		this.uri = uri;
  		this.jmxPort = JmxPort;
  		try {
  			this.multicastAddress = InetAddress.getByName("225.0.0.1");
  		} catch (UnknownHostException e) {
  			e.printStackTrace();
  		}
  	}
  
  	/*
  	 * (non-Javadoc)
  	 * 
  	 * @see org.neo.swarm.config.Config#setup()
  	 */
  	public SwarmContainer setup() throws Exception {
          jmxServer = MBeanServerFactory.createMBeanServer();
  
  		super.setup();
  
  		startHttpAdaptor();
  		startRMIAdaptor();
  
  
  		ApplicationContext ac = container.getAppContext(uri);
  		ac.addOrthogonalAspect(new Jmx("USER", "ASPECT", jmxServer)); // manage aspects on user components
  		ac.addAspect(new Jmx("USER", "COMP", jmxServer)); // manage user components
  		return container;
  	}
      protected void setupTcpService(ApplicationContext context) throws Exception  {
          // manage System Aspects (on components)
          container.addOrthogonalServiceAspect(new Jmx("SERVICE", "ASPECT", jmxServer));
  
          // control System Services via JMX
          container.addServiceAspect(new Jmx("SERVICE", "MGMT", jmxServer));
          super.setupTcpService(context);   
      }
  	/***
  	 * Starts the http server on the configured port.
  	 *  
  	 */
  	public void startHttpAdaptor() {
  		try {
  
  			// Redirect MX4J logging to Log4J
  //			Log.redirectTo(new Log4JLogger());
 			Log.redirectTo(null);
 
 			XSLTProcessor xslt = new XSLTProcessor();
 			ObjectName xsltName = new ObjectName("Server:serviceName=XSLTProcessor");
 			jmxServer.registerMBean(xslt, xsltName);
 			xslt.setUseCache(false);
 			//		xslt.setPathInJar("/mx4j/adaptor/http/xsl");
 			xslt.setLocaleString("en");
 			//	xslt.setFile("src/resources/jmx/xsl");
 
 			HttpAdaptor adapter = new HttpAdaptor();
 			ObjectName httpName = new ObjectName("Server:serviceName=HttpAdaptor");
 
 			adapter.setPort(this.jmxPort);
 			adapter.setProcessorName(xsltName);
 			jmxServer.registerMBean(adapter, httpName);
 			adapter.start();
 
 			// drop the MBeanServer into the Services Container
 			container.registerServiceInstance("mx4j", jmxServer);
 		} catch (BindException e) {
 			e.printStackTrace();
 		} catch (Exception e) {
 			e.printStackTrace();
 		}
 	}
 
 	/*** Class to use for the naming service. */
 	private static final String NAMING_SERVICE_CLASS_NAME = "mx4j.tools.naming.NamingService";
 	/*** The Jmx type string. */
 	private static final String REGISTRY_OBJECT_NAME_STRING = "Naming:type=rmiregistry";
 
 	/*** com.sun.jndi.rmi.registry.RegistryContextFactory */
 	String InitialContextFactoryClass = "com.sun.jndi.rmi.registry.RegistryContextFactory";
 
 	/***
 	 * Support for MC4J to connect using RMI, see http://mc4j.sourceforge.net
 	 */
 	public void startRMIAdaptor() {
 
 		try {
 			startMBeanNamingService();
 
             JMXServiceURL url = new JMXServiceURL("rmi", this.address.getHostName(), namingPort, "/jndi/jrmp");
             Map environment = new HashMap();
             environment.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.rmi.registry.RegistryContextFactory");
             environment.put(Context.PROVIDER_URL, "rmi://localhost:" + namingPort);
             
 			JMXConnectorServer connectorServer = JMXConnectorServerFactory.newJMXConnectorServer(url, environment, null);    
 			ObjectName connectorServerName = ObjectName.getInstance("connectors:protocol=" + url.getProtocol());
           
 			jmxServer.registerMBean(connectorServer, connectorServerName);
 			connectorServer.start();
 		} catch (NotCompliantMBeanException ex) {
 			ex.printStackTrace();
 		} catch (MalformedObjectNameException ex) {
 			ex.printStackTrace();
 		} catch (MBeanException ex) {
 			ex.printStackTrace();
 		} catch (InstanceAlreadyExistsException ex) {
 			ex.printStackTrace();
 		} catch (IOException ex) {
 			System.out.println("Ignoring = RMI-IOException:" + ex);
 		}
 	}
 
 	private void startMBeanNamingService() {
 		ObjectName namingName;
 		try {
 			namingName = new ObjectName(REGISTRY_OBJECT_NAME_STRING);
     		jmxServer.createMBean(NAMING_SERVICE_CLASS_NAME, namingName, null);
             jmxServer.invoke(namingName, "start", null, null);            
             namingPort = ((Integer)jmxServer.getAttribute(namingName, "Port")).intValue();
             System.out.println("Started naming service on port:"+namingPort);
 //    		jmxServer.setAttribute(namingName, new Attribute("Port", new Integer(namingPort)));
         } catch (MalformedObjectNameException e) {
             e.printStackTrace();
         } catch (InstanceAlreadyExistsException e) {
 			e.printStackTrace();
 		} catch (MBeanRegistrationException e) {
 			e.printStackTrace();
 		} catch (NotCompliantMBeanException e) {
 			e.printStackTrace();
 		} catch (InstanceNotFoundException e) {
 			e.printStackTrace();
 		} catch (ReflectionException e) {
 			e.printStackTrace();
 		} catch (MBeanException e) {
             System.out.println("Ignoring MBeanException:"+e);
 		} catch (AttributeNotFoundException e) {
 			e.printStackTrace();
 		}
         System.out.println("Starting naming service on port:" + namingPort);
 	}
 }