target
stringlengths 20
113k
| src_fm
stringlengths 11
86.3k
| src_fm_fc
stringlengths 21
86.4k
| src_fm_fc_co
stringlengths 30
86.4k
| src_fm_fc_ms
stringlengths 42
86.8k
| src_fm_fc_ms_ff
stringlengths 43
86.8k
|
|---|---|---|---|---|---|
@Test public void should_support_float_property() { Model model = swagger.getDefinitions().get("AllType"); Property property = model.getProperties().get("fValue"); assertThat(ConverterMgr.findJavaType(swagger, property).getRawClass()).isEqualTo(Float.class); }
|
public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); }
|
ConverterMgr { public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); } }
|
ConverterMgr { public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); } private ConverterMgr(); }
|
ConverterMgr { public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); } private ConverterMgr(); static JavaType findJavaType(String type, String format); static JavaType findJavaType(Swagger swagger, Object def); }
|
ConverterMgr { public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); } private ConverterMgr(); static JavaType findJavaType(String type, String format); static JavaType findJavaType(Swagger swagger, Object def); }
|
@Test public void should_support_double_property() { Model model = swagger.getDefinitions().get("AllType"); Property property = model.getProperties().get("dValue"); assertThat(ConverterMgr.findJavaType(swagger, property).getRawClass()).isEqualTo(Double.class); }
|
public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); }
|
ConverterMgr { public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); } }
|
ConverterMgr { public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); } private ConverterMgr(); }
|
ConverterMgr { public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); } private ConverterMgr(); static JavaType findJavaType(String type, String format); static JavaType findJavaType(Swagger swagger, Object def); }
|
ConverterMgr { public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); } private ConverterMgr(); static JavaType findJavaType(String type, String format); static JavaType findJavaType(Swagger swagger, Object def); }
|
@Test public void should_support_enum_property_with_available_type() { Model model = swagger.getDefinitions().get("AllType"); Property property = model.getProperties().get("enumValue"); assertThat(SwaggerUtils.getClassName(property.getVendorExtensions())) .isEqualTo("org.apache.servicecomb.foundation.test.scaffolding.model.Color"); assertThat(ConverterMgr.findJavaType(swagger, property).getRawClass()).isEqualTo(Color.class); }
|
public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); }
|
ConverterMgr { public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); } }
|
ConverterMgr { public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); } private ConverterMgr(); }
|
ConverterMgr { public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); } private ConverterMgr(); static JavaType findJavaType(String type, String format); static JavaType findJavaType(Swagger swagger, Object def); }
|
ConverterMgr { public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); } private ConverterMgr(); static JavaType findJavaType(String type, String format); static JavaType findJavaType(Swagger swagger, Object def); }
|
@Test public void should_support_bytes_property() { Model model = swagger.getDefinitions().get("AllType"); Property property = model.getProperties().get("bytes"); assertThat(ConverterMgr.findJavaType(swagger, property).getRawClass()).isEqualTo(byte[].class); }
|
public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); }
|
ConverterMgr { public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); } }
|
ConverterMgr { public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); } private ConverterMgr(); }
|
ConverterMgr { public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); } private ConverterMgr(); static JavaType findJavaType(String type, String format); static JavaType findJavaType(Swagger swagger, Object def); }
|
ConverterMgr { public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); } private ConverterMgr(); static JavaType findJavaType(String type, String format); static JavaType findJavaType(Swagger swagger, Object def); }
|
@Test public void test_registerMicroserviceInstance_whenInstanceExist_shouldRegisterSuccessfully() { ServerUtil.microserviceInstanceMap = prepareServiceInstanceMap(false); target.registerMicroserviceInstance(prepareServerServiceInstance(true, instanceId)); Assert.assertTrue(ServerUtil.microserviceInstanceMap.containsKey(serviceId)); Assert.assertTrue(ServerUtil.microserviceInstanceMap.get(serviceId).containsKey(instanceId)); Assert.assertEquals(1, ServerUtil.microserviceInstanceMap.size()); }
|
public void registerMicroserviceInstance(ServerMicroserviceInstance receivedInstance) { String instanceId = receivedInstance.getInstanceId(); String serviceId = receivedInstance.getServiceId(); String serviceName = receivedInstance.getServiceName(); if (serviceId == null || serviceName == null || instanceId == null) { throw new IllegalArgumentException("Invalid serviceId, serviceId=" + serviceId + "Invalid serviceName, serviceName=" + serviceName + "Invalid instanceId, instanceId=" + instanceId); } Map<String, ServerMicroserviceInstance> innerInstanceMap = ServerUtil.microserviceInstanceMap. computeIfAbsent(serviceId, id -> new ConcurrentHashMap<>()); if (innerInstanceMap.containsKey(instanceId)) { LOGGER.info("ServiceId: {}, instanceId: {} already exists", serviceId, instanceId); } else { LOGGER .info("Register a new instance for serviceId: {}, instanceId: {}, status: {}, name: {}", serviceId, instanceId, receivedInstance.getStatus(), receivedInstance.getServiceName()); innerInstanceMap.put(instanceId, receivedInstance); } }
|
ZeroConfigRegistryService { public void registerMicroserviceInstance(ServerMicroserviceInstance receivedInstance) { String instanceId = receivedInstance.getInstanceId(); String serviceId = receivedInstance.getServiceId(); String serviceName = receivedInstance.getServiceName(); if (serviceId == null || serviceName == null || instanceId == null) { throw new IllegalArgumentException("Invalid serviceId, serviceId=" + serviceId + "Invalid serviceName, serviceName=" + serviceName + "Invalid instanceId, instanceId=" + instanceId); } Map<String, ServerMicroserviceInstance> innerInstanceMap = ServerUtil.microserviceInstanceMap. computeIfAbsent(serviceId, id -> new ConcurrentHashMap<>()); if (innerInstanceMap.containsKey(instanceId)) { LOGGER.info("ServiceId: {}, instanceId: {} already exists", serviceId, instanceId); } else { LOGGER .info("Register a new instance for serviceId: {}, instanceId: {}, status: {}, name: {}", serviceId, instanceId, receivedInstance.getStatus(), receivedInstance.getServiceName()); innerInstanceMap.put(instanceId, receivedInstance); } } }
|
ZeroConfigRegistryService { public void registerMicroserviceInstance(ServerMicroserviceInstance receivedInstance) { String instanceId = receivedInstance.getInstanceId(); String serviceId = receivedInstance.getServiceId(); String serviceName = receivedInstance.getServiceName(); if (serviceId == null || serviceName == null || instanceId == null) { throw new IllegalArgumentException("Invalid serviceId, serviceId=" + serviceId + "Invalid serviceName, serviceName=" + serviceName + "Invalid instanceId, instanceId=" + instanceId); } Map<String, ServerMicroserviceInstance> innerInstanceMap = ServerUtil.microserviceInstanceMap. computeIfAbsent(serviceId, id -> new ConcurrentHashMap<>()); if (innerInstanceMap.containsKey(instanceId)) { LOGGER.info("ServiceId: {}, instanceId: {} already exists", serviceId, instanceId); } else { LOGGER .info("Register a new instance for serviceId: {}, instanceId: {}, status: {}, name: {}", serviceId, instanceId, receivedInstance.getStatus(), receivedInstance.getServiceName()); innerInstanceMap.put(instanceId, receivedInstance); } } }
|
ZeroConfigRegistryService { public void registerMicroserviceInstance(ServerMicroserviceInstance receivedInstance) { String instanceId = receivedInstance.getInstanceId(); String serviceId = receivedInstance.getServiceId(); String serviceName = receivedInstance.getServiceName(); if (serviceId == null || serviceName == null || instanceId == null) { throw new IllegalArgumentException("Invalid serviceId, serviceId=" + serviceId + "Invalid serviceName, serviceName=" + serviceName + "Invalid instanceId, instanceId=" + instanceId); } Map<String, ServerMicroserviceInstance> innerInstanceMap = ServerUtil.microserviceInstanceMap. computeIfAbsent(serviceId, id -> new ConcurrentHashMap<>()); if (innerInstanceMap.containsKey(instanceId)) { LOGGER.info("ServiceId: {}, instanceId: {} already exists", serviceId, instanceId); } else { LOGGER .info("Register a new instance for serviceId: {}, instanceId: {}, status: {}, name: {}", serviceId, instanceId, receivedInstance.getStatus(), receivedInstance.getServiceName()); innerInstanceMap.put(instanceId, receivedInstance); } } void registerMicroserviceInstance(ServerMicroserviceInstance receivedInstance); void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance); ServerMicroserviceInstance findServiceInstance(String serviceId,
String instanceId); List<ServerMicroserviceInstance> getMicroserviceInstance(String consumerId,
String providerId); void heartbeat(ServerMicroserviceInstance receivedInstance); boolean heartbeat(String microserviceId, String microserviceInstanceId); ServerMicroserviceInstance getMicroservice(String microserviceId); List<ServerMicroserviceInstance> findServiceInstances(String appId, String serviceName); }
|
ZeroConfigRegistryService { public void registerMicroserviceInstance(ServerMicroserviceInstance receivedInstance) { String instanceId = receivedInstance.getInstanceId(); String serviceId = receivedInstance.getServiceId(); String serviceName = receivedInstance.getServiceName(); if (serviceId == null || serviceName == null || instanceId == null) { throw new IllegalArgumentException("Invalid serviceId, serviceId=" + serviceId + "Invalid serviceName, serviceName=" + serviceName + "Invalid instanceId, instanceId=" + instanceId); } Map<String, ServerMicroserviceInstance> innerInstanceMap = ServerUtil.microserviceInstanceMap. computeIfAbsent(serviceId, id -> new ConcurrentHashMap<>()); if (innerInstanceMap.containsKey(instanceId)) { LOGGER.info("ServiceId: {}, instanceId: {} already exists", serviceId, instanceId); } else { LOGGER .info("Register a new instance for serviceId: {}, instanceId: {}, status: {}, name: {}", serviceId, instanceId, receivedInstance.getStatus(), receivedInstance.getServiceName()); innerInstanceMap.put(instanceId, receivedInstance); } } void registerMicroserviceInstance(ServerMicroserviceInstance receivedInstance); void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance); ServerMicroserviceInstance findServiceInstance(String serviceId,
String instanceId); List<ServerMicroserviceInstance> getMicroserviceInstance(String consumerId,
String providerId); void heartbeat(ServerMicroserviceInstance receivedInstance); boolean heartbeat(String microserviceId, String microserviceInstanceId); ServerMicroserviceInstance getMicroservice(String microserviceId); List<ServerMicroserviceInstance> findServiceInstances(String appId, String serviceName); }
|
@Test public void should_support_string_property() { Model model = swagger.getDefinitions().get("AllType"); Property property = model.getProperties().get("strValue"); assertThat(ConverterMgr.findJavaType(swagger, property).getRawClass()).isEqualTo(String.class); }
|
public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); }
|
ConverterMgr { public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); } }
|
ConverterMgr { public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); } private ConverterMgr(); }
|
ConverterMgr { public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); } private ConverterMgr(); static JavaType findJavaType(String type, String format); static JavaType findJavaType(Swagger swagger, Object def); }
|
ConverterMgr { public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); } private ConverterMgr(); static JavaType findJavaType(String type, String format); static JavaType findJavaType(Swagger swagger, Object def); }
|
@Test public void should_support_set_property() { Model model = swagger.getDefinitions().get("AllType"); Property property = model.getProperties().get("set"); assertThat(ConverterMgr.findJavaType(swagger, property)) .isEqualTo(TypeFactory.defaultInstance().constructCollectionType( Set.class, String.class)); }
|
public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); }
|
ConverterMgr { public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); } }
|
ConverterMgr { public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); } private ConverterMgr(); }
|
ConverterMgr { public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); } private ConverterMgr(); static JavaType findJavaType(String type, String format); static JavaType findJavaType(Swagger swagger, Object def); }
|
ConverterMgr { public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); } private ConverterMgr(); static JavaType findJavaType(String type, String format); static JavaType findJavaType(Swagger swagger, Object def); }
|
@Test public void should_support_list_property() { Model model = swagger.getDefinitions().get("AllType"); Property property = model.getProperties().get("list"); assertThat(ConverterMgr.findJavaType(swagger, property)) .isEqualTo(TypeFactory.defaultInstance().constructCollectionType( List.class, User.class)); }
|
public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); }
|
ConverterMgr { public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); } }
|
ConverterMgr { public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); } private ConverterMgr(); }
|
ConverterMgr { public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); } private ConverterMgr(); static JavaType findJavaType(String type, String format); static JavaType findJavaType(Swagger swagger, Object def); }
|
ConverterMgr { public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); } private ConverterMgr(); static JavaType findJavaType(String type, String format); static JavaType findJavaType(Swagger swagger, Object def); }
|
@Test public void should_support_map_property() { Model model = swagger.getDefinitions().get("AllType"); Property property = model.getProperties().get("map"); assertThat(ConverterMgr.findJavaType(swagger, property)) .isEqualTo(TypeFactory.defaultInstance().constructMapType( Map.class, String.class, User.class)); }
|
public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); }
|
ConverterMgr { public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); } }
|
ConverterMgr { public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); } private ConverterMgr(); }
|
ConverterMgr { public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); } private ConverterMgr(); static JavaType findJavaType(String type, String format); static JavaType findJavaType(Swagger swagger, Object def); }
|
ConverterMgr { public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); } private ConverterMgr(); static JavaType findJavaType(String type, String format); static JavaType findJavaType(Swagger swagger, Object def); }
|
@Test public void should_support_object_property() { Property property = new ObjectProperty(); assertThat(ConverterMgr.findJavaType(swagger, property).getRawClass()) .isEqualTo(Object.class); }
|
public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); }
|
ConverterMgr { public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); } }
|
ConverterMgr { public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); } private ConverterMgr(); }
|
ConverterMgr { public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); } private ConverterMgr(); static JavaType findJavaType(String type, String format); static JavaType findJavaType(Swagger swagger, Object def); }
|
ConverterMgr { public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); } private ConverterMgr(); static JavaType findJavaType(String type, String format); static JavaType findJavaType(Swagger swagger, Object def); }
|
@SuppressWarnings("unchecked") @Test public void jaxrsResponse() { SwaggerConsumerOperation operation = swaggerConsumer.findOperation("jaxrsResponse"); Response jaxrsResponse = (Response) operation.getResponseMapper().mapResponse(response); Assert.assertEquals(result, jaxrsResponse.getEntity()); Assert.assertTrue(jaxrsResponse.getHeaders().isEmpty()); }
|
@Override public Object mapResponse(Response response) { ResponseBuilder responseBuilder = javax.ws.rs.core.Response.status(response.getStatus()).entity(response.getResult()); Map<String, List<Object>> headers = response.getHeaders().getHeaderMap(); if (headers == null) { return responseBuilder.build(); } for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null) { continue; } for (Object value : entry.getValue()) { if (value != null) { responseBuilder.header(entry.getKey(), value); } } } return responseBuilder.build(); }
|
JaxrsConsumerResponseMapper implements ConsumerResponseMapper { @Override public Object mapResponse(Response response) { ResponseBuilder responseBuilder = javax.ws.rs.core.Response.status(response.getStatus()).entity(response.getResult()); Map<String, List<Object>> headers = response.getHeaders().getHeaderMap(); if (headers == null) { return responseBuilder.build(); } for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null) { continue; } for (Object value : entry.getValue()) { if (value != null) { responseBuilder.header(entry.getKey(), value); } } } return responseBuilder.build(); } }
|
JaxrsConsumerResponseMapper implements ConsumerResponseMapper { @Override public Object mapResponse(Response response) { ResponseBuilder responseBuilder = javax.ws.rs.core.Response.status(response.getStatus()).entity(response.getResult()); Map<String, List<Object>> headers = response.getHeaders().getHeaderMap(); if (headers == null) { return responseBuilder.build(); } for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null) { continue; } for (Object value : entry.getValue()) { if (value != null) { responseBuilder.header(entry.getKey(), value); } } } return responseBuilder.build(); } }
|
JaxrsConsumerResponseMapper implements ConsumerResponseMapper { @Override public Object mapResponse(Response response) { ResponseBuilder responseBuilder = javax.ws.rs.core.Response.status(response.getStatus()).entity(response.getResult()); Map<String, List<Object>> headers = response.getHeaders().getHeaderMap(); if (headers == null) { return responseBuilder.build(); } for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null) { continue; } for (Object value : entry.getValue()) { if (value != null) { responseBuilder.header(entry.getKey(), value); } } } return responseBuilder.build(); } @Override Object mapResponse(Response response); }
|
JaxrsConsumerResponseMapper implements ConsumerResponseMapper { @Override public Object mapResponse(Response response) { ResponseBuilder responseBuilder = javax.ws.rs.core.Response.status(response.getStatus()).entity(response.getResult()); Map<String, List<Object>> headers = response.getHeaders().getHeaderMap(); if (headers == null) { return responseBuilder.build(); } for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null) { continue; } for (Object value : entry.getValue()) { if (value != null) { responseBuilder.header(entry.getKey(), value); } } } return responseBuilder.build(); } @Override Object mapResponse(Response response); }
|
@Test public void jaxrsResponseWithHeaders() { SwaggerConsumerOperation operation = swaggerConsumer.findOperation("jaxrsResponse"); response.getHeaders().addHeader("h", "v1").addHeader("h", "v2").addHeader("h", (Object) null); response.getHeaders().getHeaderMap().put("h1", null); Response jaxrsResponse = (Response) operation.getResponseMapper().mapResponse(response); Assert.assertEquals(result, jaxrsResponse.getEntity()); Assert.assertEquals(1, jaxrsResponse.getHeaders().size()); Assert.assertThat(jaxrsResponse.getHeaders().get("h"), Matchers.contains("v1", "v2")); }
|
@Override public Object mapResponse(Response response) { ResponseBuilder responseBuilder = javax.ws.rs.core.Response.status(response.getStatus()).entity(response.getResult()); Map<String, List<Object>> headers = response.getHeaders().getHeaderMap(); if (headers == null) { return responseBuilder.build(); } for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null) { continue; } for (Object value : entry.getValue()) { if (value != null) { responseBuilder.header(entry.getKey(), value); } } } return responseBuilder.build(); }
|
JaxrsConsumerResponseMapper implements ConsumerResponseMapper { @Override public Object mapResponse(Response response) { ResponseBuilder responseBuilder = javax.ws.rs.core.Response.status(response.getStatus()).entity(response.getResult()); Map<String, List<Object>> headers = response.getHeaders().getHeaderMap(); if (headers == null) { return responseBuilder.build(); } for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null) { continue; } for (Object value : entry.getValue()) { if (value != null) { responseBuilder.header(entry.getKey(), value); } } } return responseBuilder.build(); } }
|
JaxrsConsumerResponseMapper implements ConsumerResponseMapper { @Override public Object mapResponse(Response response) { ResponseBuilder responseBuilder = javax.ws.rs.core.Response.status(response.getStatus()).entity(response.getResult()); Map<String, List<Object>> headers = response.getHeaders().getHeaderMap(); if (headers == null) { return responseBuilder.build(); } for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null) { continue; } for (Object value : entry.getValue()) { if (value != null) { responseBuilder.header(entry.getKey(), value); } } } return responseBuilder.build(); } }
|
JaxrsConsumerResponseMapper implements ConsumerResponseMapper { @Override public Object mapResponse(Response response) { ResponseBuilder responseBuilder = javax.ws.rs.core.Response.status(response.getStatus()).entity(response.getResult()); Map<String, List<Object>> headers = response.getHeaders().getHeaderMap(); if (headers == null) { return responseBuilder.build(); } for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null) { continue; } for (Object value : entry.getValue()) { if (value != null) { responseBuilder.header(entry.getKey(), value); } } } return responseBuilder.build(); } @Override Object mapResponse(Response response); }
|
JaxrsConsumerResponseMapper implements ConsumerResponseMapper { @Override public Object mapResponse(Response response) { ResponseBuilder responseBuilder = javax.ws.rs.core.Response.status(response.getStatus()).entity(response.getResult()); Map<String, List<Object>> headers = response.getHeaders().getHeaderMap(); if (headers == null) { return responseBuilder.build(); } for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null) { continue; } for (Object value : entry.getValue()) { if (value != null) { responseBuilder.header(entry.getKey(), value); } } } return responseBuilder.build(); } @Override Object mapResponse(Response response); }
|
@Test public void mapResponse_withoutHeaders() { new Expectations() { { jaxrsResponse.getStatusInfo(); result = Status.OK; jaxrsResponse.getEntity(); result = "result"; } }; Response response = mapper.mapResponse(null, jaxrsResponse); Assert.assertEquals(Status.OK, response.getStatus()); Assert.assertEquals("result", response.getResult()); Assert.assertNull(response.getHeaders().getHeaderMap()); }
|
@Override public Response mapResponse(StatusType status, Object response) { javax.ws.rs.core.Response jaxrsResponse = (javax.ws.rs.core.Response) response; Response cseResponse = Response.status(jaxrsResponse.getStatusInfo()).entity(jaxrsResponse.getEntity()); MultivaluedMap<String, Object> headers = jaxrsResponse.getHeaders(); for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null || entry.getValue().isEmpty()) { continue; } cseResponse.getHeaders().addHeader(entry.getKey(), entry.getValue()); } return cseResponse; }
|
JaxrsProducerResponseMapper implements ProducerResponseMapper { @Override public Response mapResponse(StatusType status, Object response) { javax.ws.rs.core.Response jaxrsResponse = (javax.ws.rs.core.Response) response; Response cseResponse = Response.status(jaxrsResponse.getStatusInfo()).entity(jaxrsResponse.getEntity()); MultivaluedMap<String, Object> headers = jaxrsResponse.getHeaders(); for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null || entry.getValue().isEmpty()) { continue; } cseResponse.getHeaders().addHeader(entry.getKey(), entry.getValue()); } return cseResponse; } }
|
JaxrsProducerResponseMapper implements ProducerResponseMapper { @Override public Response mapResponse(StatusType status, Object response) { javax.ws.rs.core.Response jaxrsResponse = (javax.ws.rs.core.Response) response; Response cseResponse = Response.status(jaxrsResponse.getStatusInfo()).entity(jaxrsResponse.getEntity()); MultivaluedMap<String, Object> headers = jaxrsResponse.getHeaders(); for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null || entry.getValue().isEmpty()) { continue; } cseResponse.getHeaders().addHeader(entry.getKey(), entry.getValue()); } return cseResponse; } }
|
JaxrsProducerResponseMapper implements ProducerResponseMapper { @Override public Response mapResponse(StatusType status, Object response) { javax.ws.rs.core.Response jaxrsResponse = (javax.ws.rs.core.Response) response; Response cseResponse = Response.status(jaxrsResponse.getStatusInfo()).entity(jaxrsResponse.getEntity()); MultivaluedMap<String, Object> headers = jaxrsResponse.getHeaders(); for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null || entry.getValue().isEmpty()) { continue; } cseResponse.getHeaders().addHeader(entry.getKey(), entry.getValue()); } return cseResponse; } @Override Response mapResponse(StatusType status, Object response); }
|
JaxrsProducerResponseMapper implements ProducerResponseMapper { @Override public Response mapResponse(StatusType status, Object response) { javax.ws.rs.core.Response jaxrsResponse = (javax.ws.rs.core.Response) response; Response cseResponse = Response.status(jaxrsResponse.getStatusInfo()).entity(jaxrsResponse.getEntity()); MultivaluedMap<String, Object> headers = jaxrsResponse.getHeaders(); for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null || entry.getValue().isEmpty()) { continue; } cseResponse.getHeaders().addHeader(entry.getKey(), entry.getValue()); } return cseResponse; } @Override Response mapResponse(StatusType status, Object response); }
|
@Test public void mapResponse_withHeaders() { MultivaluedMap<String, Object> headers = new MultivaluedHashMap<>(); headers.add("h", "v"); new Expectations() { { jaxrsResponse.getStatusInfo(); result = Status.OK; jaxrsResponse.getEntity(); result = "result"; jaxrsResponse.getHeaders(); result = headers; } }; Response response = mapper.mapResponse(null, jaxrsResponse); Assert.assertEquals(Status.OK, response.getStatus()); Assert.assertEquals("result", response.getResult()); Assert.assertEquals(1, response.getHeaders().getHeaderMap().size()); Assert.assertThat(response.getHeaders().getHeader("h"), Matchers.contains("v")); }
|
@Override public Response mapResponse(StatusType status, Object response) { javax.ws.rs.core.Response jaxrsResponse = (javax.ws.rs.core.Response) response; Response cseResponse = Response.status(jaxrsResponse.getStatusInfo()).entity(jaxrsResponse.getEntity()); MultivaluedMap<String, Object> headers = jaxrsResponse.getHeaders(); for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null || entry.getValue().isEmpty()) { continue; } cseResponse.getHeaders().addHeader(entry.getKey(), entry.getValue()); } return cseResponse; }
|
JaxrsProducerResponseMapper implements ProducerResponseMapper { @Override public Response mapResponse(StatusType status, Object response) { javax.ws.rs.core.Response jaxrsResponse = (javax.ws.rs.core.Response) response; Response cseResponse = Response.status(jaxrsResponse.getStatusInfo()).entity(jaxrsResponse.getEntity()); MultivaluedMap<String, Object> headers = jaxrsResponse.getHeaders(); for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null || entry.getValue().isEmpty()) { continue; } cseResponse.getHeaders().addHeader(entry.getKey(), entry.getValue()); } return cseResponse; } }
|
JaxrsProducerResponseMapper implements ProducerResponseMapper { @Override public Response mapResponse(StatusType status, Object response) { javax.ws.rs.core.Response jaxrsResponse = (javax.ws.rs.core.Response) response; Response cseResponse = Response.status(jaxrsResponse.getStatusInfo()).entity(jaxrsResponse.getEntity()); MultivaluedMap<String, Object> headers = jaxrsResponse.getHeaders(); for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null || entry.getValue().isEmpty()) { continue; } cseResponse.getHeaders().addHeader(entry.getKey(), entry.getValue()); } return cseResponse; } }
|
JaxrsProducerResponseMapper implements ProducerResponseMapper { @Override public Response mapResponse(StatusType status, Object response) { javax.ws.rs.core.Response jaxrsResponse = (javax.ws.rs.core.Response) response; Response cseResponse = Response.status(jaxrsResponse.getStatusInfo()).entity(jaxrsResponse.getEntity()); MultivaluedMap<String, Object> headers = jaxrsResponse.getHeaders(); for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null || entry.getValue().isEmpty()) { continue; } cseResponse.getHeaders().addHeader(entry.getKey(), entry.getValue()); } return cseResponse; } @Override Response mapResponse(StatusType status, Object response); }
|
JaxrsProducerResponseMapper implements ProducerResponseMapper { @Override public Response mapResponse(StatusType status, Object response) { javax.ws.rs.core.Response jaxrsResponse = (javax.ws.rs.core.Response) response; Response cseResponse = Response.status(jaxrsResponse.getStatusInfo()).entity(jaxrsResponse.getEntity()); MultivaluedMap<String, Object> headers = jaxrsResponse.getHeaders(); for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null || entry.getValue().isEmpty()) { continue; } cseResponse.getHeaders().addHeader(entry.getKey(), entry.getValue()); } return cseResponse; } @Override Response mapResponse(StatusType status, Object response); }
|
@Test public void isMatch_true() { Assert.assertTrue(factory.isMatch(Response.class)); }
|
@Override public boolean isMatch(Type producerType) { return Response.class.equals(producerType); }
|
JaxrsProducerResponseMapperFactory implements ProducerResponseMapperFactory { @Override public boolean isMatch(Type producerType) { return Response.class.equals(producerType); } }
|
JaxrsProducerResponseMapperFactory implements ProducerResponseMapperFactory { @Override public boolean isMatch(Type producerType) { return Response.class.equals(producerType); } }
|
JaxrsProducerResponseMapperFactory implements ProducerResponseMapperFactory { @Override public boolean isMatch(Type producerType) { return Response.class.equals(producerType); } @Override boolean isMatch(Type producerType); @Override ProducerResponseMapper createResponseMapper(ResponseMapperFactorys<ProducerResponseMapper> factorys,
Type producerType); }
|
JaxrsProducerResponseMapperFactory implements ProducerResponseMapperFactory { @Override public boolean isMatch(Type producerType) { return Response.class.equals(producerType); } @Override boolean isMatch(Type producerType); @Override ProducerResponseMapper createResponseMapper(ResponseMapperFactorys<ProducerResponseMapper> factorys,
Type producerType); }
|
@Test(expected = IllegalArgumentException.class) public void test_unregisterMicroserviceInstance_whenServiceIdIsNull_shouldThrowIllegalArgumentException() { target.unregisterMicroserviceInstance(prepareServerServiceInstance(false, instanceId)); }
|
public void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance) { String unregisterServiceId = receivedInstance.getServiceId(); String unregisterInstanceId = receivedInstance.getInstanceId(); if (unregisterServiceId == null || unregisterInstanceId == null) { throw new IllegalArgumentException( "Invalid unregisterServiceId, unregisterServiceId=" + unregisterServiceId + "Invalid unregisterInstanceId, unregisterInstanceId=" + unregisterInstanceId); } ServerUtil.microserviceInstanceMap .computeIfPresent(unregisterServiceId, (serviceId, instanceIdMap) -> { instanceIdMap.computeIfPresent(unregisterInstanceId, (instanceId, instance) -> { LOGGER.info( "Successfully unregistered/remove serviceId: {}, instanceId: {} from server side", unregisterServiceId, unregisterInstanceId); return null; }); return !instanceIdMap.isEmpty() ? instanceIdMap : null; }); }
|
ZeroConfigRegistryService { public void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance) { String unregisterServiceId = receivedInstance.getServiceId(); String unregisterInstanceId = receivedInstance.getInstanceId(); if (unregisterServiceId == null || unregisterInstanceId == null) { throw new IllegalArgumentException( "Invalid unregisterServiceId, unregisterServiceId=" + unregisterServiceId + "Invalid unregisterInstanceId, unregisterInstanceId=" + unregisterInstanceId); } ServerUtil.microserviceInstanceMap .computeIfPresent(unregisterServiceId, (serviceId, instanceIdMap) -> { instanceIdMap.computeIfPresent(unregisterInstanceId, (instanceId, instance) -> { LOGGER.info( "Successfully unregistered/remove serviceId: {}, instanceId: {} from server side", unregisterServiceId, unregisterInstanceId); return null; }); return !instanceIdMap.isEmpty() ? instanceIdMap : null; }); } }
|
ZeroConfigRegistryService { public void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance) { String unregisterServiceId = receivedInstance.getServiceId(); String unregisterInstanceId = receivedInstance.getInstanceId(); if (unregisterServiceId == null || unregisterInstanceId == null) { throw new IllegalArgumentException( "Invalid unregisterServiceId, unregisterServiceId=" + unregisterServiceId + "Invalid unregisterInstanceId, unregisterInstanceId=" + unregisterInstanceId); } ServerUtil.microserviceInstanceMap .computeIfPresent(unregisterServiceId, (serviceId, instanceIdMap) -> { instanceIdMap.computeIfPresent(unregisterInstanceId, (instanceId, instance) -> { LOGGER.info( "Successfully unregistered/remove serviceId: {}, instanceId: {} from server side", unregisterServiceId, unregisterInstanceId); return null; }); return !instanceIdMap.isEmpty() ? instanceIdMap : null; }); } }
|
ZeroConfigRegistryService { public void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance) { String unregisterServiceId = receivedInstance.getServiceId(); String unregisterInstanceId = receivedInstance.getInstanceId(); if (unregisterServiceId == null || unregisterInstanceId == null) { throw new IllegalArgumentException( "Invalid unregisterServiceId, unregisterServiceId=" + unregisterServiceId + "Invalid unregisterInstanceId, unregisterInstanceId=" + unregisterInstanceId); } ServerUtil.microserviceInstanceMap .computeIfPresent(unregisterServiceId, (serviceId, instanceIdMap) -> { instanceIdMap.computeIfPresent(unregisterInstanceId, (instanceId, instance) -> { LOGGER.info( "Successfully unregistered/remove serviceId: {}, instanceId: {} from server side", unregisterServiceId, unregisterInstanceId); return null; }); return !instanceIdMap.isEmpty() ? instanceIdMap : null; }); } void registerMicroserviceInstance(ServerMicroserviceInstance receivedInstance); void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance); ServerMicroserviceInstance findServiceInstance(String serviceId,
String instanceId); List<ServerMicroserviceInstance> getMicroserviceInstance(String consumerId,
String providerId); void heartbeat(ServerMicroserviceInstance receivedInstance); boolean heartbeat(String microserviceId, String microserviceInstanceId); ServerMicroserviceInstance getMicroservice(String microserviceId); List<ServerMicroserviceInstance> findServiceInstances(String appId, String serviceName); }
|
ZeroConfigRegistryService { public void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance) { String unregisterServiceId = receivedInstance.getServiceId(); String unregisterInstanceId = receivedInstance.getInstanceId(); if (unregisterServiceId == null || unregisterInstanceId == null) { throw new IllegalArgumentException( "Invalid unregisterServiceId, unregisterServiceId=" + unregisterServiceId + "Invalid unregisterInstanceId, unregisterInstanceId=" + unregisterInstanceId); } ServerUtil.microserviceInstanceMap .computeIfPresent(unregisterServiceId, (serviceId, instanceIdMap) -> { instanceIdMap.computeIfPresent(unregisterInstanceId, (instanceId, instance) -> { LOGGER.info( "Successfully unregistered/remove serviceId: {}, instanceId: {} from server side", unregisterServiceId, unregisterInstanceId); return null; }); return !instanceIdMap.isEmpty() ? instanceIdMap : null; }); } void registerMicroserviceInstance(ServerMicroserviceInstance receivedInstance); void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance); ServerMicroserviceInstance findServiceInstance(String serviceId,
String instanceId); List<ServerMicroserviceInstance> getMicroserviceInstance(String consumerId,
String providerId); void heartbeat(ServerMicroserviceInstance receivedInstance); boolean heartbeat(String microserviceId, String microserviceInstanceId); ServerMicroserviceInstance getMicroservice(String microserviceId); List<ServerMicroserviceInstance> findServiceInstances(String appId, String serviceName); }
|
@Test public void isMatch_false() { Assert.assertFalse(factory.isMatch(String.class)); }
|
@Override public boolean isMatch(Type producerType) { return Response.class.equals(producerType); }
|
JaxrsProducerResponseMapperFactory implements ProducerResponseMapperFactory { @Override public boolean isMatch(Type producerType) { return Response.class.equals(producerType); } }
|
JaxrsProducerResponseMapperFactory implements ProducerResponseMapperFactory { @Override public boolean isMatch(Type producerType) { return Response.class.equals(producerType); } }
|
JaxrsProducerResponseMapperFactory implements ProducerResponseMapperFactory { @Override public boolean isMatch(Type producerType) { return Response.class.equals(producerType); } @Override boolean isMatch(Type producerType); @Override ProducerResponseMapper createResponseMapper(ResponseMapperFactorys<ProducerResponseMapper> factorys,
Type producerType); }
|
JaxrsProducerResponseMapperFactory implements ProducerResponseMapperFactory { @Override public boolean isMatch(Type producerType) { return Response.class.equals(producerType); } @Override boolean isMatch(Type producerType); @Override ProducerResponseMapper createResponseMapper(ResponseMapperFactorys<ProducerResponseMapper> factorys,
Type producerType); }
|
@Test public void createResponseMapper() { Assert.assertThat(factory.createResponseMapper(null, null), Matchers.instanceOf(JaxrsProducerResponseMapper.class)); }
|
@Override public ProducerResponseMapper createResponseMapper(ResponseMapperFactorys<ProducerResponseMapper> factorys, Type producerType) { return new JaxrsProducerResponseMapper(); }
|
JaxrsProducerResponseMapperFactory implements ProducerResponseMapperFactory { @Override public ProducerResponseMapper createResponseMapper(ResponseMapperFactorys<ProducerResponseMapper> factorys, Type producerType) { return new JaxrsProducerResponseMapper(); } }
|
JaxrsProducerResponseMapperFactory implements ProducerResponseMapperFactory { @Override public ProducerResponseMapper createResponseMapper(ResponseMapperFactorys<ProducerResponseMapper> factorys, Type producerType) { return new JaxrsProducerResponseMapper(); } }
|
JaxrsProducerResponseMapperFactory implements ProducerResponseMapperFactory { @Override public ProducerResponseMapper createResponseMapper(ResponseMapperFactorys<ProducerResponseMapper> factorys, Type producerType) { return new JaxrsProducerResponseMapper(); } @Override boolean isMatch(Type producerType); @Override ProducerResponseMapper createResponseMapper(ResponseMapperFactorys<ProducerResponseMapper> factorys,
Type producerType); }
|
JaxrsProducerResponseMapperFactory implements ProducerResponseMapperFactory { @Override public ProducerResponseMapper createResponseMapper(ResponseMapperFactorys<ProducerResponseMapper> factorys, Type producerType) { return new JaxrsProducerResponseMapper(); } @Override boolean isMatch(Type producerType); @Override ProducerResponseMapper createResponseMapper(ResponseMapperFactorys<ProducerResponseMapper> factorys,
Type producerType); }
|
@Test public void testMethod() throws NoSuchMethodException { Method method = validatorForTest.getMethod("add", int.class, int.class); Assert.assertThat(parameterNameProvider.getParameterNames(method), Matchers.contains("a", "b")); method = validatorForTest.getMethod("sayHi", String.class); Assert.assertThat(parameterNameProvider.getParameterNames(method), Matchers.contains("hi")); method = validatorForTest.getMethod("sayHello", ValidatorForTest.Student.class); Assert.assertThat(parameterNameProvider.getParameterNames(method), Matchers.contains("student")); method = validatorForTest.getMethod("setTest", String.class); Assert.assertThat(parameterNameProvider.getParameterNames(method), Matchers.contains("grade")); method = validatorForTest.getMethod("getNumber"); Assert.assertTrue(parameterNameProvider.getParameterNames(method).isEmpty()); method = validatorForTest.getMethod("setNumber", int.class); Assert.assertThat(parameterNameProvider.getParameterNames(method), Matchers.contains("number")); }
|
@Override public List<String> getParameterNames(Constructor<?> constructor) { return methodCache.computeIfAbsent(constructor, k -> getParameterNamesEx(constructor)); }
|
DefaultParameterNameProvider implements ParameterNameProvider { @Override public List<String> getParameterNames(Constructor<?> constructor) { return methodCache.computeIfAbsent(constructor, k -> getParameterNamesEx(constructor)); } }
|
DefaultParameterNameProvider implements ParameterNameProvider { @Override public List<String> getParameterNames(Constructor<?> constructor) { return methodCache.computeIfAbsent(constructor, k -> getParameterNamesEx(constructor)); } }
|
DefaultParameterNameProvider implements ParameterNameProvider { @Override public List<String> getParameterNames(Constructor<?> constructor) { return methodCache.computeIfAbsent(constructor, k -> getParameterNamesEx(constructor)); } @Override List<String> getParameterNames(Constructor<?> constructor); @Override List<String> getParameterNames(Method method); }
|
DefaultParameterNameProvider implements ParameterNameProvider { @Override public List<String> getParameterNames(Constructor<?> constructor) { return methodCache.computeIfAbsent(constructor, k -> getParameterNamesEx(constructor)); } @Override List<String> getParameterNames(Constructor<?> constructor); @Override List<String> getParameterNames(Method method); }
|
@Test public void testConstructor() throws NoSuchMethodException { Constructor<ValidatorForTest> constructor = validatorForTest.getConstructor(String.class, int.class); Assert.assertThat(parameterNameProvider.getParameterNames(constructor), Matchers.contains("grade", "number")); constructor = validatorForTest.getConstructor(); Assert.assertTrue(parameterNameProvider.getParameterNames(constructor).isEmpty()); }
|
@Override public List<String> getParameterNames(Constructor<?> constructor) { return methodCache.computeIfAbsent(constructor, k -> getParameterNamesEx(constructor)); }
|
DefaultParameterNameProvider implements ParameterNameProvider { @Override public List<String> getParameterNames(Constructor<?> constructor) { return methodCache.computeIfAbsent(constructor, k -> getParameterNamesEx(constructor)); } }
|
DefaultParameterNameProvider implements ParameterNameProvider { @Override public List<String> getParameterNames(Constructor<?> constructor) { return methodCache.computeIfAbsent(constructor, k -> getParameterNamesEx(constructor)); } }
|
DefaultParameterNameProvider implements ParameterNameProvider { @Override public List<String> getParameterNames(Constructor<?> constructor) { return methodCache.computeIfAbsent(constructor, k -> getParameterNamesEx(constructor)); } @Override List<String> getParameterNames(Constructor<?> constructor); @Override List<String> getParameterNames(Method method); }
|
DefaultParameterNameProvider implements ParameterNameProvider { @Override public List<String> getParameterNames(Constructor<?> constructor) { return methodCache.computeIfAbsent(constructor, k -> getParameterNamesEx(constructor)); } @Override List<String> getParameterNames(Constructor<?> constructor); @Override List<String> getParameterNames(Method method); }
|
@Test public void isMatch_true() { Method method = ReflectUtils.findMethod(this.getClass(), "responseEntity"); Assert.assertTrue(factory.isMatch(method.getGenericReturnType())); }
|
@Override public boolean isMatch(Type producerType) { if (!ParameterizedType.class.isAssignableFrom(producerType.getClass())) { return false; } return ((ParameterizedType) producerType).getRawType().equals(ResponseEntity.class); }
|
SpringmvcProducerResponseMapperFactory implements ProducerResponseMapperFactory { @Override public boolean isMatch(Type producerType) { if (!ParameterizedType.class.isAssignableFrom(producerType.getClass())) { return false; } return ((ParameterizedType) producerType).getRawType().equals(ResponseEntity.class); } }
|
SpringmvcProducerResponseMapperFactory implements ProducerResponseMapperFactory { @Override public boolean isMatch(Type producerType) { if (!ParameterizedType.class.isAssignableFrom(producerType.getClass())) { return false; } return ((ParameterizedType) producerType).getRawType().equals(ResponseEntity.class); } }
|
SpringmvcProducerResponseMapperFactory implements ProducerResponseMapperFactory { @Override public boolean isMatch(Type producerType) { if (!ParameterizedType.class.isAssignableFrom(producerType.getClass())) { return false; } return ((ParameterizedType) producerType).getRawType().equals(ResponseEntity.class); } @Override boolean isMatch(Type producerType); @Override ProducerResponseMapper createResponseMapper(ResponseMapperFactorys<ProducerResponseMapper> factorys,
Type producerType); }
|
SpringmvcProducerResponseMapperFactory implements ProducerResponseMapperFactory { @Override public boolean isMatch(Type producerType) { if (!ParameterizedType.class.isAssignableFrom(producerType.getClass())) { return false; } return ((ParameterizedType) producerType).getRawType().equals(ResponseEntity.class); } @Override boolean isMatch(Type producerType); @Override ProducerResponseMapper createResponseMapper(ResponseMapperFactorys<ProducerResponseMapper> factorys,
Type producerType); }
|
@Test public void isMatch_Parameterized_false() { Method method = ReflectUtils.findMethod(this.getClass(), "list"); Assert.assertFalse(factory.isMatch(method.getGenericReturnType())); }
|
@Override public boolean isMatch(Type producerType) { if (!ParameterizedType.class.isAssignableFrom(producerType.getClass())) { return false; } return ((ParameterizedType) producerType).getRawType().equals(ResponseEntity.class); }
|
SpringmvcProducerResponseMapperFactory implements ProducerResponseMapperFactory { @Override public boolean isMatch(Type producerType) { if (!ParameterizedType.class.isAssignableFrom(producerType.getClass())) { return false; } return ((ParameterizedType) producerType).getRawType().equals(ResponseEntity.class); } }
|
SpringmvcProducerResponseMapperFactory implements ProducerResponseMapperFactory { @Override public boolean isMatch(Type producerType) { if (!ParameterizedType.class.isAssignableFrom(producerType.getClass())) { return false; } return ((ParameterizedType) producerType).getRawType().equals(ResponseEntity.class); } }
|
SpringmvcProducerResponseMapperFactory implements ProducerResponseMapperFactory { @Override public boolean isMatch(Type producerType) { if (!ParameterizedType.class.isAssignableFrom(producerType.getClass())) { return false; } return ((ParameterizedType) producerType).getRawType().equals(ResponseEntity.class); } @Override boolean isMatch(Type producerType); @Override ProducerResponseMapper createResponseMapper(ResponseMapperFactorys<ProducerResponseMapper> factorys,
Type producerType); }
|
SpringmvcProducerResponseMapperFactory implements ProducerResponseMapperFactory { @Override public boolean isMatch(Type producerType) { if (!ParameterizedType.class.isAssignableFrom(producerType.getClass())) { return false; } return ((ParameterizedType) producerType).getRawType().equals(ResponseEntity.class); } @Override boolean isMatch(Type producerType); @Override ProducerResponseMapper createResponseMapper(ResponseMapperFactorys<ProducerResponseMapper> factorys,
Type producerType); }
|
@Test public void isMatch_false() { Assert.assertFalse(factory.isMatch(String.class)); }
|
@Override public boolean isMatch(Type producerType) { if (!ParameterizedType.class.isAssignableFrom(producerType.getClass())) { return false; } return ((ParameterizedType) producerType).getRawType().equals(ResponseEntity.class); }
|
SpringmvcProducerResponseMapperFactory implements ProducerResponseMapperFactory { @Override public boolean isMatch(Type producerType) { if (!ParameterizedType.class.isAssignableFrom(producerType.getClass())) { return false; } return ((ParameterizedType) producerType).getRawType().equals(ResponseEntity.class); } }
|
SpringmvcProducerResponseMapperFactory implements ProducerResponseMapperFactory { @Override public boolean isMatch(Type producerType) { if (!ParameterizedType.class.isAssignableFrom(producerType.getClass())) { return false; } return ((ParameterizedType) producerType).getRawType().equals(ResponseEntity.class); } }
|
SpringmvcProducerResponseMapperFactory implements ProducerResponseMapperFactory { @Override public boolean isMatch(Type producerType) { if (!ParameterizedType.class.isAssignableFrom(producerType.getClass())) { return false; } return ((ParameterizedType) producerType).getRawType().equals(ResponseEntity.class); } @Override boolean isMatch(Type producerType); @Override ProducerResponseMapper createResponseMapper(ResponseMapperFactorys<ProducerResponseMapper> factorys,
Type producerType); }
|
SpringmvcProducerResponseMapperFactory implements ProducerResponseMapperFactory { @Override public boolean isMatch(Type producerType) { if (!ParameterizedType.class.isAssignableFrom(producerType.getClass())) { return false; } return ((ParameterizedType) producerType).getRawType().equals(ResponseEntity.class); } @Override boolean isMatch(Type producerType); @Override ProducerResponseMapper createResponseMapper(ResponseMapperFactorys<ProducerResponseMapper> factorys,
Type producerType); }
|
@Test public void createResponseMapper() { Method responseEntityMethod = ReflectUtils.findMethod(this.getClass(), "responseEntity"); ProducerResponseMapper mapper = factory .createResponseMapper(factorys, responseEntityMethod.getGenericReturnType()); Assert.assertThat(mapper, Matchers.instanceOf(SpringmvcProducerResponseMapper.class)); ResponseEntity<String[]> responseEntity = new ResponseEntity<>(new String[] {"a", "b"}, HttpStatus.OK); Response response = mapper.mapResponse(null, responseEntity); Assert.assertThat(response.getResult(), Matchers.arrayContaining("a", "b")); }
|
@Override public ProducerResponseMapper createResponseMapper(ResponseMapperFactorys<ProducerResponseMapper> factorys, Type producerType) { Type realProducerType = ((ParameterizedType) producerType).getActualTypeArguments()[0]; ProducerResponseMapper realMapper = factorys.createResponseMapper(realProducerType); return new SpringmvcProducerResponseMapper(realMapper); }
|
SpringmvcProducerResponseMapperFactory implements ProducerResponseMapperFactory { @Override public ProducerResponseMapper createResponseMapper(ResponseMapperFactorys<ProducerResponseMapper> factorys, Type producerType) { Type realProducerType = ((ParameterizedType) producerType).getActualTypeArguments()[0]; ProducerResponseMapper realMapper = factorys.createResponseMapper(realProducerType); return new SpringmvcProducerResponseMapper(realMapper); } }
|
SpringmvcProducerResponseMapperFactory implements ProducerResponseMapperFactory { @Override public ProducerResponseMapper createResponseMapper(ResponseMapperFactorys<ProducerResponseMapper> factorys, Type producerType) { Type realProducerType = ((ParameterizedType) producerType).getActualTypeArguments()[0]; ProducerResponseMapper realMapper = factorys.createResponseMapper(realProducerType); return new SpringmvcProducerResponseMapper(realMapper); } }
|
SpringmvcProducerResponseMapperFactory implements ProducerResponseMapperFactory { @Override public ProducerResponseMapper createResponseMapper(ResponseMapperFactorys<ProducerResponseMapper> factorys, Type producerType) { Type realProducerType = ((ParameterizedType) producerType).getActualTypeArguments()[0]; ProducerResponseMapper realMapper = factorys.createResponseMapper(realProducerType); return new SpringmvcProducerResponseMapper(realMapper); } @Override boolean isMatch(Type producerType); @Override ProducerResponseMapper createResponseMapper(ResponseMapperFactorys<ProducerResponseMapper> factorys,
Type producerType); }
|
SpringmvcProducerResponseMapperFactory implements ProducerResponseMapperFactory { @Override public ProducerResponseMapper createResponseMapper(ResponseMapperFactorys<ProducerResponseMapper> factorys, Type producerType) { Type realProducerType = ((ParameterizedType) producerType).getActualTypeArguments()[0]; ProducerResponseMapper realMapper = factorys.createResponseMapper(realProducerType); return new SpringmvcProducerResponseMapper(realMapper); } @Override boolean isMatch(Type producerType); @Override ProducerResponseMapper createResponseMapper(ResponseMapperFactorys<ProducerResponseMapper> factorys,
Type producerType); }
|
@Test public void responseEntity() { SwaggerConsumerOperation operation = swaggerConsumer.findOperation("responseEntity"); @SuppressWarnings("unchecked") ResponseEntity<String> responseEntity = (ResponseEntity<String>) operation.getResponseMapper() .mapResponse(response); Assert.assertEquals(result, responseEntity.getBody()); Assert.assertTrue(responseEntity.getHeaders().isEmpty()); }
|
@Override public Object mapResponse(Response response) { HttpStatus status = HttpStatus.valueOf(response.getStatusCode()); Map<String, List<Object>> headers = response.getHeaders().getHeaderMap(); if (headers == null) { Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, null, status); } HttpHeaders httpHeaders = new HttpHeaders(); for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null) { continue; } for (Object value : entry.getValue()) { if (value != null) { httpHeaders.add(entry.getKey(), String.valueOf(value)); } } } Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, httpHeaders, status); }
|
SpringmvcConsumerResponseMapper implements ConsumerResponseMapper { @Override public Object mapResponse(Response response) { HttpStatus status = HttpStatus.valueOf(response.getStatusCode()); Map<String, List<Object>> headers = response.getHeaders().getHeaderMap(); if (headers == null) { Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, null, status); } HttpHeaders httpHeaders = new HttpHeaders(); for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null) { continue; } for (Object value : entry.getValue()) { if (value != null) { httpHeaders.add(entry.getKey(), String.valueOf(value)); } } } Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, httpHeaders, status); } }
|
SpringmvcConsumerResponseMapper implements ConsumerResponseMapper { @Override public Object mapResponse(Response response) { HttpStatus status = HttpStatus.valueOf(response.getStatusCode()); Map<String, List<Object>> headers = response.getHeaders().getHeaderMap(); if (headers == null) { Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, null, status); } HttpHeaders httpHeaders = new HttpHeaders(); for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null) { continue; } for (Object value : entry.getValue()) { if (value != null) { httpHeaders.add(entry.getKey(), String.valueOf(value)); } } } Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, httpHeaders, status); } SpringmvcConsumerResponseMapper(ConsumerResponseMapper realMapper); }
|
SpringmvcConsumerResponseMapper implements ConsumerResponseMapper { @Override public Object mapResponse(Response response) { HttpStatus status = HttpStatus.valueOf(response.getStatusCode()); Map<String, List<Object>> headers = response.getHeaders().getHeaderMap(); if (headers == null) { Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, null, status); } HttpHeaders httpHeaders = new HttpHeaders(); for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null) { continue; } for (Object value : entry.getValue()) { if (value != null) { httpHeaders.add(entry.getKey(), String.valueOf(value)); } } } Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, httpHeaders, status); } SpringmvcConsumerResponseMapper(ConsumerResponseMapper realMapper); @Override Object mapResponse(Response response); }
|
SpringmvcConsumerResponseMapper implements ConsumerResponseMapper { @Override public Object mapResponse(Response response) { HttpStatus status = HttpStatus.valueOf(response.getStatusCode()); Map<String, List<Object>> headers = response.getHeaders().getHeaderMap(); if (headers == null) { Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, null, status); } HttpHeaders httpHeaders = new HttpHeaders(); for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null) { continue; } for (Object value : entry.getValue()) { if (value != null) { httpHeaders.add(entry.getKey(), String.valueOf(value)); } } } Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, httpHeaders, status); } SpringmvcConsumerResponseMapper(ConsumerResponseMapper realMapper); @Override Object mapResponse(Response response); }
|
@Test public void responseEntityWithHeader() { SwaggerConsumerOperation operation = swaggerConsumer.findOperation("responseEntity"); response.getHeaders().addHeader("h", "v"); @SuppressWarnings("unchecked") ResponseEntity<String> responseEntity = (ResponseEntity<String>) operation.getResponseMapper() .mapResponse(response); Assert.assertEquals(result, responseEntity.getBody()); Assert.assertEquals(1, responseEntity.getHeaders().size()); Assert.assertThat(responseEntity.getHeaders().get("h"), Matchers.contains("v")); }
|
@Override public Object mapResponse(Response response) { HttpStatus status = HttpStatus.valueOf(response.getStatusCode()); Map<String, List<Object>> headers = response.getHeaders().getHeaderMap(); if (headers == null) { Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, null, status); } HttpHeaders httpHeaders = new HttpHeaders(); for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null) { continue; } for (Object value : entry.getValue()) { if (value != null) { httpHeaders.add(entry.getKey(), String.valueOf(value)); } } } Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, httpHeaders, status); }
|
SpringmvcConsumerResponseMapper implements ConsumerResponseMapper { @Override public Object mapResponse(Response response) { HttpStatus status = HttpStatus.valueOf(response.getStatusCode()); Map<String, List<Object>> headers = response.getHeaders().getHeaderMap(); if (headers == null) { Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, null, status); } HttpHeaders httpHeaders = new HttpHeaders(); for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null) { continue; } for (Object value : entry.getValue()) { if (value != null) { httpHeaders.add(entry.getKey(), String.valueOf(value)); } } } Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, httpHeaders, status); } }
|
SpringmvcConsumerResponseMapper implements ConsumerResponseMapper { @Override public Object mapResponse(Response response) { HttpStatus status = HttpStatus.valueOf(response.getStatusCode()); Map<String, List<Object>> headers = response.getHeaders().getHeaderMap(); if (headers == null) { Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, null, status); } HttpHeaders httpHeaders = new HttpHeaders(); for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null) { continue; } for (Object value : entry.getValue()) { if (value != null) { httpHeaders.add(entry.getKey(), String.valueOf(value)); } } } Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, httpHeaders, status); } SpringmvcConsumerResponseMapper(ConsumerResponseMapper realMapper); }
|
SpringmvcConsumerResponseMapper implements ConsumerResponseMapper { @Override public Object mapResponse(Response response) { HttpStatus status = HttpStatus.valueOf(response.getStatusCode()); Map<String, List<Object>> headers = response.getHeaders().getHeaderMap(); if (headers == null) { Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, null, status); } HttpHeaders httpHeaders = new HttpHeaders(); for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null) { continue; } for (Object value : entry.getValue()) { if (value != null) { httpHeaders.add(entry.getKey(), String.valueOf(value)); } } } Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, httpHeaders, status); } SpringmvcConsumerResponseMapper(ConsumerResponseMapper realMapper); @Override Object mapResponse(Response response); }
|
SpringmvcConsumerResponseMapper implements ConsumerResponseMapper { @Override public Object mapResponse(Response response) { HttpStatus status = HttpStatus.valueOf(response.getStatusCode()); Map<String, List<Object>> headers = response.getHeaders().getHeaderMap(); if (headers == null) { Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, null, status); } HttpHeaders httpHeaders = new HttpHeaders(); for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null) { continue; } for (Object value : entry.getValue()) { if (value != null) { httpHeaders.add(entry.getKey(), String.valueOf(value)); } } } Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, httpHeaders, status); } SpringmvcConsumerResponseMapper(ConsumerResponseMapper realMapper); @Override Object mapResponse(Response response); }
|
@Test public void test_unregisterMicroserviceInstance_withServiceIdAndInstanceId_and_multipleInstance_shouldRemoveInstance() { ServerUtil.microserviceInstanceMap = prepareServiceInstanceMap(true); target.unregisterMicroserviceInstance(prepareServerServiceInstance(true, instanceId)); Assert.assertTrue(ServerUtil.microserviceInstanceMap.containsKey(serviceId)); Assert.assertTrue(ServerUtil.microserviceInstanceMap.get(serviceId).containsKey(instanceId1)); Assert.assertFalse(ServerUtil.microserviceInstanceMap.get(serviceId).containsKey(instanceId)); }
|
public void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance) { String unregisterServiceId = receivedInstance.getServiceId(); String unregisterInstanceId = receivedInstance.getInstanceId(); if (unregisterServiceId == null || unregisterInstanceId == null) { throw new IllegalArgumentException( "Invalid unregisterServiceId, unregisterServiceId=" + unregisterServiceId + "Invalid unregisterInstanceId, unregisterInstanceId=" + unregisterInstanceId); } ServerUtil.microserviceInstanceMap .computeIfPresent(unregisterServiceId, (serviceId, instanceIdMap) -> { instanceIdMap.computeIfPresent(unregisterInstanceId, (instanceId, instance) -> { LOGGER.info( "Successfully unregistered/remove serviceId: {}, instanceId: {} from server side", unregisterServiceId, unregisterInstanceId); return null; }); return !instanceIdMap.isEmpty() ? instanceIdMap : null; }); }
|
ZeroConfigRegistryService { public void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance) { String unregisterServiceId = receivedInstance.getServiceId(); String unregisterInstanceId = receivedInstance.getInstanceId(); if (unregisterServiceId == null || unregisterInstanceId == null) { throw new IllegalArgumentException( "Invalid unregisterServiceId, unregisterServiceId=" + unregisterServiceId + "Invalid unregisterInstanceId, unregisterInstanceId=" + unregisterInstanceId); } ServerUtil.microserviceInstanceMap .computeIfPresent(unregisterServiceId, (serviceId, instanceIdMap) -> { instanceIdMap.computeIfPresent(unregisterInstanceId, (instanceId, instance) -> { LOGGER.info( "Successfully unregistered/remove serviceId: {}, instanceId: {} from server side", unregisterServiceId, unregisterInstanceId); return null; }); return !instanceIdMap.isEmpty() ? instanceIdMap : null; }); } }
|
ZeroConfigRegistryService { public void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance) { String unregisterServiceId = receivedInstance.getServiceId(); String unregisterInstanceId = receivedInstance.getInstanceId(); if (unregisterServiceId == null || unregisterInstanceId == null) { throw new IllegalArgumentException( "Invalid unregisterServiceId, unregisterServiceId=" + unregisterServiceId + "Invalid unregisterInstanceId, unregisterInstanceId=" + unregisterInstanceId); } ServerUtil.microserviceInstanceMap .computeIfPresent(unregisterServiceId, (serviceId, instanceIdMap) -> { instanceIdMap.computeIfPresent(unregisterInstanceId, (instanceId, instance) -> { LOGGER.info( "Successfully unregistered/remove serviceId: {}, instanceId: {} from server side", unregisterServiceId, unregisterInstanceId); return null; }); return !instanceIdMap.isEmpty() ? instanceIdMap : null; }); } }
|
ZeroConfigRegistryService { public void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance) { String unregisterServiceId = receivedInstance.getServiceId(); String unregisterInstanceId = receivedInstance.getInstanceId(); if (unregisterServiceId == null || unregisterInstanceId == null) { throw new IllegalArgumentException( "Invalid unregisterServiceId, unregisterServiceId=" + unregisterServiceId + "Invalid unregisterInstanceId, unregisterInstanceId=" + unregisterInstanceId); } ServerUtil.microserviceInstanceMap .computeIfPresent(unregisterServiceId, (serviceId, instanceIdMap) -> { instanceIdMap.computeIfPresent(unregisterInstanceId, (instanceId, instance) -> { LOGGER.info( "Successfully unregistered/remove serviceId: {}, instanceId: {} from server side", unregisterServiceId, unregisterInstanceId); return null; }); return !instanceIdMap.isEmpty() ? instanceIdMap : null; }); } void registerMicroserviceInstance(ServerMicroserviceInstance receivedInstance); void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance); ServerMicroserviceInstance findServiceInstance(String serviceId,
String instanceId); List<ServerMicroserviceInstance> getMicroserviceInstance(String consumerId,
String providerId); void heartbeat(ServerMicroserviceInstance receivedInstance); boolean heartbeat(String microserviceId, String microserviceInstanceId); ServerMicroserviceInstance getMicroservice(String microserviceId); List<ServerMicroserviceInstance> findServiceInstances(String appId, String serviceName); }
|
ZeroConfigRegistryService { public void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance) { String unregisterServiceId = receivedInstance.getServiceId(); String unregisterInstanceId = receivedInstance.getInstanceId(); if (unregisterServiceId == null || unregisterInstanceId == null) { throw new IllegalArgumentException( "Invalid unregisterServiceId, unregisterServiceId=" + unregisterServiceId + "Invalid unregisterInstanceId, unregisterInstanceId=" + unregisterInstanceId); } ServerUtil.microserviceInstanceMap .computeIfPresent(unregisterServiceId, (serviceId, instanceIdMap) -> { instanceIdMap.computeIfPresent(unregisterInstanceId, (instanceId, instance) -> { LOGGER.info( "Successfully unregistered/remove serviceId: {}, instanceId: {} from server side", unregisterServiceId, unregisterInstanceId); return null; }); return !instanceIdMap.isEmpty() ? instanceIdMap : null; }); } void registerMicroserviceInstance(ServerMicroserviceInstance receivedInstance); void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance); ServerMicroserviceInstance findServiceInstance(String serviceId,
String instanceId); List<ServerMicroserviceInstance> getMicroserviceInstance(String consumerId,
String providerId); void heartbeat(ServerMicroserviceInstance receivedInstance); boolean heartbeat(String microserviceId, String microserviceInstanceId); ServerMicroserviceInstance getMicroservice(String microserviceId); List<ServerMicroserviceInstance> findServiceInstances(String appId, String serviceName); }
|
@Test public void asyncResponseEntity() { SwaggerConsumerOperation operation = swaggerConsumer.findOperation("asyncResponseEntity"); @SuppressWarnings("unchecked") ResponseEntity<String> responseEntity = (ResponseEntity<String>) operation.getResponseMapper() .mapResponse(response); Assert.assertEquals(result, responseEntity.getBody()); Assert.assertTrue(responseEntity.getHeaders().isEmpty()); }
|
@Override public Object mapResponse(Response response) { HttpStatus status = HttpStatus.valueOf(response.getStatusCode()); Map<String, List<Object>> headers = response.getHeaders().getHeaderMap(); if (headers == null) { Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, null, status); } HttpHeaders httpHeaders = new HttpHeaders(); for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null) { continue; } for (Object value : entry.getValue()) { if (value != null) { httpHeaders.add(entry.getKey(), String.valueOf(value)); } } } Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, httpHeaders, status); }
|
SpringmvcConsumerResponseMapper implements ConsumerResponseMapper { @Override public Object mapResponse(Response response) { HttpStatus status = HttpStatus.valueOf(response.getStatusCode()); Map<String, List<Object>> headers = response.getHeaders().getHeaderMap(); if (headers == null) { Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, null, status); } HttpHeaders httpHeaders = new HttpHeaders(); for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null) { continue; } for (Object value : entry.getValue()) { if (value != null) { httpHeaders.add(entry.getKey(), String.valueOf(value)); } } } Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, httpHeaders, status); } }
|
SpringmvcConsumerResponseMapper implements ConsumerResponseMapper { @Override public Object mapResponse(Response response) { HttpStatus status = HttpStatus.valueOf(response.getStatusCode()); Map<String, List<Object>> headers = response.getHeaders().getHeaderMap(); if (headers == null) { Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, null, status); } HttpHeaders httpHeaders = new HttpHeaders(); for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null) { continue; } for (Object value : entry.getValue()) { if (value != null) { httpHeaders.add(entry.getKey(), String.valueOf(value)); } } } Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, httpHeaders, status); } SpringmvcConsumerResponseMapper(ConsumerResponseMapper realMapper); }
|
SpringmvcConsumerResponseMapper implements ConsumerResponseMapper { @Override public Object mapResponse(Response response) { HttpStatus status = HttpStatus.valueOf(response.getStatusCode()); Map<String, List<Object>> headers = response.getHeaders().getHeaderMap(); if (headers == null) { Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, null, status); } HttpHeaders httpHeaders = new HttpHeaders(); for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null) { continue; } for (Object value : entry.getValue()) { if (value != null) { httpHeaders.add(entry.getKey(), String.valueOf(value)); } } } Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, httpHeaders, status); } SpringmvcConsumerResponseMapper(ConsumerResponseMapper realMapper); @Override Object mapResponse(Response response); }
|
SpringmvcConsumerResponseMapper implements ConsumerResponseMapper { @Override public Object mapResponse(Response response) { HttpStatus status = HttpStatus.valueOf(response.getStatusCode()); Map<String, List<Object>> headers = response.getHeaders().getHeaderMap(); if (headers == null) { Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, null, status); } HttpHeaders httpHeaders = new HttpHeaders(); for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null) { continue; } for (Object value : entry.getValue()) { if (value != null) { httpHeaders.add(entry.getKey(), String.valueOf(value)); } } } Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, httpHeaders, status); } SpringmvcConsumerResponseMapper(ConsumerResponseMapper realMapper); @Override Object mapResponse(Response response); }
|
@Test public void asyncResponseEntityWithHeader() { SwaggerConsumerOperation operation = swaggerConsumer.findOperation("asyncResponseEntity"); response.getHeaders().addHeader("h", "v1").addHeader("h", "v2"); response.getHeaders().getHeaderMap().put("h1", null); @SuppressWarnings("unchecked") ResponseEntity<String> responseEntity = (ResponseEntity<String>) operation.getResponseMapper() .mapResponse(response); Assert.assertEquals(result, responseEntity.getBody()); Assert.assertEquals(1, responseEntity.getHeaders().size()); Assert.assertThat(responseEntity.getHeaders().get("h"), Matchers.contains("v1", "v2")); }
|
@Override public Object mapResponse(Response response) { HttpStatus status = HttpStatus.valueOf(response.getStatusCode()); Map<String, List<Object>> headers = response.getHeaders().getHeaderMap(); if (headers == null) { Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, null, status); } HttpHeaders httpHeaders = new HttpHeaders(); for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null) { continue; } for (Object value : entry.getValue()) { if (value != null) { httpHeaders.add(entry.getKey(), String.valueOf(value)); } } } Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, httpHeaders, status); }
|
SpringmvcConsumerResponseMapper implements ConsumerResponseMapper { @Override public Object mapResponse(Response response) { HttpStatus status = HttpStatus.valueOf(response.getStatusCode()); Map<String, List<Object>> headers = response.getHeaders().getHeaderMap(); if (headers == null) { Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, null, status); } HttpHeaders httpHeaders = new HttpHeaders(); for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null) { continue; } for (Object value : entry.getValue()) { if (value != null) { httpHeaders.add(entry.getKey(), String.valueOf(value)); } } } Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, httpHeaders, status); } }
|
SpringmvcConsumerResponseMapper implements ConsumerResponseMapper { @Override public Object mapResponse(Response response) { HttpStatus status = HttpStatus.valueOf(response.getStatusCode()); Map<String, List<Object>> headers = response.getHeaders().getHeaderMap(); if (headers == null) { Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, null, status); } HttpHeaders httpHeaders = new HttpHeaders(); for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null) { continue; } for (Object value : entry.getValue()) { if (value != null) { httpHeaders.add(entry.getKey(), String.valueOf(value)); } } } Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, httpHeaders, status); } SpringmvcConsumerResponseMapper(ConsumerResponseMapper realMapper); }
|
SpringmvcConsumerResponseMapper implements ConsumerResponseMapper { @Override public Object mapResponse(Response response) { HttpStatus status = HttpStatus.valueOf(response.getStatusCode()); Map<String, List<Object>> headers = response.getHeaders().getHeaderMap(); if (headers == null) { Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, null, status); } HttpHeaders httpHeaders = new HttpHeaders(); for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null) { continue; } for (Object value : entry.getValue()) { if (value != null) { httpHeaders.add(entry.getKey(), String.valueOf(value)); } } } Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, httpHeaders, status); } SpringmvcConsumerResponseMapper(ConsumerResponseMapper realMapper); @Override Object mapResponse(Response response); }
|
SpringmvcConsumerResponseMapper implements ConsumerResponseMapper { @Override public Object mapResponse(Response response) { HttpStatus status = HttpStatus.valueOf(response.getStatusCode()); Map<String, List<Object>> headers = response.getHeaders().getHeaderMap(); if (headers == null) { Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, null, status); } HttpHeaders httpHeaders = new HttpHeaders(); for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null) { continue; } for (Object value : entry.getValue()) { if (value != null) { httpHeaders.add(entry.getKey(), String.valueOf(value)); } } } Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, httpHeaders, status); } SpringmvcConsumerResponseMapper(ConsumerResponseMapper realMapper); @Override Object mapResponse(Response response); }
|
@SuppressWarnings("unchecked") @Test public void mapResponse_withoutHeader_sucess() { ResponseEntity<String[]> responseEntity = new ResponseEntity<>(arrResult, org.springframework.http.HttpStatus.OK); Response response = mapper.mapResponse(null, responseEntity); Assert.assertThat((List<String>) response.getResult(), Matchers.contains("a", "b")); Assert.assertEquals(Status.OK, response.getStatus()); }
|
@SuppressWarnings("unchecked") @Override public Response mapResponse(StatusType status, Object response) { ResponseEntity<Object> springmvcResponse = (ResponseEntity<Object>) response; StatusType responseStatus = new HttpStatus(springmvcResponse.getStatusCode().value(), springmvcResponse.getStatusCode().getReasonPhrase()); Response cseResponse = null; if (HttpStatus.isSuccess(responseStatus)) { cseResponse = realMapper.mapResponse(responseStatus, springmvcResponse.getBody()); } else { cseResponse = Response.status(responseStatus).entity(springmvcResponse.getBody()); } HttpHeaders headers = springmvcResponse.getHeaders(); Headers cseHeaders = cseResponse.getHeaders(); for (Entry<String, List<String>> entry : headers.entrySet()) { if (entry.getValue() == null || entry.getValue().isEmpty()) { continue; } for (String value : entry.getValue()) { cseHeaders.addHeader(entry.getKey(), value); } } return cseResponse; }
|
SpringmvcProducerResponseMapper implements ProducerResponseMapper { @SuppressWarnings("unchecked") @Override public Response mapResponse(StatusType status, Object response) { ResponseEntity<Object> springmvcResponse = (ResponseEntity<Object>) response; StatusType responseStatus = new HttpStatus(springmvcResponse.getStatusCode().value(), springmvcResponse.getStatusCode().getReasonPhrase()); Response cseResponse = null; if (HttpStatus.isSuccess(responseStatus)) { cseResponse = realMapper.mapResponse(responseStatus, springmvcResponse.getBody()); } else { cseResponse = Response.status(responseStatus).entity(springmvcResponse.getBody()); } HttpHeaders headers = springmvcResponse.getHeaders(); Headers cseHeaders = cseResponse.getHeaders(); for (Entry<String, List<String>> entry : headers.entrySet()) { if (entry.getValue() == null || entry.getValue().isEmpty()) { continue; } for (String value : entry.getValue()) { cseHeaders.addHeader(entry.getKey(), value); } } return cseResponse; } }
|
SpringmvcProducerResponseMapper implements ProducerResponseMapper { @SuppressWarnings("unchecked") @Override public Response mapResponse(StatusType status, Object response) { ResponseEntity<Object> springmvcResponse = (ResponseEntity<Object>) response; StatusType responseStatus = new HttpStatus(springmvcResponse.getStatusCode().value(), springmvcResponse.getStatusCode().getReasonPhrase()); Response cseResponse = null; if (HttpStatus.isSuccess(responseStatus)) { cseResponse = realMapper.mapResponse(responseStatus, springmvcResponse.getBody()); } else { cseResponse = Response.status(responseStatus).entity(springmvcResponse.getBody()); } HttpHeaders headers = springmvcResponse.getHeaders(); Headers cseHeaders = cseResponse.getHeaders(); for (Entry<String, List<String>> entry : headers.entrySet()) { if (entry.getValue() == null || entry.getValue().isEmpty()) { continue; } for (String value : entry.getValue()) { cseHeaders.addHeader(entry.getKey(), value); } } return cseResponse; } SpringmvcProducerResponseMapper(ProducerResponseMapper realMapper); }
|
SpringmvcProducerResponseMapper implements ProducerResponseMapper { @SuppressWarnings("unchecked") @Override public Response mapResponse(StatusType status, Object response) { ResponseEntity<Object> springmvcResponse = (ResponseEntity<Object>) response; StatusType responseStatus = new HttpStatus(springmvcResponse.getStatusCode().value(), springmvcResponse.getStatusCode().getReasonPhrase()); Response cseResponse = null; if (HttpStatus.isSuccess(responseStatus)) { cseResponse = realMapper.mapResponse(responseStatus, springmvcResponse.getBody()); } else { cseResponse = Response.status(responseStatus).entity(springmvcResponse.getBody()); } HttpHeaders headers = springmvcResponse.getHeaders(); Headers cseHeaders = cseResponse.getHeaders(); for (Entry<String, List<String>> entry : headers.entrySet()) { if (entry.getValue() == null || entry.getValue().isEmpty()) { continue; } for (String value : entry.getValue()) { cseHeaders.addHeader(entry.getKey(), value); } } return cseResponse; } SpringmvcProducerResponseMapper(ProducerResponseMapper realMapper); @SuppressWarnings("unchecked") @Override Response mapResponse(StatusType status, Object response); }
|
SpringmvcProducerResponseMapper implements ProducerResponseMapper { @SuppressWarnings("unchecked") @Override public Response mapResponse(StatusType status, Object response) { ResponseEntity<Object> springmvcResponse = (ResponseEntity<Object>) response; StatusType responseStatus = new HttpStatus(springmvcResponse.getStatusCode().value(), springmvcResponse.getStatusCode().getReasonPhrase()); Response cseResponse = null; if (HttpStatus.isSuccess(responseStatus)) { cseResponse = realMapper.mapResponse(responseStatus, springmvcResponse.getBody()); } else { cseResponse = Response.status(responseStatus).entity(springmvcResponse.getBody()); } HttpHeaders headers = springmvcResponse.getHeaders(); Headers cseHeaders = cseResponse.getHeaders(); for (Entry<String, List<String>> entry : headers.entrySet()) { if (entry.getValue() == null || entry.getValue().isEmpty()) { continue; } for (String value : entry.getValue()) { cseHeaders.addHeader(entry.getKey(), value); } } return cseResponse; } SpringmvcProducerResponseMapper(ProducerResponseMapper realMapper); @SuppressWarnings("unchecked") @Override Response mapResponse(StatusType status, Object response); }
|
@Test public void mapResponse_withoutHeader_fail() { ResponseEntity<String[]> responseEntity = new ResponseEntity<>(arrResult, org.springframework.http.HttpStatus.BAD_REQUEST); Response response = mapper.mapResponse(null, responseEntity); Assert.assertSame(arrResult, response.getResult()); Assert.assertEquals(Status.BAD_REQUEST.getStatusCode(), response.getStatus().getStatusCode()); }
|
@SuppressWarnings("unchecked") @Override public Response mapResponse(StatusType status, Object response) { ResponseEntity<Object> springmvcResponse = (ResponseEntity<Object>) response; StatusType responseStatus = new HttpStatus(springmvcResponse.getStatusCode().value(), springmvcResponse.getStatusCode().getReasonPhrase()); Response cseResponse = null; if (HttpStatus.isSuccess(responseStatus)) { cseResponse = realMapper.mapResponse(responseStatus, springmvcResponse.getBody()); } else { cseResponse = Response.status(responseStatus).entity(springmvcResponse.getBody()); } HttpHeaders headers = springmvcResponse.getHeaders(); Headers cseHeaders = cseResponse.getHeaders(); for (Entry<String, List<String>> entry : headers.entrySet()) { if (entry.getValue() == null || entry.getValue().isEmpty()) { continue; } for (String value : entry.getValue()) { cseHeaders.addHeader(entry.getKey(), value); } } return cseResponse; }
|
SpringmvcProducerResponseMapper implements ProducerResponseMapper { @SuppressWarnings("unchecked") @Override public Response mapResponse(StatusType status, Object response) { ResponseEntity<Object> springmvcResponse = (ResponseEntity<Object>) response; StatusType responseStatus = new HttpStatus(springmvcResponse.getStatusCode().value(), springmvcResponse.getStatusCode().getReasonPhrase()); Response cseResponse = null; if (HttpStatus.isSuccess(responseStatus)) { cseResponse = realMapper.mapResponse(responseStatus, springmvcResponse.getBody()); } else { cseResponse = Response.status(responseStatus).entity(springmvcResponse.getBody()); } HttpHeaders headers = springmvcResponse.getHeaders(); Headers cseHeaders = cseResponse.getHeaders(); for (Entry<String, List<String>> entry : headers.entrySet()) { if (entry.getValue() == null || entry.getValue().isEmpty()) { continue; } for (String value : entry.getValue()) { cseHeaders.addHeader(entry.getKey(), value); } } return cseResponse; } }
|
SpringmvcProducerResponseMapper implements ProducerResponseMapper { @SuppressWarnings("unchecked") @Override public Response mapResponse(StatusType status, Object response) { ResponseEntity<Object> springmvcResponse = (ResponseEntity<Object>) response; StatusType responseStatus = new HttpStatus(springmvcResponse.getStatusCode().value(), springmvcResponse.getStatusCode().getReasonPhrase()); Response cseResponse = null; if (HttpStatus.isSuccess(responseStatus)) { cseResponse = realMapper.mapResponse(responseStatus, springmvcResponse.getBody()); } else { cseResponse = Response.status(responseStatus).entity(springmvcResponse.getBody()); } HttpHeaders headers = springmvcResponse.getHeaders(); Headers cseHeaders = cseResponse.getHeaders(); for (Entry<String, List<String>> entry : headers.entrySet()) { if (entry.getValue() == null || entry.getValue().isEmpty()) { continue; } for (String value : entry.getValue()) { cseHeaders.addHeader(entry.getKey(), value); } } return cseResponse; } SpringmvcProducerResponseMapper(ProducerResponseMapper realMapper); }
|
SpringmvcProducerResponseMapper implements ProducerResponseMapper { @SuppressWarnings("unchecked") @Override public Response mapResponse(StatusType status, Object response) { ResponseEntity<Object> springmvcResponse = (ResponseEntity<Object>) response; StatusType responseStatus = new HttpStatus(springmvcResponse.getStatusCode().value(), springmvcResponse.getStatusCode().getReasonPhrase()); Response cseResponse = null; if (HttpStatus.isSuccess(responseStatus)) { cseResponse = realMapper.mapResponse(responseStatus, springmvcResponse.getBody()); } else { cseResponse = Response.status(responseStatus).entity(springmvcResponse.getBody()); } HttpHeaders headers = springmvcResponse.getHeaders(); Headers cseHeaders = cseResponse.getHeaders(); for (Entry<String, List<String>> entry : headers.entrySet()) { if (entry.getValue() == null || entry.getValue().isEmpty()) { continue; } for (String value : entry.getValue()) { cseHeaders.addHeader(entry.getKey(), value); } } return cseResponse; } SpringmvcProducerResponseMapper(ProducerResponseMapper realMapper); @SuppressWarnings("unchecked") @Override Response mapResponse(StatusType status, Object response); }
|
SpringmvcProducerResponseMapper implements ProducerResponseMapper { @SuppressWarnings("unchecked") @Override public Response mapResponse(StatusType status, Object response) { ResponseEntity<Object> springmvcResponse = (ResponseEntity<Object>) response; StatusType responseStatus = new HttpStatus(springmvcResponse.getStatusCode().value(), springmvcResponse.getStatusCode().getReasonPhrase()); Response cseResponse = null; if (HttpStatus.isSuccess(responseStatus)) { cseResponse = realMapper.mapResponse(responseStatus, springmvcResponse.getBody()); } else { cseResponse = Response.status(responseStatus).entity(springmvcResponse.getBody()); } HttpHeaders headers = springmvcResponse.getHeaders(); Headers cseHeaders = cseResponse.getHeaders(); for (Entry<String, List<String>> entry : headers.entrySet()) { if (entry.getValue() == null || entry.getValue().isEmpty()) { continue; } for (String value : entry.getValue()) { cseHeaders.addHeader(entry.getKey(), value); } } return cseResponse; } SpringmvcProducerResponseMapper(ProducerResponseMapper realMapper); @SuppressWarnings("unchecked") @Override Response mapResponse(StatusType status, Object response); }
|
@Test public void mapResponse_withHeader() { HttpHeaders headers = new HttpHeaders(); headers.add("h", "v"); ResponseEntity<String[]> responseEntity = new ResponseEntity<>(arrResult, headers, org.springframework.http.HttpStatus.OK); Response response = mapper.mapResponse(null, responseEntity); List<Object> hv = response.getHeaders().getHeader("h"); Assert.assertThat(hv, Matchers.contains("v")); }
|
@SuppressWarnings("unchecked") @Override public Response mapResponse(StatusType status, Object response) { ResponseEntity<Object> springmvcResponse = (ResponseEntity<Object>) response; StatusType responseStatus = new HttpStatus(springmvcResponse.getStatusCode().value(), springmvcResponse.getStatusCode().getReasonPhrase()); Response cseResponse = null; if (HttpStatus.isSuccess(responseStatus)) { cseResponse = realMapper.mapResponse(responseStatus, springmvcResponse.getBody()); } else { cseResponse = Response.status(responseStatus).entity(springmvcResponse.getBody()); } HttpHeaders headers = springmvcResponse.getHeaders(); Headers cseHeaders = cseResponse.getHeaders(); for (Entry<String, List<String>> entry : headers.entrySet()) { if (entry.getValue() == null || entry.getValue().isEmpty()) { continue; } for (String value : entry.getValue()) { cseHeaders.addHeader(entry.getKey(), value); } } return cseResponse; }
|
SpringmvcProducerResponseMapper implements ProducerResponseMapper { @SuppressWarnings("unchecked") @Override public Response mapResponse(StatusType status, Object response) { ResponseEntity<Object> springmvcResponse = (ResponseEntity<Object>) response; StatusType responseStatus = new HttpStatus(springmvcResponse.getStatusCode().value(), springmvcResponse.getStatusCode().getReasonPhrase()); Response cseResponse = null; if (HttpStatus.isSuccess(responseStatus)) { cseResponse = realMapper.mapResponse(responseStatus, springmvcResponse.getBody()); } else { cseResponse = Response.status(responseStatus).entity(springmvcResponse.getBody()); } HttpHeaders headers = springmvcResponse.getHeaders(); Headers cseHeaders = cseResponse.getHeaders(); for (Entry<String, List<String>> entry : headers.entrySet()) { if (entry.getValue() == null || entry.getValue().isEmpty()) { continue; } for (String value : entry.getValue()) { cseHeaders.addHeader(entry.getKey(), value); } } return cseResponse; } }
|
SpringmvcProducerResponseMapper implements ProducerResponseMapper { @SuppressWarnings("unchecked") @Override public Response mapResponse(StatusType status, Object response) { ResponseEntity<Object> springmvcResponse = (ResponseEntity<Object>) response; StatusType responseStatus = new HttpStatus(springmvcResponse.getStatusCode().value(), springmvcResponse.getStatusCode().getReasonPhrase()); Response cseResponse = null; if (HttpStatus.isSuccess(responseStatus)) { cseResponse = realMapper.mapResponse(responseStatus, springmvcResponse.getBody()); } else { cseResponse = Response.status(responseStatus).entity(springmvcResponse.getBody()); } HttpHeaders headers = springmvcResponse.getHeaders(); Headers cseHeaders = cseResponse.getHeaders(); for (Entry<String, List<String>> entry : headers.entrySet()) { if (entry.getValue() == null || entry.getValue().isEmpty()) { continue; } for (String value : entry.getValue()) { cseHeaders.addHeader(entry.getKey(), value); } } return cseResponse; } SpringmvcProducerResponseMapper(ProducerResponseMapper realMapper); }
|
SpringmvcProducerResponseMapper implements ProducerResponseMapper { @SuppressWarnings("unchecked") @Override public Response mapResponse(StatusType status, Object response) { ResponseEntity<Object> springmvcResponse = (ResponseEntity<Object>) response; StatusType responseStatus = new HttpStatus(springmvcResponse.getStatusCode().value(), springmvcResponse.getStatusCode().getReasonPhrase()); Response cseResponse = null; if (HttpStatus.isSuccess(responseStatus)) { cseResponse = realMapper.mapResponse(responseStatus, springmvcResponse.getBody()); } else { cseResponse = Response.status(responseStatus).entity(springmvcResponse.getBody()); } HttpHeaders headers = springmvcResponse.getHeaders(); Headers cseHeaders = cseResponse.getHeaders(); for (Entry<String, List<String>> entry : headers.entrySet()) { if (entry.getValue() == null || entry.getValue().isEmpty()) { continue; } for (String value : entry.getValue()) { cseHeaders.addHeader(entry.getKey(), value); } } return cseResponse; } SpringmvcProducerResponseMapper(ProducerResponseMapper realMapper); @SuppressWarnings("unchecked") @Override Response mapResponse(StatusType status, Object response); }
|
SpringmvcProducerResponseMapper implements ProducerResponseMapper { @SuppressWarnings("unchecked") @Override public Response mapResponse(StatusType status, Object response) { ResponseEntity<Object> springmvcResponse = (ResponseEntity<Object>) response; StatusType responseStatus = new HttpStatus(springmvcResponse.getStatusCode().value(), springmvcResponse.getStatusCode().getReasonPhrase()); Response cseResponse = null; if (HttpStatus.isSuccess(responseStatus)) { cseResponse = realMapper.mapResponse(responseStatus, springmvcResponse.getBody()); } else { cseResponse = Response.status(responseStatus).entity(springmvcResponse.getBody()); } HttpHeaders headers = springmvcResponse.getHeaders(); Headers cseHeaders = cseResponse.getHeaders(); for (Entry<String, List<String>> entry : headers.entrySet()) { if (entry.getValue() == null || entry.getValue().isEmpty()) { continue; } for (String value : entry.getValue()) { cseHeaders.addHeader(entry.getKey(), value); } } return cseResponse; } SpringmvcProducerResponseMapper(ProducerResponseMapper realMapper); @SuppressWarnings("unchecked") @Override Response mapResponse(StatusType status, Object response); }
|
@Test public void getName() { String name = "paramName"; new Expectations() { { part.getName(); result = name; } }; Assert.assertEquals(name, multipartFile.getName()); }
|
@Override public String getName() { return part.getName(); }
|
PartToMultipartFile implements MultipartFile { @Override public String getName() { return part.getName(); } }
|
PartToMultipartFile implements MultipartFile { @Override public String getName() { return part.getName(); } PartToMultipartFile(Part part); }
|
PartToMultipartFile implements MultipartFile { @Override public String getName() { return part.getName(); } PartToMultipartFile(Part part); @Override String getName(); @Override String getOriginalFilename(); @Override String getContentType(); @Override boolean isEmpty(); @Override long getSize(); @Override byte[] getBytes(); @Override InputStream getInputStream(); @Override void transferTo(File dest); }
|
PartToMultipartFile implements MultipartFile { @Override public String getName() { return part.getName(); } PartToMultipartFile(Part part); @Override String getName(); @Override String getOriginalFilename(); @Override String getContentType(); @Override boolean isEmpty(); @Override long getSize(); @Override byte[] getBytes(); @Override InputStream getInputStream(); @Override void transferTo(File dest); }
|
@Test public void getOriginalFilename() { String submittedFileName = "fileName"; new Expectations() { { part.getSubmittedFileName(); result = submittedFileName; } }; Assert.assertEquals(submittedFileName, multipartFile.getOriginalFilename()); }
|
@Override public String getOriginalFilename() { return part.getSubmittedFileName(); }
|
PartToMultipartFile implements MultipartFile { @Override public String getOriginalFilename() { return part.getSubmittedFileName(); } }
|
PartToMultipartFile implements MultipartFile { @Override public String getOriginalFilename() { return part.getSubmittedFileName(); } PartToMultipartFile(Part part); }
|
PartToMultipartFile implements MultipartFile { @Override public String getOriginalFilename() { return part.getSubmittedFileName(); } PartToMultipartFile(Part part); @Override String getName(); @Override String getOriginalFilename(); @Override String getContentType(); @Override boolean isEmpty(); @Override long getSize(); @Override byte[] getBytes(); @Override InputStream getInputStream(); @Override void transferTo(File dest); }
|
PartToMultipartFile implements MultipartFile { @Override public String getOriginalFilename() { return part.getSubmittedFileName(); } PartToMultipartFile(Part part); @Override String getName(); @Override String getOriginalFilename(); @Override String getContentType(); @Override boolean isEmpty(); @Override long getSize(); @Override byte[] getBytes(); @Override InputStream getInputStream(); @Override void transferTo(File dest); }
|
@Test public void getContentType() { String contentType = "json"; new Expectations() { { part.getContentType(); result = contentType; } }; Assert.assertEquals(contentType, multipartFile.getContentType()); }
|
@Override public String getContentType() { return part.getContentType(); }
|
PartToMultipartFile implements MultipartFile { @Override public String getContentType() { return part.getContentType(); } }
|
PartToMultipartFile implements MultipartFile { @Override public String getContentType() { return part.getContentType(); } PartToMultipartFile(Part part); }
|
PartToMultipartFile implements MultipartFile { @Override public String getContentType() { return part.getContentType(); } PartToMultipartFile(Part part); @Override String getName(); @Override String getOriginalFilename(); @Override String getContentType(); @Override boolean isEmpty(); @Override long getSize(); @Override byte[] getBytes(); @Override InputStream getInputStream(); @Override void transferTo(File dest); }
|
PartToMultipartFile implements MultipartFile { @Override public String getContentType() { return part.getContentType(); } PartToMultipartFile(Part part); @Override String getName(); @Override String getOriginalFilename(); @Override String getContentType(); @Override boolean isEmpty(); @Override long getSize(); @Override byte[] getBytes(); @Override InputStream getInputStream(); @Override void transferTo(File dest); }
|
@Test public void getSize() { long size = 10; new Expectations() { { part.getSize(); result = size; } }; Assert.assertEquals(size, multipartFile.getSize()); }
|
@Override public long getSize() { return part.getSize(); }
|
PartToMultipartFile implements MultipartFile { @Override public long getSize() { return part.getSize(); } }
|
PartToMultipartFile implements MultipartFile { @Override public long getSize() { return part.getSize(); } PartToMultipartFile(Part part); }
|
PartToMultipartFile implements MultipartFile { @Override public long getSize() { return part.getSize(); } PartToMultipartFile(Part part); @Override String getName(); @Override String getOriginalFilename(); @Override String getContentType(); @Override boolean isEmpty(); @Override long getSize(); @Override byte[] getBytes(); @Override InputStream getInputStream(); @Override void transferTo(File dest); }
|
PartToMultipartFile implements MultipartFile { @Override public long getSize() { return part.getSize(); } PartToMultipartFile(Part part); @Override String getName(); @Override String getOriginalFilename(); @Override String getContentType(); @Override boolean isEmpty(); @Override long getSize(); @Override byte[] getBytes(); @Override InputStream getInputStream(); @Override void transferTo(File dest); }
|
@Test public void transferTo() throws IllegalStateException, IOException { File dest = new File("/dest"); Holder<String> destName = new Holder<>(); new MockUp<Part>(part) { @Mock void write(String fileName) throws IOException { destName.value = fileName; } }; multipartFile.transferTo(dest); Assert.assertEquals(dest.getPath(), destName.value); }
|
@Override public void transferTo(File dest) throws IOException, IllegalStateException { part.write(dest.getPath()); }
|
PartToMultipartFile implements MultipartFile { @Override public void transferTo(File dest) throws IOException, IllegalStateException { part.write(dest.getPath()); } }
|
PartToMultipartFile implements MultipartFile { @Override public void transferTo(File dest) throws IOException, IllegalStateException { part.write(dest.getPath()); } PartToMultipartFile(Part part); }
|
PartToMultipartFile implements MultipartFile { @Override public void transferTo(File dest) throws IOException, IllegalStateException { part.write(dest.getPath()); } PartToMultipartFile(Part part); @Override String getName(); @Override String getOriginalFilename(); @Override String getContentType(); @Override boolean isEmpty(); @Override long getSize(); @Override byte[] getBytes(); @Override InputStream getInputStream(); @Override void transferTo(File dest); }
|
PartToMultipartFile implements MultipartFile { @Override public void transferTo(File dest) throws IOException, IllegalStateException { part.write(dest.getPath()); } PartToMultipartFile(Part part); @Override String getName(); @Override String getOriginalFilename(); @Override String getContentType(); @Override boolean isEmpty(); @Override long getSize(); @Override byte[] getBytes(); @Override InputStream getInputStream(); @Override void transferTo(File dest); }
|
@Test public void test_unregisterMicroserviceInstance_withServiceIdAndInstanceId_and_singleInstance_shouldRemoveService() { ServerUtil.microserviceInstanceMap = prepareServiceInstanceMap(false); target.unregisterMicroserviceInstance(prepareServerServiceInstance(true, instanceId)); Assert.assertFalse(ServerUtil.microserviceInstanceMap.containsKey(serviceId)); }
|
public void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance) { String unregisterServiceId = receivedInstance.getServiceId(); String unregisterInstanceId = receivedInstance.getInstanceId(); if (unregisterServiceId == null || unregisterInstanceId == null) { throw new IllegalArgumentException( "Invalid unregisterServiceId, unregisterServiceId=" + unregisterServiceId + "Invalid unregisterInstanceId, unregisterInstanceId=" + unregisterInstanceId); } ServerUtil.microserviceInstanceMap .computeIfPresent(unregisterServiceId, (serviceId, instanceIdMap) -> { instanceIdMap.computeIfPresent(unregisterInstanceId, (instanceId, instance) -> { LOGGER.info( "Successfully unregistered/remove serviceId: {}, instanceId: {} from server side", unregisterServiceId, unregisterInstanceId); return null; }); return !instanceIdMap.isEmpty() ? instanceIdMap : null; }); }
|
ZeroConfigRegistryService { public void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance) { String unregisterServiceId = receivedInstance.getServiceId(); String unregisterInstanceId = receivedInstance.getInstanceId(); if (unregisterServiceId == null || unregisterInstanceId == null) { throw new IllegalArgumentException( "Invalid unregisterServiceId, unregisterServiceId=" + unregisterServiceId + "Invalid unregisterInstanceId, unregisterInstanceId=" + unregisterInstanceId); } ServerUtil.microserviceInstanceMap .computeIfPresent(unregisterServiceId, (serviceId, instanceIdMap) -> { instanceIdMap.computeIfPresent(unregisterInstanceId, (instanceId, instance) -> { LOGGER.info( "Successfully unregistered/remove serviceId: {}, instanceId: {} from server side", unregisterServiceId, unregisterInstanceId); return null; }); return !instanceIdMap.isEmpty() ? instanceIdMap : null; }); } }
|
ZeroConfigRegistryService { public void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance) { String unregisterServiceId = receivedInstance.getServiceId(); String unregisterInstanceId = receivedInstance.getInstanceId(); if (unregisterServiceId == null || unregisterInstanceId == null) { throw new IllegalArgumentException( "Invalid unregisterServiceId, unregisterServiceId=" + unregisterServiceId + "Invalid unregisterInstanceId, unregisterInstanceId=" + unregisterInstanceId); } ServerUtil.microserviceInstanceMap .computeIfPresent(unregisterServiceId, (serviceId, instanceIdMap) -> { instanceIdMap.computeIfPresent(unregisterInstanceId, (instanceId, instance) -> { LOGGER.info( "Successfully unregistered/remove serviceId: {}, instanceId: {} from server side", unregisterServiceId, unregisterInstanceId); return null; }); return !instanceIdMap.isEmpty() ? instanceIdMap : null; }); } }
|
ZeroConfigRegistryService { public void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance) { String unregisterServiceId = receivedInstance.getServiceId(); String unregisterInstanceId = receivedInstance.getInstanceId(); if (unregisterServiceId == null || unregisterInstanceId == null) { throw new IllegalArgumentException( "Invalid unregisterServiceId, unregisterServiceId=" + unregisterServiceId + "Invalid unregisterInstanceId, unregisterInstanceId=" + unregisterInstanceId); } ServerUtil.microserviceInstanceMap .computeIfPresent(unregisterServiceId, (serviceId, instanceIdMap) -> { instanceIdMap.computeIfPresent(unregisterInstanceId, (instanceId, instance) -> { LOGGER.info( "Successfully unregistered/remove serviceId: {}, instanceId: {} from server side", unregisterServiceId, unregisterInstanceId); return null; }); return !instanceIdMap.isEmpty() ? instanceIdMap : null; }); } void registerMicroserviceInstance(ServerMicroserviceInstance receivedInstance); void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance); ServerMicroserviceInstance findServiceInstance(String serviceId,
String instanceId); List<ServerMicroserviceInstance> getMicroserviceInstance(String consumerId,
String providerId); void heartbeat(ServerMicroserviceInstance receivedInstance); boolean heartbeat(String microserviceId, String microserviceInstanceId); ServerMicroserviceInstance getMicroservice(String microserviceId); List<ServerMicroserviceInstance> findServiceInstances(String appId, String serviceName); }
|
ZeroConfigRegistryService { public void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance) { String unregisterServiceId = receivedInstance.getServiceId(); String unregisterInstanceId = receivedInstance.getInstanceId(); if (unregisterServiceId == null || unregisterInstanceId == null) { throw new IllegalArgumentException( "Invalid unregisterServiceId, unregisterServiceId=" + unregisterServiceId + "Invalid unregisterInstanceId, unregisterInstanceId=" + unregisterInstanceId); } ServerUtil.microserviceInstanceMap .computeIfPresent(unregisterServiceId, (serviceId, instanceIdMap) -> { instanceIdMap.computeIfPresent(unregisterInstanceId, (instanceId, instance) -> { LOGGER.info( "Successfully unregistered/remove serviceId: {}, instanceId: {} from server side", unregisterServiceId, unregisterInstanceId); return null; }); return !instanceIdMap.isEmpty() ? instanceIdMap : null; }); } void registerMicroserviceInstance(ServerMicroserviceInstance receivedInstance); void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance); ServerMicroserviceInstance findServiceInstance(String serviceId,
String instanceId); List<ServerMicroserviceInstance> getMicroserviceInstance(String consumerId,
String providerId); void heartbeat(ServerMicroserviceInstance receivedInstance); boolean heartbeat(String microserviceId, String microserviceInstanceId); ServerMicroserviceInstance getMicroservice(String microserviceId); List<ServerMicroserviceInstance> findServiceInstances(String appId, String serviceName); }
|
@Test public void disable() { logger.onInvocationFinish(event); Assert.assertTrue(logCollector.getEvents().isEmpty()); }
|
@Subscribe @AllowConcurrentEvents public void onInvocationFinish(InvocationFinishEvent event) { Invocation invocation = event.getInvocation(); OperationConfig operationConfig = invocation.getOperationMeta().getConfig(); if (!operationConfig.isSlowInvocationEnabled() || invocation.getInvocationStageTrace().calcTotalTime() < operationConfig.getNanoSlowInvocation()) { return; } if (!invocation.isConsumer()) { logSlowProducer(invocation, event.getResponse(), operationConfig); return; } if (invocation.isEdge()) { logSlowEdge(invocation, event.getResponse(), operationConfig); return; } logSlowConsumer(invocation, event.getResponse(), operationConfig); }
|
SlowInvocationLogger { @Subscribe @AllowConcurrentEvents public void onInvocationFinish(InvocationFinishEvent event) { Invocation invocation = event.getInvocation(); OperationConfig operationConfig = invocation.getOperationMeta().getConfig(); if (!operationConfig.isSlowInvocationEnabled() || invocation.getInvocationStageTrace().calcTotalTime() < operationConfig.getNanoSlowInvocation()) { return; } if (!invocation.isConsumer()) { logSlowProducer(invocation, event.getResponse(), operationConfig); return; } if (invocation.isEdge()) { logSlowEdge(invocation, event.getResponse(), operationConfig); return; } logSlowConsumer(invocation, event.getResponse(), operationConfig); } }
|
SlowInvocationLogger { @Subscribe @AllowConcurrentEvents public void onInvocationFinish(InvocationFinishEvent event) { Invocation invocation = event.getInvocation(); OperationConfig operationConfig = invocation.getOperationMeta().getConfig(); if (!operationConfig.isSlowInvocationEnabled() || invocation.getInvocationStageTrace().calcTotalTime() < operationConfig.getNanoSlowInvocation()) { return; } if (!invocation.isConsumer()) { logSlowProducer(invocation, event.getResponse(), operationConfig); return; } if (invocation.isEdge()) { logSlowEdge(invocation, event.getResponse(), operationConfig); return; } logSlowConsumer(invocation, event.getResponse(), operationConfig); } SlowInvocationLogger(SCBEngine scbEngine); }
|
SlowInvocationLogger { @Subscribe @AllowConcurrentEvents public void onInvocationFinish(InvocationFinishEvent event) { Invocation invocation = event.getInvocation(); OperationConfig operationConfig = invocation.getOperationMeta().getConfig(); if (!operationConfig.isSlowInvocationEnabled() || invocation.getInvocationStageTrace().calcTotalTime() < operationConfig.getNanoSlowInvocation()) { return; } if (!invocation.isConsumer()) { logSlowProducer(invocation, event.getResponse(), operationConfig); return; } if (invocation.isEdge()) { logSlowEdge(invocation, event.getResponse(), operationConfig); return; } logSlowConsumer(invocation, event.getResponse(), operationConfig); } SlowInvocationLogger(SCBEngine scbEngine); @Subscribe @AllowConcurrentEvents void onInvocationFinish(InvocationFinishEvent event); }
|
SlowInvocationLogger { @Subscribe @AllowConcurrentEvents public void onInvocationFinish(InvocationFinishEvent event) { Invocation invocation = event.getInvocation(); OperationConfig operationConfig = invocation.getOperationMeta().getConfig(); if (!operationConfig.isSlowInvocationEnabled() || invocation.getInvocationStageTrace().calcTotalTime() < operationConfig.getNanoSlowInvocation()) { return; } if (!invocation.isConsumer()) { logSlowProducer(invocation, event.getResponse(), operationConfig); return; } if (invocation.isEdge()) { logSlowEdge(invocation, event.getResponse(), operationConfig); return; } logSlowConsumer(invocation, event.getResponse(), operationConfig); } SlowInvocationLogger(SCBEngine scbEngine); @Subscribe @AllowConcurrentEvents void onInvocationFinish(InvocationFinishEvent event); }
|
@Test public void getExceptionClass() { Assert.assertEquals(InvocationException.class, converter.getExceptionClass()); }
|
@Override public Class<InvocationException> getExceptionClass() { return InvocationException.class; }
|
InvocationExceptionToProducerResponseConverter implements
ExceptionToProducerResponseConverter<InvocationException> { @Override public Class<InvocationException> getExceptionClass() { return InvocationException.class; } }
|
InvocationExceptionToProducerResponseConverter implements
ExceptionToProducerResponseConverter<InvocationException> { @Override public Class<InvocationException> getExceptionClass() { return InvocationException.class; } }
|
InvocationExceptionToProducerResponseConverter implements
ExceptionToProducerResponseConverter<InvocationException> { @Override public Class<InvocationException> getExceptionClass() { return InvocationException.class; } @Override Class<InvocationException> getExceptionClass(); @Override Response convert(SwaggerInvocation swaggerInvocation, InvocationException e); }
|
InvocationExceptionToProducerResponseConverter implements
ExceptionToProducerResponseConverter<InvocationException> { @Override public Class<InvocationException> getExceptionClass() { return InvocationException.class; } @Override Class<InvocationException> getExceptionClass(); @Override Response convert(SwaggerInvocation swaggerInvocation, InvocationException e); }
|
@Test public void convert(@Mocked SwaggerInvocation swaggerInvocation, @Mocked InvocationException e) { Response response = converter.convert(swaggerInvocation, e); Assert.assertSame(e, response.getResult()); }
|
@Override public Response convert(SwaggerInvocation swaggerInvocation, InvocationException e) { return Response.failResp(e); }
|
InvocationExceptionToProducerResponseConverter implements
ExceptionToProducerResponseConverter<InvocationException> { @Override public Response convert(SwaggerInvocation swaggerInvocation, InvocationException e) { return Response.failResp(e); } }
|
InvocationExceptionToProducerResponseConverter implements
ExceptionToProducerResponseConverter<InvocationException> { @Override public Response convert(SwaggerInvocation swaggerInvocation, InvocationException e) { return Response.failResp(e); } }
|
InvocationExceptionToProducerResponseConverter implements
ExceptionToProducerResponseConverter<InvocationException> { @Override public Response convert(SwaggerInvocation swaggerInvocation, InvocationException e) { return Response.failResp(e); } @Override Class<InvocationException> getExceptionClass(); @Override Response convert(SwaggerInvocation swaggerInvocation, InvocationException e); }
|
InvocationExceptionToProducerResponseConverter implements
ExceptionToProducerResponseConverter<InvocationException> { @Override public Response convert(SwaggerInvocation swaggerInvocation, InvocationException e) { return Response.failResp(e); } @Override Class<InvocationException> getExceptionClass(); @Override Response convert(SwaggerInvocation swaggerInvocation, InvocationException e); }
|
@Test void should_decode_dynamic_field_from_json() { String json = "{\"message\":\"msg\",\"k\":\"v\"}"; CommonExceptionData data = Json.decodeValue(json, CommonExceptionData.class); assertThat(data.getMessage()).isEqualTo("msg"); assertThat(data.getDynamic()).isEqualTo(of("k", "v")); assertThat(Json.encode(data)).isEqualTo(json); }
|
public String getMessage() { return message; }
|
CommonExceptionData extends DynamicObject { public String getMessage() { return message; } }
|
CommonExceptionData extends DynamicObject { public String getMessage() { return message; } CommonExceptionData(); CommonExceptionData(String message); CommonExceptionData(String code, String message); }
|
CommonExceptionData extends DynamicObject { public String getMessage() { return message; } CommonExceptionData(); CommonExceptionData(String message); CommonExceptionData(String code, String message); String getCode(); CommonExceptionData setCode(String code); String getMessage(); CommonExceptionData setMessage(String message); @Override String toString(); }
|
CommonExceptionData extends DynamicObject { public String getMessage() { return message; } CommonExceptionData(); CommonExceptionData(String message); CommonExceptionData(String code, String message); String getCode(); CommonExceptionData setCode(String code); String getMessage(); CommonExceptionData setMessage(String message); @Override String toString(); }
|
@Test public void convertExceptionToResponse( @Mocked ExceptionToProducerResponseConverter<Throwable> c1, @Mocked Response r1, @Mocked ExceptionToProducerResponseConverter<Throwable> c2, @Mocked Response r2, @Mocked ExceptionToProducerResponseConverter<Throwable> cDef) { new Expectations(SPIServiceUtils.class) { { SPIServiceUtils.getSortedService(ExceptionToProducerResponseConverter.class); result = Arrays.asList(c1, c2, cDef); c1.getExceptionClass(); result = Throwable.class; c1.convert((SwaggerInvocation) any, (Throwable) any); result = r1; c2.getExceptionClass(); result = Exception.class; c2.convert((SwaggerInvocation) any, (Throwable) any); result = r2; cDef.getExceptionClass(); result = null; } }; ExceptionToProducerResponseConverters exceptionToProducerResponseConverters = new ExceptionToProducerResponseConverters(); Assert.assertSame(r1, exceptionToProducerResponseConverters.convertExceptionToResponse(null, new Throwable())); Assert.assertSame(r2, exceptionToProducerResponseConverters.convertExceptionToResponse(null, new Exception())); Assert.assertSame(r2, exceptionToProducerResponseConverters.convertExceptionToResponse(null, new IllegalStateException())); }
|
public Response convertExceptionToResponse(SwaggerInvocation swaggerInvocation, Throwable e) { ExceptionToProducerResponseConverter<Throwable> converter = null; Class<?> clazz = e.getClass(); while (converter == null) { converter = exceptionToProducerResponseConverters.get(clazz); if (clazz == Throwable.class) { break; } clazz = clazz.getSuperclass(); } if (converter == null) { converter = defaultConverter; } try { return converter.convert(swaggerInvocation, e); } catch (Throwable throwable) { LOGGER .error("ExceptionToProducerResponseConverter {} cannot throw exception, please fix it.", converter.getClass(), throwable); return Response.failResp(swaggerInvocation.getInvocationType(), e); } }
|
ExceptionToProducerResponseConverters { public Response convertExceptionToResponse(SwaggerInvocation swaggerInvocation, Throwable e) { ExceptionToProducerResponseConverter<Throwable> converter = null; Class<?> clazz = e.getClass(); while (converter == null) { converter = exceptionToProducerResponseConverters.get(clazz); if (clazz == Throwable.class) { break; } clazz = clazz.getSuperclass(); } if (converter == null) { converter = defaultConverter; } try { return converter.convert(swaggerInvocation, e); } catch (Throwable throwable) { LOGGER .error("ExceptionToProducerResponseConverter {} cannot throw exception, please fix it.", converter.getClass(), throwable); return Response.failResp(swaggerInvocation.getInvocationType(), e); } } }
|
ExceptionToProducerResponseConverters { public Response convertExceptionToResponse(SwaggerInvocation swaggerInvocation, Throwable e) { ExceptionToProducerResponseConverter<Throwable> converter = null; Class<?> clazz = e.getClass(); while (converter == null) { converter = exceptionToProducerResponseConverters.get(clazz); if (clazz == Throwable.class) { break; } clazz = clazz.getSuperclass(); } if (converter == null) { converter = defaultConverter; } try { return converter.convert(swaggerInvocation, e); } catch (Throwable throwable) { LOGGER .error("ExceptionToProducerResponseConverter {} cannot throw exception, please fix it.", converter.getClass(), throwable); return Response.failResp(swaggerInvocation.getInvocationType(), e); } } @SuppressWarnings("unchecked") ExceptionToProducerResponseConverters(); }
|
ExceptionToProducerResponseConverters { public Response convertExceptionToResponse(SwaggerInvocation swaggerInvocation, Throwable e) { ExceptionToProducerResponseConverter<Throwable> converter = null; Class<?> clazz = e.getClass(); while (converter == null) { converter = exceptionToProducerResponseConverters.get(clazz); if (clazz == Throwable.class) { break; } clazz = clazz.getSuperclass(); } if (converter == null) { converter = defaultConverter; } try { return converter.convert(swaggerInvocation, e); } catch (Throwable throwable) { LOGGER .error("ExceptionToProducerResponseConverter {} cannot throw exception, please fix it.", converter.getClass(), throwable); return Response.failResp(swaggerInvocation.getInvocationType(), e); } } @SuppressWarnings("unchecked") ExceptionToProducerResponseConverters(); Response convertExceptionToResponse(SwaggerInvocation swaggerInvocation, Throwable e); }
|
ExceptionToProducerResponseConverters { public Response convertExceptionToResponse(SwaggerInvocation swaggerInvocation, Throwable e) { ExceptionToProducerResponseConverter<Throwable> converter = null; Class<?> clazz = e.getClass(); while (converter == null) { converter = exceptionToProducerResponseConverters.get(clazz); if (clazz == Throwable.class) { break; } clazz = clazz.getSuperclass(); } if (converter == null) { converter = defaultConverter; } try { return converter.convert(swaggerInvocation, e); } catch (Throwable throwable) { LOGGER .error("ExceptionToProducerResponseConverter {} cannot throw exception, please fix it.", converter.getClass(), throwable); return Response.failResp(swaggerInvocation.getInvocationType(), e); } } @SuppressWarnings("unchecked") ExceptionToProducerResponseConverters(); Response convertExceptionToResponse(SwaggerInvocation swaggerInvocation, Throwable e); }
|
@Test public void convertExceptionToResponse_checkDefaultConverterPriority( @Mocked ExceptionToProducerResponseConverter<Throwable> c1, @Mocked Response r1, @Mocked ExceptionToProducerResponseConverter<Throwable> c2, @Mocked Response r2, @Mocked ExceptionToProducerResponseConverter<Throwable> cDef, @Mocked Response rDef, @Mocked ExceptionToProducerResponseConverter<Throwable> cDef2) { new Expectations(SPIServiceUtils.class) { { SPIServiceUtils.getSortedService(ExceptionToProducerResponseConverter.class); result = Arrays.asList(c1, c2, cDef, cDef2); c1.getExceptionClass(); result = RuntimeException.class; c1.convert((SwaggerInvocation) any, (Throwable) any); result = r1; c2.getExceptionClass(); result = InvocationException.class; c2.convert((SwaggerInvocation) any, (Throwable) any); result = r2; cDef.getExceptionClass(); result = null; cDef.convert((SwaggerInvocation) any, (Throwable) any); result = rDef; cDef2.getExceptionClass(); result = null; } }; ExceptionToProducerResponseConverters exceptionToProducerResponseConverters = new ExceptionToProducerResponseConverters(); Assert.assertSame(r2, exceptionToProducerResponseConverters .convertExceptionToResponse(null, new InvocationException(Status.UNAUTHORIZED, ""))); Assert.assertSame(r1, exceptionToProducerResponseConverters.convertExceptionToResponse(null, new RuntimeException())); Assert.assertSame(rDef, exceptionToProducerResponseConverters.convertExceptionToResponse(null, new IOException())); }
|
public Response convertExceptionToResponse(SwaggerInvocation swaggerInvocation, Throwable e) { ExceptionToProducerResponseConverter<Throwable> converter = null; Class<?> clazz = e.getClass(); while (converter == null) { converter = exceptionToProducerResponseConverters.get(clazz); if (clazz == Throwable.class) { break; } clazz = clazz.getSuperclass(); } if (converter == null) { converter = defaultConverter; } try { return converter.convert(swaggerInvocation, e); } catch (Throwable throwable) { LOGGER .error("ExceptionToProducerResponseConverter {} cannot throw exception, please fix it.", converter.getClass(), throwable); return Response.failResp(swaggerInvocation.getInvocationType(), e); } }
|
ExceptionToProducerResponseConverters { public Response convertExceptionToResponse(SwaggerInvocation swaggerInvocation, Throwable e) { ExceptionToProducerResponseConverter<Throwable> converter = null; Class<?> clazz = e.getClass(); while (converter == null) { converter = exceptionToProducerResponseConverters.get(clazz); if (clazz == Throwable.class) { break; } clazz = clazz.getSuperclass(); } if (converter == null) { converter = defaultConverter; } try { return converter.convert(swaggerInvocation, e); } catch (Throwable throwable) { LOGGER .error("ExceptionToProducerResponseConverter {} cannot throw exception, please fix it.", converter.getClass(), throwable); return Response.failResp(swaggerInvocation.getInvocationType(), e); } } }
|
ExceptionToProducerResponseConverters { public Response convertExceptionToResponse(SwaggerInvocation swaggerInvocation, Throwable e) { ExceptionToProducerResponseConverter<Throwable> converter = null; Class<?> clazz = e.getClass(); while (converter == null) { converter = exceptionToProducerResponseConverters.get(clazz); if (clazz == Throwable.class) { break; } clazz = clazz.getSuperclass(); } if (converter == null) { converter = defaultConverter; } try { return converter.convert(swaggerInvocation, e); } catch (Throwable throwable) { LOGGER .error("ExceptionToProducerResponseConverter {} cannot throw exception, please fix it.", converter.getClass(), throwable); return Response.failResp(swaggerInvocation.getInvocationType(), e); } } @SuppressWarnings("unchecked") ExceptionToProducerResponseConverters(); }
|
ExceptionToProducerResponseConverters { public Response convertExceptionToResponse(SwaggerInvocation swaggerInvocation, Throwable e) { ExceptionToProducerResponseConverter<Throwable> converter = null; Class<?> clazz = e.getClass(); while (converter == null) { converter = exceptionToProducerResponseConverters.get(clazz); if (clazz == Throwable.class) { break; } clazz = clazz.getSuperclass(); } if (converter == null) { converter = defaultConverter; } try { return converter.convert(swaggerInvocation, e); } catch (Throwable throwable) { LOGGER .error("ExceptionToProducerResponseConverter {} cannot throw exception, please fix it.", converter.getClass(), throwable); return Response.failResp(swaggerInvocation.getInvocationType(), e); } } @SuppressWarnings("unchecked") ExceptionToProducerResponseConverters(); Response convertExceptionToResponse(SwaggerInvocation swaggerInvocation, Throwable e); }
|
ExceptionToProducerResponseConverters { public Response convertExceptionToResponse(SwaggerInvocation swaggerInvocation, Throwable e) { ExceptionToProducerResponseConverter<Throwable> converter = null; Class<?> clazz = e.getClass(); while (converter == null) { converter = exceptionToProducerResponseConverters.get(clazz); if (clazz == Throwable.class) { break; } clazz = clazz.getSuperclass(); } if (converter == null) { converter = defaultConverter; } try { return converter.convert(swaggerInvocation, e); } catch (Throwable throwable) { LOGGER .error("ExceptionToProducerResponseConverter {} cannot throw exception, please fix it.", converter.getClass(), throwable); return Response.failResp(swaggerInvocation.getInvocationType(), e); } } @SuppressWarnings("unchecked") ExceptionToProducerResponseConverters(); Response convertExceptionToResponse(SwaggerInvocation swaggerInvocation, Throwable e); }
|
@Test public void convertExceptionToResponse_CheckCommonConvertPriority( @Mocked ExceptionToProducerResponseConverter<RuntimeException0> cR0, @Mocked ExceptionToProducerResponseConverter<RuntimeException0> cR0_LowPriority, @Mocked ExceptionToProducerResponseConverter<RuntimeException1> cR1, @Mocked ExceptionToProducerResponseConverter<RuntimeException> cR, @Mocked ExceptionToProducerResponseConverter<Throwable> cT, @Mocked ExceptionToProducerResponseConverter<?> cDef, @Mocked Response rR0, @Mocked Response rR1, @Mocked Response rR, @Mocked Response rT) { new Expectations(SPIServiceUtils.class) { { SPIServiceUtils.getSortedService(ExceptionToProducerResponseConverter.class); result = Arrays.asList(cR, cR0, cR0_LowPriority, cR1, cDef, cT); cR0.getExceptionClass(); result = RuntimeException0.class; cR0.convert((SwaggerInvocation) any, (RuntimeException0) any); result = rR0; cR0_LowPriority.getExceptionClass(); result = RuntimeException0.class; cR1.getExceptionClass(); result = RuntimeException1.class; cR1.convert((SwaggerInvocation) any, (RuntimeException1) any); result = rR1; cR.getExceptionClass(); result = RuntimeException.class; cR.convert((SwaggerInvocation) any, (RuntimeException) any); result = rR; cT.getExceptionClass(); result = Throwable.class; cT.convert((SwaggerInvocation) any, (Throwable) any); result = rT; cDef.getExceptionClass(); result = null; } }; ExceptionToProducerResponseConverters exceptionToProducerResponseConverters = new ExceptionToProducerResponseConverters(); Assert.assertSame(rR0, exceptionToProducerResponseConverters.convertExceptionToResponse(null, new RuntimeException0_0())); Assert.assertSame(rR0, exceptionToProducerResponseConverters.convertExceptionToResponse(null, new RuntimeException0())); Assert.assertSame(rR1, exceptionToProducerResponseConverters.convertExceptionToResponse(null, new RuntimeException1())); Assert.assertSame(rR, exceptionToProducerResponseConverters.convertExceptionToResponse(null, new RuntimeException())); Assert.assertSame(rT, exceptionToProducerResponseConverters.convertExceptionToResponse(null, new IOException())); }
|
public Response convertExceptionToResponse(SwaggerInvocation swaggerInvocation, Throwable e) { ExceptionToProducerResponseConverter<Throwable> converter = null; Class<?> clazz = e.getClass(); while (converter == null) { converter = exceptionToProducerResponseConverters.get(clazz); if (clazz == Throwable.class) { break; } clazz = clazz.getSuperclass(); } if (converter == null) { converter = defaultConverter; } try { return converter.convert(swaggerInvocation, e); } catch (Throwable throwable) { LOGGER .error("ExceptionToProducerResponseConverter {} cannot throw exception, please fix it.", converter.getClass(), throwable); return Response.failResp(swaggerInvocation.getInvocationType(), e); } }
|
ExceptionToProducerResponseConverters { public Response convertExceptionToResponse(SwaggerInvocation swaggerInvocation, Throwable e) { ExceptionToProducerResponseConverter<Throwable> converter = null; Class<?> clazz = e.getClass(); while (converter == null) { converter = exceptionToProducerResponseConverters.get(clazz); if (clazz == Throwable.class) { break; } clazz = clazz.getSuperclass(); } if (converter == null) { converter = defaultConverter; } try { return converter.convert(swaggerInvocation, e); } catch (Throwable throwable) { LOGGER .error("ExceptionToProducerResponseConverter {} cannot throw exception, please fix it.", converter.getClass(), throwable); return Response.failResp(swaggerInvocation.getInvocationType(), e); } } }
|
ExceptionToProducerResponseConverters { public Response convertExceptionToResponse(SwaggerInvocation swaggerInvocation, Throwable e) { ExceptionToProducerResponseConverter<Throwable> converter = null; Class<?> clazz = e.getClass(); while (converter == null) { converter = exceptionToProducerResponseConverters.get(clazz); if (clazz == Throwable.class) { break; } clazz = clazz.getSuperclass(); } if (converter == null) { converter = defaultConverter; } try { return converter.convert(swaggerInvocation, e); } catch (Throwable throwable) { LOGGER .error("ExceptionToProducerResponseConverter {} cannot throw exception, please fix it.", converter.getClass(), throwable); return Response.failResp(swaggerInvocation.getInvocationType(), e); } } @SuppressWarnings("unchecked") ExceptionToProducerResponseConverters(); }
|
ExceptionToProducerResponseConverters { public Response convertExceptionToResponse(SwaggerInvocation swaggerInvocation, Throwable e) { ExceptionToProducerResponseConverter<Throwable> converter = null; Class<?> clazz = e.getClass(); while (converter == null) { converter = exceptionToProducerResponseConverters.get(clazz); if (clazz == Throwable.class) { break; } clazz = clazz.getSuperclass(); } if (converter == null) { converter = defaultConverter; } try { return converter.convert(swaggerInvocation, e); } catch (Throwable throwable) { LOGGER .error("ExceptionToProducerResponseConverter {} cannot throw exception, please fix it.", converter.getClass(), throwable); return Response.failResp(swaggerInvocation.getInvocationType(), e); } } @SuppressWarnings("unchecked") ExceptionToProducerResponseConverters(); Response convertExceptionToResponse(SwaggerInvocation swaggerInvocation, Throwable e); }
|
ExceptionToProducerResponseConverters { public Response convertExceptionToResponse(SwaggerInvocation swaggerInvocation, Throwable e) { ExceptionToProducerResponseConverter<Throwable> converter = null; Class<?> clazz = e.getClass(); while (converter == null) { converter = exceptionToProducerResponseConverters.get(clazz); if (clazz == Throwable.class) { break; } clazz = clazz.getSuperclass(); } if (converter == null) { converter = defaultConverter; } try { return converter.convert(swaggerInvocation, e); } catch (Throwable throwable) { LOGGER .error("ExceptionToProducerResponseConverter {} cannot throw exception, please fix it.", converter.getClass(), throwable); return Response.failResp(swaggerInvocation.getInvocationType(), e); } } @SuppressWarnings("unchecked") ExceptionToProducerResponseConverters(); Response convertExceptionToResponse(SwaggerInvocation swaggerInvocation, Throwable e); }
|
@Test public void getExceptionClass() { Assert.assertNull(converter.getExceptionClass()); }
|
@Override public Class<Throwable> getExceptionClass() { return null; }
|
DefaultExceptionToProducerResponseConverter implements ExceptionToProducerResponseConverter<Throwable> { @Override public Class<Throwable> getExceptionClass() { return null; } }
|
DefaultExceptionToProducerResponseConverter implements ExceptionToProducerResponseConverter<Throwable> { @Override public Class<Throwable> getExceptionClass() { return null; } }
|
DefaultExceptionToProducerResponseConverter implements ExceptionToProducerResponseConverter<Throwable> { @Override public Class<Throwable> getExceptionClass() { return null; } @Override Class<Throwable> getExceptionClass(); @Override Response convert(SwaggerInvocation swaggerInvocation, Throwable e); }
|
DefaultExceptionToProducerResponseConverter implements ExceptionToProducerResponseConverter<Throwable> { @Override public Class<Throwable> getExceptionClass() { return null; } @Override Class<Throwable> getExceptionClass(); @Override Response convert(SwaggerInvocation swaggerInvocation, Throwable e); }
|
@Test public void convert(@Mocked SwaggerInvocation swaggerInvocation, @Mocked Error e) { Response response = converter.convert(swaggerInvocation, e); Assert.assertSame(e, ((InvocationException) response.getResult()).getCause()); }
|
@Override public Response convert(SwaggerInvocation swaggerInvocation, Throwable e) { LOGGER.error("invoke failed, invocation={}", swaggerInvocation.getInvocationQualifiedName(), e); return Response.failResp(swaggerInvocation.getInvocationType(), e); }
|
DefaultExceptionToProducerResponseConverter implements ExceptionToProducerResponseConverter<Throwable> { @Override public Response convert(SwaggerInvocation swaggerInvocation, Throwable e) { LOGGER.error("invoke failed, invocation={}", swaggerInvocation.getInvocationQualifiedName(), e); return Response.failResp(swaggerInvocation.getInvocationType(), e); } }
|
DefaultExceptionToProducerResponseConverter implements ExceptionToProducerResponseConverter<Throwable> { @Override public Response convert(SwaggerInvocation swaggerInvocation, Throwable e) { LOGGER.error("invoke failed, invocation={}", swaggerInvocation.getInvocationQualifiedName(), e); return Response.failResp(swaggerInvocation.getInvocationType(), e); } }
|
DefaultExceptionToProducerResponseConverter implements ExceptionToProducerResponseConverter<Throwable> { @Override public Response convert(SwaggerInvocation swaggerInvocation, Throwable e) { LOGGER.error("invoke failed, invocation={}", swaggerInvocation.getInvocationQualifiedName(), e); return Response.failResp(swaggerInvocation.getInvocationType(), e); } @Override Class<Throwable> getExceptionClass(); @Override Response convert(SwaggerInvocation swaggerInvocation, Throwable e); }
|
DefaultExceptionToProducerResponseConverter implements ExceptionToProducerResponseConverter<Throwable> { @Override public Response convert(SwaggerInvocation swaggerInvocation, Throwable e) { LOGGER.error("invoke failed, invocation={}", swaggerInvocation.getInvocationQualifiedName(), e); return Response.failResp(swaggerInvocation.getInvocationType(), e); } @Override Class<Throwable> getExceptionClass(); @Override Response convert(SwaggerInvocation swaggerInvocation, Throwable e); }
|
@Test public void convertExceptionToResponse() { Error error = new Error("test"); Response response = ExceptionFactory.convertExceptionToResponse(null, error); Assert.assertSame(Status.OK, response.getStatus()); Assert.assertEquals("response from error: test", response.getResult()); }
|
public static Response convertExceptionToResponse(SwaggerInvocation swaggerInvocation, Throwable e) { return exceptionToProducerResponseConverters.convertExceptionToResponse(swaggerInvocation, e); }
|
ExceptionFactory { public static Response convertExceptionToResponse(SwaggerInvocation swaggerInvocation, Throwable e) { return exceptionToProducerResponseConverters.convertExceptionToResponse(swaggerInvocation, e); } }
|
ExceptionFactory { public static Response convertExceptionToResponse(SwaggerInvocation swaggerInvocation, Throwable e) { return exceptionToProducerResponseConverters.convertExceptionToResponse(swaggerInvocation, e); } private ExceptionFactory(); }
|
ExceptionFactory { public static Response convertExceptionToResponse(SwaggerInvocation swaggerInvocation, Throwable e) { return exceptionToProducerResponseConverters.convertExceptionToResponse(swaggerInvocation, e); } private ExceptionFactory(); static InvocationException create(StatusType status,
Object exceptionOrErrorData); static InvocationException createConsumerException(Object errorData); static InvocationException createProducerException(Object errorData); static InvocationException convertConsumerException(Throwable e); static InvocationException convertConsumerException(Throwable e, String errorMsg); static InvocationException convertProducerException(Throwable e); static InvocationException convertProducerException(Throwable e, String errorMsg); static Response convertExceptionToResponse(SwaggerInvocation swaggerInvocation, Throwable e); static Throwable unwrapIncludeInvocationException(Throwable throwable); @SuppressWarnings("unchecked") static T unwrap(Throwable throwable); }
|
ExceptionFactory { public static Response convertExceptionToResponse(SwaggerInvocation swaggerInvocation, Throwable e) { return exceptionToProducerResponseConverters.convertExceptionToResponse(swaggerInvocation, e); } private ExceptionFactory(); static InvocationException create(StatusType status,
Object exceptionOrErrorData); static InvocationException createConsumerException(Object errorData); static InvocationException createProducerException(Object errorData); static InvocationException convertConsumerException(Throwable e); static InvocationException convertConsumerException(Throwable e, String errorMsg); static InvocationException convertProducerException(Throwable e); static InvocationException convertProducerException(Throwable e, String errorMsg); static Response convertExceptionToResponse(SwaggerInvocation swaggerInvocation, Throwable e); static Throwable unwrapIncludeInvocationException(Throwable throwable); @SuppressWarnings("unchecked") static T unwrap(Throwable throwable); static final int PRODUCER_INNER_STATUS_CODE; static final String PRODUCER_INNER_REASON_PHRASE; static final StatusType PRODUCER_INNER_STATUS; static final int CONSUMER_INNER_STATUS_CODE; static final String CONSUMER_INNER_REASON_PHRASE; static final StatusType CONSUMER_INNER_STATUS; }
|
@Test public void construct_withContext() { InvocationContext parentContext = new InvocationContext(); parentContext.addContext("k", "v"); parentContext.addLocalContext("k", 1); ContextUtils.setInvocationContext(parentContext); try { SwaggerInvocation invocation = new SwaggerInvocation(); Assert.assertSame(parentContext, invocation.getParentContext()); Assert.assertEquals("v", invocation.getContext("k")); Assert.assertEquals(1, (int) invocation.getLocalContext("k")); } finally { ContextUtils.removeInvocationContext(); } }
|
public InvocationContext getParentContext() { return parentContext; }
|
SwaggerInvocation extends InvocationContext { public InvocationContext getParentContext() { return parentContext; } }
|
SwaggerInvocation extends InvocationContext { public InvocationContext getParentContext() { return parentContext; } SwaggerInvocation(); }
|
SwaggerInvocation extends InvocationContext { public InvocationContext getParentContext() { return parentContext; } SwaggerInvocation(); InvocationContext getParentContext(); InvocationType getInvocationType(); String getInvocationQualifiedName(); void onBusinessMethodStart(); void onBusinessMethodFinish(); void onBusinessFinish(); }
|
SwaggerInvocation extends InvocationContext { public InvocationContext getParentContext() { return parentContext; } SwaggerInvocation(); InvocationContext getParentContext(); InvocationType getInvocationType(); String getInvocationQualifiedName(); void onBusinessMethodStart(); void onBusinessMethodFinish(); void onBusinessFinish(); }
|
@Test public void test_findServiceInstance_whenInstanceExist_shouldSucceed() { ServerUtil.microserviceInstanceMap = prepareServiceInstanceMap(false); ServerMicroserviceInstance returnedResult = target.findServiceInstance(serviceId, instanceId); Assert.assertNotNull(returnedResult); }
|
public ServerMicroserviceInstance findServiceInstance(String serviceId, String instanceId) { Map<String, ServerMicroserviceInstance> serverMicroserviceInstanceMap = ServerUtil.microserviceInstanceMap .get(serviceId); if (serverMicroserviceInstanceMap == null || serverMicroserviceInstanceMap.isEmpty()) { return null; } return serverMicroserviceInstanceMap.get(instanceId); }
|
ZeroConfigRegistryService { public ServerMicroserviceInstance findServiceInstance(String serviceId, String instanceId) { Map<String, ServerMicroserviceInstance> serverMicroserviceInstanceMap = ServerUtil.microserviceInstanceMap .get(serviceId); if (serverMicroserviceInstanceMap == null || serverMicroserviceInstanceMap.isEmpty()) { return null; } return serverMicroserviceInstanceMap.get(instanceId); } }
|
ZeroConfigRegistryService { public ServerMicroserviceInstance findServiceInstance(String serviceId, String instanceId) { Map<String, ServerMicroserviceInstance> serverMicroserviceInstanceMap = ServerUtil.microserviceInstanceMap .get(serviceId); if (serverMicroserviceInstanceMap == null || serverMicroserviceInstanceMap.isEmpty()) { return null; } return serverMicroserviceInstanceMap.get(instanceId); } }
|
ZeroConfigRegistryService { public ServerMicroserviceInstance findServiceInstance(String serviceId, String instanceId) { Map<String, ServerMicroserviceInstance> serverMicroserviceInstanceMap = ServerUtil.microserviceInstanceMap .get(serviceId); if (serverMicroserviceInstanceMap == null || serverMicroserviceInstanceMap.isEmpty()) { return null; } return serverMicroserviceInstanceMap.get(instanceId); } void registerMicroserviceInstance(ServerMicroserviceInstance receivedInstance); void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance); ServerMicroserviceInstance findServiceInstance(String serviceId,
String instanceId); List<ServerMicroserviceInstance> getMicroserviceInstance(String consumerId,
String providerId); void heartbeat(ServerMicroserviceInstance receivedInstance); boolean heartbeat(String microserviceId, String microserviceInstanceId); ServerMicroserviceInstance getMicroservice(String microserviceId); List<ServerMicroserviceInstance> findServiceInstances(String appId, String serviceName); }
|
ZeroConfigRegistryService { public ServerMicroserviceInstance findServiceInstance(String serviceId, String instanceId) { Map<String, ServerMicroserviceInstance> serverMicroserviceInstanceMap = ServerUtil.microserviceInstanceMap .get(serviceId); if (serverMicroserviceInstanceMap == null || serverMicroserviceInstanceMap.isEmpty()) { return null; } return serverMicroserviceInstanceMap.get(instanceId); } void registerMicroserviceInstance(ServerMicroserviceInstance receivedInstance); void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance); ServerMicroserviceInstance findServiceInstance(String serviceId,
String instanceId); List<ServerMicroserviceInstance> getMicroserviceInstance(String consumerId,
String providerId); void heartbeat(ServerMicroserviceInstance receivedInstance); boolean heartbeat(String microserviceId, String microserviceInstanceId); ServerMicroserviceInstance getMicroservice(String microserviceId); List<ServerMicroserviceInstance> findServiceInstances(String appId, String serviceName); }
|
@Test public void construct_noContext() { SwaggerInvocation invocation = new SwaggerInvocation(); Assert.assertNull(invocation.getParentContext()); }
|
public InvocationContext getParentContext() { return parentContext; }
|
SwaggerInvocation extends InvocationContext { public InvocationContext getParentContext() { return parentContext; } }
|
SwaggerInvocation extends InvocationContext { public InvocationContext getParentContext() { return parentContext; } SwaggerInvocation(); }
|
SwaggerInvocation extends InvocationContext { public InvocationContext getParentContext() { return parentContext; } SwaggerInvocation(); InvocationContext getParentContext(); InvocationType getInvocationType(); String getInvocationQualifiedName(); void onBusinessMethodStart(); void onBusinessMethodFinish(); void onBusinessFinish(); }
|
SwaggerInvocation extends InvocationContext { public InvocationContext getParentContext() { return parentContext; } SwaggerInvocation(); InvocationContext getParentContext(); InvocationType getInvocationType(); String getInvocationQualifiedName(); void onBusinessMethodStart(); void onBusinessMethodFinish(); void onBusinessFinish(); }
|
@Test public void addContext() { InvocationContext invocationContext = new InvocationContext(); invocationContext.addContext("key1", "value1"); Assert.assertEquals(1, invocationContext.getContext().size()); Assert.assertEquals("value1", invocationContext.getContext("key1")); Map<String, String> otherContext = new HashMap<>(); otherContext.put("key2", "value2"); invocationContext.addContext(otherContext); Assert.assertEquals(2, invocationContext.getContext().size()); Assert.assertEquals("value2", invocationContext.getContext("key2")); InvocationContext invocationContext2 = new InvocationContext(); Map<String, String> otherContext2 = new HashMap<>(); otherContext2.put("key3", "value3"); invocationContext2.context = otherContext2; invocationContext.addContext(invocationContext2); Assert.assertEquals(3, invocationContext.getContext().size()); }
|
public void addContext(String key, String value) { context.put(key, value); }
|
InvocationContext { public void addContext(String key, String value) { context.put(key, value); } }
|
InvocationContext { public void addContext(String key, String value) { context.put(key, value); } InvocationContext(); }
|
InvocationContext { public void addContext(String key, String value) { context.put(key, value); } InvocationContext(); Map<String, String> getContext(); void setContext(Map<String, String> context); void addContext(String key, String value); String getContext(String key); void addContext(InvocationContext otherContext); void addContext(Map<String, String> otherContext); void mergeContext(InvocationContext otherContext); void mergeContext(Map<String, String> otherContext); Map<String, Object> getLocalContext(); void setLocalContext(Map<String, Object> localContext); void addLocalContext(String key, Object value); @SuppressWarnings("unchecked") T getLocalContext(String key); void addLocalContext(Map<String, Object> otherContext); StatusType getStatus(); void setStatus(StatusType status); void setStatus(int statusCode, String reason); void setStatus(int statusCode); @SuppressWarnings("unchecked") T getTransportContext(); void setTransportContext(TransportContext transportContext); }
|
InvocationContext { public void addContext(String key, String value) { context.put(key, value); } InvocationContext(); Map<String, String> getContext(); void setContext(Map<String, String> context); void addContext(String key, String value); String getContext(String key); void addContext(InvocationContext otherContext); void addContext(Map<String, String> otherContext); void mergeContext(InvocationContext otherContext); void mergeContext(Map<String, String> otherContext); Map<String, Object> getLocalContext(); void setLocalContext(Map<String, Object> localContext); void addLocalContext(String key, Object value); @SuppressWarnings("unchecked") T getLocalContext(String key); void addLocalContext(Map<String, Object> otherContext); StatusType getStatus(); void setStatus(StatusType status); void setStatus(int statusCode, String reason); void setStatus(int statusCode); @SuppressWarnings("unchecked") T getTransportContext(); void setTransportContext(TransportContext transportContext); }
|
@Test public void addLocalContext() { InvocationContext invocationContext = new InvocationContext(); invocationContext.addLocalContext("key1", "value1"); Assert.assertEquals(1, invocationContext.getLocalContext().size()); Assert.assertEquals("value1", invocationContext.getLocalContext("key1")); Map<String, Object> otherContext = new HashMap<>(); otherContext.put("key2", "value2"); invocationContext.addLocalContext(otherContext); Assert.assertEquals(2, invocationContext.getLocalContext().size()); Assert.assertEquals("value2", invocationContext.getLocalContext("key2")); }
|
public void addLocalContext(String key, Object value) { localContext.put(key, value); }
|
InvocationContext { public void addLocalContext(String key, Object value) { localContext.put(key, value); } }
|
InvocationContext { public void addLocalContext(String key, Object value) { localContext.put(key, value); } InvocationContext(); }
|
InvocationContext { public void addLocalContext(String key, Object value) { localContext.put(key, value); } InvocationContext(); Map<String, String> getContext(); void setContext(Map<String, String> context); void addContext(String key, String value); String getContext(String key); void addContext(InvocationContext otherContext); void addContext(Map<String, String> otherContext); void mergeContext(InvocationContext otherContext); void mergeContext(Map<String, String> otherContext); Map<String, Object> getLocalContext(); void setLocalContext(Map<String, Object> localContext); void addLocalContext(String key, Object value); @SuppressWarnings("unchecked") T getLocalContext(String key); void addLocalContext(Map<String, Object> otherContext); StatusType getStatus(); void setStatus(StatusType status); void setStatus(int statusCode, String reason); void setStatus(int statusCode); @SuppressWarnings("unchecked") T getTransportContext(); void setTransportContext(TransportContext transportContext); }
|
InvocationContext { public void addLocalContext(String key, Object value) { localContext.put(key, value); } InvocationContext(); Map<String, String> getContext(); void setContext(Map<String, String> context); void addContext(String key, String value); String getContext(String key); void addContext(InvocationContext otherContext); void addContext(Map<String, String> otherContext); void mergeContext(InvocationContext otherContext); void mergeContext(Map<String, String> otherContext); Map<String, Object> getLocalContext(); void setLocalContext(Map<String, Object> localContext); void addLocalContext(String key, Object value); @SuppressWarnings("unchecked") T getLocalContext(String key); void addLocalContext(Map<String, Object> otherContext); StatusType getStatus(); void setStatus(StatusType status); void setStatus(int statusCode, String reason); void setStatus(int statusCode); @SuppressWarnings("unchecked") T getTransportContext(); void setTransportContext(TransportContext transportContext); }
|
@Test public void setStatus() { InvocationContext invocationContext = new InvocationContext(); invocationContext.setStatus(200); System.out.println(invocationContext.getStatus().getFamily()); Assert.assertEquals(200, invocationContext.getStatus().getStatusCode()); Assert.assertEquals("OK", invocationContext.getStatus().getReasonPhrase()); Assert.assertEquals(Family.SUCCESSFUL, invocationContext.getStatus().getFamily()); invocationContext.setStatus(200, "TEST"); Assert.assertEquals(200, invocationContext.getStatus().getStatusCode()); Assert.assertEquals("TEST", invocationContext.getStatus().getReasonPhrase()); Assert.assertEquals(Family.SUCCESSFUL, invocationContext.getStatus().getFamily()); }
|
public void setStatus(StatusType status) { this.httpStatus = status; }
|
InvocationContext { public void setStatus(StatusType status) { this.httpStatus = status; } }
|
InvocationContext { public void setStatus(StatusType status) { this.httpStatus = status; } InvocationContext(); }
|
InvocationContext { public void setStatus(StatusType status) { this.httpStatus = status; } InvocationContext(); Map<String, String> getContext(); void setContext(Map<String, String> context); void addContext(String key, String value); String getContext(String key); void addContext(InvocationContext otherContext); void addContext(Map<String, String> otherContext); void mergeContext(InvocationContext otherContext); void mergeContext(Map<String, String> otherContext); Map<String, Object> getLocalContext(); void setLocalContext(Map<String, Object> localContext); void addLocalContext(String key, Object value); @SuppressWarnings("unchecked") T getLocalContext(String key); void addLocalContext(Map<String, Object> otherContext); StatusType getStatus(); void setStatus(StatusType status); void setStatus(int statusCode, String reason); void setStatus(int statusCode); @SuppressWarnings("unchecked") T getTransportContext(); void setTransportContext(TransportContext transportContext); }
|
InvocationContext { public void setStatus(StatusType status) { this.httpStatus = status; } InvocationContext(); Map<String, String> getContext(); void setContext(Map<String, String> context); void addContext(String key, String value); String getContext(String key); void addContext(InvocationContext otherContext); void addContext(Map<String, String> otherContext); void mergeContext(InvocationContext otherContext); void mergeContext(Map<String, String> otherContext); Map<String, Object> getLocalContext(); void setLocalContext(Map<String, Object> localContext); void addLocalContext(String key, Object value); @SuppressWarnings("unchecked") T getLocalContext(String key); void addLocalContext(Map<String, Object> otherContext); StatusType getStatus(); void setStatus(StatusType status); void setStatus(int statusCode, String reason); void setStatus(int statusCode); @SuppressWarnings("unchecked") T getTransportContext(); void setTransportContext(TransportContext transportContext); }
|
@Test public void getFromCompletableFuture() { Assert.assertNull(ContextUtils.getFromCompletableFuture(new CompletableFuture<>())); InvocationContext context = new InvocationContext(); Assert .assertSame(context, ContextUtils.getFromCompletableFuture(new InvocationContextCompletableFuture<>(context))); }
|
public static InvocationContext getFromCompletableFuture(CompletableFuture<?> future) { if (future instanceof InvocationContextCompletableFuture) { return ((InvocationContextCompletableFuture<?>) future).getContext(); } return null; }
|
ContextUtils { public static InvocationContext getFromCompletableFuture(CompletableFuture<?> future) { if (future instanceof InvocationContextCompletableFuture) { return ((InvocationContextCompletableFuture<?>) future).getContext(); } return null; } }
|
ContextUtils { public static InvocationContext getFromCompletableFuture(CompletableFuture<?> future) { if (future instanceof InvocationContextCompletableFuture) { return ((InvocationContextCompletableFuture<?>) future).getContext(); } return null; } private ContextUtils(); }
|
ContextUtils { public static InvocationContext getFromCompletableFuture(CompletableFuture<?> future) { if (future instanceof InvocationContextCompletableFuture) { return ((InvocationContextCompletableFuture<?>) future).getContext(); } return null; } private ContextUtils(); static InvocationContext getInvocationContext(); static InvocationContext getAndRemoveInvocationContext(); static void setInvocationContext(InvocationContext invocationContext); static void removeInvocationContext(); static InvocationContext getFromCompletableFuture(CompletableFuture<?> future); }
|
ContextUtils { public static InvocationContext getFromCompletableFuture(CompletableFuture<?> future) { if (future instanceof InvocationContextCompletableFuture) { return ((InvocationContextCompletableFuture<?>) future).getContext(); } return null; } private ContextUtils(); static InvocationContext getInvocationContext(); static InvocationContext getAndRemoveInvocationContext(); static void setInvocationContext(InvocationContext invocationContext); static void removeInvocationContext(); static InvocationContext getFromCompletableFuture(CompletableFuture<?> future); }
|
@Test public void getSrcType() { Assert.assertEquals(Resource.class.getName(), converter.getSrcType().getTypeName()); }
|
@Override public Type getSrcType() { return Resource.class; }
|
ResourceToPartConverter implements Converter { @Override public Type getSrcType() { return Resource.class; } }
|
ResourceToPartConverter implements Converter { @Override public Type getSrcType() { return Resource.class; } }
|
ResourceToPartConverter implements Converter { @Override public Type getSrcType() { return Resource.class; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
ResourceToPartConverter implements Converter { @Override public Type getSrcType() { return Resource.class; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
@Test public void getTargetType() { Assert.assertEquals(Part.class.getName(), converter.getTargetType().getTypeName()); }
|
@Override public Type getTargetType() { return Part.class; }
|
ResourceToPartConverter implements Converter { @Override public Type getTargetType() { return Part.class; } }
|
ResourceToPartConverter implements Converter { @Override public Type getTargetType() { return Part.class; } }
|
ResourceToPartConverter implements Converter { @Override public Type getTargetType() { return Part.class; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
ResourceToPartConverter implements Converter { @Override public Type getTargetType() { return Part.class; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
@Test public void convert() { Object part = converter.convert(new InputStreamResource(new ByteArrayInputStream(new byte[] {}))); Assert.assertThat(part, Matchers.instanceOf(Part.class)); }
|
@Override public Object convert(Object value) { return new ResourcePart(null, (Resource) value); }
|
ResourceToPartConverter implements Converter { @Override public Object convert(Object value) { return new ResourcePart(null, (Resource) value); } }
|
ResourceToPartConverter implements Converter { @Override public Object convert(Object value) { return new ResourcePart(null, (Resource) value); } }
|
ResourceToPartConverter implements Converter { @Override public Object convert(Object value) { return new ResourcePart(null, (Resource) value); } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
ResourceToPartConverter implements Converter { @Override public Object convert(Object value) { return new ResourcePart(null, (Resource) value); } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
@Test public void getSrcType() { Assert.assertEquals("java.util.List<javax.servlet.http.Part>", converter.getSrcType().getTypeName()); }
|
@Override public Type getSrcType() { return Types.newParameterizedType(List.class, Part.class); }
|
PartListToPartArrayConverter implements Converter { @Override public Type getSrcType() { return Types.newParameterizedType(List.class, Part.class); } }
|
PartListToPartArrayConverter implements Converter { @Override public Type getSrcType() { return Types.newParameterizedType(List.class, Part.class); } }
|
PartListToPartArrayConverter implements Converter { @Override public Type getSrcType() { return Types.newParameterizedType(List.class, Part.class); } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
PartListToPartArrayConverter implements Converter { @Override public Type getSrcType() { return Types.newParameterizedType(List.class, Part.class); } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
@Test public void getTargetType() { Assert.assertEquals(Part[].class.getCanonicalName(), converter.getTargetType().getTypeName()); }
|
@Override public Type getTargetType() { return Part[].class; }
|
PartListToPartArrayConverter implements Converter { @Override public Type getTargetType() { return Part[].class; } }
|
PartListToPartArrayConverter implements Converter { @Override public Type getTargetType() { return Part[].class; } }
|
PartListToPartArrayConverter implements Converter { @Override public Type getTargetType() { return Part[].class; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
PartListToPartArrayConverter implements Converter { @Override public Type getTargetType() { return Part[].class; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
@Test public void test_findServiceInstance_whenInstanceNotExist_shouldReturnEmptyOptionalObject() { ServerUtil.microserviceInstanceMap = prepareServiceInstanceMap(false); ServerMicroserviceInstance returnedResult = target.findServiceInstance(serviceId, instanceId1); Assert.assertNull(returnedResult); }
|
public ServerMicroserviceInstance findServiceInstance(String serviceId, String instanceId) { Map<String, ServerMicroserviceInstance> serverMicroserviceInstanceMap = ServerUtil.microserviceInstanceMap .get(serviceId); if (serverMicroserviceInstanceMap == null || serverMicroserviceInstanceMap.isEmpty()) { return null; } return serverMicroserviceInstanceMap.get(instanceId); }
|
ZeroConfigRegistryService { public ServerMicroserviceInstance findServiceInstance(String serviceId, String instanceId) { Map<String, ServerMicroserviceInstance> serverMicroserviceInstanceMap = ServerUtil.microserviceInstanceMap .get(serviceId); if (serverMicroserviceInstanceMap == null || serverMicroserviceInstanceMap.isEmpty()) { return null; } return serverMicroserviceInstanceMap.get(instanceId); } }
|
ZeroConfigRegistryService { public ServerMicroserviceInstance findServiceInstance(String serviceId, String instanceId) { Map<String, ServerMicroserviceInstance> serverMicroserviceInstanceMap = ServerUtil.microserviceInstanceMap .get(serviceId); if (serverMicroserviceInstanceMap == null || serverMicroserviceInstanceMap.isEmpty()) { return null; } return serverMicroserviceInstanceMap.get(instanceId); } }
|
ZeroConfigRegistryService { public ServerMicroserviceInstance findServiceInstance(String serviceId, String instanceId) { Map<String, ServerMicroserviceInstance> serverMicroserviceInstanceMap = ServerUtil.microserviceInstanceMap .get(serviceId); if (serverMicroserviceInstanceMap == null || serverMicroserviceInstanceMap.isEmpty()) { return null; } return serverMicroserviceInstanceMap.get(instanceId); } void registerMicroserviceInstance(ServerMicroserviceInstance receivedInstance); void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance); ServerMicroserviceInstance findServiceInstance(String serviceId,
String instanceId); List<ServerMicroserviceInstance> getMicroserviceInstance(String consumerId,
String providerId); void heartbeat(ServerMicroserviceInstance receivedInstance); boolean heartbeat(String microserviceId, String microserviceInstanceId); ServerMicroserviceInstance getMicroservice(String microserviceId); List<ServerMicroserviceInstance> findServiceInstances(String appId, String serviceName); }
|
ZeroConfigRegistryService { public ServerMicroserviceInstance findServiceInstance(String serviceId, String instanceId) { Map<String, ServerMicroserviceInstance> serverMicroserviceInstanceMap = ServerUtil.microserviceInstanceMap .get(serviceId); if (serverMicroserviceInstanceMap == null || serverMicroserviceInstanceMap.isEmpty()) { return null; } return serverMicroserviceInstanceMap.get(instanceId); } void registerMicroserviceInstance(ServerMicroserviceInstance receivedInstance); void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance); ServerMicroserviceInstance findServiceInstance(String serviceId,
String instanceId); List<ServerMicroserviceInstance> getMicroserviceInstance(String consumerId,
String providerId); void heartbeat(ServerMicroserviceInstance receivedInstance); boolean heartbeat(String microserviceId, String microserviceInstanceId); ServerMicroserviceInstance getMicroservice(String microserviceId); List<ServerMicroserviceInstance> findServiceInstances(String appId, String serviceName); }
|
@Test public void convert() { Object parts = converter.convert(Arrays.asList(new FilePart("name", "file"))); Assert.assertThat(parts, Matchers.instanceOf(Part[].class)); }
|
@Override public Object convert(Object value) { if (value == null) { return null; } @SuppressWarnings("unchecked") List<Part> partList = (List<Part>) value; return partList.toArray(new Part[partList.size()]); }
|
PartListToPartArrayConverter implements Converter { @Override public Object convert(Object value) { if (value == null) { return null; } @SuppressWarnings("unchecked") List<Part> partList = (List<Part>) value; return partList.toArray(new Part[partList.size()]); } }
|
PartListToPartArrayConverter implements Converter { @Override public Object convert(Object value) { if (value == null) { return null; } @SuppressWarnings("unchecked") List<Part> partList = (List<Part>) value; return partList.toArray(new Part[partList.size()]); } }
|
PartListToPartArrayConverter implements Converter { @Override public Object convert(Object value) { if (value == null) { return null; } @SuppressWarnings("unchecked") List<Part> partList = (List<Part>) value; return partList.toArray(new Part[partList.size()]); } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
PartListToPartArrayConverter implements Converter { @Override public Object convert(Object value) { if (value == null) { return null; } @SuppressWarnings("unchecked") List<Part> partList = (List<Part>) value; return partList.toArray(new Part[partList.size()]); } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
@Test public void should_got_null_when_convert_null() { Assert.assertNull(converter.convert(null)); }
|
@Override public Object convert(Object value) { if (value == null) { return null; } @SuppressWarnings("unchecked") List<Part> partList = (List<Part>) value; return partList.toArray(new Part[partList.size()]); }
|
PartListToPartArrayConverter implements Converter { @Override public Object convert(Object value) { if (value == null) { return null; } @SuppressWarnings("unchecked") List<Part> partList = (List<Part>) value; return partList.toArray(new Part[partList.size()]); } }
|
PartListToPartArrayConverter implements Converter { @Override public Object convert(Object value) { if (value == null) { return null; } @SuppressWarnings("unchecked") List<Part> partList = (List<Part>) value; return partList.toArray(new Part[partList.size()]); } }
|
PartListToPartArrayConverter implements Converter { @Override public Object convert(Object value) { if (value == null) { return null; } @SuppressWarnings("unchecked") List<Part> partList = (List<Part>) value; return partList.toArray(new Part[partList.size()]); } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
PartListToPartArrayConverter implements Converter { @Override public Object convert(Object value) { if (value == null) { return null; } @SuppressWarnings("unchecked") List<Part> partList = (List<Part>) value; return partList.toArray(new Part[partList.size()]); } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
@Test public void getSrcType() { Assert.assertEquals(File.class.getName(), converter.getSrcType().getTypeName()); }
|
@Override public Type getSrcType() { return File.class; }
|
FileToPartConverter implements Converter { @Override public Type getSrcType() { return File.class; } }
|
FileToPartConverter implements Converter { @Override public Type getSrcType() { return File.class; } }
|
FileToPartConverter implements Converter { @Override public Type getSrcType() { return File.class; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
FileToPartConverter implements Converter { @Override public Type getSrcType() { return File.class; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
@Test public void getTargetType() { Assert.assertEquals(Part.class.getName(), converter.getTargetType().getTypeName()); }
|
@Override public Type getTargetType() { return Part.class; }
|
FileToPartConverter implements Converter { @Override public Type getTargetType() { return Part.class; } }
|
FileToPartConverter implements Converter { @Override public Type getTargetType() { return Part.class; } }
|
FileToPartConverter implements Converter { @Override public Type getTargetType() { return Part.class; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
FileToPartConverter implements Converter { @Override public Type getTargetType() { return Part.class; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
@Test public void convert() { File file = new File("abc"); Object part = converter.convert(file); Assert.assertThat(part, Matchers.instanceOf(Part.class)); }
|
@Override public Object convert(Object value) { return new FilePart(null, (File) value); }
|
FileToPartConverter implements Converter { @Override public Object convert(Object value) { return new FilePart(null, (File) value); } }
|
FileToPartConverter implements Converter { @Override public Object convert(Object value) { return new FilePart(null, (File) value); } }
|
FileToPartConverter implements Converter { @Override public Object convert(Object value) { return new FilePart(null, (File) value); } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
FileToPartConverter implements Converter { @Override public Object convert(Object value) { return new FilePart(null, (File) value); } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
@Test public void getSrcType() { Assert.assertEquals(InputStream.class.getName(), converter.getSrcType().getTypeName()); }
|
@Override public Type getSrcType() { return InputStream.class; }
|
InputStreamToPartConverter implements Converter { @Override public Type getSrcType() { return InputStream.class; } }
|
InputStreamToPartConverter implements Converter { @Override public Type getSrcType() { return InputStream.class; } }
|
InputStreamToPartConverter implements Converter { @Override public Type getSrcType() { return InputStream.class; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
InputStreamToPartConverter implements Converter { @Override public Type getSrcType() { return InputStream.class; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
@Test public void getTargetType() { Assert.assertEquals(Part.class.getName(), converter.getTargetType().getTypeName()); }
|
@Override public Type getTargetType() { return Part.class; }
|
InputStreamToPartConverter implements Converter { @Override public Type getTargetType() { return Part.class; } }
|
InputStreamToPartConverter implements Converter { @Override public Type getTargetType() { return Part.class; } }
|
InputStreamToPartConverter implements Converter { @Override public Type getTargetType() { return Part.class; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
InputStreamToPartConverter implements Converter { @Override public Type getTargetType() { return Part.class; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
@Test public void convert() { Object part = converter.convert(new ByteArrayInputStream(new byte[] {})); Assert.assertThat(part, Matchers.instanceOf(Part.class)); }
|
@Override public Object convert(Object value) { return new InputStreamPart(null, (InputStream) value); }
|
InputStreamToPartConverter implements Converter { @Override public Object convert(Object value) { return new InputStreamPart(null, (InputStream) value); } }
|
InputStreamToPartConverter implements Converter { @Override public Object convert(Object value) { return new InputStreamPart(null, (InputStream) value); } }
|
InputStreamToPartConverter implements Converter { @Override public Object convert(Object value) { return new InputStreamPart(null, (InputStream) value); } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
InputStreamToPartConverter implements Converter { @Override public Object convert(Object value) { return new InputStreamPart(null, (InputStream) value); } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
@Test public void getSrcType() { Assert.assertEquals(Part.class.getName(), converter.getSrcType().getTypeName()); }
|
@Override public Type getSrcType() { return Part.class; }
|
PartToPartConverter implements Converter { @Override public Type getSrcType() { return Part.class; } }
|
PartToPartConverter implements Converter { @Override public Type getSrcType() { return Part.class; } }
|
PartToPartConverter implements Converter { @Override public Type getSrcType() { return Part.class; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
PartToPartConverter implements Converter { @Override public Type getSrcType() { return Part.class; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
@Test public void getTargetType() { Assert.assertEquals(Part.class.getName(), converter.getTargetType().getTypeName()); }
|
@Override public Type getTargetType() { return Part.class; }
|
PartToPartConverter implements Converter { @Override public Type getTargetType() { return Part.class; } }
|
PartToPartConverter implements Converter { @Override public Type getTargetType() { return Part.class; } }
|
PartToPartConverter implements Converter { @Override public Type getTargetType() { return Part.class; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
PartToPartConverter implements Converter { @Override public Type getTargetType() { return Part.class; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
@Test(expected = IllegalArgumentException.class) public void test_getMicroserviceInstance_whenServiceHasNoInstance_shouldThrowIllegalArgumentException() { ServerUtil.microserviceInstanceMap = prepareServiceInstanceMapWihtoutInstance(); target.getMicroserviceInstance(serviceId, serviceId); }
|
public List<ServerMicroserviceInstance> getMicroserviceInstance(String consumerId, String providerId) { Map<String, ServerMicroserviceInstance> instanceIdMap = ServerUtil.microserviceInstanceMap .get(providerId); if (instanceIdMap == null || instanceIdMap.isEmpty()) { throw new IllegalArgumentException("Invalid serviceId, serviceId=" + providerId); } return new ArrayList<>(instanceIdMap.values()); }
|
ZeroConfigRegistryService { public List<ServerMicroserviceInstance> getMicroserviceInstance(String consumerId, String providerId) { Map<String, ServerMicroserviceInstance> instanceIdMap = ServerUtil.microserviceInstanceMap .get(providerId); if (instanceIdMap == null || instanceIdMap.isEmpty()) { throw new IllegalArgumentException("Invalid serviceId, serviceId=" + providerId); } return new ArrayList<>(instanceIdMap.values()); } }
|
ZeroConfigRegistryService { public List<ServerMicroserviceInstance> getMicroserviceInstance(String consumerId, String providerId) { Map<String, ServerMicroserviceInstance> instanceIdMap = ServerUtil.microserviceInstanceMap .get(providerId); if (instanceIdMap == null || instanceIdMap.isEmpty()) { throw new IllegalArgumentException("Invalid serviceId, serviceId=" + providerId); } return new ArrayList<>(instanceIdMap.values()); } }
|
ZeroConfigRegistryService { public List<ServerMicroserviceInstance> getMicroserviceInstance(String consumerId, String providerId) { Map<String, ServerMicroserviceInstance> instanceIdMap = ServerUtil.microserviceInstanceMap .get(providerId); if (instanceIdMap == null || instanceIdMap.isEmpty()) { throw new IllegalArgumentException("Invalid serviceId, serviceId=" + providerId); } return new ArrayList<>(instanceIdMap.values()); } void registerMicroserviceInstance(ServerMicroserviceInstance receivedInstance); void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance); ServerMicroserviceInstance findServiceInstance(String serviceId,
String instanceId); List<ServerMicroserviceInstance> getMicroserviceInstance(String consumerId,
String providerId); void heartbeat(ServerMicroserviceInstance receivedInstance); boolean heartbeat(String microserviceId, String microserviceInstanceId); ServerMicroserviceInstance getMicroservice(String microserviceId); List<ServerMicroserviceInstance> findServiceInstances(String appId, String serviceName); }
|
ZeroConfigRegistryService { public List<ServerMicroserviceInstance> getMicroserviceInstance(String consumerId, String providerId) { Map<String, ServerMicroserviceInstance> instanceIdMap = ServerUtil.microserviceInstanceMap .get(providerId); if (instanceIdMap == null || instanceIdMap.isEmpty()) { throw new IllegalArgumentException("Invalid serviceId, serviceId=" + providerId); } return new ArrayList<>(instanceIdMap.values()); } void registerMicroserviceInstance(ServerMicroserviceInstance receivedInstance); void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance); ServerMicroserviceInstance findServiceInstance(String serviceId,
String instanceId); List<ServerMicroserviceInstance> getMicroserviceInstance(String consumerId,
String providerId); void heartbeat(ServerMicroserviceInstance receivedInstance); boolean heartbeat(String microserviceId, String microserviceInstanceId); ServerMicroserviceInstance getMicroservice(String microserviceId); List<ServerMicroserviceInstance> findServiceInstances(String appId, String serviceName); }
|
@Test public void convert() { Part part = new FilePart("name", "file"); Assert.assertSame(part, converter.convert(part)); }
|
@Override public Object convert(Object value) { return value; }
|
PartToPartConverter implements Converter { @Override public Object convert(Object value) { return value; } }
|
PartToPartConverter implements Converter { @Override public Object convert(Object value) { return value; } }
|
PartToPartConverter implements Converter { @Override public Object convert(Object value) { return value; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
PartToPartConverter implements Converter { @Override public Object convert(Object value) { return value; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
@Test public void getSrcType() { Assert.assertEquals("java.util.List<javax.servlet.http.Part>", converter.getSrcType().getTypeName()); }
|
@Override public Type getSrcType() { return Types.newParameterizedType(List.class, Part.class); }
|
PartListToPartListConverter implements Converter { @Override public Type getSrcType() { return Types.newParameterizedType(List.class, Part.class); } }
|
PartListToPartListConverter implements Converter { @Override public Type getSrcType() { return Types.newParameterizedType(List.class, Part.class); } }
|
PartListToPartListConverter implements Converter { @Override public Type getSrcType() { return Types.newParameterizedType(List.class, Part.class); } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
PartListToPartListConverter implements Converter { @Override public Type getSrcType() { return Types.newParameterizedType(List.class, Part.class); } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
@Test public void getTargetType() { Assert.assertEquals("java.util.List<javax.servlet.http.Part>", converter.getTargetType().getTypeName()); }
|
@Override public Type getTargetType() { return Types.newParameterizedType(List.class, Part.class); }
|
PartListToPartListConverter implements Converter { @Override public Type getTargetType() { return Types.newParameterizedType(List.class, Part.class); } }
|
PartListToPartListConverter implements Converter { @Override public Type getTargetType() { return Types.newParameterizedType(List.class, Part.class); } }
|
PartListToPartListConverter implements Converter { @Override public Type getTargetType() { return Types.newParameterizedType(List.class, Part.class); } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
PartListToPartListConverter implements Converter { @Override public Type getTargetType() { return Types.newParameterizedType(List.class, Part.class); } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
@Test public void convert() { List<Part> parts = Arrays.asList(new FilePart("name", "file")); Assert.assertSame(parts, converter.convert(parts)); }
|
@Override public Object convert(Object value) { return value; }
|
PartListToPartListConverter implements Converter { @Override public Object convert(Object value) { return value; } }
|
PartListToPartListConverter implements Converter { @Override public Object convert(Object value) { return value; } }
|
PartListToPartListConverter implements Converter { @Override public Object convert(Object value) { return value; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
PartListToPartListConverter implements Converter { @Override public Object convert(Object value) { return value; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }
|
@Test public void createConsumer_consumerMethodSetBigger() { Swagger swagger = SwaggerGenerator.generate(ContractIntf.class); SwaggerConsumer swaggerConsumer = env.createConsumer(ConsumerIntf.class, swagger); Assert.assertNotNull(swaggerConsumer.findOperation("exist")); Assert.assertNull(swaggerConsumer.findOperation("notExist")); }
|
public SwaggerConsumer createConsumer(Class<?> consumerIntf, Swagger swagger) { Map<Class<?>, ContextArgumentMapperFactory> contextFactorys = SPIServiceUtils .getOrLoadSortedService(ConsumerContextArgumentMapperFactory.class) .stream() .collect(Collectors.toMap(ConsumerContextArgumentMapperFactory::getContextClass, Function.identity())); ResponseMapperFactorys<ConsumerResponseMapper> consumerResponseMapperFactorys = new ResponseMapperFactorys<>(ConsumerResponseMapperFactory.class); SwaggerOperations swaggerOperations = new SwaggerOperations(swagger); SwaggerConsumer consumer = new SwaggerConsumer(); consumer.setConsumerIntf(consumerIntf); for (Method consumerMethod : MethodUtils.findSwaggerMethods(consumerIntf)) { String operationId = findOperationId(consumerMethod); SwaggerOperation swaggerOperation = swaggerOperations.findOperation(operationId); if (swaggerOperation == null) { LOGGER.warn("consumer method {}:{} not exist in contract.", consumerIntf.getName(), consumerMethod.getName()); continue; } ConsumerArgumentsMapperCreator creator = new ConsumerArgumentsMapperCreator( Json.mapper().getSerializationConfig(), contextFactorys, consumerIntf, consumerMethod, swaggerOperation); ArgumentsMapper argsMapper = creator.createArgumentsMapper(); ConsumerResponseMapper responseMapper = consumerResponseMapperFactorys .createResponseMapper(consumerMethod.getGenericReturnType()); SwaggerConsumerOperation op = new SwaggerConsumerOperation(); op.setConsumerClass(consumerIntf); op.setConsumerMethod(consumerMethod); op.setSwaggerOperation(swaggerOperation); op.setArgumentsMapper(argsMapper); op.setResponseMapper(responseMapper); consumer.addOperation(op); } return consumer; }
|
SwaggerEnvironment { public SwaggerConsumer createConsumer(Class<?> consumerIntf, Swagger swagger) { Map<Class<?>, ContextArgumentMapperFactory> contextFactorys = SPIServiceUtils .getOrLoadSortedService(ConsumerContextArgumentMapperFactory.class) .stream() .collect(Collectors.toMap(ConsumerContextArgumentMapperFactory::getContextClass, Function.identity())); ResponseMapperFactorys<ConsumerResponseMapper> consumerResponseMapperFactorys = new ResponseMapperFactorys<>(ConsumerResponseMapperFactory.class); SwaggerOperations swaggerOperations = new SwaggerOperations(swagger); SwaggerConsumer consumer = new SwaggerConsumer(); consumer.setConsumerIntf(consumerIntf); for (Method consumerMethod : MethodUtils.findSwaggerMethods(consumerIntf)) { String operationId = findOperationId(consumerMethod); SwaggerOperation swaggerOperation = swaggerOperations.findOperation(operationId); if (swaggerOperation == null) { LOGGER.warn("consumer method {}:{} not exist in contract.", consumerIntf.getName(), consumerMethod.getName()); continue; } ConsumerArgumentsMapperCreator creator = new ConsumerArgumentsMapperCreator( Json.mapper().getSerializationConfig(), contextFactorys, consumerIntf, consumerMethod, swaggerOperation); ArgumentsMapper argsMapper = creator.createArgumentsMapper(); ConsumerResponseMapper responseMapper = consumerResponseMapperFactorys .createResponseMapper(consumerMethod.getGenericReturnType()); SwaggerConsumerOperation op = new SwaggerConsumerOperation(); op.setConsumerClass(consumerIntf); op.setConsumerMethod(consumerMethod); op.setSwaggerOperation(swaggerOperation); op.setArgumentsMapper(argsMapper); op.setResponseMapper(responseMapper); consumer.addOperation(op); } return consumer; } }
|
SwaggerEnvironment { public SwaggerConsumer createConsumer(Class<?> consumerIntf, Swagger swagger) { Map<Class<?>, ContextArgumentMapperFactory> contextFactorys = SPIServiceUtils .getOrLoadSortedService(ConsumerContextArgumentMapperFactory.class) .stream() .collect(Collectors.toMap(ConsumerContextArgumentMapperFactory::getContextClass, Function.identity())); ResponseMapperFactorys<ConsumerResponseMapper> consumerResponseMapperFactorys = new ResponseMapperFactorys<>(ConsumerResponseMapperFactory.class); SwaggerOperations swaggerOperations = new SwaggerOperations(swagger); SwaggerConsumer consumer = new SwaggerConsumer(); consumer.setConsumerIntf(consumerIntf); for (Method consumerMethod : MethodUtils.findSwaggerMethods(consumerIntf)) { String operationId = findOperationId(consumerMethod); SwaggerOperation swaggerOperation = swaggerOperations.findOperation(operationId); if (swaggerOperation == null) { LOGGER.warn("consumer method {}:{} not exist in contract.", consumerIntf.getName(), consumerMethod.getName()); continue; } ConsumerArgumentsMapperCreator creator = new ConsumerArgumentsMapperCreator( Json.mapper().getSerializationConfig(), contextFactorys, consumerIntf, consumerMethod, swaggerOperation); ArgumentsMapper argsMapper = creator.createArgumentsMapper(); ConsumerResponseMapper responseMapper = consumerResponseMapperFactorys .createResponseMapper(consumerMethod.getGenericReturnType()); SwaggerConsumerOperation op = new SwaggerConsumerOperation(); op.setConsumerClass(consumerIntf); op.setConsumerMethod(consumerMethod); op.setSwaggerOperation(swaggerOperation); op.setArgumentsMapper(argsMapper); op.setResponseMapper(responseMapper); consumer.addOperation(op); } return consumer; } }
|
SwaggerEnvironment { public SwaggerConsumer createConsumer(Class<?> consumerIntf, Swagger swagger) { Map<Class<?>, ContextArgumentMapperFactory> contextFactorys = SPIServiceUtils .getOrLoadSortedService(ConsumerContextArgumentMapperFactory.class) .stream() .collect(Collectors.toMap(ConsumerContextArgumentMapperFactory::getContextClass, Function.identity())); ResponseMapperFactorys<ConsumerResponseMapper> consumerResponseMapperFactorys = new ResponseMapperFactorys<>(ConsumerResponseMapperFactory.class); SwaggerOperations swaggerOperations = new SwaggerOperations(swagger); SwaggerConsumer consumer = new SwaggerConsumer(); consumer.setConsumerIntf(consumerIntf); for (Method consumerMethod : MethodUtils.findSwaggerMethods(consumerIntf)) { String operationId = findOperationId(consumerMethod); SwaggerOperation swaggerOperation = swaggerOperations.findOperation(operationId); if (swaggerOperation == null) { LOGGER.warn("consumer method {}:{} not exist in contract.", consumerIntf.getName(), consumerMethod.getName()); continue; } ConsumerArgumentsMapperCreator creator = new ConsumerArgumentsMapperCreator( Json.mapper().getSerializationConfig(), contextFactorys, consumerIntf, consumerMethod, swaggerOperation); ArgumentsMapper argsMapper = creator.createArgumentsMapper(); ConsumerResponseMapper responseMapper = consumerResponseMapperFactorys .createResponseMapper(consumerMethod.getGenericReturnType()); SwaggerConsumerOperation op = new SwaggerConsumerOperation(); op.setConsumerClass(consumerIntf); op.setConsumerMethod(consumerMethod); op.setSwaggerOperation(swaggerOperation); op.setArgumentsMapper(argsMapper); op.setResponseMapper(responseMapper); consumer.addOperation(op); } return consumer; } SwaggerConsumer createConsumer(Class<?> consumerIntf, Swagger swagger); SwaggerProducer createProducer(Object producerInstance, Swagger swagger); SwaggerProducer createProducer(Object producerInstance, Class<?> schemaInterface, Swagger swagger); }
|
SwaggerEnvironment { public SwaggerConsumer createConsumer(Class<?> consumerIntf, Swagger swagger) { Map<Class<?>, ContextArgumentMapperFactory> contextFactorys = SPIServiceUtils .getOrLoadSortedService(ConsumerContextArgumentMapperFactory.class) .stream() .collect(Collectors.toMap(ConsumerContextArgumentMapperFactory::getContextClass, Function.identity())); ResponseMapperFactorys<ConsumerResponseMapper> consumerResponseMapperFactorys = new ResponseMapperFactorys<>(ConsumerResponseMapperFactory.class); SwaggerOperations swaggerOperations = new SwaggerOperations(swagger); SwaggerConsumer consumer = new SwaggerConsumer(); consumer.setConsumerIntf(consumerIntf); for (Method consumerMethod : MethodUtils.findSwaggerMethods(consumerIntf)) { String operationId = findOperationId(consumerMethod); SwaggerOperation swaggerOperation = swaggerOperations.findOperation(operationId); if (swaggerOperation == null) { LOGGER.warn("consumer method {}:{} not exist in contract.", consumerIntf.getName(), consumerMethod.getName()); continue; } ConsumerArgumentsMapperCreator creator = new ConsumerArgumentsMapperCreator( Json.mapper().getSerializationConfig(), contextFactorys, consumerIntf, consumerMethod, swaggerOperation); ArgumentsMapper argsMapper = creator.createArgumentsMapper(); ConsumerResponseMapper responseMapper = consumerResponseMapperFactorys .createResponseMapper(consumerMethod.getGenericReturnType()); SwaggerConsumerOperation op = new SwaggerConsumerOperation(); op.setConsumerClass(consumerIntf); op.setConsumerMethod(consumerMethod); op.setSwaggerOperation(swaggerOperation); op.setArgumentsMapper(argsMapper); op.setResponseMapper(responseMapper); consumer.addOperation(op); } return consumer; } SwaggerConsumer createConsumer(Class<?> consumerIntf, Swagger swagger); SwaggerProducer createProducer(Object producerInstance, Swagger swagger); SwaggerProducer createProducer(Object producerInstance, Class<?> schemaInterface, Swagger swagger); }
|
@Test public void testConfiguration() { DefaultDeploymentProvider.setConfiguration(ConfigUtil.createLocalConfig()); SystemBootstrapInfo info = Deployment.getSystemBootStrapInfo(DeploymentProvider.SYSTEM_KEY_SERVICE_CENTER); Assert.assertEquals(info.getAccessURL().get(0), "http: info = Deployment.getSystemBootStrapInfo(DeploymentProvider.SYSTEM_KEY_CONFIG_CENTER); Assert.assertEquals(info.getAccessURL().get(0), "http: Assert.assertNull(Deployment.getSystemBootStrapInfo("wrong")); }
|
public static SystemBootstrapInfo getSystemBootStrapInfo(String systemKey) { for (DeploymentProvider provider : providerList) { if (provider.getSystemBootStrapInfo(systemKey) != null) { return provider.getSystemBootStrapInfo(systemKey); } } return null; }
|
Deployment { public static SystemBootstrapInfo getSystemBootStrapInfo(String systemKey) { for (DeploymentProvider provider : providerList) { if (provider.getSystemBootStrapInfo(systemKey) != null) { return provider.getSystemBootStrapInfo(systemKey); } } return null; } }
|
Deployment { public static SystemBootstrapInfo getSystemBootStrapInfo(String systemKey) { for (DeploymentProvider provider : providerList) { if (provider.getSystemBootStrapInfo(systemKey) != null) { return provider.getSystemBootStrapInfo(systemKey); } } return null; } }
|
Deployment { public static SystemBootstrapInfo getSystemBootStrapInfo(String systemKey) { for (DeploymentProvider provider : providerList) { if (provider.getSystemBootStrapInfo(systemKey) != null) { return provider.getSystemBootStrapInfo(systemKey); } } return null; } static SystemBootstrapInfo getSystemBootStrapInfo(String systemKey); }
|
Deployment { public static SystemBootstrapInfo getSystemBootStrapInfo(String systemKey) { for (DeploymentProvider provider : providerList) { if (provider.getSystemBootStrapInfo(systemKey) != null) { return provider.getSystemBootStrapInfo(systemKey); } } return null; } static SystemBootstrapInfo getSystemBootStrapInfo(String systemKey); }
|
@Test public void testConfigurationEnv() { System.setProperty("servicecomb.service.registry.address", "https: System.setProperty("servicecomb.config.client.serverUri", "https: DefaultDeploymentProvider.setConfiguration(ConfigUtil.createLocalConfig()); SystemBootstrapInfo info = Deployment.getSystemBootStrapInfo(DeploymentProvider.SYSTEM_KEY_SERVICE_CENTER); Assert.assertEquals(info.getAccessURL().get(0), "https: info = Deployment.getSystemBootStrapInfo(DeploymentProvider.SYSTEM_KEY_CONFIG_CENTER); Assert.assertEquals(info.getAccessURL().get(0), "http: System.getProperties().remove("servicecomb.service.registry.address"); System.getProperties().remove("servicecomb.config.client.serverUri"); }
|
public static SystemBootstrapInfo getSystemBootStrapInfo(String systemKey) { for (DeploymentProvider provider : providerList) { if (provider.getSystemBootStrapInfo(systemKey) != null) { return provider.getSystemBootStrapInfo(systemKey); } } return null; }
|
Deployment { public static SystemBootstrapInfo getSystemBootStrapInfo(String systemKey) { for (DeploymentProvider provider : providerList) { if (provider.getSystemBootStrapInfo(systemKey) != null) { return provider.getSystemBootStrapInfo(systemKey); } } return null; } }
|
Deployment { public static SystemBootstrapInfo getSystemBootStrapInfo(String systemKey) { for (DeploymentProvider provider : providerList) { if (provider.getSystemBootStrapInfo(systemKey) != null) { return provider.getSystemBootStrapInfo(systemKey); } } return null; } }
|
Deployment { public static SystemBootstrapInfo getSystemBootStrapInfo(String systemKey) { for (DeploymentProvider provider : providerList) { if (provider.getSystemBootStrapInfo(systemKey) != null) { return provider.getSystemBootStrapInfo(systemKey); } } return null; } static SystemBootstrapInfo getSystemBootStrapInfo(String systemKey); }
|
Deployment { public static SystemBootstrapInfo getSystemBootStrapInfo(String systemKey) { for (DeploymentProvider provider : providerList) { if (provider.getSystemBootStrapInfo(systemKey) != null) { return provider.getSystemBootStrapInfo(systemKey); } } return null; } static SystemBootstrapInfo getSystemBootStrapInfo(String systemKey); }
|
@Test public void testConfigurationEnvTwo() { System.setProperty("servicecomb.service.registry.address", "https: System.setProperty("servicecomb.config.client.serverUri", "https: DefaultDeploymentProvider.setConfiguration(ConfigUtil.createLocalConfig()); SystemBootstrapInfo info = Deployment.getSystemBootStrapInfo(DeploymentProvider.SYSTEM_KEY_SERVICE_CENTER); Assert.assertEquals(info.getAccessURL().size(), 2); Assert.assertEquals(info.getAccessURL().get(0), "https: Assert.assertEquals(info.getAccessURL().get(1), "https: info = Deployment.getSystemBootStrapInfo(DeploymentProvider.SYSTEM_KEY_CONFIG_CENTER); Assert.assertEquals(info.getAccessURL().get(0), "http: Assert.assertEquals(info.getAccessURL().size(), 1); System.getProperties().remove("servicecomb.service.registry.address"); System.getProperties().remove("servicecomb.config.client.serverUri"); }
|
public static SystemBootstrapInfo getSystemBootStrapInfo(String systemKey) { for (DeploymentProvider provider : providerList) { if (provider.getSystemBootStrapInfo(systemKey) != null) { return provider.getSystemBootStrapInfo(systemKey); } } return null; }
|
Deployment { public static SystemBootstrapInfo getSystemBootStrapInfo(String systemKey) { for (DeploymentProvider provider : providerList) { if (provider.getSystemBootStrapInfo(systemKey) != null) { return provider.getSystemBootStrapInfo(systemKey); } } return null; } }
|
Deployment { public static SystemBootstrapInfo getSystemBootStrapInfo(String systemKey) { for (DeploymentProvider provider : providerList) { if (provider.getSystemBootStrapInfo(systemKey) != null) { return provider.getSystemBootStrapInfo(systemKey); } } return null; } }
|
Deployment { public static SystemBootstrapInfo getSystemBootStrapInfo(String systemKey) { for (DeploymentProvider provider : providerList) { if (provider.getSystemBootStrapInfo(systemKey) != null) { return provider.getSystemBootStrapInfo(systemKey); } } return null; } static SystemBootstrapInfo getSystemBootStrapInfo(String systemKey); }
|
Deployment { public static SystemBootstrapInfo getSystemBootStrapInfo(String systemKey) { for (DeploymentProvider provider : providerList) { if (provider.getSystemBootStrapInfo(systemKey) != null) { return provider.getSystemBootStrapInfo(systemKey); } } return null; } static SystemBootstrapInfo getSystemBootStrapInfo(String systemKey); }
|
@Test public void testCreate() throws Exception { ApolloConfigurationSourceImpl apolloConfigurationSource = new ApolloConfigurationSourceImpl(); apolloConfigurationSource.addUpdateListener(result -> Assert.assertTrue(!result.getAdded().isEmpty())); UpdateHandler udateHandler = Deencapsulation.getField(apolloConfigurationSource, UpdateHandler.class); Map<String, Object> createItems = new HashMap<>(); createItems.put("testKey", "testValue"); udateHandler.handle(CREATE, createItems); }
|
@Override public void addUpdateListener(WatchedUpdateListener watchedUpdateListener) { listeners.add(watchedUpdateListener); }
|
ApolloConfigurationSourceImpl implements ConfigCenterConfigurationSource { @Override public void addUpdateListener(WatchedUpdateListener watchedUpdateListener) { listeners.add(watchedUpdateListener); } }
|
ApolloConfigurationSourceImpl implements ConfigCenterConfigurationSource { @Override public void addUpdateListener(WatchedUpdateListener watchedUpdateListener) { listeners.add(watchedUpdateListener); } ApolloConfigurationSourceImpl(); }
|
ApolloConfigurationSourceImpl implements ConfigCenterConfigurationSource { @Override public void addUpdateListener(WatchedUpdateListener watchedUpdateListener) { listeners.add(watchedUpdateListener); } ApolloConfigurationSourceImpl(); @Override boolean isValidSource(Configuration localConfiguration); @Override void init(Configuration localConfiguration); @Override void addUpdateListener(WatchedUpdateListener watchedUpdateListener); @Override void removeUpdateListener(WatchedUpdateListener watchedUpdateListener); @Override Map<String, Object> getCurrentData(); List<WatchedUpdateListener> getCurrentListeners(); }
|
ApolloConfigurationSourceImpl implements ConfigCenterConfigurationSource { @Override public void addUpdateListener(WatchedUpdateListener watchedUpdateListener) { listeners.add(watchedUpdateListener); } ApolloConfigurationSourceImpl(); @Override boolean isValidSource(Configuration localConfiguration); @Override void init(Configuration localConfiguration); @Override void addUpdateListener(WatchedUpdateListener watchedUpdateListener); @Override void removeUpdateListener(WatchedUpdateListener watchedUpdateListener); @Override Map<String, Object> getCurrentData(); List<WatchedUpdateListener> getCurrentListeners(); }
|
@Test public void testUpdate() throws Exception { ApolloConfigurationSourceImpl apolloConfigurationSource = new ApolloConfigurationSourceImpl(); apolloConfigurationSource.addUpdateListener(result -> Assert.assertTrue(!result.getChanged().isEmpty())); UpdateHandler udateHandler = Deencapsulation.getField(apolloConfigurationSource, UpdateHandler.class); Map<String, Object> updateItems = new HashMap<>(); updateItems.put("testKey", "testValue"); udateHandler.handle(SET, updateItems); }
|
@Override public void addUpdateListener(WatchedUpdateListener watchedUpdateListener) { listeners.add(watchedUpdateListener); }
|
ApolloConfigurationSourceImpl implements ConfigCenterConfigurationSource { @Override public void addUpdateListener(WatchedUpdateListener watchedUpdateListener) { listeners.add(watchedUpdateListener); } }
|
ApolloConfigurationSourceImpl implements ConfigCenterConfigurationSource { @Override public void addUpdateListener(WatchedUpdateListener watchedUpdateListener) { listeners.add(watchedUpdateListener); } ApolloConfigurationSourceImpl(); }
|
ApolloConfigurationSourceImpl implements ConfigCenterConfigurationSource { @Override public void addUpdateListener(WatchedUpdateListener watchedUpdateListener) { listeners.add(watchedUpdateListener); } ApolloConfigurationSourceImpl(); @Override boolean isValidSource(Configuration localConfiguration); @Override void init(Configuration localConfiguration); @Override void addUpdateListener(WatchedUpdateListener watchedUpdateListener); @Override void removeUpdateListener(WatchedUpdateListener watchedUpdateListener); @Override Map<String, Object> getCurrentData(); List<WatchedUpdateListener> getCurrentListeners(); }
|
ApolloConfigurationSourceImpl implements ConfigCenterConfigurationSource { @Override public void addUpdateListener(WatchedUpdateListener watchedUpdateListener) { listeners.add(watchedUpdateListener); } ApolloConfigurationSourceImpl(); @Override boolean isValidSource(Configuration localConfiguration); @Override void init(Configuration localConfiguration); @Override void addUpdateListener(WatchedUpdateListener watchedUpdateListener); @Override void removeUpdateListener(WatchedUpdateListener watchedUpdateListener); @Override Map<String, Object> getCurrentData(); List<WatchedUpdateListener> getCurrentListeners(); }
|
@Test public void test_getMicroserviceInstance_whenServiceHasInstance_shouldReturnAllInstances() { ServerUtil.microserviceInstanceMap = prepareServiceInstanceMap(true); List<ServerMicroserviceInstance> returnedResult = target .getMicroserviceInstance(serviceId, serviceId); Assert.assertNotNull(returnedResult); Assert.assertEquals(2, returnedResult.size()); }
|
public List<ServerMicroserviceInstance> getMicroserviceInstance(String consumerId, String providerId) { Map<String, ServerMicroserviceInstance> instanceIdMap = ServerUtil.microserviceInstanceMap .get(providerId); if (instanceIdMap == null || instanceIdMap.isEmpty()) { throw new IllegalArgumentException("Invalid serviceId, serviceId=" + providerId); } return new ArrayList<>(instanceIdMap.values()); }
|
ZeroConfigRegistryService { public List<ServerMicroserviceInstance> getMicroserviceInstance(String consumerId, String providerId) { Map<String, ServerMicroserviceInstance> instanceIdMap = ServerUtil.microserviceInstanceMap .get(providerId); if (instanceIdMap == null || instanceIdMap.isEmpty()) { throw new IllegalArgumentException("Invalid serviceId, serviceId=" + providerId); } return new ArrayList<>(instanceIdMap.values()); } }
|
ZeroConfigRegistryService { public List<ServerMicroserviceInstance> getMicroserviceInstance(String consumerId, String providerId) { Map<String, ServerMicroserviceInstance> instanceIdMap = ServerUtil.microserviceInstanceMap .get(providerId); if (instanceIdMap == null || instanceIdMap.isEmpty()) { throw new IllegalArgumentException("Invalid serviceId, serviceId=" + providerId); } return new ArrayList<>(instanceIdMap.values()); } }
|
ZeroConfigRegistryService { public List<ServerMicroserviceInstance> getMicroserviceInstance(String consumerId, String providerId) { Map<String, ServerMicroserviceInstance> instanceIdMap = ServerUtil.microserviceInstanceMap .get(providerId); if (instanceIdMap == null || instanceIdMap.isEmpty()) { throw new IllegalArgumentException("Invalid serviceId, serviceId=" + providerId); } return new ArrayList<>(instanceIdMap.values()); } void registerMicroserviceInstance(ServerMicroserviceInstance receivedInstance); void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance); ServerMicroserviceInstance findServiceInstance(String serviceId,
String instanceId); List<ServerMicroserviceInstance> getMicroserviceInstance(String consumerId,
String providerId); void heartbeat(ServerMicroserviceInstance receivedInstance); boolean heartbeat(String microserviceId, String microserviceInstanceId); ServerMicroserviceInstance getMicroservice(String microserviceId); List<ServerMicroserviceInstance> findServiceInstances(String appId, String serviceName); }
|
ZeroConfigRegistryService { public List<ServerMicroserviceInstance> getMicroserviceInstance(String consumerId, String providerId) { Map<String, ServerMicroserviceInstance> instanceIdMap = ServerUtil.microserviceInstanceMap .get(providerId); if (instanceIdMap == null || instanceIdMap.isEmpty()) { throw new IllegalArgumentException("Invalid serviceId, serviceId=" + providerId); } return new ArrayList<>(instanceIdMap.values()); } void registerMicroserviceInstance(ServerMicroserviceInstance receivedInstance); void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance); ServerMicroserviceInstance findServiceInstance(String serviceId,
String instanceId); List<ServerMicroserviceInstance> getMicroserviceInstance(String consumerId,
String providerId); void heartbeat(ServerMicroserviceInstance receivedInstance); boolean heartbeat(String microserviceId, String microserviceInstanceId); ServerMicroserviceInstance getMicroservice(String microserviceId); List<ServerMicroserviceInstance> findServiceInstances(String appId, String serviceName); }
|
@Test public void testRemoveUpdateListener() { ApolloConfigurationSourceImpl apolloConfigurationSource = new ApolloConfigurationSourceImpl(); WatchedUpdateListener watchedUpdateListener = Mockito.mock(WatchedUpdateListener.class); apolloConfigurationSource.addUpdateListener(watchedUpdateListener); apolloConfigurationSource.removeUpdateListener(watchedUpdateListener); Assert.assertTrue(apolloConfigurationSource.getCurrentListeners().isEmpty()); }
|
@Override public void removeUpdateListener(WatchedUpdateListener watchedUpdateListener) { listeners.remove(watchedUpdateListener); }
|
ApolloConfigurationSourceImpl implements ConfigCenterConfigurationSource { @Override public void removeUpdateListener(WatchedUpdateListener watchedUpdateListener) { listeners.remove(watchedUpdateListener); } }
|
ApolloConfigurationSourceImpl implements ConfigCenterConfigurationSource { @Override public void removeUpdateListener(WatchedUpdateListener watchedUpdateListener) { listeners.remove(watchedUpdateListener); } ApolloConfigurationSourceImpl(); }
|
ApolloConfigurationSourceImpl implements ConfigCenterConfigurationSource { @Override public void removeUpdateListener(WatchedUpdateListener watchedUpdateListener) { listeners.remove(watchedUpdateListener); } ApolloConfigurationSourceImpl(); @Override boolean isValidSource(Configuration localConfiguration); @Override void init(Configuration localConfiguration); @Override void addUpdateListener(WatchedUpdateListener watchedUpdateListener); @Override void removeUpdateListener(WatchedUpdateListener watchedUpdateListener); @Override Map<String, Object> getCurrentData(); List<WatchedUpdateListener> getCurrentListeners(); }
|
ApolloConfigurationSourceImpl implements ConfigCenterConfigurationSource { @Override public void removeUpdateListener(WatchedUpdateListener watchedUpdateListener) { listeners.remove(watchedUpdateListener); } ApolloConfigurationSourceImpl(); @Override boolean isValidSource(Configuration localConfiguration); @Override void init(Configuration localConfiguration); @Override void addUpdateListener(WatchedUpdateListener watchedUpdateListener); @Override void removeUpdateListener(WatchedUpdateListener watchedUpdateListener); @Override Map<String, Object> getCurrentData(); List<WatchedUpdateListener> getCurrentListeners(); }
|
@Test public void refreshApolloConfig() { ApolloConfig apolloConfig = ApolloConfig.INSTANCE; RestTemplate rest = Mockito.mock(RestTemplate.class); ResponseEntity<String> responseEntity = new ResponseEntity<>( "{\"apollo\":\"mocked\", \"configurations\":{\"timeout\":1000}}", HttpStatus.OK); Mockito.when(rest.exchange( Matchers.anyString(), Matchers.any(HttpMethod.class), Matchers.<HttpEntity<String>>any(), Matchers.<Class<String>>any())).thenReturn(responseEntity); ApolloConfigurationSourceImpl impl = new ApolloConfigurationSourceImpl(); UpdateHandler updateHandler = impl.new UpdateHandler(); ApolloClient apolloClient = new ApolloClient(updateHandler); Deencapsulation.setField(apolloClient, "rest", rest); ConfigRefresh cr = apolloClient.new ConfigRefresh(apolloConfig.getServerUri()); cr.run(); Map<String, Object> originMap = Deencapsulation.getField(apolloClient, "originalConfigMap"); Assert.assertEquals(1, originMap.size()); }
|
public void refreshApolloConfig() { EXECUTOR .scheduleWithFixedDelay(new ConfigRefresh(serviceUri), firstRefreshInterval, refreshInterval, TimeUnit.SECONDS); }
|
ApolloClient { public void refreshApolloConfig() { EXECUTOR .scheduleWithFixedDelay(new ConfigRefresh(serviceUri), firstRefreshInterval, refreshInterval, TimeUnit.SECONDS); } }
|
ApolloClient { public void refreshApolloConfig() { EXECUTOR .scheduleWithFixedDelay(new ConfigRefresh(serviceUri), firstRefreshInterval, refreshInterval, TimeUnit.SECONDS); } ApolloClient(UpdateHandler updateHandler); }
|
ApolloClient { public void refreshApolloConfig() { EXECUTOR .scheduleWithFixedDelay(new ConfigRefresh(serviceUri), firstRefreshInterval, refreshInterval, TimeUnit.SECONDS); } ApolloClient(UpdateHandler updateHandler); void refreshApolloConfig(); }
|
ApolloClient { public void refreshApolloConfig() { EXECUTOR .scheduleWithFixedDelay(new ConfigRefresh(serviceUri), firstRefreshInterval, refreshInterval, TimeUnit.SECONDS); } ApolloClient(UpdateHandler updateHandler); void refreshApolloConfig(); }
|
@Test public void getServiceName() { ApolloConfig instance = ApolloConfig.INSTANCE; Assert.assertEquals("apollo-test", instance.getServiceName()); Assert.assertEquals("http: Assert.assertEquals("DEV", instance.getEnv()); Assert.assertEquals("test-cluster", instance.getServerClusters()); Assert.assertEquals("application", instance.getNamespace()); Assert.assertEquals("xxx", instance.getToken()); Assert.assertEquals(30, instance.getRefreshInterval()); Assert.assertEquals(0, instance.getFirstRefreshInterval()); }
|
public String getServiceName() { return finalConfig.getString(APOLLO_SERVICE_NAME); }
|
ApolloConfig { public String getServiceName() { return finalConfig.getString(APOLLO_SERVICE_NAME); } }
|
ApolloConfig { public String getServiceName() { return finalConfig.getString(APOLLO_SERVICE_NAME); } private ApolloConfig(); }
|
ApolloConfig { public String getServiceName() { return finalConfig.getString(APOLLO_SERVICE_NAME); } private ApolloConfig(); static void setConcurrentCompositeConfiguration(Configuration config); Configuration getConcurrentCompositeConfiguration(); String getServiceName(); String getServerUri(); String getToken(); String getEnv(); String getNamespace(); String getServerClusters(); int getRefreshInterval(); int getFirstRefreshInterval(); }
|
ApolloConfig { public String getServiceName() { return finalConfig.getString(APOLLO_SERVICE_NAME); } private ApolloConfig(); static void setConcurrentCompositeConfiguration(Configuration config); Configuration getConcurrentCompositeConfiguration(); String getServiceName(); String getServerUri(); String getToken(); String getEnv(); String getNamespace(); String getServerClusters(); int getRefreshInterval(); int getFirstRefreshInterval(); static final ApolloConfig INSTANCE; }
|
@SuppressWarnings("unchecked") @Test public void testConnectServer(@Mocked ClientPoolManager<HttpClientWithContext> clientMgr) { HttpClients.mockClientPoolManager("config-center", clientMgr); HttpClientRequest request = Mockito.mock(HttpClientRequest.class); Mockito.when(request.method()).thenReturn(HttpMethod.GET); Mockito.when(request.headers()).thenReturn(MultiMap.caseInsensitiveMultiMap()); Buffer rsp = Mockito.mock(Buffer.class); Mockito.when(rsp.toJsonObject()).thenReturn(new JsonObject( "{\"instances\":[{\"status\":\"UP\",\"endpoints\":[\"rest:0.0.0.0:30103\"],\"hostName\":\"125292-0.0.0.0\",\"serviceName\":\"configServer\",\"https\":false}]}")); HttpClientResponse event = Mockito.mock(HttpClientResponse.class); Mockito.when(event.bodyHandler(Mockito.any(Handler.class))).then(invocation -> { Handler<Buffer> handler = invocation.getArgumentAt(0, Handler.class); handler.handle(rsp); return null; }); Mockito.when(event.statusCode()).thenReturn(200); HttpClient httpClient = Mockito.mock(HttpClient.class); Mockito.when( httpClient.get(Mockito.anyInt(), Mockito.anyString(), Mockito.anyString(), Mockito.any(Handler.class))) .then(invocation -> { Handler<HttpClientResponse> handler = invocation.getArgumentAt(3, Handler.class); handler.handle(event); return request; }); new MockUp<HttpClientWithContext>() { @Mock public void runOnContext(RunHandler handler) { handler.run(httpClient); } }; new MockUp<MemberDiscovery>() { @Mock public void refreshMembers(JsonObject members) { Assert.assertTrue(members.size() == 1); } }; UpdateHandler updateHandler = new ConfigCenterConfigurationSourceImpl().new UpdateHandler(); ConfigCenterClient cc = new ConfigCenterClient(updateHandler); cc.connectServer(); }
|
public void connectServer() { if (refreshMode != 0 && refreshMode != 1) { LOGGER.error("refreshMode must be 0 or 1."); return; } ParseConfigUtils.getInstance().initWithUpdateHandler(updateHandler); refreshMembers(memberDiscovery); ConfigRefresh refreshTask = new ConfigRefresh(ParseConfigUtils.getInstance(), memberDiscovery); refreshTask.run(true); executor.scheduleWithFixedDelay(refreshTask, firstRefreshInterval, refreshInterval, TimeUnit.MILLISECONDS); }
|
ConfigCenterClient { public void connectServer() { if (refreshMode != 0 && refreshMode != 1) { LOGGER.error("refreshMode must be 0 or 1."); return; } ParseConfigUtils.getInstance().initWithUpdateHandler(updateHandler); refreshMembers(memberDiscovery); ConfigRefresh refreshTask = new ConfigRefresh(ParseConfigUtils.getInstance(), memberDiscovery); refreshTask.run(true); executor.scheduleWithFixedDelay(refreshTask, firstRefreshInterval, refreshInterval, TimeUnit.MILLISECONDS); } }
|
ConfigCenterClient { public void connectServer() { if (refreshMode != 0 && refreshMode != 1) { LOGGER.error("refreshMode must be 0 or 1."); return; } ParseConfigUtils.getInstance().initWithUpdateHandler(updateHandler); refreshMembers(memberDiscovery); ConfigRefresh refreshTask = new ConfigRefresh(ParseConfigUtils.getInstance(), memberDiscovery); refreshTask.run(true); executor.scheduleWithFixedDelay(refreshTask, firstRefreshInterval, refreshInterval, TimeUnit.MILLISECONDS); } ConfigCenterClient(ConfigCenterConfigurationSourceImpl.UpdateHandler updateHandler); }
|
ConfigCenterClient { public void connectServer() { if (refreshMode != 0 && refreshMode != 1) { LOGGER.error("refreshMode must be 0 or 1."); return; } ParseConfigUtils.getInstance().initWithUpdateHandler(updateHandler); refreshMembers(memberDiscovery); ConfigRefresh refreshTask = new ConfigRefresh(ParseConfigUtils.getInstance(), memberDiscovery); refreshTask.run(true); executor.scheduleWithFixedDelay(refreshTask, firstRefreshInterval, refreshInterval, TimeUnit.MILLISECONDS); } ConfigCenterClient(ConfigCenterConfigurationSourceImpl.UpdateHandler updateHandler); void connectServer(); void destroy(); static SignRequest createSignRequest(String method, String endpoint, Map<String, String> headers,
InputStream content); }
|
ConfigCenterClient { public void connectServer() { if (refreshMode != 0 && refreshMode != 1) { LOGGER.error("refreshMode must be 0 or 1."); return; } ParseConfigUtils.getInstance().initWithUpdateHandler(updateHandler); refreshMembers(memberDiscovery); ConfigRefresh refreshTask = new ConfigRefresh(ParseConfigUtils.getInstance(), memberDiscovery); refreshTask.run(true); executor.scheduleWithFixedDelay(refreshTask, firstRefreshInterval, refreshInterval, TimeUnit.MILLISECONDS); } ConfigCenterClient(ConfigCenterConfigurationSourceImpl.UpdateHandler updateHandler); void connectServer(); void destroy(); static SignRequest createSignRequest(String method, String endpoint, Map<String, String> headers,
InputStream content); }
|
@Test public void testConnectRefreshModeTwo() { ConfigCenterClient cc2 = new ConfigCenterClient(null); boolean status = false; try { Deencapsulation.setField(cc2, "refreshMode", 2); cc2.connectServer(); } catch (Exception e) { status = true; } Assert.assertFalse(status); }
|
public void connectServer() { if (refreshMode != 0 && refreshMode != 1) { LOGGER.error("refreshMode must be 0 or 1."); return; } ParseConfigUtils.getInstance().initWithUpdateHandler(updateHandler); refreshMembers(memberDiscovery); ConfigRefresh refreshTask = new ConfigRefresh(ParseConfigUtils.getInstance(), memberDiscovery); refreshTask.run(true); executor.scheduleWithFixedDelay(refreshTask, firstRefreshInterval, refreshInterval, TimeUnit.MILLISECONDS); }
|
ConfigCenterClient { public void connectServer() { if (refreshMode != 0 && refreshMode != 1) { LOGGER.error("refreshMode must be 0 or 1."); return; } ParseConfigUtils.getInstance().initWithUpdateHandler(updateHandler); refreshMembers(memberDiscovery); ConfigRefresh refreshTask = new ConfigRefresh(ParseConfigUtils.getInstance(), memberDiscovery); refreshTask.run(true); executor.scheduleWithFixedDelay(refreshTask, firstRefreshInterval, refreshInterval, TimeUnit.MILLISECONDS); } }
|
ConfigCenterClient { public void connectServer() { if (refreshMode != 0 && refreshMode != 1) { LOGGER.error("refreshMode must be 0 or 1."); return; } ParseConfigUtils.getInstance().initWithUpdateHandler(updateHandler); refreshMembers(memberDiscovery); ConfigRefresh refreshTask = new ConfigRefresh(ParseConfigUtils.getInstance(), memberDiscovery); refreshTask.run(true); executor.scheduleWithFixedDelay(refreshTask, firstRefreshInterval, refreshInterval, TimeUnit.MILLISECONDS); } ConfigCenterClient(ConfigCenterConfigurationSourceImpl.UpdateHandler updateHandler); }
|
ConfigCenterClient { public void connectServer() { if (refreshMode != 0 && refreshMode != 1) { LOGGER.error("refreshMode must be 0 or 1."); return; } ParseConfigUtils.getInstance().initWithUpdateHandler(updateHandler); refreshMembers(memberDiscovery); ConfigRefresh refreshTask = new ConfigRefresh(ParseConfigUtils.getInstance(), memberDiscovery); refreshTask.run(true); executor.scheduleWithFixedDelay(refreshTask, firstRefreshInterval, refreshInterval, TimeUnit.MILLISECONDS); } ConfigCenterClient(ConfigCenterConfigurationSourceImpl.UpdateHandler updateHandler); void connectServer(); void destroy(); static SignRequest createSignRequest(String method, String endpoint, Map<String, String> headers,
InputStream content); }
|
ConfigCenterClient { public void connectServer() { if (refreshMode != 0 && refreshMode != 1) { LOGGER.error("refreshMode must be 0 or 1."); return; } ParseConfigUtils.getInstance().initWithUpdateHandler(updateHandler); refreshMembers(memberDiscovery); ConfigRefresh refreshTask = new ConfigRefresh(ParseConfigUtils.getInstance(), memberDiscovery); refreshTask.run(true); executor.scheduleWithFixedDelay(refreshTask, firstRefreshInterval, refreshInterval, TimeUnit.MILLISECONDS); } ConfigCenterClient(ConfigCenterConfigurationSourceImpl.UpdateHandler updateHandler); void connectServer(); void destroy(); static SignRequest createSignRequest(String method, String endpoint, Map<String, String> headers,
InputStream content); }
|
@Test public void destroy() { ConfigCenterClient configCenterClient = new ConfigCenterClient(null); ScheduledExecutorService executor = Deencapsulation.getField(configCenterClient, "executor"); ScheduledExecutorService heartbeatTask = Executors.newScheduledThreadPool(1); Deencapsulation.setField(configCenterClient, "heartbeatTask", heartbeatTask); Assert.assertFalse(executor.isShutdown()); configCenterClient.destroy(); Assert.assertTrue(executor.isShutdown()); Assert.assertTrue(heartbeatTask.isShutdown()); }
|
public void destroy() { if (executor != null) { executor.shutdown(); executor = null; } if (heartbeatTask != null) { heartbeatTask.shutdown(); heartbeatTask = null; } }
|
ConfigCenterClient { public void destroy() { if (executor != null) { executor.shutdown(); executor = null; } if (heartbeatTask != null) { heartbeatTask.shutdown(); heartbeatTask = null; } } }
|
ConfigCenterClient { public void destroy() { if (executor != null) { executor.shutdown(); executor = null; } if (heartbeatTask != null) { heartbeatTask.shutdown(); heartbeatTask = null; } } ConfigCenterClient(ConfigCenterConfigurationSourceImpl.UpdateHandler updateHandler); }
|
ConfigCenterClient { public void destroy() { if (executor != null) { executor.shutdown(); executor = null; } if (heartbeatTask != null) { heartbeatTask.shutdown(); heartbeatTask = null; } } ConfigCenterClient(ConfigCenterConfigurationSourceImpl.UpdateHandler updateHandler); void connectServer(); void destroy(); static SignRequest createSignRequest(String method, String endpoint, Map<String, String> headers,
InputStream content); }
|
ConfigCenterClient { public void destroy() { if (executor != null) { executor.shutdown(); executor = null; } if (heartbeatTask != null) { heartbeatTask.shutdown(); heartbeatTask = null; } } ConfigCenterClient(ConfigCenterConfigurationSourceImpl.UpdateHandler updateHandler); void connectServer(); void destroy(); static SignRequest createSignRequest(String method, String endpoint, Map<String, String> headers,
InputStream content); }
|
@Test public void testNotifyItemsChangedNeedRefresh() { boolean status = true; Map<String, Object> before = new HashMap<>(); Map<String, Object> after = new HashMap<>(); try { Deencapsulation.invoke(pc, "notifyItemsChangedNeedRefresh", before, after); } catch (Exception e) { status = false; } Assert.assertTrue(status); status = true; before.put("test", "testValue"); try { Deencapsulation.invoke(pc, "notifyItemsChangedNeedRefresh", before, after); } catch (Exception e) { status = false; } Assert.assertTrue(status); status = true; after.put("test", "testValue2"); try { Deencapsulation.invoke(pc, "notifyItemsChangedNeedRefresh", before, after); } catch (Exception e) { status = false; } Assert.assertTrue(status); status = true; try { Deencapsulation.invoke(pc, "notifyItemsChangedNeedRefresh", before, after); } catch (Exception e) { status = false; } Assert.assertTrue(status); }
|
private void notifyItemsChangedNeedRefresh(Map<String, Object> before, Map<String, Object> after) { Map<String, Object> itemsCreated = new HashMap<>(); Map<String, Object> itemsDeleted = new HashMap<>(); Map<String, Object> itemsModified = new HashMap<>(); if (before == null || before.isEmpty()) { updateHandler.handle("create", after); return; } if (after == null || after.isEmpty()) { updateHandler.handle("delete", before); return; } for (String itemKey : after.keySet()) { if (!before.containsKey(itemKey)) { itemsCreated.put(itemKey, after.get(itemKey)); } else if (!after.get(itemKey).equals(before.get(itemKey))) { itemsModified.put(itemKey, after.get(itemKey)); } } for (String itemKey : before.keySet()) { if (!after.containsKey(itemKey)) { itemsDeleted.put(itemKey, ""); } } updateHandler.handle("create", itemsCreated); updateHandler.handle("set", itemsModified); updateHandler.handle("delete", itemsDeleted); }
|
ParseConfigUtils { private void notifyItemsChangedNeedRefresh(Map<String, Object> before, Map<String, Object> after) { Map<String, Object> itemsCreated = new HashMap<>(); Map<String, Object> itemsDeleted = new HashMap<>(); Map<String, Object> itemsModified = new HashMap<>(); if (before == null || before.isEmpty()) { updateHandler.handle("create", after); return; } if (after == null || after.isEmpty()) { updateHandler.handle("delete", before); return; } for (String itemKey : after.keySet()) { if (!before.containsKey(itemKey)) { itemsCreated.put(itemKey, after.get(itemKey)); } else if (!after.get(itemKey).equals(before.get(itemKey))) { itemsModified.put(itemKey, after.get(itemKey)); } } for (String itemKey : before.keySet()) { if (!after.containsKey(itemKey)) { itemsDeleted.put(itemKey, ""); } } updateHandler.handle("create", itemsCreated); updateHandler.handle("set", itemsModified); updateHandler.handle("delete", itemsDeleted); } }
|
ParseConfigUtils { private void notifyItemsChangedNeedRefresh(Map<String, Object> before, Map<String, Object> after) { Map<String, Object> itemsCreated = new HashMap<>(); Map<String, Object> itemsDeleted = new HashMap<>(); Map<String, Object> itemsModified = new HashMap<>(); if (before == null || before.isEmpty()) { updateHandler.handle("create", after); return; } if (after == null || after.isEmpty()) { updateHandler.handle("delete", before); return; } for (String itemKey : after.keySet()) { if (!before.containsKey(itemKey)) { itemsCreated.put(itemKey, after.get(itemKey)); } else if (!after.get(itemKey).equals(before.get(itemKey))) { itemsModified.put(itemKey, after.get(itemKey)); } } for (String itemKey : before.keySet()) { if (!after.containsKey(itemKey)) { itemsDeleted.put(itemKey, ""); } } updateHandler.handle("create", itemsCreated); updateHandler.handle("set", itemsModified); updateHandler.handle("delete", itemsDeleted); } ParseConfigUtils(UpdateHandler updateHandler); private ParseConfigUtils(); }
|
ParseConfigUtils { private void notifyItemsChangedNeedRefresh(Map<String, Object> before, Map<String, Object> after) { Map<String, Object> itemsCreated = new HashMap<>(); Map<String, Object> itemsDeleted = new HashMap<>(); Map<String, Object> itemsModified = new HashMap<>(); if (before == null || before.isEmpty()) { updateHandler.handle("create", after); return; } if (after == null || after.isEmpty()) { updateHandler.handle("delete", before); return; } for (String itemKey : after.keySet()) { if (!before.containsKey(itemKey)) { itemsCreated.put(itemKey, after.get(itemKey)); } else if (!after.get(itemKey).equals(before.get(itemKey))) { itemsModified.put(itemKey, after.get(itemKey)); } } for (String itemKey : before.keySet()) { if (!after.containsKey(itemKey)) { itemsDeleted.put(itemKey, ""); } } updateHandler.handle("create", itemsCreated); updateHandler.handle("set", itemsModified); updateHandler.handle("delete", itemsDeleted); } ParseConfigUtils(UpdateHandler updateHandler); private ParseConfigUtils(); void initWithUpdateHandler(UpdateHandler updateHandler); void refreshConfigItems(Map<String, Map<String, Object>> remoteItems); static ParseConfigUtils getInstance(); String getCurrentVersionInfo(); void refreshConfigItemsIncremental(Map<String, Object> action); }
|
ParseConfigUtils { private void notifyItemsChangedNeedRefresh(Map<String, Object> before, Map<String, Object> after) { Map<String, Object> itemsCreated = new HashMap<>(); Map<String, Object> itemsDeleted = new HashMap<>(); Map<String, Object> itemsModified = new HashMap<>(); if (before == null || before.isEmpty()) { updateHandler.handle("create", after); return; } if (after == null || after.isEmpty()) { updateHandler.handle("delete", before); return; } for (String itemKey : after.keySet()) { if (!before.containsKey(itemKey)) { itemsCreated.put(itemKey, after.get(itemKey)); } else if (!after.get(itemKey).equals(before.get(itemKey))) { itemsModified.put(itemKey, after.get(itemKey)); } } for (String itemKey : before.keySet()) { if (!after.containsKey(itemKey)) { itemsDeleted.put(itemKey, ""); } } updateHandler.handle("create", itemsCreated); updateHandler.handle("set", itemsModified); updateHandler.handle("delete", itemsDeleted); } ParseConfigUtils(UpdateHandler updateHandler); private ParseConfigUtils(); void initWithUpdateHandler(UpdateHandler updateHandler); void refreshConfigItems(Map<String, Map<String, Object>> remoteItems); static ParseConfigUtils getInstance(); String getCurrentVersionInfo(); void refreshConfigItemsIncremental(Map<String, Object> action); }
|
@Test public void testMergeDimensionItems() { boolean status = true; Map<String, Object> application = new HashMap<>(); application.put("key1", "application1"); application.put("key2", "application2"); application.put("key3", "application3"); application.put("key4", "application4"); Map<String, Object> service = new HashMap<>(); service.put("key1", "service1"); service.put("key2", "service2"); service.put("key3", "service3"); Map<String, Object> version = new HashMap<>(); version.put("key1", "version1"); version.put("key2", "version1"); Map<String, Object> tag = new HashMap<>(); tag.put("key1", "tag1"); Map<String, Map<String, Object>> items = new LinkedHashMap<String, Map<String, Object>>(); items.put("application", application); items.put("service@app", service); items.put("service@app#version", version); items.put("service@app#version!tag", tag); Map<String, Object> result = null; try { result = Deencapsulation.invoke(pc, "mergeDimensionItems", items); } catch (Exception e) { status = false; } Assert.assertTrue(status); Assert.assertEquals(application.get("key4"), result.get("key4")); Assert.assertEquals(service.get("key3"), result.get("key3")); Assert.assertEquals(version.get("key2"), result.get("key2")); Assert.assertEquals(tag.get("key1"), result.get("key1")); }
|
private Map<String, Object> mergeDimensionItems(Map<String, Map<String, Object>> items) { Map<String, Object> flatMap = new HashMap<>(); Set<String> keySet = items.keySet(); if (keySet.contains("application")) { flatMap.putAll(items.get("application")); keySet.remove("application"); } if (!keySet.isEmpty()) { TreeSet<String> sortedKeys = new TreeSet<String>(new Comparator<String>() { @Override public int compare(String o1, String o2) { return o1.length() - o2.length(); } }); sortedKeys.addAll(keySet); sortedKeys.forEach(key -> flatMap.putAll(items.get(key))); } return flatMap; }
|
ParseConfigUtils { private Map<String, Object> mergeDimensionItems(Map<String, Map<String, Object>> items) { Map<String, Object> flatMap = new HashMap<>(); Set<String> keySet = items.keySet(); if (keySet.contains("application")) { flatMap.putAll(items.get("application")); keySet.remove("application"); } if (!keySet.isEmpty()) { TreeSet<String> sortedKeys = new TreeSet<String>(new Comparator<String>() { @Override public int compare(String o1, String o2) { return o1.length() - o2.length(); } }); sortedKeys.addAll(keySet); sortedKeys.forEach(key -> flatMap.putAll(items.get(key))); } return flatMap; } }
|
ParseConfigUtils { private Map<String, Object> mergeDimensionItems(Map<String, Map<String, Object>> items) { Map<String, Object> flatMap = new HashMap<>(); Set<String> keySet = items.keySet(); if (keySet.contains("application")) { flatMap.putAll(items.get("application")); keySet.remove("application"); } if (!keySet.isEmpty()) { TreeSet<String> sortedKeys = new TreeSet<String>(new Comparator<String>() { @Override public int compare(String o1, String o2) { return o1.length() - o2.length(); } }); sortedKeys.addAll(keySet); sortedKeys.forEach(key -> flatMap.putAll(items.get(key))); } return flatMap; } ParseConfigUtils(UpdateHandler updateHandler); private ParseConfigUtils(); }
|
ParseConfigUtils { private Map<String, Object> mergeDimensionItems(Map<String, Map<String, Object>> items) { Map<String, Object> flatMap = new HashMap<>(); Set<String> keySet = items.keySet(); if (keySet.contains("application")) { flatMap.putAll(items.get("application")); keySet.remove("application"); } if (!keySet.isEmpty()) { TreeSet<String> sortedKeys = new TreeSet<String>(new Comparator<String>() { @Override public int compare(String o1, String o2) { return o1.length() - o2.length(); } }); sortedKeys.addAll(keySet); sortedKeys.forEach(key -> flatMap.putAll(items.get(key))); } return flatMap; } ParseConfigUtils(UpdateHandler updateHandler); private ParseConfigUtils(); void initWithUpdateHandler(UpdateHandler updateHandler); void refreshConfigItems(Map<String, Map<String, Object>> remoteItems); static ParseConfigUtils getInstance(); String getCurrentVersionInfo(); void refreshConfigItemsIncremental(Map<String, Object> action); }
|
ParseConfigUtils { private Map<String, Object> mergeDimensionItems(Map<String, Map<String, Object>> items) { Map<String, Object> flatMap = new HashMap<>(); Set<String> keySet = items.keySet(); if (keySet.contains("application")) { flatMap.putAll(items.get("application")); keySet.remove("application"); } if (!keySet.isEmpty()) { TreeSet<String> sortedKeys = new TreeSet<String>(new Comparator<String>() { @Override public int compare(String o1, String o2) { return o1.length() - o2.length(); } }); sortedKeys.addAll(keySet); sortedKeys.forEach(key -> flatMap.putAll(items.get(key))); } return flatMap; } ParseConfigUtils(UpdateHandler updateHandler); private ParseConfigUtils(); void initWithUpdateHandler(UpdateHandler updateHandler); void refreshConfigItems(Map<String, Map<String, Object>> remoteItems); static ParseConfigUtils getInstance(); String getCurrentVersionInfo(); void refreshConfigItemsIncremental(Map<String, Object> action); }
|
@Test public void testGetConfigServerURIs() { MemberDiscovery dc = new MemberDiscovery(ConfigCenterConfig.INSTANCE.getServerUri()); assertNotNull(dc.getConfigServer()); }
|
public String getConfigServer() { synchronized (lock) { if (configServerAddresses.isEmpty()) { throw new IllegalStateException("Config center address is not available."); } int index = Math.abs(counter.get() % configServerAddresses.size()); return configServerAddresses.get(index); } }
|
MemberDiscovery { public String getConfigServer() { synchronized (lock) { if (configServerAddresses.isEmpty()) { throw new IllegalStateException("Config center address is not available."); } int index = Math.abs(counter.get() % configServerAddresses.size()); return configServerAddresses.get(index); } } }
|
MemberDiscovery { public String getConfigServer() { synchronized (lock) { if (configServerAddresses.isEmpty()) { throw new IllegalStateException("Config center address is not available."); } int index = Math.abs(counter.get() % configServerAddresses.size()); return configServerAddresses.get(index); } } MemberDiscovery(List<String> configCenterUri); }
|
MemberDiscovery { public String getConfigServer() { synchronized (lock) { if (configServerAddresses.isEmpty()) { throw new IllegalStateException("Config center address is not available."); } int index = Math.abs(counter.get() % configServerAddresses.size()); return configServerAddresses.get(index); } } MemberDiscovery(List<String> configCenterUri); String getConfigServer(); @Subscribe void onConnFailEvent(ConnFailEvent e); void refreshMembers(JsonObject members); }
|
MemberDiscovery { public String getConfigServer() { synchronized (lock) { if (configServerAddresses.isEmpty()) { throw new IllegalStateException("Config center address is not available."); } int index = Math.abs(counter.get() % configServerAddresses.size()); return configServerAddresses.get(index); } } MemberDiscovery(List<String> configCenterUri); String getConfigServer(); @Subscribe void onConnFailEvent(ConnFailEvent e); void refreshMembers(JsonObject members); }
|
@Test public void getServerUri() { List<String> servers = ConfigCenterConfig.INSTANCE.getServerUri(); Assert.assertEquals("https: Assert.assertEquals("https: }
|
public List<String> getServerUri() { return Deployment.getSystemBootStrapInfo(DeploymentProvider.SYSTEM_KEY_CONFIG_CENTER).getAccessURL(); }
|
ConfigCenterConfig { public List<String> getServerUri() { return Deployment.getSystemBootStrapInfo(DeploymentProvider.SYSTEM_KEY_CONFIG_CENTER).getAccessURL(); } }
|
ConfigCenterConfig { public List<String> getServerUri() { return Deployment.getSystemBootStrapInfo(DeploymentProvider.SYSTEM_KEY_CONFIG_CENTER).getAccessURL(); } private ConfigCenterConfig(); }
|
ConfigCenterConfig { public List<String> getServerUri() { return Deployment.getSystemBootStrapInfo(DeploymentProvider.SYSTEM_KEY_CONFIG_CENTER).getAccessURL(); } private ConfigCenterConfig(); static void setConcurrentCompositeConfiguration(ConcurrentCompositeConfiguration config); static ConcurrentCompositeConfiguration getConcurrentCompositeConfiguration(); int getRefreshMode(); int getRefreshPort(); String getTenantName(); String getDomainName(); String getToken(); String getApiVersion(); int getRefreshInterval(); int getFirstRefreshInterval(); Boolean isProxyEnable(); String getProxyHost(); int getProxyPort(); String getProxyUsername(); String getProxyPasswd(); @SuppressWarnings("unchecked") String getServiceName(); List<String> getServerUri(); boolean getAutoDiscoveryEnabled(); int getConnectionTimeout(); int getEventLoopSize(); int getVerticalInstanceCount(); int getIdleTimeoutInSeconds(); String getEnvironment(); }
|
ConfigCenterConfig { public List<String> getServerUri() { return Deployment.getSystemBootStrapInfo(DeploymentProvider.SYSTEM_KEY_CONFIG_CENTER).getAccessURL(); } private ConfigCenterConfig(); static void setConcurrentCompositeConfiguration(ConcurrentCompositeConfiguration config); static ConcurrentCompositeConfiguration getConcurrentCompositeConfiguration(); int getRefreshMode(); int getRefreshPort(); String getTenantName(); String getDomainName(); String getToken(); String getApiVersion(); int getRefreshInterval(); int getFirstRefreshInterval(); Boolean isProxyEnable(); String getProxyHost(); int getProxyPort(); String getProxyUsername(); String getProxyPasswd(); @SuppressWarnings("unchecked") String getServiceName(); List<String> getServerUri(); boolean getAutoDiscoveryEnabled(); int getConnectionTimeout(); int getEventLoopSize(); int getVerticalInstanceCount(); int getIdleTimeoutInSeconds(); String getEnvironment(); static final ConfigCenterConfig INSTANCE; static final String CONNECTION_TIME_OUT; static final String EVENT_LOOP_SIZE; static final String VERTICAL_INSTANCE_COUNT; static final String IDLE_TIMEOUT_IN_SECONDES; }
|
@Test public void test_heartbeat_whenInstanceExist_shouldReturnTrue() { ServerUtil.microserviceInstanceMap = prepareServiceInstanceMap(false); boolean returnedResult = target.heartbeat(serviceId, instanceId); Assert.assertTrue(returnedResult); }
|
public void heartbeat(ServerMicroserviceInstance receivedInstance) { String serviceId = receivedInstance.getServiceId(); String instanceId = receivedInstance.getInstanceId(); Map<String, ServerMicroserviceInstance> serverMicroserviceInstanceMap = ServerUtil.microserviceInstanceMap .get(serviceId); if (serverMicroserviceInstanceMap != null && serverMicroserviceInstanceMap .containsKey(instanceId)) { ServerMicroserviceInstance instance = serverMicroserviceInstanceMap.get(instanceId); instance.setLastHeartbeatTimeStamp(Instant.now()); } else { receivedInstance.setEvent(REGISTER_EVENT); LOGGER.info( "Received HEARTBEAT event from serviceId: {}, instancdId: {} for the first time. Register it instead.", serviceId, instanceId); this.registerMicroserviceInstance(receivedInstance); } }
|
ZeroConfigRegistryService { public void heartbeat(ServerMicroserviceInstance receivedInstance) { String serviceId = receivedInstance.getServiceId(); String instanceId = receivedInstance.getInstanceId(); Map<String, ServerMicroserviceInstance> serverMicroserviceInstanceMap = ServerUtil.microserviceInstanceMap .get(serviceId); if (serverMicroserviceInstanceMap != null && serverMicroserviceInstanceMap .containsKey(instanceId)) { ServerMicroserviceInstance instance = serverMicroserviceInstanceMap.get(instanceId); instance.setLastHeartbeatTimeStamp(Instant.now()); } else { receivedInstance.setEvent(REGISTER_EVENT); LOGGER.info( "Received HEARTBEAT event from serviceId: {}, instancdId: {} for the first time. Register it instead.", serviceId, instanceId); this.registerMicroserviceInstance(receivedInstance); } } }
|
ZeroConfigRegistryService { public void heartbeat(ServerMicroserviceInstance receivedInstance) { String serviceId = receivedInstance.getServiceId(); String instanceId = receivedInstance.getInstanceId(); Map<String, ServerMicroserviceInstance> serverMicroserviceInstanceMap = ServerUtil.microserviceInstanceMap .get(serviceId); if (serverMicroserviceInstanceMap != null && serverMicroserviceInstanceMap .containsKey(instanceId)) { ServerMicroserviceInstance instance = serverMicroserviceInstanceMap.get(instanceId); instance.setLastHeartbeatTimeStamp(Instant.now()); } else { receivedInstance.setEvent(REGISTER_EVENT); LOGGER.info( "Received HEARTBEAT event from serviceId: {}, instancdId: {} for the first time. Register it instead.", serviceId, instanceId); this.registerMicroserviceInstance(receivedInstance); } } }
|
ZeroConfigRegistryService { public void heartbeat(ServerMicroserviceInstance receivedInstance) { String serviceId = receivedInstance.getServiceId(); String instanceId = receivedInstance.getInstanceId(); Map<String, ServerMicroserviceInstance> serverMicroserviceInstanceMap = ServerUtil.microserviceInstanceMap .get(serviceId); if (serverMicroserviceInstanceMap != null && serverMicroserviceInstanceMap .containsKey(instanceId)) { ServerMicroserviceInstance instance = serverMicroserviceInstanceMap.get(instanceId); instance.setLastHeartbeatTimeStamp(Instant.now()); } else { receivedInstance.setEvent(REGISTER_EVENT); LOGGER.info( "Received HEARTBEAT event from serviceId: {}, instancdId: {} for the first time. Register it instead.", serviceId, instanceId); this.registerMicroserviceInstance(receivedInstance); } } void registerMicroserviceInstance(ServerMicroserviceInstance receivedInstance); void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance); ServerMicroserviceInstance findServiceInstance(String serviceId,
String instanceId); List<ServerMicroserviceInstance> getMicroserviceInstance(String consumerId,
String providerId); void heartbeat(ServerMicroserviceInstance receivedInstance); boolean heartbeat(String microserviceId, String microserviceInstanceId); ServerMicroserviceInstance getMicroservice(String microserviceId); List<ServerMicroserviceInstance> findServiceInstances(String appId, String serviceName); }
|
ZeroConfigRegistryService { public void heartbeat(ServerMicroserviceInstance receivedInstance) { String serviceId = receivedInstance.getServiceId(); String instanceId = receivedInstance.getInstanceId(); Map<String, ServerMicroserviceInstance> serverMicroserviceInstanceMap = ServerUtil.microserviceInstanceMap .get(serviceId); if (serverMicroserviceInstanceMap != null && serverMicroserviceInstanceMap .containsKey(instanceId)) { ServerMicroserviceInstance instance = serverMicroserviceInstanceMap.get(instanceId); instance.setLastHeartbeatTimeStamp(Instant.now()); } else { receivedInstance.setEvent(REGISTER_EVENT); LOGGER.info( "Received HEARTBEAT event from serviceId: {}, instancdId: {} for the first time. Register it instead.", serviceId, instanceId); this.registerMicroserviceInstance(receivedInstance); } } void registerMicroserviceInstance(ServerMicroserviceInstance receivedInstance); void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance); ServerMicroserviceInstance findServiceInstance(String serviceId,
String instanceId); List<ServerMicroserviceInstance> getMicroserviceInstance(String consumerId,
String providerId); void heartbeat(ServerMicroserviceInstance receivedInstance); boolean heartbeat(String microserviceId, String microserviceInstanceId); ServerMicroserviceInstance getMicroservice(String microserviceId); List<ServerMicroserviceInstance> findServiceInstances(String appId, String serviceName); }
|
@Test public void getEnvironment() { Assert.assertEquals("testing", ConfigCenterConfig.INSTANCE.getEnvironment()); System.setProperty("SERVICECOMB_ENV", "development"); ConfigCenterConfig.setConcurrentCompositeConfiguration(ConfigUtil.createLocalConfig()); Assert.assertEquals("development", ConfigCenterConfig.INSTANCE.getEnvironment()); }
|
public String getEnvironment() { return BootStrapProperties.readServiceEnvironment(finalConfig); }
|
ConfigCenterConfig { public String getEnvironment() { return BootStrapProperties.readServiceEnvironment(finalConfig); } }
|
ConfigCenterConfig { public String getEnvironment() { return BootStrapProperties.readServiceEnvironment(finalConfig); } private ConfigCenterConfig(); }
|
ConfigCenterConfig { public String getEnvironment() { return BootStrapProperties.readServiceEnvironment(finalConfig); } private ConfigCenterConfig(); static void setConcurrentCompositeConfiguration(ConcurrentCompositeConfiguration config); static ConcurrentCompositeConfiguration getConcurrentCompositeConfiguration(); int getRefreshMode(); int getRefreshPort(); String getTenantName(); String getDomainName(); String getToken(); String getApiVersion(); int getRefreshInterval(); int getFirstRefreshInterval(); Boolean isProxyEnable(); String getProxyHost(); int getProxyPort(); String getProxyUsername(); String getProxyPasswd(); @SuppressWarnings("unchecked") String getServiceName(); List<String> getServerUri(); boolean getAutoDiscoveryEnabled(); int getConnectionTimeout(); int getEventLoopSize(); int getVerticalInstanceCount(); int getIdleTimeoutInSeconds(); String getEnvironment(); }
|
ConfigCenterConfig { public String getEnvironment() { return BootStrapProperties.readServiceEnvironment(finalConfig); } private ConfigCenterConfig(); static void setConcurrentCompositeConfiguration(ConcurrentCompositeConfiguration config); static ConcurrentCompositeConfiguration getConcurrentCompositeConfiguration(); int getRefreshMode(); int getRefreshPort(); String getTenantName(); String getDomainName(); String getToken(); String getApiVersion(); int getRefreshInterval(); int getFirstRefreshInterval(); Boolean isProxyEnable(); String getProxyHost(); int getProxyPort(); String getProxyUsername(); String getProxyPasswd(); @SuppressWarnings("unchecked") String getServiceName(); List<String> getServerUri(); boolean getAutoDiscoveryEnabled(); int getConnectionTimeout(); int getEventLoopSize(); int getVerticalInstanceCount(); int getIdleTimeoutInSeconds(); String getEnvironment(); static final ConfigCenterConfig INSTANCE; static final String CONNECTION_TIME_OUT; static final String EVENT_LOOP_SIZE; static final String VERTICAL_INSTANCE_COUNT; static final String IDLE_TIMEOUT_IN_SECONDES; }
|
@Test public void testCreate() throws Exception { NacosConfigurationSourceImpl nacosConfigurationSource = new NacosConfigurationSourceImpl(); nacosConfigurationSource.addUpdateListener(result -> Assert.assertTrue(!result.getAdded().isEmpty())); UpdateHandler udateHandler = Deencapsulation.getField(nacosConfigurationSource, UpdateHandler.class); Map<String, Object> createItems = new HashMap<>(); createItems.put("nacosTestKey", "testValue"); udateHandler.handle(CREATE, createItems); }
|
@Override public void addUpdateListener(WatchedUpdateListener watchedUpdateListener) { listeners.add(watchedUpdateListener); }
|
NacosConfigurationSourceImpl implements ConfigCenterConfigurationSource { @Override public void addUpdateListener(WatchedUpdateListener watchedUpdateListener) { listeners.add(watchedUpdateListener); } }
|
NacosConfigurationSourceImpl implements ConfigCenterConfigurationSource { @Override public void addUpdateListener(WatchedUpdateListener watchedUpdateListener) { listeners.add(watchedUpdateListener); } NacosConfigurationSourceImpl(); }
|
NacosConfigurationSourceImpl implements ConfigCenterConfigurationSource { @Override public void addUpdateListener(WatchedUpdateListener watchedUpdateListener) { listeners.add(watchedUpdateListener); } NacosConfigurationSourceImpl(); @Override boolean isValidSource(Configuration localConfiguration); @Override void init(Configuration localConfiguration); @Override void addUpdateListener(WatchedUpdateListener watchedUpdateListener); @Override void removeUpdateListener(WatchedUpdateListener watchedUpdateListener); @Override Map<String, Object> getCurrentData(); List<WatchedUpdateListener> getCurrentListeners(); }
|
NacosConfigurationSourceImpl implements ConfigCenterConfigurationSource { @Override public void addUpdateListener(WatchedUpdateListener watchedUpdateListener) { listeners.add(watchedUpdateListener); } NacosConfigurationSourceImpl(); @Override boolean isValidSource(Configuration localConfiguration); @Override void init(Configuration localConfiguration); @Override void addUpdateListener(WatchedUpdateListener watchedUpdateListener); @Override void removeUpdateListener(WatchedUpdateListener watchedUpdateListener); @Override Map<String, Object> getCurrentData(); List<WatchedUpdateListener> getCurrentListeners(); }
|
@Test public void testUpdate() throws Exception { NacosConfigurationSourceImpl nacosConfigurationSource = new NacosConfigurationSourceImpl(); nacosConfigurationSource.addUpdateListener(result -> Assert.assertTrue(!result.getChanged().isEmpty())); UpdateHandler udateHandler = Deencapsulation.getField(nacosConfigurationSource, UpdateHandler.class); Map<String, Object> updateItems = new HashMap<>(); updateItems.put("nacosTestKey", "testValue"); udateHandler.handle(SET, updateItems); }
|
@Override public void addUpdateListener(WatchedUpdateListener watchedUpdateListener) { listeners.add(watchedUpdateListener); }
|
NacosConfigurationSourceImpl implements ConfigCenterConfigurationSource { @Override public void addUpdateListener(WatchedUpdateListener watchedUpdateListener) { listeners.add(watchedUpdateListener); } }
|
NacosConfigurationSourceImpl implements ConfigCenterConfigurationSource { @Override public void addUpdateListener(WatchedUpdateListener watchedUpdateListener) { listeners.add(watchedUpdateListener); } NacosConfigurationSourceImpl(); }
|
NacosConfigurationSourceImpl implements ConfigCenterConfigurationSource { @Override public void addUpdateListener(WatchedUpdateListener watchedUpdateListener) { listeners.add(watchedUpdateListener); } NacosConfigurationSourceImpl(); @Override boolean isValidSource(Configuration localConfiguration); @Override void init(Configuration localConfiguration); @Override void addUpdateListener(WatchedUpdateListener watchedUpdateListener); @Override void removeUpdateListener(WatchedUpdateListener watchedUpdateListener); @Override Map<String, Object> getCurrentData(); List<WatchedUpdateListener> getCurrentListeners(); }
|
NacosConfigurationSourceImpl implements ConfigCenterConfigurationSource { @Override public void addUpdateListener(WatchedUpdateListener watchedUpdateListener) { listeners.add(watchedUpdateListener); } NacosConfigurationSourceImpl(); @Override boolean isValidSource(Configuration localConfiguration); @Override void init(Configuration localConfiguration); @Override void addUpdateListener(WatchedUpdateListener watchedUpdateListener); @Override void removeUpdateListener(WatchedUpdateListener watchedUpdateListener); @Override Map<String, Object> getCurrentData(); List<WatchedUpdateListener> getCurrentListeners(); }
|
@Test public void testRemoveUpdateListener() { NacosConfigurationSourceImpl nacosConfigurationSource = new NacosConfigurationSourceImpl(); WatchedUpdateListener watchedUpdateListener = Mockito.mock(WatchedUpdateListener.class); nacosConfigurationSource.addUpdateListener(watchedUpdateListener); nacosConfigurationSource.removeUpdateListener(watchedUpdateListener); Assert.assertTrue(nacosConfigurationSource.getCurrentListeners().isEmpty()); }
|
@Override public void removeUpdateListener(WatchedUpdateListener watchedUpdateListener) { listeners.remove(watchedUpdateListener); }
|
NacosConfigurationSourceImpl implements ConfigCenterConfigurationSource { @Override public void removeUpdateListener(WatchedUpdateListener watchedUpdateListener) { listeners.remove(watchedUpdateListener); } }
|
NacosConfigurationSourceImpl implements ConfigCenterConfigurationSource { @Override public void removeUpdateListener(WatchedUpdateListener watchedUpdateListener) { listeners.remove(watchedUpdateListener); } NacosConfigurationSourceImpl(); }
|
NacosConfigurationSourceImpl implements ConfigCenterConfigurationSource { @Override public void removeUpdateListener(WatchedUpdateListener watchedUpdateListener) { listeners.remove(watchedUpdateListener); } NacosConfigurationSourceImpl(); @Override boolean isValidSource(Configuration localConfiguration); @Override void init(Configuration localConfiguration); @Override void addUpdateListener(WatchedUpdateListener watchedUpdateListener); @Override void removeUpdateListener(WatchedUpdateListener watchedUpdateListener); @Override Map<String, Object> getCurrentData(); List<WatchedUpdateListener> getCurrentListeners(); }
|
NacosConfigurationSourceImpl implements ConfigCenterConfigurationSource { @Override public void removeUpdateListener(WatchedUpdateListener watchedUpdateListener) { listeners.remove(watchedUpdateListener); } NacosConfigurationSourceImpl(); @Override boolean isValidSource(Configuration localConfiguration); @Override void init(Configuration localConfiguration); @Override void addUpdateListener(WatchedUpdateListener watchedUpdateListener); @Override void removeUpdateListener(WatchedUpdateListener watchedUpdateListener); @Override Map<String, Object> getCurrentData(); List<WatchedUpdateListener> getCurrentListeners(); }
|
@Test public void refreshNacosConfig() { NacosConfigurationSourceImpl impl = new NacosConfigurationSourceImpl(); UpdateHandler updateHandler = impl.new UpdateHandler(); NacosClient nacosClient = new NacosClient(updateHandler); Map<String, Object> originMap = Deencapsulation.getField(nacosClient, "originalConfigMap"); originMap.put("nacos","12345"); Assert.assertEquals(1, originMap.size()); }
|
public void refreshNacosConfig() { new ConfigRefresh().refreshConfig(); }
|
NacosClient { public void refreshNacosConfig() { new ConfigRefresh().refreshConfig(); } }
|
NacosClient { public void refreshNacosConfig() { new ConfigRefresh().refreshConfig(); } NacosClient(UpdateHandler updateHandler); }
|
NacosClient { public void refreshNacosConfig() { new ConfigRefresh().refreshConfig(); } NacosClient(UpdateHandler updateHandler); void refreshNacosConfig(); }
|
NacosClient { public void refreshNacosConfig() { new ConfigRefresh().refreshConfig(); } NacosClient(UpdateHandler updateHandler); void refreshNacosConfig(); }
|
@Test public void test_processValueType() { KVDoc kvDoc = new KVDoc(); kvDoc.setKey("hello"); kvDoc.setValue("world"); Map<String, Object> result = KieUtil.processValueType(kvDoc); Assert.assertEquals("world", result.get("hello")); kvDoc.setValueType("text"); result = KieUtil.processValueType(kvDoc); Assert.assertEquals("world", result.get("hello")); kvDoc.setValueType("string"); result = KieUtil.processValueType(kvDoc); Assert.assertEquals("world", result.get("hello")); kvDoc.setValueType("json"); result = KieUtil.processValueType(kvDoc); Assert.assertEquals("world", result.get("hello")); kvDoc.setValueType("yml"); kvDoc.setValue("hello: world"); result = KieUtil.processValueType(kvDoc); Assert.assertEquals("world", result.get("hello.hello")); kvDoc.setValueType("yaml"); kvDoc.setValue("hello: world"); result = KieUtil.processValueType(kvDoc); Assert.assertEquals("world", result.get("hello.hello")); kvDoc.setValueType("properties"); kvDoc.setValue("hello=world"); result = KieUtil.processValueType(kvDoc); Assert.assertEquals("world", result.get("hello.hello")); }
|
public static Map<String, Object> processValueType(KVDoc kvDoc) { ValueType valueType = parseValueType(kvDoc.getValueType()); if (valueType == (ValueType.YAML) || valueType == (ValueType.YML)) { return Parser.findParser(Parser.CONTENT_TYPE_YAML).parse(kvDoc.getValue(), kvDoc.getKey(), true); } else if (valueType == (ValueType.PROPERTIES)) { return Parser.findParser(Parser.CONTENT_TYPE_PROPERTIES).parse(kvDoc.getValue(), kvDoc.getKey(), true); } else { return Parser.findParser(Parser.CONTENT_TYPE_RAW).parse(kvDoc.getValue(), kvDoc.getKey(), true); } }
|
KieUtil { public static Map<String, Object> processValueType(KVDoc kvDoc) { ValueType valueType = parseValueType(kvDoc.getValueType()); if (valueType == (ValueType.YAML) || valueType == (ValueType.YML)) { return Parser.findParser(Parser.CONTENT_TYPE_YAML).parse(kvDoc.getValue(), kvDoc.getKey(), true); } else if (valueType == (ValueType.PROPERTIES)) { return Parser.findParser(Parser.CONTENT_TYPE_PROPERTIES).parse(kvDoc.getValue(), kvDoc.getKey(), true); } else { return Parser.findParser(Parser.CONTENT_TYPE_RAW).parse(kvDoc.getValue(), kvDoc.getKey(), true); } } }
|
KieUtil { public static Map<String, Object> processValueType(KVDoc kvDoc) { ValueType valueType = parseValueType(kvDoc.getValueType()); if (valueType == (ValueType.YAML) || valueType == (ValueType.YML)) { return Parser.findParser(Parser.CONTENT_TYPE_YAML).parse(kvDoc.getValue(), kvDoc.getKey(), true); } else if (valueType == (ValueType.PROPERTIES)) { return Parser.findParser(Parser.CONTENT_TYPE_PROPERTIES).parse(kvDoc.getValue(), kvDoc.getKey(), true); } else { return Parser.findParser(Parser.CONTENT_TYPE_RAW).parse(kvDoc.getValue(), kvDoc.getKey(), true); } } }
|
KieUtil { public static Map<String, Object> processValueType(KVDoc kvDoc) { ValueType valueType = parseValueType(kvDoc.getValueType()); if (valueType == (ValueType.YAML) || valueType == (ValueType.YML)) { return Parser.findParser(Parser.CONTENT_TYPE_YAML).parse(kvDoc.getValue(), kvDoc.getKey(), true); } else if (valueType == (ValueType.PROPERTIES)) { return Parser.findParser(Parser.CONTENT_TYPE_PROPERTIES).parse(kvDoc.getValue(), kvDoc.getKey(), true); } else { return Parser.findParser(Parser.CONTENT_TYPE_RAW).parse(kvDoc.getValue(), kvDoc.getKey(), true); } } static String encrypt(String dataStr); static Map<String, Object> getConfigByLabel(KVResponse resp); static Map<String, Object> processValueType(KVDoc kvDoc); }
|
KieUtil { public static Map<String, Object> processValueType(KVDoc kvDoc) { ValueType valueType = parseValueType(kvDoc.getValueType()); if (valueType == (ValueType.YAML) || valueType == (ValueType.YML)) { return Parser.findParser(Parser.CONTENT_TYPE_YAML).parse(kvDoc.getValue(), kvDoc.getKey(), true); } else if (valueType == (ValueType.PROPERTIES)) { return Parser.findParser(Parser.CONTENT_TYPE_PROPERTIES).parse(kvDoc.getValue(), kvDoc.getKey(), true); } else { return Parser.findParser(Parser.CONTENT_TYPE_RAW).parse(kvDoc.getValue(), kvDoc.getKey(), true); } } static String encrypt(String dataStr); static Map<String, Object> getConfigByLabel(KVResponse resp); static Map<String, Object> processValueType(KVDoc kvDoc); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.