--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.config.util.jolokia;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+import java.util.regex.Pattern;
+
+import javax.management.InstanceNotFoundException;
+import javax.management.MalformedObjectNameException;
+import javax.management.ObjectName;
+
+import org.jolokia.client.J4pClient;
+import org.jolokia.client.exception.J4pException;
+import org.jolokia.client.exception.J4pRemoteException;
+import org.jolokia.client.request.J4pExecRequest;
+import org.jolokia.client.request.J4pListRequest;
+import org.jolokia.client.request.J4pQueryParameter;
+import org.jolokia.client.request.J4pReadRequest;
+import org.jolokia.client.request.J4pRequest;
+import org.jolokia.client.request.J4pResponse;
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+import org.opendaylight.controller.config.api.ConflictingVersionException;
+import org.opendaylight.controller.config.api.ValidationException;
+import org.opendaylight.controller.config.api.ValidationException.ExceptionMessageWithStackTrace;
+import org.opendaylight.controller.config.api.jmx.ObjectNameUtil;
+import org.opendaylight.controller.config.util.AttributeEntry;
+
+abstract class ListableJolokiaClient {
+ protected final J4pClient j4pClient;
+ protected final String url;
+ protected final ObjectName objectName;
+
+ public ListableJolokiaClient(String url, ObjectName objectName) {
+ if (url == null) {
+ throw new NullPointerException("Parameter 'url' is null");
+ }
+ if (!url.endsWith("/")) {
+ throw new IllegalArgumentException(
+ "Parameter 'url' must end with '/'");
+ }
+
+ this.url = url;
+ this.j4pClient = new J4pClient(url);
+ this.objectName = objectName;
+ }
+
+ public ObjectName getObjectName() {
+ return objectName;
+ }
+
+ protected <R extends J4pResponse<T>, T extends J4pRequest> R execute(
+ T pRequest) {
+ try {
+ Map<J4pQueryParameter, String> pProcessingOptions = new HashMap<J4pQueryParameter, String>();
+ pProcessingOptions
+ .put(J4pQueryParameter.INCLUDE_STACKTRACE, "true");
+ pProcessingOptions.put(J4pQueryParameter.SERIALIZE_EXCEPTION,
+ "true");
+ return j4pClient.execute(pRequest, "POST", pProcessingOptions);
+ } catch (J4pRemoteException e) {
+ tryToConvertException(e.getRemoteStackTrace(), e.getErrorValue());
+ throw new RuntimeException(e.getRemoteStackTrace(), e);
+ } catch (J4pException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ protected void tryToConvertException(String remoteStackTrace,
+ JSONObject errorValue) {
+ String conflictPrefix = ConflictingVersionException.class.getName()
+ + ": ";
+ if (remoteStackTrace.startsWith(conflictPrefix)) {
+ remoteStackTrace = remoteStackTrace.substring(conflictPrefix
+ .length());
+ Pattern p = Pattern.compile("\r?\n");
+ remoteStackTrace = Arrays.asList(p.split(remoteStackTrace))
+ .iterator().next();
+ throw new ConflictingVersionException(remoteStackTrace);
+ }
+ String validationExceptionPrefix = ValidationException.class.getName();
+ if (remoteStackTrace.startsWith(validationExceptionPrefix)) {
+ throw createValidationExceptionFromJSONObject(errorValue);
+ }
+ }
+
+ static ValidationException createValidationExceptionFromJSONObject(
+ JSONObject errorValue) {
+ String fValsKey = "failedValidations";
+ JSONObject failedVals = (JSONObject) errorValue.get(fValsKey);
+
+ checkArgument(
+ !failedVals.isEmpty(),
+ fValsKey + " was not present in received JSON: "
+ + errorValue.toJSONString());
+ Map<String, Map<String, ExceptionMessageWithStackTrace>> failedValsMap = new HashMap<String, Map<String, ExceptionMessageWithStackTrace>>();
+
+ for (Object key : failedVals.keySet()) {
+ checkArgument(key instanceof String, "Unexpected key " + key
+ + ", expected instance of String");
+ Map<String, ExceptionMessageWithStackTrace> innerMap = new HashMap<String, ValidationException.ExceptionMessageWithStackTrace>();
+ for (Object innerKey : ((JSONObject) failedVals.get(key)).keySet()) {
+ checkArgument(innerKey instanceof String, "Unexpected key "
+ + innerKey + ", expected instance of String");
+ JSONObject exWithStackTraceVal = (JSONObject) (((JSONObject) failedVals
+ .get(key)).get(innerKey));
+ Object mess = exWithStackTraceVal.get("message");
+ Object stack = exWithStackTraceVal.get("trace");
+ checkArgument(mess != null && stack != null,
+ "\"Message\" and \"trace\" elements expected in received json: "
+ + errorValue.toJSONString());
+ innerMap.put(innerKey.toString(),
+ new ExceptionMessageWithStackTrace((String) mess,
+ (String) stack));
+ }
+ failedValsMap.put((String) key, innerMap);
+ }
+ return new ValidationException(failedValsMap);
+ }
+
+ private static void checkArgument(boolean b, String string) {
+ if (b == false)
+ throw new IllegalArgumentException(string);
+ }
+
+ public String getUrl() {
+ return url;
+ }
+
+ public Map<String, AttributeEntry> getAttributes(ObjectName on) {
+ J4pListRequest req = new J4pListRequest(on);
+ J4pResponse<J4pListRequest> response = execute(req);
+ JSONObject listJSONResponse = response.getValue();
+ JSONObject attributes = (JSONObject) listJSONResponse.get("attr");
+ Map<String, JSONObject> listMap = new HashMap<String, JSONObject>();
+ for (Object entryObject : attributes.entrySet()) {
+ Entry<String, Object> entry = (Entry<String, Object>) entryObject;
+ JSONObject entryVal = (JSONObject) entry.getValue();
+
+ // read value
+ listMap.put(entry.getKey(), entryVal);
+ }
+ J4pReadRequest j4pReadRequest = new J4pReadRequest(on, listMap.keySet()
+ .toArray(new String[0]));
+ J4pResponse<J4pReadRequest> readResponse = execute(j4pReadRequest);
+ Object readResponseValue = readResponse.getValue();
+ // readResponseValue can be String if there is just one attribute or
+ // JSONObject
+ Map<String, Object> attribsToValues = new HashMap<String, Object>();
+ if (readResponseValue instanceof JSONObject) {
+ JSONObject readJSONResponse = (JSONObject) readResponseValue;
+ for (Object entryObject : readJSONResponse.entrySet()) {
+ Entry<String, Object> entry = (Entry<String, Object>) entryObject;
+ String key = entry.getKey();
+ Object value = entry.getValue();
+ attribsToValues.put(key, value);
+ }
+ }
+
+ Map<String, AttributeEntry> resultMap = new HashMap<String, AttributeEntry>();
+ for (Entry<String, JSONObject> entry : listMap.entrySet()) {
+ String key = entry.getKey();
+ Object value = attribsToValues.size() > 0 ? attribsToValues
+ .get(key) : readResponseValue;
+ JSONObject listJSON = entry.getValue();
+ String description = (String) listJSON.get("desc");
+ String type = (String) listJSON.get("type");
+ boolean rw = (Boolean) listJSON.get("rw");
+ AttributeEntry attributeEntry = new AttributeEntry(key,
+ description, value, type, rw);
+ resultMap.put(key, attributeEntry);
+ }
+
+ return resultMap;
+ }
+
+ public String getConfigBeanDescripton(ObjectName on) {
+ J4pListRequest req = new J4pListRequest(on);
+ J4pResponse<J4pListRequest> response = execute(req);
+ JSONObject jsonDesc = response.getValue();
+ Object description = jsonDesc.get("desc");
+ return description == null ? null : description.toString();
+ }
+
+ protected List<ObjectName> jsonArrayToObjectNames(JSONArray jsonArray) {
+ List<ObjectName> result = new ArrayList<>(jsonArray.size());
+ for (Object entry : jsonArray) {
+ JSONObject jsonObject = (JSONObject) entry;
+ String objectNameString = (String) jsonObject.get("objectName");
+ try {
+ result.add(new ObjectName(objectNameString));
+ } catch (MalformedObjectNameException e) {
+ throw new IllegalStateException("Cannot convert "
+ + objectNameString + " to ObjectName", e);
+ }
+ }
+ return result;
+ }
+
+ protected ObjectName extractObjectName(J4pResponse<J4pExecRequest> resp) {
+ JSONObject jsonResponse = resp.getValue();
+ return extractObjectName(jsonResponse);
+ }
+
+ protected ObjectName extractObjectName(JSONObject jsonResponse) {
+ String result = jsonResponse.get("objectName").toString();
+ return ObjectNameUtil.createON(result);
+ }
+
+ protected Set<ObjectName> lookupSomething(String signature,
+ Object[] parameters) {
+ J4pExecRequest req = new J4pExecRequest(objectName, signature,
+ parameters);
+ JSONArray jsonArray = execute(req).getValue();
+ return new HashSet<>(jsonArrayToObjectNames(jsonArray));
+ }
+
+ public Set<ObjectName> lookupConfigBeans() {
+ return lookupSomething("lookupConfigBeans()", new Object[0]);
+ }
+
+ public Set<ObjectName> lookupConfigBeans(String ifcName) {
+ return lookupSomething("lookupConfigBeans(java.lang.String)",
+ new Object[] { ifcName });
+ }
+
+ public Set<ObjectName> lookupConfigBeans(String ifcName, String instanceName) {
+ return lookupSomething(
+ "lookupConfigBeans(java.lang.String,java.lang.String)",
+ new Object[] { ifcName, instanceName });
+ }
+
+ public ObjectName lookupConfigBean(String ifcName, String instanceName)
+ throws InstanceNotFoundException {
+ J4pExecRequest req = new J4pExecRequest(objectName,
+ "lookupConfigBean(java.lang.String,java.lang.String)",
+ new Object[] { ifcName, instanceName });
+ try {
+ J4pResponse<J4pExecRequest> resp = execute(req);
+ return extractObjectName(resp);
+ } catch (RuntimeException e) {
+ if (e.getMessage() != null
+ && e.getMessage().startsWith(
+ InstanceNotFoundException.class.getName()))
+ throw new InstanceNotFoundException();
+ throw e;
+ }
+ }
+
+ public Set<String> getAvailableModuleNames() {
+ J4pReadRequest req = new J4pReadRequest(objectName,
+ "AvailableModuleNames");
+ List<String> value = execute(req).getValue();
+ return new HashSet<>(value);
+ }
+}
Code Review / controller.git / blobdiff