Java Code Examples for javax.management.ObjectName

private static void scanDeployment(MBeanServerConnection connection,HTTPContext httpContext,String archiveName) throws Exception {
  ObjectName earExpression=new ObjectName("*:*,J2EEApplication=" + archiveName);
  Set<ObjectName> deployments=connection.queryNames(earExpression,null);
  for (  ObjectName deployment : deployments) {
    if (deployment.getKeyProperty("j2eeType").equals("WebModule")) {
      scanWar(connection,httpContext,deployment);
    }
  }
  ObjectName warExpression=new ObjectName("*:*,J2EEApplication=null,j2eeType=WebModule,name=" + archiveName);
  Set<ObjectName> warDeployments=connection.queryNames(warExpression,null);
  for (  ObjectName warDeployment : warDeployments) {
    scanWar(connection,httpContext,warDeployment);
  }
}
 

private void unregister(Hashtable<String,String> attributes){
  try {
    ObjectName name=this.createObjectName(attributes);
    if (this.server.isRegistered(name)) {
      this.server.unregisterMBean(name);
    }
  }
 catch (  Exception e) {
    logger.log(Level.WARN,e);
  }
}
 

/** 
 * Testing code.
 * @param args Command line arguments.
 * @throws NullPointerException 
 * @throws MalformedObjectNameException 
 * @throws NamingException 
 * @throws InvalidNameException 
 */
public static void main(String[] args) throws MalformedObjectNameException, NullPointerException, InvalidNameException, NamingException {
  final ObjectName on=new ObjectName("org.archive.crawler:" + "type=Service,name=Heritrix00,host=debord.archive.org");
  Context c=getSubContext(getCompoundName(on.getDomain()));
  CompoundName key=bindObjectName(c,on);
  Reference r=(Reference)c.lookup(key);
  for (Enumeration<RefAddr> e=r.getAll(); e.hasMoreElements(); ) {
    System.out.println(e.nextElement());
  }
  unbindObjectName(c,on);
}
 

public ObjectName registerMBean(MBeanServer mbeanServer) throws JMException {
  ObjectName oname=new ObjectName(JMXTestRunnerMBean.OBJECT_NAME);
  mbeanServer.registerMBean(this,oname);
  log.fine("JMXTestRunner registered: " + oname);
  localMBeanServer=mbeanServer;
  return oname;
}
 

/** 
 * @param connection
 * @param httpContext
 * @param archiveName
 */
private static void scanDeployment(MBeanServerConnection connection,HTTPContext httpContext,String archiveName) throws Exception {
  ObjectName earExpression=new ObjectName("*:*,J2EEApplication=" + archiveName);
  Set<ObjectName> deployments=connection.queryNames(earExpression,null);
  for (  ObjectName deployment : deployments) {
    if (deployment.getKeyProperty("j2eeType").equals("WebModule")) {
      scanWar(connection,httpContext,deployment);
    }
  }
}
 

/** 
 * The initialize method.
 */
@PostConstruct public void init(){
  LOG.info("Register the ACManagement MBean: " + _acManager);
  try {
    MBeanServer mbs=ManagementFactory.getPlatformMBeanServer();
    ObjectName objname=new ObjectName(OBJECT_NAME_DOMAIN + OBJECT_NAME_MANAGER);
    mbs.registerMBean(this,objname);
  }
 catch (  Exception e) {
    LOG.log(Level.SEVERE,java.util.PropertyResourceBundle.getBundle("active-collection-jee.Messages").getString("ACTIVE-COLLECTION-JEE-1"),e);
  }
  _acManager.addActiveCollectionListener(this);
}
 

/** 
 * Register the INSTANCE as an mbean under the given name.
 * @param name - the object name string to register the INSTANCE under
 */
public void registerHelperMBean(String name){
synchronized (createMap) {
    MBeanServer mbs=ManagementFactory.getPlatformMBeanServer();
    try {
      ObjectName oname=new ObjectName(name);
      if (mbs.isRegistered(oname) == false)       mbs.registerMBean(INSTANCE,oname);
    }
 catch (    Exception e) {
      e.printStackTrace();
    }
  }
}
 

public synchronized void testEnpointConfigurationCanBeSetViaJMX() throws Exception {
  Set s=mbsc.queryNames(new ObjectName(domainName + ":type=endpoints,*"),null);
  assertEquals("Could not find  endpoints: " + s,2,s.size());
  ObjectName zepName=new ArrayList<ObjectName>(s).get(0);
  verifyManagedAttribute(zepName,"Path","/someotherpath");
  verifyManagedAttribute(zepName,"Create",true);
  verifyManagedAttribute(zepName,"Repeat",true);
  verifyManagedAttribute(zepName,"ListChildren",true);
  verifyManagedAttribute(zepName,"AwaitExistence",true);
  verifyManagedAttribute(zepName,"Timeout",12345);
  verifyManagedAttribute(zepName,"Backoff",12345L);
  mbsc.invoke(zepName,"clearServers",null,JmxUtils.getMethodSignature(ZooKeeperEndpoint.class.getMethod("clearServers",null)));
  mbsc.invoke(zepName,"addServer",new Object[]{"someserver:12345"},JmxUtils.getMethodSignature(ZooKeeperEndpoint.class.getMethod("addServer",new Class[]{String.class})));
}
 

/** 
 * Gets the queue control management class
 * @param queueAddress Address of queue
 * @param queueName Name of queue
 * @return <code>QueueControl</code> that can be used for managing queues. Null if returned if queue not found
 * @throws Exception
 */
public QueueControl getQueueControl(String queueAddress,String queueName) throws Exception {
  ObjectName objectName=ObjectNameBuilder.DEFAULT.getQueueObjectName(new SimpleString(queueAddress),new SimpleString(queueName));
  if (!_hornetqServer.getMBeanServer().isRegistered(objectName)) {
    return null;
  }
  return (QueueControl)MBeanServerInvocationHandler.newProxyInstance(_hornetqServer.getMBeanServer(),objectName,QueueControl.class,false);
}
 

@Override public void doProcess(HttpServletRequest request,MBeanServerConnection mbsc) throws Exception {
  String name=request.getParameter(Parameters.OBJECT_NAME);
  ObjectName objectName=new ObjectName(name);
  if (isContext(objectName,mbsc)) {
    mbsc.invoke(objectName,"start",null,null);
    String path=(String)mbsc.getAttribute(objectName,"contextPath");
    request.getSession().setAttribute(Attributes.INFO,"Application with context path " + path + " sucessfully started");
  }
 else   request.getSession().setAttribute(Attributes.WARN,"Could not found application");
}
 

private void registerMBean(){
  if (configuration == null) {
    return;
  }
  if (configuration.isJmxEnabled()) {
    try {
      ObjectName name=new ObjectName(configuration.getJmxDomain() + ":name=" + configuration.getName());
      ManagementFactory.getPlatformMBeanServer().registerMBean(this,name);
    }
 catch (    Exception e) {
      logger.error("Unable to register DefaultSmppServerMXBean [{}]",configuration.getName(),e);
    }
  }
}
 

/** 
 * Shuts down or restarts this node.
 * @param restart true to restart the node, false to just shut down.
 */
protected void shutdownOrRestartNode(boolean restart){
  String method=restart ? "restart" : "shutdown";
  logger.info("Node {} requested.",method);
  final MBeanServer platformMBeanServer=ManagementFactory.getPlatformMBeanServer();
  ObjectName nodeAdminName=MBeanUtils.objectNameFor(logger,JPPFNodeAdminMBean.MBEAN_NAME);
  MBeanUtils.invoke(logger,platformMBeanServer,nodeAdminName,method);
}
 

@Test public void doTest() throws Exception {
  ObjectName beanName=new ObjectName("com.nesscomputing.config:n0=com,n1=nesscomputing,n2=config,n3=JmxExporterTest$MyBean");
  Assert.assertEquals("foo",server.getAttribute(beanName,"x"));
  Assert.assertEquals("3",server.getAttribute(beanName,"y"));
  Assert.assertEquals("10s",server.getAttribute(beanName,"z"));
}
 

public void registerStatistics(NamedStatistics s){
  try {
    ObjectName objName=new ObjectName(getServerName() + ":name=" + s.getName());
    registerMBean(s,objName);
  }
 catch (  Exception e) {
    e.printStackTrace();
  }
}
 

private void unregisterClassLoaderMBean(){
  try {
    StandardContext ctx=(StandardContext)getContainer();
    ObjectName classLoaderObjectName=createClassLoaderObjectName(ctx);
    Registry.getRegistry(null,null).unregisterComponent(classLoaderObjectName);
  }
 catch (  Throwable t) {
    log.error("LifecycleException ",t);
  }
}
 

@Override public final void unregister(final GnipStream stream){
  final ObjectName name=getStreamName(stream);
  try {
    ManagementFactory.getPlatformMBeanServer().unregisterMBean(name);
  }
 catch (  MBeanRegistrationException e) {
    throw new RuntimeException(e);
  }
catch (  InstanceNotFoundException e) {
    logger.warn("Unknown stream: " + name);
  }
}
 

private void kill(String nodeName) throws Exception {
  ObjectName on=ObjectName.getInstance("org.hornetq." + nodeName + ":module=Core,type=Server");
  JMXConnector connector=JMXConnectorFactory.connect(new JMXServiceURL(JMX_URL),new HashMap<String,String>());
  MBeanServerConnection mbsc=connector.getMBeanServerConnection();
  HornetQServerControl serverControl=MBeanServerInvocationHandler.newProxyInstance(mbsc,on,HornetQServerControl.class,false);
  try {
    serverControl.forceFailover();
  }
 catch (  Exception e) {
  }
}
 

private static ObjectName createObjectName(String domain,Hashtable<String,String> properties,String beanName,boolean query,String... extraNaming){
  properties.put("name",beanName);
  for (int i=0; i < extraNaming.length; i++) {
    properties.put("name" + i,extraNaming[i]);
  }
  ObjectName result;
  try {
    result=new ObjectName(domain,properties);
    if (query)     result=ObjectName.getInstance(result.toString() + ",*");
  }
 catch (  MalformedObjectNameException e) {
    return null;
  }
  return result;
}
 

@GET @Produces(MediaType.APPLICATION_JSON) public List<MBeanRepresentation> getMBeans() throws JMException {
  ImmutableList.Builder<MBeanRepresentation> mbeans=ImmutableList.builder();
  for (  ObjectName objectName : mbeanServer.queryNames(new ObjectName("*:*"),null)) {
    mbeans.add(new MBeanRepresentation(mbeanServer,objectName,objectMapper));
  }
  return mbeans.build();
}
 

private static ObjectName getJMXObjectName(AbstractConfiguration config,ConfigMBean bean) throws Exception {
  try {
    Class<? extends ConfigMBean> c=bean.getClass();
    String className=c.getName();
    int lastDot=className.lastIndexOf('.');
    ObjectName name=new ObjectName("Config-" + className.substring(0,lastDot) + ":class="+ className.substring(lastDot + 1));
    return name;
  }
 catch (  MalformedObjectNameException e) {
    throw new RuntimeException("MalformedObjectNameException",e);
  }
catch (  NullPointerException e) {
    throw new RuntimeException("NullPointerException",e);
  }
}
 

private void init(){
  JMXClient client=null;
  try {
    client=new JMXClient(String.format("%s:%s",host,guiceDefaults.getJmxPort()));
    ObjectName objectName=new ObjectName(NING_JMX_NAME_MONITORING_PROFILE);
    if (client.getMBeanServerConnection().isRegistered(objectName)) {
      String[] list=(String[])client.getMBeanServerConnection().getAttribute(objectName,ATTR_MONITORING_PROFILE);
      for (      String line : list) {
        try {
          Config config=parseOldFormatLine(line);
          if (config != null) {
            configs.add(config);
          }
        }
 catch (        Exception e) {
          log.info(e,"Could not parse config line '" + line + "', for '"+ host+ ":"+ guiceDefaults.getJmxPort()+ "', for core monitoring file");
        }
      }
      log.info("Loaded " + configs.size() + " configs via registered monitoring profile for host '"+ host+ "'");
    }
 else {
      log.info("No registered monitoring profile found for host '" + host + "'");
    }
  }
 catch (  Exception e) {
    log.info("Could not poll '" + host + ":"+ guiceDefaults.getJmxPort()+ "' for core monitoring file",e);
  }
 finally {
    if (client != null) {
      try {
        client.close();
      }
 catch (      IOException e) {
        log.warn("Problem closing jmx client connection",e);
      }
    }
  }
}
 

protected Set<ObjectInstance> getServletMBeans(JMXConnector jmxc,String context) throws IOException {
  MBeanServerConnection mbsc=jmxc.getMBeanServerConnection();
  String catalinaServlet=String.format(catalinaServletTemplate,configuration.getJmxVirtualHost(),context);
  ObjectName servletON;
  try {
    servletON=ObjectName.getInstance(catalinaServlet);
  }
 catch (  MalformedObjectNameException e) {
    throw new IllegalArgumentException("Unable to retrieve catalina MBeans for protocol metadata construction.\n" + "Following object name is not valid: " + catalinaServlet,e);
  }
catch (  NullPointerException e) {
    throw new IllegalArgumentException("Unable to retrieve catalina MBeans for protocol metadata construction.\n" + "Object name must not be null",e);
  }
  return mbsc.queryMBeans(servletON,null);
}
 

public DeploymentNotificationListener(AdminClient adminClient,NotificationFilterSupport support,Object handBack,String eventTypeToCheck) throws Exception {
  super();
  this.adminClient=adminClient;
  this.filterSupport=support;
  this.eventTypeToCheck=eventTypeToCheck;
  this.objectName=(ObjectName)adminClient.queryNames(new ObjectName("WebSphere:type=AppManagement,*"),null).iterator().next();
  adminClient.addNotificationListener(objectName,this,filterSupport,handBack);
}
 

public synchronized void registerMonitor(String name,ConnectionPool<?> pool){
  String monitorName=generateMonitorName(name);
  if (!monitors.containsKey(monitorName)) {
    JmxConnectionPoolMonitorMBean mbean;
    try {
      LOG.info("Registering mbean: " + monitorName);
      ObjectName oName=new ObjectName(monitorName);
      mbean=new JmxConnectionPoolMonitor(pool);
      monitors.put(monitorName,mbean);
      mbs.registerMBean(mbean,oName);
    }
 catch (    Exception e) {
      LOG.error(e.getMessage());
      monitors.remove(monitorName);
    }
  }
}
 

private static boolean isDeployQueue(String serviceName) throws Exception {
  boolean conversational=false;
  String type="queue";
  if (!serviceName.startsWith(".")) {
    conversational=(Boolean)getProperty("blacktie." + serviceName + ".conversational");
    type=(String)getProperty("blacktie." + serviceName + ".type");
  }
  String prefix=null;
  if (conversational) {
    prefix="BTC_";
  }
 else {
    prefix="BTR_";
  }
  ObjectName objName=new ObjectName("jboss.as:subsystem=messaging,hornetq-server=default,jms-" + type + "="+ prefix+ "*");
  ObjectInstance[] dests=getMBeanServerConnection().queryMBeans(objName,null).toArray(new ObjectInstance[]{});
  for (int i=0; i < dests.length; i++) {
    String serviceComponentOfObjectName=dests[i].getObjectName().getCanonicalName();
    serviceComponentOfObjectName=serviceComponentOfObjectName.substring(serviceComponentOfObjectName.indexOf('_') + 1,serviceComponentOfObjectName.indexOf(",",serviceComponentOfObjectName.indexOf('_')));
    log.debug("Service name component of ObjectName is: " + serviceComponentOfObjectName);
    if (serviceComponentOfObjectName.equals(serviceName)) {
      log.debug("find serviceName " + serviceName + " in Queues");
      return true;
    }
  }
  log.trace("did not find serviceName " + serviceName);
  return false;
}
 

/** 
 * Initialises JMX stuff.
 * @param doRegister if true, perform registration, if false unregister
 */
protected void registerUnregisterJMX(boolean doRegister){
  if (this.mbs == null) {
    this.mbs=ManagementFactory.getPlatformMBeanServer();
  }
  try {
    String suffix="";
    if (this.config.getPoolName() != null) {
      suffix="-" + this.config.getPoolName();
    }
    ObjectName name=new ObjectName(MBEAN_BONECP + suffix);
    ObjectName configname=new ObjectName(MBEAN_CONFIG + suffix);
    if (doRegister) {
      if (!this.mbs.isRegistered(name)) {
        this.mbs.registerMBean(this.statistics,name);
      }
      if (!this.mbs.isRegistered(configname)) {
        this.mbs.registerMBean(this.config,configname);
      }
    }
 else {
      if (this.mbs.isRegistered(name)) {
        this.mbs.unregisterMBean(name);
      }
      if (this.mbs.isRegistered(configname)) {
        this.mbs.unregisterMBean(configname);
      }
    }
  }
 catch (  Exception e) {
    logger.error("Unable to start/stop JMX",e);
  }
}
 

@PostConstruct public void createQueues() throws Exception {
  this.log.info("Creating queues ...");
  final MBeanServer mbeanServer=ManagementFactory.getPlatformMBeanServer();
  this.log.info("Found PlatformMBeanServer [{}]",mbeanServer);
  this.log.info("JMX Domains: {}",Arrays.toString(mbeanServer.getDomains()));
  for (  final JmsResources.QueueDefinition queueDef : JmsResources.loanBrokerQueues()) {
    mbeanServer.invoke(new ObjectName("org.hornetq:module=JMS,type=Server"),"createQueue",new Object[]{queueDef.getName(),queueDef.getBinding()},new String[]{"java.lang.String","java.lang.String"});
    this.log.info("Created queue [{}]",queueDef);
  }
}
 

protected void handleJMXBean(final ArrayList<JmxAttribute> resultList,final MBeanServerConnection mbsc,final JmxBeanAttributes t) throws MalformedObjectNameException {
  final ObjectName beanName=new ObjectName(t.getObjectName());
  final String[] attributeNames=t.getAttributeNames();
  try {
    final AttributeList vals=mbsc.getAttributes(beanName,attributeNames);
    @SuppressWarnings("rawtypes") final Iterator it=vals.iterator();
    while (it.hasNext()) {
      final Attribute att=(Attribute)it.next();
      if (att.getValue() instanceof Exception) {
        logger.log(Level.WARNING,"Failed to read JMX attribute: " + att.getName() + " in bean: "+ t.getObjectName(),att.getValue());
      }
 else {
        final JmxAttribute result=t.setValueAndReturnAttribute(att.getName(),att.getValue());
        resultList.add(result);
      }
    }
  }
 catch (  final Exception e) {
    if (logger.isLoggable(Level.WARNING)) {
      logger.warning("Failed to read Attributes for JMX Bean: " + t + ": "+ e.getMessage());
    }
    if (logger.isLoggable(Level.FINE)) {
      logger.log(Level.FINE,"Failed to read Attributes for JMX Bean: " + t,e);
    }
  }
}
 

/** 
 * Assert configuration of an attribute is taken into account and has the same value when queried directly or through the MBean.
 * @param attributeProperty      the property to use to configure the attribute.
 * @param attributePropertyValue the value to use for the attribute.
 * @param attributeName          the name of the attribute in the MBean.
 * @param attributeGetterName    the name of the getter method for the attribute.
 * @throws Exception should not happen.
 */
@Test(dataProvider="testConfigurableAttributeProvider") public void testConfigurableAttribute(String attributeProperty,Object attributePropertyValue,String attributeName,String attributeGetterName) throws Exception {
  final Properties testDataSourceProperties=new Properties();
  testDataSourceProperties.put(attributeProperty,String.valueOf(attributePropertyValue));
  final ManagedBasicDataSource testDataSource=(ManagedBasicDataSource)ManagedBasicDataSourceFactory.createDataSource(testDataSourceProperties);
  final Object attributeValue=getMBeanServerConnection().getAttribute(new ObjectName(testDataSource.getMBeanName()),attributeName);
  assertTrue((ManagedBasicDataSource.class.getMethod(attributeGetterName).invoke(testDataSource)).equals(attributeValue));
}
 

@Override public void init(ServletConfig config) throws ServletException {
  super.init(config);
  try {
    dicomConfig=(DicomConfiguration)Class.forName(config.getInitParameter("dicomConfigurationClass"),false,Thread.currentThread().getContextClassLoader()).newInstance();
    echoSCP=new EchoSCP(dicomConfig,config.getInitParameter("deviceName"));
    echoSCP.start();
    mbean=ManagementFactory.getPlatformMBeanServer().registerMBean(echoSCP,new ObjectName(config.getInitParameter("jmxName")));
  }
 catch (  Exception e) {
    destroy();
    throw new ServletException(e);
  }
}
 

/** 
 * Performs cleanup for deregistering this MBean. Default implementation unregisters MBean instances which are registered using  {@link #registerMBean(Object mbean,ObjectName objectName)}.
 */
public void preDeregister(){
  getLogger().debug("preDeregister called.");
  Enumeration iterator=mbeanList.elements();
  while (iterator.hasMoreElements()) {
    ObjectName name=(ObjectName)iterator.nextElement();
    try {
      server.unregisterMBean(name);
    }
 catch (    InstanceNotFoundException e) {
      getLogger().warn("Missing MBean " + name.getCanonicalName());
    }
catch (    MBeanRegistrationException e) {
      getLogger().warn("Failed unregistering " + name.getCanonicalName());
    }
  }
}
 

@Test public void testRegister() throws Exception {
  assertFalse(mbs.isRegistered(new ObjectName(DOZER_ADMIN_CONTROLLER)));
  platform.registerMBean(DOZER_ADMIN_CONTROLLER,new DozerAdminController());
  assertTrue(mbs.isRegistered(new ObjectName(DOZER_ADMIN_CONTROLLER)));
  platform.unregisterMBean(DOZER_ADMIN_CONTROLLER);
  assertFalse(mbs.isRegistered(new ObjectName(DOZER_ADMIN_CONTROLLER)));
}
 

/** 
 * @throws Exception 
 */
public void stopFraSCAtiService() throws Exception {
  MBeanServer mbs=ManagementFactory.getPlatformMBeanServer();
  ObjectName name;
  try {
    name=new ObjectName("SCA domain:name0=*,*");
    Set<ObjectName> names=mbs.queryNames(name,name);
    for (    ObjectName objectName : names) {
      mbs.unregisterMBean(objectName);
    }
    mbs.unregisterMBean(new ObjectName("org.ow2.frascati.jmx:name=FrascatiJmx"));
  }
 catch (  MalformedObjectNameException e) {
  }
catch (  NullPointerException e) {
  }
catch (  MBeanRegistrationException e) {
  }
catch (  InstanceNotFoundException e) {
  }
  Object lifeCycleController=componentClass.getDeclaredMethod("getFcInterface",new Class<?>[]{String.class}).invoke(factory,new Object[]{"lifecycle-controller"});
  lifecycleClass.getDeclaredMethod("stopFc").invoke(lifeCycleController);
  frascatiService=null;
  frascati=null;
  icl=null;
  Runtime.getRuntime().runFinalization();
  System.gc();
}
 

/** 
 * @param objectName
 * @return
 */
private ObjectName createObjectName(final String objectName){
  try {
    return new ObjectName(objectName);
  }
 catch (  final Exception e) {
    throw new AssertionError(e);
  }
}
 

@Override public void restored(){
  try {
    ManagementFactory.getPlatformMBeanServer().registerMBean(mbean,new ObjectName("com.rubenlaguna.en4j.noterepositoryjdbm:type=JdbmMgmt"));
  }
 catch (  JMException ex) {
  }
}
 

public long getYoungGC(){
  try {
    MBeanServer mbeanServer=ManagementFactory.getPlatformMBeanServer();
    ObjectName objectName;
    if (mbeanServer.isRegistered(new ObjectName("java.lang:type=GarbageCollector,name=ParNew"))) {
      objectName=new ObjectName("java.lang:type=GarbageCollector,name=ParNew");
    }
 else     if (mbeanServer.isRegistered(new ObjectName("java.lang:type=GarbageCollector,name=Copy"))) {
      objectName=new ObjectName("java.lang:type=GarbageCollector,name=Copy");
    }
 else {
      objectName=new ObjectName("java.lang:type=GarbageCollector,name=PS Scavenge");
    }
    return (Long)mbeanServer.getAttribute(objectName,"CollectionCount");
  }
 catch (  Exception e) {
    throw new RuntimeException("error");
  }
}
 

protected MonitoredCounterGroup(Type type,String name,String... attrs){
  this.type=type;
  this.name=name;
  Map<String,AtomicLong> counterInitMap=new HashMap<String,AtomicLong>();
  for (  String attribute : attrs) {
    counterInitMap.put(attribute,new AtomicLong(0L));
  }
  counterMap=Collections.unmodifiableMap(counterInitMap);
  startTime=new AtomicLong(0L);
  stopTime=new AtomicLong(0L);
  try {
    ObjectName objName=new ObjectName("org.apache.flume." + type.name().toLowerCase() + ":type="+ this.name);
    ManagementFactory.getPlatformMBeanServer().registerMBean(this,objName);
    LOG.info("Monitoried counter group for type: " + type + ", name: "+ name+ ", registered successfully.");
  }
 catch (  Exception ex) {
    LOG.error("Failed to register monitored counter group for type: " + type + ", name: "+ name,ex);
  }
}
 

public void registerMBean(){
  try {
    LOG.info("Registering MBean {}",name);
    MBeanServer mbs=ManagementFactory.getPlatformMBeanServer();
    ObjectName mxbeanName=new ObjectName(name);
    mbs.registerMBean(this,mxbeanName);
    this.registered=true;
  }
 catch (  InstanceAlreadyExistsException ex) {
    throw new RuntimeException(ex);
  }
catch (  MBeanRegistrationException ex) {
    throw new RuntimeException(ex);
  }
catch (  NotCompliantMBeanException ex) {
    throw new AssertionError(ex);
  }
catch (  MalformedObjectNameException ex) {
    throw new AssertionError(ex);
  }
}
 

public void registMBean(final Object o,final String name){
  if (null != this.mbs) {
    try {
      this.mbs.registerMBean(o,new ObjectName(o.getClass().getPackage().getName() + ":type=" + o.getClass().getSimpleName()+ (null == name ? ",id=" + o.hashCode() : ",name=" + name + "-"+ o.hashCode())));
    }
 catch (    final Exception e) {
      throw new RuntimeException(e);
    }
  }
}
 

public void setAsText(String text) throws IllegalArgumentException {
  try {
    setValue(new ObjectName(text));
  }
 catch (  MalformedObjectNameException e) {
    throw new IllegalArgumentException("Could not convert ObjectName for " + text + ": "+ e.getMessage());
  }
}
 

/** 
 * Verifies the jmx bean for the region.
 * @param region the refion to verify.
 */
private static void verifyMBean(IdxRegion region) throws Exception {
  final MBeanServer mbs=ManagementFactory.getPlatformMBeanServer();
  ObjectName objectName=IdxRegionMBeanImpl.generateObjectName(region.getRegionInfo());
  MBeanInfo mbeanInfo=mbs.getMBeanInfo(objectName);
  for (  MBeanAttributeInfo aInfo : mbeanInfo.getAttributes()) {
    Object value=mbs.getAttribute(objectName,aInfo.getName());
    if (aInfo.isWritable()) {
      mbs.setAttribute(objectName,new Attribute(aInfo.getName(),value));
    }
  }
  for (  MBeanOperationInfo oInfo : mbeanInfo.getOperations()) {
    if (oInfo.getSignature().length == 0) {
      mbs.invoke(objectName,oInfo.getName(),new Object[]{},new String[]{});
    }
 else {
      LOG.warn("Did not test operation " + oInfo.getName());
    }
  }
}
 

private boolean isServerModuleStarted(String moduleName){
  final String serverModule="org.infinispan:type=Server,name=" + moduleName + ",component=Transport";
  try {
    Set<ObjectInstance> mBeans=(Set<ObjectInstance>)provider.getConnection().queryMBeans(new ObjectName(serverModule),null);
    return mBeans.size() == 1 ? true : false;
  }
 catch (  Exception e) {
    return false;
  }
}
 

private void configureMBeanServer(){
  logger.info("Registering MBeans...");
  mbeanServer=ManagementFactory.getPlatformMBeanServer();
  try {
    jobRefresherName=new ObjectName("azkaban.app.jmx.RefreshJobs:name=jobRefresher");
    jobSchedulerName=new ObjectName("azkaban.app.jmx.jobScheduler:name=jobScheduler");
    mbeanServer.registerMBean(new RefreshJobs(this),jobRefresherName);
    logger.info("Bean " + jobRefresherName.getCanonicalName() + " registered.");
    mbeanServer.registerMBean(new JobScheduler(_schedulerManager,_jobManager),jobSchedulerName);
    logger.info("Bean " + jobSchedulerName.getCanonicalName() + " registered.");
  }
 catch (  Exception e) {
    logger.error("Failed to configure MBeanServer",e);
  }
}
 

private final static void createServerUrl(final int startPort){
  if (serverUrl != null)   return;
  try {
    String hostName=System.getProperty("org.dawb.workbench.jmx.host.name");
    if (hostName == null)     hostName=InetAddress.getLocalHost().getHostName();
    if (hostName == null)     hostName=InetAddress.getLocalHost().getHostAddress();
    if (hostName == null)     hostName="localhost";
    currentPort=getFreePort(startPort);
    serverUrl=new JMXServiceURL("service:jmx:rmi:///jndi/rmi://" + hostName + ":"+ currentPort+ "/workbench");
    REMOTE_WORKBENCH=new ObjectName(RemoteWorkbenchManager.class.getPackage().getName() + ":type=RemoteWorkbench");
  }
 catch (  Exception e) {
    logger.error("Cannot create ObjectName for remotemanager",e);
  }
  logger.debug("Workbench URI: " + serverUrl.getURLPath());
}
 

/** 
 * Registers all the bindings of an Injector with the given MBean server. Consider using the name of your root  {@link Module} class as the domain.
 */
public static void manage(MBeanServer server,String domain,Injector injector){
  for (  Binding<?> binding : injector.getBindings().values()) {
    StringBuilder name=new StringBuilder();
    name.append(domain).append(":");
    Key<?> key=binding.getKey();
    name.append("type=").append(quote(key.getTypeLiteral().toString()));
    Annotation annotation=key.getAnnotation();
    if (annotation != null) {
      name.append(",annotation=").append(quote(annotation.toString()));
    }
 else {
      Class<? extends Annotation> annotationType=key.getAnnotationType();
      if (annotationType != null) {
        name.append(",annotation=").append(quote("@" + annotationType.getName()));
      }
    }
    try {
      server.registerMBean(new ManagedBinding(binding),new ObjectName(name.toString()));
    }
 catch (    MalformedObjectNameException e) {
      throw new RuntimeException("Bad object name: " + name.toString(),e);
    }
catch (    Exception e) {
      throw new RuntimeException(e);
    }
  }
}
 

private void writeDetailsToFile(String id,ObjectName objectName,ObjectInstance bean,MBeanInfo info,String description) throws IOException {
  StringBuilder beanInfo=new StringBuilder(2048);
  String name=objectName.getKeyProperty(BEAN_NAME);
  String name0=objectName.getKeyProperty(BEAN_NAME0);
  if (name0 != null) {
    name+="/" + name0;
  }
  MBeanAttributeInfo[] attributes=info.getAttributes();
  if (attributes.length > 0) {
    beanInfo.append("[[").append(id).append("]]\n" + ".MBean ").append(name).append(" (").append(bean.getClassName()).append(") Attributes\n");
    writeAttributesTable(description,beanInfo,attributes,false);
    writeAttributesTable(description,beanInfo,attributes,true);
    beanInfo.append("\n");
  }
  MBeanOperationInfo[] operations=info.getOperations();
  if (operations.length > 0) {
    beanInfo.append(".MBean ").append(name).append(" (").append(bean.getClassName()).append(") Operations\n");
    writeOperationsTable(beanInfo,operations,false);
    writeOperationsTable(beanInfo,operations,true);
    beanInfo.append("\n");
  }
  if (beanInfo.length() > 0) {
    Writer fw=null;
    try {
      fw=AsciiDocGenerator.getFW("target/docs/ops",id);
      fw.write(beanInfo.toString());
    }
  finally {
      if (fw != null) {
        fw.close();
      }
    }
  }
}
 

public JMXQueryCommand(int port,String host,String username,String password,ObjectName query){
  this.port=port;
  this.host=host;
  this.username=username;
  this.password=password;
  this.query=query;
}
 

public ObjectName getObjectName(Object o,String s) throws MalformedObjectNameException {
  Hashtable<String,String> table=new Hashtable<String,String>();
  table.put("name",s);
  table.put("instance",contextId);
  return ObjectName.getInstance(domain,table);
}