package org.jolokia.converter.json;
import java.lang.reflect.InvocationTargetException;
import java.util.*;
import javax.management.*;
import javax.management.openmbean.*;
import org.jolokia.converter.object.StringToObjectConverter;
import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
/*
* Copyright 2009-2013 Roland Huss
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @author roland
* @since Apr 19, 2009
*/
public class TabularDataExtractor implements Extractor {
/** {@inheritDoc} */
public Class getType() {
return TabularData.class;
}
/**
* <p>
* Extract a {@link TabularData}. The JSON representation of a tabular data is different,
* depending on whether it represents a map for an {@link javax.management.MXBean} or is a regular data.
* </p>
* <p>
* I.e. for an tabular data which have a row type with two column "key" and "value", then
* a map is returned (with the "key" values as map keys and "value" values as map values).
* </p>
* <p>
* Otherwise a map of (one or more) maps is returned, where the map keys are taken
* from {@link TabularType} of the presented data. E.g. if there is a single valued key
* <code>"key"</code>, then the returned JSON looks like
* <pre>
* {
* "mykey1" : { "key" : "mkey1", "item" : "value1", .... }
* "mykey2" : { "key" : "mkey2", "item" : "value2", .... }
* ....
* }
* </pre>
* For multi valued keys of simple open types (i.e. {@link TabularType#getIndexNames()} is a list with more than one element), the
* returned JSON structure looks like (index names here are "key" and "innerkey")
* <pre>
* {
* "mykey1" : {
* "myinner1" : { "key" : "mkey1", "innerkey" : "myinner1", "item" : "value1", .... }
* "myinner2" : { "key" : "mkey1", "innerkey" : "myinner2", "item" : "value1", .... }
* ....
* }
* "mykey2" : {
* "second1" : { "key" : "mkey2", "innerkey" : "second1", "item" : "value1", .... }
* "second2" : { "key" : "mkey2", "innerkey" : "second2", "item" : "value1", .... }
* ....
* }
* ....
* }
* </pre>
* If keys are used, which themselves are complex objects (like composite data), this hierarchical map
* structure can not be used. In this case an object with two keys is returned: "indexNames" holds the
* name of the key index and "values" is an array of all rows which are represented as JSON objects:
* <pre>
* {
* "indexNames" : [ "key", "innerkey" ],
* "values" : [
* { "key" : "mykey1", "innerkey" : { "name" : "a", "number" : 4711 }, "item" : "value1", .... },
* { "key" : "mykey2", "innerkey" : { "name" : "b", "number" : 815 }, "item" : "value2", .... },
* ...
* ]
* }
* </pre>
* </p>
* <p>
* Accessing {@link TabularData} with a path is only supported for simple type keys, i.e. each index name must point
* to a string representation of a simple open type. As many path elements must be provided as index names for
* the tabular type exists (i.e. <code>pExtraArgs.size() >= pValue.getTabularType().getIndexNames().size()</code>)
*
* For TabularData representing maps, a path access with the single "key" value will
* return the content of the "value" value. For all other TabularData, the complete row to which the path points
* is returned.
* </p>
* @param pConverter the global converter in order to be able do dispatch for
* serializing inner data types
* @param pValue the value to convert
* @param pPathParts extra arguments which contain e.g. a path
* @param pJsonify whether to convert to a JSON object/list or whether the plain object
* should be returned. The later is required for writing an inner value
* @return the extracted object
* @throws AttributeNotFoundException
*/
public Object extractObject(ObjectToJsonConverter pConverter, Object pValue,
Stack<String> pPathParts,boolean pJsonify) throws AttributeNotFoundException {
TabularData td = (TabularData) pValue;
String tdPath = pPathParts.isEmpty() ? null : pPathParts.pop();
if (tdPath != null) {
try {
pPathParts.push(tdPath); // Need it later on for the index
CompositeData cd = extractCompositeDataFromPath(td, pPathParts);
return pConverter.extractObject(
cd != null && checkForMxBeanMap(td.getTabularType()) ? cd.get("value") : cd,
pPathParts, pJsonify);
} catch (AttributeNotFoundException exp) {
ValueFaultHandler faultHandler = pConverter.getValueFaultHandler();
return faultHandler.handleException(exp);
}
} else {
if (pJsonify) {
return checkForMxBeanMap(td.getTabularType()) ?
convertMxBeanMapToJson(td,pPathParts,pConverter) :
convertTabularDataToJson(td, pPathParts, pConverter);
} else {
return td;
}
}
}
// ====================================================================================================
/**
* Check whether the given tabular type represents a MXBean map. See the
* {@link javax.management.MXBean} specification for
* details how a map is converted to {@link TabularData} by the MXBean framework.
*
* @param pType type of tabular data to convert
* @return true if this type represents an MXBean map, false otherwise.
*/
private boolean checkForMxBeanMap(TabularType pType) {
CompositeType rowType = pType.getRowType();
return rowType.containsKey("key") && rowType.containsKey("value") && rowType.keySet().size() == 2
// Only convert to map for simple types for all others use normal conversion. See #105 for details.
&& rowType.getType("key") instanceof SimpleType;
}
private Object convertTabularDataToJson(TabularData pTd, Stack<String> pExtraArgs, ObjectToJsonConverter pConverter)
throws AttributeNotFoundException {
TabularType type = pTd.getTabularType();
if (hasComplexKeys(type)) {
return convertTabularDataDirectly(pTd, pExtraArgs, pConverter);
} else {
return convertToMaps(pTd, pExtraArgs, pConverter);
}
}
// Check, whether all keys are simple types or not
private boolean hasComplexKeys(TabularType pType) {
List<String> indexes = pType.getIndexNames();
CompositeType rowType = pType.getRowType();
for (String index : indexes) {
if ( ! (rowType.getType(index) instanceof SimpleType)) {
return true;
}
}
return false;
}
// Convert tabular data to (nested) maps. Path access is allowed here
private Object convertToMaps(TabularData pTd, Stack<String> pExtraArgs, ObjectToJsonConverter pConverter) throws AttributeNotFoundException {
JSONObject ret = new JSONObject();
TabularType type = pTd.getTabularType();
List<String> indexNames = type.getIndexNames();
boolean found = false;
for (CompositeData cd : (Collection<CompositeData>) pTd.values()) {
Stack<String> path = (Stack<String>) pExtraArgs.clone();
try {
JSONObject targetJSONObject = ret;
// TODO: Check whether all keys can be represented as simple types. If not, well
// we dont do any magic and return the tabular data as an array.
for (int i = 0; i < indexNames.size() - 1; i++) {
Object indexValue = pConverter.extractObject(cd.get(indexNames.get(i)), null, true);
targetJSONObject = getNextMap(targetJSONObject, indexValue);
}
Object row = pConverter.extractObject(cd, path, true);
String finalIndex = indexNames.get(indexNames.size() - 1);
Object finalIndexValue = pConverter.extractObject(cd.get(finalIndex), null, true);
targetJSONObject.put(finalIndexValue, row);
found = true;
} catch (ValueFaultHandler.AttributeFilteredException exp) {
// Ignoring filtered attributes
}
}
if (!pTd.isEmpty() && !found) {
throw new ValueFaultHandler.AttributeFilteredException();
}
return ret;
}
// Convert to a direct representation of the tabular data
private Object convertTabularDataDirectly(TabularData pTd, Stack<String> pExtraArgs, ObjectToJsonConverter pConverter)
throws AttributeNotFoundException {
if (!pExtraArgs.empty()) {
throw new IllegalArgumentException("Cannot use a path for converting tabular data with complex keys (" +
pTd.getTabularType().getRowType() + ")");
}
JSONObject ret = new JSONObject();
JSONArray indexNames = new JSONArray();
TabularType type = pTd.getTabularType();
for (String index : type.getIndexNames()) {
indexNames.add(index);
}
ret.put("indexNames",indexNames);
JSONArray values = new JSONArray();
// Here no special handling for wildcard pathes since pathes are not supported for this use case (yet)
for (CompositeData cd : (Collection<CompositeData>) pTd.values()) {
values.add(pConverter.extractObject(cd, pExtraArgs, true));
}
ret.put("values",values);
return ret;
}
private JSONObject getNextMap(JSONObject pJsonObject, Object pKey) {
JSONObject ret = (JSONObject) pJsonObject.get(pKey);
if (ret == null) {
ret = new JSONObject();
pJsonObject.put(pKey, ret);
}
return ret;
}
private CompositeData extractCompositeDataFromPath(TabularData pTd, Stack<String> pPathStack)
throws AttributeNotFoundException {
// We first try it as a key
TabularType type = pTd.getTabularType();
List<String> indexNames = type.getIndexNames();
checkPathFitsIndexNames(pPathStack, indexNames);
Object keys[] = new Object[indexNames.size()];
CompositeType rowType = type.getRowType();
List<String> pathPartsUsed = new ArrayList<String>();
for (int i = 0; i < indexNames.size(); i++) {
String path = pPathStack.pop();
pathPartsUsed.add(path);
keys[i] = getKey(rowType, indexNames.get(i), path);
}
if (pTd.containsKey(keys)) {
return pTd.get(keys);
} else {
throw new AttributeNotFoundException("No entry with " + pathPartsUsed + " found");
}
}
private void checkPathFitsIndexNames(Stack<String> pPathStack, List<String> pIndexNames) throws AttributeNotFoundException {
if (pIndexNames.size() > pPathStack.size()) {
StringBuilder buf = new StringBuilder();
for (int i = 0; i < pIndexNames.size(); i++) {
buf.append(pIndexNames.get(i));
if (i < pIndexNames.size() - 1) {
buf.append(",");
}
}
throw new AttributeNotFoundException("No enough keys on path stack provided for accessing tabular data with index names "
+ buf.toString());
}
}
// The key is tried to convert to the proper type. These checks are
// a bit redundant, since this sort of conversion is already offered
// in StringToOpenTypeConverter. Unfortunately, this converter is not
// easily available here. For 2.0 the modularity aspects are refactored
// from the ground up, so I can live with the solution here.
// See also #97 for details.
private Object getKey(CompositeType rowType, String key, String value) {
OpenType keyType = rowType.getType(key);
if (SimpleType.STRING == keyType) {
return value;
} else if (SimpleType.INTEGER == keyType) {
return Integer.parseInt(value);
} else if (SimpleType.LONG == keyType) {
return Long.parseLong(value);
} else if (SimpleType.SHORT == keyType) {
return Short.parseShort(value);
} else if (SimpleType.BYTE == keyType) {
return Byte.parseByte(value);
} else if (SimpleType.OBJECTNAME == keyType) {
try {
return new ObjectName(value);
} catch (MalformedObjectNameException e) {
throw new IllegalArgumentException("Can not convert " + value + " to an ObjectName",e);
}
} else {
throw new IllegalArgumentException("All keys must be a string, integer, long, short, byte or ObjectName type for accessing TabularData via a path. " +
"This is not the case for '"
+ key + "' which is of type " + keyType);
}
}
private Object convertMxBeanMapToJson(TabularData pTd, Stack<String> pExtraArgs, ObjectToJsonConverter pConverter)
throws AttributeNotFoundException {
JSONObject ret = new JSONObject();
for (Object rowObject : pTd.values()) {
CompositeData row = (CompositeData) rowObject;
Stack<String> path = (Stack<String>) pExtraArgs.clone();
Object keyObject = row.get("key");
if (keyObject != null) {
try {
Object value = pConverter.extractObject(row.get("value"), path, true);
ret.put(keyObject.toString(), value);
} catch (ValueFaultHandler.AttributeFilteredException exp) {
// Skip to next object since attribute was filtered
}
}
}
if (!pTd.isEmpty() && ret.isEmpty()) {
// Bubble up if not a single thingy has been found
throw new ValueFaultHandler.AttributeFilteredException();
}
return ret;
}
/**
* Throws always {@link IllegalArgumentException} since tabular data is immutable
*/
public Object setObjectValue(StringToObjectConverter pConverter, Object pInner, String pAttribute, Object pValue)
throws IllegalAccessException, InvocationTargetException {
throw new IllegalArgumentException("TabularData cannot be written to");
}
/** {@inheritDoc} */
public boolean canSetValue() {
return false;
}
}