private void doTest(JMXConnector connector) throws IOException, MalformedObjectNameException, ReflectionException, InstanceAlreadyExistsException, MBeanRegistrationException, MBeanException, NotCompliantMBeanException, InstanceNotFoundException, AttributeNotFoundException, InvalidAttributeValueException { MBeanServerConnection mbsc = connector.getMBeanServerConnection(); ObjectName objName = new ObjectName("com.redhat.test.jmx:type=NameMBean"); System.out.println("DEBUG: Calling createMBean"); mbsc.createMBean(Name.class.getName(), objName); System.out.println("DEBUG: Calling setAttributes"); AttributeList attList = new AttributeList(); attList.add(new Attribute("FirstName", ANY_NAME)); attList.add(new Attribute("LastName", ANY_NAME)); mbsc.setAttributes(objName, attList); }
public ObjectInstance createMBean(String className, ObjectName name, Object[] params, String[] signature) throws ReflectionException, InstanceAlreadyExistsException, MBeanRegistrationException, MBeanException, NotCompliantMBeanException { try { return createMBean(className, name, null, true, params, signature); } catch (InstanceNotFoundException e) { /* Can only happen if loaderName doesn't exist, but we just passed null, so we shouldn't get this exception. */ throw EnvHelp.initCause( new IllegalArgumentException("Unexpected exception: " + e), e); } }
public boolean init() throws MalformedObjectNameException, InstanceAlreadyExistsException, MBeanRegistrationException, NotCompliantMBeanException, FileNotFoundException, NoSuchElementException, IOException { //Initialize SPARQL 1.1 processing service properties endpointProperties = new SPARQL11Properties("endpoint.jpar"); //Initialize SPARQL 1.1 SE processing service properties engineProperties = new EngineProperties("engine.jpar"); //SPARQL 1.1 SE request processor processor = new Processor(endpointProperties); //SPARQL 1.1 SE request scheduler scheduler = new Scheduler(engineProperties,processor); //SPARQL 1.1 Protocol handlers httpGate = new HTTPGate(engineProperties,scheduler); httpsGate = new HTTPSGate(engineProperties,scheduler,am); //SPARQL 1.1 SE Protocol handler for WebSocket based subscriptions websocketApp = new WSGate(engineProperties,scheduler); secureWebsocketApp = new WSSGate(engineProperties,scheduler,am); return true; }
/** * Call <code>checkCreate(className)</code>, then forward this method to the * wrapped object. */ public ObjectInstance createMBean(String className, ObjectName name, ObjectName loaderName) throws ReflectionException, InstanceAlreadyExistsException, MBeanRegistrationException, MBeanException, NotCompliantMBeanException, InstanceNotFoundException { checkCreate(className); SecurityManager sm = System.getSecurityManager(); if (sm == null) { Object object = getMBeanServer().instantiate(className, loaderName); checkClassLoader(object); return getMBeanServer().registerMBean(object, name); } else { return getMBeanServer().createMBean(className, name, loaderName); } }
/** * Get the MBean interface implemented by a JMX Standard MBean class. * * @param baseClass The class to be tested. * * @return The MBean interface implemented by the Standard MBean. * * @throws NotCompliantMBeanException The specified class is * not a JMX compliant Standard MBean. */ public static <T> Class<? super T> getStandardMBeanInterface(Class<T> baseClass) throws NotCompliantMBeanException { Class<? super T> current = baseClass; Class<? super T> mbeanInterface = null; while (current != null) { mbeanInterface = findMBeanInterface(current, current.getName()); if (mbeanInterface != null) break; current = current.getSuperclass(); } if (mbeanInterface != null) { return mbeanInterface; } else { final String msg = "Class " + baseClass.getName() + " is not a JMX compliant Standard MBean"; throw new NotCompliantMBeanException(msg); } }
/** * Call <code>checkCreate(className)</code>, then forward this method to the * wrapped object. */ public ObjectInstance createMBean(String className, ObjectName name) throws ReflectionException, InstanceAlreadyExistsException, MBeanRegistrationException, MBeanException, NotCompliantMBeanException { checkCreate(className); SecurityManager sm = System.getSecurityManager(); if (sm == null) { Object object = getMBeanServer().instantiate(className); checkClassLoader(object); return getMBeanServer().registerMBean(object, name); } else { return getMBeanServer().createMBean(className, name); } }
private static void testNonCompliant(Class<?> iface, Object bean) throws Exception { try { System.out.println("Registering a non-compliant MBean " + iface.getName() + " ..."); MBeanServer mbs = MBeanServerFactory.newMBeanServer(); ObjectName on = new ObjectName("test:type=NonCompliant"); mbs.registerMBean(bean, on); fail("Registered a non-compliant MBean - " + iface.getName()); } catch (Exception e) { Throwable t = e; while (t != null && !(t instanceof NotCompliantMBeanException)) { t = t.getCause(); } if (t != null) { success("MBean not registered"); } else { throw e; } } }
private static String getNewMBeanClassName(Object mbeanToRegister) throws NotCompliantMBeanException { if (mbeanToRegister instanceof DynamicMBean) { DynamicMBean mbean = (DynamicMBean) mbeanToRegister; final String name; try { name = mbean.getMBeanInfo().getClassName(); } catch (Exception e) { // Includes case where getMBeanInfo() returns null NotCompliantMBeanException ncmbe = new NotCompliantMBeanException("Bad getMBeanInfo()"); ncmbe.initCause(e); throw ncmbe; } if (name == null) { final String msg = "MBeanInfo has null class name"; throw new NotCompliantMBeanException(msg); } return name; } else return mbeanToRegister.getClass().getName(); }
private static void testCompliant(Class<?> iface, Object bean) throws Exception { try { System.out.println("Registering a compliant MBean " + iface.getName() + " ..."); MBeanServer mbs = MBeanServerFactory.newMBeanServer(); ObjectName on = new ObjectName("test:type=Compliant"); mbs.registerMBean(bean, on); success("Registered a compliant MBean - " + iface.getName()); } catch (Exception e) { Throwable t = e; while (t != null && !(t instanceof NotCompliantMBeanException)) { t = t.getCause(); } if (t != null) { fail("MBean not registered"); } else { throw e; } } }
private static void testPrivate(Class<?> iface, Object bean) throws Exception { try { System.out.println("Registering a private MBean " + iface.getName() + " ..."); MBeanServer mbs = MBeanServerFactory.newMBeanServer(); ObjectName on = new ObjectName("test:type=Compliant"); mbs.registerMBean(bean, on); success("Registered a private MBean - " + iface.getName()); } catch (Exception e) { Throwable t = e; while (t != null && !(t instanceof NotCompliantMBeanException)) { t = t.getCause(); } if (t != null) { fail("MBean not registered"); } else { throw e; } } }
<T> MBeanSupport(T resource, Class<T> mbeanInterfaceType) throws NotCompliantMBeanException { if (mbeanInterfaceType == null) throw new NotCompliantMBeanException("Null MBean interface"); if (!mbeanInterfaceType.isInstance(resource)) { final String msg = "Resource class " + resource.getClass().getName() + " is not an instance of " + mbeanInterfaceType.getName(); throw new NotCompliantMBeanException(msg); } ReflectUtil.checkPackageAccess(mbeanInterfaceType); this.resource = resource; MBeanIntrospector<M> introspector = getMBeanIntrospector(); this.perInterface = introspector.getPerInterface(mbeanInterfaceType); this.mbeanInfo = introspector.getMBeanInfo(resource, perInterface); }
private MBeanAnalyzer(Class<?> mbeanType, MBeanIntrospector<M> introspector) throws NotCompliantMBeanException { if (!mbeanType.isInterface()) { throw new NotCompliantMBeanException("Not an interface: " + mbeanType.getName()); } else if (!Modifier.isPublic(mbeanType.getModifiers()) && !Introspector.ALLOW_NONPUBLIC_MBEAN) { throw new NotCompliantMBeanException("Interface is not public: " + mbeanType.getName()); } try { initMaps(mbeanType, introspector); } catch (Exception x) { throw Introspector.throwException(mbeanType,x); } }
/** * Call <code>checkCreate(className)</code>, then forward this method to the * wrapped object. */ public ObjectInstance createMBean(String className, ObjectName name, Object params[], String signature[]) throws ReflectionException, InstanceAlreadyExistsException, MBeanRegistrationException, MBeanException, NotCompliantMBeanException { checkCreate(className); SecurityManager sm = System.getSecurityManager(); if (sm == null) { Object object = getMBeanServer().instantiate(className, params, signature); checkClassLoader(object); return getMBeanServer().registerMBean(object, name); } else { return getMBeanServer().createMBean(className, name, params, signature); } }
/** * Constructor. * * @param roleName name of the role * @param mbeanClassName name of the class of MBean(s) expected to * be referenced in corresponding role. If an MBean <em>M</em> is in * this role, then the MBean server must return true for * {@link MBeanServer#isInstanceOf isInstanceOf(M, mbeanClassName)}. * * <P>IsReadable and IsWritable defaulted to true. * <P>Minimum and maximum degrees defaulted to 1. * <P>Description of role defaulted to null. * * @exception IllegalArgumentException if null parameter * @exception ClassNotFoundException As of JMX 1.2, this exception * can no longer be thrown. It is retained in the declaration of * this class for compatibility with existing code. * @exception NotCompliantMBeanException As of JMX 1.2, this * exception can no longer be thrown. It is retained in the * declaration of this class for compatibility with existing code. */ public RoleInfo(String roleName, String mbeanClassName) throws IllegalArgumentException, ClassNotFoundException, NotCompliantMBeanException { try { init(roleName, mbeanClassName, true, true, 1, 1, null); } catch (InvalidRoleInfoException exc) { // OK : Can never happen as the minimum // degree equals the maximum degree. } return; }
public ObjectInstance registerMBean(Object object, ObjectName name) throws InstanceAlreadyExistsException, MBeanRegistrationException, NotCompliantMBeanException { // ------------------------------ // ------------------------------ Class<?> theClass = object.getClass(); Introspector.checkCompliance(theClass); final String infoClassName = getNewMBeanClassName(object); checkMBeanPermission(infoClassName, null, name, "registerMBean"); checkMBeanTrustPermission(theClass); return registerObject(infoClassName, object, name); }
public MXBeanProxy(Class<?> mxbeanInterface) { if (mxbeanInterface == null) throw new IllegalArgumentException("Null parameter"); final MBeanAnalyzer<ConvertingMethod> analyzer; try { analyzer = MXBeanIntrospector.getInstance().getAnalyzer(mxbeanInterface); } catch (NotCompliantMBeanException e) { throw new IllegalArgumentException(e); } analyzer.visit(new Visitor()); }
/** * Basic method for testing that a MBean of a given class can be * instantiated by the MBean server.<p> * This method checks that: * <ul><li>The given class is a concrete class.</li> * <li>The given class exposes at least one public constructor.</li> * </ul> * If these conditions are not met, throws a NotCompliantMBeanException. * @param c The class of the MBean we want to create. * @exception NotCompliantMBeanException if the MBean class makes it * impossible to instantiate the MBean from within the * MBeanServer. * **/ public static void testCreation(Class<?> c) throws NotCompliantMBeanException { // Check if the class is a concrete class final int mods = c.getModifiers(); if (Modifier.isAbstract(mods) || Modifier.isInterface(mods)) { throw new NotCompliantMBeanException("MBean class must be concrete"); } // Check if the MBean has a public constructor final Constructor<?>[] consList = c.getConstructors(); if (consList.length == 0) { throw new NotCompliantMBeanException("MBean class must have public constructor"); } }
public Scheduler(EngineProperties properties,Processor processor) throws MalformedObjectNameException, InstanceAlreadyExistsException, MBeanRegistrationException, NotCompliantMBeanException { requestHandler = new RequestResponseHandler(properties); tokenHandler = new TokenHandler(properties); if (processor == null) logger.error("Processor is null"); else { this.processor = processor; this.processor.addObserver(this); } }
public Processor(SPARQL11Properties properties) throws MalformedObjectNameException, InstanceAlreadyExistsException, MBeanRegistrationException, NotCompliantMBeanException { //Create SPARQL 1.1 interface endpoint = new SPARQL11Protocol(properties); logger.info(endpoint.toString()); //Create processor to manage (optimize) QUERY and UPDATE request queryProcessor = new QueryProcessor(endpoint); updateProcessor = new UpdateProcessor(endpoint); //Subscriptions manager spuManager = new SPUManager(endpoint); spuManager.addObserver(this); }
private static void testNonCompliant(Class<?> iface, boolean isMx) throws Exception { try { System.out.println("Creating a proxy for non-compliant " + (isMx ? "MXBean" : "MBean") + " " + iface.getName() + " ..."); MBeanServer mbs = MBeanServerFactory.newMBeanServer(); ObjectName on = new ObjectName("test:type=Proxy"); if (isMx) { JMX.newMXBeanProxy(mbs, on, iface); } else { JMX.newMBeanProxy(mbs, on, iface); } fail("Created a proxy for non-compliant " + (isMx ? "MXBean" : "MBean") + " - " + iface.getName()); } catch (Exception e) { Throwable t = e; while (t != null && !(t instanceof NotCompliantMBeanException)) { t = t.getCause(); } if (t != null) { success("Proxy not created"); } else { throw e; } } }
public static void main(String[] args) throws MalformedObjectNameException, InstanceAlreadyExistsException, MBeanRegistrationException, NotCompliantMBeanException, FileNotFoundException, NoSuchElementException, IOException { System.out.println("##########################################################################################"); System.out.println("# SEPA Engine Ver 0.6 Copyright (C) 2016-2017 #"); System.out.println("# University of Bologna (Italy) #"); System.out.println("# #"); System.out.println("# This program comes with ABSOLUTELY NO WARRANTY #"); System.out.println("# This is free software, and you are welcome to redistribute it under certain conditions #"); System.out.println("# GNU GENERAL PUBLIC LICENSE, Version 3, 29 June 2007 #"); System.out.println("# #"); System.out.println("# GitHub: https://github.com/vaimee/sepatools #"); System.out.println("# Web: http://wot.arces.unibo.it #"); System.out.println("##########################################################################################"); System.out.println(""); System.out.println("Dependencies"); System.out.println("com.google.code.gson 2.8.0 Apache 2.0"); System.out.println("com.nimbusds 4.34.2 The Apache Software License, Version 2.0"); System.out.println("commons-io 2.5 Apache License, Version 2.0"); System.out.println("commons-logging 1.2 The Apache Software License, Version 2.0"); System.out.println("org.apache.httpcomponents 4.5.3 Apache License, Version 2.0"); System.out.println("org.apache.httpcomponents 4.4.6 Apache License, Version 2.0"); System.out.println("org.apache.logging.log4j 2.8.1 Apache License, Version 2.0"); System.out.println("org.bouncycastle 1.56 Bouncy Castle Licence"); System.out.println("org.eclipse.paho 1.1.1 Eclipse Public License - Version 1.0"); System.out.println("org.glassfish.grizzly 2.3.30 CDDL+GPL"); System.out.println("org.glassfish.tyrus.bundles 1.13.1 Dual license consisting of the CDDL v1.1 and GPL v2"); System.out.println("org.jdom 2.0.6 Similar to Apache License but with the acknowledgment clause removed"); System.out.println(""); //Engine creation and initialization Engine engine = new Engine(); engine.init(); //Starting main engine thread engine.start(); }
/** * Basic method for testing if a given class is a JMX compliant MBean. * * @param baseClass The class to be tested * * @return <code>null</code> if the MBean is a DynamicMBean, * the computed {@link javax.management.MBeanInfo} otherwise. * @exception NotCompliantMBeanException The specified class is not a * JMX compliant MBean */ public static MBeanInfo testCompliance(Class<?> baseClass) throws NotCompliantMBeanException { // ------------------------------ // ------------------------------ // Check if the MBean implements the MBean or the Dynamic // MBean interface if (isDynamic(baseClass)) return null; return testCompliance(baseClass, null); }
@Override public synchronized ObjectInstance createMBean(String className, ObjectName name, Object[] params, String[] signature) throws ReflectionException, InstanceAlreadyExistsException, MBeanRegistrationException, MBeanException, NotCompliantMBeanException { throw new UnsupportedOperationException("Not supported by PogamutMBeanServer yet..."); }
@Override public synchronized ObjectInstance registerMBean(Object object, ObjectName name) throws InstanceAlreadyExistsException, MBeanRegistrationException, NotCompliantMBeanException { ObjectInstance obj = mbs.registerMBean(object, name); mBeans.add(new MBean1(name, object)); unregisteredMBeans.remove(new MBean1(name, object)); return obj; }
private static void testCompliant(Class<?> iface, boolean isMx) throws Exception { try { System.out.println("Creating a proxy for compliant " + (isMx ? "MXBean" : "MBean") + " " + iface.getName() + " ..."); MBeanServer mbs = MBeanServerFactory.newMBeanServer(); ObjectName on = new ObjectName("test:type=Proxy"); if (isMx) { JMX.newMXBeanProxy(mbs, on, iface); } else { JMX.newMBeanProxy(mbs, on, iface); } success("Created a proxy for compliant " + (isMx ? "MXBean" : "MBean") + " - " + iface.getName()); } catch (Exception e) { Throwable t = e; while (t != null && !(t instanceof NotCompliantMBeanException)) { t = t.getCause(); } if (t != null) { fail("Proxy not created"); } else { throw e; } } }
/** * Call <code>checkWrite()</code>, then forward this method to the * wrapped object. */ public ObjectInstance registerMBean(Object object, ObjectName name) throws InstanceAlreadyExistsException, MBeanRegistrationException, NotCompliantMBeanException { checkWrite(); return getMBeanServer().registerMBean(object, name); }
@Override protected AgentJMXComponents createAgentJMX() { return new AgentJMXComponents<IAgent3D>(this) { @Override protected AgentMBeanAdapter createAgentMBean(ObjectName objectName, MBeanServer mbs) throws MalformedObjectNameException, InstanceAlreadyExistsException, InstanceAlreadyExistsException, MBeanRegistrationException, NotCompliantMBeanException { return new Agent3DMBeanAdapter(AbstractAgent3D.this, objectName, mbs); } }; }
private static <M> MBeanInfo getClassMBeanInfo(MBeanIntrospector<M> introspector, Class<?> baseClass, Class<?> mbeanInterface) throws NotCompliantMBeanException { PerInterface<M> perInterface = introspector.getPerInterface(mbeanInterface); return introspector.getClassMBeanInfo(baseClass, perInterface); }
@Override protected AgentJMXComponents createAgentJMX() { return new AgentJMXComponents<IUT2004Bot>(this) { @Override protected AgentMBeanAdapter createAgentMBean(ObjectName objectName, MBeanServer mbs) throws MalformedObjectNameException, InstanceAlreadyExistsException, InstanceAlreadyExistsException, MBeanRegistrationException, NotCompliantMBeanException { return new BotJMXMBeanAdapter(UT2004Bot.this, objectName, mbs); } }; }
/** * QuartzSchedulerMBeanImpl * * @throws NotCompliantMBeanException */ protected QuartzSchedulerMBeanImpl(QuartzScheduler scheduler) throws NotCompliantMBeanException { super(QuartzSchedulerMBean.class); this.scheduler = scheduler; this.scheduler.addInternalJobListener(this); this.scheduler.addInternalSchedulerListener(this); this.sampledStatistics = NULL_SAMPLED_STATISTICS; this.sampledStatisticsEnabled = false; }
public ObjectInstance createMBean( String className, ObjectName name, ObjectName loaderName, Object[] params, String[] signature) throws ReflectionException, InstanceAlreadyExistsException, MBeanRegistrationException, MBeanException, NotCompliantMBeanException, InstanceNotFoundException { Object mbean = instantiate(className, loaderName, params, signature); return registerMBean(mbean, name); }
public ObjectInstance createMBean(String className, ObjectName name, ObjectName loaderName, Object[] params, String[] signature) throws ReflectionException, InstanceAlreadyExistsException, MBeanRegistrationException, MBeanException, NotCompliantMBeanException, InstanceNotFoundException { return createMBean(className, name, loaderName, false, params, signature); }
/** * Register a JMXWrapper based object to mbean server. * @param objectToRegister object you want to register * @param objectName under which object name it should be available */ public void registerElement(final Object objectToRegister, final ObjectName objectName){ try{ final JMXBeanWrapper wrapper = new JMXBeanWrapper(objectToRegister); this.mbs.registerMBean(wrapper, objectName); } catch (final IntrospectionException | NotCompliantMBeanException | MBeanRegistrationException | InstanceAlreadyExistsException e) { log.log(Level.WARNING, "Error during initialisation or registration of Object to MBeanserver." + " see Stracktrace for more Information", e); } }
/** * Register a static build mbean to the mbean server. * @param objecToRegister object you want to register * @param objectName under which object name it should be available */ public void registerStaticElement(final Object objecToRegister, final ObjectName objectName){ try { this.mbs.registerMBean(objecToRegister,objectName); } catch (InstanceAlreadyExistsException | NotCompliantMBeanException | MBeanRegistrationException e) { log.log(Level.WARNING,"Could not register static example mbean on MBeanServer. Check Stacktrace.", e); } }
