org.apache.flink.shaded.jackson2.com.fasterxml.jackson.core.JsonProcessingException Java Examples

private static <P extends ResponseBody> CompletableFuture<P> parseResponse(JsonResponse rawResponse, JavaType responseType) {
	CompletableFuture<P> responseFuture = new CompletableFuture<>();
	final JsonParser jsonParser = objectMapper.treeAsTokens(rawResponse.json);
	try {
		P response = objectMapper.readValue(jsonParser, responseType);
		responseFuture.complete(response);
	} catch (IOException originalException) {
		// the received response did not matched the expected response type

		// lets see if it is an ErrorResponse instead
		try {
			ErrorResponseBody error = objectMapper.treeToValue(rawResponse.getJson(), ErrorResponseBody.class);
			responseFuture.completeExceptionally(new RestClientException(error.errors.toString(), rawResponse.getHttpResponseStatus()));
		} catch (JsonProcessingException jpe2) {
			// if this fails it is either the expected type or response type was wrong, most likely caused
			// by a client/search MessageHeaders mismatch
			LOG.error("Received response was neither of the expected type ({}) nor an error. Response={}", responseType, rawResponse, jpe2);
			responseFuture.completeExceptionally(
				new RestClientException(
					"Response was neither of the expected type(" + responseType + ") nor an error.",
					originalException,
					rawResponse.getHttpResponseStatus()));
		}
	}
	return responseFuture;
}
 

@Test
public void serializeMeterWithoutHost() throws JsonProcessingException {

	DMeter m = new DMeter(new Meter() {
		@Override
		public void markEvent() {}

		@Override
		public void markEvent(long n) {}

		@Override
		public double getRate() {
			return 1;
		}

		@Override
		public long getCount() {
			return 0;
		}
	}, "testMeter", null, tags, () -> MOCKED_SYSTEM_MILLIS);

	assertEquals(
		"{\"metric\":\"testMeter\",\"type\":\"gauge\",\"tags\":[\"tag1\",\"tag2\"],\"points\":[[123,1.0]]}",
		DatadogHttpClient.serialize(m));
}
 

@Test
public void serializeMeter() throws JsonProcessingException {

	DMeter m = new DMeter(new Meter() {
		@Override
		public void markEvent() {}

		@Override
		public void markEvent(long n) {}

		@Override
		public double getRate() {
			return 1;
		}

		@Override
		public long getCount() {
			return 0;
		}
	}, "testMeter", "localhost", tags, () -> MOCKED_SYSTEM_MILLIS);

	assertEquals(
		"{\"metric\":\"testMeter\",\"type\":\"gauge\",\"host\":\"localhost\",\"tags\":[\"tag1\",\"tag2\"],\"points\":[[123,1.0]]}",
		DatadogHttpClient.serialize(m));
}
 

@Override
public String toJson() {
	ObjectMapper mapper = new ObjectMapper();

	List<Map<String, String>> stageJsons = new ArrayList<>();
	for (PipelineStage s : getStages()) {
		Map<String, String> stageMap = new HashMap<>();
		stageMap.put("stageClassName", s.getClass().getTypeName());
		stageMap.put("stageJson", s.toJson());
		stageJsons.add(stageMap);
	}

	try {
		return mapper.writeValueAsString(stageJsons);
	} catch (JsonProcessingException e) {
		throw new RuntimeException("Failed to serialize pipeline", e);
	}
}
 

/**
 * Tests that we can marshal and unmarshal JobDetails instances.
 */
@Test
public void testJobDetailsMarshalling() throws JsonProcessingException {
	final JobDetails expected = new JobDetails(
		new JobID(),
		"foobar",
		1L,
		10L,
		9L,
		JobStatus.RUNNING,
		8L,
		new int[]{1, 3, 3, 7, 4, 2, 7, 3, 3},
		42);

	final ObjectMapper objectMapper = RestMapperUtils.getStrictObjectMapper();

	final JsonNode marshalled = objectMapper.valueToTree(expected);

	final JobDetails unmarshalled = objectMapper.treeToValue(marshalled, JobDetails.class);

	assertEquals(expected, unmarshalled);
}
 

private static <P extends ResponseBody> CompletableFuture<P> parseResponse(JsonResponse rawResponse, JavaType responseType) {
	CompletableFuture<P> responseFuture = new CompletableFuture<>();
	final JsonParser jsonParser = objectMapper.treeAsTokens(rawResponse.json);
	try {
		P response = objectMapper.readValue(jsonParser, responseType);
		responseFuture.complete(response);
	} catch (IOException originalException) {
		// the received response did not matched the expected response type

		// lets see if it is an ErrorResponse instead
		try {
			ErrorResponseBody error = objectMapper.treeToValue(rawResponse.getJson(), ErrorResponseBody.class);
			responseFuture.completeExceptionally(new RestClientException(error.errors.toString(), rawResponse.getHttpResponseStatus()));
		} catch (JsonProcessingException jpe2) {
			// if this fails it is either the expected type or response type was wrong, most likely caused
			// by a client/search MessageHeaders mismatch
			LOG.error("Received response was neither of the expected type ({}) nor an error. Response={}", responseType, rawResponse, jpe2);
			responseFuture.completeExceptionally(
				new RestClientException(
					"Response was neither of the expected type(" + responseType + ") nor an error.",
					originalException,
					rawResponse.getHttpResponseStatus()));
		}
	}
	return responseFuture;
}
 

private static String createMessageHtmlEntry(Class<?> messageClass, @Nullable Class<?> nestedAsyncOperationResultClass, Class<?> emptyMessageClass) {
	JsonSchema schema = generateSchema(messageClass);

	if (nestedAsyncOperationResultClass != null) {
		JsonSchema innerSchema = generateSchema(nestedAsyncOperationResultClass);
		schema.asObjectSchema().getProperties().put(AsynchronousOperationResult.FIELD_NAME_OPERATION, innerSchema);
	}

	String json;
	if (messageClass == emptyMessageClass) {
		json = "{}";
	} else {
		try {
			json = mapper.writerWithDefaultPrettyPrinter()
				.writeValueAsString(schema);
		} catch (JsonProcessingException e) {
			LOG.error("Failed to write message schema for class {}.", messageClass.getCanonicalName(), e);
			throw new RuntimeException("Failed to write message schema for class " + messageClass.getCanonicalName() + ".", e);
		}
	}

	return json;
}
 

@Override
public String toJson() {
	ObjectMapper mapper = new ObjectMapper();

	List<Map<String, String>> stageJsons = new ArrayList<>();
	for (PipelineStage s : getStages()) {
		Map<String, String> stageMap = new HashMap<>();
		stageMap.put("stageClassName", s.getClass().getTypeName());
		stageMap.put("stageJson", s.toJson());
		stageJsons.add(stageMap);
	}

	try {
		return mapper.writeValueAsString(stageJsons);
	} catch (JsonProcessingException e) {
		throw new RuntimeException("Failed to toString pipeline", e);
	}
}
 

@Before
public void init()
        throws JsonProcessingException
{
    String json = MAPPER.writeValueAsString(ImmutableMap.of("user_id", "uid_001",
            "ip", "127.0.0.1",
            "store", 12.0,
            "key1", ImmutableMap.of("key2", 123)
    ));

    StreamExecutionEnvironment execEnv = StreamExecutionEnvironment.createLocalEnvironment();
    execEnv.setParallelism(2);
    tableEnv = StreamTableEnvironment.create(execEnv);
    tableEnv.registerFunction("get_json_object", new UDFJson());
    table = tableEnv.sqlQuery("select '" + json + "' as message");
}
 

@Test
public void serializeMeterWithoutHost() throws JsonProcessingException {

	DMeter m = new DMeter(new Meter() {
		@Override
		public void markEvent() {}

		@Override
		public void markEvent(long n) {}

		@Override
		public double getRate() {
			return 1;
		}

		@Override
		public long getCount() {
			return 0;
		}
	}, "testMeter", null, tags);

	assertEquals(
		"{\"metric\":\"testMeter\",\"type\":\"gauge\",\"tags\":[\"tag1\",\"tag2\"],\"points\":[[123,1.0]]}",
		DatadogHttpClient.serialize(m));
}
 

@Test
public void serializeMeter() throws JsonProcessingException {

	DMeter m = new DMeter(new Meter() {
		@Override
		public void markEvent() {}

		@Override
		public void markEvent(long n) {}

		@Override
		public double getRate() {
			return 1;
		}

		@Override
		public long getCount() {
			return 0;
		}
	}, "testMeter", "localhost", tags);

	assertEquals(
		"{\"metric\":\"testMeter\",\"type\":\"gauge\",\"host\":\"localhost\",\"tags\":[\"tag1\",\"tag2\"],\"points\":[[123,1.0]]}",
		DatadogHttpClient.serialize(m));
}
 

@Override
public String toJson() {
	ObjectMapper mapper = new ObjectMapper();

	List<Map<String, String>> stageJsons = new ArrayList<>();
	for (PipelineStage s : getStages()) {
		Map<String, String> stageMap = new HashMap<>();
		stageMap.put("stageClassName", s.getClass().getTypeName());
		stageMap.put("stageJson", s.toJson());
		stageJsons.add(stageMap);
	}

	try {
		return mapper.writeValueAsString(stageJsons);
	} catch (JsonProcessingException e) {
		throw new RuntimeException("Failed to serialize pipeline", e);
	}
}
 

/**
 * Tests that we can marshal and unmarshal JobDetails instances.
 */
@Test
public void testJobDetailsMarshalling() throws JsonProcessingException {
	final JobDetails expected = new JobDetails(
		new JobID(),
		"foobar",
		1L,
		10L,
		9L,
		JobStatus.RUNNING,
		8L,
		new int[]{1, 3, 3, 7, 4, 2, 7, 3, 3},
		42);

	final ObjectMapper objectMapper = RestMapperUtils.getStrictObjectMapper();

	final JsonNode marshalled = objectMapper.valueToTree(expected);

	final JobDetails unmarshalled = objectMapper.treeToValue(marshalled, JobDetails.class);

	assertEquals(expected, unmarshalled);
}
 

private static <P extends ResponseBody> CompletableFuture<P> parseResponse(JsonResponse rawResponse, JavaType responseType) {
	CompletableFuture<P> responseFuture = new CompletableFuture<>();
	final JsonParser jsonParser = objectMapper.treeAsTokens(rawResponse.json);
	try {
		P response = objectMapper.readValue(jsonParser, responseType);
		responseFuture.complete(response);
	} catch (IOException originalException) {
		// the received response did not matched the expected response type

		// lets see if it is an ErrorResponse instead
		try {
			ErrorResponseBody error = objectMapper.treeToValue(rawResponse.getJson(), ErrorResponseBody.class);
			responseFuture.completeExceptionally(new RestClientException(error.errors.toString(), rawResponse.getHttpResponseStatus()));
		} catch (JsonProcessingException jpe2) {
			// if this fails it is either the expected type or response type was wrong, most likely caused
			// by a client/search MessageHeaders mismatch
			LOG.error("Received response was neither of the expected type ({}) nor an error. Response={}", responseType, rawResponse, jpe2);
			responseFuture.completeExceptionally(
				new RestClientException(
					"Response was neither of the expected type(" + responseType + ") nor an error.",
					originalException,
					rawResponse.getHttpResponseStatus()));
		}
	}
	return responseFuture;
}
 

/**
 * Tests that we can marshal and unmarshal JobDetails instances.
 */
@Test
public void testJobDetailsMarshalling() throws JsonProcessingException {
	final JobDetails expected = new JobDetails(
		new JobID(),
		"foobar",
		1L,
		10L,
		9L,
		JobStatus.RUNNING,
		8L,
		new int[]{1, 3, 3, 7, 4, 2, 7, 3, 3},
		42);

	final ObjectMapper objectMapper = RestMapperUtils.getStrictObjectMapper();

	final JsonNode marshalled = objectMapper.valueToTree(expected);

	final JobDetails unmarshalled = objectMapper.treeToValue(marshalled, JobDetails.class);

	assertEquals(expected, unmarshalled);
}
 

@Test
public void serializeMeter() throws JsonProcessingException {

	DMeter m = new DMeter(new Meter() {
		@Override
		public void markEvent() {}

		@Override
		public void markEvent(long n) {}

		@Override
		public double getRate() {
			return 1;
		}

		@Override
		public long getCount() {
			return 0;
		}
	}, "testMeter", "localhost", tags);

	assertEquals(
		"{\"metric\":\"testMeter\",\"type\":\"gauge\",\"host\":\"localhost\",\"tags\":[\"tag1\",\"tag2\"],\"points\":[[123,1.0]]}",
		DatadogHttpClient.serialize(m));
}
 

@Test
public void serializeMeterWithoutHost() throws JsonProcessingException {

	DMeter m = new DMeter(new Meter() {
		@Override
		public void markEvent() {}

		@Override
		public void markEvent(long n) {}

		@Override
		public double getRate() {
			return 1;
		}

		@Override
		public long getCount() {
			return 0;
		}
	}, "testMeter", null, tags);

	assertEquals(
		"{\"metric\":\"testMeter\",\"type\":\"gauge\",\"tags\":[\"tag1\",\"tag2\"],\"points\":[[123,1.0]]}",
		DatadogHttpClient.serialize(m));
}
 

private static JsonSchema generateSchema(Class<?> messageClass) {
	try {
		return schemaGen.generateSchema(messageClass);
	} catch (JsonProcessingException e) {
		LOG.error("Failed to generate message schema for class {}.", messageClass, e);
		throw new RuntimeException("Failed to generate message schema for class " + messageClass.getCanonicalName() + ".", e);
	}
}
 

/**
 * serialize an object to pretty json.
 *
 * @param src the object serialized as json
 * @return the json string
 */
public static String toPrettyJson(Object src) {
	try {
		return JSON_INSTANCE.writerWithDefaultPrettyPrinter().writeValueAsString(src);
	} catch (JsonProcessingException e) {
		throw new IllegalJsonFormatException("Serialize object to json fail.", e);
	}
}
 

public ControlMessage(ControlEvent event) {
    this.type = event.getClass().getName();
    ObjectMapper mapper = new ObjectMapper();
    try {
        this.payload = mapper.writeValueAsString(event);
    } catch (JsonProcessingException e) {
        throw new IllegalArgumentException(e);
    }
}
 

@Override
public byte[] serialize(T t) {
    try {
        return mapper.writeValueAsBytes(t);
    } catch (JsonProcessingException e) {
        throw new RuntimeException("Error while serializing the record to Json", e);
    }
}
 

private DeserializationRuntimeConverter createFallbackConverter(Class<?> valueType) {
	return (mapper, jsonNode) -> {
		// for types that were specified without JSON schema
		// e.g. POJOs
		try {
			return mapper.treeToValue(jsonNode, valueType);
		} catch (JsonProcessingException e) {
			throw new JsonParseException(format("Could not convert node: %s", jsonNode), e);
		}
	};
}
 

@VisibleForTesting
static ArrayList getNameSpaceArray(MetricKey metricKey) {
	MetricName metricName = metricKey.metricName();
	try {
		return new ObjectMapper().readValue(metricName.getNamespace(), ArrayList.class);
	} catch (JsonProcessingException e) {
		throw new RuntimeException(
			String.format("Parse namespace[%s] error. ", metricName.getNamespace()), e);
	}
}
 

@Test
public void serializeGauge() throws JsonProcessingException {

	DGauge g = new DGauge(new Gauge<Number>() {
		@Override
		public Number getValue() {
			return 1;
		}
	}, "testCounter", "localhost", tags);

	assertEquals(
		"{\"metric\":\"testCounter\",\"type\":\"gauge\",\"host\":\"localhost\",\"tags\":[\"tag1\",\"tag2\"],\"points\":[[123,1]]}",
		DatadogHttpClient.serialize(g));
}
 

private void readRawResponse(FullHttpResponse msg) {
	ByteBuf content = msg.content();

	JsonNode rawResponse;
	try (InputStream in = new ByteBufInputStream(content)) {
		rawResponse = objectMapper.readTree(in);
		LOG.debug("Received response {}.", rawResponse);
	} catch (JsonProcessingException je) {
		LOG.error("Response was not valid JSON.", je);
		// let's see if it was a plain-text message instead
		content.readerIndex(0);
		try (ByteBufInputStream in = new ByteBufInputStream(content)) {
			byte[] data = new byte[in.available()];
			in.readFully(data);
			String message = new String(data);
			LOG.error("Unexpected plain-text response: {}", message);
			jsonFuture.completeExceptionally(new RestClientException("Response was not valid JSON, but plain-text: " + message, je, msg.getStatus()));
		} catch (IOException e) {
			jsonFuture.completeExceptionally(new RestClientException("Response was not valid JSON, nor plain-text.", je, msg.getStatus()));
		}
		return;
	} catch (IOException ioe) {
		LOG.error("Response could not be read.", ioe);
		jsonFuture.completeExceptionally(new RestClientException("Response could not be read.", ioe, msg.getStatus()));
		return;
	}
	jsonFuture.complete(new JsonResponse(rawResponse, msg.getStatus()));
}
 

private static <X> X jsonToObject(final JsonNode jsonContainer, final Class<X> containerClass) {
	try {
		return OBJECT_MAPPER.treeToValue(jsonContainer, containerClass);
	} catch (JsonProcessingException e) {
		throw new RuntimeException(e);
	}
}
 

private void readRawResponse(FullHttpResponse msg) {
	ByteBuf content = msg.content();

	JsonNode rawResponse;
	try (InputStream in = new ByteBufInputStream(content)) {
		rawResponse = objectMapper.readTree(in);
		LOG.debug("Received response {}.", rawResponse);
	} catch (JsonProcessingException je) {
		LOG.error("Response was not valid JSON.", je);
		// let's see if it was a plain-text message instead
		content.readerIndex(0);
		try (ByteBufInputStream in = new ByteBufInputStream(content)) {
			byte[] data = new byte[in.available()];
			in.readFully(data);
			String message = new String(data);
			LOG.error("Unexpected plain-text response: {}", message);
			jsonFuture.completeExceptionally(new RestClientException("Response was not valid JSON, but plain-text: " + message, je, msg.getStatus()));
		} catch (IOException e) {
			jsonFuture.completeExceptionally(new RestClientException("Response was not valid JSON, nor plain-text.", je, msg.getStatus()));
		}
		return;
	} catch (IOException ioe) {
		LOG.error("Response could not be read.", ioe);
		jsonFuture.completeExceptionally(new RestClientException("Response could not be read.", ioe, msg.getStatus()));
		return;
	}
	jsonFuture.complete(new JsonResponse(rawResponse, msg.getStatus()));
}
 

/**
 * Returns a json containing all parameters in this Params. The json should be human-readable if
 * possible.
 *
 * @return a json containing all parameters in this Params
 */
public String toJson() {
	assertMapperInited();
	try {
		return mapper.writeValueAsString(params);
	} catch (JsonProcessingException e) {
		throw new RuntimeException("Failed to serialize params to json", e);
	}
}
 

private String valueToJson(Object value) {
	assertMapperInited();
	try {
		if (value == null) {
			return null;
		}
		return mapper.writeValueAsString(value);
	} catch (JsonProcessingException e) {
		throw new RuntimeException("Failed to serialize to json:" + value, e);
	}
}
 

@Test
public void serializeGauge() throws JsonProcessingException {

	DGauge g = new DGauge(new Gauge<Number>() {
		@Override
		public Number getValue() {
			return 1;
		}
	}, "testCounter", "localhost", tags, () -> MOCKED_SYSTEM_MILLIS);

	assertEquals(
		"{\"metric\":\"testCounter\",\"type\":\"gauge\",\"host\":\"localhost\",\"tags\":[\"tag1\",\"tag2\"],\"points\":[[123,1]]}",
		DatadogHttpClient.serialize(g));
}