Example usage for javax.management MBeanServer registerMBean

List of usage examples for javax.management MBeanServer registerMBean

  1. HOME
  2. Java
  3. javax
  4. javax.management.*
  5. MBeanServer
  6. registerMBean

Introduction

In this page you can find the example usage for javax.management MBeanServer registerMBean.

Prototype

public ObjectInstance registerMBean(Object object, ObjectName name)
        throws InstanceAlreadyExistsException, MBeanRegistrationException, NotCompliantMBeanException;

Source Link

Document

Registers a pre-existing object as an MBean with the MBean server.

Usage

From source file:org.wso2.carbon.dataservices.core.DBDeployer.java

/**
 * Registers an MBean representing the given data service.
 *///from w ww.j  a  va 2 s .  c o  m
private void registerMBean(DataService dataService) {
    DataServiceInstanceMBean dsMBean = new DataServiceInstance(dataService);
    MBeanServer server = ManagementFactory.getPlatformMBeanServer();
    if (server != null) {
        try {
            ObjectName objectName = new ObjectName(DBConstants.DATA_SERVICES_JMX_DOMAIN
                    + ":section=Services,service=" + dsMBean.getServiceName());
            try {
                server.unregisterMBean(objectName);
            } catch (Exception ignore) {
                /* ignore if it doesn't exist */
            }
            server.registerMBean(dsMBean, objectName);
        } catch (Exception e) {
            log.error("Error in Registering Data Services MBean", e);
        }
    }
}

From source file:org.jboss.web.tomcat.tc5.session.JBossCacheCluster.java

/**
 * Registers this object and the tree cache (if we created it) with JMX.
 *//*from  w  ww  .j  a va2 s.c  o m*/
private void registerMBeans() {
    try {
        MBeanServer server = getMBeanServer();

        String domain;
        if (container instanceof ContainerBase) {
            domain = ((ContainerBase) container).getDomain();
        } else {
            domain = server.getDefaultDomain();
        }

        String name = ":type=Cluster";
        if (container instanceof Host) {
            name += ",host=" + container.getName();
        } else if (container instanceof Engine) {
            name += ",engine=" + container.getName();
        }

        ObjectName clusterName = new ObjectName(domain + name);

        if (server.isRegistered(clusterName)) {
            log.warn("MBean " + clusterName + " already registered");
        } else {
            this.objectName = clusterName;
            server.registerMBean(this, objectName);
        }

        if (treeCacheLocal) {
            // Register the treeCache
            ObjectName treeCacheName = new ObjectName(treeCacheObjectName);
            server.registerMBean(getTreeCache(), treeCacheName);
        }

    } catch (Exception ex) {
        log.error(ex.getMessage(), ex);
    }
}

From source file:com.bigdata.dastor.service.StorageService.java

public StorageService() {
    MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
    try {/*from  w w  w .  jav  a  2  s .c  o  m*/
        mbs.registerMBean(this, new ObjectName("com.bigdata.dastor.service:type=StorageService"));
    } catch (Exception e) {
        throw new RuntimeException(e);
    }

    bootstrapSet = Multimaps.synchronizedSetMultimap(HashMultimap.<InetAddress, String>create());

    /* register the verb handlers */
    MessagingService.instance.registerVerbHandlers(Verb.BINARY, new BinaryVerbHandler());
    MessagingService.instance.registerVerbHandlers(Verb.MUTATION, new RowMutationVerbHandler());
    MessagingService.instance.registerVerbHandlers(Verb.READ_REPAIR, new ReadRepairVerbHandler());
    MessagingService.instance.registerVerbHandlers(Verb.READ, new ReadVerbHandler());
    MessagingService.instance.registerVerbHandlers(Verb.RANGE_SLICE, new RangeSliceVerbHandler());
    // see BootStrapper for a summary of how the bootstrap verbs interact
    MessagingService.instance.registerVerbHandlers(Verb.BOOTSTRAP_TOKEN,
            new BootStrapper.BootstrapTokenVerbHandler());
    MessagingService.instance.registerVerbHandlers(Verb.STREAM_REQUEST, new StreamRequestVerbHandler());
    MessagingService.instance.registerVerbHandlers(Verb.STREAM_INITIATE, new StreamInitiateVerbHandler());
    MessagingService.instance.registerVerbHandlers(Verb.STREAM_INITIATE_DONE,
            new StreamInitiateDoneVerbHandler());
    MessagingService.instance.registerVerbHandlers(Verb.STREAM_FINISHED, new StreamFinishedVerbHandler());
    MessagingService.instance.registerVerbHandlers(Verb.READ_RESPONSE, new ResponseVerbHandler());
    MessagingService.instance.registerVerbHandlers(Verb.TREE_REQUEST, new TreeRequestVerbHandler());
    MessagingService.instance.registerVerbHandlers(Verb.TREE_RESPONSE,
            new AntiEntropyService.TreeResponseVerbHandler());

    MessagingService.instance.registerVerbHandlers(Verb.JOIN, new GossiperJoinVerbHandler());
    MessagingService.instance.registerVerbHandlers(Verb.GOSSIP_DIGEST_SYN, new GossipDigestSynVerbHandler());
    MessagingService.instance.registerVerbHandlers(Verb.GOSSIP_DIGEST_ACK, new GossipDigestAckVerbHandler());
    MessagingService.instance.registerVerbHandlers(Verb.GOSSIP_DIGEST_ACK2, new GossipDigestAck2VerbHandler());

    replicationStrategies = new HashMap<String, AbstractReplicationStrategy>();
    for (String table : DatabaseDescriptor.getNonSystemTables()) {
        AbstractReplicationStrategy strat = getReplicationStrategy(tokenMetadata_, table);
        replicationStrategies.put(table, strat);
    }
    replicationStrategies = Collections.unmodifiableMap(replicationStrategies);

    // spin up the streaming serivice so it is available for jmx tools.
    if (StreamingService.instance == null)
        throw new RuntimeException("Streaming service is unavailable.");
}

From source file:JDBCPool.dbcp.demo.sourcecode.BaseGenericObjectPool.java

/**
 * Registers the pool with the platform MBean server.
 * The registered name will be/*from ww  w  .  j  a v a2s. c o m*/
 * <code>jmxNameBase + jmxNamePrefix + i</code> where i is the least
 * integer greater than or equal to 1 such that the name is not already
 * registered. Swallows MBeanRegistrationException, NotCompliantMBeanException
 * returning null.
 *
 * @param config Pool configuration
 * @param jmxNameBase default base JMX name for this pool
 * @param jmxNamePrefix name prefix
 * @return registered ObjectName, null if registration fails
 */
private ObjectName jmxRegister(BaseObjectPoolConfig config, String jmxNameBase, String jmxNamePrefix) {
    ObjectName objectName = null;
    MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
    int i = 1;
    boolean registered = false;
    String base = config.getJmxNameBase();
    if (base == null) {
        base = jmxNameBase;
    }
    while (!registered) {
        try {
            ObjectName objName;
            // Skip the numeric suffix for the first pool in case there is
            // only one so the names are cleaner.
            if (i == 1) {
                objName = new ObjectName(base + jmxNamePrefix);
            } else {
                objName = new ObjectName(base + jmxNamePrefix + i);
            }
            mbs.registerMBean(this, objName);
            objectName = objName;
            registered = true;
        } catch (MalformedObjectNameException e) {
            if (BaseObjectPoolConfig.DEFAULT_JMX_NAME_PREFIX.equals(jmxNamePrefix)
                    && jmxNameBase.equals(base)) {
                // Shouldn't happen. Skip registration if it does.
                registered = true;
            } else {
                // Must be an invalid name. Use the defaults instead.
                jmxNamePrefix = BaseObjectPoolConfig.DEFAULT_JMX_NAME_PREFIX;
                base = jmxNameBase;
            }
        } catch (InstanceAlreadyExistsException e) {
            // Increment the index and try again
            i++;
        } catch (MBeanRegistrationException e) {
            // Shouldn't happen. Skip registration if it does.
            registered = true;
        } catch (NotCompliantMBeanException e) {
            // Shouldn't happen. Skip registration if it does.
            registered = true;
        }
    }
    return objectName;
}

From source file:org.red5.server.scope.Scope.java

protected void registerJMX() {
    // register with jmx
    MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
    try {//  ww  w  . j a va 2s . c o  m
        String cName = this.getClass().getName();
        if (cName.indexOf('.') != -1) {
            cName = cName.substring(cName.lastIndexOf('.')).replaceFirst("[\\.]", "");
        }
        oName = new ObjectName(String.format("org.red5.server:type=%s,name=%s", cName, name));
        // don't reregister
        if (!mbs.isRegistered(oName)) {
            mbs.registerMBean(new StandardMBean(this, ScopeMXBean.class, true), oName);
        }
    } catch (Exception e) {
        log.warn("Error on jmx registration", e);
    }
}

From source file:org.apache.cassandra.db.ColumnFamilyStore.java

private ColumnFamilyStore(Table table, String columnFamilyName, IPartitioner partitioner, int generation,
        CFMetaData metadata) {//from   ww w . j  a v a 2  s .co  m
    assert metadata != null : "null metadata for " + table + ":" + columnFamilyName;
    this.table = table;
    columnFamily = columnFamilyName;
    this.metadata = metadata;
    this.minCompactionThreshold = new DefaultInteger(metadata.getMinCompactionThreshold());
    this.maxCompactionThreshold = new DefaultInteger(metadata.getMaxCompactionThreshold());
    this.memtime = new DefaultInteger(metadata.getMemtableFlushAfterMins());
    this.memsize = new DefaultInteger(metadata.getMemtableThroughputInMb());
    this.memops = new DefaultDouble(metadata.getMemtableOperationsInMillions());
    this.rowCacheSaveInSeconds = new DefaultInteger(metadata.getRowCacheSavePeriodInSeconds());
    this.keyCacheSaveInSeconds = new DefaultInteger(metadata.getKeyCacheSavePeriodInSeconds());
    this.partitioner = partitioner;
    fileIndexGenerator.set(generation);
    binaryMemtable = new AtomicReference<BinaryMemtable>(new BinaryMemtable(this));

    if (logger.isDebugEnabled())
        logger.debug("Starting CFS {}", columnFamily);

    ICache<Pair<Descriptor, DecoratedKey>, Long> kc = ConcurrentLinkedHashCache.create(0);
    keyCache = new AutoSavingKeyCache<Pair<Descriptor, DecoratedKey>, Long>(kc, table.name, columnFamilyName);
    ICache<DecoratedKey, ColumnFamily> rc = metadata.getRowCacheProvider().create(0);
    rowCache = new AutoSavingRowCache<DecoratedKey, ColumnFamily>(rc, table.name, columnFamilyName);

    // scan for sstables corresponding to this cf and load them
    data = new DataTracker(this);
    Set<DecoratedKey> savedKeys = keyCache.readSaved();
    List<SSTableReader> sstables = new ArrayList<SSTableReader>();
    for (Map.Entry<Descriptor, Set<Component>> sstableFiles : files(table.name, columnFamilyName, false)
            .entrySet()) {
        SSTableReader sstable;
        try {
            sstable = SSTableReader.open(sstableFiles.getKey(), sstableFiles.getValue(), savedKeys, data,
                    metadata, this.partitioner);
        } catch (FileNotFoundException ex) {
            logger.error(
                    "Missing sstable component in " + sstableFiles + "; skipped because of " + ex.getMessage());
            continue;
        } catch (IOException ex) {
            logger.error("Corrupt sstable " + sstableFiles + "; skipped", ex);
            continue;
        }
        sstables.add(sstable);
    }
    data.addSSTables(sstables);

    // create the private ColumnFamilyStores for the secondary column indexes
    indexedColumns = new ConcurrentSkipListMap<ByteBuffer, ColumnFamilyStore>(getComparator());
    for (ColumnDefinition info : metadata.getColumn_metadata().values()) {
        if (info.getIndexType() != null)
            addIndex(info);
    }

    // register the mbean
    String type = this.partitioner instanceof LocalPartitioner ? "IndexColumnFamilies" : "ColumnFamilies";
    mbeanName = "org.apache.cassandra.db:type=" + type + ",keyspace=" + this.table.name + ",columnfamily="
            + columnFamily;
    try {
        MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
        ObjectName nameObj = new ObjectName(mbeanName);
        mbs.registerMBean(this, nameObj);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

From source file:org.apache.geode.admin.jmx.internal.AgentImpl.java

private void createRMIRegistry() throws Exception {
    if (!this.agentConfig.isRmiRegistryEnabled()) {
        return;//  w  w  w  . ja v  a2  s  .  c om
    }
    MBeanServer mbs = getMBeanServer();
    String host = this.agentConfig.getRmiBindAddress();
    int port = this.agentConfig.getRmiPort();

    /*
     * Register and start the rmi-registry naming MBean, which is needed by JSR 160
     * RMIConnectorServer
     */
    ObjectName registryName = getRMIRegistryNamingName();
    try {
        RMIRegistryService registryNamingService = null;
        if (host != null && !("".equals(host.trim()))) {
            registryNamingService = new RMIRegistryService(host, port);
        } else {
            registryNamingService = new RMIRegistryService(port);
        }
        mbs.registerMBean(registryNamingService, registryName);
    } catch (javax.management.InstanceAlreadyExistsException e) {
        logger.info(LocalizedMessage.create(LocalizedStrings.AgentImpl_0__IS_ALREADY_REGISTERED, registryName));
    }
    mbs.invoke(registryName, "start", null, null);
}

From source file:org.apache.cassandra.service.StorageService.java

public StorageService() {
    MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
    try {//w  w  w  .ja  va2  s .c o  m
        mbs.registerMBean(this, new ObjectName("org.apache.cassandra.db:type=StorageService"));
    } catch (Exception e) {
        throw new RuntimeException(e);
    }

    /* register the verb handlers */
    MessagingService.instance().registerVerbHandlers(Verb.BINARY, new BinaryVerbHandler());
    MessagingService.instance().registerVerbHandlers(Verb.MUTATION, new RowMutationVerbHandler());
    MessagingService.instance().registerVerbHandlers(Verb.READ_REPAIR, new ReadRepairVerbHandler());
    MessagingService.instance().registerVerbHandlers(Verb.READ, new ReadVerbHandler());
    MessagingService.instance().registerVerbHandlers(Verb.RANGE_SLICE, new RangeSliceVerbHandler());
    MessagingService.instance().registerVerbHandlers(Verb.INDEX_SCAN, new IndexScanVerbHandler());
    MessagingService.instance().registerVerbHandlers(Verb.COUNTER_MUTATION, new CounterMutationVerbHandler());
    // see BootStrapper for a summary of how the bootstrap verbs interact
    MessagingService.instance().registerVerbHandlers(Verb.BOOTSTRAP_TOKEN,
            new BootStrapper.BootstrapTokenVerbHandler());
    MessagingService.instance().registerVerbHandlers(Verb.STREAM_REQUEST, new StreamRequestVerbHandler());
    MessagingService.instance().registerVerbHandlers(Verb.STREAM_REPLY, new StreamReplyVerbHandler());
    MessagingService.instance().registerVerbHandlers(Verb.REPLICATION_FINISHED,
            new ReplicationFinishedVerbHandler());
    MessagingService.instance().registerVerbHandlers(Verb.REQUEST_RESPONSE, new ResponseVerbHandler());
    MessagingService.instance().registerVerbHandlers(Verb.INTERNAL_RESPONSE, new ResponseVerbHandler());
    MessagingService.instance().registerVerbHandlers(Verb.TREE_REQUEST, new TreeRequestVerbHandler());
    MessagingService.instance().registerVerbHandlers(Verb.TREE_RESPONSE,
            new AntiEntropyService.TreeResponseVerbHandler());

    MessagingService.instance().registerVerbHandlers(Verb.GOSSIP_DIGEST_SYN, new GossipDigestSynVerbHandler());
    MessagingService.instance().registerVerbHandlers(Verb.GOSSIP_DIGEST_ACK, new GossipDigestAckVerbHandler());
    MessagingService.instance().registerVerbHandlers(Verb.GOSSIP_DIGEST_ACK2,
            new GossipDigestAck2VerbHandler());

    MessagingService.instance().registerVerbHandlers(Verb.DEFINITIONS_ANNOUNCE,
            new DefinitionsAnnounceVerbHandler());
    MessagingService.instance().registerVerbHandlers(Verb.DEFINITIONS_UPDATE_RESPONSE,
            new DefinitionsUpdateResponseVerbHandler());
    MessagingService.instance().registerVerbHandlers(Verb.TRUNCATE, new TruncateVerbHandler());
    MessagingService.instance().registerVerbHandlers(Verb.SCHEMA_CHECK, new SchemaCheckVerbHandler());

    MessagingService.instance().registerVerbHandlers(Verb.PAXOSPREPARE, new PaxosPrepareVerbHandler());
    MessagingService.instance().registerVerbHandlers(Verb.PAXOSPROMISE, new PaxosPromiseVerbHandler());
    MessagingService.instance().registerVerbHandlers(Verb.PAXOSACCEPT, new PaxosAcceptVerbHandler());
    MessagingService.instance().registerVerbHandlers(Verb.PAXOSACCEPTED, new PaxosAcceptedVerbHandler());
    MessagingService.instance().registerVerbHandlers(Verb.PAXOSDELIVER, new PaxosDeliverVerbHandler());
    MessagingService.instance().registerVerbHandlers(Verb.PAXOSDELIVERRESPONSE,
            new PaxosDeliverResponseVerbHandler());

    // spin up the streaming serivice so it is available for jmx tools.
    if (StreamingService.instance == null)
        throw new RuntimeException("Streaming service is unavailable.");
}

From source file:JDBCPool.dbcp.demo.sourcecode.BasicDataSource.java

private void jmxRegister() {
    // Return immediately if this DataSource has already been registered
    if (registeredJmxName != null) {
        return;//from   w ww. j a v  a 2s.  co m
    }
    // Return immediately if no JMX name has been specified
    String requestedName = getJmxName();
    if (requestedName == null) {
        return;
    }
    ObjectName oname;
    try {
        oname = new ObjectName(requestedName);
    } catch (MalformedObjectNameException e) {
        log.warn("The requested JMX name [" + requestedName + "] was not valid and will be ignored.");
        return;
    }

    MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
    try {
        mbs.registerMBean(this, oname);
    } catch (InstanceAlreadyExistsException | MBeanRegistrationException | NotCompliantMBeanException e) {
        log.warn("Failed to complete JMX registration", e);
    }
}