@SuppressWarnings("unchecked") public ObjectName registerMBean(Object managedResource, ObjectName objectName) { Object mbean; if (isMBean(managedResource.getClass())) { mbean = managedResource; } else { mbean = createAndConfigureMBean(managedResource, managedResource.getClass().getName()); } ObjectName actualObjectName = objectName; try { doRegister(mbean, actualObjectName); } catch (JMException e) { throw new RuntimeException(e); } return actualObjectName; }
/** * Registers a new MBean with the platform MBean server. * @param bean the bean being registered * @param parent if not null, the new bean will be registered as a child * node of this parent. */ public void register(ZKMBeanInfo bean, ZKMBeanInfo parent) throws JMException { assert bean != null; String path = null; if (parent != null) { path = mapBean2Path.get(parent); assert path != null; } path = makeFullPath(path, parent); if(bean.isHidden()) return; ObjectName oname = makeObjectName(path, bean); try { mBeanServer.registerMBean(bean, oname); mapBean2Path.put(bean, path); mapName2Bean.put(bean.getName(), bean); } catch (JMException e) { LOG.warn("Failed to register MBean " + bean.getName()); throw e; } }
protected void initializeAndRun(String[] args) throws ConfigException, IOException { try { ManagedUtil.registerLog4jMBeans(); } catch (JMException e) { LOG.warn("Unable to register log4j JMX control", e); } //再次解析配置文件(我也是醉了呀,又解析一遍!!!,写这段的人你出来我保证不打你) ServerConfig config = new ServerConfig(); if (args.length == 1) { config.parse(args[0]); } else { config.parse(args); } runFromConfig(config); }
/** * Routes a method invocation (not a property get/set) to the corresponding * operation on the managed resource. * @param method the method corresponding to operation on the managed resource. * @param args the invocation arguments * @return the value returned by the method invocation. */ private Object invokeOperation(Method method, Object[] args) throws JMException, IOException { MethodCacheKey key = new MethodCacheKey(method.getName(), method.getParameterTypes()); MBeanOperationInfo info = this.allowedOperations.get(key); if (info == null) { throw new InvalidInvocationException("Operation '" + method.getName() + "' is not exposed on the management interface"); } String[] signature = null; synchronized (this.signatureCache) { signature = this.signatureCache.get(method); if (signature == null) { signature = JmxUtils.getMethodSignature(method); this.signatureCache.put(method, signature); } } return this.serverToUse.invoke(this.objectName, method.getName(), args, signature); }
@Override public void registerManagedResource(Object managedResource, ObjectName objectName) throws MBeanExportException { Assert.notNull(managedResource, "Managed resource must not be null"); Assert.notNull(objectName, "ObjectName must not be null"); try { if (isMBean(managedResource.getClass())) { doRegister(managedResource, objectName); } else { ModelMBean mbean = createAndConfigureMBean(managedResource, managedResource.getClass().getName()); doRegister(mbean, objectName); injectNotificationPublisherIfNecessary(managedResource, mbean, objectName); } } catch (JMException ex) { throw new UnableToRegisterMBeanException( "Unable to register MBean [" + managedResource + "] with object name [" + objectName + "]", ex); } }
/** * Build an adapted MBean for the given bean instance, if possible. * <p>The default implementation builds a JMX 1.2 StandardMBean * for the target's MBean/MXBean interface in case of an AOP proxy, * delegating the interface's management operations to the proxy. * @param bean the original bean instance * @return the adapted MBean, or {@code null} if not possible */ @SuppressWarnings("unchecked") protected DynamicMBean adaptMBeanIfPossible(Object bean) throws JMException { Class<?> targetClass = AopUtils.getTargetClass(bean); if (targetClass != bean.getClass()) { Class<?> ifc = JmxUtils.getMXBeanInterface(targetClass); if (ifc != null) { if (!ifc.isInstance(bean)) { throw new NotCompliantMBeanException("Managed bean [" + bean + "] has a target class with an MXBean interface but does not expose it in the proxy"); } return new StandardMBean(bean, ((Class<Object>) ifc), true); } else { ifc = JmxUtils.getMBeanInterface(targetClass); if (ifc != null) { if (!ifc.isInstance(bean)) { throw new NotCompliantMBeanException("Managed bean [" + bean + "] has a target class with an MBean interface but does not expose it in the proxy"); } return new StandardMBean(bean, ((Class<Object>) ifc)); } } } return null; }
/** * 测试爬虫模板 * * @param info * @return */ public List<Webpage> testSpiderInfo(SpiderInfo info) throws JMException { final ResultItemsCollectorPipeline resultItemsCollectorPipeline = new ResultItemsCollectorPipeline(); final String uuid = UUID.randomUUID().toString(); Task task = taskManager.initTask(uuid, info.getDomain(), info.getCallbackURL(), "spiderInfoId=" + info.getId() + "&spiderUUID=" + uuid); task.addExtraInfo("spiderInfo", info); QueueScheduler queueScheduler = new QueueScheduler(); MySpider spider = (MySpider) makeSpider(info, task) .addPipeline(resultItemsCollectorPipeline) .setScheduler(queueScheduler); spider.startUrls(info.getStartURL()); //慎用爬虫监控,可能导致内存泄露 // spiderMonitor.register(spider); spiderMap.put(uuid, spider); taskManager.getTaskById(uuid).setState(State.RUNNING); spider.run(); List<Webpage> webpageList = Lists.newLinkedList(); resultItemsCollectorPipeline.getCollected().forEach(resultItems -> webpageList.add(CommonWebpagePipeline.convertResultItems2Webpage(resultItems))); return webpageList; }
/** * Registers a new MBean with the platform MBean server. * @param bean the bean being registered * @param parent if not null, the new bean will be registered as a child * node of this parent. */ public void register(ZKMBeanInfo bean, ZKMBeanInfo parent) throws JMException { assert bean != null; String path = null; if (parent != null) { path = mapBean2Path.get(parent); assert path != null; } path = makeFullPath(path, parent); if(bean.isHidden()) return; ObjectName oname = makeObjectName(path, bean); try { synchronized (LOCK) { mBeanServer.registerMBean(bean, oname); mapBean2Path.put(bean, path); } } catch (JMException e) { LOG.warn("Failed to register MBean " + bean.getName()); throw e; } }
protected void initializeAndRun(String[] args) throws ConfigException, IOException, AdminServerException { try { ManagedUtil.registerLog4jMBeans(); } catch (JMException e) { LOG.warn("Unable to register log4j JMX control", e); } ServerConfig config = new ServerConfig(); if (args.length == 1) { config.parse(args[0]); } else { config.parse(args); } runFromConfig(config); }
public static void startManager() { MemberMXBean bean = getManagementService().getMemberMXBean(); // When the cache is created if jmx-manager is true then we create the manager. // So it may already exist when we get here. if (!bean.isManagerCreated()) { if (!bean.createManager()) { fail("Could not create Manager"); } else if (!bean.isManagerCreated()) { fail("Should have been a manager after createManager returned true."); } } ManagerMXBean mngrBean = getManagementService().getManagerMXBean(); try { mngrBean.start(); } catch (JMException e) { fail("Could not start Manager " + e); } assertTrue(mngrBean.isRunning()); assertTrue(getManagementService().isManager()); assertTrue(bean.isManager()); }
private void applyConfiguration(ScanManagerConfig bean) throws IOException, JMException { if (bean == null) return; if (!sequencer.tryAcquire()) { throw new IllegalStateException("Can't acquire lock"); } try { unregisterScanners(); final DirectoryScannerConfig[] scans = bean.getScanList(); if (scans == null) return; for (DirectoryScannerConfig scan : scans) { addDirectoryScanner(scan); } log.setConfig(bean.getInitialResultLogConfig()); } finally { sequencer.release(); } }
protected void initializeAndRun(String[] args) throws ConfigException, IOException { try { ManagedUtil.registerLog4jMBeans(); } catch (JMException e) { LOG.warn("Unable to register log4j JMX control", e); } ServerConfig config = new ServerConfig(); if (args.length == 1) { config.parse(args[0]); } else { config.parse(args); } runFromConfig(config); }
@SuppressWarnings({ "unchecked", "rawtypes" }) public static String registerMBean(final Object object) throws JMException { final ObjectName objectName = generateMBeanName(object.getClass()); final MBeanServer context = ManagementFactory.getPlatformMBeanServer(); final String mbeanName = object.getClass().getName() + "MBean"; for (final Class c : object.getClass().getInterfaces()) { if (mbeanName.equals(c.getName())) { context.registerMBean(new AnnotatedStandardMBean(object, c), objectName); return objectName.getCanonicalName(); } } context.registerMBean(object, objectName); return objectName.getCanonicalName(); }
private void handlePotentialStuckRepairs(LazyInitializer<Set<String>> busyHosts, String hostName) throws ConcurrentException { if (!busyHosts.get().contains(hostName) && context.storage instanceof IDistributedStorage) { try (JmxProxy hostProxy = context.jmxConnectionFactory.connect(hostName, context.config.getJmxConnectionTimeoutInSeconds())) { // We double check that repair is still running there before actually canceling repairs if (hostProxy.isRepairRunning()) { LOG.warn( "A host ({}) reported that it is involved in a repair, but there is no record " + "of any ongoing repair involving the host. Sending command to abort all repairs " + "on the host.", hostName); hostProxy.cancelAllRepairs(); hostProxy.close(); } } catch (ReaperException | RuntimeException | InterruptedException | JMException e) { LOG.debug("failed to cancel repairs on host {}", hostName, e); } } }
/** * 根据爬虫模板ID批量启动任务 * * @param spiderInfoIdList 爬虫模板ID列表 * @return 任务id列表 */ public ResultListBundle<String> startAll(List<String> spiderInfoIdList) { return bundleBuilder.listBundle(spiderInfoIdList.toString(), () -> { List<String> taskIdList = Lists.newArrayList(); for (String id : spiderInfoIdList) { try { SpiderInfo info = spiderInfoService.getById(id).getResult(); String taskId = commonSpider.start(info); taskIdList.add(taskId); } catch (JMException e) { LOG.error("启动任务ID{}出错,{}", id, e); } } return taskIdList; }); }
/** * Registers a new MBean with the platform MBean server. * @param bean the bean being registered * @param parent if not null, the new bean will be registered as a child * node of this parent. */ public void register(ZKMBeanInfo bean, ZKMBeanInfo parent) throws JMException { assert bean != null; String path = null; if (parent != null) { path = mapBean2Path.get(parent); assert path != null; } path = makeFullPath(path, parent); mapBean2Path.put(bean, path); mapName2Bean.put(bean.getName(), bean); if(bean.isHidden()) return; MBeanServer mbs = ManagementFactory.getPlatformMBeanServer(); ObjectName oname = makeObjectName(path, bean); try { mbs.registerMBean(bean, oname); } catch (JMException e) { LOG.warn("Failed to register MBean " + bean.getName()); throw e; } }
public static QuickfixjEngine createEngine(boolean lazy) throws ConfigError, FieldConvertError, IOException, JMException { SessionID sessionID = new SessionID("FIX.4.4:SENDER->TARGET"); MessageStoreFactory mockMessageStoreFactory = Mockito.mock(MessageStoreFactory.class); MessageStore mockMessageStore = Mockito.mock(MessageStore.class); Mockito.when(mockMessageStore.getCreationTime()).thenReturn(new Date()); Mockito.when(mockMessageStoreFactory.create(sessionID)).thenReturn(mockMessageStore); SessionSettings settings = new SessionSettings(); settings.setLong(sessionID, Session.SETTING_HEARTBTINT, 10); settings.setString(sessionID, Session.SETTING_START_TIME, "00:00:00"); settings.setString(sessionID, Session.SETTING_END_TIME, "00:00:00"); settings.setString(sessionID, SessionFactory.SETTING_CONNECTION_TYPE, SessionFactory.ACCEPTOR_CONNECTION_TYPE); settings.setLong(sessionID, Acceptor.SETTING_SOCKET_ACCEPT_PORT, 8000); settings.setBool(sessionID, Session.SETTING_USE_DATA_DICTIONARY, false); return new QuickfixjEngine("", settings, mockMessageStoreFactory, Mockito.mock(LogFactory.class), Mockito.mock(MessageFactory.class), lazy); }
/** * Export this folder to a JMX MBeanServer. * @param mBeanServer MBeanServer where this folder will be registered * @param domain domain under which the folder will appear, eg. "MyDomain" * @throws javax.management.JMException */ public void registerFolderHierarchyInJMX(MBeanServer mBeanServer, String domain, String path) throws JMException, IntrospectionException { // register this folder ObjectName objectName = ObjectName.getInstance(domain + ":type=" + path + ",name=" + folder.getName()); mBeanServer.registerMBean(this, objectName); // register all subfolders for (Folder f : folder.getFolders()) { new FolderMBean(f).registerFolderHierarchyInJMX(mBeanServer, domain, path + "." + folder.getName()); } }
/** * 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); }
/** * Unregister the MBean identified by the path. * @param path * @param bean */ private void unregister(String path,ZKMBeanInfo bean) throws JMException { if(path==null) return; if (!bean.isHidden()) { try { mBeanServer.unregisterMBean(makeObjectName(path, bean)); } catch (JMException e) { LOG.warn("Failed to unregister MBean " + bean.getName()); throw e; } } }
/** * Unregister MBean. * @param bean */ public void unregister(ZKMBeanInfo bean) { if(bean==null) return; String path=mapBean2Path.get(bean); try { unregister(path,bean); } catch (JMException e) { LOG.warn("Error during unregister", e); } mapBean2Path.remove(bean); mapName2Bean.remove(bean.getName()); }
/** * Unregister all currently registered MBeans */ public void unregisterAll() { for(Map.Entry<ZKMBeanInfo,String> e: mapBean2Path.entrySet()) { try { unregister(e.getValue(), e.getKey()); } catch (JMException e1) { LOG.warn("Error during unregister", e1); } } mapBean2Path.clear(); mapName2Bean.clear(); }
public void registerConnection(ServerCnxn serverCnxn) { if (zkServer != null) { ConnectionBean jmxConnectionBean = new ConnectionBean(serverCnxn, zkServer); try { MBeanRegistry.getInstance().register(jmxConnectionBean, zkServer.jmxServerBean); connectionBeans.put(serverCnxn, jmxConnectionBean); } catch (JMException e) { LOG.warn("Could not register connection", e); } } }
/** Un-register the previously registered mBean. */ public synchronized boolean unregister() throws JMException { if (registeredName == null) { return false; } ManagementFactory.getPlatformMBeanServer().unregisterMBean(registeredName); LOG.info("Successfully un-registered JMX Bean with object name " + registeredName); registeredName = null; return true; }
private Object invokeAttribute(PropertyDescriptor pd, MethodInvocation invocation) throws JMException, IOException { String attributeName = JmxUtils.getAttributeName(pd, this.useStrictCasing); MBeanAttributeInfo inf = this.allowedAttributes.get(attributeName); // If no attribute is returned, we know that it is not defined in the // management interface. if (inf == null) { throw new InvalidInvocationException( "Attribute '" + pd.getName() + "' is not exposed on the management interface"); } if (invocation.getMethod().equals(pd.getReadMethod())) { if (inf.isReadable()) { return this.serverToUse.getAttribute(this.objectName, attributeName); } else { throw new InvalidInvocationException("Attribute '" + attributeName + "' is not readable"); } } else if (invocation.getMethod().equals(pd.getWriteMethod())) { if (inf.isWritable()) { this.serverToUse.setAttribute(this.objectName, new Attribute(attributeName, invocation.getArguments()[0])); return null; } else { throw new InvalidInvocationException("Attribute '" + attributeName + "' is not writable"); } } else { throw new IllegalStateException( "Method [" + invocation.getMethod() + "] is neither a bean property getter nor a setter"); } }
/** * Actually unregister the specified MBean from the server. * @param objectName the suggested ObjectName for the MBean */ protected void doUnregister(ObjectName objectName) { boolean actuallyUnregistered = false; synchronized (this.registeredBeans) { if (this.registeredBeans.remove(objectName)) { try { // MBean might already have been unregistered by an external process if (this.server.isRegistered(objectName)) { this.server.unregisterMBean(objectName); actuallyUnregistered = true; } else { if (logger.isWarnEnabled()) { logger.warn("Could not unregister MBean [" + objectName + "] as said MBean " + "is not registered (perhaps already unregistered by an external process)"); } } } catch (JMException ex) { if (logger.isErrorEnabled()) { logger.error("Could not unregister MBean [" + objectName + "]", ex); } } } } if (actuallyUnregistered) { onUnregister(objectName); } }
/** * Registers an existing MBean or an MBean adapter for a plain bean * with the {@code MBeanServer}. * @param bean the bean to register, either an MBean or a plain bean * @param beanKey the key associated with this bean in the beans map * @return the {@code ObjectName} under which the bean was registered * with the {@code MBeanServer} */ private ObjectName registerBeanInstance(Object bean, String beanKey) throws JMException { ObjectName objectName = getObjectName(bean, beanKey); Object mbeanToExpose = null; if (isMBean(bean.getClass())) { mbeanToExpose = bean; } else { DynamicMBean adaptedBean = adaptMBeanIfPossible(bean); if (adaptedBean != null) { mbeanToExpose = adaptedBean; } } if (mbeanToExpose != null) { if (logger.isInfoEnabled()) { logger.info("Located MBean '" + beanKey + "': registering with JMX server as MBean [" + objectName + "]"); } doRegister(mbeanToExpose, objectName); } else { if (logger.isInfoEnabled()) { logger.info("Located managed bean '" + beanKey + "': registering with JMX server as MBean [" + objectName + "]"); } ModelMBean mbean = createAndConfigureMBean(bean, beanKey); doRegister(mbean, objectName); injectNotificationPublisherIfNecessary(bean, mbean, objectName); } return objectName; }
/** * Gets the {@code ModelMBeanInfo} for the bean with the supplied key * and of the supplied type. */ private ModelMBeanInfo getMBeanInfo(Object managedBean, String beanKey) throws JMException { ModelMBeanInfo info = this.assembler.getMBeanInfo(managedBean, beanKey); if (logger.isWarnEnabled() && ObjectUtils.isEmpty(info.getAttributes()) && ObjectUtils.isEmpty(info.getOperations())) { logger.warn("Bean with key '" + beanKey + "' has been registered as an MBean but has no exposed attributes or operations"); } return info; }
@Bean @ConditionalOnProperty(prefix = "quickfixj.client", name = "jmx-enabled", havingValue = "true") @ConditionalOnClass(JmxExporter.class) @ConditionalOnSingleCandidate(Initiator.class) @ConditionalOnMissingBean(name = "clientInitiatorMBean") public ObjectName clientInitiatorMBean(Initiator clientInitiator) { try { JmxExporter exporter = new JmxExporter(); return exporter.register(clientInitiator); } catch (JMException e) { throw new ConfigurationException(e.getMessage(), e); } }