public static CompositeData toCompositeData(Trigger trigger) { try { return new CompositeDataSupport(COMPOSITE_TYPE, ITEM_NAMES, new Object[] { trigger.getKey().getName(), trigger.getKey().getGroup(), trigger.getJobKey().getName(), trigger.getJobKey().getGroup(), trigger.getDescription(), JobDataMapSupport.toTabularData(trigger .getJobDataMap()), trigger.getCalendarName(), ((OperableTrigger)trigger).getFireInstanceId(), trigger.getMisfireInstruction(), trigger.getPriority(), trigger.getStartTime(), trigger.getEndTime(), trigger.getNextFireTime(), trigger.getPreviousFireTime(), trigger.getFinalFireTime() }); } catch (OpenDataException e) { throw new RuntimeException(e); } }
/** * JMX operation - returns all the queries we have collected. * @return - the slow query report as composite data. */ @Override public CompositeData[] getSlowQueriesCD() throws OpenDataException { CompositeDataSupport[] result = null; ConcurrentHashMap<String,QueryStats> queries = perPoolStats.get(poolName); if (queries!=null) { Set<Map.Entry<String,QueryStats>> stats = queries.entrySet(); if (stats!=null) { result = new CompositeDataSupport[stats.size()]; Iterator<Map.Entry<String,QueryStats>> it = stats.iterator(); int pos = 0; while (it.hasNext()) { Map.Entry<String,QueryStats> entry = it.next(); QueryStats qs = entry.getValue(); result[pos++] = qs.getCompositeData(getCompositeType()); } } } return result; }
/** * @param jobDetail * @return CompositeData */ public static CompositeData toCompositeData(JobDetail jobDetail) { try { return new CompositeDataSupport(COMPOSITE_TYPE, ITEM_NAMES, new Object[] { jobDetail.getKey().getName(), jobDetail.getKey().getGroup(), jobDetail.getDescription(), jobDetail.getJobClass().getName(), JobDataMapSupport.toTabularData(jobDetail .getJobDataMap()), jobDetail.isDurable(), jobDetail.requestsRecovery(), }); } catch (OpenDataException e) { throw new RuntimeException(e); } }
public static CompositeData toCompositeData(CronTrigger trigger) { try { return new CompositeDataSupport(COMPOSITE_TYPE, ITEM_NAMES, new Object[] { trigger.getCronExpression(), trigger.getTimeZone(), trigger.getKey().getName(), trigger.getKey().getGroup(), trigger.getJobKey().getName(), trigger.getJobKey().getGroup(), trigger.getDescription(), JobDataMapSupport.toTabularData(trigger .getJobDataMap()), trigger.getCalendarName(), ((OperableTrigger)trigger).getFireInstanceId(), trigger.getMisfireInstruction(), trigger.getPriority(), trigger.getStartTime(), trigger.getEndTime(), trigger.getNextFireTime(), trigger.getPreviousFireTime(), trigger.getFinalFireTime() }); } catch (OpenDataException e) { throw new RuntimeException(e); } }
public static CompositeData toCompositeData(SimpleTrigger trigger) { try { return new CompositeDataSupport(COMPOSITE_TYPE, ITEM_NAMES, new Object[] { trigger.getRepeatCount(), trigger.getRepeatInterval(), trigger.getTimesTriggered(), trigger.getKey().getName(), trigger.getKey().getGroup(), trigger.getJobKey().getName(), trigger.getJobKey().getGroup(), trigger.getDescription(), JobDataMapSupport.toTabularData(trigger .getJobDataMap()), trigger.getCalendarName(), ((OperableTrigger)trigger).getFireInstanceId(), trigger.getMisfireInstruction(), trigger.getPriority(), trigger.getStartTime(), trigger.getEndTime(), trigger.getNextFireTime(), trigger.getPreviousFireTime(), trigger.getFinalFireTime() }); } catch (OpenDataException e) { throw new RuntimeException(e); } }
/** * @param jobDetail * @return CompositeData */ public static CompositeData toCompositeData(JobDetail jobDetail) { try { return new CompositeDataSupport(COMPOSITE_TYPE, ITEM_NAMES, new Object[] { jobDetail.getName(), jobDetail.getGroup(), jobDetail.getDescription(), jobDetail.getJobClass().getName(), JobDataMapSupport.toTabularData(jobDetail .getJobDataMap()), jobDetail.isVolatile(), jobDetail.isDurable(), jobDetail.requestsRecovery(), }); } catch (OpenDataException e) { throw new RuntimeException(e); } }
protected CompositeData getCompositeData() { // CONTENTS OF THIS ARRAY MUST BE SYNCHRONIZED WITH // gcNotifInfoItemNames! final Object[] gcNotifInfoItemValues; gcNotifInfoItemValues = new Object[] { gcNotifInfo.getGcName(), gcNotifInfo.getGcAction(), gcNotifInfo.getGcCause(), GcInfoCompositeData.toCompositeData(gcNotifInfo.getGcInfo()) }; CompositeType gict = getCompositeTypeByBuilder(); try { return new CompositeDataSupport(gict, gcNotifInfoItemNames, gcNotifInfoItemValues); } catch (OpenDataException e) { // Should never reach here throw new AssertionError(e); } }
protected CompositeData getCompositeData() { // CONTENTS OF THIS ARRAY MUST BE SYNCHRONIZED WITH // stackTraceElementItemNames! final Object[] stackTraceElementItemValues = { ste.getClassName(), ste.getMethodName(), ste.getFileName(), new Integer(ste.getLineNumber()), new Boolean(ste.isNativeMethod()), }; try { return new CompositeDataSupport(stackTraceElementCompositeType, stackTraceElementItemNames, stackTraceElementItemValues); } catch (OpenDataException e) { // Should never reach here throw new AssertionError(e); } }
protected CompositeData getCompositeData() { // CONTENTS OF THIS ARRAY MUST BE SYNCHRONIZED WITH // lockInfoItemNames! final Object[] lockInfoItemValues = { new String(lock.getClassName()), new Integer(lock.getIdentityHashCode()), }; try { return new CompositeDataSupport(lockInfoCompositeType, lockInfoItemNames, lockInfoItemValues); } catch (OpenDataException e) { // Should never reach here throw Util.newException(e); } }
protected CompositeData getCompositeData() { // CONTENTS OF THIS ARRAY MUST BE SYNCHRONIZED WITH // vmOptionItemNames! final Object[] vmOptionItemValues = { option.getName(), option.getValue(), new Boolean(option.isWriteable()), option.getOrigin().toString(), }; try { return new CompositeDataSupport(vmOptionCompositeType, vmOptionItemNames, vmOptionItemValues); } catch (OpenDataException e) { // Should never reach here throw new AssertionError(e); } }
protected CompositeData getCompositeData() { // CONTENTS OF THIS ARRAY MUST BE SYNCHRONIZED WITH // memoryNotifInfoItemNames! final Object[] memoryNotifInfoItemValues = { memoryNotifInfo.getPoolName(), MemoryUsageCompositeData.toCompositeData(memoryNotifInfo.getUsage()), new Long(memoryNotifInfo.getCount()), }; try { return new CompositeDataSupport(memoryNotifInfoCompositeType, memoryNotifInfoItemNames, memoryNotifInfoItemValues); } catch (OpenDataException e) { // Should never reach here throw new AssertionError(e); } }
@Override final Object toNonNullOpenValue(Object value) throws OpenDataException { final Collection<?> valueCollection = (Collection<?>) value; if (valueCollection instanceof SortedSet<?>) { Comparator<?> comparator = ((SortedSet<?>) valueCollection).comparator(); if (comparator != null) { final String msg = "Cannot convert SortedSet with non-null comparator: " + comparator; throw openDataException(msg, new IllegalArgumentException(msg)); } } final Object[] openArray = (Object[]) Array.newInstance(getOpenClass().getComponentType(), valueCollection.size()); int i = 0; for (Object o : valueCollection) openArray[i++] = elementMapping.toOpenValue(o); return openArray; }
CompositeMapping(Class<?> targetClass, CompositeType compositeType, String[] itemNames, Method[] getters, MXBeanMappingFactory factory) throws OpenDataException { super(targetClass, compositeType); assert(itemNames.length == getters.length); this.itemNames = itemNames; this.getters = getters; this.getterMappings = new MXBeanMapping[getters.length]; for (int i = 0; i < getters.length; i++) { Type retType = getters[i].getGenericReturnType(); getterMappings[i] = factory.mappingForType(retType, factory); } }
@Override public CompositeType getOpenType() { final String description = getNullableDescription() == null ? getAttributeYangName() : getNullableDescription(); final FunctionImpl functionImpl = new FunctionImpl(); final Map<String, AttributeIfc> jmxPropertiesToTypesMap = getJmxPropertiesToTypesMap(); final OpenType<?>[] itemTypes = Collections2.transform( jmxPropertiesToTypesMap.entrySet(), functionImpl).toArray( new OpenType<?>[] {}); final String[] itemNames = functionImpl.getItemNames(); try { // TODO add package name to create fully qualified name for this // type final CompositeType compositeType = new CompositeType( getUpperCaseCammelCase(), description, itemNames, itemNames, itemTypes); return compositeType; } catch (final OpenDataException e) { throw new RuntimeException("Unable to create CompositeType for " + this, e); } }
final Object toNonNullOpenValue(Object value) throws OpenDataException { final Collection valueCollection = (Collection) value; if (valueCollection instanceof SortedSet) { Comparator comparator = ((SortedSet) valueCollection).comparator(); if (comparator != null) { final String msg = "Cannot convert SortedSet with non-null comparator: " + comparator; throw openDataException(msg, new IllegalArgumentException(msg)); } } final Object[] openArray = (Object[]) Array.newInstance(getOpenClass().getComponentType(), valueCollection.size()); int i = 0; for (Object o : valueCollection) openArray[i++] = elementConverter.toOpenValue(o); return openArray; }
/** * * @param objType * @return the converter for the given Java type, creating it if necessary * @throws OpenDataException */ public static synchronized OpenTypeConverter toConverter(Type objType) throws OpenDataException { if (inProgress.containsKey(objType)) { throw new OpenDataException("Recursive data structure, including " + typeName(objType)); } OpenTypeConverter conv; conv = getConverter(objType); if (conv != null) return conv; inProgress.put(objType, objType); try { conv = makeConverter(objType); } catch (OpenDataException e) { throw openDataException("Cannot convert type: " + objType, e); } finally { inProgress.remove(objType); } putConverter(objType, conv); return conv; }
private MXBeanMapping makeTabularMapping(Type objType, boolean sortedMap, Type keyType, Type valueType, MXBeanMappingFactory factory) throws OpenDataException { final String objTypeName = typeName(objType); final MXBeanMapping keyMapping = factory.mappingForType(keyType, factory); final MXBeanMapping valueMapping = factory.mappingForType(valueType, factory); final OpenType<?> keyOpenType = keyMapping.getOpenType(); final OpenType<?> valueOpenType = valueMapping.getOpenType(); final CompositeType rowType = new CompositeType(objTypeName, objTypeName, keyValueArray, keyValueArray, new OpenType<?>[] {keyOpenType, valueOpenType}); final TabularType tabularType = new TabularType(objTypeName, objTypeName, rowType, keyArray); return new TabularMapping(objType, sortedMap, tabularType, keyMapping, valueMapping); }
/** * Converts to open value */ final Object toNonNullOpenValue(Object value) throws OpenDataException { CompositeType ct = (CompositeType) getOpenType(); if (value instanceof CompositeDataView) return ((CompositeDataView) value).toCompositeData(ct); if (value == null) return null; Object[] values = new Object[getters.length]; for (int i = 0; i < getters.length; i++) { try { Object got = getters[i].invoke(value, (Object[]) null); values[i] = getterConverters[i].toOpenValue(got); } catch (Exception e) { throw openDataException("Error calling getter for " + itemNames[i] + ": " + e, e); } } return new CompositeDataSupport(ct, itemNames, values); }
protected CompositeData getCompositeData() { // CONTENTS OF THIS ARRAY MUST BE SYNCHRONIZED WITH // memoryUsageItemNames! final Object[] memoryUsageItemValues = { usage.getInit(), usage.getUsed(), usage.getCommitted(), usage.getMax(), }; try { return new CompositeDataSupport(memoryUsageCompositeType, memoryUsageItemNames, memoryUsageItemValues); } catch (OpenDataException e) { // Should never reach here throw new AssertionError(e); } }
public CompositeDataSupport getCompositeData(final CompositeType type) throws OpenDataException{ Object[] values = new Object[] { query, Integer.valueOf(nrOfInvocations), Long.valueOf(maxInvocationTime), Long.valueOf(maxInvocationDate), Long.valueOf(minInvocationTime), Long.valueOf(minInvocationDate), Long.valueOf(totalInvocationTime), Long.valueOf(failures), Integer.valueOf(prepareCount), Long.valueOf(prepareTime), Long.valueOf(lastInvocation) }; return new CompositeDataSupport(type,FIELD_NAMES,values); }
protected CompositeData getCompositeData() { // CONTENTS OF THIS ARRAY MUST BE SYNCHRONIZED WITH // lockInfoItemNames! final Object[] lockInfoItemValues = { new String(lock.getClassName()), lock.getIdentityHashCode(), }; try { return new CompositeDataSupport(lockInfoCompositeType, lockInfoItemNames, lockInfoItemValues); } catch (OpenDataException e) { // Should never reach here throw Util.newException(e); } }
@Override final Object toNonNullOpenValue(Object value) throws OpenDataException { CompositeType ct = (CompositeType) getOpenType(); if (value instanceof CompositeDataView) return ((CompositeDataView) value).toCompositeData(ct); if (value == null) return null; Object[] values = new Object[getters.length]; for (int i = 0; i < getters.length; i++) { try { Object got = MethodUtil.invoke(getters[i], value, (Object[]) null); values[i] = getterMappings[i].toOpenValue(got); } catch (Exception e) { throw openDataException("Error calling getter for " + itemNames[i] + ": " + e, e); } } return new CompositeDataSupport(ct, itemNames, values); }
protected CompositeData getCompositeData() { // CONTENTS OF THIS ARRAY MUST BE SYNCHRONIZED WITH // memoryUsageItemNames! final Object[] memoryUsageItemValues = { new Long(usage.getInit()), new Long(usage.getUsed()), new Long(usage.getCommitted()), new Long(usage.getMax()), }; try { return new CompositeDataSupport(memoryUsageCompositeType, memoryUsageItemNames, memoryUsageItemValues); } catch (OpenDataException e) { // Should never reach here throw new AssertionError(e); } }
protected CompositeData getCompositeData() { // CONTENTS OF THIS ARRAY MUST BE SYNCHRONIZED WITH // stackTraceElementItemNames! final Object[] stackTraceElementItemValues = { ste.getClassLoaderName(), ste.getModuleName(), ste.getModuleVersion(), ste.getClassName(), ste.getMethodName(), ste.getFileName(), ste.getLineNumber(), ste.isNativeMethod(), }; try { return new CompositeDataSupport(stackTraceElementCompositeType, stackTraceElementItemNames, stackTraceElementItemValues); } catch (OpenDataException e) { // Should never reach here throw new AssertionError(e); } }
/** * Will call all getter methods on payload that are defined in the given interfaces */ public static Map makeCallerChain ( Object payload, Class... ifaces ) throws OpenDataException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException, Exception, ClassNotFoundException { CompositeType rt = new CompositeType("a", "b", new String[] { "a" }, new String[] { "a" }, new OpenType[] { javax.management.openmbean.SimpleType.INTEGER }); TabularType tt = new TabularType("a", "b", rt, new String[] { "a" }); TabularDataSupport t1 = new TabularDataSupport(tt); TabularDataSupport t2 = new TabularDataSupport(tt); // we need to make payload implement composite data // it's very likely that there are other proxy impls that could be used AdvisedSupport as = new AdvisedSupport(); as.setTarget(payload); InvocationHandler delegateInvocationHandler = (InvocationHandler) Reflections .getFirstCtor("org.springframework.aop.framework.JdkDynamicAopProxy").newInstance(as); InvocationHandler cdsInvocationHandler = Gadgets.createMemoizedInvocationHandler(Gadgets.createMap("getCompositeType", rt)); CompositeInvocationHandlerImpl invocationHandler = new CompositeInvocationHandlerImpl(); invocationHandler.addInvocationHandler(CompositeData.class, cdsInvocationHandler); invocationHandler.setDefaultHandler(delegateInvocationHandler); final CompositeData cdsProxy = Gadgets.createProxy(invocationHandler, CompositeData.class, ifaces); JSONObject jo = new JSONObject(); Map m = new HashMap(); m.put("t", cdsProxy); Reflections.setFieldValue(jo, "properties", m); Reflections.setFieldValue(jo, "properties", m); Reflections.setFieldValue(t1, "dataMap", jo); Reflections.setFieldValue(t2, "dataMap", jo); return Gadgets.makeMap(t1, t2); }
/** * @return composite data */ public static CompositeData toCompositeData(String key, String value) { try { return new CompositeDataSupport(rowType, keyValue, new Object[] { key, value }); } catch (OpenDataException e) { throw new RuntimeException(e); } }
@Override public final Object toOpenValue(Object javaValue) throws OpenDataException { if (javaValue == null) return null; else return toNonNullOpenValue(javaValue); }
protected CompositeData getCompositeData() { // CONTENTS OF THIS ARRAY MUST BE SYNCHRONIZED WITH // monitorInfoItemNames! int len = monitorInfoItemNames.length; Object[] values = new Object[len]; CompositeData li = LockInfoCompositeData.toCompositeData(lock); for (int i = 0; i < len; i++) { String item = monitorInfoItemNames[i]; if (item.equals(LOCKED_STACK_FRAME)) { StackTraceElement ste = lock.getLockedStackFrame(); values[i] = (ste != null ? StackTraceElementCompositeData. toCompositeData(ste) : null); } else if (item.equals(LOCKED_STACK_DEPTH)) { values[i] = new Integer(lock.getLockedStackDepth()); } else { values[i] = li.get(item); } } try { return new CompositeDataSupport(monitorInfoCompositeType, monitorInfoItemNames, values); } catch (OpenDataException e) { // Should never reach here throw new AssertionError(e); } }
final Object[] toOpenParameters(MXBeanLookup lookup, Object[] params) throws OpenDataException { if (paramConversionIsIdentity || params == null) return params; final Object[] oparams = new Object[params.length]; for (int i = 0; i < params.length; i++) oparams[i] = paramMappings[i].toOpenValue(params[i]); return oparams; }
public CompositeData getCompositeDataAttribute() throws OpenDataException { CompositeType ct = new CompositeType("CompositeDataAttribute", "Composite Data Attribute", itemNames, itemDescriptions, itemTypes); Object itemValues[] = { ia, da, sa }; return new CompositeDataSupport(ct, itemNames, itemValues); }
public static Map<String, MemoryUsage> getMemoryUsageBeforeGc(CompositeData cd) { try { TabularData td = (TabularData) cd.get(MEMORY_USAGE_BEFORE_GC); return cast(memoryUsageMapType.toJavaTypeData(td)); } catch (InvalidObjectException | OpenDataException e) { // Should never reach here throw new AssertionError(e); } }
static ArrayType make(int dims, OpenType baseType) { try { return new ArrayType(dims, baseType); } catch (OpenDataException e) { throw new Error(e); } }
