/** * Convert from JSON for OpenType objects. Throws an {@link IllegalArgumentException} if * * @param type open type * @param json JSON representation to convert from * @return the converted object */ Object fromJson(OpenType type, String json) { return converters.getToOpenTypeConverter().convertToObject(type,json); }
private Object[] getValues(OpenMBeanAttributeInfo pOpenTypeInfo, Object pCurrentValue, JmxWriteRequest pRequest) { // TODO: What to do when path is not null ? Simplest: Throw exception. Advanced: Extract other values and create // a new CompositeData with old values and the new value. // However, since this is probably out of scope, we will simply throw an exception if the path is not empty. List<String> pathParts = pRequest.getPathParts(); if (pathParts != null && pathParts.size() > 0) { throw new IllegalArgumentException("Cannot set value for OpenType " + pOpenTypeInfo.getOpenType() + " with inner path " + pRequest.getPath() + " since OpenTypes are immutable"); } return new Object[] { converters.getToOpenTypeConverter().convertToObject(pOpenTypeInfo.getOpenType(), pRequest.getValue()), pCurrentValue }; } }
/** * Execute an JMX operation. The operation name is taken from the request, as well as the * arguments to use. If the operation is given in the format "op(type1,type2,...)" * (e.g "getText(java.lang.String,int)" then the argument types are taken into account * as well. This way, overloaded JMX operation can be used. If an overloaded JMX operation * is called without specifying the argument types, then an exception is raised. * * * @param server server to try * @param request request to process from where the operation and its arguments are extracted. * @return the return value of the operation call */ @Override public Object doHandleRequest(MBeanServerConnection server, JmxExecRequest request) throws InstanceNotFoundException, AttributeNotFoundException, ReflectionException, MBeanException, IOException { OperationAndParamType types = extractOperationTypes(server,request); int nrParams = types.paramClasses.length; Object[] params = new Object[nrParams]; List<Object> args = request.getArguments(); verifyArguments(request, types, nrParams, args); for (int i = 0;i < nrParams; i++) { if (types.paramOpenTypes != null && types.paramOpenTypes[i] != null) { params[i] = converters.getToOpenTypeConverter().convertToObject(types.paramOpenTypes[i], args.get(i)); } else { params[i] = converters.getToObjectConverter().prepareValue(types.paramClasses[i], args.get(i)); } } // TODO: Maybe allow for a path as well which could be applied on the return value ... return server.invoke(request.getObjectName(),types.operationName,params,types.paramClasses); }
/** * Convert from JSON for OpenType objects. Throws an {@link IllegalArgumentException} if * * @param type open type * @param json JSON representation to convert from * @return the converted object */ Object fromJson(OpenType type, String json) { return converters.getToOpenTypeConverter().convertToObject(type,json); }
public static Object toOpenData(OpenType<?> otype, ClassLoader classLoader, Object value) throws OpenDataException { Object result; if (otype instanceof CompositeType && value instanceof JSONObject) { StringToOpenTypeConverter converter = converters.getToOpenTypeConverter(); result = converter.convertToObject(otype, value); } else if (otype instanceof TabularType && value instanceof JSONObject) { StringToOpenTypeConverter converter = converters.getToOpenTypeConverter(); result = converter.convertToObject(otype, value); } else if (otype instanceof ArrayType && value instanceof JSONArray) { StringToOpenTypeConverter converter = converters.getToOpenTypeConverter(); result = converter.convertToObject(otype, value); } else { result = OpenTypeGenerator.toOpenData(otype, value); } boolean isAssignable = result == null || otype.isValue(result); IllegalStateAssertion.assertTrue(isAssignable, "Value " + result + " is not a value of: " + otype); return result; } }
public static Object toOpenData(OpenType<?> otype, ClassLoader classLoader, Object value) throws OpenDataException { Object result; if (otype instanceof CompositeType && value instanceof JSONObject) { StringToOpenTypeConverter converter = converters.getToOpenTypeConverter(); result = converter.convertToObject(otype, value); } else if (otype instanceof TabularType && value instanceof JSONObject) { StringToOpenTypeConverter converter = converters.getToOpenTypeConverter(); result = converter.convertToObject(otype, value); } else if (otype instanceof ArrayType && value instanceof JSONArray) { StringToOpenTypeConverter converter = converters.getToOpenTypeConverter(); result = converter.convertToObject(otype, value); } else { result = OpenTypeGenerator.toOpenData(otype, value); } boolean isAssignable = result == null || otype.isValue(result); IllegalStateAssertion.assertTrue(isAssignable, "Value " + result + " is not a value of: " + otype); return result; } }
private Object[] getValues(OpenMBeanAttributeInfo pOpenTypeInfo, Object pCurrentValue, JmxWriteRequest pRequest) { // TODO: What to do when path is not null ? Simplest: Throw exception. Advanced: Extract other values and create // a new CompositeData with old values and the new value. // However, since this is probably out of scope, we will simply throw an exception if the path is not empty. List<String> pathParts = pRequest.getPathParts(); if (pathParts != null && pathParts.size() > 0) { throw new IllegalArgumentException("Cannot set value for OpenType " + pOpenTypeInfo.getOpenType() + " with inner path " + pRequest.getPath() + " since OpenTypes are immutable"); } return new Object[] { converters.getToOpenTypeConverter().convertToObject(pOpenTypeInfo.getOpenType(), pRequest.getValue()), pCurrentValue }; } }
private Object[] getValues(OpenMBeanAttributeInfo pOpenTypeInfo, Object pCurrentValue, JmxWriteRequest pRequest) { // TODO: What to do when path is not null ? Simplest: Throw exception. Advanced: Extract other values and create // a new CompositeData with old values and the new value. // However, since this is probably out of scope, we will simply throw an exception if the path is not empty. List<String> pathParts = pRequest.getPathParts(); if (pathParts != null && pathParts.size() > 0) { throw new IllegalArgumentException("Cannot set value for OpenType " + pOpenTypeInfo.getOpenType() + " with inner path " + pRequest.getPath() + " since OpenTypes are immutable"); } return new Object[] { converters.getToOpenTypeConverter().convertToObject(pOpenTypeInfo.getOpenType(), pRequest.getValue()), pCurrentValue }; } }
/** * Execute an JMX operation. The operation name is taken from the request, as well as the * arguments to use. If the operation is given in the format "op(type1,type2,...)" * (e.g "getText(java.lang.String,int)" then the argument types are taken into account * as well. This way, overloaded JMX operation can be used. If an overloaded JMX operation * is called without specifying the argument types, then an exception is raised. * * * @param server server to try * @param request request to process from where the operation and its arguments are extracted. * @return the return value of the operation call */ @Override public Object doHandleRequest(MBeanServerConnection server, JmxExecRequest request) throws InstanceNotFoundException, AttributeNotFoundException, ReflectionException, MBeanException, IOException { OperationAndParamType types = extractOperationTypes(server,request); int nrParams = types.paramClasses.length; Object[] params = new Object[nrParams]; List<Object> args = request.getArguments(); verifyArguments(request, types, nrParams, args); for (int i = 0;i < nrParams; i++) { if (types.paramOpenTypes != null && types.paramOpenTypes[i] != null) { params[i] = converters.getToOpenTypeConverter().convertToObject(types.paramOpenTypes[i], args.get(i)); } else { params[i] = converters.getToObjectConverter().prepareValue(types.paramClasses[i], args.get(i)); } } // TODO: Maybe allow for a path as well which could be applied on the return value ... return server.invoke(request.getObjectName(),types.operationName,params,types.paramClasses); }
/** * Execute an JMX operation. The operation name is taken from the request, as well as the * arguments to use. If the operation is given in the format "op(type1,type2,...)" * (e.g "getText(java.lang.String,int)" then the argument types are taken into account * as well. This way, overloaded JMX operation can be used. If an overloaded JMX operation * is called without specifying the argument types, then an exception is raised. * * * @param server server to try * @param request request to process from where the operation and its arguments are extracted. * @return the return value of the operation call */ @Override public Object doHandleRequest(MBeanServerConnection server, JmxExecRequest request) throws InstanceNotFoundException, AttributeNotFoundException, ReflectionException, MBeanException, IOException { OperationAndParamType types = extractOperationTypes(server,request); int nrParams = types.paramClasses.length; Object[] params = new Object[nrParams]; List<Object> args = request.getArguments(); verifyArguments(request, types, nrParams, args); for (int i = 0;i < nrParams; i++) { if (types.paramOpenTypes != null && types.paramOpenTypes[i] != null) { params[i] = converters.getToOpenTypeConverter().convertToObject(types.paramOpenTypes[i], args.get(i)); } else { params[i] = converters.getToObjectConverter().prepareValue(types.paramClasses[i], args.get(i)); } } // TODO: Maybe allow for a path as well which could be applied on the return value ... return server.invoke(request.getObjectName(),types.operationName,params,types.paramClasses); }