/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.apache.servicemix.jbi.management;
import java.io.IOException;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import javax.jbi.JBIException;
import javax.management.JMException;
import javax.management.MBeanAttributeInfo;
import javax.management.MBeanOperationInfo;
import javax.management.MBeanServer;
import javax.management.MalformedObjectNameException;
import javax.management.ObjectName;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.servicemix.jbi.container.EnvironmentContext;
import org.apache.servicemix.jbi.container.JBIContainer;
import org.apache.servicemix.jbi.framework.ComponentMBeanImpl;
/**
* Management Context applied to a ServiceMix container
*
* @version $Revision: 665810 $
*/
public class ManagementContext extends BaseSystemService implements ManagementContextMBean {
/**
* Default servicemix domain
*/
public static final String DEFAULT_DOMAIN = "org.apache.servicemix";
public static final String DEFAULT_CONNECTOR_PATH = "/jmxrmi";
public static final int DEFAULT_CONNECTOR_PORT = 1099;
private static final Log LOG = LogFactory.getLog(ManagementContext.class);
protected Map<String, ObjectName> systemServices = new ConcurrentHashMap<String, ObjectName>();
private Map<ObjectName, Object> beanMap = new ConcurrentHashMap<ObjectName, Object>();
private MBeanServerContext mbeanServerContext = new MBeanServerContext();
private ExecutorService executors;
/**
* Default Constructor
*/
public ManagementContext() {
mbeanServerContext.setJmxDomainName(DEFAULT_DOMAIN);
}
/**
* Get the Description of the item
*
* @return the description
*/
public String getDescription() {
return "JMX Management";
}
/**
* Get the MBeanServer
*
* @return the MBeanServer
*/
public MBeanServer getMBeanServer() {
return mbeanServerContext.getMBeanServer();
}
/**
* @return the domain
*/
public String getJmxDomainName() {
return mbeanServerContext.getJmxDomainName();
}
/**
* @return Returns the useMBeanServer.
*/
public boolean isUseMBeanServer() {
return mbeanServerContext.isUseMBeanServer();
}
/**
* @param useMBeanServer
* The useMBeanServer to set.
*/
public void setUseMBeanServer(boolean useMBeanServer) {
mbeanServerContext.setUseMBeanServer(useMBeanServer);
}
/**
* @return Returns the createMBeanServer flag.
*/
public boolean isCreateMBeanServer() {
return mbeanServerContext.isCreateMBeanServer();
}
/**
* @param enableJMX
* Set createMBeanServer.
*/
public void setCreateMBeanServer(boolean enableJMX) {
mbeanServerContext.setCreateMBeanServer(enableJMX);
}
public void setNamingPort(int portNum) {
mbeanServerContext.setConnectorPort(portNum);
}
public int getNamingPort() {
return mbeanServerContext.getConnectorPort();
}
public boolean isCreateJmxConnector() {
return mbeanServerContext.isCreateConnector();
}
public void setCreateJmxConnector(boolean createJmxConnector) {
mbeanServerContext.setCreateConnector(createJmxConnector);
}
/**
* Initialize the ManagementContext
*
* @param container
* @param server
* @throws JBIException
*
*/
public void init(JBIContainer container, MBeanServer server) throws JBIException {
if (container.isEmbedded() && server == null) {
mbeanServerContext.setUseMBeanServer(false);
mbeanServerContext.setCreateMBeanServer(false);
mbeanServerContext.setCreateConnector(false);
}
mbeanServerContext.setMBeanServer(server);
try {
mbeanServerContext.start();
} catch (IOException e) {
LOG.error("Failed to start mbeanServerContext", e);
}
this.executors = Executors.newCachedThreadPool();
super.init(container);
}
protected Class<ManagementContextMBean> getServiceMBean() {
return ManagementContextMBean.class;
}
/**
* Start the item.
*
* @exception JBIException
* if the item fails to start.
*/
public void start() throws JBIException {
super.start();
}
/**
* Stop the item. This suspends current messaging activities.
*
* @exception JBIException
* if the item fails to stop.
*/
public void stop() throws JBIException {
super.stop();
}
/**
* Shut down the item. The releases resources, preparatory to
* uninstallation.
*
* @exception JBIException
* if the item fails to shut down.
*/
public void shutDown() throws JBIException {
super.shutDown();
// Unregister all mbeans
ObjectName[] beans = beanMap.keySet().toArray(new ObjectName[beanMap.size()]);
for (int i = 0; i < beans.length; i++) {
try {
unregisterMBean(beans[i]);
} catch (Exception e) {
LOG.debug("Could not unregister mbean", e);
}
}
try {
mbeanServerContext.stop();
} catch (IOException e) {
LOG.debug("Failed to shutdown mbeanServerContext cleanly", e);
}
executors.shutdown();
}
/**
* Get a list of all binding components currently installed.
*
* @return array of JMX object names of all installed BCs.
*/
public ObjectName[] getBindingComponents() {
return container.getRegistry().getBindingComponents();
}
/**
* Lookup a JBI Installable Component by its unique name.
*
* @param componentName -
* is the name of the BC or SE.
* @return the JMX object name of the component's LifeCycle MBean or null.
*/
public ObjectName getComponentByName(String componentName) {
ComponentMBeanImpl component = container.getRegistry().getComponent(componentName);
return component != null ? component.getMBeanName() : null;
}
/**
* Get a list of all engines currently installed.
*
* @return array of JMX object names of all installed SEs.
*/
public ObjectName[] getEngineComponents() {
return container.getRegistry().getEngineComponents();
}
/**
* @return an array of ObjectNames for all Pojo components
*/
public ObjectName[] getPojoComponents() {
return container.getRegistry().getPojoComponents();
}
/**
* Return current version and other info about this JBI Framework.
*
* @return info String
*/
public String getSystemInfo() {
return "ServiceMix JBI Container: version: " + EnvironmentContext.getVersion();
}
/**
* Lookup a system service by name.
*
* @param serviceName -
* is the name of the system service
* @return the JMX object name of the service or null
*/
public ObjectName getSystemService(String serviceName) {
return systemServices.get(serviceName);
}
/**
* Looks up all JBI Framework System Services currently installed.
*
* @return array of JMX object names of system services
*/
public ObjectName[] getSystemServices() {
ObjectName[] result = null;
Collection<ObjectName> col = systemServices.values();
result = new ObjectName[col.size()];
col.toArray(result);
return result;
}
/**
* Check if a given JBI Installable Component is a Binding Component.
*
* @param componentName -
* the unique name of the component
* @return true if the component is a binding
*/
public boolean isBinding(String componentName) {
ComponentMBeanImpl component = container.getRegistry().getComponent(componentName);
return component != null ? component.isBinding() : false;
}
/**
* Check if a given JBI Component is a service engine.
*
* @param componentName -
* the unique name of the component
* @return true if the component is a service engine
*/
public boolean isEngine(String componentName) {
ComponentMBeanImpl component = container.getRegistry().getComponent(componentName);
return component != null ? component.isEngine() : false;
}
/**
* Start a Component
*
* @param componentName
* @return the status
* @throws JBIException
*/
public String startComponent(String componentName) throws JBIException {
String result = "NOT FOUND: " + componentName;
ObjectName objName = getComponentByName(componentName);
if (objName != null) {
ComponentMBeanImpl mbean = (ComponentMBeanImpl) beanMap.get(objName);
if (mbean != null) {
mbean.start();
result = mbean.getCurrentState();
}
}
return result;
}
/**
* Stop a Component
*
* @param componentName
* @return the status
* @throws JBIException
*/
public String stopComponent(String componentName) throws JBIException {
String result = "NOT FOUND: " + componentName;
ObjectName objName = getComponentByName(componentName);
if (objName != null) {
ComponentMBeanImpl mbean = (ComponentMBeanImpl) beanMap.get(objName);
if (mbean != null) {
mbean.stop();
result = mbean.getCurrentState();
}
}
return result;
}
/**
* Shutdown a Component
*
* @param componentName
* @return the status
* @throws JBIException
*/
public String shutDownComponent(String componentName) throws JBIException {
String result = "NOT FOUND: " + componentName;
ObjectName objName = getComponentByName(componentName);
if (objName != null) {
ComponentMBeanImpl mbean = (ComponentMBeanImpl) beanMap.get(objName);
if (mbean != null) {
mbean.shutDown();
result = mbean.getCurrentState();
}
}
return result;
}
/**
* Formulate and return the MBean ObjectName of a custom control MBean for a
* JBI component.
*
* @param type
* @param name
* @return the JMX ObjectName of the MBean, or <code>null</code> if
* <code>customName</code> is invalid.
*/
public ObjectName createCustomComponentMBeanName(String type, String name) {
Map<String, String> result = new LinkedHashMap<String, String>();
result.put("ContainerName", container.getName());
result.put("Type", "Component");
result.put("Name", sanitizeString(name));
result.put("SubType", sanitizeString(type));
return createObjectName(result);
}
/**
* Create an ObjectName
*
* @param provider
* @return the ObjectName
*/
public ObjectName createObjectName(MBeanInfoProvider provider) {
Map<String, String> props = createObjectNameProps(provider);
return createObjectName(props);
}
/**
* Create an ObjectName
*
* @param name
*
* @return the ObjectName
*/
public ObjectName createObjectName(String name) {
ObjectName result = null;
try {
result = new ObjectName(name);
} catch (MalformedObjectNameException e) {
// shouldn't happen
String error = "Could not create ObjectName for " + name;
LOG.error(error, e);
throw new RuntimeException(error);
}
return result;
}
/**
* Create an ObjectName
*
* @param domain
*
* @return the ObjectName
*/
public ObjectName createObjectName(String domain, Map<String, String> props) {
StringBuffer sb = new StringBuffer();
sb.append(domain).append(':');
int i = 0;
for (Iterator it = props.entrySet().iterator(); it.hasNext();) {
Map.Entry entry = (Map.Entry) it.next();
if (i++ > 0) {
sb.append(",");
}
sb.append(entry.getKey()).append("=").append(entry.getValue());
}
ObjectName result = null;
try {
result = new ObjectName(sb.toString());
} catch (MalformedObjectNameException e) {
// shouldn't happen
String error = "Could not create ObjectName for " + props;
LOG.error(error, e);
throw new RuntimeException(error);
}
return result;
}
/**
* Create an ObjectName
*
* @param props
* @return the ObjectName
*/
public ObjectName createObjectName(Map<String, String> props) {
return createObjectName(getJmxDomainName(), props);
}
/**
* Create a String used to create an ObjectName
*
* @param provider
* @return the ObjectName
*/
public Map<String, String> createObjectNameProps(MBeanInfoProvider provider) {
return createObjectNameProps(provider, false);
}
/**
* Create a String used to create an ObjectName
*
* @param provider
* @return the ObjectName
*/
public Map<String, String> createObjectNameProps(MBeanInfoProvider provider, boolean subTypeBeforeName) {
Map<String, String> result = new LinkedHashMap<String, String>();
result.put("ContainerName", container.getName());
result.put("Type", sanitizeString(provider.getType()));
if (subTypeBeforeName && provider.getSubType() != null) {
result.put("SubType", sanitizeString(provider.getSubType()));
}
result.put("Name", sanitizeString(provider.getName()));
if (!subTypeBeforeName && provider.getSubType() != null) {
result.put("SubType", sanitizeString(provider.getSubType()));
}
return result;
}
/**
* The ':' and '/' characters are reserved in ObjectNames
*
* @param in
* @return sanitized String
*/
private static String sanitizeString(String in) {
String result = null;
if (in != null) {
result = in.replace(':', '_');
result = result.replace('/', '_');
result = result.replace('\\', '_');
result = result.replace('?', '_');
result = result.replace('=', '_');
result = result.replace(',', '_');
}
return result;
}
/**
* Register an MBean
*
* @param resource
* @param name
* @param interfaceMBean
* @throws JMException
*/
public void registerMBean(ObjectName name, MBeanInfoProvider resource, Class interfaceMBean) throws JMException {
registerMBean(name, resource, interfaceMBean, resource.getDescription());
}
/**
* Register an MBean
*
* @param resource
* @param name
* @param interfaceMBean
* @param description
* @throws JMException
*/
public void registerMBean(ObjectName name, Object resource, Class interfaceMBean, String description) throws JMException {
if (mbeanServerContext.getMBeanServer() != null) {
Object mbean = MBeanBuilder.buildStandardMBean(resource, interfaceMBean, description, executors);
if (mbeanServerContext.getMBeanServer().isRegistered(name)) {
mbeanServerContext.getMBeanServer().unregisterMBean(name);
}
mbeanServerContext.getMBeanServer().registerMBean(mbean, name);
beanMap.put(name, resource);
}
}
/**
* Retrive an System ObjectName
*
* @param domainName
* @param containerName
* @param interfaceType
* @return the ObjectName
*/
public static ObjectName getSystemObjectName(String domainName, String containerName, Class interfaceType) {
String tmp = domainName + ":ContainerName=" + containerName + ",Type=SystemService,Name=" + getSystemServiceName(interfaceType);
ObjectName result = null;
try {
result = new ObjectName(tmp);
} catch (MalformedObjectNameException e) {
LOG.error("Failed to build ObjectName:", e);
} catch (NullPointerException e) {
LOG.error("Failed to build ObjectName:", e);
}
return result;
}
public static String getSystemServiceName(Class interfaceType) {
String name = interfaceType.getName();
name = name.substring(name.lastIndexOf('.') + 1);
if (name.endsWith("MBean")) {
name = name.substring(0, name.length() - 5);
}
return name;
}
public static ObjectName getContainerObjectName(String domainName, String containerName) {
String tmp = domainName + ":ContainerName=" + containerName + ",Type=JBIContainer";
ObjectName result = null;
try {
result = new ObjectName(tmp);
} catch (MalformedObjectNameException e) {
LOG.debug("Unable to build ObjectName", e);
} catch (NullPointerException e) {
LOG.debug("Unable to build ObjectName", e);
}
return result;
}
/**
* Register a System service
*
* @param service
* @param interfaceType
* @throws JBIException
*/
public void registerSystemService(BaseSystemService service, Class interfaceType) throws JBIException {
try {
String name = service.getName();
if (systemServices.containsKey(name)) {
throw new JBIException("A system service for the name " + name + " is already registered");
}
ObjectName objName = createObjectName(service);
if (LOG.isDebugEnabled()) {
LOG.debug("Registering system service: " + objName);
}
registerMBean(objName, service, interfaceType, service.getDescription());
systemServices.put(name, objName);
} catch (MalformedObjectNameException e) {
throw new JBIException(e);
} catch (JMException e) {
throw new JBIException(e);
}
}
/**
* Unregister a System service
*
* @param service
* @throws JBIException
*/
public void unregisterSystemService(BaseSystemService service) throws JBIException {
String name = service.getName();
if (!systemServices.containsKey(name)) {
throw new JBIException("A system service for the name " + name + " is not registered");
}
ObjectName objName = systemServices.remove(name);
if (LOG.isDebugEnabled()) {
LOG.debug("Unregistering system service: " + objName);
}
unregisterMBean(objName);
}
/**
* Unregister an MBean
*
* @param name
* @throws JBIException
*/
public void unregisterMBean(ObjectName name) throws JBIException {
try {
mbeanServerContext.unregisterMBean(name);
beanMap.remove(name);
} catch (JMException e) {
LOG.error("Failed to unregister mbean: " + name, e);
throw new JBIException(e);
}
}
/**
* Unregister an MBean
*
* @param bean
* @throws JBIException
*/
public void unregisterMBean(Object bean) throws JBIException {
for (Iterator i = beanMap.entrySet().iterator(); i.hasNext();) {
Map.Entry entry = (Map.Entry) i.next();
if (entry.getValue() == bean) {
ObjectName name = (ObjectName) entry.getKey();
unregisterMBean(name);
break;
}
}
}
/**
* Get an array of MBeanOperationInfo
*
* @return array of OperationInfos
* @throws JMException
*/
public MBeanAttributeInfo[] getAttributeInfos() throws JMException {
AttributeInfoHelper helper = new AttributeInfoHelper();
helper.addAttribute(getObjectToManage(), "bindingComponents", "Get list of all binding components");
helper.addAttribute(getObjectToManage(), "engineComponents", "Get list of all engine components");
helper.addAttribute(getObjectToManage(), "pojoComponents", "Get list of all pojo components");
helper.addAttribute(getObjectToManage(), "systemInfo", "Return current version");
helper.addAttribute(getObjectToManage(), "systemServices", "Get list of system services");
return AttributeInfoHelper.join(super.getAttributeInfos(), helper.getAttributeInfos());
}
public MBeanOperationInfo[] getOperationInfos() throws JMException {
OperationInfoHelper helper = new OperationInfoHelper();
ParameterHelper ph = helper.addOperation(getObjectToManage(), "getComponentByName", 1, "look up Component by name");
ph.setDescription(0, "name", "Component name");
ph = helper.addOperation(getObjectToManage(), "getSystemService", 1, "look up System service by name");
ph.setDescription(0, "name", "System name");
ph = helper.addOperation(getObjectToManage(), "isBinding", 1, "Is Component a binding Component?");
ph.setDescription(0, "name", "Component name");
ph = helper.addOperation(getObjectToManage(), "isEngine", 1, "Is Component a service engine?");
ph.setDescription(0, "name", "Component name");
return OperationInfoHelper.join(super.getOperationInfos(), helper.getOperationInfos());
}
}