package org.jolokia.client.request;
/*
* 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.
*/
import java.lang.reflect.Array;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.json.simple.*;
/**
* Request object abstracting a request to a j4p agent.
*
* @author roland
* @since Apr 24, 2010
*/
public abstract class J4pRequest {
// request type
private J4pType type;
// "GET" or "POST"
private String preferredHttpMethod;
// target configuration for this request when used as a JSR-160 proxy
private J4pTargetConfig targetConfig;
/**
* Constructor for subclasses
* @param pType type of this request
* @param pTargetConfig a target configuration if used in proxy mode or <code>null</code>
* if this is a direct request
*/
protected J4pRequest(J4pType pType, J4pTargetConfig pTargetConfig) {
type = pType;
targetConfig = pTargetConfig;
}
/**
* Escape a input (like the part of an path) so that it can be safely used
* e.g. as a path
*
* @param pInput input to escape
* @return the escaped input
*/
public static String escape(String pInput) {
return pInput.replaceAll("!","!!").replaceAll("/","!/");
}
/**
* Get the type of the request
*
* @return request's type
*/
public J4pType getType() {
return type;
}
/**
* Get a target configuration for use with an agent in JSR-160 proxy mode
*
* @return the target config or <code>null</code> if this is a direct request
*/
public J4pTargetConfig getTargetConfig() {
return targetConfig;
}
/**
* The preferred HTTP method to use (either 'GET' or 'POST')
* @return the HTTP method to use for this request, or <code>null</code> if the method should be automatically selected.
*/
public String getPreferredHttpMethod() {
return preferredHttpMethod;
}
/**
* Set the preferred HTTP method, either 'GET' or 'POST'.
*
* @param pPreferredHttpMethod HTTP method to use.
*/
public void setPreferredHttpMethod(String pPreferredHttpMethod) {
preferredHttpMethod = pPreferredHttpMethod != null ? pPreferredHttpMethod.toUpperCase() : null;
}
// ==================================================================================================
// Methods used for building up HTTP Requests and setting up the reponse
// These methods are package visible only since are used only internally
// Get the parts to build up a GET url (without the type as the first part)
abstract List<String> getRequestParts();
// Get a JSON representation of this request
JSONObject toJson() {
JSONObject ret = new JSONObject();
ret.put("type",type.name());
if (targetConfig != null) {
ret.put("target",targetConfig.toJson());
}
return ret;
}
/**
* Create a response from a given JSON response
*
* @param pResponse http response as obtained from the Http-Request
* @return the create response
*/
abstract <R extends J4pResponse<? extends J4pRequest>> R createResponse(JSONObject pResponse);
// Helper class
protected void addPath(List<String> pParts, String pPath) {
if (pPath != null) {
// Split up path
pParts.addAll(splitPath(pPath));
}
}
/**
* Serialize an object to a string which can be uses as URL part in a GET request
* when object should be transmitted <em>to</em> the agent. The serialization is
* rather limited: If it is an array, the array's member's string representation are used
* in a comma separated list (without escaping so far, so the strings must not contain any
* commas themselves). If it is not an array, the string representation ist used (<code>Object.toString()</code>)
* Any <code>null</code> value is transformed in the special marker <code>[null]</code> which on the
* agent side is converted back into a <code>null</code>.
* <p>
* You should consider POST requests when you need a more sophisticated JSON serialization.
* </p>
* @param pArg the argument to serialize for an GET request
* @return the string representation
*/
protected String serializeArgumentToRequestPart(Object pArg) {
if (pArg != null) {
if (pArg.getClass().isArray()) {
return getArrayForArgument((Object[]) pArg);
} else if (List.class.isAssignableFrom(pArg.getClass())) {
List list = (List) pArg;
Object[] args = new Object[list.size()];
int i = 0;
for (Object e : list) {
args[i++] = e;
}
return getArrayForArgument(args);
}
}
return nullEscape(pArg);
}
/**
* Serialize an object to an string or JSON structure for write/exec POST requests.
* Serialization is up to now rather limited:
* <ul>
* <li>
* If the argument is <code>null</code> null is returned.
* </li>
* <li>
* If the argument is of type {@see org.json.simple.JSONAware}, the it is used directly for inclusion
* in the POST request.
* </li>
* <li>
* If the argument is an array, this array's content is put into
* an {@see org.json.simple.JSONArray}, where each array member is serialized recursively.
* </li>
* <li>
* If the argument is a map, it is transformed into a {@see org.json.simple.JSONObject} with the keys taken
* directly from the map and the values recursively serialized to their JSON representation.
* So it is only save fto use or a simple map with string keys.
* </li>
* <li>
* If the argument is a {@link Collection}, it is transformed into a {@see JSONArray} with
* the values recursively serialized to their JSON representaion.
* </li>
* <li>
* Otherwise the object is used directly.
* </li>
* </ul>
*
* Future version of this lib will probably provide a more sophisticated serialization mechanism.
* <em>This is how it is supposed to be for the next release, currently a simplified serialization is in place</em>
*
* @param pArg the object to serialize
* @return a JSON serialized object
*/
protected Object serializeArgumentToJson(Object pArg) {
if (pArg == null) {
return null;
} else if (pArg instanceof JSONAware) {
return pArg;
} else if (pArg.getClass().isArray()) {
return serializeArray(pArg);
} else if (pArg instanceof Map) {
return serializeMap((Map) pArg);
} else if (pArg instanceof Collection) {
return serializeCollection((Collection) pArg);
} else {
return pArg instanceof Number || pArg instanceof Boolean ? pArg : pArg.toString();
}
}
// pattern used for escaping business
private static final Pattern SLASH_ESCAPE_PATTERN = Pattern.compile("((?:[^!/]|!.)*)(?:/|$)");
private static final Pattern UNESCAPE_PATTERN = Pattern.compile("!(.)");
/**
* Split up a path taking into account proper escaping (as descibed in the
* <a href="http://www.jolokia.org/reference">reference manual</a>).
*
* @param pArg string to split with escaping taken into account
* @return splitted element or null if the argument was null.
*/
protected List<String> splitPath(String pArg) {
List<String> ret = new ArrayList<String>();
if (pArg != null) {
Matcher m = SLASH_ESCAPE_PATTERN.matcher(pArg);
while (m.find() && m.start(1) != pArg.length()) {
ret.add(UNESCAPE_PATTERN.matcher(m.group(1)).replaceAll("$1"));
}
}
return ret;
}
// =====================================================================================================
private Object serializeCollection(Collection pArg) {
JSONArray array = new JSONArray();
for (Object value : ((Collection) pArg)) {
array.add(serializeArgumentToJson(value));
}
return array;
}
private Object serializeMap(Map pArg) {
JSONObject map = new JSONObject();
for (Map.Entry<Object,Object> entry : ((Map<Object,Object>) pArg).entrySet()) {
map.put(entry.getKey(),serializeArgumentToJson(entry.getValue()));
}
return map;
}
private Object serializeArray(Object pArg) {
JSONArray innerArray = new JSONArray();
for (int i = 0; i < Array.getLength(pArg); i++ ) {
innerArray.add(serializeArgumentToJson(Array.get(pArg, i)));
}
return innerArray;
}
private String getArrayForArgument(Object[] pArg) {
StringBuilder inner = new StringBuilder();
for (int i = 0; i< pArg.length; i++) {
inner.append(nullEscape(pArg[i]));
if (i < pArg.length - 1) {
inner.append(",");
}
}
return inner.toString();
}
// null escape used for GET requests
private String nullEscape(Object pArg) {
if (pArg == null) {
return "[null]";
} else if (pArg instanceof String && ((String) pArg).length() == 0) {
return "\"\"";
} else if (pArg instanceof JSONAware) {
return ((JSONAware) pArg).toJSONString();
} else {
return pArg.toString();
}
}
}