package com.googlecode.jsonrpc4j.util;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.googlecode.jsonrpc4j.JsonRpcBasicServer;
import com.googlecode.jsonrpc4j.JsonRpcServer;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
public class Util {
public static final String param1 = "param1";
public static final String nonAsciiCharacters = "PñA&s<>k ;";
public static final String param2 = "param2";
public static final String param3 = "param3";
public static final String param4 = "param4";
public static final int intParam1 = 1;
public static final int intParam2 = 2;
public static final String JSON_ENCODING = StandardCharsets.UTF_8.name();
public static final ObjectMapper mapper = new ObjectMapper();
@SuppressWarnings("PMD.AvoidUsingHardCodedIP")
public static final String DEFAULT_LOCAL_HOSTNAME = "127.0.0.1";
private static final String invalidJsonRpcRequest = "{\"method\": \"subtract\", \"params\": [], \"id\": 1}";
private static final String invalidJson = "{\"jsonrpc\": \"2.0,\n" +
" \"method\": \"testMethod\",\n" +
" \"params\": {},\n" +
" \"id\": \n" +
" }\n" +
" ";
public static InputStream invalidJsonRpcRequestStream() {
return new ByteArrayInputStream(invalidJsonRpcRequest.getBytes(StandardCharsets.UTF_8));
}
public static InputStream invalidJsonStream() {
return new ByteArrayInputStream(invalidJson.getBytes(StandardCharsets.UTF_8));
}
public static InputStream messageWithListParamsStream(final Object id, final String methodName, final Object... args) throws JsonProcessingException {
return createStream(messageWithListParams(id, methodName, args));
}
public static InputStream createStream(Object content) throws JsonProcessingException {
String data = mapper.writeValueAsString(content);
return new ByteArrayInputStream(data.getBytes(StandardCharsets.UTF_8));
}
public static HashMap<String, Object> messageWithListParams(final Object id, final String methodName, final Object... args) throws JsonProcessingException {
return messageOfStream(id, methodName, Arrays.asList(args));
}
public static HashMap<String, Object> messageOfStream(final Object id, final String methodName, final Object params) {
return makeJsonRpcRequestObject(id, methodName, params);
}
@SuppressWarnings("serial")
private static HashMap<String, Object> makeJsonRpcRequestObject(final Object id, final String methodName, final Object params) {
return new HashMap<String, Object>() {
{
if (id != null) put(JsonRpcBasicServer.ID, id);
put(JsonRpcBasicServer.JSONRPC, JsonRpcServer.VERSION);
if (methodName != null) put(JsonRpcBasicServer.METHOD, methodName);
if (params != null) put(JsonRpcBasicServer.PARAMS, params);
}
};
}
public static InputStream multiMessageOfStream(Object... args) throws JsonProcessingException {
return createStream(args);
}
public static InputStream messageWithMapParamsStream(final String methodName, final Object... args) throws JsonProcessingException {
return createStream(messageWithMapParams(methodName, args));
}
private static HashMap<String, Object> messageWithMapParams(final String methodName, final Object... args) throws JsonProcessingException {
Map<String, Object> elements = new HashMap<>();
for (int i = 0; i < args.length; i += 2) {
final String key = (String) args[i];
final Object value = args[i + 1];
elements.put(key, value);
}
return messageOfStream(1, methodName, elements);
}
public static ByteArrayOutputStream toByteArrayOutputStream(byte[] data) throws IOException {
ByteArrayOutputStream result = new ByteArrayOutputStream(data.length);
result.write(data);
return result;
}
public static ByteArrayOutputStream toByteArrayOutputStream(InputStream inputStream) throws IOException {
ByteArrayOutputStream result = new ByteArrayOutputStream();
byte[] buffer = new byte[256];
int read;
while (-1 != (read = inputStream.read(buffer))) {
result.write(buffer, 0, read);
}
return result;
}
public static JsonNode error(ByteArrayOutputStream byteArrayOutputStream) throws IOException {
return decodeAnswer(byteArrayOutputStream).get(JsonRpcBasicServer.ERROR);
}
public static JsonNode decodeAnswer(ByteArrayOutputStream byteArrayOutputStream) throws IOException {
return mapper.readTree(byteArrayOutputStream.toString(JSON_ENCODING));
}
public static JsonNode errorCode(JsonNode error) {
return error.get(JsonRpcBasicServer.ERROR_CODE);
}
public static JsonNode errorMessage(JsonNode error) {
return error.get(JsonRpcBasicServer.ERROR_MESSAGE);
}
public static JsonNode errorData(JsonNode error) {
return error.get(JsonRpcBasicServer.DATA);
}
public static JsonNode exceptionType(JsonNode error) {
return error.get(JsonRpcBasicServer.EXCEPTION_TYPE_NAME);
}
public static JsonNode getFromArrayWithId(final JsonNode node, final int id) {
for (JsonNode n : node) {
if (n.get(JsonRpcBasicServer.ID).asInt() == id) {
return n;
}
}
throw new IllegalStateException("could not find in " + node + " id " + id);
}
/**
* Simple input stream to byte array converter.
*
* @param inputStream the input stream that will be converted.
* @return the content of the input stream in form of a byte array.
* @throws IOException thrown if there was an IO error while converting data.
*/
public static byte[] convertInputStreamToByteArray(InputStream inputStream) throws IOException {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
int read;
byte[] data = new byte[512];
while ((read = inputStream.read(data, 0, data.length)) != -1) {
buffer.write(data, 0, read);
}
buffer.flush();
return buffer.toByteArray();
}
}