public void test(TestHarness h) { ArrayType type = ArrayType.getPrimitiveArrayType(int[].class); h.check(!type.isValue(null), "Null value check"); h.check(!type.isValue(3), "Non-array value check"); h.check(type.isValue(new int[] {3}), "Primitive int array value check"); h.check(!type.isValue(new Integer[] {3}), "Integer array value check"); try { CompositeType ctype = new CompositeType( "Test", "Test", new String[] {"name"}, new String[] {"Name"}, new OpenType[] {SimpleType.STRING}); Map<String, String> data = new HashMap<String, String>(); data.put("name", "Bob"); CompositeData cdata = new CompositeDataSupport(ctype, data); CompositeData[] cdataarr = new CompositeData[] {cdata}; ArrayType type2 = new ArrayType(1, ctype); h.check(type2.isValue(cdataarr), "Composite data check"); TabularType ttype = new TabularType("Test", "Test", ctype, new String[] {"name"}); TabularData tdata = new TabularDataSupport(ttype); tdata.put(cdata); TabularData[] tdataarr = new TabularData[] {tdata}; ArrayType type3 = new ArrayType(1, ttype); h.check(type3.isValue(tdataarr), "Tabular data check"); } catch (OpenDataException e) { h.debug(e); } }
/** * Adds the attribute to the given list. * * @param mBeanAttributes The attributes * @param root The root attribute * @param value The value */ private void addAttributeRoots( List<AttributeNode> mBeanAttributes, AttributeNode root, Object value) { if (value instanceof CompositeData) { mBeanAttributes.add(root); CompositeData compositeData = (CompositeData) value; CompositeType type = compositeData.getCompositeType(); for (String key : type.keySet()) { AttributeNode attribute = new AttributeNode(key, root); root.addChild(attribute); addAttributeItems(attribute, compositeData.get(key)); } } else if (value instanceof TabularData) { mBeanAttributes.add(root); TabularData tabularData = (TabularData) value; for (Object keyList : tabularData.keySet()) { @SuppressWarnings("unchecked") Object[] keys = ((List<Object>) keyList).toArray(new Object[0]); AttributeNode attribute = new AttributeNode(String.valueOf(keys[0]), root); root.addChild(attribute); addAttributeItems(attribute, tabularData.get(keys)); } } else if (value instanceof Long || value instanceof Integer || value instanceof Double) { root.setValidLeaf(true); root.setRgb(getRGB(root.getQualifiedName())); mBeanAttributes.add(root); } }
public static TabularData createTable(ResultSet rs) throws Exception { ResultSetMetaData rsMetaData = rs.getMetaData(); int numCols = rsMetaData.getColumnCount(); String[] headers = new String[numCols]; OpenType[] allTypes = new OpenType[numCols]; Vector[] values = new Vector[numCols]; Object[] allValues = new Object[numCols]; for (int i = 0; i < numCols; i++) { headers[i] = rsMetaData.getColumnName(i + 1); allTypes[i] = new ArrayType(1, SimpleType.STRING); values[i] = new Vector(); } CompositeType ct = new CompositeType("column and values", "column and values", headers, headers, allTypes); TabularType tt = new TabularType("column and values", "column with values", ct, headers); TabularData td = new TabularDataSupport(tt); while (rs.next()) { for (int i = 0; i < numCols; i++) { values[i].add(rs.getString(i + 1)); } } for (int i = 0; i < numCols; i++) { allValues[i] = (String[]) values[i].toArray(new String[0]); } CompositeData entry = new CompositeDataSupport(ct, headers, allValues); td.put(entry); return td; }
public TabularData listEips() throws Exception { try { // find all EIPs Map<String, Properties> eips = context.findEips(); TabularData answer = new TabularDataSupport(CamelOpenMBeanTypes.listEipsTabularType()); // gather EIP detail for each eip for (Map.Entry<String, Properties> entry : eips.entrySet()) { String name = entry.getKey(); String title = (String) entry.getValue().get("title"); String description = (String) entry.getValue().get("description"); String label = (String) entry.getValue().get("label"); String type = (String) entry.getValue().get("class"); String status = CamelContextHelper.isEipInUse(context, name) ? "in use" : "on classpath"; CompositeType ct = CamelOpenMBeanTypes.listEipsCompositeType(); CompositeData data = new CompositeDataSupport( ct, new String[] {"name", "title", "description", "label", "status", "type"}, new Object[] {name, title, description, label, status, type}); answer.put(data); } return answer; } catch (Exception e) { throw ObjectHelper.wrapRuntimeCamelException(e); } }
@Test public void testByteArrayObject() throws Exception { ModelNode description = createDescription(ModelType.OBJECT, ModelType.BYTES); TypeConverter converter = getConverter(description); assertMapType( assertCast(TabularType.class, converter.getOpenType()), SimpleType.STRING, ArrayType.getPrimitiveArrayType(byte[].class)); ModelNode node = new ModelNode(); node.get("one").set(new byte[] {1, 2}); node.get("two").set(new byte[] {3, 4}); TabularData tabularData = assertCast(TabularData.class, converter.fromModelNode(node)); Assert.assertEquals(2, tabularData.size()); Assert.assertTrue( Arrays.equals( new byte[] {1, 2}, (byte[]) tabularData.get(new Object[] {"one"}).get("value"))); Assert.assertTrue( Arrays.equals( new byte[] {3, 4}, (byte[]) tabularData.get(new Object[] {"two"}).get("value"))); // Allow plain map as well? Yeah why not! Map<String, byte[]> map = new HashMap<String, byte[]>(); map.put("one", new byte[] {1, 2}); map.put("two", new byte[] {3, 4}); Assert.assertEquals(node, converter.toModelNode(map)); }
@Test public void testSimpleTypeObject() throws Exception { ModelNode description = createDescription(ModelType.OBJECT, ModelType.LONG); TypeConverter converter = getConverter(description); assertMapType( assertCast(TabularType.class, converter.getOpenType()), SimpleType.STRING, SimpleType.LONG); ModelNode node = new ModelNode(); node.get("one").set(1L); node.get("two").set(2L); TabularData tabularData = assertCast(TabularData.class, converter.fromModelNode(node)); Assert.assertEquals(2, tabularData.size()); Assert.assertEquals(Long.valueOf(1), tabularData.get(new Object[] {"one"}).get("value")); Assert.assertEquals(Long.valueOf(2), tabularData.get(new Object[] {"two"}).get("value")); Assert.assertEquals(node, converter.toModelNode(tabularData)); // Allow plain map as well? Yeah why not! Map<String, Long> map = new HashMap<String, Long>(); map.put("one", 1L); map.put("two", 2L); Assert.assertEquals(node, converter.toModelNode(map)); }
public void testManageMarshal() throws Exception { // JMX tests dont work well on AIX CI servers (hangs them) if (isPlatform("aix")) { return; } MockEndpoint foo = getMockEndpoint("mock:foo"); foo.expectedMessageCount(1); template.sendBodyAndHeader("direct:start", "Hello World", "foo", "123"); assertMockEndpointsSatisfied(); // get the stats for the route MBeanServer mbeanServer = getMBeanServer(); // get the object name for the delayer ObjectName on = ObjectName.getInstance("org.apache.camel:context=camel-1,type=processors,name=\"mysend\""); // should be on route1 String routeId = (String) mbeanServer.getAttribute(on, "RouteId"); assertEquals("route1", routeId); String camelId = (String) mbeanServer.getAttribute(on, "CamelId"); assertEquals("camel-1", camelId); String state = (String) mbeanServer.getAttribute(on, "State"); assertEquals(ServiceStatus.Started.name(), state); String name = (String) mbeanServer.getAttribute(on, "DataFormatName"); assertEquals("string", name); String xml = (String) mbeanServer.invoke(on, "dumpProcessorAsXml", null, null); assertTrue(xml.contains("<marshal")); assertTrue(xml.contains("</marshal>")); assertTrue(xml.contains("<string charset=\"iso-8859-1\"/>")); TabularData data = (TabularData) mbeanServer.invoke(on, "explain", new Object[] {false}, new String[] {"boolean"}); assertNotNull(data); assertEquals(2, data.size()); data = (TabularData) mbeanServer.invoke(on, "explain", new Object[] {true}, new String[] {"boolean"}); assertNotNull(data); assertEquals(4, data.size()); String json = (String) mbeanServer.invoke(on, "informationJson", null, null); assertNotNull(json); assertTrue( json.contains( "\"description\": \"Marshals data into a specified format for transmission over a transport or component")); }
/** * {@inheritDoc} * * @see HibernateStats#getEntityStats() */ public TabularData getEntityStats() { List<CompositeData> result = new ArrayList<CompositeData>(); Statistics statistics = getStatistics(); for (String entity : statistics.getEntityNames()) { EntityStats entityStats = new EntityStats(entity, statistics.getEntityStatistics(entity)); result.add(entityStats.toCompositeData()); } TabularData td = EntityStats.newTabularDataInstance(); td.putAll(result.toArray(new CompositeData[result.size()])); return td; }
/** * {@inheritDoc} * * @see HibernateStats#getQueryStats() */ public TabularData getQueryStats() { List<CompositeData> result = new ArrayList<CompositeData>(); Statistics statistics = getStatistics(); for (String query : statistics.getQueries()) { QueryStats queryStats = new QueryStats(query, statistics.getQueryStatistics(query)); result.add(queryStats.toCompositeData()); } TabularData td = QueryStats.newTabularDataInstance(); td.putAll(result.toArray(new CompositeData[result.size()])); return td; }
/** * {@inheritDoc} * * @see HibernateStats#getCollectionStats() */ public TabularData getCollectionStats() { List<CompositeData> result = new ArrayList<CompositeData>(); Statistics statistics = getStatistics(); for (String roleName : statistics.getCollectionRoleNames()) { CollectionStats collectionStats = new CollectionStats(roleName, statistics.getCollectionStatistics(roleName)); result.add(collectionStats.toCompositeData()); } TabularData td = CollectionStats.newTabularDataInstance(); td.putAll(result.toArray(new CompositeData[result.size()])); return td; }
/** {@inheritDoc} */ public TabularData getCacheRegionStats() { List<CompositeData> list = new ArrayList<CompositeData>(); Statistics statistics = getStatistics(); for (String region : statistics.getSecondLevelCacheRegionNames()) { CacheRegionStats l2CacheStats = new CacheRegionStats(region, statistics.getSecondLevelCacheStatistics(region)); list.add(l2CacheStats.toCompositeData()); } TabularData td = CacheRegionStats.newTabularDataInstance(); td.putAll(list.toArray(new CompositeData[list.size()])); return td; }
public void testManageChoice() throws Exception { // JMX tests dont work well on AIX CI servers (hangs them) if (isPlatform("aix")) { return; } getMockEndpoint("mock:foo").expectedMessageCount(2); getMockEndpoint("mock:bar").expectedMessageCount(1); template.sendBodyAndHeader("direct:start", "Hello World", "foo", "123"); template.sendBodyAndHeader("direct:start", "Bye World", "foo", "456"); template.sendBodyAndHeader("direct:start", "Hi World", "bar", "789"); assertMockEndpointsSatisfied(); // get the stats for the route MBeanServer mbeanServer = getMBeanServer(); // get the object name for the delayer ObjectName on = ObjectName.getInstance("org.apache.camel:context=camel-1,type=processors,name=\"mysend\""); // should be on route1 String routeId = (String) mbeanServer.getAttribute(on, "RouteId"); assertEquals("route1", routeId); String camelId = (String) mbeanServer.getAttribute(on, "CamelId"); assertEquals("camel-1", camelId); String state = (String) mbeanServer.getAttribute(on, "State"); assertEquals(ServiceStatus.Started.name(), state); TabularData data = (TabularData) mbeanServer.invoke(on, "choiceStatistics", null, null); assertNotNull(data); assertEquals(2, data.size()); data = (TabularData) mbeanServer.invoke(on, "explain", new Object[] {false}, new String[] {"boolean"}); assertNotNull(data); assertEquals(3, data.size()); data = (TabularData) mbeanServer.invoke(on, "explain", new Object[] {true}, new String[] {"boolean"}); assertNotNull(data); assertEquals(4, data.size()); String json = (String) mbeanServer.invoke(on, "informationJson", null, null); assertNotNull(json); assertTrue(json.contains("\"description\": \"Routes messages based on a series of predicates")); }
public TabularData listCoordinations(String regexFilter) { Pattern p = Pattern.compile(regexFilter); TabularData td = new TabularDataSupport(COORDINATIONS_TYPE); for (CoordinationImpl c : coordinations.values()) { if (p.matcher(c.getName()).matches()) { try { td.put(fromCoordination(c)); } catch (OpenDataException e) { // TODO: log } } } return td; }
@Override public TabularData getConnectionList() throws JMException { CompositeType rowType = JdbcConnectionStat.Entry.getCompositeType(); String[] indexNames = rowType.keySet().toArray(new String[rowType.keySet().size()]); TabularType tabularType = new TabularType("ConnectionListStatistic", "ConnectionListStatistic", rowType, indexNames); TabularData data = new TabularDataSupport(tabularType); for (Map.Entry<Long, JdbcConnectionStat.Entry> entry : getConnections().entrySet()) { data.put(entry.getValue().getCompositeData()); } return data; }
protected void setUp() throws Exception { TabularData sqlList = JdbcStatManager.getInstance().getSqlList(); if (sqlList.size() > 0) { for (Object item : JdbcStatManager.getInstance().getSqlList().values()) { String text = JSONUtils.toJSONString(item); System.out.println(text); } } Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size()); dataSource = new DruidDataSource(); dataSource.setUrl("jdbc:mock:xx"); dataSource.setFilters("mergeStat"); dataSource.setDbType("mysql"); }
@Override public TabularData getSqlList() throws JMException { Map<String, JdbcSqlStat> sqlStatMap = this.getSqlStatMap(); CompositeType rowType = JdbcSqlStat.getCompositeType(); String[] indexNames = rowType.keySet().toArray(new String[rowType.keySet().size()]); TabularType tabularType = new TabularType("SqlListStatistic", "SqlListStatistic", rowType, indexNames); TabularData data = new TabularDataSupport(tabularType); for (Map.Entry<String, JdbcSqlStat> entry : sqlStatMap.entrySet()) { data.put(entry.getValue().getCompositeData()); } return data; }
/** * Reads in the numeric value of mapped to the tabularDataKey value specified when this object was * created * * @param jmxConnection * @param f * @param beanName * @throws Exception */ protected void readValueFromBean( MBeanServerConnection jmxConnection, AggregateFunction f, ObjectName beanName) throws Exception { checkBeanExists(jmxConnection, beanName); Object attribute = safelyGetAttribute(jmxConnection, beanName); if (!(attribute instanceof TabularData)) { raiseValueException("The attribute was not of type TabularData"); } TabularData tabularData = (TabularData) attribute; Object[] key = {tabularDataKey}; if (!tabularData.containsKey(key)) { raiseValueException("No value is available for the key Object[] {" + tabularDataKey + "}"); } CompositeData compositeData = null; try { compositeData = tabularData.get(key); } catch (InvalidKeyException k) { raiseValueException("The TabularDataKey " + tabularDataKey + " was invalid", k); } if (compositeData == null) { raiseValueException( "Even after checking the TabularDataKey " + tabularDataKey + " existed, we were still return a null value"); // key asynchronously removed on remote server?, probably possible, but never seen it } Object value = getValueFromCompositeData(compositeData, "value"); if (value == null) { raiseValueException( "The value attribute of the CompositeDataItem with tabular key " + tabularDataKey + " was null"); } Double v = convertToDouble(value); // yippee! after all this checking we actually have a value! f.addValue(v); }
@Test public void testSimpleTypeObjectExpressions() throws Exception { ModelNode description = createDescription(ModelType.OBJECT, ModelType.LONG); description.get(EXPRESSIONS_ALLOWED).set(true); TypeConverter converter = getConverter(description); assertMapType( assertCast(TabularType.class, converter.getOpenType()), SimpleType.STRING, SimpleType.LONG); ModelNode node = new ModelNode(); node.get("one").setExpression("${this.should.not.exist.!!!!!:1}"); node.get("two").setExpression("${this.should.not.exist.!!!!!:2}"); TabularData tabularData = assertCast(TabularData.class, converter.fromModelNode(node)); Assert.assertEquals(2, tabularData.size()); Assert.assertEquals(Long.valueOf(1), tabularData.get(new Object[] {"one"}).get("value")); Assert.assertEquals(Long.valueOf(2), tabularData.get(new Object[] {"two"}).get("value")); }
private static String getProperty(TabularData td, String propName) { CompositeData cd = td.get(new Object[] {propName}); if (cd != null) { String key = (String) cd.get("key"); if (!propName.equals(key)) { throw new RuntimeException( "TEST FAILED: " + key + " property found" + " but expected to be " + propName); } return (String) cd.get("value"); } return null; }
@Test public void testSimpleTypeObjectEmpty() throws Exception { ModelNode description = createDescription(ModelType.OBJECT, ModelType.LONG); TypeConverter converter = getConverter(description); assertMapType( assertCast(TabularType.class, converter.getOpenType()), SimpleType.STRING, SimpleType.LONG); ModelNode node = new ModelNode(); node.get("one").set(""); node.get("two").set(""); TabularData tabularData = assertCast(TabularData.class, converter.fromModelNode(node)); Assert.assertEquals(2, tabularData.size()); Assert.assertNull(tabularData.get(new Object[] {"one"}).get("value")); Assert.assertNull(tabularData.get(new Object[] {"two"}).get("value")); ModelNode expected = new ModelNode(); expected.get("one"); expected.get("two"); Assert.assertEquals(expected, converter.toModelNode(tabularData)); }
/** * Gets the initial file name. * * @param jvm The active JVM * @return The file name, or <tt>null</tt> if file name is specified * @throws JvmCoreException */ String getInitialFileName(IActiveJvm jvm) throws JvmCoreException { ObjectName objectName; try { objectName = new ObjectName(ManagementFactory.RUNTIME_MXBEAN_NAME); } catch (MalformedObjectNameException e) { throw new JvmCoreException(IStatus.ERROR, e.getMessage(), e); } catch (NullPointerException e) { throw new JvmCoreException(IStatus.ERROR, e.getMessage(), e); } TabularData initialName = (TabularData) jvm.getMBeanServer().getAttribute(objectName, "SystemProperties"); // $NON-NLS-1$ CompositeData compisiteData = initialName.get(new Object[] {"user.home"}); // $NON-NLS-1$ String home = compisiteData.values().toArray(new String[0])[1]; StringBuffer initialFileName = new StringBuffer(home); initialFileName .append(File.separator) .append(new Date().getTime()) .append('.') .append(SnapshotType.Hprof.getExtension()); return initialFileName.toString(); }
private int getInstancesNum(MBeanServerConnection connection, ObjectName name) throws Exception { TabularData instances = (TabularData) connection.getAttribute(name, "Instances"); return instances.size(); }
/** * If we have access to {@link ConfigurationAdmin}, we can add RBAC information * * @param result */ @Override @SuppressWarnings("unchecked") public void decorate(Map<String, Object> result) throws Exception { try { ServiceReference<ConfigurationAdmin> cmRef = bundleContext.getServiceReference(ConfigurationAdmin.class); ServiceReference<JMXSecurityMBean> jmxSecRef = bundleContext.getServiceReference(JMXSecurityMBean.class); if (cmRef != null && jmxSecRef != null) { ConfigurationAdmin configAdmin = bundleContext.getService(cmRef); JMXSecurityMBean jmxSec = bundleContext.getService(jmxSecRef); if (configAdmin != null && jmxSec != null) { // 1. each pair of MBean/operation has to be marked with RBAC flag (can/can't invoke) // 2. the information is provided by // org.apache.karaf.management.JMXSecurityMBean.canInvoke(java.util.Map) // 3. we'll peek into available configadmin jmx.acl* configs, to see which // MBeans/operations have to // be examined and which will produce same results // 4. only then we'll prepare Map as parameter for canInvoke() Configuration[] configurations = configAdmin.listConfigurations("(service.pid=jmx.acl*)"); List<String> allJmxAclPids = new LinkedList<>(); for (Configuration cfg : configurations) { allJmxAclPids.add(cfg.getPid()); } if (allJmxAclPids.size() == 0) { return; } Map<String, Map<String, Object>> domains = (Map<String, Map<String, Object>>) result.get("domains"); // cache contains MBeanInfos for different MBeans/ObjectNames Map<String, Map<String, Object>> cache = (Map<String, Map<String, Object>>) result.get("cache"); // new cache will contain MBeanInfos + RBAC info Map<String, Map<String, Object>> rbacCache = new HashMap<>(); // the fact that some MBeans share JSON MBeanInfo doesn't mean that they can share RBAC // info // - each MBean's name may have RBAC information configured in different PIDs. // when iterating through all reapeating MBeans that share MBeanInfo (that doesn't have // RBAC info // yet), we have to decide if it'll use shared info after RBAC check or will switch to // dedicated // info. we have to be careful not to end with most MBeans *not* sharing MBeanInfo (in // case if // somehow the shared info will be "special case" from RBAC point of view) Map<String, List<String>> queryForMBeans = new HashMap<>(); Map<String, List<String>> queryForMBeanOperations = new HashMap<>(); for (String domain : domains.keySet()) { Map<String, Object> domainMBeansCheck = new HashMap<>(domains.get(domain)); Map<String, Object> domainMBeans = domains.get(domain); for (String name : domainMBeansCheck.keySet()) { Object mBeanInfo = domainMBeansCheck.get(name); String fullName = domain + ":" + name; ObjectName n = new ObjectName(fullName); if (mBeanInfo instanceof Map) { // not shared JSONified MBeanInfo prepareKarafRbacInvocations( fullName, (Map<String, Object>) mBeanInfo, queryForMBeans, queryForMBeanOperations); } else /*if (mBeanInfo instanceof String)*/ { // shared JSONified MBeanInfo // shard mbeanNames sharing MBeanInfo by the hierarchy of jmx.acl* PIDs used to // check RBAC info String key = (String) mBeanInfo; String pidListKey = pidListKey(allJmxAclPids, n); if (!rbacCache.containsKey(key + ":" + pidListKey)) { // shallow copy - we can share op/not/attr/desc, but we put specific // canInvoke/opByString keys HashMap<String, Object> sharedMBeanAndRbacInfo = new HashMap<>(cache.get(key)); rbacCache.put(key + ":" + pidListKey, sharedMBeanAndRbacInfo); // we'll be checking RBAC only for single (first) MBean having this pidListKey prepareKarafRbacInvocations( fullName, sharedMBeanAndRbacInfo, queryForMBeans, queryForMBeanOperations); } // switch key from shared MBeanInfo-only to shared MBean+RbacInfo domainMBeans.put(name, key + ":" + pidListKey); } } } // RBAC per MBeans (can invoke *any* operation or attribute?) TabularData dataForMBeans = jmxSec.canInvoke(queryForMBeans); Collection<?> results = dataForMBeans.values(); for (Object cd : results) { ObjectName objectName = new ObjectName((String) ((CompositeData) cd).get("ObjectName")); boolean canInvoke = ((CompositeData) cd).get("CanInvoke") != null ? (Boolean) ((CompositeData) cd).get("CanInvoke") : false; Object mBeanInfoOrKey = domains.get(objectName.getDomain()).get(objectName.getKeyPropertyListString()); Map<String, Object> mBeanInfo; if (mBeanInfoOrKey instanceof Map) { mBeanInfo = (Map<String, Object>) mBeanInfoOrKey; } else /*if (mBeanInfoOrKey instanceof String) */ { mBeanInfo = rbacCache.get(mBeanInfoOrKey.toString()); } if (mBeanInfo != null) { mBeanInfo.put("canInvoke", canInvoke); } } // RBAC per { MBean,operation } (can invoke status for each operation) TabularData dataForMBeanOperations = jmxSec.canInvoke(queryForMBeanOperations); results = dataForMBeanOperations.values(); for (Object cd : results) { ObjectName objectName = new ObjectName((String) ((CompositeData) cd).get("ObjectName")); String method = (String) ((CompositeData) cd).get("Method"); boolean canInvoke = ((CompositeData) cd).get("CanInvoke") != null ? (Boolean) ((CompositeData) cd).get("CanInvoke") : false; Object mBeanInfoOrKey = domains.get(objectName.getDomain()).get(objectName.getKeyPropertyListString()); Map<String, Object> mBeanInfo; if (mBeanInfoOrKey instanceof Map) { mBeanInfo = (Map<String, Object>) mBeanInfoOrKey; } else /*if (mBeanInfoOrKey instanceof String) */ { mBeanInfo = rbacCache.get(mBeanInfoOrKey.toString()); } if (mBeanInfo != null) { ((Map<String, Object>) ((Map<String, Object>) mBeanInfo.get("opByString")).get(method)) .put("canInvoke", canInvoke); } } result.remove("cache"); result.put("cache", rbacCache); } } } catch (Exception e) { LOG.error(e.getMessage(), e); // simply do not decorate } }
@Override public TabularData listComponents() throws Exception { try { // find all components Map<String, Properties> components = context.findComponents(); TabularData answer = new TabularDataSupport(CamelOpenMBeanTypes.listComponentsTabularType()); // gather component detail for each component for (Map.Entry<String, Properties> entry : components.entrySet()) { String name = entry.getKey(); String title = null; String syntax = null; String description = null; String label = null; String deprecated = null; String status = context.hasComponent(name) != null ? "in use" : "on classpath"; String type = (String) entry.getValue().get("class"); String groupId = null; String artifactId = null; String version = null; // a component may have been given a different name, so resolve its default name by its java // type // as we can find the component json information from the default component name String defaultName = context.resolveComponentDefaultName(type); String target = defaultName != null ? defaultName : name; // load component json data, and parse it to gather the component meta-data String json = context.getComponentParameterJsonSchema(target); List<Map<String, String>> rows = JsonSchemaHelper.parseJsonSchema("component", json, false); for (Map<String, String> row : rows) { if (row.containsKey("title")) { title = row.get("title"); } else if (row.containsKey("syntax")) { syntax = row.get("syntax"); } else if (row.containsKey("description")) { description = row.get("description"); } else if (row.containsKey("label")) { label = row.get("label"); } else if (row.containsKey("deprecated")) { deprecated = row.get("deprecated"); } else if (row.containsKey("javaType")) { type = row.get("javaType"); } else if (row.containsKey("groupId")) { groupId = row.get("groupId"); } else if (row.containsKey("artifactId")) { artifactId = row.get("artifactId"); } else if (row.containsKey("version")) { version = row.get("version"); } } CompositeType ct = CamelOpenMBeanTypes.listComponentsCompositeType(); CompositeData data = new CompositeDataSupport( ct, new String[] { "name", "title", "syntax", "description", "label", "deprecated", "status", "type", "groupId", "artifactId", "version" }, new Object[] { name, title, syntax, description, label, deprecated, status, type, groupId, artifactId, version }); answer.put(data); } return answer; } catch (Exception e) { throw ObjectHelper.wrapRuntimeCamelException(e); } }