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
|
|---|---|---|---|---|---|
@SuppressWarnings("unchecked") @Test public void testRefreshKieConfig() { 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(mockKvResponse)); 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); } }; UpdateHandler updateHandler = new KieConfigurationSourceImpl().new UpdateHandler(); KieClient kie = new KieClient(updateHandler); kie.refreshKieConfig(); }
|
public void refreshKieConfig() { if (enableLongPolling) { EXECUTOR.execute(new ConfigRefresh(serviceUri)); } else { EXECUTOR.scheduleWithFixedDelay(new ConfigRefresh(serviceUri), firstRefreshInterval, refreshInterval, TimeUnit.MILLISECONDS); } }
|
KieClient { public void refreshKieConfig() { if (enableLongPolling) { EXECUTOR.execute(new ConfigRefresh(serviceUri)); } else { EXECUTOR.scheduleWithFixedDelay(new ConfigRefresh(serviceUri), firstRefreshInterval, refreshInterval, TimeUnit.MILLISECONDS); } } }
|
KieClient { public void refreshKieConfig() { if (enableLongPolling) { EXECUTOR.execute(new ConfigRefresh(serviceUri)); } else { EXECUTOR.scheduleWithFixedDelay(new ConfigRefresh(serviceUri), firstRefreshInterval, refreshInterval, TimeUnit.MILLISECONDS); } } KieClient(UpdateHandler updateHandler); }
|
KieClient { public void refreshKieConfig() { if (enableLongPolling) { EXECUTOR.execute(new ConfigRefresh(serviceUri)); } else { EXECUTOR.scheduleWithFixedDelay(new ConfigRefresh(serviceUri), firstRefreshInterval, refreshInterval, TimeUnit.MILLISECONDS); } } KieClient(UpdateHandler updateHandler); void refreshKieConfig(); void destroy(); }
|
KieClient { public void refreshKieConfig() { if (enableLongPolling) { EXECUTOR.execute(new ConfigRefresh(serviceUri)); } else { EXECUTOR.scheduleWithFixedDelay(new ConfigRefresh(serviceUri), firstRefreshInterval, refreshInterval, TimeUnit.MILLISECONDS); } } KieClient(UpdateHandler updateHandler); void refreshKieConfig(); void destroy(); }
|
@Test public void destroy() { KieClient kieClient = new KieClient(null); ScheduledExecutorService executor = Deencapsulation.getField(kieClient, "EXECUTOR"); Assert.assertFalse(executor.isShutdown()); executor.shutdown(); Assert.assertTrue(executor.isShutdown()); }
|
public void destroy() { if (EXECUTOR != null) { EXECUTOR.shutdown(); EXECUTOR = null; } }
|
KieClient { public void destroy() { if (EXECUTOR != null) { EXECUTOR.shutdown(); EXECUTOR = null; } } }
|
KieClient { public void destroy() { if (EXECUTOR != null) { EXECUTOR.shutdown(); EXECUTOR = null; } } KieClient(UpdateHandler updateHandler); }
|
KieClient { public void destroy() { if (EXECUTOR != null) { EXECUTOR.shutdown(); EXECUTOR = null; } } KieClient(UpdateHandler updateHandler); void refreshKieConfig(); void destroy(); }
|
KieClient { public void destroy() { if (EXECUTOR != null) { EXECUTOR.shutdown(); EXECUTOR = null; } } KieClient(UpdateHandler updateHandler); void refreshKieConfig(); void destroy(); }
|
@Test public void getServerUri() { String servers = KieConfig.INSTANCE.getServerUri(); Assert.assertEquals("https: }
|
public String getServerUri() { return finalConfig.getString(SERVER_URL_KEY); }
|
KieConfig { public String getServerUri() { return finalConfig.getString(SERVER_URL_KEY); } }
|
KieConfig { public String getServerUri() { return finalConfig.getString(SERVER_URL_KEY); } private KieConfig(); }
|
KieConfig { public String getServerUri() { return finalConfig.getString(SERVER_URL_KEY); } private KieConfig(); static ConcurrentCompositeConfiguration getFinalConfig(); static void setFinalConfig(ConcurrentCompositeConfiguration finalConfig); int getConnectionTimeOut(); int getEventLoopSize(); int getVerticalInstanceCount(); int getIdleTimeoutInSeconds(); String getVersion(); String getServiceName(); String getTags(); String getEnvironment(); String getAppName(); String getDomainName(); String getServerUri(); int getRefreshInterval(); int getFirstRefreshInterval(); boolean enableLongPolling(); Boolean isProxyEnable(); String getProxyHost(); int getProxyPort(); String getProxyUsername(); String getProxyPasswd(); }
|
KieConfig { public String getServerUri() { return finalConfig.getString(SERVER_URL_KEY); } private KieConfig(); static ConcurrentCompositeConfiguration getFinalConfig(); static void setFinalConfig(ConcurrentCompositeConfiguration finalConfig); int getConnectionTimeOut(); int getEventLoopSize(); int getVerticalInstanceCount(); int getIdleTimeoutInSeconds(); String getVersion(); String getServiceName(); String getTags(); String getEnvironment(); String getAppName(); String getDomainName(); String getServerUri(); int getRefreshInterval(); int getFirstRefreshInterval(); boolean enableLongPolling(); Boolean isProxyEnable(); String getProxyHost(); int getProxyPort(); String getProxyUsername(); String getProxyPasswd(); static final KieConfig 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 getEnvironment() { Assert.assertEquals("testing", KieConfig.INSTANCE.getEnvironment()); System.setProperty("SERVICECOMB_ENV", "development"); KieConfig.setFinalConfig(ConfigUtil.createLocalConfig()); Assert.assertEquals("development", KieConfig.INSTANCE.getEnvironment()); }
|
public String getEnvironment() { return BootStrapProperties.readServiceEnvironment(finalConfig); }
|
KieConfig { public String getEnvironment() { return BootStrapProperties.readServiceEnvironment(finalConfig); } }
|
KieConfig { public String getEnvironment() { return BootStrapProperties.readServiceEnvironment(finalConfig); } private KieConfig(); }
|
KieConfig { public String getEnvironment() { return BootStrapProperties.readServiceEnvironment(finalConfig); } private KieConfig(); static ConcurrentCompositeConfiguration getFinalConfig(); static void setFinalConfig(ConcurrentCompositeConfiguration finalConfig); int getConnectionTimeOut(); int getEventLoopSize(); int getVerticalInstanceCount(); int getIdleTimeoutInSeconds(); String getVersion(); String getServiceName(); String getTags(); String getEnvironment(); String getAppName(); String getDomainName(); String getServerUri(); int getRefreshInterval(); int getFirstRefreshInterval(); boolean enableLongPolling(); Boolean isProxyEnable(); String getProxyHost(); int getProxyPort(); String getProxyUsername(); String getProxyPasswd(); }
|
KieConfig { public String getEnvironment() { return BootStrapProperties.readServiceEnvironment(finalConfig); } private KieConfig(); static ConcurrentCompositeConfiguration getFinalConfig(); static void setFinalConfig(ConcurrentCompositeConfiguration finalConfig); int getConnectionTimeOut(); int getEventLoopSize(); int getVerticalInstanceCount(); int getIdleTimeoutInSeconds(); String getVersion(); String getServiceName(); String getTags(); String getEnvironment(); String getAppName(); String getDomainName(); String getServerUri(); int getRefreshInterval(); int getFirstRefreshInterval(); boolean enableLongPolling(); Boolean isProxyEnable(); String getProxyHost(); int getProxyPort(); String getProxyUsername(); String getProxyPasswd(); static final KieConfig 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_whenInstanceNotExist_shouldReturnFalse() { ServerUtil.microserviceInstanceMap = prepareServiceInstanceMap(false); boolean returnedResult = target.heartbeat(serviceId, instanceId1); Assert.assertFalse(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 testRefreshConfigItems() { boolean status = true; Map<String, Object> configMap = new HashMap<>(); configMap.put("key1", "application1"); configMap.put("key2", "application2"); configMap.put("key3", "application3"); configMap.put("key4", "application4"); Map<String, Object> result = null; try { result = Deencapsulation.invoke(KieWatcher.INSTANCE, "refreshConfigItems", configMap); } catch (Exception e) { status = false; } Assert.assertTrue(status); }
|
public void refreshConfigItems(Map<String, Object> remoteItems) { String md5Vaule = KieUtil.encrypt(remoteItems.toString()); if (CollectionUtils.isEmpty(remoteItems)) { updateHandler.handle("delete", lastTimeData); lastTimeData = remoteItems; return; } if (StringUtils.isEmpty(refreshRecord)) { refreshRecord = md5Vaule; updateHandler.handle("create", remoteItems); lastTimeData = remoteItems; return; } if (md5Vaule.equals(refreshRecord)) { return; } refreshRecord = md5Vaule; doRefresh(remoteItems); lastTimeData = remoteItems; }
|
KieWatcher { public void refreshConfigItems(Map<String, Object> remoteItems) { String md5Vaule = KieUtil.encrypt(remoteItems.toString()); if (CollectionUtils.isEmpty(remoteItems)) { updateHandler.handle("delete", lastTimeData); lastTimeData = remoteItems; return; } if (StringUtils.isEmpty(refreshRecord)) { refreshRecord = md5Vaule; updateHandler.handle("create", remoteItems); lastTimeData = remoteItems; return; } if (md5Vaule.equals(refreshRecord)) { return; } refreshRecord = md5Vaule; doRefresh(remoteItems); lastTimeData = remoteItems; } }
|
KieWatcher { public void refreshConfigItems(Map<String, Object> remoteItems) { String md5Vaule = KieUtil.encrypt(remoteItems.toString()); if (CollectionUtils.isEmpty(remoteItems)) { updateHandler.handle("delete", lastTimeData); lastTimeData = remoteItems; return; } if (StringUtils.isEmpty(refreshRecord)) { refreshRecord = md5Vaule; updateHandler.handle("create", remoteItems); lastTimeData = remoteItems; return; } if (md5Vaule.equals(refreshRecord)) { return; } refreshRecord = md5Vaule; doRefresh(remoteItems); lastTimeData = remoteItems; } private KieWatcher(); }
|
KieWatcher { public void refreshConfigItems(Map<String, Object> remoteItems) { String md5Vaule = KieUtil.encrypt(remoteItems.toString()); if (CollectionUtils.isEmpty(remoteItems)) { updateHandler.handle("delete", lastTimeData); lastTimeData = remoteItems; return; } if (StringUtils.isEmpty(refreshRecord)) { refreshRecord = md5Vaule; updateHandler.handle("create", remoteItems); lastTimeData = remoteItems; return; } if (md5Vaule.equals(refreshRecord)) { return; } refreshRecord = md5Vaule; doRefresh(remoteItems); lastTimeData = remoteItems; } private KieWatcher(); void setUpdateHandler(UpdateHandler updateHandler); void refreshConfigItems(Map<String, Object> remoteItems); }
|
KieWatcher { public void refreshConfigItems(Map<String, Object> remoteItems) { String md5Vaule = KieUtil.encrypt(remoteItems.toString()); if (CollectionUtils.isEmpty(remoteItems)) { updateHandler.handle("delete", lastTimeData); lastTimeData = remoteItems; return; } if (StringUtils.isEmpty(refreshRecord)) { refreshRecord = md5Vaule; updateHandler.handle("create", remoteItems); lastTimeData = remoteItems; return; } if (md5Vaule.equals(refreshRecord)) { return; } refreshRecord = md5Vaule; doRefresh(remoteItems); lastTimeData = remoteItems; } private KieWatcher(); void setUpdateHandler(UpdateHandler updateHandler); void refreshConfigItems(Map<String, Object> remoteItems); static final KieWatcher INSTANCE; }
|
@Test public void test_getMicroservice_whenServiceExist_shouldReturnService() { ServerUtil.microserviceInstanceMap = prepareServiceInstanceMap(true); ServerMicroserviceInstance returnedResult = target.getMicroservice(serviceId); Assert.assertNotNull(returnedResult); Assert.assertEquals(serviceId, returnedResult.getServiceId()); }
|
public ServerMicroserviceInstance getMicroservice(String microserviceId) { Map<String, ServerMicroserviceInstance> instanceIdMap = ServerUtil.microserviceInstanceMap .get(microserviceId); if (instanceIdMap != null) { List<ServerMicroserviceInstance> serverMicroserviceInstanceList = new ArrayList<>( instanceIdMap.values()); return serverMicroserviceInstanceList.get(0); } return null; }
|
ZeroConfigRegistryService { public ServerMicroserviceInstance getMicroservice(String microserviceId) { Map<String, ServerMicroserviceInstance> instanceIdMap = ServerUtil.microserviceInstanceMap .get(microserviceId); if (instanceIdMap != null) { List<ServerMicroserviceInstance> serverMicroserviceInstanceList = new ArrayList<>( instanceIdMap.values()); return serverMicroserviceInstanceList.get(0); } return null; } }
|
ZeroConfigRegistryService { public ServerMicroserviceInstance getMicroservice(String microserviceId) { Map<String, ServerMicroserviceInstance> instanceIdMap = ServerUtil.microserviceInstanceMap .get(microserviceId); if (instanceIdMap != null) { List<ServerMicroserviceInstance> serverMicroserviceInstanceList = new ArrayList<>( instanceIdMap.values()); return serverMicroserviceInstanceList.get(0); } return null; } }
|
ZeroConfigRegistryService { public ServerMicroserviceInstance getMicroservice(String microserviceId) { Map<String, ServerMicroserviceInstance> instanceIdMap = ServerUtil.microserviceInstanceMap .get(microserviceId); if (instanceIdMap != null) { List<ServerMicroserviceInstance> serverMicroserviceInstanceList = new ArrayList<>( instanceIdMap.values()); return serverMicroserviceInstanceList.get(0); } return 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 ServerMicroserviceInstance getMicroservice(String microserviceId) { Map<String, ServerMicroserviceInstance> instanceIdMap = ServerUtil.microserviceInstanceMap .get(microserviceId); if (instanceIdMap != null) { List<ServerMicroserviceInstance> serverMicroserviceInstanceList = new ArrayList<>( instanceIdMap.values()); return serverMicroserviceInstanceList.get(0); } return 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 test_getMicroservice_whenServiceNotExist_shouldReturnNull() { ServerUtil.microserviceInstanceMap = prepareServiceInstanceMap(true); ServerMicroserviceInstance returnedResult = target.getMicroservice(otherServiceId); Assert.assertNull(returnedResult); }
|
public ServerMicroserviceInstance getMicroservice(String microserviceId) { Map<String, ServerMicroserviceInstance> instanceIdMap = ServerUtil.microserviceInstanceMap .get(microserviceId); if (instanceIdMap != null) { List<ServerMicroserviceInstance> serverMicroserviceInstanceList = new ArrayList<>( instanceIdMap.values()); return serverMicroserviceInstanceList.get(0); } return null; }
|
ZeroConfigRegistryService { public ServerMicroserviceInstance getMicroservice(String microserviceId) { Map<String, ServerMicroserviceInstance> instanceIdMap = ServerUtil.microserviceInstanceMap .get(microserviceId); if (instanceIdMap != null) { List<ServerMicroserviceInstance> serverMicroserviceInstanceList = new ArrayList<>( instanceIdMap.values()); return serverMicroserviceInstanceList.get(0); } return null; } }
|
ZeroConfigRegistryService { public ServerMicroserviceInstance getMicroservice(String microserviceId) { Map<String, ServerMicroserviceInstance> instanceIdMap = ServerUtil.microserviceInstanceMap .get(microserviceId); if (instanceIdMap != null) { List<ServerMicroserviceInstance> serverMicroserviceInstanceList = new ArrayList<>( instanceIdMap.values()); return serverMicroserviceInstanceList.get(0); } return null; } }
|
ZeroConfigRegistryService { public ServerMicroserviceInstance getMicroservice(String microserviceId) { Map<String, ServerMicroserviceInstance> instanceIdMap = ServerUtil.microserviceInstanceMap .get(microserviceId); if (instanceIdMap != null) { List<ServerMicroserviceInstance> serverMicroserviceInstanceList = new ArrayList<>( instanceIdMap.values()); return serverMicroserviceInstanceList.get(0); } return 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 ServerMicroserviceInstance getMicroservice(String microserviceId) { Map<String, ServerMicroserviceInstance> instanceIdMap = ServerUtil.microserviceInstanceMap .get(microserviceId); if (instanceIdMap != null) { List<ServerMicroserviceInstance> serverMicroserviceInstanceList = new ArrayList<>( instanceIdMap.values()); return serverMicroserviceInstanceList.get(0); } return 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 test_findServiceInstances_whenInstanceExist_shouldReturnInstanceList() { ServerUtil.microserviceInstanceMap = prepareServiceInstanceMap(true); List<ServerMicroserviceInstance> returnedResult = target .findServiceInstances(appId, serviceName); Assert.assertTrue(!returnedResult.isEmpty()); Assert.assertEquals(2, returnedResult.size()); }
|
public List<ServerMicroserviceInstance> findServiceInstances(String appId, String serviceName) { List<ServerMicroserviceInstance> resultInstanceList = new ArrayList<>(); ServerUtil.microserviceInstanceMap.forEach((serviceId, instanceIdMap) -> { instanceIdMap.forEach((instanceId, instance) -> { if (appId.equals(instance.getAppId()) && serviceName.equals(instance.getServiceName())) { resultInstanceList.add(instance); } }); }); return resultInstanceList; }
|
ZeroConfigRegistryService { public List<ServerMicroserviceInstance> findServiceInstances(String appId, String serviceName) { List<ServerMicroserviceInstance> resultInstanceList = new ArrayList<>(); ServerUtil.microserviceInstanceMap.forEach((serviceId, instanceIdMap) -> { instanceIdMap.forEach((instanceId, instance) -> { if (appId.equals(instance.getAppId()) && serviceName.equals(instance.getServiceName())) { resultInstanceList.add(instance); } }); }); return resultInstanceList; } }
|
ZeroConfigRegistryService { public List<ServerMicroserviceInstance> findServiceInstances(String appId, String serviceName) { List<ServerMicroserviceInstance> resultInstanceList = new ArrayList<>(); ServerUtil.microserviceInstanceMap.forEach((serviceId, instanceIdMap) -> { instanceIdMap.forEach((instanceId, instance) -> { if (appId.equals(instance.getAppId()) && serviceName.equals(instance.getServiceName())) { resultInstanceList.add(instance); } }); }); return resultInstanceList; } }
|
ZeroConfigRegistryService { public List<ServerMicroserviceInstance> findServiceInstances(String appId, String serviceName) { List<ServerMicroserviceInstance> resultInstanceList = new ArrayList<>(); ServerUtil.microserviceInstanceMap.forEach((serviceId, instanceIdMap) -> { instanceIdMap.forEach((instanceId, instance) -> { if (appId.equals(instance.getAppId()) && serviceName.equals(instance.getServiceName())) { resultInstanceList.add(instance); } }); }); return resultInstanceList; } 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> findServiceInstances(String appId, String serviceName) { List<ServerMicroserviceInstance> resultInstanceList = new ArrayList<>(); ServerUtil.microserviceInstanceMap.forEach((serviceId, instanceIdMap) -> { instanceIdMap.forEach((instanceId, instance) -> { if (appId.equals(instance.getAppId()) && serviceName.equals(instance.getServiceName())) { resultInstanceList.add(instance); } }); }); return resultInstanceList; } 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 test_findServiceInstances_whenNoInstanceExist_shouldReturnEmptyInstanceList() { ServerUtil.microserviceInstanceMap = prepareServiceInstanceMap(true); List<ServerMicroserviceInstance> returnedResult = target .findServiceInstances(appId, otherServiceName); Assert.assertTrue(returnedResult.isEmpty()); }
|
public List<ServerMicroserviceInstance> findServiceInstances(String appId, String serviceName) { List<ServerMicroserviceInstance> resultInstanceList = new ArrayList<>(); ServerUtil.microserviceInstanceMap.forEach((serviceId, instanceIdMap) -> { instanceIdMap.forEach((instanceId, instance) -> { if (appId.equals(instance.getAppId()) && serviceName.equals(instance.getServiceName())) { resultInstanceList.add(instance); } }); }); return resultInstanceList; }
|
ZeroConfigRegistryService { public List<ServerMicroserviceInstance> findServiceInstances(String appId, String serviceName) { List<ServerMicroserviceInstance> resultInstanceList = new ArrayList<>(); ServerUtil.microserviceInstanceMap.forEach((serviceId, instanceIdMap) -> { instanceIdMap.forEach((instanceId, instance) -> { if (appId.equals(instance.getAppId()) && serviceName.equals(instance.getServiceName())) { resultInstanceList.add(instance); } }); }); return resultInstanceList; } }
|
ZeroConfigRegistryService { public List<ServerMicroserviceInstance> findServiceInstances(String appId, String serviceName) { List<ServerMicroserviceInstance> resultInstanceList = new ArrayList<>(); ServerUtil.microserviceInstanceMap.forEach((serviceId, instanceIdMap) -> { instanceIdMap.forEach((instanceId, instance) -> { if (appId.equals(instance.getAppId()) && serviceName.equals(instance.getServiceName())) { resultInstanceList.add(instance); } }); }); return resultInstanceList; } }
|
ZeroConfigRegistryService { public List<ServerMicroserviceInstance> findServiceInstances(String appId, String serviceName) { List<ServerMicroserviceInstance> resultInstanceList = new ArrayList<>(); ServerUtil.microserviceInstanceMap.forEach((serviceId, instanceIdMap) -> { instanceIdMap.forEach((instanceId, instance) -> { if (appId.equals(instance.getAppId()) && serviceName.equals(instance.getServiceName())) { resultInstanceList.add(instance); } }); }); return resultInstanceList; } 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> findServiceInstances(String appId, String serviceName) { List<ServerMicroserviceInstance> resultInstanceList = new ArrayList<>(); ServerUtil.microserviceInstanceMap.forEach((serviceId, instanceIdMap) -> { instanceIdMap.forEach((instanceId, instance) -> { if (appId.equals(instance.getAppId()) && serviceName.equals(instance.getServiceName())) { resultInstanceList.add(instance); } }); }); return resultInstanceList; } 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 enableButNotSlow() { new Expectations() { { operationConfig.isSlowInvocationEnabled(); result = true; operationConfig.getNanoSlowInvocation(); result = 2; stageTrace.calcTotalTime(); result = 1; } }; 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 testLoadbalanceExceptionUtils() { assertEquals("servicecomb.handler.lb.wrong.rule", LoadbalanceExceptionUtils.CSE_HANDLER_LB_WRONG_RULE); CseException cseException = LoadbalanceExceptionUtils.createLoadbalanceException("servicecomb.handler.lb.wrong.rule", new Throwable(), "ARGS"); Assert.assertNotNull(cseException); }
|
public static CseException createLoadbalanceException(String code, Throwable cause, Object... args) { String msg = String.format(ERROR_DESC_MGR.ensureFindValue(code), args); CseException exception = new CseException(code, msg, cause); return exception; }
|
LoadbalanceExceptionUtils extends ExceptionUtils { public static CseException createLoadbalanceException(String code, Throwable cause, Object... args) { String msg = String.format(ERROR_DESC_MGR.ensureFindValue(code), args); CseException exception = new CseException(code, msg, cause); return exception; } }
|
LoadbalanceExceptionUtils extends ExceptionUtils { public static CseException createLoadbalanceException(String code, Throwable cause, Object... args) { String msg = String.format(ERROR_DESC_MGR.ensureFindValue(code), args); CseException exception = new CseException(code, msg, cause); return exception; } }
|
LoadbalanceExceptionUtils extends ExceptionUtils { public static CseException createLoadbalanceException(String code, Throwable cause, Object... args) { String msg = String.format(ERROR_DESC_MGR.ensureFindValue(code), args); CseException exception = new CseException(code, msg, cause); return exception; } static CseException createLoadbalanceException(String code, Throwable cause, Object... args); }
|
LoadbalanceExceptionUtils extends ExceptionUtils { public static CseException createLoadbalanceException(String code, Throwable cause, Object... args) { String msg = String.format(ERROR_DESC_MGR.ensureFindValue(code), args); CseException exception = new CseException(code, msg, cause); return exception; } static CseException createLoadbalanceException(String code, Throwable cause, Object... args); static final String CSE_HANDLER_LB_WRONG_RULE; }
|
@Test public void discovery_no_instance_reach_error_threshold() { DiscoveryTreeNode childNode = filter.discovery(discoveryContext, discoveryTreeNode); Map<String, MicroserviceInstance> childNodeData = childNode.data(); Assert.assertThat(childNodeData.keySet(), Matchers.containsInAnyOrder("i0", "i1", "i2")); Assert.assertEquals(data.get("i0"), childNodeData.get("i0")); Assert.assertEquals(data.get("i1"), childNodeData.get("i1")); Assert.assertEquals(data.get("i2"), childNodeData.get("i2")); }
|
@Override public DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent) { Map<String, MicroserviceInstance> instances = parent.data(); Invocation invocation = context.getInputParameters(); if (!Configuration.INSTANCE.isIsolationFilterOpen(invocation.getMicroserviceName())) { return parent; } Map<String, MicroserviceInstance> filteredServers = new HashMap<>(); instances.entrySet().forEach(stringMicroserviceInstanceEntry -> { MicroserviceInstance instance = stringMicroserviceInstanceEntry.getValue(); if (allowVisit(invocation, instance)) { filteredServers.put(stringMicroserviceInstanceEntry.getKey(), instance); } }); DiscoveryTreeNode child = new DiscoveryTreeNode(); if (ZoneAwareDiscoveryFilter.GROUP_Instances_All .equals(context.getContextParameter(ZoneAwareDiscoveryFilter.KEY_ZONE_AWARE_STEP)) && filteredServers.isEmpty() && emptyProtection.get()) { LOGGER.warn("All servers have been isolated, allow one of them based on load balance rule."); child.data(instances); } else { child.data(filteredServers); } parent.child("filterred", child); return child; }
|
IsolationDiscoveryFilter implements DiscoveryFilter { @Override public DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent) { Map<String, MicroserviceInstance> instances = parent.data(); Invocation invocation = context.getInputParameters(); if (!Configuration.INSTANCE.isIsolationFilterOpen(invocation.getMicroserviceName())) { return parent; } Map<String, MicroserviceInstance> filteredServers = new HashMap<>(); instances.entrySet().forEach(stringMicroserviceInstanceEntry -> { MicroserviceInstance instance = stringMicroserviceInstanceEntry.getValue(); if (allowVisit(invocation, instance)) { filteredServers.put(stringMicroserviceInstanceEntry.getKey(), instance); } }); DiscoveryTreeNode child = new DiscoveryTreeNode(); if (ZoneAwareDiscoveryFilter.GROUP_Instances_All .equals(context.getContextParameter(ZoneAwareDiscoveryFilter.KEY_ZONE_AWARE_STEP)) && filteredServers.isEmpty() && emptyProtection.get()) { LOGGER.warn("All servers have been isolated, allow one of them based on load balance rule."); child.data(instances); } else { child.data(filteredServers); } parent.child("filterred", child); return child; } }
|
IsolationDiscoveryFilter implements DiscoveryFilter { @Override public DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent) { Map<String, MicroserviceInstance> instances = parent.data(); Invocation invocation = context.getInputParameters(); if (!Configuration.INSTANCE.isIsolationFilterOpen(invocation.getMicroserviceName())) { return parent; } Map<String, MicroserviceInstance> filteredServers = new HashMap<>(); instances.entrySet().forEach(stringMicroserviceInstanceEntry -> { MicroserviceInstance instance = stringMicroserviceInstanceEntry.getValue(); if (allowVisit(invocation, instance)) { filteredServers.put(stringMicroserviceInstanceEntry.getKey(), instance); } }); DiscoveryTreeNode child = new DiscoveryTreeNode(); if (ZoneAwareDiscoveryFilter.GROUP_Instances_All .equals(context.getContextParameter(ZoneAwareDiscoveryFilter.KEY_ZONE_AWARE_STEP)) && filteredServers.isEmpty() && emptyProtection.get()) { LOGGER.warn("All servers have been isolated, allow one of them based on load balance rule."); child.data(instances); } else { child.data(filteredServers); } parent.child("filterred", child); return child; } IsolationDiscoveryFilter(); }
|
IsolationDiscoveryFilter implements DiscoveryFilter { @Override public DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent) { Map<String, MicroserviceInstance> instances = parent.data(); Invocation invocation = context.getInputParameters(); if (!Configuration.INSTANCE.isIsolationFilterOpen(invocation.getMicroserviceName())) { return parent; } Map<String, MicroserviceInstance> filteredServers = new HashMap<>(); instances.entrySet().forEach(stringMicroserviceInstanceEntry -> { MicroserviceInstance instance = stringMicroserviceInstanceEntry.getValue(); if (allowVisit(invocation, instance)) { filteredServers.put(stringMicroserviceInstanceEntry.getKey(), instance); } }); DiscoveryTreeNode child = new DiscoveryTreeNode(); if (ZoneAwareDiscoveryFilter.GROUP_Instances_All .equals(context.getContextParameter(ZoneAwareDiscoveryFilter.KEY_ZONE_AWARE_STEP)) && filteredServers.isEmpty() && emptyProtection.get()) { LOGGER.warn("All servers have been isolated, allow one of them based on load balance rule."); child.data(instances); } else { child.data(filteredServers); } parent.child("filterred", child); return child; } IsolationDiscoveryFilter(); @Override int getOrder(); @Override boolean enabled(); @Override boolean isGroupingFilter(); @Override DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent); }
|
IsolationDiscoveryFilter implements DiscoveryFilter { @Override public DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent) { Map<String, MicroserviceInstance> instances = parent.data(); Invocation invocation = context.getInputParameters(); if (!Configuration.INSTANCE.isIsolationFilterOpen(invocation.getMicroserviceName())) { return parent; } Map<String, MicroserviceInstance> filteredServers = new HashMap<>(); instances.entrySet().forEach(stringMicroserviceInstanceEntry -> { MicroserviceInstance instance = stringMicroserviceInstanceEntry.getValue(); if (allowVisit(invocation, instance)) { filteredServers.put(stringMicroserviceInstanceEntry.getKey(), instance); } }); DiscoveryTreeNode child = new DiscoveryTreeNode(); if (ZoneAwareDiscoveryFilter.GROUP_Instances_All .equals(context.getContextParameter(ZoneAwareDiscoveryFilter.KEY_ZONE_AWARE_STEP)) && filteredServers.isEmpty() && emptyProtection.get()) { LOGGER.warn("All servers have been isolated, allow one of them based on load balance rule."); child.data(instances); } else { child.data(filteredServers); } parent.child("filterred", child); return child; } IsolationDiscoveryFilter(); @Override int getOrder(); @Override boolean enabled(); @Override boolean isGroupingFilter(); @Override DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent); static final String TRYING_INSTANCES_EXISTING; public EventBus eventBus; }
|
@Test public void discovery_isolate_error_instance() { ServiceCombServer server0 = ServiceCombLoadBalancerStats.INSTANCE.getServiceCombServer(data.get("i0")); for (int i = 0; i < 4; ++i) { ServiceCombLoadBalancerStats.INSTANCE.markFailure(server0); } DiscoveryTreeNode childNode = filter.discovery(discoveryContext, discoveryTreeNode); Map<String, MicroserviceInstance> childNodeData = childNode.data(); Assert.assertThat(childNodeData.keySet(), Matchers.containsInAnyOrder("i0", "i1", "i2")); Assert.assertEquals(data.get("i0"), childNodeData.get("i0")); Assert.assertEquals(data.get("i1"), childNodeData.get("i1")); Assert.assertEquals(data.get("i2"), childNodeData.get("i2")); ServiceCombLoadBalancerStats.INSTANCE.markFailure(server0); Assert.assertFalse(ServiceCombLoadBalancerStats.INSTANCE.getServiceCombServerStats(server0).isIsolated()); childNode = filter.discovery(discoveryContext, discoveryTreeNode); childNodeData = childNode.data(); Assert.assertThat(childNodeData.keySet(), Matchers.containsInAnyOrder("i1", "i2")); Assert.assertEquals(data.get("i1"), childNodeData.get("i1")); Assert.assertEquals(data.get("i2"), childNodeData.get("i2")); Assert.assertTrue(ServiceCombLoadBalancerStats.INSTANCE.getServiceCombServerStats(server0).isIsolated()); }
|
@Override public DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent) { Map<String, MicroserviceInstance> instances = parent.data(); Invocation invocation = context.getInputParameters(); if (!Configuration.INSTANCE.isIsolationFilterOpen(invocation.getMicroserviceName())) { return parent; } Map<String, MicroserviceInstance> filteredServers = new HashMap<>(); instances.entrySet().forEach(stringMicroserviceInstanceEntry -> { MicroserviceInstance instance = stringMicroserviceInstanceEntry.getValue(); if (allowVisit(invocation, instance)) { filteredServers.put(stringMicroserviceInstanceEntry.getKey(), instance); } }); DiscoveryTreeNode child = new DiscoveryTreeNode(); if (ZoneAwareDiscoveryFilter.GROUP_Instances_All .equals(context.getContextParameter(ZoneAwareDiscoveryFilter.KEY_ZONE_AWARE_STEP)) && filteredServers.isEmpty() && emptyProtection.get()) { LOGGER.warn("All servers have been isolated, allow one of them based on load balance rule."); child.data(instances); } else { child.data(filteredServers); } parent.child("filterred", child); return child; }
|
IsolationDiscoveryFilter implements DiscoveryFilter { @Override public DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent) { Map<String, MicroserviceInstance> instances = parent.data(); Invocation invocation = context.getInputParameters(); if (!Configuration.INSTANCE.isIsolationFilterOpen(invocation.getMicroserviceName())) { return parent; } Map<String, MicroserviceInstance> filteredServers = new HashMap<>(); instances.entrySet().forEach(stringMicroserviceInstanceEntry -> { MicroserviceInstance instance = stringMicroserviceInstanceEntry.getValue(); if (allowVisit(invocation, instance)) { filteredServers.put(stringMicroserviceInstanceEntry.getKey(), instance); } }); DiscoveryTreeNode child = new DiscoveryTreeNode(); if (ZoneAwareDiscoveryFilter.GROUP_Instances_All .equals(context.getContextParameter(ZoneAwareDiscoveryFilter.KEY_ZONE_AWARE_STEP)) && filteredServers.isEmpty() && emptyProtection.get()) { LOGGER.warn("All servers have been isolated, allow one of them based on load balance rule."); child.data(instances); } else { child.data(filteredServers); } parent.child("filterred", child); return child; } }
|
IsolationDiscoveryFilter implements DiscoveryFilter { @Override public DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent) { Map<String, MicroserviceInstance> instances = parent.data(); Invocation invocation = context.getInputParameters(); if (!Configuration.INSTANCE.isIsolationFilterOpen(invocation.getMicroserviceName())) { return parent; } Map<String, MicroserviceInstance> filteredServers = new HashMap<>(); instances.entrySet().forEach(stringMicroserviceInstanceEntry -> { MicroserviceInstance instance = stringMicroserviceInstanceEntry.getValue(); if (allowVisit(invocation, instance)) { filteredServers.put(stringMicroserviceInstanceEntry.getKey(), instance); } }); DiscoveryTreeNode child = new DiscoveryTreeNode(); if (ZoneAwareDiscoveryFilter.GROUP_Instances_All .equals(context.getContextParameter(ZoneAwareDiscoveryFilter.KEY_ZONE_AWARE_STEP)) && filteredServers.isEmpty() && emptyProtection.get()) { LOGGER.warn("All servers have been isolated, allow one of them based on load balance rule."); child.data(instances); } else { child.data(filteredServers); } parent.child("filterred", child); return child; } IsolationDiscoveryFilter(); }
|
IsolationDiscoveryFilter implements DiscoveryFilter { @Override public DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent) { Map<String, MicroserviceInstance> instances = parent.data(); Invocation invocation = context.getInputParameters(); if (!Configuration.INSTANCE.isIsolationFilterOpen(invocation.getMicroserviceName())) { return parent; } Map<String, MicroserviceInstance> filteredServers = new HashMap<>(); instances.entrySet().forEach(stringMicroserviceInstanceEntry -> { MicroserviceInstance instance = stringMicroserviceInstanceEntry.getValue(); if (allowVisit(invocation, instance)) { filteredServers.put(stringMicroserviceInstanceEntry.getKey(), instance); } }); DiscoveryTreeNode child = new DiscoveryTreeNode(); if (ZoneAwareDiscoveryFilter.GROUP_Instances_All .equals(context.getContextParameter(ZoneAwareDiscoveryFilter.KEY_ZONE_AWARE_STEP)) && filteredServers.isEmpty() && emptyProtection.get()) { LOGGER.warn("All servers have been isolated, allow one of them based on load balance rule."); child.data(instances); } else { child.data(filteredServers); } parent.child("filterred", child); return child; } IsolationDiscoveryFilter(); @Override int getOrder(); @Override boolean enabled(); @Override boolean isGroupingFilter(); @Override DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent); }
|
IsolationDiscoveryFilter implements DiscoveryFilter { @Override public DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent) { Map<String, MicroserviceInstance> instances = parent.data(); Invocation invocation = context.getInputParameters(); if (!Configuration.INSTANCE.isIsolationFilterOpen(invocation.getMicroserviceName())) { return parent; } Map<String, MicroserviceInstance> filteredServers = new HashMap<>(); instances.entrySet().forEach(stringMicroserviceInstanceEntry -> { MicroserviceInstance instance = stringMicroserviceInstanceEntry.getValue(); if (allowVisit(invocation, instance)) { filteredServers.put(stringMicroserviceInstanceEntry.getKey(), instance); } }); DiscoveryTreeNode child = new DiscoveryTreeNode(); if (ZoneAwareDiscoveryFilter.GROUP_Instances_All .equals(context.getContextParameter(ZoneAwareDiscoveryFilter.KEY_ZONE_AWARE_STEP)) && filteredServers.isEmpty() && emptyProtection.get()) { LOGGER.warn("All servers have been isolated, allow one of them based on load balance rule."); child.data(instances); } else { child.data(filteredServers); } parent.child("filterred", child); return child; } IsolationDiscoveryFilter(); @Override int getOrder(); @Override boolean enabled(); @Override boolean isGroupingFilter(); @Override DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent); static final String TRYING_INSTANCES_EXISTING; public EventBus eventBus; }
|
@Test public void discovery_try_isolated_instance_after_singleTestTime() { ServiceCombServer server0 = ServiceCombLoadBalancerStats.INSTANCE.getServiceCombServer(data.get("i0")); ServiceCombServerStats serviceCombServerStats = ServiceCombLoadBalancerStats.INSTANCE .getServiceCombServerStats(server0); for (int i = 0; i < 5; ++i) { serviceCombServerStats.markFailure(); } letIsolatedInstancePassSingleTestTime(serviceCombServerStats); ServiceCombLoadBalancerStats.INSTANCE.markIsolated(server0, true); Assert.assertTrue(ServiceCombServerStats.isolatedServerCanTry()); Assert.assertNull(TestServiceCombServerStats.getTryingIsolatedServerInvocation()); DiscoveryTreeNode childNode = filter.discovery(discoveryContext, discoveryTreeNode); Map<String, MicroserviceInstance> childNodeData = childNode.data(); Assert.assertThat(childNodeData.keySet(), Matchers.containsInAnyOrder("i0", "i1", "i2")); Assert.assertEquals(data.get("i0"), childNodeData.get("i0")); Assert.assertEquals(data.get("i1"), childNodeData.get("i1")); Assert.assertEquals(data.get("i2"), childNodeData.get("i2")); Assert.assertTrue(serviceCombServerStats.isIsolated()); Assert.assertFalse(ServiceCombServerStats.isolatedServerCanTry()); Assert.assertSame(invocation, TestServiceCombServerStats.getTryingIsolatedServerInvocation()); }
|
@Override public DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent) { Map<String, MicroserviceInstance> instances = parent.data(); Invocation invocation = context.getInputParameters(); if (!Configuration.INSTANCE.isIsolationFilterOpen(invocation.getMicroserviceName())) { return parent; } Map<String, MicroserviceInstance> filteredServers = new HashMap<>(); instances.entrySet().forEach(stringMicroserviceInstanceEntry -> { MicroserviceInstance instance = stringMicroserviceInstanceEntry.getValue(); if (allowVisit(invocation, instance)) { filteredServers.put(stringMicroserviceInstanceEntry.getKey(), instance); } }); DiscoveryTreeNode child = new DiscoveryTreeNode(); if (ZoneAwareDiscoveryFilter.GROUP_Instances_All .equals(context.getContextParameter(ZoneAwareDiscoveryFilter.KEY_ZONE_AWARE_STEP)) && filteredServers.isEmpty() && emptyProtection.get()) { LOGGER.warn("All servers have been isolated, allow one of them based on load balance rule."); child.data(instances); } else { child.data(filteredServers); } parent.child("filterred", child); return child; }
|
IsolationDiscoveryFilter implements DiscoveryFilter { @Override public DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent) { Map<String, MicroserviceInstance> instances = parent.data(); Invocation invocation = context.getInputParameters(); if (!Configuration.INSTANCE.isIsolationFilterOpen(invocation.getMicroserviceName())) { return parent; } Map<String, MicroserviceInstance> filteredServers = new HashMap<>(); instances.entrySet().forEach(stringMicroserviceInstanceEntry -> { MicroserviceInstance instance = stringMicroserviceInstanceEntry.getValue(); if (allowVisit(invocation, instance)) { filteredServers.put(stringMicroserviceInstanceEntry.getKey(), instance); } }); DiscoveryTreeNode child = new DiscoveryTreeNode(); if (ZoneAwareDiscoveryFilter.GROUP_Instances_All .equals(context.getContextParameter(ZoneAwareDiscoveryFilter.KEY_ZONE_AWARE_STEP)) && filteredServers.isEmpty() && emptyProtection.get()) { LOGGER.warn("All servers have been isolated, allow one of them based on load balance rule."); child.data(instances); } else { child.data(filteredServers); } parent.child("filterred", child); return child; } }
|
IsolationDiscoveryFilter implements DiscoveryFilter { @Override public DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent) { Map<String, MicroserviceInstance> instances = parent.data(); Invocation invocation = context.getInputParameters(); if (!Configuration.INSTANCE.isIsolationFilterOpen(invocation.getMicroserviceName())) { return parent; } Map<String, MicroserviceInstance> filteredServers = new HashMap<>(); instances.entrySet().forEach(stringMicroserviceInstanceEntry -> { MicroserviceInstance instance = stringMicroserviceInstanceEntry.getValue(); if (allowVisit(invocation, instance)) { filteredServers.put(stringMicroserviceInstanceEntry.getKey(), instance); } }); DiscoveryTreeNode child = new DiscoveryTreeNode(); if (ZoneAwareDiscoveryFilter.GROUP_Instances_All .equals(context.getContextParameter(ZoneAwareDiscoveryFilter.KEY_ZONE_AWARE_STEP)) && filteredServers.isEmpty() && emptyProtection.get()) { LOGGER.warn("All servers have been isolated, allow one of them based on load balance rule."); child.data(instances); } else { child.data(filteredServers); } parent.child("filterred", child); return child; } IsolationDiscoveryFilter(); }
|
IsolationDiscoveryFilter implements DiscoveryFilter { @Override public DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent) { Map<String, MicroserviceInstance> instances = parent.data(); Invocation invocation = context.getInputParameters(); if (!Configuration.INSTANCE.isIsolationFilterOpen(invocation.getMicroserviceName())) { return parent; } Map<String, MicroserviceInstance> filteredServers = new HashMap<>(); instances.entrySet().forEach(stringMicroserviceInstanceEntry -> { MicroserviceInstance instance = stringMicroserviceInstanceEntry.getValue(); if (allowVisit(invocation, instance)) { filteredServers.put(stringMicroserviceInstanceEntry.getKey(), instance); } }); DiscoveryTreeNode child = new DiscoveryTreeNode(); if (ZoneAwareDiscoveryFilter.GROUP_Instances_All .equals(context.getContextParameter(ZoneAwareDiscoveryFilter.KEY_ZONE_AWARE_STEP)) && filteredServers.isEmpty() && emptyProtection.get()) { LOGGER.warn("All servers have been isolated, allow one of them based on load balance rule."); child.data(instances); } else { child.data(filteredServers); } parent.child("filterred", child); return child; } IsolationDiscoveryFilter(); @Override int getOrder(); @Override boolean enabled(); @Override boolean isGroupingFilter(); @Override DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent); }
|
IsolationDiscoveryFilter implements DiscoveryFilter { @Override public DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent) { Map<String, MicroserviceInstance> instances = parent.data(); Invocation invocation = context.getInputParameters(); if (!Configuration.INSTANCE.isIsolationFilterOpen(invocation.getMicroserviceName())) { return parent; } Map<String, MicroserviceInstance> filteredServers = new HashMap<>(); instances.entrySet().forEach(stringMicroserviceInstanceEntry -> { MicroserviceInstance instance = stringMicroserviceInstanceEntry.getValue(); if (allowVisit(invocation, instance)) { filteredServers.put(stringMicroserviceInstanceEntry.getKey(), instance); } }); DiscoveryTreeNode child = new DiscoveryTreeNode(); if (ZoneAwareDiscoveryFilter.GROUP_Instances_All .equals(context.getContextParameter(ZoneAwareDiscoveryFilter.KEY_ZONE_AWARE_STEP)) && filteredServers.isEmpty() && emptyProtection.get()) { LOGGER.warn("All servers have been isolated, allow one of them based on load balance rule."); child.data(instances); } else { child.data(filteredServers); } parent.child("filterred", child); return child; } IsolationDiscoveryFilter(); @Override int getOrder(); @Override boolean enabled(); @Override boolean isGroupingFilter(); @Override DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent); static final String TRYING_INSTANCES_EXISTING; public EventBus eventBus; }
|
@Test public void discovery_not_try_isolated_instance_concurrently() { ServiceCombServer server0 = ServiceCombLoadBalancerStats.INSTANCE.getServiceCombServer(data.get("i0")); ServiceCombServerStats serviceCombServerStats = ServiceCombLoadBalancerStats.INSTANCE .getServiceCombServerStats(server0); for (int i = 0; i < 5; ++i) { serviceCombServerStats.markFailure(); } ServiceCombLoadBalancerStats.INSTANCE.markIsolated(server0, true); letIsolatedInstancePassSingleTestTime(serviceCombServerStats); Assert.assertTrue(ServiceCombServerStats.isolatedServerCanTry()); DiscoveryTreeNode childNode = filter.discovery(discoveryContext, discoveryTreeNode); Map<String, MicroserviceInstance> childNodeData = childNode.data(); Assert.assertThat(childNodeData.keySet(), Matchers.containsInAnyOrder("i0", "i1", "i2")); Assert.assertEquals(data.get("i0"), childNodeData.get("i0")); Assert.assertEquals(data.get("i1"), childNodeData.get("i1")); Assert.assertEquals(data.get("i2"), childNodeData.get("i2")); Assert.assertFalse(ServiceCombServerStats.isolatedServerCanTry()); childNode = filter.discovery(discoveryContext, discoveryTreeNode); childNodeData = childNode.data(); Assert.assertThat(childNodeData.keySet(), Matchers.containsInAnyOrder("i1", "i2")); Assert.assertEquals(data.get("i1"), childNodeData.get("i1")); Assert.assertEquals(data.get("i2"), childNodeData.get("i2")); ServiceCombServerStats .checkAndReleaseTryingChance(invocation); childNode = filter.discovery(discoveryContext, discoveryTreeNode); childNodeData = childNode.data(); Assert.assertThat(childNodeData.keySet(), Matchers.containsInAnyOrder("i0", "i1", "i2")); Assert.assertEquals(data.get("i0"), childNodeData.get("i0")); Assert.assertEquals(data.get("i1"), childNodeData.get("i1")); Assert.assertEquals(data.get("i2"), childNodeData.get("i2")); Assert.assertFalse(ServiceCombServerStats.isolatedServerCanTry()); }
|
@Override public DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent) { Map<String, MicroserviceInstance> instances = parent.data(); Invocation invocation = context.getInputParameters(); if (!Configuration.INSTANCE.isIsolationFilterOpen(invocation.getMicroserviceName())) { return parent; } Map<String, MicroserviceInstance> filteredServers = new HashMap<>(); instances.entrySet().forEach(stringMicroserviceInstanceEntry -> { MicroserviceInstance instance = stringMicroserviceInstanceEntry.getValue(); if (allowVisit(invocation, instance)) { filteredServers.put(stringMicroserviceInstanceEntry.getKey(), instance); } }); DiscoveryTreeNode child = new DiscoveryTreeNode(); if (ZoneAwareDiscoveryFilter.GROUP_Instances_All .equals(context.getContextParameter(ZoneAwareDiscoveryFilter.KEY_ZONE_AWARE_STEP)) && filteredServers.isEmpty() && emptyProtection.get()) { LOGGER.warn("All servers have been isolated, allow one of them based on load balance rule."); child.data(instances); } else { child.data(filteredServers); } parent.child("filterred", child); return child; }
|
IsolationDiscoveryFilter implements DiscoveryFilter { @Override public DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent) { Map<String, MicroserviceInstance> instances = parent.data(); Invocation invocation = context.getInputParameters(); if (!Configuration.INSTANCE.isIsolationFilterOpen(invocation.getMicroserviceName())) { return parent; } Map<String, MicroserviceInstance> filteredServers = new HashMap<>(); instances.entrySet().forEach(stringMicroserviceInstanceEntry -> { MicroserviceInstance instance = stringMicroserviceInstanceEntry.getValue(); if (allowVisit(invocation, instance)) { filteredServers.put(stringMicroserviceInstanceEntry.getKey(), instance); } }); DiscoveryTreeNode child = new DiscoveryTreeNode(); if (ZoneAwareDiscoveryFilter.GROUP_Instances_All .equals(context.getContextParameter(ZoneAwareDiscoveryFilter.KEY_ZONE_AWARE_STEP)) && filteredServers.isEmpty() && emptyProtection.get()) { LOGGER.warn("All servers have been isolated, allow one of them based on load balance rule."); child.data(instances); } else { child.data(filteredServers); } parent.child("filterred", child); return child; } }
|
IsolationDiscoveryFilter implements DiscoveryFilter { @Override public DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent) { Map<String, MicroserviceInstance> instances = parent.data(); Invocation invocation = context.getInputParameters(); if (!Configuration.INSTANCE.isIsolationFilterOpen(invocation.getMicroserviceName())) { return parent; } Map<String, MicroserviceInstance> filteredServers = new HashMap<>(); instances.entrySet().forEach(stringMicroserviceInstanceEntry -> { MicroserviceInstance instance = stringMicroserviceInstanceEntry.getValue(); if (allowVisit(invocation, instance)) { filteredServers.put(stringMicroserviceInstanceEntry.getKey(), instance); } }); DiscoveryTreeNode child = new DiscoveryTreeNode(); if (ZoneAwareDiscoveryFilter.GROUP_Instances_All .equals(context.getContextParameter(ZoneAwareDiscoveryFilter.KEY_ZONE_AWARE_STEP)) && filteredServers.isEmpty() && emptyProtection.get()) { LOGGER.warn("All servers have been isolated, allow one of them based on load balance rule."); child.data(instances); } else { child.data(filteredServers); } parent.child("filterred", child); return child; } IsolationDiscoveryFilter(); }
|
IsolationDiscoveryFilter implements DiscoveryFilter { @Override public DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent) { Map<String, MicroserviceInstance> instances = parent.data(); Invocation invocation = context.getInputParameters(); if (!Configuration.INSTANCE.isIsolationFilterOpen(invocation.getMicroserviceName())) { return parent; } Map<String, MicroserviceInstance> filteredServers = new HashMap<>(); instances.entrySet().forEach(stringMicroserviceInstanceEntry -> { MicroserviceInstance instance = stringMicroserviceInstanceEntry.getValue(); if (allowVisit(invocation, instance)) { filteredServers.put(stringMicroserviceInstanceEntry.getKey(), instance); } }); DiscoveryTreeNode child = new DiscoveryTreeNode(); if (ZoneAwareDiscoveryFilter.GROUP_Instances_All .equals(context.getContextParameter(ZoneAwareDiscoveryFilter.KEY_ZONE_AWARE_STEP)) && filteredServers.isEmpty() && emptyProtection.get()) { LOGGER.warn("All servers have been isolated, allow one of them based on load balance rule."); child.data(instances); } else { child.data(filteredServers); } parent.child("filterred", child); return child; } IsolationDiscoveryFilter(); @Override int getOrder(); @Override boolean enabled(); @Override boolean isGroupingFilter(); @Override DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent); }
|
IsolationDiscoveryFilter implements DiscoveryFilter { @Override public DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent) { Map<String, MicroserviceInstance> instances = parent.data(); Invocation invocation = context.getInputParameters(); if (!Configuration.INSTANCE.isIsolationFilterOpen(invocation.getMicroserviceName())) { return parent; } Map<String, MicroserviceInstance> filteredServers = new HashMap<>(); instances.entrySet().forEach(stringMicroserviceInstanceEntry -> { MicroserviceInstance instance = stringMicroserviceInstanceEntry.getValue(); if (allowVisit(invocation, instance)) { filteredServers.put(stringMicroserviceInstanceEntry.getKey(), instance); } }); DiscoveryTreeNode child = new DiscoveryTreeNode(); if (ZoneAwareDiscoveryFilter.GROUP_Instances_All .equals(context.getContextParameter(ZoneAwareDiscoveryFilter.KEY_ZONE_AWARE_STEP)) && filteredServers.isEmpty() && emptyProtection.get()) { LOGGER.warn("All servers have been isolated, allow one of them based on load balance rule."); child.data(instances); } else { child.data(filteredServers); } parent.child("filterred", child); return child; } IsolationDiscoveryFilter(); @Override int getOrder(); @Override boolean enabled(); @Override boolean isGroupingFilter(); @Override DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent); static final String TRYING_INSTANCES_EXISTING; public EventBus eventBus; }
|
@Test public void discovery_keep_minIsolationTime() { ServiceCombServer server0 = ServiceCombLoadBalancerStats.INSTANCE.getServiceCombServer(data.get("i0")); ServiceCombLoadBalancerStats.INSTANCE.markIsolated(server0, true); ServiceCombLoadBalancerStats.INSTANCE.markSuccess(server0); DiscoveryTreeNode childNode = filter.discovery(discoveryContext, discoveryTreeNode); Map<String, MicroserviceInstance> childNodeData = childNode.data(); Assert.assertThat(childNodeData.keySet(), Matchers.containsInAnyOrder("i1", "i2")); Assert.assertEquals(data.get("i1"), childNodeData.get("i1")); Assert.assertEquals(data.get("i2"), childNodeData.get("i2")); ServiceCombServerStats serviceCombServerStats = ServiceCombLoadBalancerStats.INSTANCE .getServiceCombServerStats(server0); Deencapsulation.setField(serviceCombServerStats, "lastVisitTime", System.currentTimeMillis() - Configuration.INSTANCE.getMinIsolationTime(invocation.getMicroserviceName()) - 1); childNode = filter.discovery(discoveryContext, discoveryTreeNode); childNodeData = childNode.data(); Assert.assertThat(childNodeData.keySet(), Matchers.containsInAnyOrder("i0", "i1", "i2")); Assert.assertEquals(data.get("i0"), childNodeData.get("i0")); Assert.assertEquals(data.get("i1"), childNodeData.get("i1")); Assert.assertEquals(data.get("i2"), childNodeData.get("i2")); }
|
@Override public DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent) { Map<String, MicroserviceInstance> instances = parent.data(); Invocation invocation = context.getInputParameters(); if (!Configuration.INSTANCE.isIsolationFilterOpen(invocation.getMicroserviceName())) { return parent; } Map<String, MicroserviceInstance> filteredServers = new HashMap<>(); instances.entrySet().forEach(stringMicroserviceInstanceEntry -> { MicroserviceInstance instance = stringMicroserviceInstanceEntry.getValue(); if (allowVisit(invocation, instance)) { filteredServers.put(stringMicroserviceInstanceEntry.getKey(), instance); } }); DiscoveryTreeNode child = new DiscoveryTreeNode(); if (ZoneAwareDiscoveryFilter.GROUP_Instances_All .equals(context.getContextParameter(ZoneAwareDiscoveryFilter.KEY_ZONE_AWARE_STEP)) && filteredServers.isEmpty() && emptyProtection.get()) { LOGGER.warn("All servers have been isolated, allow one of them based on load balance rule."); child.data(instances); } else { child.data(filteredServers); } parent.child("filterred", child); return child; }
|
IsolationDiscoveryFilter implements DiscoveryFilter { @Override public DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent) { Map<String, MicroserviceInstance> instances = parent.data(); Invocation invocation = context.getInputParameters(); if (!Configuration.INSTANCE.isIsolationFilterOpen(invocation.getMicroserviceName())) { return parent; } Map<String, MicroserviceInstance> filteredServers = new HashMap<>(); instances.entrySet().forEach(stringMicroserviceInstanceEntry -> { MicroserviceInstance instance = stringMicroserviceInstanceEntry.getValue(); if (allowVisit(invocation, instance)) { filteredServers.put(stringMicroserviceInstanceEntry.getKey(), instance); } }); DiscoveryTreeNode child = new DiscoveryTreeNode(); if (ZoneAwareDiscoveryFilter.GROUP_Instances_All .equals(context.getContextParameter(ZoneAwareDiscoveryFilter.KEY_ZONE_AWARE_STEP)) && filteredServers.isEmpty() && emptyProtection.get()) { LOGGER.warn("All servers have been isolated, allow one of them based on load balance rule."); child.data(instances); } else { child.data(filteredServers); } parent.child("filterred", child); return child; } }
|
IsolationDiscoveryFilter implements DiscoveryFilter { @Override public DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent) { Map<String, MicroserviceInstance> instances = parent.data(); Invocation invocation = context.getInputParameters(); if (!Configuration.INSTANCE.isIsolationFilterOpen(invocation.getMicroserviceName())) { return parent; } Map<String, MicroserviceInstance> filteredServers = new HashMap<>(); instances.entrySet().forEach(stringMicroserviceInstanceEntry -> { MicroserviceInstance instance = stringMicroserviceInstanceEntry.getValue(); if (allowVisit(invocation, instance)) { filteredServers.put(stringMicroserviceInstanceEntry.getKey(), instance); } }); DiscoveryTreeNode child = new DiscoveryTreeNode(); if (ZoneAwareDiscoveryFilter.GROUP_Instances_All .equals(context.getContextParameter(ZoneAwareDiscoveryFilter.KEY_ZONE_AWARE_STEP)) && filteredServers.isEmpty() && emptyProtection.get()) { LOGGER.warn("All servers have been isolated, allow one of them based on load balance rule."); child.data(instances); } else { child.data(filteredServers); } parent.child("filterred", child); return child; } IsolationDiscoveryFilter(); }
|
IsolationDiscoveryFilter implements DiscoveryFilter { @Override public DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent) { Map<String, MicroserviceInstance> instances = parent.data(); Invocation invocation = context.getInputParameters(); if (!Configuration.INSTANCE.isIsolationFilterOpen(invocation.getMicroserviceName())) { return parent; } Map<String, MicroserviceInstance> filteredServers = new HashMap<>(); instances.entrySet().forEach(stringMicroserviceInstanceEntry -> { MicroserviceInstance instance = stringMicroserviceInstanceEntry.getValue(); if (allowVisit(invocation, instance)) { filteredServers.put(stringMicroserviceInstanceEntry.getKey(), instance); } }); DiscoveryTreeNode child = new DiscoveryTreeNode(); if (ZoneAwareDiscoveryFilter.GROUP_Instances_All .equals(context.getContextParameter(ZoneAwareDiscoveryFilter.KEY_ZONE_AWARE_STEP)) && filteredServers.isEmpty() && emptyProtection.get()) { LOGGER.warn("All servers have been isolated, allow one of them based on load balance rule."); child.data(instances); } else { child.data(filteredServers); } parent.child("filterred", child); return child; } IsolationDiscoveryFilter(); @Override int getOrder(); @Override boolean enabled(); @Override boolean isGroupingFilter(); @Override DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent); }
|
IsolationDiscoveryFilter implements DiscoveryFilter { @Override public DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent) { Map<String, MicroserviceInstance> instances = parent.data(); Invocation invocation = context.getInputParameters(); if (!Configuration.INSTANCE.isIsolationFilterOpen(invocation.getMicroserviceName())) { return parent; } Map<String, MicroserviceInstance> filteredServers = new HashMap<>(); instances.entrySet().forEach(stringMicroserviceInstanceEntry -> { MicroserviceInstance instance = stringMicroserviceInstanceEntry.getValue(); if (allowVisit(invocation, instance)) { filteredServers.put(stringMicroserviceInstanceEntry.getKey(), instance); } }); DiscoveryTreeNode child = new DiscoveryTreeNode(); if (ZoneAwareDiscoveryFilter.GROUP_Instances_All .equals(context.getContextParameter(ZoneAwareDiscoveryFilter.KEY_ZONE_AWARE_STEP)) && filteredServers.isEmpty() && emptyProtection.get()) { LOGGER.warn("All servers have been isolated, allow one of them based on load balance rule."); child.data(instances); } else { child.data(filteredServers); } parent.child("filterred", child); return child; } IsolationDiscoveryFilter(); @Override int getOrder(); @Override boolean enabled(); @Override boolean isGroupingFilter(); @Override DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent); static final String TRYING_INSTANCES_EXISTING; public EventBus eventBus; }
|
@Test public void discovery_recover_instance() { ServiceCombServer server0 = ServiceCombLoadBalancerStats.INSTANCE.getServiceCombServer(data.get("i0")); ServiceCombLoadBalancerStats.INSTANCE.markSuccess(server0); ServiceCombServerStats serviceCombServerStats = ServiceCombLoadBalancerStats.INSTANCE .getServiceCombServerStats(server0); Deencapsulation.setField(serviceCombServerStats, "lastVisitTime", System.currentTimeMillis() - Configuration.INSTANCE.getMinIsolationTime(invocation.getMicroserviceName()) - 1); ServiceCombLoadBalancerStats.INSTANCE.markIsolated(server0, true); DiscoveryTreeNode childNode = filter.discovery(discoveryContext, discoveryTreeNode); Map<String, MicroserviceInstance> childNodeData = childNode.data(); Assert.assertThat(childNodeData.keySet(), Matchers.containsInAnyOrder("i0", "i1", "i2")); Assert.assertEquals(data.get("i0"), childNodeData.get("i0")); Assert.assertEquals(data.get("i1"), childNodeData.get("i1")); Assert.assertEquals(data.get("i2"), childNodeData.get("i2")); Assert.assertFalse(ServiceCombLoadBalancerStats.INSTANCE.getServiceCombServerStats(server0).isIsolated()); }
|
@Override public DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent) { Map<String, MicroserviceInstance> instances = parent.data(); Invocation invocation = context.getInputParameters(); if (!Configuration.INSTANCE.isIsolationFilterOpen(invocation.getMicroserviceName())) { return parent; } Map<String, MicroserviceInstance> filteredServers = new HashMap<>(); instances.entrySet().forEach(stringMicroserviceInstanceEntry -> { MicroserviceInstance instance = stringMicroserviceInstanceEntry.getValue(); if (allowVisit(invocation, instance)) { filteredServers.put(stringMicroserviceInstanceEntry.getKey(), instance); } }); DiscoveryTreeNode child = new DiscoveryTreeNode(); if (ZoneAwareDiscoveryFilter.GROUP_Instances_All .equals(context.getContextParameter(ZoneAwareDiscoveryFilter.KEY_ZONE_AWARE_STEP)) && filteredServers.isEmpty() && emptyProtection.get()) { LOGGER.warn("All servers have been isolated, allow one of them based on load balance rule."); child.data(instances); } else { child.data(filteredServers); } parent.child("filterred", child); return child; }
|
IsolationDiscoveryFilter implements DiscoveryFilter { @Override public DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent) { Map<String, MicroserviceInstance> instances = parent.data(); Invocation invocation = context.getInputParameters(); if (!Configuration.INSTANCE.isIsolationFilterOpen(invocation.getMicroserviceName())) { return parent; } Map<String, MicroserviceInstance> filteredServers = new HashMap<>(); instances.entrySet().forEach(stringMicroserviceInstanceEntry -> { MicroserviceInstance instance = stringMicroserviceInstanceEntry.getValue(); if (allowVisit(invocation, instance)) { filteredServers.put(stringMicroserviceInstanceEntry.getKey(), instance); } }); DiscoveryTreeNode child = new DiscoveryTreeNode(); if (ZoneAwareDiscoveryFilter.GROUP_Instances_All .equals(context.getContextParameter(ZoneAwareDiscoveryFilter.KEY_ZONE_AWARE_STEP)) && filteredServers.isEmpty() && emptyProtection.get()) { LOGGER.warn("All servers have been isolated, allow one of them based on load balance rule."); child.data(instances); } else { child.data(filteredServers); } parent.child("filterred", child); return child; } }
|
IsolationDiscoveryFilter implements DiscoveryFilter { @Override public DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent) { Map<String, MicroserviceInstance> instances = parent.data(); Invocation invocation = context.getInputParameters(); if (!Configuration.INSTANCE.isIsolationFilterOpen(invocation.getMicroserviceName())) { return parent; } Map<String, MicroserviceInstance> filteredServers = new HashMap<>(); instances.entrySet().forEach(stringMicroserviceInstanceEntry -> { MicroserviceInstance instance = stringMicroserviceInstanceEntry.getValue(); if (allowVisit(invocation, instance)) { filteredServers.put(stringMicroserviceInstanceEntry.getKey(), instance); } }); DiscoveryTreeNode child = new DiscoveryTreeNode(); if (ZoneAwareDiscoveryFilter.GROUP_Instances_All .equals(context.getContextParameter(ZoneAwareDiscoveryFilter.KEY_ZONE_AWARE_STEP)) && filteredServers.isEmpty() && emptyProtection.get()) { LOGGER.warn("All servers have been isolated, allow one of them based on load balance rule."); child.data(instances); } else { child.data(filteredServers); } parent.child("filterred", child); return child; } IsolationDiscoveryFilter(); }
|
IsolationDiscoveryFilter implements DiscoveryFilter { @Override public DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent) { Map<String, MicroserviceInstance> instances = parent.data(); Invocation invocation = context.getInputParameters(); if (!Configuration.INSTANCE.isIsolationFilterOpen(invocation.getMicroserviceName())) { return parent; } Map<String, MicroserviceInstance> filteredServers = new HashMap<>(); instances.entrySet().forEach(stringMicroserviceInstanceEntry -> { MicroserviceInstance instance = stringMicroserviceInstanceEntry.getValue(); if (allowVisit(invocation, instance)) { filteredServers.put(stringMicroserviceInstanceEntry.getKey(), instance); } }); DiscoveryTreeNode child = new DiscoveryTreeNode(); if (ZoneAwareDiscoveryFilter.GROUP_Instances_All .equals(context.getContextParameter(ZoneAwareDiscoveryFilter.KEY_ZONE_AWARE_STEP)) && filteredServers.isEmpty() && emptyProtection.get()) { LOGGER.warn("All servers have been isolated, allow one of them based on load balance rule."); child.data(instances); } else { child.data(filteredServers); } parent.child("filterred", child); return child; } IsolationDiscoveryFilter(); @Override int getOrder(); @Override boolean enabled(); @Override boolean isGroupingFilter(); @Override DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent); }
|
IsolationDiscoveryFilter implements DiscoveryFilter { @Override public DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent) { Map<String, MicroserviceInstance> instances = parent.data(); Invocation invocation = context.getInputParameters(); if (!Configuration.INSTANCE.isIsolationFilterOpen(invocation.getMicroserviceName())) { return parent; } Map<String, MicroserviceInstance> filteredServers = new HashMap<>(); instances.entrySet().forEach(stringMicroserviceInstanceEntry -> { MicroserviceInstance instance = stringMicroserviceInstanceEntry.getValue(); if (allowVisit(invocation, instance)) { filteredServers.put(stringMicroserviceInstanceEntry.getKey(), instance); } }); DiscoveryTreeNode child = new DiscoveryTreeNode(); if (ZoneAwareDiscoveryFilter.GROUP_Instances_All .equals(context.getContextParameter(ZoneAwareDiscoveryFilter.KEY_ZONE_AWARE_STEP)) && filteredServers.isEmpty() && emptyProtection.get()) { LOGGER.warn("All servers have been isolated, allow one of them based on load balance rule."); child.data(instances); } else { child.data(filteredServers); } parent.child("filterred", child); return child; } IsolationDiscoveryFilter(); @Override int getOrder(); @Override boolean enabled(); @Override boolean isGroupingFilter(); @Override DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent); static final String TRYING_INSTANCES_EXISTING; public EventBus eventBus; }
|
@Test public void testAllowVisit() { Map<String, String> filterOptions = new HashMap<>(); Assert.assertTrue(filter.allowVisit(instance, filterOptions)); filterOptions.put("tag0", "value0"); Assert.assertTrue(filter.allowVisit(instance, filterOptions)); filterOptions.put("tag2", "value2"); Assert.assertFalse(filter.allowVisit(instance, filterOptions)); filterOptions.clear(); filterOptions.put("tag0", "value1"); Assert.assertFalse(filter.allowVisit(instance, filterOptions)); }
|
protected boolean allowVisit(MicroserviceInstance instance, Map<String, String> filterOptions) { Map<String, String> propertiesMap = instance.getProperties(); for (Entry<String, String> entry : filterOptions.entrySet()) { if (!entry.getValue().equals(propertiesMap.get(entry.getKey()))) { return false; } } return true; }
|
InstancePropertyDiscoveryFilter extends AbstractDiscoveryFilter { protected boolean allowVisit(MicroserviceInstance instance, Map<String, String> filterOptions) { Map<String, String> propertiesMap = instance.getProperties(); for (Entry<String, String> entry : filterOptions.entrySet()) { if (!entry.getValue().equals(propertiesMap.get(entry.getKey()))) { return false; } } return true; } }
|
InstancePropertyDiscoveryFilter extends AbstractDiscoveryFilter { protected boolean allowVisit(MicroserviceInstance instance, Map<String, String> filterOptions) { Map<String, String> propertiesMap = instance.getProperties(); for (Entry<String, String> entry : filterOptions.entrySet()) { if (!entry.getValue().equals(propertiesMap.get(entry.getKey()))) { return false; } } return true; } }
|
InstancePropertyDiscoveryFilter extends AbstractDiscoveryFilter { protected boolean allowVisit(MicroserviceInstance instance, Map<String, String> filterOptions) { Map<String, String> propertiesMap = instance.getProperties(); for (Entry<String, String> entry : filterOptions.entrySet()) { if (!entry.getValue().equals(propertiesMap.get(entry.getKey()))) { return false; } } return true; } @Override int getOrder(); @Override boolean enabled(); @Override boolean isGroupingFilter(); }
|
InstancePropertyDiscoveryFilter extends AbstractDiscoveryFilter { protected boolean allowVisit(MicroserviceInstance instance, Map<String, String> filterOptions) { Map<String, String> propertiesMap = instance.getProperties(); for (Entry<String, String> entry : filterOptions.entrySet()) { if (!entry.getValue().equals(propertiesMap.get(entry.getKey()))) { return false; } } return true; } @Override int getOrder(); @Override boolean enabled(); @Override boolean isGroupingFilter(); }
|
@Test public void createEndpoint_TransportNotExist() { new Expectations(transportManager) { { transportManager.findTransport(anyString); result = null; } }; ServiceCombServer server = (ServiceCombServer) filter.createEndpoint(Const.RESTFUL, null, null); Assert.assertNull(server); }
|
@Override protected Object createEndpoint(String transportName, String endpoint, MicroserviceInstance instance) { Transport transport = SCBEngine.getInstance().getTransportManager().findTransport(transportName); if (transport == null) { LOGGER.info("not deployed transport {}, ignore {}.", transportName, endpoint); return null; } return new ServiceCombServer(transport, new CacheEndpoint(endpoint, instance)); }
|
ServerDiscoveryFilter extends EndpointDiscoveryFilter { @Override protected Object createEndpoint(String transportName, String endpoint, MicroserviceInstance instance) { Transport transport = SCBEngine.getInstance().getTransportManager().findTransport(transportName); if (transport == null) { LOGGER.info("not deployed transport {}, ignore {}.", transportName, endpoint); return null; } return new ServiceCombServer(transport, new CacheEndpoint(endpoint, instance)); } }
|
ServerDiscoveryFilter extends EndpointDiscoveryFilter { @Override protected Object createEndpoint(String transportName, String endpoint, MicroserviceInstance instance) { Transport transport = SCBEngine.getInstance().getTransportManager().findTransport(transportName); if (transport == null) { LOGGER.info("not deployed transport {}, ignore {}.", transportName, endpoint); return null; } return new ServiceCombServer(transport, new CacheEndpoint(endpoint, instance)); } }
|
ServerDiscoveryFilter extends EndpointDiscoveryFilter { @Override protected Object createEndpoint(String transportName, String endpoint, MicroserviceInstance instance) { Transport transport = SCBEngine.getInstance().getTransportManager().findTransport(transportName); if (transport == null) { LOGGER.info("not deployed transport {}, ignore {}.", transportName, endpoint); return null; } return new ServiceCombServer(transport, new CacheEndpoint(endpoint, instance)); } }
|
ServerDiscoveryFilter extends EndpointDiscoveryFilter { @Override protected Object createEndpoint(String transportName, String endpoint, MicroserviceInstance instance) { Transport transport = SCBEngine.getInstance().getTransportManager().findTransport(transportName); if (transport == null) { LOGGER.info("not deployed transport {}, ignore {}.", transportName, endpoint); return null; } return new ServiceCombServer(transport, new CacheEndpoint(endpoint, instance)); } }
|
@Test public void createEndpointNormal() { new Expectations(transportManager) { { transportManager.findTransport(anyString); result = trasport; } }; MicroserviceInstance instance = new MicroserviceInstance(); instance.setInstanceId("0000001"); ServiceCombServer server = (ServiceCombServer) filter .createEndpoint(Const.RESTFUL, "rest: Assert.assertSame(instance, server.getInstance()); Assert.assertSame(trasport, server.getEndpoint().getTransport()); Assert.assertEquals("rest: }
|
@Override protected Object createEndpoint(String transportName, String endpoint, MicroserviceInstance instance) { Transport transport = SCBEngine.getInstance().getTransportManager().findTransport(transportName); if (transport == null) { LOGGER.info("not deployed transport {}, ignore {}.", transportName, endpoint); return null; } return new ServiceCombServer(transport, new CacheEndpoint(endpoint, instance)); }
|
ServerDiscoveryFilter extends EndpointDiscoveryFilter { @Override protected Object createEndpoint(String transportName, String endpoint, MicroserviceInstance instance) { Transport transport = SCBEngine.getInstance().getTransportManager().findTransport(transportName); if (transport == null) { LOGGER.info("not deployed transport {}, ignore {}.", transportName, endpoint); return null; } return new ServiceCombServer(transport, new CacheEndpoint(endpoint, instance)); } }
|
ServerDiscoveryFilter extends EndpointDiscoveryFilter { @Override protected Object createEndpoint(String transportName, String endpoint, MicroserviceInstance instance) { Transport transport = SCBEngine.getInstance().getTransportManager().findTransport(transportName); if (transport == null) { LOGGER.info("not deployed transport {}, ignore {}.", transportName, endpoint); return null; } return new ServiceCombServer(transport, new CacheEndpoint(endpoint, instance)); } }
|
ServerDiscoveryFilter extends EndpointDiscoveryFilter { @Override protected Object createEndpoint(String transportName, String endpoint, MicroserviceInstance instance) { Transport transport = SCBEngine.getInstance().getTransportManager().findTransport(transportName); if (transport == null) { LOGGER.info("not deployed transport {}, ignore {}.", transportName, endpoint); return null; } return new ServiceCombServer(transport, new CacheEndpoint(endpoint, instance)); } }
|
ServerDiscoveryFilter extends EndpointDiscoveryFilter { @Override protected Object createEndpoint(String transportName, String endpoint, MicroserviceInstance instance) { Transport transport = SCBEngine.getInstance().getTransportManager().findTransport(transportName); if (transport == null) { LOGGER.info("not deployed transport {}, ignore {}.", transportName, endpoint); return null; } return new ServiceCombServer(transport, new CacheEndpoint(endpoint, instance)); } }
|
@Test public void consumerSlow(@Mocked Endpoint endpoint) { new Expectations() { { invocation.getEndpoint(); result = endpoint; endpoint.getEndpoint(); result = "rest: invocation.isConsumer(); result = true; invocation.getTraceIdLogger(); result = new TraceIdLogger(invocation); operationMeta.getExtData(RestConst.SWAGGER_REST_OPERATION); result = restOperationMeta; operationConfig.isSlowInvocationEnabled(); result = true; operationConfig.getNanoSlowInvocation(); result = 1; stageTrace.calcTotalTime(); result = 1; } }; logger.onInvocationFinish(event); Assert.assertEquals("" + "slow(0 ms) invocation, null:\n" + " http method: null\n" + " url : null\n" + " server : rest: + " status code: 0\n" + " total : 0.0 ms\n" + " prepare : 0.0 ms\n" + " handlers request : 0.0 ms\n" + " client filters request : 0.0 ms\n" + " send request : 0.0 ms\n" + " get connection : 0.0 ms\n" + " write to buf : 0.0 ms\n" + " wait response : 0.0 ms\n" + " wake consumer : 0.0 ms\n" + " client filters response: 0.0 ms\n" + " handlers response : 0.0 ms", logCollector.getEvents().get(0).getMessage()); }
|
@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 testConfigurationWithGetpropertyReturnsStringChar() { new MockUp<Configuration>() { @Mock private String getProperty(String defaultValue, String... keys) { return "tyt"; } }; Configuration.INSTANCE.getRetryNextServer("test"); assertNotNull(Configuration.INSTANCE.getRetryNextServer("test")); }
|
public int getRetryNextServer(String microservice) { return getRetryServer(microservice, RETRY_ON_NEXT); }
|
Configuration { public int getRetryNextServer(String microservice) { return getRetryServer(microservice, RETRY_ON_NEXT); } }
|
Configuration { public int getRetryNextServer(String microservice) { return getRetryServer(microservice, RETRY_ON_NEXT); } private Configuration(); }
|
Configuration { public int getRetryNextServer(String microservice) { return getRetryServer(microservice, RETRY_ON_NEXT); } private Configuration(); String getRuleStrategyName(String microservice); int getSessionTimeoutInSeconds(String microservice); int getSuccessiveFailedTimes(String microservice); String getRetryHandler(String microservice); boolean isRetryEnabled(String microservice); int getRetryNextServer(String microservice); int getRetrySameServer(String microservice); boolean isIsolationFilterOpen(String microservice); int getErrorThresholdPercentage(String microservice); int getEnableRequestThreshold(String microservice); int getSingleTestTime(String microservice); int getMaxSingleTestWindow(); int getMinIsolationTime(String microservice); Map<String, String> getFlowsplitFilterOptions(String microservice); static String getStringProperty(String defaultValue, String... keys); int getContinuousFailureThreshold(String microservice); }
|
Configuration { public int getRetryNextServer(String microservice) { return getRetryServer(microservice, RETRY_ON_NEXT); } private Configuration(); String getRuleStrategyName(String microservice); int getSessionTimeoutInSeconds(String microservice); int getSuccessiveFailedTimes(String microservice); String getRetryHandler(String microservice); boolean isRetryEnabled(String microservice); int getRetryNextServer(String microservice); int getRetrySameServer(String microservice); boolean isIsolationFilterOpen(String microservice); int getErrorThresholdPercentage(String microservice); int getEnableRequestThreshold(String microservice); int getSingleTestTime(String microservice); int getMaxSingleTestWindow(); int getMinIsolationTime(String microservice); Map<String, String> getFlowsplitFilterOptions(String microservice); static String getStringProperty(String defaultValue, String... keys); int getContinuousFailureThreshold(String microservice); static final String ROOT; static final String SERVER_EXPIRED_IN_SECONDS; static final String TIMER_INTERVAL_IN_MILLIS; static final String RULE_STRATEGY_NAME; static final String ROOT_20; static final String RETRY_HANDLER; static final String RETRY_ENABLED; static final String RETRY_ON_NEXT; static final String RETRY_ON_SAME; static final String SESSION_TIMEOUT_IN_SECONDS; static final String SUCCESSIVE_FAILED_TIMES; static final String FILTER_ISOLATION; static final String FILTER_OPEN; static final String FILTER_ERROR_PERCENTAGE; static final String FILTER_ENABLE_REQUEST; static final String FILTER_SINGLE_TEST; static final String FILTER_MAX_SINGLE_TEST_WINDOW; static final String FILTER_MIN_ISOLATION_TIME; static final String FILTER_CONTINUOUS_FAILURE_THRESHOLD; static final String TRANSACTIONCONTROL_OPTIONS_PREFIX_PATTERN; static final Configuration INSTANCE; }
|
@Test public void testConfigurationWithGetpropertyReturnsStringNum() { new MockUp<Configuration>() { @Mock private String getProperty(String defaultValue, String... keys) { return "1234"; } }; Configuration.INSTANCE.getRetryNextServer("test"); assertNotNull(Configuration.INSTANCE.getRetryNextServer("test")); }
|
public int getRetryNextServer(String microservice) { return getRetryServer(microservice, RETRY_ON_NEXT); }
|
Configuration { public int getRetryNextServer(String microservice) { return getRetryServer(microservice, RETRY_ON_NEXT); } }
|
Configuration { public int getRetryNextServer(String microservice) { return getRetryServer(microservice, RETRY_ON_NEXT); } private Configuration(); }
|
Configuration { public int getRetryNextServer(String microservice) { return getRetryServer(microservice, RETRY_ON_NEXT); } private Configuration(); String getRuleStrategyName(String microservice); int getSessionTimeoutInSeconds(String microservice); int getSuccessiveFailedTimes(String microservice); String getRetryHandler(String microservice); boolean isRetryEnabled(String microservice); int getRetryNextServer(String microservice); int getRetrySameServer(String microservice); boolean isIsolationFilterOpen(String microservice); int getErrorThresholdPercentage(String microservice); int getEnableRequestThreshold(String microservice); int getSingleTestTime(String microservice); int getMaxSingleTestWindow(); int getMinIsolationTime(String microservice); Map<String, String> getFlowsplitFilterOptions(String microservice); static String getStringProperty(String defaultValue, String... keys); int getContinuousFailureThreshold(String microservice); }
|
Configuration { public int getRetryNextServer(String microservice) { return getRetryServer(microservice, RETRY_ON_NEXT); } private Configuration(); String getRuleStrategyName(String microservice); int getSessionTimeoutInSeconds(String microservice); int getSuccessiveFailedTimes(String microservice); String getRetryHandler(String microservice); boolean isRetryEnabled(String microservice); int getRetryNextServer(String microservice); int getRetrySameServer(String microservice); boolean isIsolationFilterOpen(String microservice); int getErrorThresholdPercentage(String microservice); int getEnableRequestThreshold(String microservice); int getSingleTestTime(String microservice); int getMaxSingleTestWindow(); int getMinIsolationTime(String microservice); Map<String, String> getFlowsplitFilterOptions(String microservice); static String getStringProperty(String defaultValue, String... keys); int getContinuousFailureThreshold(String microservice); static final String ROOT; static final String SERVER_EXPIRED_IN_SECONDS; static final String TIMER_INTERVAL_IN_MILLIS; static final String RULE_STRATEGY_NAME; static final String ROOT_20; static final String RETRY_HANDLER; static final String RETRY_ENABLED; static final String RETRY_ON_NEXT; static final String RETRY_ON_SAME; static final String SESSION_TIMEOUT_IN_SECONDS; static final String SUCCESSIVE_FAILED_TIMES; static final String FILTER_ISOLATION; static final String FILTER_OPEN; static final String FILTER_ERROR_PERCENTAGE; static final String FILTER_ENABLE_REQUEST; static final String FILTER_SINGLE_TEST; static final String FILTER_MAX_SINGLE_TEST_WINDOW; static final String FILTER_MIN_ISOLATION_TIME; static final String FILTER_CONTINUOUS_FAILURE_THRESHOLD; static final String TRANSACTIONCONTROL_OPTIONS_PREFIX_PATTERN; static final Configuration INSTANCE; }
|
@Test public void testGetRetryOnSameWithGetpropertyReturnsStringChar() { new MockUp<Configuration>() { @Mock private String getProperty(String defaultValue, String... keys) { return "tyt"; } }; Configuration.INSTANCE.getRetrySameServer("test"); assertNotNull(Configuration.INSTANCE.getRetrySameServer("test")); }
|
public int getRetrySameServer(String microservice) { return getRetryServer(microservice, RETRY_ON_SAME); }
|
Configuration { public int getRetrySameServer(String microservice) { return getRetryServer(microservice, RETRY_ON_SAME); } }
|
Configuration { public int getRetrySameServer(String microservice) { return getRetryServer(microservice, RETRY_ON_SAME); } private Configuration(); }
|
Configuration { public int getRetrySameServer(String microservice) { return getRetryServer(microservice, RETRY_ON_SAME); } private Configuration(); String getRuleStrategyName(String microservice); int getSessionTimeoutInSeconds(String microservice); int getSuccessiveFailedTimes(String microservice); String getRetryHandler(String microservice); boolean isRetryEnabled(String microservice); int getRetryNextServer(String microservice); int getRetrySameServer(String microservice); boolean isIsolationFilterOpen(String microservice); int getErrorThresholdPercentage(String microservice); int getEnableRequestThreshold(String microservice); int getSingleTestTime(String microservice); int getMaxSingleTestWindow(); int getMinIsolationTime(String microservice); Map<String, String> getFlowsplitFilterOptions(String microservice); static String getStringProperty(String defaultValue, String... keys); int getContinuousFailureThreshold(String microservice); }
|
Configuration { public int getRetrySameServer(String microservice) { return getRetryServer(microservice, RETRY_ON_SAME); } private Configuration(); String getRuleStrategyName(String microservice); int getSessionTimeoutInSeconds(String microservice); int getSuccessiveFailedTimes(String microservice); String getRetryHandler(String microservice); boolean isRetryEnabled(String microservice); int getRetryNextServer(String microservice); int getRetrySameServer(String microservice); boolean isIsolationFilterOpen(String microservice); int getErrorThresholdPercentage(String microservice); int getEnableRequestThreshold(String microservice); int getSingleTestTime(String microservice); int getMaxSingleTestWindow(); int getMinIsolationTime(String microservice); Map<String, String> getFlowsplitFilterOptions(String microservice); static String getStringProperty(String defaultValue, String... keys); int getContinuousFailureThreshold(String microservice); static final String ROOT; static final String SERVER_EXPIRED_IN_SECONDS; static final String TIMER_INTERVAL_IN_MILLIS; static final String RULE_STRATEGY_NAME; static final String ROOT_20; static final String RETRY_HANDLER; static final String RETRY_ENABLED; static final String RETRY_ON_NEXT; static final String RETRY_ON_SAME; static final String SESSION_TIMEOUT_IN_SECONDS; static final String SUCCESSIVE_FAILED_TIMES; static final String FILTER_ISOLATION; static final String FILTER_OPEN; static final String FILTER_ERROR_PERCENTAGE; static final String FILTER_ENABLE_REQUEST; static final String FILTER_SINGLE_TEST; static final String FILTER_MAX_SINGLE_TEST_WINDOW; static final String FILTER_MIN_ISOLATION_TIME; static final String FILTER_CONTINUOUS_FAILURE_THRESHOLD; static final String TRANSACTIONCONTROL_OPTIONS_PREFIX_PATTERN; static final Configuration INSTANCE; }
|
@Test public void testGetRetryOnSameWithGetpropertyReturnsStringNum() { new MockUp<Configuration>() { @Mock private String getProperty(String defaultValue, String... keys) { return "1234"; } }; Configuration.INSTANCE.getRetrySameServer("test"); assertNotNull(Configuration.INSTANCE.getRetrySameServer("test")); }
|
public int getRetrySameServer(String microservice) { return getRetryServer(microservice, RETRY_ON_SAME); }
|
Configuration { public int getRetrySameServer(String microservice) { return getRetryServer(microservice, RETRY_ON_SAME); } }
|
Configuration { public int getRetrySameServer(String microservice) { return getRetryServer(microservice, RETRY_ON_SAME); } private Configuration(); }
|
Configuration { public int getRetrySameServer(String microservice) { return getRetryServer(microservice, RETRY_ON_SAME); } private Configuration(); String getRuleStrategyName(String microservice); int getSessionTimeoutInSeconds(String microservice); int getSuccessiveFailedTimes(String microservice); String getRetryHandler(String microservice); boolean isRetryEnabled(String microservice); int getRetryNextServer(String microservice); int getRetrySameServer(String microservice); boolean isIsolationFilterOpen(String microservice); int getErrorThresholdPercentage(String microservice); int getEnableRequestThreshold(String microservice); int getSingleTestTime(String microservice); int getMaxSingleTestWindow(); int getMinIsolationTime(String microservice); Map<String, String> getFlowsplitFilterOptions(String microservice); static String getStringProperty(String defaultValue, String... keys); int getContinuousFailureThreshold(String microservice); }
|
Configuration { public int getRetrySameServer(String microservice) { return getRetryServer(microservice, RETRY_ON_SAME); } private Configuration(); String getRuleStrategyName(String microservice); int getSessionTimeoutInSeconds(String microservice); int getSuccessiveFailedTimes(String microservice); String getRetryHandler(String microservice); boolean isRetryEnabled(String microservice); int getRetryNextServer(String microservice); int getRetrySameServer(String microservice); boolean isIsolationFilterOpen(String microservice); int getErrorThresholdPercentage(String microservice); int getEnableRequestThreshold(String microservice); int getSingleTestTime(String microservice); int getMaxSingleTestWindow(); int getMinIsolationTime(String microservice); Map<String, String> getFlowsplitFilterOptions(String microservice); static String getStringProperty(String defaultValue, String... keys); int getContinuousFailureThreshold(String microservice); static final String ROOT; static final String SERVER_EXPIRED_IN_SECONDS; static final String TIMER_INTERVAL_IN_MILLIS; static final String RULE_STRATEGY_NAME; static final String ROOT_20; static final String RETRY_HANDLER; static final String RETRY_ENABLED; static final String RETRY_ON_NEXT; static final String RETRY_ON_SAME; static final String SESSION_TIMEOUT_IN_SECONDS; static final String SUCCESSIVE_FAILED_TIMES; static final String FILTER_ISOLATION; static final String FILTER_OPEN; static final String FILTER_ERROR_PERCENTAGE; static final String FILTER_ENABLE_REQUEST; static final String FILTER_SINGLE_TEST; static final String FILTER_MAX_SINGLE_TEST_WINDOW; static final String FILTER_MIN_ISOLATION_TIME; static final String FILTER_CONTINUOUS_FAILURE_THRESHOLD; static final String TRANSACTIONCONTROL_OPTIONS_PREFIX_PATTERN; static final Configuration INSTANCE; }
|
@Test public void testIsRetryEnabledWithGetpropertyReturnsStringChar() { new MockUp<Configuration>() { @Mock private String getProperty(String defaultValue, String... keys) { return "tyt"; } }; Configuration.INSTANCE.isRetryEnabled("test"); assertNotNull(Configuration.INSTANCE.isRetryEnabled("test")); }
|
public boolean isRetryEnabled(String microservice) { String p = getStringProperty("false", ROOT + microservice + "." + RETRY_ENABLED, ROOT + RETRY_ENABLED); return Boolean.parseBoolean(p); }
|
Configuration { public boolean isRetryEnabled(String microservice) { String p = getStringProperty("false", ROOT + microservice + "." + RETRY_ENABLED, ROOT + RETRY_ENABLED); return Boolean.parseBoolean(p); } }
|
Configuration { public boolean isRetryEnabled(String microservice) { String p = getStringProperty("false", ROOT + microservice + "." + RETRY_ENABLED, ROOT + RETRY_ENABLED); return Boolean.parseBoolean(p); } private Configuration(); }
|
Configuration { public boolean isRetryEnabled(String microservice) { String p = getStringProperty("false", ROOT + microservice + "." + RETRY_ENABLED, ROOT + RETRY_ENABLED); return Boolean.parseBoolean(p); } private Configuration(); String getRuleStrategyName(String microservice); int getSessionTimeoutInSeconds(String microservice); int getSuccessiveFailedTimes(String microservice); String getRetryHandler(String microservice); boolean isRetryEnabled(String microservice); int getRetryNextServer(String microservice); int getRetrySameServer(String microservice); boolean isIsolationFilterOpen(String microservice); int getErrorThresholdPercentage(String microservice); int getEnableRequestThreshold(String microservice); int getSingleTestTime(String microservice); int getMaxSingleTestWindow(); int getMinIsolationTime(String microservice); Map<String, String> getFlowsplitFilterOptions(String microservice); static String getStringProperty(String defaultValue, String... keys); int getContinuousFailureThreshold(String microservice); }
|
Configuration { public boolean isRetryEnabled(String microservice) { String p = getStringProperty("false", ROOT + microservice + "." + RETRY_ENABLED, ROOT + RETRY_ENABLED); return Boolean.parseBoolean(p); } private Configuration(); String getRuleStrategyName(String microservice); int getSessionTimeoutInSeconds(String microservice); int getSuccessiveFailedTimes(String microservice); String getRetryHandler(String microservice); boolean isRetryEnabled(String microservice); int getRetryNextServer(String microservice); int getRetrySameServer(String microservice); boolean isIsolationFilterOpen(String microservice); int getErrorThresholdPercentage(String microservice); int getEnableRequestThreshold(String microservice); int getSingleTestTime(String microservice); int getMaxSingleTestWindow(); int getMinIsolationTime(String microservice); Map<String, String> getFlowsplitFilterOptions(String microservice); static String getStringProperty(String defaultValue, String... keys); int getContinuousFailureThreshold(String microservice); static final String ROOT; static final String SERVER_EXPIRED_IN_SECONDS; static final String TIMER_INTERVAL_IN_MILLIS; static final String RULE_STRATEGY_NAME; static final String ROOT_20; static final String RETRY_HANDLER; static final String RETRY_ENABLED; static final String RETRY_ON_NEXT; static final String RETRY_ON_SAME; static final String SESSION_TIMEOUT_IN_SECONDS; static final String SUCCESSIVE_FAILED_TIMES; static final String FILTER_ISOLATION; static final String FILTER_OPEN; static final String FILTER_ERROR_PERCENTAGE; static final String FILTER_ENABLE_REQUEST; static final String FILTER_SINGLE_TEST; static final String FILTER_MAX_SINGLE_TEST_WINDOW; static final String FILTER_MIN_ISOLATION_TIME; static final String FILTER_CONTINUOUS_FAILURE_THRESHOLD; static final String TRANSACTIONCONTROL_OPTIONS_PREFIX_PATTERN; static final Configuration INSTANCE; }
|
@Test public void testIsRetryEnabledWithGetpropertyReturnsStringNum() { new MockUp<Configuration>() { @Mock private String getProperty(String defaultValue, String... keys) { return "1234"; } }; Configuration.INSTANCE.isRetryEnabled("test"); assertNotNull(Configuration.INSTANCE.isRetryEnabled("test")); }
|
public boolean isRetryEnabled(String microservice) { String p = getStringProperty("false", ROOT + microservice + "." + RETRY_ENABLED, ROOT + RETRY_ENABLED); return Boolean.parseBoolean(p); }
|
Configuration { public boolean isRetryEnabled(String microservice) { String p = getStringProperty("false", ROOT + microservice + "." + RETRY_ENABLED, ROOT + RETRY_ENABLED); return Boolean.parseBoolean(p); } }
|
Configuration { public boolean isRetryEnabled(String microservice) { String p = getStringProperty("false", ROOT + microservice + "." + RETRY_ENABLED, ROOT + RETRY_ENABLED); return Boolean.parseBoolean(p); } private Configuration(); }
|
Configuration { public boolean isRetryEnabled(String microservice) { String p = getStringProperty("false", ROOT + microservice + "." + RETRY_ENABLED, ROOT + RETRY_ENABLED); return Boolean.parseBoolean(p); } private Configuration(); String getRuleStrategyName(String microservice); int getSessionTimeoutInSeconds(String microservice); int getSuccessiveFailedTimes(String microservice); String getRetryHandler(String microservice); boolean isRetryEnabled(String microservice); int getRetryNextServer(String microservice); int getRetrySameServer(String microservice); boolean isIsolationFilterOpen(String microservice); int getErrorThresholdPercentage(String microservice); int getEnableRequestThreshold(String microservice); int getSingleTestTime(String microservice); int getMaxSingleTestWindow(); int getMinIsolationTime(String microservice); Map<String, String> getFlowsplitFilterOptions(String microservice); static String getStringProperty(String defaultValue, String... keys); int getContinuousFailureThreshold(String microservice); }
|
Configuration { public boolean isRetryEnabled(String microservice) { String p = getStringProperty("false", ROOT + microservice + "." + RETRY_ENABLED, ROOT + RETRY_ENABLED); return Boolean.parseBoolean(p); } private Configuration(); String getRuleStrategyName(String microservice); int getSessionTimeoutInSeconds(String microservice); int getSuccessiveFailedTimes(String microservice); String getRetryHandler(String microservice); boolean isRetryEnabled(String microservice); int getRetryNextServer(String microservice); int getRetrySameServer(String microservice); boolean isIsolationFilterOpen(String microservice); int getErrorThresholdPercentage(String microservice); int getEnableRequestThreshold(String microservice); int getSingleTestTime(String microservice); int getMaxSingleTestWindow(); int getMinIsolationTime(String microservice); Map<String, String> getFlowsplitFilterOptions(String microservice); static String getStringProperty(String defaultValue, String... keys); int getContinuousFailureThreshold(String microservice); static final String ROOT; static final String SERVER_EXPIRED_IN_SECONDS; static final String TIMER_INTERVAL_IN_MILLIS; static final String RULE_STRATEGY_NAME; static final String ROOT_20; static final String RETRY_HANDLER; static final String RETRY_ENABLED; static final String RETRY_ON_NEXT; static final String RETRY_ON_SAME; static final String SESSION_TIMEOUT_IN_SECONDS; static final String SUCCESSIVE_FAILED_TIMES; static final String FILTER_ISOLATION; static final String FILTER_OPEN; static final String FILTER_ERROR_PERCENTAGE; static final String FILTER_ENABLE_REQUEST; static final String FILTER_SINGLE_TEST; static final String FILTER_MAX_SINGLE_TEST_WINDOW; static final String FILTER_MIN_ISOLATION_TIME; static final String FILTER_CONTINUOUS_FAILURE_THRESHOLD; static final String TRANSACTIONCONTROL_OPTIONS_PREFIX_PATTERN; static final Configuration INSTANCE; }
|
@Test public void testGetSuccessiveFailedTimes() { assertNotNull(Configuration.INSTANCE.getSuccessiveFailedTimes("test")); }
|
public int getSuccessiveFailedTimes(String microservice) { final int defaultValue = 5; String p = getStringProperty("5", ROOT + microservice + "." + SUCCESSIVE_FAILED_TIMES, ROOT + SUCCESSIVE_FAILED_TIMES); try { return Integer.parseInt(p); } catch (NumberFormatException e) { return defaultValue; } }
|
Configuration { public int getSuccessiveFailedTimes(String microservice) { final int defaultValue = 5; String p = getStringProperty("5", ROOT + microservice + "." + SUCCESSIVE_FAILED_TIMES, ROOT + SUCCESSIVE_FAILED_TIMES); try { return Integer.parseInt(p); } catch (NumberFormatException e) { return defaultValue; } } }
|
Configuration { public int getSuccessiveFailedTimes(String microservice) { final int defaultValue = 5; String p = getStringProperty("5", ROOT + microservice + "." + SUCCESSIVE_FAILED_TIMES, ROOT + SUCCESSIVE_FAILED_TIMES); try { return Integer.parseInt(p); } catch (NumberFormatException e) { return defaultValue; } } private Configuration(); }
|
Configuration { public int getSuccessiveFailedTimes(String microservice) { final int defaultValue = 5; String p = getStringProperty("5", ROOT + microservice + "." + SUCCESSIVE_FAILED_TIMES, ROOT + SUCCESSIVE_FAILED_TIMES); try { return Integer.parseInt(p); } catch (NumberFormatException e) { return defaultValue; } } private Configuration(); String getRuleStrategyName(String microservice); int getSessionTimeoutInSeconds(String microservice); int getSuccessiveFailedTimes(String microservice); String getRetryHandler(String microservice); boolean isRetryEnabled(String microservice); int getRetryNextServer(String microservice); int getRetrySameServer(String microservice); boolean isIsolationFilterOpen(String microservice); int getErrorThresholdPercentage(String microservice); int getEnableRequestThreshold(String microservice); int getSingleTestTime(String microservice); int getMaxSingleTestWindow(); int getMinIsolationTime(String microservice); Map<String, String> getFlowsplitFilterOptions(String microservice); static String getStringProperty(String defaultValue, String... keys); int getContinuousFailureThreshold(String microservice); }
|
Configuration { public int getSuccessiveFailedTimes(String microservice) { final int defaultValue = 5; String p = getStringProperty("5", ROOT + microservice + "." + SUCCESSIVE_FAILED_TIMES, ROOT + SUCCESSIVE_FAILED_TIMES); try { return Integer.parseInt(p); } catch (NumberFormatException e) { return defaultValue; } } private Configuration(); String getRuleStrategyName(String microservice); int getSessionTimeoutInSeconds(String microservice); int getSuccessiveFailedTimes(String microservice); String getRetryHandler(String microservice); boolean isRetryEnabled(String microservice); int getRetryNextServer(String microservice); int getRetrySameServer(String microservice); boolean isIsolationFilterOpen(String microservice); int getErrorThresholdPercentage(String microservice); int getEnableRequestThreshold(String microservice); int getSingleTestTime(String microservice); int getMaxSingleTestWindow(); int getMinIsolationTime(String microservice); Map<String, String> getFlowsplitFilterOptions(String microservice); static String getStringProperty(String defaultValue, String... keys); int getContinuousFailureThreshold(String microservice); static final String ROOT; static final String SERVER_EXPIRED_IN_SECONDS; static final String TIMER_INTERVAL_IN_MILLIS; static final String RULE_STRATEGY_NAME; static final String ROOT_20; static final String RETRY_HANDLER; static final String RETRY_ENABLED; static final String RETRY_ON_NEXT; static final String RETRY_ON_SAME; static final String SESSION_TIMEOUT_IN_SECONDS; static final String SUCCESSIVE_FAILED_TIMES; static final String FILTER_ISOLATION; static final String FILTER_OPEN; static final String FILTER_ERROR_PERCENTAGE; static final String FILTER_ENABLE_REQUEST; static final String FILTER_SINGLE_TEST; static final String FILTER_MAX_SINGLE_TEST_WINDOW; static final String FILTER_MIN_ISOLATION_TIME; static final String FILTER_CONTINUOUS_FAILURE_THRESHOLD; static final String TRANSACTIONCONTROL_OPTIONS_PREFIX_PATTERN; static final Configuration INSTANCE; }
|
@Test public void testGetSessionTimeoutInSeconds() { assertNotNull(Configuration.INSTANCE.getSessionTimeoutInSeconds("test")); }
|
public int getSessionTimeoutInSeconds(String microservice) { final int defaultValue = 30; String p = getStringProperty("30", ROOT + microservice + "." + SESSION_TIMEOUT_IN_SECONDS, ROOT + SESSION_TIMEOUT_IN_SECONDS); try { return Integer.parseInt(p); } catch (NumberFormatException e) { return defaultValue; } }
|
Configuration { public int getSessionTimeoutInSeconds(String microservice) { final int defaultValue = 30; String p = getStringProperty("30", ROOT + microservice + "." + SESSION_TIMEOUT_IN_SECONDS, ROOT + SESSION_TIMEOUT_IN_SECONDS); try { return Integer.parseInt(p); } catch (NumberFormatException e) { return defaultValue; } } }
|
Configuration { public int getSessionTimeoutInSeconds(String microservice) { final int defaultValue = 30; String p = getStringProperty("30", ROOT + microservice + "." + SESSION_TIMEOUT_IN_SECONDS, ROOT + SESSION_TIMEOUT_IN_SECONDS); try { return Integer.parseInt(p); } catch (NumberFormatException e) { return defaultValue; } } private Configuration(); }
|
Configuration { public int getSessionTimeoutInSeconds(String microservice) { final int defaultValue = 30; String p = getStringProperty("30", ROOT + microservice + "." + SESSION_TIMEOUT_IN_SECONDS, ROOT + SESSION_TIMEOUT_IN_SECONDS); try { return Integer.parseInt(p); } catch (NumberFormatException e) { return defaultValue; } } private Configuration(); String getRuleStrategyName(String microservice); int getSessionTimeoutInSeconds(String microservice); int getSuccessiveFailedTimes(String microservice); String getRetryHandler(String microservice); boolean isRetryEnabled(String microservice); int getRetryNextServer(String microservice); int getRetrySameServer(String microservice); boolean isIsolationFilterOpen(String microservice); int getErrorThresholdPercentage(String microservice); int getEnableRequestThreshold(String microservice); int getSingleTestTime(String microservice); int getMaxSingleTestWindow(); int getMinIsolationTime(String microservice); Map<String, String> getFlowsplitFilterOptions(String microservice); static String getStringProperty(String defaultValue, String... keys); int getContinuousFailureThreshold(String microservice); }
|
Configuration { public int getSessionTimeoutInSeconds(String microservice) { final int defaultValue = 30; String p = getStringProperty("30", ROOT + microservice + "." + SESSION_TIMEOUT_IN_SECONDS, ROOT + SESSION_TIMEOUT_IN_SECONDS); try { return Integer.parseInt(p); } catch (NumberFormatException e) { return defaultValue; } } private Configuration(); String getRuleStrategyName(String microservice); int getSessionTimeoutInSeconds(String microservice); int getSuccessiveFailedTimes(String microservice); String getRetryHandler(String microservice); boolean isRetryEnabled(String microservice); int getRetryNextServer(String microservice); int getRetrySameServer(String microservice); boolean isIsolationFilterOpen(String microservice); int getErrorThresholdPercentage(String microservice); int getEnableRequestThreshold(String microservice); int getSingleTestTime(String microservice); int getMaxSingleTestWindow(); int getMinIsolationTime(String microservice); Map<String, String> getFlowsplitFilterOptions(String microservice); static String getStringProperty(String defaultValue, String... keys); int getContinuousFailureThreshold(String microservice); static final String ROOT; static final String SERVER_EXPIRED_IN_SECONDS; static final String TIMER_INTERVAL_IN_MILLIS; static final String RULE_STRATEGY_NAME; static final String ROOT_20; static final String RETRY_HANDLER; static final String RETRY_ENABLED; static final String RETRY_ON_NEXT; static final String RETRY_ON_SAME; static final String SESSION_TIMEOUT_IN_SECONDS; static final String SUCCESSIVE_FAILED_TIMES; static final String FILTER_ISOLATION; static final String FILTER_OPEN; static final String FILTER_ERROR_PERCENTAGE; static final String FILTER_ENABLE_REQUEST; static final String FILTER_SINGLE_TEST; static final String FILTER_MAX_SINGLE_TEST_WINDOW; static final String FILTER_MIN_ISOLATION_TIME; static final String FILTER_CONTINUOUS_FAILURE_THRESHOLD; static final String TRANSACTIONCONTROL_OPTIONS_PREFIX_PATTERN; static final Configuration INSTANCE; }
|
@Test public void testGetMaxSingleTestWindow() { assertEquals(60000, Configuration.INSTANCE.getMaxSingleTestWindow()); ArchaiusUtils.setProperty("servicecomb.loadbalance.isolation.maxSingleTestWindow", 5000); assertEquals(5000, Configuration.INSTANCE.getMaxSingleTestWindow()); }
|
public int getMaxSingleTestWindow() { final int defaultValue = 60000; String p = getStringProperty(Integer.toString(defaultValue), ROOT + FILTER_ISOLATION + FILTER_MAX_SINGLE_TEST_WINDOW); try { int result = Integer.parseInt(p); if (result >= 0) { return result; } return defaultValue; } catch (NumberFormatException e) { return defaultValue; } }
|
Configuration { public int getMaxSingleTestWindow() { final int defaultValue = 60000; String p = getStringProperty(Integer.toString(defaultValue), ROOT + FILTER_ISOLATION + FILTER_MAX_SINGLE_TEST_WINDOW); try { int result = Integer.parseInt(p); if (result >= 0) { return result; } return defaultValue; } catch (NumberFormatException e) { return defaultValue; } } }
|
Configuration { public int getMaxSingleTestWindow() { final int defaultValue = 60000; String p = getStringProperty(Integer.toString(defaultValue), ROOT + FILTER_ISOLATION + FILTER_MAX_SINGLE_TEST_WINDOW); try { int result = Integer.parseInt(p); if (result >= 0) { return result; } return defaultValue; } catch (NumberFormatException e) { return defaultValue; } } private Configuration(); }
|
Configuration { public int getMaxSingleTestWindow() { final int defaultValue = 60000; String p = getStringProperty(Integer.toString(defaultValue), ROOT + FILTER_ISOLATION + FILTER_MAX_SINGLE_TEST_WINDOW); try { int result = Integer.parseInt(p); if (result >= 0) { return result; } return defaultValue; } catch (NumberFormatException e) { return defaultValue; } } private Configuration(); String getRuleStrategyName(String microservice); int getSessionTimeoutInSeconds(String microservice); int getSuccessiveFailedTimes(String microservice); String getRetryHandler(String microservice); boolean isRetryEnabled(String microservice); int getRetryNextServer(String microservice); int getRetrySameServer(String microservice); boolean isIsolationFilterOpen(String microservice); int getErrorThresholdPercentage(String microservice); int getEnableRequestThreshold(String microservice); int getSingleTestTime(String microservice); int getMaxSingleTestWindow(); int getMinIsolationTime(String microservice); Map<String, String> getFlowsplitFilterOptions(String microservice); static String getStringProperty(String defaultValue, String... keys); int getContinuousFailureThreshold(String microservice); }
|
Configuration { public int getMaxSingleTestWindow() { final int defaultValue = 60000; String p = getStringProperty(Integer.toString(defaultValue), ROOT + FILTER_ISOLATION + FILTER_MAX_SINGLE_TEST_WINDOW); try { int result = Integer.parseInt(p); if (result >= 0) { return result; } return defaultValue; } catch (NumberFormatException e) { return defaultValue; } } private Configuration(); String getRuleStrategyName(String microservice); int getSessionTimeoutInSeconds(String microservice); int getSuccessiveFailedTimes(String microservice); String getRetryHandler(String microservice); boolean isRetryEnabled(String microservice); int getRetryNextServer(String microservice); int getRetrySameServer(String microservice); boolean isIsolationFilterOpen(String microservice); int getErrorThresholdPercentage(String microservice); int getEnableRequestThreshold(String microservice); int getSingleTestTime(String microservice); int getMaxSingleTestWindow(); int getMinIsolationTime(String microservice); Map<String, String> getFlowsplitFilterOptions(String microservice); static String getStringProperty(String defaultValue, String... keys); int getContinuousFailureThreshold(String microservice); static final String ROOT; static final String SERVER_EXPIRED_IN_SECONDS; static final String TIMER_INTERVAL_IN_MILLIS; static final String RULE_STRATEGY_NAME; static final String ROOT_20; static final String RETRY_HANDLER; static final String RETRY_ENABLED; static final String RETRY_ON_NEXT; static final String RETRY_ON_SAME; static final String SESSION_TIMEOUT_IN_SECONDS; static final String SUCCESSIVE_FAILED_TIMES; static final String FILTER_ISOLATION; static final String FILTER_OPEN; static final String FILTER_ERROR_PERCENTAGE; static final String FILTER_ENABLE_REQUEST; static final String FILTER_SINGLE_TEST; static final String FILTER_MAX_SINGLE_TEST_WINDOW; static final String FILTER_MIN_ISOLATION_TIME; static final String FILTER_CONTINUOUS_FAILURE_THRESHOLD; static final String TRANSACTIONCONTROL_OPTIONS_PREFIX_PATTERN; static final Configuration INSTANCE; }
|
@Test public void sendWithRetry(@Injectable LoadBalancer loadBalancer) { Holder<String> result = new Holder<>(); Deencapsulation.invoke(handler, "sendWithRetry", invocation, (AsyncResponse) resp -> { result.value = resp.getResult(); }, loadBalancer); }
|
private void sendWithRetry(Invocation invocation, AsyncResponse asyncResp, LoadBalancer chosenLB) throws Exception { long time = System.currentTimeMillis(); int currentHandler = invocation.getHandlerIndex(); SyncResponseExecutor orginExecutor; Executor newExecutor; if (invocation.getResponseExecutor() instanceof SyncResponseExecutor) { orginExecutor = (SyncResponseExecutor) invocation.getResponseExecutor(); newExecutor = new Executor() { @Override public void execute(Runnable command) { RETRY_POOL.submit(command); } }; invocation.setResponseExecutor(newExecutor); } else { orginExecutor = null; newExecutor = null; } ExecutionListener<Invocation, Response> listener = new ExecutionListener<Invocation, Response>() { @Override public void onExecutionStart(ExecutionContext<Invocation> context) throws AbortExecutionException { } @Override public void onStartWithServer(ExecutionContext<Invocation> context, ExecutionInfo info) throws AbortExecutionException { } @Override public void onExceptionWithServer(ExecutionContext<Invocation> context, Throwable exception, ExecutionInfo info) { context.getRequest().getTraceIdLogger() .error(LOGGER, "Invoke server failed. Operation {}; server {}; {}-{} msg {}", context.getRequest().getInvocationQualifiedName(), context.getRequest().getEndpoint(), info.getNumberOfPastServersAttempted(), info.getNumberOfPastAttemptsOnServer(), ExceptionUtils.getExceptionMessageWithoutTrace(exception)); } @Override public void onExecutionSuccess(ExecutionContext<Invocation> context, Response response, ExecutionInfo info) { if (info.getNumberOfPastServersAttempted() > 0 || info.getNumberOfPastAttemptsOnServer() > 0) { context.getRequest().getTraceIdLogger().error(LOGGER, "Invoke server success. Operation {}; server {}", context.getRequest().getInvocationQualifiedName(), context.getRequest().getEndpoint()); } if (orginExecutor != null) { orginExecutor.execute(() -> { asyncResp.complete(response); }); } else { asyncResp.complete(response); } } @Override public void onExecutionFailed(ExecutionContext<Invocation> context, Throwable finalException, ExecutionInfo info) { context.getRequest().getTraceIdLogger().error(LOGGER, "Invoke all server failed. Operation {}, e={}", context.getRequest().getInvocationQualifiedName(), ExceptionUtils.getExceptionMessageWithoutTrace(finalException)); if (orginExecutor != null) { orginExecutor.execute(() -> { fail(finalException); }); } else { fail(finalException); } } private void fail(Throwable finalException) { int depth = 10; Throwable t = finalException; while (depth-- > 0) { if (t instanceof InvocationException) { asyncResp.consumerFail(t); return; } t = finalException.getCause(); } asyncResp.consumerFail(finalException); } }; List<ExecutionListener<Invocation, Response>> listeners = new ArrayList<>(0); listeners.add(listener); ExecutionContext<Invocation> context = new ExecutionContext<>(invocation, null, null, null); LoadBalancerCommand<Response> command = LoadBalancerCommand.<Response>builder() .withLoadBalancer(new RetryLoadBalancer(chosenLB)) .withServerLocator(invocation) .withRetryHandler(ExtensionsManager.createRetryHandler(invocation.getMicroserviceName())) .withListeners(listeners) .withExecutionContext(context) .build(); Observable<Response> observable = command.submit(new ServerOperation<Response>() { public Observable<Response> call(Server s) { return Observable.create(f -> { try { ServiceCombServer server = (ServiceCombServer) s; chosenLB.getLoadBalancerStats().incrementNumRequests(s); invocation.setHandlerIndex(currentHandler); invocation.setEndpoint(server.getEndpoint()); invocation.next(resp -> { if (isFailedResponse(resp)) { invocation.getTraceIdLogger().error(LOGGER, "service {}, call error, msg is {}, server is {} ", invocation.getInvocationQualifiedName(), ExceptionUtils.getExceptionMessageWithoutTrace((Throwable) resp.getResult()), s); chosenLB.getLoadBalancerStats().incrementSuccessiveConnectionFailureCount(s); ServiceCombLoadBalancerStats.INSTANCE.markFailure(server); f.onError(resp.getResult()); } else { chosenLB.getLoadBalancerStats().incrementActiveRequestsCount(s); chosenLB.getLoadBalancerStats().noteResponseTime(s, (System.currentTimeMillis() - time)); ServiceCombLoadBalancerStats.INSTANCE.markSuccess(server); f.onNext(resp); f.onCompleted(); } }); } catch (Exception e) { invocation.getTraceIdLogger() .error(LOGGER, "execution error, msg is {}", ExceptionUtils.getExceptionMessageWithoutTrace(e)); f.onError(e); } }); } }); observable.subscribe(response -> { }, error -> { }, () -> { }); }
|
LoadbalanceHandler implements Handler { private void sendWithRetry(Invocation invocation, AsyncResponse asyncResp, LoadBalancer chosenLB) throws Exception { long time = System.currentTimeMillis(); int currentHandler = invocation.getHandlerIndex(); SyncResponseExecutor orginExecutor; Executor newExecutor; if (invocation.getResponseExecutor() instanceof SyncResponseExecutor) { orginExecutor = (SyncResponseExecutor) invocation.getResponseExecutor(); newExecutor = new Executor() { @Override public void execute(Runnable command) { RETRY_POOL.submit(command); } }; invocation.setResponseExecutor(newExecutor); } else { orginExecutor = null; newExecutor = null; } ExecutionListener<Invocation, Response> listener = new ExecutionListener<Invocation, Response>() { @Override public void onExecutionStart(ExecutionContext<Invocation> context) throws AbortExecutionException { } @Override public void onStartWithServer(ExecutionContext<Invocation> context, ExecutionInfo info) throws AbortExecutionException { } @Override public void onExceptionWithServer(ExecutionContext<Invocation> context, Throwable exception, ExecutionInfo info) { context.getRequest().getTraceIdLogger() .error(LOGGER, "Invoke server failed. Operation {}; server {}; {}-{} msg {}", context.getRequest().getInvocationQualifiedName(), context.getRequest().getEndpoint(), info.getNumberOfPastServersAttempted(), info.getNumberOfPastAttemptsOnServer(), ExceptionUtils.getExceptionMessageWithoutTrace(exception)); } @Override public void onExecutionSuccess(ExecutionContext<Invocation> context, Response response, ExecutionInfo info) { if (info.getNumberOfPastServersAttempted() > 0 || info.getNumberOfPastAttemptsOnServer() > 0) { context.getRequest().getTraceIdLogger().error(LOGGER, "Invoke server success. Operation {}; server {}", context.getRequest().getInvocationQualifiedName(), context.getRequest().getEndpoint()); } if (orginExecutor != null) { orginExecutor.execute(() -> { asyncResp.complete(response); }); } else { asyncResp.complete(response); } } @Override public void onExecutionFailed(ExecutionContext<Invocation> context, Throwable finalException, ExecutionInfo info) { context.getRequest().getTraceIdLogger().error(LOGGER, "Invoke all server failed. Operation {}, e={}", context.getRequest().getInvocationQualifiedName(), ExceptionUtils.getExceptionMessageWithoutTrace(finalException)); if (orginExecutor != null) { orginExecutor.execute(() -> { fail(finalException); }); } else { fail(finalException); } } private void fail(Throwable finalException) { int depth = 10; Throwable t = finalException; while (depth-- > 0) { if (t instanceof InvocationException) { asyncResp.consumerFail(t); return; } t = finalException.getCause(); } asyncResp.consumerFail(finalException); } }; List<ExecutionListener<Invocation, Response>> listeners = new ArrayList<>(0); listeners.add(listener); ExecutionContext<Invocation> context = new ExecutionContext<>(invocation, null, null, null); LoadBalancerCommand<Response> command = LoadBalancerCommand.<Response>builder() .withLoadBalancer(new RetryLoadBalancer(chosenLB)) .withServerLocator(invocation) .withRetryHandler(ExtensionsManager.createRetryHandler(invocation.getMicroserviceName())) .withListeners(listeners) .withExecutionContext(context) .build(); Observable<Response> observable = command.submit(new ServerOperation<Response>() { public Observable<Response> call(Server s) { return Observable.create(f -> { try { ServiceCombServer server = (ServiceCombServer) s; chosenLB.getLoadBalancerStats().incrementNumRequests(s); invocation.setHandlerIndex(currentHandler); invocation.setEndpoint(server.getEndpoint()); invocation.next(resp -> { if (isFailedResponse(resp)) { invocation.getTraceIdLogger().error(LOGGER, "service {}, call error, msg is {}, server is {} ", invocation.getInvocationQualifiedName(), ExceptionUtils.getExceptionMessageWithoutTrace((Throwable) resp.getResult()), s); chosenLB.getLoadBalancerStats().incrementSuccessiveConnectionFailureCount(s); ServiceCombLoadBalancerStats.INSTANCE.markFailure(server); f.onError(resp.getResult()); } else { chosenLB.getLoadBalancerStats().incrementActiveRequestsCount(s); chosenLB.getLoadBalancerStats().noteResponseTime(s, (System.currentTimeMillis() - time)); ServiceCombLoadBalancerStats.INSTANCE.markSuccess(server); f.onNext(resp); f.onCompleted(); } }); } catch (Exception e) { invocation.getTraceIdLogger() .error(LOGGER, "execution error, msg is {}", ExceptionUtils.getExceptionMessageWithoutTrace(e)); f.onError(e); } }); } }); observable.subscribe(response -> { }, error -> { }, () -> { }); } }
|
LoadbalanceHandler implements Handler { private void sendWithRetry(Invocation invocation, AsyncResponse asyncResp, LoadBalancer chosenLB) throws Exception { long time = System.currentTimeMillis(); int currentHandler = invocation.getHandlerIndex(); SyncResponseExecutor orginExecutor; Executor newExecutor; if (invocation.getResponseExecutor() instanceof SyncResponseExecutor) { orginExecutor = (SyncResponseExecutor) invocation.getResponseExecutor(); newExecutor = new Executor() { @Override public void execute(Runnable command) { RETRY_POOL.submit(command); } }; invocation.setResponseExecutor(newExecutor); } else { orginExecutor = null; newExecutor = null; } ExecutionListener<Invocation, Response> listener = new ExecutionListener<Invocation, Response>() { @Override public void onExecutionStart(ExecutionContext<Invocation> context) throws AbortExecutionException { } @Override public void onStartWithServer(ExecutionContext<Invocation> context, ExecutionInfo info) throws AbortExecutionException { } @Override public void onExceptionWithServer(ExecutionContext<Invocation> context, Throwable exception, ExecutionInfo info) { context.getRequest().getTraceIdLogger() .error(LOGGER, "Invoke server failed. Operation {}; server {}; {}-{} msg {}", context.getRequest().getInvocationQualifiedName(), context.getRequest().getEndpoint(), info.getNumberOfPastServersAttempted(), info.getNumberOfPastAttemptsOnServer(), ExceptionUtils.getExceptionMessageWithoutTrace(exception)); } @Override public void onExecutionSuccess(ExecutionContext<Invocation> context, Response response, ExecutionInfo info) { if (info.getNumberOfPastServersAttempted() > 0 || info.getNumberOfPastAttemptsOnServer() > 0) { context.getRequest().getTraceIdLogger().error(LOGGER, "Invoke server success. Operation {}; server {}", context.getRequest().getInvocationQualifiedName(), context.getRequest().getEndpoint()); } if (orginExecutor != null) { orginExecutor.execute(() -> { asyncResp.complete(response); }); } else { asyncResp.complete(response); } } @Override public void onExecutionFailed(ExecutionContext<Invocation> context, Throwable finalException, ExecutionInfo info) { context.getRequest().getTraceIdLogger().error(LOGGER, "Invoke all server failed. Operation {}, e={}", context.getRequest().getInvocationQualifiedName(), ExceptionUtils.getExceptionMessageWithoutTrace(finalException)); if (orginExecutor != null) { orginExecutor.execute(() -> { fail(finalException); }); } else { fail(finalException); } } private void fail(Throwable finalException) { int depth = 10; Throwable t = finalException; while (depth-- > 0) { if (t instanceof InvocationException) { asyncResp.consumerFail(t); return; } t = finalException.getCause(); } asyncResp.consumerFail(finalException); } }; List<ExecutionListener<Invocation, Response>> listeners = new ArrayList<>(0); listeners.add(listener); ExecutionContext<Invocation> context = new ExecutionContext<>(invocation, null, null, null); LoadBalancerCommand<Response> command = LoadBalancerCommand.<Response>builder() .withLoadBalancer(new RetryLoadBalancer(chosenLB)) .withServerLocator(invocation) .withRetryHandler(ExtensionsManager.createRetryHandler(invocation.getMicroserviceName())) .withListeners(listeners) .withExecutionContext(context) .build(); Observable<Response> observable = command.submit(new ServerOperation<Response>() { public Observable<Response> call(Server s) { return Observable.create(f -> { try { ServiceCombServer server = (ServiceCombServer) s; chosenLB.getLoadBalancerStats().incrementNumRequests(s); invocation.setHandlerIndex(currentHandler); invocation.setEndpoint(server.getEndpoint()); invocation.next(resp -> { if (isFailedResponse(resp)) { invocation.getTraceIdLogger().error(LOGGER, "service {}, call error, msg is {}, server is {} ", invocation.getInvocationQualifiedName(), ExceptionUtils.getExceptionMessageWithoutTrace((Throwable) resp.getResult()), s); chosenLB.getLoadBalancerStats().incrementSuccessiveConnectionFailureCount(s); ServiceCombLoadBalancerStats.INSTANCE.markFailure(server); f.onError(resp.getResult()); } else { chosenLB.getLoadBalancerStats().incrementActiveRequestsCount(s); chosenLB.getLoadBalancerStats().noteResponseTime(s, (System.currentTimeMillis() - time)); ServiceCombLoadBalancerStats.INSTANCE.markSuccess(server); f.onNext(resp); f.onCompleted(); } }); } catch (Exception e) { invocation.getTraceIdLogger() .error(LOGGER, "execution error, msg is {}", ExceptionUtils.getExceptionMessageWithoutTrace(e)); f.onError(e); } }); } }); observable.subscribe(response -> { }, error -> { }, () -> { }); } LoadbalanceHandler(DiscoveryTree discoveryTree); LoadbalanceHandler(); }
|
LoadbalanceHandler implements Handler { private void sendWithRetry(Invocation invocation, AsyncResponse asyncResp, LoadBalancer chosenLB) throws Exception { long time = System.currentTimeMillis(); int currentHandler = invocation.getHandlerIndex(); SyncResponseExecutor orginExecutor; Executor newExecutor; if (invocation.getResponseExecutor() instanceof SyncResponseExecutor) { orginExecutor = (SyncResponseExecutor) invocation.getResponseExecutor(); newExecutor = new Executor() { @Override public void execute(Runnable command) { RETRY_POOL.submit(command); } }; invocation.setResponseExecutor(newExecutor); } else { orginExecutor = null; newExecutor = null; } ExecutionListener<Invocation, Response> listener = new ExecutionListener<Invocation, Response>() { @Override public void onExecutionStart(ExecutionContext<Invocation> context) throws AbortExecutionException { } @Override public void onStartWithServer(ExecutionContext<Invocation> context, ExecutionInfo info) throws AbortExecutionException { } @Override public void onExceptionWithServer(ExecutionContext<Invocation> context, Throwable exception, ExecutionInfo info) { context.getRequest().getTraceIdLogger() .error(LOGGER, "Invoke server failed. Operation {}; server {}; {}-{} msg {}", context.getRequest().getInvocationQualifiedName(), context.getRequest().getEndpoint(), info.getNumberOfPastServersAttempted(), info.getNumberOfPastAttemptsOnServer(), ExceptionUtils.getExceptionMessageWithoutTrace(exception)); } @Override public void onExecutionSuccess(ExecutionContext<Invocation> context, Response response, ExecutionInfo info) { if (info.getNumberOfPastServersAttempted() > 0 || info.getNumberOfPastAttemptsOnServer() > 0) { context.getRequest().getTraceIdLogger().error(LOGGER, "Invoke server success. Operation {}; server {}", context.getRequest().getInvocationQualifiedName(), context.getRequest().getEndpoint()); } if (orginExecutor != null) { orginExecutor.execute(() -> { asyncResp.complete(response); }); } else { asyncResp.complete(response); } } @Override public void onExecutionFailed(ExecutionContext<Invocation> context, Throwable finalException, ExecutionInfo info) { context.getRequest().getTraceIdLogger().error(LOGGER, "Invoke all server failed. Operation {}, e={}", context.getRequest().getInvocationQualifiedName(), ExceptionUtils.getExceptionMessageWithoutTrace(finalException)); if (orginExecutor != null) { orginExecutor.execute(() -> { fail(finalException); }); } else { fail(finalException); } } private void fail(Throwable finalException) { int depth = 10; Throwable t = finalException; while (depth-- > 0) { if (t instanceof InvocationException) { asyncResp.consumerFail(t); return; } t = finalException.getCause(); } asyncResp.consumerFail(finalException); } }; List<ExecutionListener<Invocation, Response>> listeners = new ArrayList<>(0); listeners.add(listener); ExecutionContext<Invocation> context = new ExecutionContext<>(invocation, null, null, null); LoadBalancerCommand<Response> command = LoadBalancerCommand.<Response>builder() .withLoadBalancer(new RetryLoadBalancer(chosenLB)) .withServerLocator(invocation) .withRetryHandler(ExtensionsManager.createRetryHandler(invocation.getMicroserviceName())) .withListeners(listeners) .withExecutionContext(context) .build(); Observable<Response> observable = command.submit(new ServerOperation<Response>() { public Observable<Response> call(Server s) { return Observable.create(f -> { try { ServiceCombServer server = (ServiceCombServer) s; chosenLB.getLoadBalancerStats().incrementNumRequests(s); invocation.setHandlerIndex(currentHandler); invocation.setEndpoint(server.getEndpoint()); invocation.next(resp -> { if (isFailedResponse(resp)) { invocation.getTraceIdLogger().error(LOGGER, "service {}, call error, msg is {}, server is {} ", invocation.getInvocationQualifiedName(), ExceptionUtils.getExceptionMessageWithoutTrace((Throwable) resp.getResult()), s); chosenLB.getLoadBalancerStats().incrementSuccessiveConnectionFailureCount(s); ServiceCombLoadBalancerStats.INSTANCE.markFailure(server); f.onError(resp.getResult()); } else { chosenLB.getLoadBalancerStats().incrementActiveRequestsCount(s); chosenLB.getLoadBalancerStats().noteResponseTime(s, (System.currentTimeMillis() - time)); ServiceCombLoadBalancerStats.INSTANCE.markSuccess(server); f.onNext(resp); f.onCompleted(); } }); } catch (Exception e) { invocation.getTraceIdLogger() .error(LOGGER, "execution error, msg is {}", ExceptionUtils.getExceptionMessageWithoutTrace(e)); f.onError(e); } }); } }); observable.subscribe(response -> { }, error -> { }, () -> { }); } LoadbalanceHandler(DiscoveryTree discoveryTree); LoadbalanceHandler(); @Override void handle(Invocation invocation, AsyncResponse asyncResp); }
|
LoadbalanceHandler implements Handler { private void sendWithRetry(Invocation invocation, AsyncResponse asyncResp, LoadBalancer chosenLB) throws Exception { long time = System.currentTimeMillis(); int currentHandler = invocation.getHandlerIndex(); SyncResponseExecutor orginExecutor; Executor newExecutor; if (invocation.getResponseExecutor() instanceof SyncResponseExecutor) { orginExecutor = (SyncResponseExecutor) invocation.getResponseExecutor(); newExecutor = new Executor() { @Override public void execute(Runnable command) { RETRY_POOL.submit(command); } }; invocation.setResponseExecutor(newExecutor); } else { orginExecutor = null; newExecutor = null; } ExecutionListener<Invocation, Response> listener = new ExecutionListener<Invocation, Response>() { @Override public void onExecutionStart(ExecutionContext<Invocation> context) throws AbortExecutionException { } @Override public void onStartWithServer(ExecutionContext<Invocation> context, ExecutionInfo info) throws AbortExecutionException { } @Override public void onExceptionWithServer(ExecutionContext<Invocation> context, Throwable exception, ExecutionInfo info) { context.getRequest().getTraceIdLogger() .error(LOGGER, "Invoke server failed. Operation {}; server {}; {}-{} msg {}", context.getRequest().getInvocationQualifiedName(), context.getRequest().getEndpoint(), info.getNumberOfPastServersAttempted(), info.getNumberOfPastAttemptsOnServer(), ExceptionUtils.getExceptionMessageWithoutTrace(exception)); } @Override public void onExecutionSuccess(ExecutionContext<Invocation> context, Response response, ExecutionInfo info) { if (info.getNumberOfPastServersAttempted() > 0 || info.getNumberOfPastAttemptsOnServer() > 0) { context.getRequest().getTraceIdLogger().error(LOGGER, "Invoke server success. Operation {}; server {}", context.getRequest().getInvocationQualifiedName(), context.getRequest().getEndpoint()); } if (orginExecutor != null) { orginExecutor.execute(() -> { asyncResp.complete(response); }); } else { asyncResp.complete(response); } } @Override public void onExecutionFailed(ExecutionContext<Invocation> context, Throwable finalException, ExecutionInfo info) { context.getRequest().getTraceIdLogger().error(LOGGER, "Invoke all server failed. Operation {}, e={}", context.getRequest().getInvocationQualifiedName(), ExceptionUtils.getExceptionMessageWithoutTrace(finalException)); if (orginExecutor != null) { orginExecutor.execute(() -> { fail(finalException); }); } else { fail(finalException); } } private void fail(Throwable finalException) { int depth = 10; Throwable t = finalException; while (depth-- > 0) { if (t instanceof InvocationException) { asyncResp.consumerFail(t); return; } t = finalException.getCause(); } asyncResp.consumerFail(finalException); } }; List<ExecutionListener<Invocation, Response>> listeners = new ArrayList<>(0); listeners.add(listener); ExecutionContext<Invocation> context = new ExecutionContext<>(invocation, null, null, null); LoadBalancerCommand<Response> command = LoadBalancerCommand.<Response>builder() .withLoadBalancer(new RetryLoadBalancer(chosenLB)) .withServerLocator(invocation) .withRetryHandler(ExtensionsManager.createRetryHandler(invocation.getMicroserviceName())) .withListeners(listeners) .withExecutionContext(context) .build(); Observable<Response> observable = command.submit(new ServerOperation<Response>() { public Observable<Response> call(Server s) { return Observable.create(f -> { try { ServiceCombServer server = (ServiceCombServer) s; chosenLB.getLoadBalancerStats().incrementNumRequests(s); invocation.setHandlerIndex(currentHandler); invocation.setEndpoint(server.getEndpoint()); invocation.next(resp -> { if (isFailedResponse(resp)) { invocation.getTraceIdLogger().error(LOGGER, "service {}, call error, msg is {}, server is {} ", invocation.getInvocationQualifiedName(), ExceptionUtils.getExceptionMessageWithoutTrace((Throwable) resp.getResult()), s); chosenLB.getLoadBalancerStats().incrementSuccessiveConnectionFailureCount(s); ServiceCombLoadBalancerStats.INSTANCE.markFailure(server); f.onError(resp.getResult()); } else { chosenLB.getLoadBalancerStats().incrementActiveRequestsCount(s); chosenLB.getLoadBalancerStats().noteResponseTime(s, (System.currentTimeMillis() - time)); ServiceCombLoadBalancerStats.INSTANCE.markSuccess(server); f.onNext(resp); f.onCompleted(); } }); } catch (Exception e) { invocation.getTraceIdLogger() .error(LOGGER, "execution error, msg is {}", ExceptionUtils.getExceptionMessageWithoutTrace(e)); f.onError(e); } }); } }); observable.subscribe(response -> { }, error -> { }, () -> { }); } LoadbalanceHandler(DiscoveryTree discoveryTree); LoadbalanceHandler(); @Override void handle(Invocation invocation, AsyncResponse asyncResp); static final String CONTEXT_KEY_SERVER_LIST; static final String SERVICECOMB_SERVER_ENDPOINT; static final boolean supportDefinedEndpoint; }
|
@Test public void edgeSlow(@Mocked Endpoint endpoint) { new Expectations() { { invocation.getEndpoint(); result = endpoint; endpoint.getEndpoint(); result = "rest: invocation.isConsumer(); result = true; invocation.getTraceIdLogger(); result = new TraceIdLogger(invocation); invocation.isEdge(); result = true; operationMeta.getExtData(RestConst.SWAGGER_REST_OPERATION); result = restOperationMeta; operationConfig.isSlowInvocationEnabled(); result = true; operationConfig.getNanoSlowInvocation(); result = 1; stageTrace.calcTotalTime(); result = 1; } }; logger.onInvocationFinish(event); Assert.assertEquals("" + "slow(0 ms) invocation, null:\n" + " http method: null\n" + " url : null\n" + " server : rest: + " status code: 0\n" + " total : 0.0 ms\n" + " prepare : 0.0 ms\n" + " threadPoolQueue : 0.0 ms\n" + " server filters request : 0.0 ms\n" + " handlers request : 0.0 ms\n" + " client filters request : 0.0 ms\n" + " send request : 0.0 ms\n" + " get connection : 0.0 ms\n" + " write to buf : 0.0 ms\n" + " wait response : 0.0 ms\n" + " wake consumer : 0.0 ms\n" + " client filters response: 0.0 ms\n" + " handlers response : 0.0 ms\n" + " server filters response: 0.0 ms\n" + " send response : 0.0 ms", logCollector.getEvents().get(0).getMessage()); }
|
@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 testIsFailedResponse() { Assert.assertFalse(handler.isFailedResponse(Response.create(400, "", ""))); Assert.assertFalse(handler.isFailedResponse(Response.create(500, "", ""))); Assert.assertTrue(handler.isFailedResponse(Response.create(490, "", ""))); Assert.assertTrue(handler.isFailedResponse(Response.consumerFailResp(new NullPointerException()))); }
|
protected boolean isFailedResponse(Response resp) { if (resp.isFailed()) { if (InvocationException.class.isInstance(resp.getResult())) { InvocationException e = (InvocationException) resp.getResult(); return e.getStatusCode() == ExceptionFactory.CONSUMER_INNER_STATUS_CODE || e.getStatusCode() == 503; } else { return true; } } else { return false; } }
|
LoadbalanceHandler implements Handler { protected boolean isFailedResponse(Response resp) { if (resp.isFailed()) { if (InvocationException.class.isInstance(resp.getResult())) { InvocationException e = (InvocationException) resp.getResult(); return e.getStatusCode() == ExceptionFactory.CONSUMER_INNER_STATUS_CODE || e.getStatusCode() == 503; } else { return true; } } else { return false; } } }
|
LoadbalanceHandler implements Handler { protected boolean isFailedResponse(Response resp) { if (resp.isFailed()) { if (InvocationException.class.isInstance(resp.getResult())) { InvocationException e = (InvocationException) resp.getResult(); return e.getStatusCode() == ExceptionFactory.CONSUMER_INNER_STATUS_CODE || e.getStatusCode() == 503; } else { return true; } } else { return false; } } LoadbalanceHandler(DiscoveryTree discoveryTree); LoadbalanceHandler(); }
|
LoadbalanceHandler implements Handler { protected boolean isFailedResponse(Response resp) { if (resp.isFailed()) { if (InvocationException.class.isInstance(resp.getResult())) { InvocationException e = (InvocationException) resp.getResult(); return e.getStatusCode() == ExceptionFactory.CONSUMER_INNER_STATUS_CODE || e.getStatusCode() == 503; } else { return true; } } else { return false; } } LoadbalanceHandler(DiscoveryTree discoveryTree); LoadbalanceHandler(); @Override void handle(Invocation invocation, AsyncResponse asyncResp); }
|
LoadbalanceHandler implements Handler { protected boolean isFailedResponse(Response resp) { if (resp.isFailed()) { if (InvocationException.class.isInstance(resp.getResult())) { InvocationException e = (InvocationException) resp.getResult(); return e.getStatusCode() == ExceptionFactory.CONSUMER_INNER_STATUS_CODE || e.getStatusCode() == 503; } else { return true; } } else { return false; } } LoadbalanceHandler(DiscoveryTree discoveryTree); LoadbalanceHandler(); @Override void handle(Invocation invocation, AsyncResponse asyncResp); static final String CONTEXT_KEY_SERVER_LIST; static final String SERVICECOMB_SERVER_ENDPOINT; static final boolean supportDefinedEndpoint; }
|
@Test public void testRuleName() { System.setProperty("servicecomb.loadbalance.mytest1.strategy.name", "RoundRobin"); System.setProperty("servicecomb.loadbalance.mytest2.strategy.name", "Random"); System.setProperty("servicecomb.loadbalance.mytest3.strategy.name", "WeightedResponse"); System.setProperty("servicecomb.loadbalance.mytest4.strategy.name", "SessionStickiness"); BeansHolder holder = new BeansHolder(); List<ExtensionsFactory> extensionsFactories = new ArrayList<>(); extensionsFactories.add(new RuleNameExtentionsFactory()); extensionsFactories.add(new DefaultRetryExtensionsFactory()); Deencapsulation.setField(holder, "extentionsFactories", extensionsFactories); holder.init(); Assert.assertEquals(RoundRobinRuleExt.class.getName(), ExtensionsManager.createLoadBalancerRule("mytest1").getClass().getName()); Assert.assertEquals(RandomRuleExt.class.getName(), ExtensionsManager.createLoadBalancerRule("mytest2").getClass().getName()); Assert.assertEquals(WeightedResponseTimeRuleExt.class.getName(), ExtensionsManager.createLoadBalancerRule("mytest3").getClass().getName()); Assert.assertEquals(SessionStickinessRule.class.getName(), ExtensionsManager.createLoadBalancerRule("mytest4").getClass().getName()); System.getProperties().remove("servicecomb.loadbalance.mytest1.strategy.name"); System.getProperties().remove("servicecomb.loadbalance.mytest2.strategy.name"); System.getProperties().remove("servicecomb.loadbalance.mytest3.strategy.name"); System.getProperties().remove("servicecomb.loadbalance.mytest4.strategy.name"); }
|
public static RuleExt createLoadBalancerRule(String microservice) { RuleExt rule = null; for (ExtensionsFactory factory : extentionFactories) { if (factory.isSupport(Configuration.RULE_STRATEGY_NAME, Configuration.INSTANCE.getRuleStrategyName(microservice))) { rule = factory.createLoadBalancerRule( Configuration.INSTANCE.getRuleStrategyName(microservice)); break; } } if (rule == null) { rule = new RoundRobinRuleExt(); } LOGGER.info("Using load balance rule {} for microservice {}.", rule.getClass().getName(), microservice); return rule; }
|
ExtensionsManager { public static RuleExt createLoadBalancerRule(String microservice) { RuleExt rule = null; for (ExtensionsFactory factory : extentionFactories) { if (factory.isSupport(Configuration.RULE_STRATEGY_NAME, Configuration.INSTANCE.getRuleStrategyName(microservice))) { rule = factory.createLoadBalancerRule( Configuration.INSTANCE.getRuleStrategyName(microservice)); break; } } if (rule == null) { rule = new RoundRobinRuleExt(); } LOGGER.info("Using load balance rule {} for microservice {}.", rule.getClass().getName(), microservice); return rule; } }
|
ExtensionsManager { public static RuleExt createLoadBalancerRule(String microservice) { RuleExt rule = null; for (ExtensionsFactory factory : extentionFactories) { if (factory.isSupport(Configuration.RULE_STRATEGY_NAME, Configuration.INSTANCE.getRuleStrategyName(microservice))) { rule = factory.createLoadBalancerRule( Configuration.INSTANCE.getRuleStrategyName(microservice)); break; } } if (rule == null) { rule = new RoundRobinRuleExt(); } LOGGER.info("Using load balance rule {} for microservice {}.", rule.getClass().getName(), microservice); return rule; } }
|
ExtensionsManager { public static RuleExt createLoadBalancerRule(String microservice) { RuleExt rule = null; for (ExtensionsFactory factory : extentionFactories) { if (factory.isSupport(Configuration.RULE_STRATEGY_NAME, Configuration.INSTANCE.getRuleStrategyName(microservice))) { rule = factory.createLoadBalancerRule( Configuration.INSTANCE.getRuleStrategyName(microservice)); break; } } if (rule == null) { rule = new RoundRobinRuleExt(); } LOGGER.info("Using load balance rule {} for microservice {}.", rule.getClass().getName(), microservice); return rule; } static void addExtentionsFactory(ExtensionsFactory factory); static RuleExt createLoadBalancerRule(String microservice); static RetryHandler createRetryHandler(String microservice); }
|
ExtensionsManager { public static RuleExt createLoadBalancerRule(String microservice) { RuleExt rule = null; for (ExtensionsFactory factory : extentionFactories) { if (factory.isSupport(Configuration.RULE_STRATEGY_NAME, Configuration.INSTANCE.getRuleStrategyName(microservice))) { rule = factory.createLoadBalancerRule( Configuration.INSTANCE.getRuleStrategyName(microservice)); break; } } if (rule == null) { rule = new RoundRobinRuleExt(); } LOGGER.info("Using load balance rule {} for microservice {}.", rule.getClass().getName(), microservice); return rule; } static void addExtentionsFactory(ExtensionsFactory factory); static RuleExt createLoadBalancerRule(String microservice); static RetryHandler createRetryHandler(String microservice); }
|
@Test public void testRuleClassName() { BeansHolder holder = new BeansHolder(); List<ExtensionsFactory> extensionsFactories = new ArrayList<>(); extensionsFactories.add(new RuleNameExtentionsFactory()); extensionsFactories.add(new DefaultRetryExtensionsFactory()); Deencapsulation.setField(holder, "extentionsFactories", extensionsFactories); holder.init(); RetryHandler retryHandler = ExtensionsManager.createRetryHandler("mytest1"); Assert.assertTrue(DefaultLoadBalancerRetryHandler.class.isInstance(retryHandler)); Assert.assertFalse(retryHandler.isRetriableException(new InvocationException(400, "", ""), false)); Assert.assertFalse(retryHandler.isRetriableException(new InvocationException(400, "", ""), true)); Assert.assertTrue(retryHandler.isRetriableException(new InvocationException(503, "", ""), true)); Assert.assertTrue(retryHandler.isRetriableException(new ConnectException(), false)); Assert.assertTrue(retryHandler.isRetriableException(new ConnectException(), true)); Assert.assertTrue(retryHandler.isRetriableException(new SocketTimeoutException(), false)); Assert.assertTrue(retryHandler.isRetriableException(new SocketTimeoutException(), true)); Assert.assertFalse(retryHandler.isRetriableException(new IOException(), true)); }
|
public static RetryHandler createRetryHandler(String microservice) { RetryHandler handler = null; for (ExtensionsFactory factory : extentionFactories) { if (factory.isSupport(Configuration.RETRY_HANDLER, Configuration.INSTANCE.getRetryHandler(microservice))) { handler = factory.createRetryHandler(Configuration.INSTANCE.getRetryHandler(microservice), microservice); break; } } LOGGER.debug("Using retry handler {} for microservice {}.", handler.getClass().getName(), microservice); return handler; }
|
ExtensionsManager { public static RetryHandler createRetryHandler(String microservice) { RetryHandler handler = null; for (ExtensionsFactory factory : extentionFactories) { if (factory.isSupport(Configuration.RETRY_HANDLER, Configuration.INSTANCE.getRetryHandler(microservice))) { handler = factory.createRetryHandler(Configuration.INSTANCE.getRetryHandler(microservice), microservice); break; } } LOGGER.debug("Using retry handler {} for microservice {}.", handler.getClass().getName(), microservice); return handler; } }
|
ExtensionsManager { public static RetryHandler createRetryHandler(String microservice) { RetryHandler handler = null; for (ExtensionsFactory factory : extentionFactories) { if (factory.isSupport(Configuration.RETRY_HANDLER, Configuration.INSTANCE.getRetryHandler(microservice))) { handler = factory.createRetryHandler(Configuration.INSTANCE.getRetryHandler(microservice), microservice); break; } } LOGGER.debug("Using retry handler {} for microservice {}.", handler.getClass().getName(), microservice); return handler; } }
|
ExtensionsManager { public static RetryHandler createRetryHandler(String microservice) { RetryHandler handler = null; for (ExtensionsFactory factory : extentionFactories) { if (factory.isSupport(Configuration.RETRY_HANDLER, Configuration.INSTANCE.getRetryHandler(microservice))) { handler = factory.createRetryHandler(Configuration.INSTANCE.getRetryHandler(microservice), microservice); break; } } LOGGER.debug("Using retry handler {} for microservice {}.", handler.getClass().getName(), microservice); return handler; } static void addExtentionsFactory(ExtensionsFactory factory); static RuleExt createLoadBalancerRule(String microservice); static RetryHandler createRetryHandler(String microservice); }
|
ExtensionsManager { public static RetryHandler createRetryHandler(String microservice) { RetryHandler handler = null; for (ExtensionsFactory factory : extentionFactories) { if (factory.isSupport(Configuration.RETRY_HANDLER, Configuration.INSTANCE.getRetryHandler(microservice))) { handler = factory.createRetryHandler(Configuration.INSTANCE.getRetryHandler(microservice), microservice); break; } } LOGGER.debug("Using retry handler {} for microservice {}.", handler.getClass().getName(), microservice); return handler; } static void addExtentionsFactory(ExtensionsFactory factory); static RuleExt createLoadBalancerRule(String microservice); static RetryHandler createRetryHandler(String microservice); }
|
@Test public void testRoundRobin() { RoundRobinRuleExt rule = new RoundRobinRuleExt(); LoadBalancer loadBalancer = new LoadBalancer(rule, "testService"); List<ServiceCombServer> servers = new ArrayList<>(); Invocation invocation = Mockito.mock(Invocation.class); for (int i = 0; i < 2; i++) { ServiceCombServer server = Mockito.mock(ServiceCombServer.class); Mockito.when(server.toString()).thenReturn("server " + i); servers.add(server); loadBalancer.getLoadBalancerStats().noteResponseTime(server, 1); } AtomicInteger server1 = new AtomicInteger(0); AtomicInteger server2 = new AtomicInteger(0); for (int i = 0; i < 2000; i++) { if (rule.choose(servers, invocation).toString().equals("server 0")) { server1.incrementAndGet(); } else { server2.incrementAndGet(); } } Assert.assertEquals(server1.get(), server2.get()); }
|
@Override public ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation) { if (servers.isEmpty()) { return null; } int index = Math.abs(counter.getAndIncrement()) % servers.size(); return servers.get(index); }
|
RoundRobinRuleExt implements RuleExt { @Override public ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation) { if (servers.isEmpty()) { return null; } int index = Math.abs(counter.getAndIncrement()) % servers.size(); return servers.get(index); } }
|
RoundRobinRuleExt implements RuleExt { @Override public ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation) { if (servers.isEmpty()) { return null; } int index = Math.abs(counter.getAndIncrement()) % servers.size(); return servers.get(index); } }
|
RoundRobinRuleExt implements RuleExt { @Override public ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation) { if (servers.isEmpty()) { return null; } int index = Math.abs(counter.getAndIncrement()) % servers.size(); return servers.get(index); } @Override ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation); }
|
RoundRobinRuleExt implements RuleExt { @Override public ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation) { if (servers.isEmpty()) { return null; } int index = Math.abs(counter.getAndIncrement()) % servers.size(); return servers.get(index); } @Override ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation); }
|
@Test public void testBenchmarkRobin() { RoundRobinRuleExt rule = new RoundRobinRuleExt(); LoadBalancer loadBalancer = new LoadBalancer(rule, "testService"); List<ServiceCombServer> servers = new ArrayList<>(); Invocation invocation = Mockito.mock(Invocation.class); for (int i = 0; i < 100; i++) { ServiceCombServer server = Mockito.mock(ServiceCombServer.class); Mockito.when(server.toString()).thenReturn("server " + i); servers.add(server); loadBalancer.getLoadBalancerStats().noteResponseTime(server, 2); } long begin = System.currentTimeMillis(); for (int i = 0; i < 10000; i++) { rule.choose(servers, invocation); } long taken = System.currentTimeMillis() - begin; System.out.println("taken " + taken); Assert.assertEquals("actual token " + taken, taken < 10 * 5, true); }
|
@Override public ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation) { if (servers.isEmpty()) { return null; } int index = Math.abs(counter.getAndIncrement()) % servers.size(); return servers.get(index); }
|
RoundRobinRuleExt implements RuleExt { @Override public ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation) { if (servers.isEmpty()) { return null; } int index = Math.abs(counter.getAndIncrement()) % servers.size(); return servers.get(index); } }
|
RoundRobinRuleExt implements RuleExt { @Override public ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation) { if (servers.isEmpty()) { return null; } int index = Math.abs(counter.getAndIncrement()) % servers.size(); return servers.get(index); } }
|
RoundRobinRuleExt implements RuleExt { @Override public ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation) { if (servers.isEmpty()) { return null; } int index = Math.abs(counter.getAndIncrement()) % servers.size(); return servers.get(index); } @Override ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation); }
|
RoundRobinRuleExt implements RuleExt { @Override public ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation) { if (servers.isEmpty()) { return null; } int index = Math.abs(counter.getAndIncrement()) % servers.size(); return servers.get(index); } @Override ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation); }
|
@Test public void testRoundRobin() { WeightedResponseTimeRuleExt rule = new WeightedResponseTimeRuleExt(); LoadBalancer loadBalancer = new LoadBalancer(rule, "testService"); List<ServiceCombServer> servers = new ArrayList<>(); Invocation invocation = Mockito.mock(Invocation.class); for (int i = 0; i < 2; i++) { ServiceCombServer server = Mockito.mock(ServiceCombServer.class); Mockito.when(server.toString()).thenReturn("server " + i); servers.add(server); loadBalancer.getLoadBalancerStats().noteResponseTime(server, 1); } AtomicInteger server1 = new AtomicInteger(0); AtomicInteger server2 = new AtomicInteger(0); for (int i = 0; i < 2000; i++) { if (rule.choose(servers, invocation).toString().equals("server 0")) { server1.incrementAndGet(); } else { server2.incrementAndGet(); } } Assert.assertEquals(server1.get(), server2.get()); }
|
@Override public ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation) { List<Double> stats = calculateTotalWeights(servers); if (stats.size() > 0) { double finalTotal = stats.get(stats.size() - 1); List<Double> weights = new ArrayList<>(servers.size()); for (int i = 0; i < stats.size() - 1; i++) { weights.add(finalTotal - stats.get(i)); } double ran = ThreadLocalRandom.current().nextDouble() * finalTotal * (servers.size() - 1); for (int i = 0; i < weights.size(); i++) { ran -= weights.get(i); if (ran < 0) { return servers.get(i); } } return servers.get(servers.size() - 1); } return super.choose(servers, invocation); }
|
WeightedResponseTimeRuleExt extends RoundRobinRuleExt { @Override public ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation) { List<Double> stats = calculateTotalWeights(servers); if (stats.size() > 0) { double finalTotal = stats.get(stats.size() - 1); List<Double> weights = new ArrayList<>(servers.size()); for (int i = 0; i < stats.size() - 1; i++) { weights.add(finalTotal - stats.get(i)); } double ran = ThreadLocalRandom.current().nextDouble() * finalTotal * (servers.size() - 1); for (int i = 0; i < weights.size(); i++) { ran -= weights.get(i); if (ran < 0) { return servers.get(i); } } return servers.get(servers.size() - 1); } return super.choose(servers, invocation); } }
|
WeightedResponseTimeRuleExt extends RoundRobinRuleExt { @Override public ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation) { List<Double> stats = calculateTotalWeights(servers); if (stats.size() > 0) { double finalTotal = stats.get(stats.size() - 1); List<Double> weights = new ArrayList<>(servers.size()); for (int i = 0; i < stats.size() - 1; i++) { weights.add(finalTotal - stats.get(i)); } double ran = ThreadLocalRandom.current().nextDouble() * finalTotal * (servers.size() - 1); for (int i = 0; i < weights.size(); i++) { ran -= weights.get(i); if (ran < 0) { return servers.get(i); } } return servers.get(servers.size() - 1); } return super.choose(servers, invocation); } }
|
WeightedResponseTimeRuleExt extends RoundRobinRuleExt { @Override public ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation) { List<Double> stats = calculateTotalWeights(servers); if (stats.size() > 0) { double finalTotal = stats.get(stats.size() - 1); List<Double> weights = new ArrayList<>(servers.size()); for (int i = 0; i < stats.size() - 1; i++) { weights.add(finalTotal - stats.get(i)); } double ran = ThreadLocalRandom.current().nextDouble() * finalTotal * (servers.size() - 1); for (int i = 0; i < weights.size(); i++) { ran -= weights.get(i); if (ran < 0) { return servers.get(i); } } return servers.get(servers.size() - 1); } return super.choose(servers, invocation); } @Override void setLoadBalancer(LoadBalancer loadBalancer); @Override ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation); }
|
WeightedResponseTimeRuleExt extends RoundRobinRuleExt { @Override public ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation) { List<Double> stats = calculateTotalWeights(servers); if (stats.size() > 0) { double finalTotal = stats.get(stats.size() - 1); List<Double> weights = new ArrayList<>(servers.size()); for (int i = 0; i < stats.size() - 1; i++) { weights.add(finalTotal - stats.get(i)); } double ran = ThreadLocalRandom.current().nextDouble() * finalTotal * (servers.size() - 1); for (int i = 0; i < weights.size(); i++) { ran -= weights.get(i); if (ran < 0) { return servers.get(i); } } return servers.get(servers.size() - 1); } return super.choose(servers, invocation); } @Override void setLoadBalancer(LoadBalancer loadBalancer); @Override ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation); }
|
@Test public void testWeighed() { WeightedResponseTimeRuleExt rule = new WeightedResponseTimeRuleExt(); LoadBalancer loadBalancer = new LoadBalancer(rule, "testService"); List<ServiceCombServer> servers = new ArrayList<>(); Invocation invocation = Mockito.mock(Invocation.class); for (int i = 0; i < 2; i++) { ServiceCombServer server = Mockito.mock(ServiceCombServer.class); Mockito.when(server.toString()).thenReturn("server " + i); servers.add(server); loadBalancer.getLoadBalancerStats().noteResponseTime(server, 20 * Math.pow(4, i + 1)); } AtomicInteger server1 = new AtomicInteger(0); AtomicInteger server2 = new AtomicInteger(0); for (int i = 0; i < 2000; i++) { if (rule.choose(servers, invocation).toString().equals("server 0")) { server1.incrementAndGet(); } else { server2.incrementAndGet(); } } double percent = (double) server1.get() / (server2.get() + server1.get()); System.out.println("percent" + percent); Assert.assertEquals("actually percent: " + percent, 0.70d < percent, percent < 0.90d); }
|
@Override public ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation) { List<Double> stats = calculateTotalWeights(servers); if (stats.size() > 0) { double finalTotal = stats.get(stats.size() - 1); List<Double> weights = new ArrayList<>(servers.size()); for (int i = 0; i < stats.size() - 1; i++) { weights.add(finalTotal - stats.get(i)); } double ran = ThreadLocalRandom.current().nextDouble() * finalTotal * (servers.size() - 1); for (int i = 0; i < weights.size(); i++) { ran -= weights.get(i); if (ran < 0) { return servers.get(i); } } return servers.get(servers.size() - 1); } return super.choose(servers, invocation); }
|
WeightedResponseTimeRuleExt extends RoundRobinRuleExt { @Override public ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation) { List<Double> stats = calculateTotalWeights(servers); if (stats.size() > 0) { double finalTotal = stats.get(stats.size() - 1); List<Double> weights = new ArrayList<>(servers.size()); for (int i = 0; i < stats.size() - 1; i++) { weights.add(finalTotal - stats.get(i)); } double ran = ThreadLocalRandom.current().nextDouble() * finalTotal * (servers.size() - 1); for (int i = 0; i < weights.size(); i++) { ran -= weights.get(i); if (ran < 0) { return servers.get(i); } } return servers.get(servers.size() - 1); } return super.choose(servers, invocation); } }
|
WeightedResponseTimeRuleExt extends RoundRobinRuleExt { @Override public ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation) { List<Double> stats = calculateTotalWeights(servers); if (stats.size() > 0) { double finalTotal = stats.get(stats.size() - 1); List<Double> weights = new ArrayList<>(servers.size()); for (int i = 0; i < stats.size() - 1; i++) { weights.add(finalTotal - stats.get(i)); } double ran = ThreadLocalRandom.current().nextDouble() * finalTotal * (servers.size() - 1); for (int i = 0; i < weights.size(); i++) { ran -= weights.get(i); if (ran < 0) { return servers.get(i); } } return servers.get(servers.size() - 1); } return super.choose(servers, invocation); } }
|
WeightedResponseTimeRuleExt extends RoundRobinRuleExt { @Override public ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation) { List<Double> stats = calculateTotalWeights(servers); if (stats.size() > 0) { double finalTotal = stats.get(stats.size() - 1); List<Double> weights = new ArrayList<>(servers.size()); for (int i = 0; i < stats.size() - 1; i++) { weights.add(finalTotal - stats.get(i)); } double ran = ThreadLocalRandom.current().nextDouble() * finalTotal * (servers.size() - 1); for (int i = 0; i < weights.size(); i++) { ran -= weights.get(i); if (ran < 0) { return servers.get(i); } } return servers.get(servers.size() - 1); } return super.choose(servers, invocation); } @Override void setLoadBalancer(LoadBalancer loadBalancer); @Override ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation); }
|
WeightedResponseTimeRuleExt extends RoundRobinRuleExt { @Override public ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation) { List<Double> stats = calculateTotalWeights(servers); if (stats.size() > 0) { double finalTotal = stats.get(stats.size() - 1); List<Double> weights = new ArrayList<>(servers.size()); for (int i = 0; i < stats.size() - 1; i++) { weights.add(finalTotal - stats.get(i)); } double ran = ThreadLocalRandom.current().nextDouble() * finalTotal * (servers.size() - 1); for (int i = 0; i < weights.size(); i++) { ran -= weights.get(i); if (ran < 0) { return servers.get(i); } } return servers.get(servers.size() - 1); } return super.choose(servers, invocation); } @Override void setLoadBalancer(LoadBalancer loadBalancer); @Override ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation); }
|
@Test public void testBenchmark() { WeightedResponseTimeRuleExt rule = new WeightedResponseTimeRuleExt(); LoadBalancer loadBalancer = new LoadBalancer(rule, "testService"); List<ServiceCombServer> servers = new ArrayList<>(); Invocation invocation = Mockito.mock(Invocation.class); for (int i = 0; i < 100; i++) { ServiceCombServer server = Mockito.mock(ServiceCombServer.class); Mockito.when(server.toString()).thenReturn("server " + i); servers.add(server); loadBalancer.getLoadBalancerStats().noteResponseTime(server, i); } long begin = System.currentTimeMillis(); for (int i = 0; i < 10000; i++) { rule.choose(servers, invocation); } long taken = System.currentTimeMillis() - begin; System.out.println("taken " + taken); Assert.assertEquals("actually taken: " + taken, taken < 1000 * 5, true); }
|
@Override public ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation) { List<Double> stats = calculateTotalWeights(servers); if (stats.size() > 0) { double finalTotal = stats.get(stats.size() - 1); List<Double> weights = new ArrayList<>(servers.size()); for (int i = 0; i < stats.size() - 1; i++) { weights.add(finalTotal - stats.get(i)); } double ran = ThreadLocalRandom.current().nextDouble() * finalTotal * (servers.size() - 1); for (int i = 0; i < weights.size(); i++) { ran -= weights.get(i); if (ran < 0) { return servers.get(i); } } return servers.get(servers.size() - 1); } return super.choose(servers, invocation); }
|
WeightedResponseTimeRuleExt extends RoundRobinRuleExt { @Override public ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation) { List<Double> stats = calculateTotalWeights(servers); if (stats.size() > 0) { double finalTotal = stats.get(stats.size() - 1); List<Double> weights = new ArrayList<>(servers.size()); for (int i = 0; i < stats.size() - 1; i++) { weights.add(finalTotal - stats.get(i)); } double ran = ThreadLocalRandom.current().nextDouble() * finalTotal * (servers.size() - 1); for (int i = 0; i < weights.size(); i++) { ran -= weights.get(i); if (ran < 0) { return servers.get(i); } } return servers.get(servers.size() - 1); } return super.choose(servers, invocation); } }
|
WeightedResponseTimeRuleExt extends RoundRobinRuleExt { @Override public ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation) { List<Double> stats = calculateTotalWeights(servers); if (stats.size() > 0) { double finalTotal = stats.get(stats.size() - 1); List<Double> weights = new ArrayList<>(servers.size()); for (int i = 0; i < stats.size() - 1; i++) { weights.add(finalTotal - stats.get(i)); } double ran = ThreadLocalRandom.current().nextDouble() * finalTotal * (servers.size() - 1); for (int i = 0; i < weights.size(); i++) { ran -= weights.get(i); if (ran < 0) { return servers.get(i); } } return servers.get(servers.size() - 1); } return super.choose(servers, invocation); } }
|
WeightedResponseTimeRuleExt extends RoundRobinRuleExt { @Override public ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation) { List<Double> stats = calculateTotalWeights(servers); if (stats.size() > 0) { double finalTotal = stats.get(stats.size() - 1); List<Double> weights = new ArrayList<>(servers.size()); for (int i = 0; i < stats.size() - 1; i++) { weights.add(finalTotal - stats.get(i)); } double ran = ThreadLocalRandom.current().nextDouble() * finalTotal * (servers.size() - 1); for (int i = 0; i < weights.size(); i++) { ran -= weights.get(i); if (ran < 0) { return servers.get(i); } } return servers.get(servers.size() - 1); } return super.choose(servers, invocation); } @Override void setLoadBalancer(LoadBalancer loadBalancer); @Override ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation); }
|
WeightedResponseTimeRuleExt extends RoundRobinRuleExt { @Override public ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation) { List<Double> stats = calculateTotalWeights(servers); if (stats.size() > 0) { double finalTotal = stats.get(stats.size() - 1); List<Double> weights = new ArrayList<>(servers.size()); for (int i = 0; i < stats.size() - 1; i++) { weights.add(finalTotal - stats.get(i)); } double ran = ThreadLocalRandom.current().nextDouble() * finalTotal * (servers.size() - 1); for (int i = 0; i < weights.size(); i++) { ran -= weights.get(i); if (ran < 0) { return servers.get(i); } } return servers.get(servers.size() - 1); } return super.choose(servers, invocation); } @Override void setLoadBalancer(LoadBalancer loadBalancer); @Override ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation); }
|
@Test public void testBenchmarkRobin() { WeightedResponseTimeRuleExt rule = new WeightedResponseTimeRuleExt(); LoadBalancer loadBalancer = new LoadBalancer(rule, "testService"); List<ServiceCombServer> servers = new ArrayList<>(); Invocation invocation = Mockito.mock(Invocation.class); for (int i = 0; i < 100; i++) { ServiceCombServer server = Mockito.mock(ServiceCombServer.class); Mockito.when(server.toString()).thenReturn("server " + i); servers.add(server); loadBalancer.getLoadBalancerStats().noteResponseTime(server, 2); } long begin = System.currentTimeMillis(); for (int i = 0; i < 10000; i++) { rule.choose(servers, invocation); } long taken = System.currentTimeMillis() - begin; System.out.println("taken " + taken); Assert.assertEquals("actually taken: " + taken, taken < 200 * 5, true); }
|
@Override public ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation) { List<Double> stats = calculateTotalWeights(servers); if (stats.size() > 0) { double finalTotal = stats.get(stats.size() - 1); List<Double> weights = new ArrayList<>(servers.size()); for (int i = 0; i < stats.size() - 1; i++) { weights.add(finalTotal - stats.get(i)); } double ran = ThreadLocalRandom.current().nextDouble() * finalTotal * (servers.size() - 1); for (int i = 0; i < weights.size(); i++) { ran -= weights.get(i); if (ran < 0) { return servers.get(i); } } return servers.get(servers.size() - 1); } return super.choose(servers, invocation); }
|
WeightedResponseTimeRuleExt extends RoundRobinRuleExt { @Override public ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation) { List<Double> stats = calculateTotalWeights(servers); if (stats.size() > 0) { double finalTotal = stats.get(stats.size() - 1); List<Double> weights = new ArrayList<>(servers.size()); for (int i = 0; i < stats.size() - 1; i++) { weights.add(finalTotal - stats.get(i)); } double ran = ThreadLocalRandom.current().nextDouble() * finalTotal * (servers.size() - 1); for (int i = 0; i < weights.size(); i++) { ran -= weights.get(i); if (ran < 0) { return servers.get(i); } } return servers.get(servers.size() - 1); } return super.choose(servers, invocation); } }
|
WeightedResponseTimeRuleExt extends RoundRobinRuleExt { @Override public ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation) { List<Double> stats = calculateTotalWeights(servers); if (stats.size() > 0) { double finalTotal = stats.get(stats.size() - 1); List<Double> weights = new ArrayList<>(servers.size()); for (int i = 0; i < stats.size() - 1; i++) { weights.add(finalTotal - stats.get(i)); } double ran = ThreadLocalRandom.current().nextDouble() * finalTotal * (servers.size() - 1); for (int i = 0; i < weights.size(); i++) { ran -= weights.get(i); if (ran < 0) { return servers.get(i); } } return servers.get(servers.size() - 1); } return super.choose(servers, invocation); } }
|
WeightedResponseTimeRuleExt extends RoundRobinRuleExt { @Override public ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation) { List<Double> stats = calculateTotalWeights(servers); if (stats.size() > 0) { double finalTotal = stats.get(stats.size() - 1); List<Double> weights = new ArrayList<>(servers.size()); for (int i = 0; i < stats.size() - 1; i++) { weights.add(finalTotal - stats.get(i)); } double ran = ThreadLocalRandom.current().nextDouble() * finalTotal * (servers.size() - 1); for (int i = 0; i < weights.size(); i++) { ran -= weights.get(i); if (ran < 0) { return servers.get(i); } } return servers.get(servers.size() - 1); } return super.choose(servers, invocation); } @Override void setLoadBalancer(LoadBalancer loadBalancer); @Override ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation); }
|
WeightedResponseTimeRuleExt extends RoundRobinRuleExt { @Override public ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation) { List<Double> stats = calculateTotalWeights(servers); if (stats.size() > 0) { double finalTotal = stats.get(stats.size() - 1); List<Double> weights = new ArrayList<>(servers.size()); for (int i = 0; i < stats.size() - 1; i++) { weights.add(finalTotal - stats.get(i)); } double ran = ThreadLocalRandom.current().nextDouble() * finalTotal * (servers.size() - 1); for (int i = 0; i < weights.size(); i++) { ran -= weights.get(i); if (ran < 0) { return servers.get(i); } } return servers.get(servers.size() - 1); } return super.choose(servers, invocation); } @Override void setLoadBalancer(LoadBalancer loadBalancer); @Override ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation); }
|
@Test public void testGlobalAllowIsolatedServerTryingFlag_apply_with_null_precondition() { Invocation invocation = new Invocation(); Assert.assertTrue(ServiceCombServerStats.applyForTryingChance(invocation)); Assert.assertSame(invocation, ServiceCombServerStats.globalAllowIsolatedServerTryingFlag.get().getInvocation()); }
|
public static boolean applyForTryingChance(Invocation invocation) { TryingIsolatedServerMarker marker = globalAllowIsolatedServerTryingFlag.get(); if (marker == null) { return globalAllowIsolatedServerTryingFlag.compareAndSet(null, new TryingIsolatedServerMarker(invocation)); } if (marker.isOutdated()) { return globalAllowIsolatedServerTryingFlag.compareAndSet(marker, new TryingIsolatedServerMarker(invocation)); } return false; }
|
ServiceCombServerStats { public static boolean applyForTryingChance(Invocation invocation) { TryingIsolatedServerMarker marker = globalAllowIsolatedServerTryingFlag.get(); if (marker == null) { return globalAllowIsolatedServerTryingFlag.compareAndSet(null, new TryingIsolatedServerMarker(invocation)); } if (marker.isOutdated()) { return globalAllowIsolatedServerTryingFlag.compareAndSet(marker, new TryingIsolatedServerMarker(invocation)); } return false; } }
|
ServiceCombServerStats { public static boolean applyForTryingChance(Invocation invocation) { TryingIsolatedServerMarker marker = globalAllowIsolatedServerTryingFlag.get(); if (marker == null) { return globalAllowIsolatedServerTryingFlag.compareAndSet(null, new TryingIsolatedServerMarker(invocation)); } if (marker.isOutdated()) { return globalAllowIsolatedServerTryingFlag.compareAndSet(marker, new TryingIsolatedServerMarker(invocation)); } return false; } ServiceCombServerStats(); ServiceCombServerStats(Clock clock); }
|
ServiceCombServerStats { public static boolean applyForTryingChance(Invocation invocation) { TryingIsolatedServerMarker marker = globalAllowIsolatedServerTryingFlag.get(); if (marker == null) { return globalAllowIsolatedServerTryingFlag.compareAndSet(null, new TryingIsolatedServerMarker(invocation)); } if (marker.isOutdated()) { return globalAllowIsolatedServerTryingFlag.compareAndSet(marker, new TryingIsolatedServerMarker(invocation)); } return false; } ServiceCombServerStats(); ServiceCombServerStats(Clock clock); static boolean isolatedServerCanTry(); static boolean applyForTryingChance(Invocation invocation); static void checkAndReleaseTryingChance(Invocation invocation); void markIsolated(boolean isolated); void markSuccess(); void markFailure(); long getLastVisitTime(); long getLastActiveTime(); long getCountinuousFailureCount(); long getTotalRequests(); long getSuccessRequests(); long getFailedRequests(); int getSuccessRate(); int getFailedRate(); boolean isIsolated(); }
|
ServiceCombServerStats { public static boolean applyForTryingChance(Invocation invocation) { TryingIsolatedServerMarker marker = globalAllowIsolatedServerTryingFlag.get(); if (marker == null) { return globalAllowIsolatedServerTryingFlag.compareAndSet(null, new TryingIsolatedServerMarker(invocation)); } if (marker.isOutdated()) { return globalAllowIsolatedServerTryingFlag.compareAndSet(marker, new TryingIsolatedServerMarker(invocation)); } return false; } ServiceCombServerStats(); ServiceCombServerStats(Clock clock); static boolean isolatedServerCanTry(); static boolean applyForTryingChance(Invocation invocation); static void checkAndReleaseTryingChance(Invocation invocation); void markIsolated(boolean isolated); void markSuccess(); void markFailure(); long getLastVisitTime(); long getLastActiveTime(); long getCountinuousFailureCount(); long getTotalRequests(); long getSuccessRequests(); long getFailedRequests(); int getSuccessRate(); int getFailedRate(); boolean isIsolated(); }
|
@Test public void producerSlow(@Mocked HttpServletRequestEx requestEx) { new Expectations() { { invocation.getRequestEx(); result = requestEx; invocation.getTraceIdLogger(); result = new TraceIdLogger(invocation); requestEx.getRemoteAddr(); result = "1.1.1.1"; requestEx.getRemotePort(); result = 1234; invocation.isConsumer(); result = false; operationMeta.getExtData(RestConst.SWAGGER_REST_OPERATION); result = restOperationMeta; operationConfig.isSlowInvocationEnabled(); result = true; operationConfig.getNanoSlowInvocation(); result = 1; stageTrace.calcTotalTime(); result = 1; } }; logger.onInvocationFinish(event); Assert.assertEquals("" + "slow(0 ms) invocation, null:\n" + " http method: null\n" + " url : null\n" + " client : 1.1.1.1:1234\n" + " status code: 0\n" + " total : 0.0 ms\n" + " prepare : 0.0 ms\n" + " threadPoolQueue : 0.0 ms\n" + " server filters request : 0.0 ms\n" + " handlers request : 0.0 ms\n" + " business execute : 0.0 ms\n" + " handlers response : 0.0 ms\n" + " server filters response: 0.0 ms\n" + " send response : 0.0 ms", logCollector.getEvents().get(0).getMessage()); }
|
@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 testGlobalAllowIsolatedServerTryingFlag_apply_with_chance_occupied() { Invocation invocation = new Invocation(); Assert.assertTrue(ServiceCombServerStats.applyForTryingChance(invocation)); Assert.assertSame(invocation, ServiceCombServerStats.globalAllowIsolatedServerTryingFlag.get().getInvocation()); Invocation otherInvocation = new Invocation(); Assert.assertFalse(ServiceCombServerStats.applyForTryingChance(otherInvocation)); Assert.assertSame(invocation, ServiceCombServerStats.globalAllowIsolatedServerTryingFlag.get().getInvocation()); }
|
public static boolean applyForTryingChance(Invocation invocation) { TryingIsolatedServerMarker marker = globalAllowIsolatedServerTryingFlag.get(); if (marker == null) { return globalAllowIsolatedServerTryingFlag.compareAndSet(null, new TryingIsolatedServerMarker(invocation)); } if (marker.isOutdated()) { return globalAllowIsolatedServerTryingFlag.compareAndSet(marker, new TryingIsolatedServerMarker(invocation)); } return false; }
|
ServiceCombServerStats { public static boolean applyForTryingChance(Invocation invocation) { TryingIsolatedServerMarker marker = globalAllowIsolatedServerTryingFlag.get(); if (marker == null) { return globalAllowIsolatedServerTryingFlag.compareAndSet(null, new TryingIsolatedServerMarker(invocation)); } if (marker.isOutdated()) { return globalAllowIsolatedServerTryingFlag.compareAndSet(marker, new TryingIsolatedServerMarker(invocation)); } return false; } }
|
ServiceCombServerStats { public static boolean applyForTryingChance(Invocation invocation) { TryingIsolatedServerMarker marker = globalAllowIsolatedServerTryingFlag.get(); if (marker == null) { return globalAllowIsolatedServerTryingFlag.compareAndSet(null, new TryingIsolatedServerMarker(invocation)); } if (marker.isOutdated()) { return globalAllowIsolatedServerTryingFlag.compareAndSet(marker, new TryingIsolatedServerMarker(invocation)); } return false; } ServiceCombServerStats(); ServiceCombServerStats(Clock clock); }
|
ServiceCombServerStats { public static boolean applyForTryingChance(Invocation invocation) { TryingIsolatedServerMarker marker = globalAllowIsolatedServerTryingFlag.get(); if (marker == null) { return globalAllowIsolatedServerTryingFlag.compareAndSet(null, new TryingIsolatedServerMarker(invocation)); } if (marker.isOutdated()) { return globalAllowIsolatedServerTryingFlag.compareAndSet(marker, new TryingIsolatedServerMarker(invocation)); } return false; } ServiceCombServerStats(); ServiceCombServerStats(Clock clock); static boolean isolatedServerCanTry(); static boolean applyForTryingChance(Invocation invocation); static void checkAndReleaseTryingChance(Invocation invocation); void markIsolated(boolean isolated); void markSuccess(); void markFailure(); long getLastVisitTime(); long getLastActiveTime(); long getCountinuousFailureCount(); long getTotalRequests(); long getSuccessRequests(); long getFailedRequests(); int getSuccessRate(); int getFailedRate(); boolean isIsolated(); }
|
ServiceCombServerStats { public static boolean applyForTryingChance(Invocation invocation) { TryingIsolatedServerMarker marker = globalAllowIsolatedServerTryingFlag.get(); if (marker == null) { return globalAllowIsolatedServerTryingFlag.compareAndSet(null, new TryingIsolatedServerMarker(invocation)); } if (marker.isOutdated()) { return globalAllowIsolatedServerTryingFlag.compareAndSet(marker, new TryingIsolatedServerMarker(invocation)); } return false; } ServiceCombServerStats(); ServiceCombServerStats(Clock clock); static boolean isolatedServerCanTry(); static boolean applyForTryingChance(Invocation invocation); static void checkAndReleaseTryingChance(Invocation invocation); void markIsolated(boolean isolated); void markSuccess(); void markFailure(); long getLastVisitTime(); long getLastActiveTime(); long getCountinuousFailureCount(); long getTotalRequests(); long getSuccessRequests(); long getFailedRequests(); int getSuccessRate(); int getFailedRate(); boolean isIsolated(); }
|
@Test public void testGlobalAllowIsolatedServerTryingFlag_apply_with_flag_outdated() { Invocation invocation = new Invocation(); Assert.assertTrue(ServiceCombServerStats.applyForTryingChance(invocation)); Assert.assertSame(invocation, ServiceCombServerStats.globalAllowIsolatedServerTryingFlag.get().getInvocation()); ServiceCombServerStats.globalAllowIsolatedServerTryingFlag.get().clock = new MockClock(new Holder<>( ServiceCombServerStats.globalAllowIsolatedServerTryingFlag.get().startTryingTimestamp + 60000 )); Invocation otherInvocation = new Invocation(); Assert.assertTrue(ServiceCombServerStats.applyForTryingChance(otherInvocation)); Assert .assertSame(otherInvocation, ServiceCombServerStats.globalAllowIsolatedServerTryingFlag.get().getInvocation()); }
|
public static boolean applyForTryingChance(Invocation invocation) { TryingIsolatedServerMarker marker = globalAllowIsolatedServerTryingFlag.get(); if (marker == null) { return globalAllowIsolatedServerTryingFlag.compareAndSet(null, new TryingIsolatedServerMarker(invocation)); } if (marker.isOutdated()) { return globalAllowIsolatedServerTryingFlag.compareAndSet(marker, new TryingIsolatedServerMarker(invocation)); } return false; }
|
ServiceCombServerStats { public static boolean applyForTryingChance(Invocation invocation) { TryingIsolatedServerMarker marker = globalAllowIsolatedServerTryingFlag.get(); if (marker == null) { return globalAllowIsolatedServerTryingFlag.compareAndSet(null, new TryingIsolatedServerMarker(invocation)); } if (marker.isOutdated()) { return globalAllowIsolatedServerTryingFlag.compareAndSet(marker, new TryingIsolatedServerMarker(invocation)); } return false; } }
|
ServiceCombServerStats { public static boolean applyForTryingChance(Invocation invocation) { TryingIsolatedServerMarker marker = globalAllowIsolatedServerTryingFlag.get(); if (marker == null) { return globalAllowIsolatedServerTryingFlag.compareAndSet(null, new TryingIsolatedServerMarker(invocation)); } if (marker.isOutdated()) { return globalAllowIsolatedServerTryingFlag.compareAndSet(marker, new TryingIsolatedServerMarker(invocation)); } return false; } ServiceCombServerStats(); ServiceCombServerStats(Clock clock); }
|
ServiceCombServerStats { public static boolean applyForTryingChance(Invocation invocation) { TryingIsolatedServerMarker marker = globalAllowIsolatedServerTryingFlag.get(); if (marker == null) { return globalAllowIsolatedServerTryingFlag.compareAndSet(null, new TryingIsolatedServerMarker(invocation)); } if (marker.isOutdated()) { return globalAllowIsolatedServerTryingFlag.compareAndSet(marker, new TryingIsolatedServerMarker(invocation)); } return false; } ServiceCombServerStats(); ServiceCombServerStats(Clock clock); static boolean isolatedServerCanTry(); static boolean applyForTryingChance(Invocation invocation); static void checkAndReleaseTryingChance(Invocation invocation); void markIsolated(boolean isolated); void markSuccess(); void markFailure(); long getLastVisitTime(); long getLastActiveTime(); long getCountinuousFailureCount(); long getTotalRequests(); long getSuccessRequests(); long getFailedRequests(); int getSuccessRate(); int getFailedRate(); boolean isIsolated(); }
|
ServiceCombServerStats { public static boolean applyForTryingChance(Invocation invocation) { TryingIsolatedServerMarker marker = globalAllowIsolatedServerTryingFlag.get(); if (marker == null) { return globalAllowIsolatedServerTryingFlag.compareAndSet(null, new TryingIsolatedServerMarker(invocation)); } if (marker.isOutdated()) { return globalAllowIsolatedServerTryingFlag.compareAndSet(marker, new TryingIsolatedServerMarker(invocation)); } return false; } ServiceCombServerStats(); ServiceCombServerStats(Clock clock); static boolean isolatedServerCanTry(); static boolean applyForTryingChance(Invocation invocation); static void checkAndReleaseTryingChance(Invocation invocation); void markIsolated(boolean isolated); void markSuccess(); void markFailure(); long getLastVisitTime(); long getLastActiveTime(); long getCountinuousFailureCount(); long getTotalRequests(); long getSuccessRequests(); long getFailedRequests(); int getSuccessRate(); int getFailedRate(); boolean isIsolated(); }
|
@Test public void testGetEndpoint() { cs.getEndpoint(); assertNotNull(cs.getEndpoint()); }
|
public Endpoint getEndpoint() { return endpoint; }
|
ServiceCombServer extends Server { public Endpoint getEndpoint() { return endpoint; } }
|
ServiceCombServer extends Server { public Endpoint getEndpoint() { return endpoint; } @VisibleForTesting ServiceCombServer(Endpoint endpoint, MicroserviceInstance instance); ServiceCombServer(Transport transport, CacheEndpoint cacheEndpoint); }
|
ServiceCombServer extends Server { public Endpoint getEndpoint() { return endpoint; } @VisibleForTesting ServiceCombServer(Endpoint endpoint, MicroserviceInstance instance); ServiceCombServer(Transport transport, CacheEndpoint cacheEndpoint); Endpoint getEndpoint(); MicroserviceInstance getInstance(); String toString(); String getHost(); boolean equals(Object o); int hashCode(); }
|
ServiceCombServer extends Server { public Endpoint getEndpoint() { return endpoint; } @VisibleForTesting ServiceCombServer(Endpoint endpoint, MicroserviceInstance instance); ServiceCombServer(Transport transport, CacheEndpoint cacheEndpoint); Endpoint getEndpoint(); MicroserviceInstance getInstance(); String toString(); String getHost(); boolean equals(Object o); int hashCode(); }
|
@Test public void testEqualsMethod() { Assert.assertFalse(cs.equals((Object) "abcd")); MicroserviceInstance instance1 = new MicroserviceInstance(); instance1.setInstanceId("1234"); ServiceCombServer other = new ServiceCombServer(transport, new CacheEndpoint("1234", instance1)); Assert.assertFalse(cs.equals(other)); MicroserviceInstance instance2 = new MicroserviceInstance(); instance2.setInstanceId("123456"); other = new ServiceCombServer(transport, new CacheEndpoint("abcd", instance2)); Assert.assertTrue(cs.equals(other)); }
|
public boolean equals(Object o) { if (o instanceof ServiceCombServer) { return this.instance.getInstanceId().equals(((ServiceCombServer) o).instance.getInstanceId()); } else { return false; } }
|
ServiceCombServer extends Server { public boolean equals(Object o) { if (o instanceof ServiceCombServer) { return this.instance.getInstanceId().equals(((ServiceCombServer) o).instance.getInstanceId()); } else { return false; } } }
|
ServiceCombServer extends Server { public boolean equals(Object o) { if (o instanceof ServiceCombServer) { return this.instance.getInstanceId().equals(((ServiceCombServer) o).instance.getInstanceId()); } else { return false; } } @VisibleForTesting ServiceCombServer(Endpoint endpoint, MicroserviceInstance instance); ServiceCombServer(Transport transport, CacheEndpoint cacheEndpoint); }
|
ServiceCombServer extends Server { public boolean equals(Object o) { if (o instanceof ServiceCombServer) { return this.instance.getInstanceId().equals(((ServiceCombServer) o).instance.getInstanceId()); } else { return false; } } @VisibleForTesting ServiceCombServer(Endpoint endpoint, MicroserviceInstance instance); ServiceCombServer(Transport transport, CacheEndpoint cacheEndpoint); Endpoint getEndpoint(); MicroserviceInstance getInstance(); String toString(); String getHost(); boolean equals(Object o); int hashCode(); }
|
ServiceCombServer extends Server { public boolean equals(Object o) { if (o instanceof ServiceCombServer) { return this.instance.getInstanceId().equals(((ServiceCombServer) o).instance.getInstanceId()); } else { return false; } } @VisibleForTesting ServiceCombServer(Endpoint endpoint, MicroserviceInstance instance); ServiceCombServer(Transport transport, CacheEndpoint cacheEndpoint); Endpoint getEndpoint(); MicroserviceInstance getInstance(); String toString(); String getHost(); boolean equals(Object o); int hashCode(); }
|
@Test public void testToStringMethod() { cs.toString(); assertNotNull(cs.toString()); }
|
public String toString() { return endpoint.getEndpoint(); }
|
ServiceCombServer extends Server { public String toString() { return endpoint.getEndpoint(); } }
|
ServiceCombServer extends Server { public String toString() { return endpoint.getEndpoint(); } @VisibleForTesting ServiceCombServer(Endpoint endpoint, MicroserviceInstance instance); ServiceCombServer(Transport transport, CacheEndpoint cacheEndpoint); }
|
ServiceCombServer extends Server { public String toString() { return endpoint.getEndpoint(); } @VisibleForTesting ServiceCombServer(Endpoint endpoint, MicroserviceInstance instance); ServiceCombServer(Transport transport, CacheEndpoint cacheEndpoint); Endpoint getEndpoint(); MicroserviceInstance getInstance(); String toString(); String getHost(); boolean equals(Object o); int hashCode(); }
|
ServiceCombServer extends Server { public String toString() { return endpoint.getEndpoint(); } @VisibleForTesting ServiceCombServer(Endpoint endpoint, MicroserviceInstance instance); ServiceCombServer(Transport transport, CacheEndpoint cacheEndpoint); Endpoint getEndpoint(); MicroserviceInstance getInstance(); String toString(); String getHost(); boolean equals(Object o); int hashCode(); }
|
@Test public void testGetHost() { cs.getHost(); assertNotNull(cs.getHost()); }
|
public String getHost() { return endpoint.getEndpoint(); }
|
ServiceCombServer extends Server { public String getHost() { return endpoint.getEndpoint(); } }
|
ServiceCombServer extends Server { public String getHost() { return endpoint.getEndpoint(); } @VisibleForTesting ServiceCombServer(Endpoint endpoint, MicroserviceInstance instance); ServiceCombServer(Transport transport, CacheEndpoint cacheEndpoint); }
|
ServiceCombServer extends Server { public String getHost() { return endpoint.getEndpoint(); } @VisibleForTesting ServiceCombServer(Endpoint endpoint, MicroserviceInstance instance); ServiceCombServer(Transport transport, CacheEndpoint cacheEndpoint); Endpoint getEndpoint(); MicroserviceInstance getInstance(); String toString(); String getHost(); boolean equals(Object o); int hashCode(); }
|
ServiceCombServer extends Server { public String getHost() { return endpoint.getEndpoint(); } @VisibleForTesting ServiceCombServer(Endpoint endpoint, MicroserviceInstance instance); ServiceCombServer(Transport transport, CacheEndpoint cacheEndpoint); Endpoint getEndpoint(); MicroserviceInstance getInstance(); String toString(); String getHost(); boolean equals(Object o); int hashCode(); }
|
@Test public void testHashCodeMethod() { cs.hashCode(); assertNotNull(cs.hashCode()); }
|
public int hashCode() { return this.instance.getInstanceId().hashCode(); }
|
ServiceCombServer extends Server { public int hashCode() { return this.instance.getInstanceId().hashCode(); } }
|
ServiceCombServer extends Server { public int hashCode() { return this.instance.getInstanceId().hashCode(); } @VisibleForTesting ServiceCombServer(Endpoint endpoint, MicroserviceInstance instance); ServiceCombServer(Transport transport, CacheEndpoint cacheEndpoint); }
|
ServiceCombServer extends Server { public int hashCode() { return this.instance.getInstanceId().hashCode(); } @VisibleForTesting ServiceCombServer(Endpoint endpoint, MicroserviceInstance instance); ServiceCombServer(Transport transport, CacheEndpoint cacheEndpoint); Endpoint getEndpoint(); MicroserviceInstance getInstance(); String toString(); String getHost(); boolean equals(Object o); int hashCode(); }
|
ServiceCombServer extends Server { public int hashCode() { return this.instance.getInstanceId().hashCode(); } @VisibleForTesting ServiceCombServer(Endpoint endpoint, MicroserviceInstance instance); ServiceCombServer(Transport transport, CacheEndpoint cacheEndpoint); Endpoint getEndpoint(); MicroserviceInstance getInstance(); String toString(); String getHost(); boolean equals(Object o); int hashCode(); }
|
@Test public void testGlobalQpsControl(final @Injectable Invocation invocation, final @Injectable AsyncResponse asyncResp) throws Exception { new Expectations() { { invocation.getHandlerIndex(); result = 0; invocation.getContext(Const.SRC_MICROSERVICE); result = "test"; invocation.getOperationMeta(); result = QpsControllerManagerTest.getMockOperationMeta("pojo", "server", "opr"); invocation.getSchemaId(); result = "server"; asyncResp.producerFail((Throwable) any); result = new RuntimeException("test error"); } }; ProviderQpsFlowControlHandler gHandler = new ProviderQpsFlowControlHandler(); gHandler.handle(invocation, asyncResp); ArchaiusUtils.setProperty(Config.PROVIDER_LIMIT_KEY_GLOBAL, 3); expectedException.expect(RuntimeException.class); expectedException.expectMessage("test error"); gHandler.handle(invocation, asyncResp); gHandler.handle(invocation, asyncResp); }
|
@Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { if (invocation.getHandlerIndex() > 0) { invocation.next(asyncResp); return; } if (!Config.INSTANCE.isProviderEnabled()) { return; } String microserviceName = invocation.getContext(Const.SRC_MICROSERVICE); QpsStrategy qpsStrategy = StringUtils.isEmpty(microserviceName) ? qpsControllerMgr.getGlobalQpsStrategy() : qpsControllerMgr.getOrCreate(microserviceName, invocation); isLimitNewRequest(qpsStrategy, asyncResp); }
|
ProviderQpsFlowControlHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { if (invocation.getHandlerIndex() > 0) { invocation.next(asyncResp); return; } if (!Config.INSTANCE.isProviderEnabled()) { return; } String microserviceName = invocation.getContext(Const.SRC_MICROSERVICE); QpsStrategy qpsStrategy = StringUtils.isEmpty(microserviceName) ? qpsControllerMgr.getGlobalQpsStrategy() : qpsControllerMgr.getOrCreate(microserviceName, invocation); isLimitNewRequest(qpsStrategy, asyncResp); } }
|
ProviderQpsFlowControlHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { if (invocation.getHandlerIndex() > 0) { invocation.next(asyncResp); return; } if (!Config.INSTANCE.isProviderEnabled()) { return; } String microserviceName = invocation.getContext(Const.SRC_MICROSERVICE); QpsStrategy qpsStrategy = StringUtils.isEmpty(microserviceName) ? qpsControllerMgr.getGlobalQpsStrategy() : qpsControllerMgr.getOrCreate(microserviceName, invocation); isLimitNewRequest(qpsStrategy, asyncResp); } }
|
ProviderQpsFlowControlHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { if (invocation.getHandlerIndex() > 0) { invocation.next(asyncResp); return; } if (!Config.INSTANCE.isProviderEnabled()) { return; } String microserviceName = invocation.getContext(Const.SRC_MICROSERVICE); QpsStrategy qpsStrategy = StringUtils.isEmpty(microserviceName) ? qpsControllerMgr.getGlobalQpsStrategy() : qpsControllerMgr.getOrCreate(microserviceName, invocation); isLimitNewRequest(qpsStrategy, asyncResp); } @Override void handle(Invocation invocation, AsyncResponse asyncResp); }
|
ProviderQpsFlowControlHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { if (invocation.getHandlerIndex() > 0) { invocation.next(asyncResp); return; } if (!Config.INSTANCE.isProviderEnabled()) { return; } String microserviceName = invocation.getContext(Const.SRC_MICROSERVICE); QpsStrategy qpsStrategy = StringUtils.isEmpty(microserviceName) ? qpsControllerMgr.getGlobalQpsStrategy() : qpsControllerMgr.getOrCreate(microserviceName, invocation); isLimitNewRequest(qpsStrategy, asyncResp); } @Override void handle(Invocation invocation, AsyncResponse asyncResp); }
|
@Test public void testQpsController() { AbstractQpsStrategy qpsStrategy = new FixedWindowStrategy(); qpsStrategy.setKey("abc"); qpsStrategy.setQpsLimit(100L); assertFalse(qpsStrategy.isLimitNewRequest()); qpsStrategy.setQpsLimit(1L); assertTrue(qpsStrategy.isLimitNewRequest()); }
|
private boolean isLimitNewRequest(QpsStrategy qpsStrategy, AsyncResponse asyncResp) { if (qpsStrategy.isLimitNewRequest()) { CommonExceptionData errorData = new CommonExceptionData("rejected by qps flowcontrol"); asyncResp.producerFail(new InvocationException(QpsConst.TOO_MANY_REQUESTS_STATUS, errorData)); return true; } else { return false; } }
|
ProviderQpsFlowControlHandler implements Handler { private boolean isLimitNewRequest(QpsStrategy qpsStrategy, AsyncResponse asyncResp) { if (qpsStrategy.isLimitNewRequest()) { CommonExceptionData errorData = new CommonExceptionData("rejected by qps flowcontrol"); asyncResp.producerFail(new InvocationException(QpsConst.TOO_MANY_REQUESTS_STATUS, errorData)); return true; } else { return false; } } }
|
ProviderQpsFlowControlHandler implements Handler { private boolean isLimitNewRequest(QpsStrategy qpsStrategy, AsyncResponse asyncResp) { if (qpsStrategy.isLimitNewRequest()) { CommonExceptionData errorData = new CommonExceptionData("rejected by qps flowcontrol"); asyncResp.producerFail(new InvocationException(QpsConst.TOO_MANY_REQUESTS_STATUS, errorData)); return true; } else { return false; } } }
|
ProviderQpsFlowControlHandler implements Handler { private boolean isLimitNewRequest(QpsStrategy qpsStrategy, AsyncResponse asyncResp) { if (qpsStrategy.isLimitNewRequest()) { CommonExceptionData errorData = new CommonExceptionData("rejected by qps flowcontrol"); asyncResp.producerFail(new InvocationException(QpsConst.TOO_MANY_REQUESTS_STATUS, errorData)); return true; } else { return false; } } @Override void handle(Invocation invocation, AsyncResponse asyncResp); }
|
ProviderQpsFlowControlHandler implements Handler { private boolean isLimitNewRequest(QpsStrategy qpsStrategy, AsyncResponse asyncResp) { if (qpsStrategy.isLimitNewRequest()) { CommonExceptionData errorData = new CommonExceptionData("rejected by qps flowcontrol"); asyncResp.producerFail(new InvocationException(QpsConst.TOO_MANY_REQUESTS_STATUS, errorData)); return true; } else { return false; } } @Override void handle(Invocation invocation, AsyncResponse asyncResp); }
|
@Test public void testHandleOnSourceMicroserviceNameIsNull() throws Exception { Mockito.when(invocation.getContext(Const.SRC_MICROSERVICE)).thenReturn(null); Mockito.when(invocation.getHandlerIndex()).thenReturn(0); ArchaiusUtils.setProperty("servicecomb.flowcontrol.Provider.qps.global.limit", 1); ProviderQpsFlowControlHandler.qpsControllerMgr .setGlobalQpsStrategy(Config.PROVIDER_LIMIT_KEY_GLOBAL, Config.PROVIDER_BUCKET_KEY_GLOBAL); handler.handle(invocation, asyncResp); handler.handle(invocation, asyncResp); Mockito.verify(invocation, times(2)).getContext(Const.SRC_MICROSERVICE); Mockito.verify(asyncResp, times(1)).producerFail(Mockito.any(Exception.class)); }
|
@Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { if (invocation.getHandlerIndex() > 0) { invocation.next(asyncResp); return; } if (!Config.INSTANCE.isProviderEnabled()) { return; } String microserviceName = invocation.getContext(Const.SRC_MICROSERVICE); QpsStrategy qpsStrategy = StringUtils.isEmpty(microserviceName) ? qpsControllerMgr.getGlobalQpsStrategy() : qpsControllerMgr.getOrCreate(microserviceName, invocation); isLimitNewRequest(qpsStrategy, asyncResp); }
|
ProviderQpsFlowControlHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { if (invocation.getHandlerIndex() > 0) { invocation.next(asyncResp); return; } if (!Config.INSTANCE.isProviderEnabled()) { return; } String microserviceName = invocation.getContext(Const.SRC_MICROSERVICE); QpsStrategy qpsStrategy = StringUtils.isEmpty(microserviceName) ? qpsControllerMgr.getGlobalQpsStrategy() : qpsControllerMgr.getOrCreate(microserviceName, invocation); isLimitNewRequest(qpsStrategy, asyncResp); } }
|
ProviderQpsFlowControlHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { if (invocation.getHandlerIndex() > 0) { invocation.next(asyncResp); return; } if (!Config.INSTANCE.isProviderEnabled()) { return; } String microserviceName = invocation.getContext(Const.SRC_MICROSERVICE); QpsStrategy qpsStrategy = StringUtils.isEmpty(microserviceName) ? qpsControllerMgr.getGlobalQpsStrategy() : qpsControllerMgr.getOrCreate(microserviceName, invocation); isLimitNewRequest(qpsStrategy, asyncResp); } }
|
ProviderQpsFlowControlHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { if (invocation.getHandlerIndex() > 0) { invocation.next(asyncResp); return; } if (!Config.INSTANCE.isProviderEnabled()) { return; } String microserviceName = invocation.getContext(Const.SRC_MICROSERVICE); QpsStrategy qpsStrategy = StringUtils.isEmpty(microserviceName) ? qpsControllerMgr.getGlobalQpsStrategy() : qpsControllerMgr.getOrCreate(microserviceName, invocation); isLimitNewRequest(qpsStrategy, asyncResp); } @Override void handle(Invocation invocation, AsyncResponse asyncResp); }
|
ProviderQpsFlowControlHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { if (invocation.getHandlerIndex() > 0) { invocation.next(asyncResp); return; } if (!Config.INSTANCE.isProviderEnabled()) { return; } String microserviceName = invocation.getContext(Const.SRC_MICROSERVICE); QpsStrategy qpsStrategy = StringUtils.isEmpty(microserviceName) ? qpsControllerMgr.getGlobalQpsStrategy() : qpsControllerMgr.getOrCreate(microserviceName, invocation); isLimitNewRequest(qpsStrategy, asyncResp); } @Override void handle(Invocation invocation, AsyncResponse asyncResp); }
|
@Test public void addOperationPerf() { OperationPerf opPerf = Utils.createOperationPerf(op); group.addOperationPerf(opPerf); group.addOperationPerf(opPerf); Assert.assertThat(group.getOperationPerfs(), Matchers.contains(opPerf, opPerf)); OperationPerf summary = group.getSummary(); PerfInfo perfInfo = summary.findStage(MeterInvocationConst.STAGE_TOTAL); Assert.assertEquals(20, perfInfo.getTps(), 0); Assert.assertEquals(1000, perfInfo.calcMsLatency(), 0); Assert.assertEquals(100000, perfInfo.getMsMaxLatency(), 0); perfInfo = summary.findStage(MeterInvocationConst.STAGE_EXECUTION); Assert.assertEquals(20, perfInfo.getTps(), 0); Assert.assertEquals(1000, perfInfo.calcMsLatency(), 0); Assert.assertEquals(100000, perfInfo.getMsMaxLatency(), 0); }
|
public void addOperationPerf(OperationPerf operationPerf) { operationPerfs.add(operationPerf); if (summary == null) { summary = new OperationPerf(); summary.setOperation(""); } summary.add(operationPerf); }
|
OperationPerfGroup { public void addOperationPerf(OperationPerf operationPerf) { operationPerfs.add(operationPerf); if (summary == null) { summary = new OperationPerf(); summary.setOperation(""); } summary.add(operationPerf); } }
|
OperationPerfGroup { public void addOperationPerf(OperationPerf operationPerf) { operationPerfs.add(operationPerf); if (summary == null) { summary = new OperationPerf(); summary.setOperation(""); } summary.add(operationPerf); } OperationPerfGroup(String transport, String status); }
|
OperationPerfGroup { public void addOperationPerf(OperationPerf operationPerf) { operationPerfs.add(operationPerf); if (summary == null) { summary = new OperationPerf(); summary.setOperation(""); } summary.add(operationPerf); } OperationPerfGroup(String transport, String status); String getTransport(); String getStatus(); List<OperationPerf> getOperationPerfs(); OperationPerf getSummary(); void addOperationPerf(OperationPerf operationPerf); }
|
OperationPerfGroup { public void addOperationPerf(OperationPerf operationPerf) { operationPerfs.add(operationPerf); if (summary == null) { summary = new OperationPerf(); summary.setOperation(""); } summary.add(operationPerf); } OperationPerfGroup(String transport, String status); String getTransport(); String getStatus(); List<OperationPerf> getOperationPerfs(); OperationPerf getSummary(); void addOperationPerf(OperationPerf operationPerf); }
|
@Test public void testHandleOnSourceOnHandlerIndexIsGreaterThan0() throws Exception { Mockito.when(invocation.getContext(Const.SRC_MICROSERVICE)).thenReturn(null); Mockito.when(invocation.getHandlerIndex()).thenReturn(1); handler.handle(invocation, asyncResp); handler.handle(invocation, asyncResp); Mockito.verify(invocation, times(0)).getContext(Mockito.anyString()); }
|
@Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { if (invocation.getHandlerIndex() > 0) { invocation.next(asyncResp); return; } if (!Config.INSTANCE.isProviderEnabled()) { return; } String microserviceName = invocation.getContext(Const.SRC_MICROSERVICE); QpsStrategy qpsStrategy = StringUtils.isEmpty(microserviceName) ? qpsControllerMgr.getGlobalQpsStrategy() : qpsControllerMgr.getOrCreate(microserviceName, invocation); isLimitNewRequest(qpsStrategy, asyncResp); }
|
ProviderQpsFlowControlHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { if (invocation.getHandlerIndex() > 0) { invocation.next(asyncResp); return; } if (!Config.INSTANCE.isProviderEnabled()) { return; } String microserviceName = invocation.getContext(Const.SRC_MICROSERVICE); QpsStrategy qpsStrategy = StringUtils.isEmpty(microserviceName) ? qpsControllerMgr.getGlobalQpsStrategy() : qpsControllerMgr.getOrCreate(microserviceName, invocation); isLimitNewRequest(qpsStrategy, asyncResp); } }
|
ProviderQpsFlowControlHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { if (invocation.getHandlerIndex() > 0) { invocation.next(asyncResp); return; } if (!Config.INSTANCE.isProviderEnabled()) { return; } String microserviceName = invocation.getContext(Const.SRC_MICROSERVICE); QpsStrategy qpsStrategy = StringUtils.isEmpty(microserviceName) ? qpsControllerMgr.getGlobalQpsStrategy() : qpsControllerMgr.getOrCreate(microserviceName, invocation); isLimitNewRequest(qpsStrategy, asyncResp); } }
|
ProviderQpsFlowControlHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { if (invocation.getHandlerIndex() > 0) { invocation.next(asyncResp); return; } if (!Config.INSTANCE.isProviderEnabled()) { return; } String microserviceName = invocation.getContext(Const.SRC_MICROSERVICE); QpsStrategy qpsStrategy = StringUtils.isEmpty(microserviceName) ? qpsControllerMgr.getGlobalQpsStrategy() : qpsControllerMgr.getOrCreate(microserviceName, invocation); isLimitNewRequest(qpsStrategy, asyncResp); } @Override void handle(Invocation invocation, AsyncResponse asyncResp); }
|
ProviderQpsFlowControlHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { if (invocation.getHandlerIndex() > 0) { invocation.next(asyncResp); return; } if (!Config.INSTANCE.isProviderEnabled()) { return; } String microserviceName = invocation.getContext(Const.SRC_MICROSERVICE); QpsStrategy qpsStrategy = StringUtils.isEmpty(microserviceName) ? qpsControllerMgr.getGlobalQpsStrategy() : qpsControllerMgr.getOrCreate(microserviceName, invocation); isLimitNewRequest(qpsStrategy, asyncResp); } @Override void handle(Invocation invocation, AsyncResponse asyncResp); }
|
@Test public void testHandle() throws Exception { Mockito.when(invocation.getContext(Const.SRC_MICROSERVICE)).thenReturn("test"); OperationMeta mockOperationMeta = QpsControllerManagerTest.getMockOperationMeta("pojo", "server", "opr"); Mockito.when(invocation.getOperationMeta()).thenReturn(mockOperationMeta); Mockito.when(invocation.getSchemaId()).thenReturn("server"); new MockUp<QpsControllerManager>() { @Mock protected QpsStrategy create(String qualifiedNameKey) { AbstractQpsStrategy strategy = new FixedWindowStrategy(); strategy.setKey(qualifiedNameKey); strategy.setQpsLimit(1L); return strategy; } }; handler.handle(invocation, asyncResp); handler.handle(invocation, asyncResp); ArgumentCaptor<InvocationException> captor = ArgumentCaptor.forClass(InvocationException.class); Mockito.verify(asyncResp, times(1)).producerFail(captor.capture()); InvocationException invocationException = captor.getValue(); assertEquals(QpsConst.TOO_MANY_REQUESTS_STATUS, invocationException.getStatus()); assertEquals("rejected by qps flowcontrol", ((CommonExceptionData) invocationException.getErrorData()).getMessage()); }
|
@Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { if (invocation.getHandlerIndex() > 0) { invocation.next(asyncResp); return; } if (!Config.INSTANCE.isProviderEnabled()) { return; } String microserviceName = invocation.getContext(Const.SRC_MICROSERVICE); QpsStrategy qpsStrategy = StringUtils.isEmpty(microserviceName) ? qpsControllerMgr.getGlobalQpsStrategy() : qpsControllerMgr.getOrCreate(microserviceName, invocation); isLimitNewRequest(qpsStrategy, asyncResp); }
|
ProviderQpsFlowControlHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { if (invocation.getHandlerIndex() > 0) { invocation.next(asyncResp); return; } if (!Config.INSTANCE.isProviderEnabled()) { return; } String microserviceName = invocation.getContext(Const.SRC_MICROSERVICE); QpsStrategy qpsStrategy = StringUtils.isEmpty(microserviceName) ? qpsControllerMgr.getGlobalQpsStrategy() : qpsControllerMgr.getOrCreate(microserviceName, invocation); isLimitNewRequest(qpsStrategy, asyncResp); } }
|
ProviderQpsFlowControlHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { if (invocation.getHandlerIndex() > 0) { invocation.next(asyncResp); return; } if (!Config.INSTANCE.isProviderEnabled()) { return; } String microserviceName = invocation.getContext(Const.SRC_MICROSERVICE); QpsStrategy qpsStrategy = StringUtils.isEmpty(microserviceName) ? qpsControllerMgr.getGlobalQpsStrategy() : qpsControllerMgr.getOrCreate(microserviceName, invocation); isLimitNewRequest(qpsStrategy, asyncResp); } }
|
ProviderQpsFlowControlHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { if (invocation.getHandlerIndex() > 0) { invocation.next(asyncResp); return; } if (!Config.INSTANCE.isProviderEnabled()) { return; } String microserviceName = invocation.getContext(Const.SRC_MICROSERVICE); QpsStrategy qpsStrategy = StringUtils.isEmpty(microserviceName) ? qpsControllerMgr.getGlobalQpsStrategy() : qpsControllerMgr.getOrCreate(microserviceName, invocation); isLimitNewRequest(qpsStrategy, asyncResp); } @Override void handle(Invocation invocation, AsyncResponse asyncResp); }
|
ProviderQpsFlowControlHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { if (invocation.getHandlerIndex() > 0) { invocation.next(asyncResp); return; } if (!Config.INSTANCE.isProviderEnabled()) { return; } String microserviceName = invocation.getContext(Const.SRC_MICROSERVICE); QpsStrategy qpsStrategy = StringUtils.isEmpty(microserviceName) ? qpsControllerMgr.getGlobalQpsStrategy() : qpsControllerMgr.getOrCreate(microserviceName, invocation); isLimitNewRequest(qpsStrategy, asyncResp); } @Override void handle(Invocation invocation, AsyncResponse asyncResp); }
|
@Test public void testHandleIsLimitNewRequestAsFalse() throws Exception { Mockito.when(invocation.getContext(Const.SRC_MICROSERVICE)).thenReturn("test"); OperationMeta mockOperationMeta = QpsControllerManagerTest .getMockOperationMeta("pojo", "server", "opr"); Mockito.when(invocation.getOperationMeta()).thenReturn(mockOperationMeta); Mockito.when(invocation.getSchemaId()).thenReturn("server"); new MockUp<QpsControllerManager>() { @Mock protected QpsStrategy create(String qualifiedNameKey) { AbstractQpsStrategy strategy = new FixedWindowStrategy(); strategy.setKey(qualifiedNameKey); strategy.setQpsLimit(1L); return strategy; } }; handler.handle(invocation, asyncResp); Mockito.verify(invocation, times(0)).next(asyncResp); Mockito.verify(asyncResp, times(0)).producerFail(Mockito.any(Exception.class)); }
|
@Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { if (invocation.getHandlerIndex() > 0) { invocation.next(asyncResp); return; } if (!Config.INSTANCE.isProviderEnabled()) { return; } String microserviceName = invocation.getContext(Const.SRC_MICROSERVICE); QpsStrategy qpsStrategy = StringUtils.isEmpty(microserviceName) ? qpsControllerMgr.getGlobalQpsStrategy() : qpsControllerMgr.getOrCreate(microserviceName, invocation); isLimitNewRequest(qpsStrategy, asyncResp); }
|
ProviderQpsFlowControlHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { if (invocation.getHandlerIndex() > 0) { invocation.next(asyncResp); return; } if (!Config.INSTANCE.isProviderEnabled()) { return; } String microserviceName = invocation.getContext(Const.SRC_MICROSERVICE); QpsStrategy qpsStrategy = StringUtils.isEmpty(microserviceName) ? qpsControllerMgr.getGlobalQpsStrategy() : qpsControllerMgr.getOrCreate(microserviceName, invocation); isLimitNewRequest(qpsStrategy, asyncResp); } }
|
ProviderQpsFlowControlHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { if (invocation.getHandlerIndex() > 0) { invocation.next(asyncResp); return; } if (!Config.INSTANCE.isProviderEnabled()) { return; } String microserviceName = invocation.getContext(Const.SRC_MICROSERVICE); QpsStrategy qpsStrategy = StringUtils.isEmpty(microserviceName) ? qpsControllerMgr.getGlobalQpsStrategy() : qpsControllerMgr.getOrCreate(microserviceName, invocation); isLimitNewRequest(qpsStrategy, asyncResp); } }
|
ProviderQpsFlowControlHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { if (invocation.getHandlerIndex() > 0) { invocation.next(asyncResp); return; } if (!Config.INSTANCE.isProviderEnabled()) { return; } String microserviceName = invocation.getContext(Const.SRC_MICROSERVICE); QpsStrategy qpsStrategy = StringUtils.isEmpty(microserviceName) ? qpsControllerMgr.getGlobalQpsStrategy() : qpsControllerMgr.getOrCreate(microserviceName, invocation); isLimitNewRequest(qpsStrategy, asyncResp); } @Override void handle(Invocation invocation, AsyncResponse asyncResp); }
|
ProviderQpsFlowControlHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { if (invocation.getHandlerIndex() > 0) { invocation.next(asyncResp); return; } if (!Config.INSTANCE.isProviderEnabled()) { return; } String microserviceName = invocation.getContext(Const.SRC_MICROSERVICE); QpsStrategy qpsStrategy = StringUtils.isEmpty(microserviceName) ? qpsControllerMgr.getGlobalQpsStrategy() : qpsControllerMgr.getOrCreate(microserviceName, invocation); isLimitNewRequest(qpsStrategy, asyncResp); } @Override void handle(Invocation invocation, AsyncResponse asyncResp); }
|
@Test public void testGetOrCreate(@Mocked Invocation invocation, @Mocked OperationMeta operationMeta) { new Expectations() { { invocation.getOperationMeta(); result = operationMeta; invocation.getSchemaId(); result = "server"; operationMeta.getSchemaQualifiedName(); result = "server.test"; } }; QpsControllerManager testQpsControllerManager = new QpsControllerManager() .setLimitKeyPrefix(Config.CONSUMER_LIMIT_KEY_PREFIX); initTestQpsControllerManager(testQpsControllerManager, invocation, operationMeta); setConfigWithDefaultPrefix("pojo", 100); QpsStrategy qpsStrategy = testQpsControllerManager.getOrCreate("pojo", invocation); Assert.assertEquals("pojo", ((AbstractQpsStrategy) qpsStrategy).getKey()); Assert.assertTrue(100 == ((AbstractQpsStrategy) qpsStrategy).getQpsLimit()); qpsStrategy = testQpsControllerManager.getOrCreate("pojo2", invocation); Assert.assertEquals("pojo2", ((AbstractQpsStrategy) qpsStrategy).getKey()); Assert.assertNull(((AbstractQpsStrategy) qpsStrategy).getQpsLimit()); qpsStrategy = testQpsControllerManager.getOrCreate("poj", invocation); Assert.assertEquals("poj", ((AbstractQpsStrategy) qpsStrategy).getKey()); Assert.assertNull(((AbstractQpsStrategy) qpsStrategy).getQpsLimit()); ArchaiusUtils.setProperty("servicecomb.flowcontrol.Consumer.qps.limit.poj.server", 10000); qpsStrategy = testQpsControllerManager.getOrCreate("poj", invocation); Assert.assertEquals("poj.server", ((AbstractQpsStrategy) qpsStrategy).getKey()); Assert.assertEquals(((AbstractQpsStrategy) qpsStrategy).getQpsLimit(), (Long) 10000L); ArchaiusUtils.setProperty("servicecomb.flowcontrol.Consumer.qps.limit.poj.server.test", 20000); qpsStrategy = testQpsControllerManager.getOrCreate("poj", invocation); Assert.assertEquals("poj.server.test", ((AbstractQpsStrategy) qpsStrategy).getKey()); Assert.assertEquals(((AbstractQpsStrategy) qpsStrategy).getQpsLimit(), (Long) 20000L); testGetOrCreateCommon(testQpsControllerManager, invocation, operationMeta); }
|
public QpsStrategy getOrCreate(String microserviceName, Invocation invocation) { return qualifiedNameControllerMap .computeIfAbsent( microserviceName + SEPARATOR + invocation.getOperationMeta().getSchemaQualifiedName(), key -> create(key, microserviceName, invocation)); }
|
QpsControllerManager { public QpsStrategy getOrCreate(String microserviceName, Invocation invocation) { return qualifiedNameControllerMap .computeIfAbsent( microserviceName + SEPARATOR + invocation.getOperationMeta().getSchemaQualifiedName(), key -> create(key, microserviceName, invocation)); } }
|
QpsControllerManager { public QpsStrategy getOrCreate(String microserviceName, Invocation invocation) { return qualifiedNameControllerMap .computeIfAbsent( microserviceName + SEPARATOR + invocation.getOperationMeta().getSchemaQualifiedName(), key -> create(key, microserviceName, invocation)); } }
|
QpsControllerManager { public QpsStrategy getOrCreate(String microserviceName, Invocation invocation) { return qualifiedNameControllerMap .computeIfAbsent( microserviceName + SEPARATOR + invocation.getOperationMeta().getSchemaQualifiedName(), key -> create(key, microserviceName, invocation)); } QpsStrategy getOrCreate(String microserviceName, Invocation invocation); QpsControllerManager setLimitKeyPrefix(String limitKeyPrefix); QpsControllerManager setBucketKeyPrefix(String bucketKeyPrefix); QpsControllerManager setGlobalQpsStrategy(String globalLimitKey, String globalBucketKey); QpsStrategy getGlobalQpsStrategy(); }
|
QpsControllerManager { public QpsStrategy getOrCreate(String microserviceName, Invocation invocation) { return qualifiedNameControllerMap .computeIfAbsent( microserviceName + SEPARATOR + invocation.getOperationMeta().getSchemaQualifiedName(), key -> create(key, microserviceName, invocation)); } QpsStrategy getOrCreate(String microserviceName, Invocation invocation); QpsControllerManager setLimitKeyPrefix(String limitKeyPrefix); QpsControllerManager setBucketKeyPrefix(String bucketKeyPrefix); QpsControllerManager setGlobalQpsStrategy(String globalLimitKey, String globalBucketKey); QpsStrategy getGlobalQpsStrategy(); static final String SEPARATOR; }
|
@Test public void testQualifiedNameKey(@Mocked Invocation invocation, @Mocked OperationMeta operationMeta) { new Expectations() { { invocation.getOperationMeta(); result = operationMeta; invocation.getSchemaId(); result = "schema"; operationMeta.getSchemaQualifiedName(); result = "schema.opr"; } }; QpsControllerManager qpsControllerManager = new QpsControllerManager(); QpsStrategy qpsStrategy = qpsControllerManager.getOrCreate("service", invocation); Assert.assertEquals("service", ((AbstractQpsStrategy) qpsStrategy).getKey()); Assert.assertNull(((AbstractQpsStrategy) qpsStrategy).getQpsLimit()); new Expectations() { { invocation.getOperationMeta(); result = operationMeta; invocation.getSchemaId(); result = "test_schema"; operationMeta.getSchemaQualifiedName(); result = "test_schema.test_opr"; } }; qpsStrategy = qpsControllerManager.getOrCreate("test_service", invocation); Assert.assertEquals("test_service", ((AbstractQpsStrategy) qpsStrategy).getKey()); Assert.assertNull(((AbstractQpsStrategy) qpsStrategy).getQpsLimit()); new Expectations() { { invocation.getOperationMeta(); result = operationMeta; invocation.getSchemaId(); result = "test_schema"; operationMeta.getSchemaQualifiedName(); result = "test-schema.test-opr"; } }; qpsStrategy = qpsControllerManager.getOrCreate("test-service", invocation); Assert.assertEquals("test-service", ((AbstractQpsStrategy) qpsStrategy).getKey()); Assert.assertNull(((AbstractQpsStrategy) qpsStrategy).getQpsLimit()); new Expectations() { { invocation.getOperationMeta(); result = operationMeta; invocation.getSchemaId(); result = "schema"; operationMeta.getSchemaQualifiedName(); result = "schema.opr.tail"; } }; qpsStrategy = qpsControllerManager.getOrCreate("svc", invocation); Assert.assertEquals("svc", ((AbstractQpsStrategy) qpsStrategy).getKey()); Assert.assertNull(((AbstractQpsStrategy) qpsStrategy).getQpsLimit()); new Expectations() { { invocation.getOperationMeta(); result = operationMeta; invocation.getSchemaId(); result = "schema.opr2"; operationMeta.getSchemaQualifiedName(); result = "schema.opr2.tail"; } }; qpsStrategy = qpsControllerManager.getOrCreate("svc", invocation); Assert.assertEquals("svc", ((AbstractQpsStrategy) qpsStrategy).getKey()); Assert.assertNull(((AbstractQpsStrategy) qpsStrategy).getQpsLimit()); }
|
public QpsStrategy getOrCreate(String microserviceName, Invocation invocation) { return qualifiedNameControllerMap .computeIfAbsent( microserviceName + SEPARATOR + invocation.getOperationMeta().getSchemaQualifiedName(), key -> create(key, microserviceName, invocation)); }
|
QpsControllerManager { public QpsStrategy getOrCreate(String microserviceName, Invocation invocation) { return qualifiedNameControllerMap .computeIfAbsent( microserviceName + SEPARATOR + invocation.getOperationMeta().getSchemaQualifiedName(), key -> create(key, microserviceName, invocation)); } }
|
QpsControllerManager { public QpsStrategy getOrCreate(String microserviceName, Invocation invocation) { return qualifiedNameControllerMap .computeIfAbsent( microserviceName + SEPARATOR + invocation.getOperationMeta().getSchemaQualifiedName(), key -> create(key, microserviceName, invocation)); } }
|
QpsControllerManager { public QpsStrategy getOrCreate(String microserviceName, Invocation invocation) { return qualifiedNameControllerMap .computeIfAbsent( microserviceName + SEPARATOR + invocation.getOperationMeta().getSchemaQualifiedName(), key -> create(key, microserviceName, invocation)); } QpsStrategy getOrCreate(String microserviceName, Invocation invocation); QpsControllerManager setLimitKeyPrefix(String limitKeyPrefix); QpsControllerManager setBucketKeyPrefix(String bucketKeyPrefix); QpsControllerManager setGlobalQpsStrategy(String globalLimitKey, String globalBucketKey); QpsStrategy getGlobalQpsStrategy(); }
|
QpsControllerManager { public QpsStrategy getOrCreate(String microserviceName, Invocation invocation) { return qualifiedNameControllerMap .computeIfAbsent( microserviceName + SEPARATOR + invocation.getOperationMeta().getSchemaQualifiedName(), key -> create(key, microserviceName, invocation)); } QpsStrategy getOrCreate(String microserviceName, Invocation invocation); QpsControllerManager setLimitKeyPrefix(String limitKeyPrefix); QpsControllerManager setBucketKeyPrefix(String bucketKeyPrefix); QpsControllerManager setGlobalQpsStrategy(String globalLimitKey, String globalBucketKey); QpsStrategy getGlobalQpsStrategy(); static final String SEPARATOR; }
|
@Test public void testHandle() throws Exception { String key = "svc.schema.opr"; AbstractQpsStrategy qpsStrategy = new FixedWindowStrategy(); qpsStrategy.setKey("key"); qpsStrategy.setQpsLimit(12L); Mockito.when(invocation.getOperationMeta()).thenReturn(operationMeta); Mockito.when(operationMeta.getSchemaQualifiedName()).thenReturn("schema.opr"); Mockito.when(invocation.getSchemaId()).thenReturn("schema"); Mockito.when(invocation.getMicroserviceName()).thenReturn("svc"); setQpsController(key, qpsStrategy); new MockUp<FixedWindowStrategy>() { @Mock public boolean isLimitNewRequest() { return true; } }; new MockUp<QpsControllerManager>() { @Mock protected QpsStrategy create(String qualifiedNameKey) { return qpsStrategy; } }; handler.handle(invocation, asyncResp); ArgumentCaptor<InvocationException> captor = ArgumentCaptor.forClass(InvocationException.class); Mockito.verify(asyncResp).consumerFail(captor.capture()); InvocationException invocationException = captor.getValue(); assertEquals(QpsConst.TOO_MANY_REQUESTS_STATUS, invocationException.getStatus()); assertEquals("rejected by qps flowcontrol", ((CommonExceptionData) invocationException.getErrorData()).getMessage()); }
|
@Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { if (!Config.INSTANCE.isConsumerEnabled()) { invocation.next(asyncResp); return; } QpsStrategy qpsStrategy = qpsControllerMgr.getOrCreate(invocation.getMicroserviceName(), invocation); if (qpsStrategy.isLimitNewRequest()) { CommonExceptionData errorData = new CommonExceptionData("rejected by qps flowcontrol"); asyncResp.consumerFail( new InvocationException(QpsConst.TOO_MANY_REQUESTS_STATUS, errorData)); return; } invocation.next(asyncResp); }
|
ConsumerQpsFlowControlHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { if (!Config.INSTANCE.isConsumerEnabled()) { invocation.next(asyncResp); return; } QpsStrategy qpsStrategy = qpsControllerMgr.getOrCreate(invocation.getMicroserviceName(), invocation); if (qpsStrategy.isLimitNewRequest()) { CommonExceptionData errorData = new CommonExceptionData("rejected by qps flowcontrol"); asyncResp.consumerFail( new InvocationException(QpsConst.TOO_MANY_REQUESTS_STATUS, errorData)); return; } invocation.next(asyncResp); } }
|
ConsumerQpsFlowControlHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { if (!Config.INSTANCE.isConsumerEnabled()) { invocation.next(asyncResp); return; } QpsStrategy qpsStrategy = qpsControllerMgr.getOrCreate(invocation.getMicroserviceName(), invocation); if (qpsStrategy.isLimitNewRequest()) { CommonExceptionData errorData = new CommonExceptionData("rejected by qps flowcontrol"); asyncResp.consumerFail( new InvocationException(QpsConst.TOO_MANY_REQUESTS_STATUS, errorData)); return; } invocation.next(asyncResp); } }
|
ConsumerQpsFlowControlHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { if (!Config.INSTANCE.isConsumerEnabled()) { invocation.next(asyncResp); return; } QpsStrategy qpsStrategy = qpsControllerMgr.getOrCreate(invocation.getMicroserviceName(), invocation); if (qpsStrategy.isLimitNewRequest()) { CommonExceptionData errorData = new CommonExceptionData("rejected by qps flowcontrol"); asyncResp.consumerFail( new InvocationException(QpsConst.TOO_MANY_REQUESTS_STATUS, errorData)); return; } invocation.next(asyncResp); } @Override void handle(Invocation invocation, AsyncResponse asyncResp); }
|
ConsumerQpsFlowControlHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { if (!Config.INSTANCE.isConsumerEnabled()) { invocation.next(asyncResp); return; } QpsStrategy qpsStrategy = qpsControllerMgr.getOrCreate(invocation.getMicroserviceName(), invocation); if (qpsStrategy.isLimitNewRequest()) { CommonExceptionData errorData = new CommonExceptionData("rejected by qps flowcontrol"); asyncResp.consumerFail( new InvocationException(QpsConst.TOO_MANY_REQUESTS_STATUS, errorData)); return; } invocation.next(asyncResp); } @Override void handle(Invocation invocation, AsyncResponse asyncResp); }
|
@Test public void testHandleIsLimitNewRequestAsFalse() throws Exception { String key = "service.schema.id"; AbstractQpsStrategy qpsStrategy = new FixedWindowStrategy(); qpsStrategy.setKey("service"); qpsStrategy.setQpsLimit(12L); Mockito.when(invocation.getMicroserviceName()).thenReturn("service"); Mockito.when(invocation.getOperationMeta()).thenReturn(operationMeta); Mockito.when(operationMeta.getSchemaQualifiedName()).thenReturn("schema.id"); setQpsController(key, qpsStrategy); new MockUp<QpsStrategy>() { @Mock public boolean isLimitNewRequest() { return false; } }; new MockUp<QpsControllerManager>() { @Mock protected QpsStrategy create(String qualifiedNameKey) { return qpsStrategy; } }; handler.handle(invocation, asyncResp); Mockito.verify(invocation).next(asyncResp); }
|
@Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { if (!Config.INSTANCE.isConsumerEnabled()) { invocation.next(asyncResp); return; } QpsStrategy qpsStrategy = qpsControllerMgr.getOrCreate(invocation.getMicroserviceName(), invocation); if (qpsStrategy.isLimitNewRequest()) { CommonExceptionData errorData = new CommonExceptionData("rejected by qps flowcontrol"); asyncResp.consumerFail( new InvocationException(QpsConst.TOO_MANY_REQUESTS_STATUS, errorData)); return; } invocation.next(asyncResp); }
|
ConsumerQpsFlowControlHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { if (!Config.INSTANCE.isConsumerEnabled()) { invocation.next(asyncResp); return; } QpsStrategy qpsStrategy = qpsControllerMgr.getOrCreate(invocation.getMicroserviceName(), invocation); if (qpsStrategy.isLimitNewRequest()) { CommonExceptionData errorData = new CommonExceptionData("rejected by qps flowcontrol"); asyncResp.consumerFail( new InvocationException(QpsConst.TOO_MANY_REQUESTS_STATUS, errorData)); return; } invocation.next(asyncResp); } }
|
ConsumerQpsFlowControlHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { if (!Config.INSTANCE.isConsumerEnabled()) { invocation.next(asyncResp); return; } QpsStrategy qpsStrategy = qpsControllerMgr.getOrCreate(invocation.getMicroserviceName(), invocation); if (qpsStrategy.isLimitNewRequest()) { CommonExceptionData errorData = new CommonExceptionData("rejected by qps flowcontrol"); asyncResp.consumerFail( new InvocationException(QpsConst.TOO_MANY_REQUESTS_STATUS, errorData)); return; } invocation.next(asyncResp); } }
|
ConsumerQpsFlowControlHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { if (!Config.INSTANCE.isConsumerEnabled()) { invocation.next(asyncResp); return; } QpsStrategy qpsStrategy = qpsControllerMgr.getOrCreate(invocation.getMicroserviceName(), invocation); if (qpsStrategy.isLimitNewRequest()) { CommonExceptionData errorData = new CommonExceptionData("rejected by qps flowcontrol"); asyncResp.consumerFail( new InvocationException(QpsConst.TOO_MANY_REQUESTS_STATUS, errorData)); return; } invocation.next(asyncResp); } @Override void handle(Invocation invocation, AsyncResponse asyncResp); }
|
ConsumerQpsFlowControlHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { if (!Config.INSTANCE.isConsumerEnabled()) { invocation.next(asyncResp); return; } QpsStrategy qpsStrategy = qpsControllerMgr.getOrCreate(invocation.getMicroserviceName(), invocation); if (qpsStrategy.isLimitNewRequest()) { CommonExceptionData errorData = new CommonExceptionData("rejected by qps flowcontrol"); asyncResp.consumerFail( new InvocationException(QpsConst.TOO_MANY_REQUESTS_STATUS, errorData)); return; } invocation.next(asyncResp); } @Override void handle(Invocation invocation, AsyncResponse asyncResp); }
|
@Test public void injectFaultVertxDelay() throws InterruptedException { ArchaiusUtils .setProperty("servicecomb.governance.Consumer._global.policy.fault.protocols.rest.delay.fixedDelay", "10"); ArchaiusUtils .setProperty("servicecomb.governance.Consumer._global.policy.fault.protocols.rest.delay.percent", "100"); assertEquals("10", DynamicProperty .getInstance("servicecomb.governance.Consumer._global.policy.fault.protocols.rest.delay.fixedDelay") .getString()); assertEquals("100", DynamicProperty .getInstance("servicecomb.governance.Consumer._global.policy.fault.protocols.rest.delay.percent") .getString()); DelayFault delayFault = new DelayFault(); FaultParam faultParam = new FaultParam(1); Vertx vertx = VertxUtils.getOrCreateVertxByName("faultinjectionTest", null); faultParam.setVertx(vertx); Holder<String> resultHolder = new Holder<>(); CountDownLatch latch = new CountDownLatch(1); delayFault.injectFault(invocation, faultParam, response -> { resultHolder.value = response.getResult(); latch.countDown(); }); latch.await(10, TimeUnit.SECONDS); AtomicLong count = FaultInjectionUtil.getOperMetTotalReq("restMicroserviceQualifiedName12"); assertEquals(1, count.get()); assertEquals("success", resultHolder.value); }
|
@Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asynResponse) { if (!shouldDelay(invocation, faultParam, asynResponse)) { asynResponse.success(SUCCESS_RESPONSE); return; } LOGGER.debug("Fault injection: delay is added for the request by fault inject handler"); long delay = FaultInjectionUtil.getFaultInjectionConfig(invocation, "delay.fixedDelay"); if (delay == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: delay is not configured"); asynResponse.success(SUCCESS_RESPONSE); return; } executeDelay(faultParam, asynResponse, delay); }
|
DelayFault extends AbstractFault { @Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asynResponse) { if (!shouldDelay(invocation, faultParam, asynResponse)) { asynResponse.success(SUCCESS_RESPONSE); return; } LOGGER.debug("Fault injection: delay is added for the request by fault inject handler"); long delay = FaultInjectionUtil.getFaultInjectionConfig(invocation, "delay.fixedDelay"); if (delay == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: delay is not configured"); asynResponse.success(SUCCESS_RESPONSE); return; } executeDelay(faultParam, asynResponse, delay); } }
|
DelayFault extends AbstractFault { @Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asynResponse) { if (!shouldDelay(invocation, faultParam, asynResponse)) { asynResponse.success(SUCCESS_RESPONSE); return; } LOGGER.debug("Fault injection: delay is added for the request by fault inject handler"); long delay = FaultInjectionUtil.getFaultInjectionConfig(invocation, "delay.fixedDelay"); if (delay == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: delay is not configured"); asynResponse.success(SUCCESS_RESPONSE); return; } executeDelay(faultParam, asynResponse, delay); } }
|
DelayFault extends AbstractFault { @Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asynResponse) { if (!shouldDelay(invocation, faultParam, asynResponse)) { asynResponse.success(SUCCESS_RESPONSE); return; } LOGGER.debug("Fault injection: delay is added for the request by fault inject handler"); long delay = FaultInjectionUtil.getFaultInjectionConfig(invocation, "delay.fixedDelay"); if (delay == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: delay is not configured"); asynResponse.success(SUCCESS_RESPONSE); return; } executeDelay(faultParam, asynResponse, delay); } @Override int getOrder(); @Override void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asynResponse); }
|
DelayFault extends AbstractFault { @Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asynResponse) { if (!shouldDelay(invocation, faultParam, asynResponse)) { asynResponse.success(SUCCESS_RESPONSE); return; } LOGGER.debug("Fault injection: delay is added for the request by fault inject handler"); long delay = FaultInjectionUtil.getFaultInjectionConfig(invocation, "delay.fixedDelay"); if (delay == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: delay is not configured"); asynResponse.success(SUCCESS_RESPONSE); return; } executeDelay(faultParam, asynResponse, delay); } @Override int getOrder(); @Override void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asynResponse); }
|
@Test public void injectFaultSystemDelay() throws InterruptedException { ArchaiusUtils .setProperty("servicecomb.governance.Consumer._global.policy.fault.protocols.rest.delay.fixedDelay", "10"); ArchaiusUtils .setProperty("servicecomb.governance.Consumer._global.policy.fault.protocols.rest.delay.percent", "100"); assertEquals("10", DynamicProperty .getInstance("servicecomb.governance.Consumer._global.policy.fault.protocols.rest.delay.fixedDelay") .getString()); assertEquals("100", DynamicProperty .getInstance("servicecomb.governance.Consumer._global.policy.fault.protocols.rest.delay.percent") .getString()); DelayFault delayFault = new DelayFault(); FaultParam faultParam = new FaultParam(1); Holder<String> resultHolder = new Holder<>(); CountDownLatch latch = new CountDownLatch(1); delayFault.injectFault(invocation, faultParam, response -> { resultHolder.value = response.getResult(); latch.countDown(); }); latch.await(10, TimeUnit.SECONDS); AtomicLong count = FaultInjectionUtil.getOperMetTotalReq("restMicroserviceQualifiedName12"); assertEquals(1, count.get()); assertEquals("success", resultHolder.value); }
|
@Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asynResponse) { if (!shouldDelay(invocation, faultParam, asynResponse)) { asynResponse.success(SUCCESS_RESPONSE); return; } LOGGER.debug("Fault injection: delay is added for the request by fault inject handler"); long delay = FaultInjectionUtil.getFaultInjectionConfig(invocation, "delay.fixedDelay"); if (delay == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: delay is not configured"); asynResponse.success(SUCCESS_RESPONSE); return; } executeDelay(faultParam, asynResponse, delay); }
|
DelayFault extends AbstractFault { @Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asynResponse) { if (!shouldDelay(invocation, faultParam, asynResponse)) { asynResponse.success(SUCCESS_RESPONSE); return; } LOGGER.debug("Fault injection: delay is added for the request by fault inject handler"); long delay = FaultInjectionUtil.getFaultInjectionConfig(invocation, "delay.fixedDelay"); if (delay == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: delay is not configured"); asynResponse.success(SUCCESS_RESPONSE); return; } executeDelay(faultParam, asynResponse, delay); } }
|
DelayFault extends AbstractFault { @Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asynResponse) { if (!shouldDelay(invocation, faultParam, asynResponse)) { asynResponse.success(SUCCESS_RESPONSE); return; } LOGGER.debug("Fault injection: delay is added for the request by fault inject handler"); long delay = FaultInjectionUtil.getFaultInjectionConfig(invocation, "delay.fixedDelay"); if (delay == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: delay is not configured"); asynResponse.success(SUCCESS_RESPONSE); return; } executeDelay(faultParam, asynResponse, delay); } }
|
DelayFault extends AbstractFault { @Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asynResponse) { if (!shouldDelay(invocation, faultParam, asynResponse)) { asynResponse.success(SUCCESS_RESPONSE); return; } LOGGER.debug("Fault injection: delay is added for the request by fault inject handler"); long delay = FaultInjectionUtil.getFaultInjectionConfig(invocation, "delay.fixedDelay"); if (delay == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: delay is not configured"); asynResponse.success(SUCCESS_RESPONSE); return; } executeDelay(faultParam, asynResponse, delay); } @Override int getOrder(); @Override void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asynResponse); }
|
DelayFault extends AbstractFault { @Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asynResponse) { if (!shouldDelay(invocation, faultParam, asynResponse)) { asynResponse.success(SUCCESS_RESPONSE); return; } LOGGER.debug("Fault injection: delay is added for the request by fault inject handler"); long delay = FaultInjectionUtil.getFaultInjectionConfig(invocation, "delay.fixedDelay"); if (delay == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: delay is not configured"); asynResponse.success(SUCCESS_RESPONSE); return; } executeDelay(faultParam, asynResponse, delay); } @Override int getOrder(); @Override void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asynResponse); }
|
@Test public void injectFaultNotDelay() throws InterruptedException { ArchaiusUtils .setProperty("servicecomb.governance.Consumer._global.policy.fault.protocols.rest.delay.fixedDelay", "10"); ArchaiusUtils.setProperty("servicecomb.governance.Consumer._global.policy.fault.protocols.rest.delay.percent", "0"); assertEquals("10", DynamicProperty .getInstance("servicecomb.governance.Consumer._global.policy.fault.protocols.rest.delay.fixedDelay") .getString()); assertEquals("0", DynamicProperty .getInstance("servicecomb.governance.Consumer._global.policy.fault.protocols.rest.delay.percent") .getString()); DelayFault delayFault = new DelayFault(); FaultParam faultParam = new FaultParam(1); Vertx vertx = VertxUtils.getOrCreateVertxByName("faultinjectionTest", null); faultParam.setVertx(vertx); Holder<String> resultHolder = new Holder<>(); CountDownLatch latch = new CountDownLatch(1); delayFault.injectFault(invocation, faultParam, response -> { resultHolder.value = response.getResult(); latch.countDown(); }); latch.await(3, TimeUnit.SECONDS); AtomicLong count = FaultInjectionUtil.getOperMetTotalReq("restMicroserviceQualifiedName12"); assertEquals(1, count.get()); assertEquals("success", resultHolder.value); }
|
@Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asynResponse) { if (!shouldDelay(invocation, faultParam, asynResponse)) { asynResponse.success(SUCCESS_RESPONSE); return; } LOGGER.debug("Fault injection: delay is added for the request by fault inject handler"); long delay = FaultInjectionUtil.getFaultInjectionConfig(invocation, "delay.fixedDelay"); if (delay == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: delay is not configured"); asynResponse.success(SUCCESS_RESPONSE); return; } executeDelay(faultParam, asynResponse, delay); }
|
DelayFault extends AbstractFault { @Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asynResponse) { if (!shouldDelay(invocation, faultParam, asynResponse)) { asynResponse.success(SUCCESS_RESPONSE); return; } LOGGER.debug("Fault injection: delay is added for the request by fault inject handler"); long delay = FaultInjectionUtil.getFaultInjectionConfig(invocation, "delay.fixedDelay"); if (delay == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: delay is not configured"); asynResponse.success(SUCCESS_RESPONSE); return; } executeDelay(faultParam, asynResponse, delay); } }
|
DelayFault extends AbstractFault { @Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asynResponse) { if (!shouldDelay(invocation, faultParam, asynResponse)) { asynResponse.success(SUCCESS_RESPONSE); return; } LOGGER.debug("Fault injection: delay is added for the request by fault inject handler"); long delay = FaultInjectionUtil.getFaultInjectionConfig(invocation, "delay.fixedDelay"); if (delay == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: delay is not configured"); asynResponse.success(SUCCESS_RESPONSE); return; } executeDelay(faultParam, asynResponse, delay); } }
|
DelayFault extends AbstractFault { @Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asynResponse) { if (!shouldDelay(invocation, faultParam, asynResponse)) { asynResponse.success(SUCCESS_RESPONSE); return; } LOGGER.debug("Fault injection: delay is added for the request by fault inject handler"); long delay = FaultInjectionUtil.getFaultInjectionConfig(invocation, "delay.fixedDelay"); if (delay == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: delay is not configured"); asynResponse.success(SUCCESS_RESPONSE); return; } executeDelay(faultParam, asynResponse, delay); } @Override int getOrder(); @Override void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asynResponse); }
|
DelayFault extends AbstractFault { @Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asynResponse) { if (!shouldDelay(invocation, faultParam, asynResponse)) { asynResponse.success(SUCCESS_RESPONSE); return; } LOGGER.debug("Fault injection: delay is added for the request by fault inject handler"); long delay = FaultInjectionUtil.getFaultInjectionConfig(invocation, "delay.fixedDelay"); if (delay == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: delay is not configured"); asynResponse.success(SUCCESS_RESPONSE); return; } executeDelay(faultParam, asynResponse, delay); } @Override int getOrder(); @Override void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asynResponse); }
|
@Test public void testToString() { PerfInfo perf = new PerfInfo(); perf.setTps(10); perf.setMsTotalTime(10); perf.setMsMaxLatency(100); Assert.assertEquals("PerfInfo [tps=10.0, msTotalTime=10.0, msLatency=1.0, msMaxLatency=100.0]", perf.toString()); }
|
@Override public String toString() { return "PerfInfo [tps=" + tps + ", msTotalTime=" + msTotalTime + ", msLatency=" + calcMsLatency() + ", msMaxLatency=" + msMaxLatency + "]"; }
|
PerfInfo { @Override public String toString() { return "PerfInfo [tps=" + tps + ", msTotalTime=" + msTotalTime + ", msLatency=" + calcMsLatency() + ", msMaxLatency=" + msMaxLatency + "]"; } }
|
PerfInfo { @Override public String toString() { return "PerfInfo [tps=" + tps + ", msTotalTime=" + msTotalTime + ", msLatency=" + calcMsLatency() + ", msMaxLatency=" + msMaxLatency + "]"; } }
|
PerfInfo { @Override public String toString() { return "PerfInfo [tps=" + tps + ", msTotalTime=" + msTotalTime + ", msLatency=" + calcMsLatency() + ", msMaxLatency=" + msMaxLatency + "]"; } double getTps(); void setTps(double tps); double getMsTotalTime(); void setMsTotalTime(double msTotalTime); double getMsMaxLatency(); void setMsMaxLatency(double msMaxLatency); void add(PerfInfo other); double calcMsLatency(); @Override String toString(); }
|
PerfInfo { @Override public String toString() { return "PerfInfo [tps=" + tps + ", msTotalTime=" + msTotalTime + ", msLatency=" + calcMsLatency() + ", msMaxLatency=" + msMaxLatency + "]"; } double getTps(); void setTps(double tps); double getMsTotalTime(); void setMsTotalTime(double msTotalTime); double getMsMaxLatency(); void setMsMaxLatency(double msMaxLatency); void add(PerfInfo other); double calcMsLatency(); @Override String toString(); }
|
@Test public void injectFaultNoPercentageConfig() { ArchaiusUtils .setProperty("servicecomb.governance.Consumer._global.policy.fault.protocols.rest.delay.percent", null); assertNull(DynamicProperty .getInstance("servicecomb.governance.Consumer._global.policy.fault.protocols.rest.delay.percent") .getString()); DelayFault delayFault = new DelayFault(); FaultParam faultParam = new FaultParam(1); Vertx vertx = VertxUtils.getOrCreateVertxByName("faultinjectionTest", null); faultParam.setVertx(vertx); Holder<String> resultHolder = new Holder<>(); delayFault.injectFault(invocation, faultParam, response -> resultHolder.value = response.getResult()); AtomicLong count = FaultInjectionUtil.getOperMetTotalReq("restMicroserviceQualifiedName12"); assertEquals(1, count.get()); assertEquals("success", resultHolder.value); }
|
@Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asynResponse) { if (!shouldDelay(invocation, faultParam, asynResponse)) { asynResponse.success(SUCCESS_RESPONSE); return; } LOGGER.debug("Fault injection: delay is added for the request by fault inject handler"); long delay = FaultInjectionUtil.getFaultInjectionConfig(invocation, "delay.fixedDelay"); if (delay == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: delay is not configured"); asynResponse.success(SUCCESS_RESPONSE); return; } executeDelay(faultParam, asynResponse, delay); }
|
DelayFault extends AbstractFault { @Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asynResponse) { if (!shouldDelay(invocation, faultParam, asynResponse)) { asynResponse.success(SUCCESS_RESPONSE); return; } LOGGER.debug("Fault injection: delay is added for the request by fault inject handler"); long delay = FaultInjectionUtil.getFaultInjectionConfig(invocation, "delay.fixedDelay"); if (delay == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: delay is not configured"); asynResponse.success(SUCCESS_RESPONSE); return; } executeDelay(faultParam, asynResponse, delay); } }
|
DelayFault extends AbstractFault { @Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asynResponse) { if (!shouldDelay(invocation, faultParam, asynResponse)) { asynResponse.success(SUCCESS_RESPONSE); return; } LOGGER.debug("Fault injection: delay is added for the request by fault inject handler"); long delay = FaultInjectionUtil.getFaultInjectionConfig(invocation, "delay.fixedDelay"); if (delay == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: delay is not configured"); asynResponse.success(SUCCESS_RESPONSE); return; } executeDelay(faultParam, asynResponse, delay); } }
|
DelayFault extends AbstractFault { @Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asynResponse) { if (!shouldDelay(invocation, faultParam, asynResponse)) { asynResponse.success(SUCCESS_RESPONSE); return; } LOGGER.debug("Fault injection: delay is added for the request by fault inject handler"); long delay = FaultInjectionUtil.getFaultInjectionConfig(invocation, "delay.fixedDelay"); if (delay == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: delay is not configured"); asynResponse.success(SUCCESS_RESPONSE); return; } executeDelay(faultParam, asynResponse, delay); } @Override int getOrder(); @Override void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asynResponse); }
|
DelayFault extends AbstractFault { @Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asynResponse) { if (!shouldDelay(invocation, faultParam, asynResponse)) { asynResponse.success(SUCCESS_RESPONSE); return; } LOGGER.debug("Fault injection: delay is added for the request by fault inject handler"); long delay = FaultInjectionUtil.getFaultInjectionConfig(invocation, "delay.fixedDelay"); if (delay == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: delay is not configured"); asynResponse.success(SUCCESS_RESPONSE); return; } executeDelay(faultParam, asynResponse, delay); } @Override int getOrder(); @Override void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asynResponse); }
|
@Test public void injectFaultNoDelayMsConfig() { ArchaiusUtils .setProperty("servicecomb.governance.Consumer._global.policy.fault.protocols.rest.delay.percent", "10"); assertEquals("10", DynamicProperty .getInstance("servicecomb.governance.Consumer._global.policy.fault.protocols.rest.delay.percent") .getString()); DelayFault delayFault = new DelayFault(); FaultParam faultParam = new FaultParam(10); Vertx vertx = VertxUtils.getOrCreateVertxByName("faultinjectionTest", null); faultParam.setVertx(vertx); Holder<String> resultHolder = new Holder<>(); delayFault.injectFault(invocation, faultParam, response -> resultHolder.value = response.getResult()); AtomicLong count = FaultInjectionUtil.getOperMetTotalReq("restMicroserviceQualifiedName12"); assertEquals(1, count.get()); assertEquals("success", resultHolder.value); }
|
@Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asynResponse) { if (!shouldDelay(invocation, faultParam, asynResponse)) { asynResponse.success(SUCCESS_RESPONSE); return; } LOGGER.debug("Fault injection: delay is added for the request by fault inject handler"); long delay = FaultInjectionUtil.getFaultInjectionConfig(invocation, "delay.fixedDelay"); if (delay == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: delay is not configured"); asynResponse.success(SUCCESS_RESPONSE); return; } executeDelay(faultParam, asynResponse, delay); }
|
DelayFault extends AbstractFault { @Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asynResponse) { if (!shouldDelay(invocation, faultParam, asynResponse)) { asynResponse.success(SUCCESS_RESPONSE); return; } LOGGER.debug("Fault injection: delay is added for the request by fault inject handler"); long delay = FaultInjectionUtil.getFaultInjectionConfig(invocation, "delay.fixedDelay"); if (delay == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: delay is not configured"); asynResponse.success(SUCCESS_RESPONSE); return; } executeDelay(faultParam, asynResponse, delay); } }
|
DelayFault extends AbstractFault { @Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asynResponse) { if (!shouldDelay(invocation, faultParam, asynResponse)) { asynResponse.success(SUCCESS_RESPONSE); return; } LOGGER.debug("Fault injection: delay is added for the request by fault inject handler"); long delay = FaultInjectionUtil.getFaultInjectionConfig(invocation, "delay.fixedDelay"); if (delay == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: delay is not configured"); asynResponse.success(SUCCESS_RESPONSE); return; } executeDelay(faultParam, asynResponse, delay); } }
|
DelayFault extends AbstractFault { @Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asynResponse) { if (!shouldDelay(invocation, faultParam, asynResponse)) { asynResponse.success(SUCCESS_RESPONSE); return; } LOGGER.debug("Fault injection: delay is added for the request by fault inject handler"); long delay = FaultInjectionUtil.getFaultInjectionConfig(invocation, "delay.fixedDelay"); if (delay == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: delay is not configured"); asynResponse.success(SUCCESS_RESPONSE); return; } executeDelay(faultParam, asynResponse, delay); } @Override int getOrder(); @Override void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asynResponse); }
|
DelayFault extends AbstractFault { @Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asynResponse) { if (!shouldDelay(invocation, faultParam, asynResponse)) { asynResponse.success(SUCCESS_RESPONSE); return; } LOGGER.debug("Fault injection: delay is added for the request by fault inject handler"); long delay = FaultInjectionUtil.getFaultInjectionConfig(invocation, "delay.fixedDelay"); if (delay == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: delay is not configured"); asynResponse.success(SUCCESS_RESPONSE); return; } executeDelay(faultParam, asynResponse, delay); } @Override int getOrder(); @Override void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asynResponse); }
|
@Test public void injectFaultError() { ArchaiusUtils .setProperty("servicecomb.governance.Consumer._global.policy.fault.protocols.rest.abort.httpStatus", "421"); ArchaiusUtils .setProperty("servicecomb.governance.Consumer._global.policy.fault.protocols.rest.abort.percent", "100"); assertEquals("421", DynamicProperty .getInstance("servicecomb.governance.Consumer._global.policy.fault.protocols.rest.abort.httpStatus") .getString()); assertEquals("100", DynamicProperty .getInstance("servicecomb.governance.Consumer._global.policy.fault.protocols.rest.abort.percent") .getString()); AbortFault abortFault = new AbortFault(); FaultParam faultParam = new FaultParam(1); Vertx vertx = VertxUtils.getOrCreateVertxByName("faultinjectionTest", null); faultParam.setVertx(vertx); Holder<InvocationException> resultHolder = new Holder<>(); abortFault.injectFault(invocation, faultParam, response -> resultHolder.value = response.getResult()); AtomicLong count = FaultInjectionUtil.getOperMetTotalReq("restMicroserviceQualifiedName12"); assertEquals(1, count.get()); assertEquals(421, resultHolder.value.getStatusCode()); assertEquals("aborted by fault inject", resultHolder.value.getReasonPhrase()); assertEquals("CommonExceptionData [message=aborted by fault inject]", resultHolder.value.getErrorData().toString()); }
|
@Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asyncResponse) { if (!shouldAbort(invocation, faultParam)) { asyncResponse.success(SUCCESS_RESPONSE); return; } int errorCode = FaultInjectionUtil.getFaultInjectionConfig(invocation, "abort.httpStatus"); if (errorCode == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: Abort error code is not configured"); asyncResponse.success(SUCCESS_RESPONSE); return; } CommonExceptionData errorData = new CommonExceptionData(ABORTED_ERROR_MSG); asyncResponse.consumerFail(new InvocationException(errorCode, ABORTED_ERROR_MSG, errorData)); }
|
AbortFault extends AbstractFault { @Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asyncResponse) { if (!shouldAbort(invocation, faultParam)) { asyncResponse.success(SUCCESS_RESPONSE); return; } int errorCode = FaultInjectionUtil.getFaultInjectionConfig(invocation, "abort.httpStatus"); if (errorCode == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: Abort error code is not configured"); asyncResponse.success(SUCCESS_RESPONSE); return; } CommonExceptionData errorData = new CommonExceptionData(ABORTED_ERROR_MSG); asyncResponse.consumerFail(new InvocationException(errorCode, ABORTED_ERROR_MSG, errorData)); } }
|
AbortFault extends AbstractFault { @Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asyncResponse) { if (!shouldAbort(invocation, faultParam)) { asyncResponse.success(SUCCESS_RESPONSE); return; } int errorCode = FaultInjectionUtil.getFaultInjectionConfig(invocation, "abort.httpStatus"); if (errorCode == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: Abort error code is not configured"); asyncResponse.success(SUCCESS_RESPONSE); return; } CommonExceptionData errorData = new CommonExceptionData(ABORTED_ERROR_MSG); asyncResponse.consumerFail(new InvocationException(errorCode, ABORTED_ERROR_MSG, errorData)); } }
|
AbortFault extends AbstractFault { @Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asyncResponse) { if (!shouldAbort(invocation, faultParam)) { asyncResponse.success(SUCCESS_RESPONSE); return; } int errorCode = FaultInjectionUtil.getFaultInjectionConfig(invocation, "abort.httpStatus"); if (errorCode == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: Abort error code is not configured"); asyncResponse.success(SUCCESS_RESPONSE); return; } CommonExceptionData errorData = new CommonExceptionData(ABORTED_ERROR_MSG); asyncResponse.consumerFail(new InvocationException(errorCode, ABORTED_ERROR_MSG, errorData)); } @Override void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asyncResponse); @Override int getOrder(); }
|
AbortFault extends AbstractFault { @Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asyncResponse) { if (!shouldAbort(invocation, faultParam)) { asyncResponse.success(SUCCESS_RESPONSE); return; } int errorCode = FaultInjectionUtil.getFaultInjectionConfig(invocation, "abort.httpStatus"); if (errorCode == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: Abort error code is not configured"); asyncResponse.success(SUCCESS_RESPONSE); return; } CommonExceptionData errorData = new CommonExceptionData(ABORTED_ERROR_MSG); asyncResponse.consumerFail(new InvocationException(errorCode, ABORTED_ERROR_MSG, errorData)); } @Override void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asyncResponse); @Override int getOrder(); static final String ABORTED_ERROR_MSG; }
|
@Test public void injectFaultNoError() { ArchaiusUtils .setProperty("servicecomb.governance.Consumer._global.policy.fault.protocols.rest.abort.httpStatus", "421"); ArchaiusUtils.setProperty("servicecomb.governance.Consumer._global.policy.fault.protocols.rest.abort.percent", "0"); assertEquals("421", DynamicProperty .getInstance("servicecomb.governance.Consumer._global.policy.fault.protocols.rest.abort.httpStatus") .getString()); assertEquals("0", DynamicProperty .getInstance("servicecomb.governance.Consumer._global.policy.fault.protocols.rest.abort.percent") .getString()); AbortFault abortFault = new AbortFault(); FaultParam faultParam = new FaultParam(1); Vertx vertx = VertxUtils.getOrCreateVertxByName("faultinjectionTest", null); faultParam.setVertx(vertx); Holder<String> resultHolder = new Holder<>(); abortFault.injectFault(invocation, faultParam, response -> resultHolder.value = response.getResult()); AtomicLong count = FaultInjectionUtil.getOperMetTotalReq("restMicroserviceQualifiedName12"); assertEquals(1, count.get()); assertEquals("success", resultHolder.value); }
|
@Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asyncResponse) { if (!shouldAbort(invocation, faultParam)) { asyncResponse.success(SUCCESS_RESPONSE); return; } int errorCode = FaultInjectionUtil.getFaultInjectionConfig(invocation, "abort.httpStatus"); if (errorCode == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: Abort error code is not configured"); asyncResponse.success(SUCCESS_RESPONSE); return; } CommonExceptionData errorData = new CommonExceptionData(ABORTED_ERROR_MSG); asyncResponse.consumerFail(new InvocationException(errorCode, ABORTED_ERROR_MSG, errorData)); }
|
AbortFault extends AbstractFault { @Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asyncResponse) { if (!shouldAbort(invocation, faultParam)) { asyncResponse.success(SUCCESS_RESPONSE); return; } int errorCode = FaultInjectionUtil.getFaultInjectionConfig(invocation, "abort.httpStatus"); if (errorCode == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: Abort error code is not configured"); asyncResponse.success(SUCCESS_RESPONSE); return; } CommonExceptionData errorData = new CommonExceptionData(ABORTED_ERROR_MSG); asyncResponse.consumerFail(new InvocationException(errorCode, ABORTED_ERROR_MSG, errorData)); } }
|
AbortFault extends AbstractFault { @Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asyncResponse) { if (!shouldAbort(invocation, faultParam)) { asyncResponse.success(SUCCESS_RESPONSE); return; } int errorCode = FaultInjectionUtil.getFaultInjectionConfig(invocation, "abort.httpStatus"); if (errorCode == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: Abort error code is not configured"); asyncResponse.success(SUCCESS_RESPONSE); return; } CommonExceptionData errorData = new CommonExceptionData(ABORTED_ERROR_MSG); asyncResponse.consumerFail(new InvocationException(errorCode, ABORTED_ERROR_MSG, errorData)); } }
|
AbortFault extends AbstractFault { @Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asyncResponse) { if (!shouldAbort(invocation, faultParam)) { asyncResponse.success(SUCCESS_RESPONSE); return; } int errorCode = FaultInjectionUtil.getFaultInjectionConfig(invocation, "abort.httpStatus"); if (errorCode == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: Abort error code is not configured"); asyncResponse.success(SUCCESS_RESPONSE); return; } CommonExceptionData errorData = new CommonExceptionData(ABORTED_ERROR_MSG); asyncResponse.consumerFail(new InvocationException(errorCode, ABORTED_ERROR_MSG, errorData)); } @Override void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asyncResponse); @Override int getOrder(); }
|
AbortFault extends AbstractFault { @Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asyncResponse) { if (!shouldAbort(invocation, faultParam)) { asyncResponse.success(SUCCESS_RESPONSE); return; } int errorCode = FaultInjectionUtil.getFaultInjectionConfig(invocation, "abort.httpStatus"); if (errorCode == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: Abort error code is not configured"); asyncResponse.success(SUCCESS_RESPONSE); return; } CommonExceptionData errorData = new CommonExceptionData(ABORTED_ERROR_MSG); asyncResponse.consumerFail(new InvocationException(errorCode, ABORTED_ERROR_MSG, errorData)); } @Override void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asyncResponse); @Override int getOrder(); static final String ABORTED_ERROR_MSG; }
|
@Test public void injectFaultNoPercentageConfig() { ArchaiusUtils .setProperty("servicecomb.governance.Consumer._global.policy.fault.protocols.rest.abort.percent", null); assertNull(DynamicProperty .getInstance("servicecomb.governance.Consumer._global.policy.fault.protocols.rest.abort.percent") .getString()); AbortFault abortFault = new AbortFault(); FaultParam faultParam = new FaultParam(1); Vertx vertx = VertxUtils.getOrCreateVertxByName("faultinjectionTest", null); faultParam.setVertx(vertx); Holder<String> resultHolder = new Holder<>(); abortFault.injectFault(invocation, faultParam, response -> resultHolder.value = response.getResult()); AtomicLong count = FaultInjectionUtil.getOperMetTotalReq("restMicroserviceQualifiedName12"); assertEquals(1, count.get()); assertEquals("success", resultHolder.value); }
|
@Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asyncResponse) { if (!shouldAbort(invocation, faultParam)) { asyncResponse.success(SUCCESS_RESPONSE); return; } int errorCode = FaultInjectionUtil.getFaultInjectionConfig(invocation, "abort.httpStatus"); if (errorCode == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: Abort error code is not configured"); asyncResponse.success(SUCCESS_RESPONSE); return; } CommonExceptionData errorData = new CommonExceptionData(ABORTED_ERROR_MSG); asyncResponse.consumerFail(new InvocationException(errorCode, ABORTED_ERROR_MSG, errorData)); }
|
AbortFault extends AbstractFault { @Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asyncResponse) { if (!shouldAbort(invocation, faultParam)) { asyncResponse.success(SUCCESS_RESPONSE); return; } int errorCode = FaultInjectionUtil.getFaultInjectionConfig(invocation, "abort.httpStatus"); if (errorCode == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: Abort error code is not configured"); asyncResponse.success(SUCCESS_RESPONSE); return; } CommonExceptionData errorData = new CommonExceptionData(ABORTED_ERROR_MSG); asyncResponse.consumerFail(new InvocationException(errorCode, ABORTED_ERROR_MSG, errorData)); } }
|
AbortFault extends AbstractFault { @Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asyncResponse) { if (!shouldAbort(invocation, faultParam)) { asyncResponse.success(SUCCESS_RESPONSE); return; } int errorCode = FaultInjectionUtil.getFaultInjectionConfig(invocation, "abort.httpStatus"); if (errorCode == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: Abort error code is not configured"); asyncResponse.success(SUCCESS_RESPONSE); return; } CommonExceptionData errorData = new CommonExceptionData(ABORTED_ERROR_MSG); asyncResponse.consumerFail(new InvocationException(errorCode, ABORTED_ERROR_MSG, errorData)); } }
|
AbortFault extends AbstractFault { @Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asyncResponse) { if (!shouldAbort(invocation, faultParam)) { asyncResponse.success(SUCCESS_RESPONSE); return; } int errorCode = FaultInjectionUtil.getFaultInjectionConfig(invocation, "abort.httpStatus"); if (errorCode == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: Abort error code is not configured"); asyncResponse.success(SUCCESS_RESPONSE); return; } CommonExceptionData errorData = new CommonExceptionData(ABORTED_ERROR_MSG); asyncResponse.consumerFail(new InvocationException(errorCode, ABORTED_ERROR_MSG, errorData)); } @Override void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asyncResponse); @Override int getOrder(); }
|
AbortFault extends AbstractFault { @Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asyncResponse) { if (!shouldAbort(invocation, faultParam)) { asyncResponse.success(SUCCESS_RESPONSE); return; } int errorCode = FaultInjectionUtil.getFaultInjectionConfig(invocation, "abort.httpStatus"); if (errorCode == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: Abort error code is not configured"); asyncResponse.success(SUCCESS_RESPONSE); return; } CommonExceptionData errorData = new CommonExceptionData(ABORTED_ERROR_MSG); asyncResponse.consumerFail(new InvocationException(errorCode, ABORTED_ERROR_MSG, errorData)); } @Override void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asyncResponse); @Override int getOrder(); static final String ABORTED_ERROR_MSG; }
|
@Test public void injectFaultNoErrorCodeConfig() { ArchaiusUtils .setProperty("servicecomb.governance.Consumer._global.policy.fault.protocols.rest.abort.percent", "10"); assertEquals("10", DynamicProperty .getInstance("servicecomb.governance.Consumer._global.policy.fault.protocols.rest.abort.percent") .getString()); AbortFault abortFault = new AbortFault(); FaultParam faultParam = new FaultParam(10); Vertx vertx = VertxUtils.getOrCreateVertxByName("faultinjectionTest", null); faultParam.setVertx(vertx); Holder<String> resultHolder = new Holder<>(); abortFault.injectFault(invocation, faultParam, response -> resultHolder.value = response.getResult()); AtomicLong count = FaultInjectionUtil.getOperMetTotalReq("restMicroserviceQualifiedName12"); assertEquals(1, count.get()); assertEquals("success", resultHolder.value); }
|
@Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asyncResponse) { if (!shouldAbort(invocation, faultParam)) { asyncResponse.success(SUCCESS_RESPONSE); return; } int errorCode = FaultInjectionUtil.getFaultInjectionConfig(invocation, "abort.httpStatus"); if (errorCode == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: Abort error code is not configured"); asyncResponse.success(SUCCESS_RESPONSE); return; } CommonExceptionData errorData = new CommonExceptionData(ABORTED_ERROR_MSG); asyncResponse.consumerFail(new InvocationException(errorCode, ABORTED_ERROR_MSG, errorData)); }
|
AbortFault extends AbstractFault { @Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asyncResponse) { if (!shouldAbort(invocation, faultParam)) { asyncResponse.success(SUCCESS_RESPONSE); return; } int errorCode = FaultInjectionUtil.getFaultInjectionConfig(invocation, "abort.httpStatus"); if (errorCode == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: Abort error code is not configured"); asyncResponse.success(SUCCESS_RESPONSE); return; } CommonExceptionData errorData = new CommonExceptionData(ABORTED_ERROR_MSG); asyncResponse.consumerFail(new InvocationException(errorCode, ABORTED_ERROR_MSG, errorData)); } }
|
AbortFault extends AbstractFault { @Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asyncResponse) { if (!shouldAbort(invocation, faultParam)) { asyncResponse.success(SUCCESS_RESPONSE); return; } int errorCode = FaultInjectionUtil.getFaultInjectionConfig(invocation, "abort.httpStatus"); if (errorCode == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: Abort error code is not configured"); asyncResponse.success(SUCCESS_RESPONSE); return; } CommonExceptionData errorData = new CommonExceptionData(ABORTED_ERROR_MSG); asyncResponse.consumerFail(new InvocationException(errorCode, ABORTED_ERROR_MSG, errorData)); } }
|
AbortFault extends AbstractFault { @Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asyncResponse) { if (!shouldAbort(invocation, faultParam)) { asyncResponse.success(SUCCESS_RESPONSE); return; } int errorCode = FaultInjectionUtil.getFaultInjectionConfig(invocation, "abort.httpStatus"); if (errorCode == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: Abort error code is not configured"); asyncResponse.success(SUCCESS_RESPONSE); return; } CommonExceptionData errorData = new CommonExceptionData(ABORTED_ERROR_MSG); asyncResponse.consumerFail(new InvocationException(errorCode, ABORTED_ERROR_MSG, errorData)); } @Override void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asyncResponse); @Override int getOrder(); }
|
AbortFault extends AbstractFault { @Override public void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asyncResponse) { if (!shouldAbort(invocation, faultParam)) { asyncResponse.success(SUCCESS_RESPONSE); return; } int errorCode = FaultInjectionUtil.getFaultInjectionConfig(invocation, "abort.httpStatus"); if (errorCode == FaultInjectionConst.FAULT_INJECTION_DEFAULT_VALUE) { LOGGER.debug("Fault injection: Abort error code is not configured"); asyncResponse.success(SUCCESS_RESPONSE); return; } CommonExceptionData errorData = new CommonExceptionData(ABORTED_ERROR_MSG); asyncResponse.consumerFail(new InvocationException(errorCode, ABORTED_ERROR_MSG, errorData)); } @Override void injectFault(Invocation invocation, FaultParam faultParam, AsyncResponse asyncResponse); @Override int getOrder(); static final String ABORTED_ERROR_MSG; }
|
@Test public void testResumeWithFallbackProvider() { Invocation invocation = Mockito.mock(Invocation.class); Mockito.when(invocation.getOperationMeta()).thenReturn(Mockito.mock(OperationMeta.class)); Mockito.when(invocation.getOperationMeta().getMicroserviceQualifiedName()).thenReturn("test1"); HystrixCommandProperties.Setter setter = HystrixCommandProperties.Setter() .withRequestCacheEnabled(true) .withRequestLogEnabled(false); BizkeeperCommand bizkeeperCommand = new ProviderBizkeeperCommand("groupname", invocation, HystrixObservableCommand.Setter .withGroupKey(CommandKey.toHystrixCommandGroupKey("groupname", invocation)) .andCommandKey(CommandKey.toHystrixCommandKey("groupname", invocation)) .andCommandPropertiesDefaults(setter)); Observable<Response> observe = bizkeeperCommand.resumeWithFallback(); Assert.assertNotNull(observe); }
|
@Override protected Observable<Response> resumeWithFallback() { Throwable cause = getFailedExecutionException(); Observable<Response> observable = Observable.create(f -> { try { f.onNext(FallbackPolicyManager.getFallbackResponse(type, cause, invocation)); f.onCompleted(); } catch (Exception e) { LOG.warn("fallback failed due to:" + e.getMessage()); throw e; } }); return observable; }
|
BizkeeperCommand extends HystrixObservableCommand<Response> { @Override protected Observable<Response> resumeWithFallback() { Throwable cause = getFailedExecutionException(); Observable<Response> observable = Observable.create(f -> { try { f.onNext(FallbackPolicyManager.getFallbackResponse(type, cause, invocation)); f.onCompleted(); } catch (Exception e) { LOG.warn("fallback failed due to:" + e.getMessage()); throw e; } }); return observable; } }
|
BizkeeperCommand extends HystrixObservableCommand<Response> { @Override protected Observable<Response> resumeWithFallback() { Throwable cause = getFailedExecutionException(); Observable<Response> observable = Observable.create(f -> { try { f.onNext(FallbackPolicyManager.getFallbackResponse(type, cause, invocation)); f.onCompleted(); } catch (Exception e) { LOG.warn("fallback failed due to:" + e.getMessage()); throw e; } }); return observable; } protected BizkeeperCommand(String type, Invocation invocation, HystrixObservableCommand.Setter setter); }
|
BizkeeperCommand extends HystrixObservableCommand<Response> { @Override protected Observable<Response> resumeWithFallback() { Throwable cause = getFailedExecutionException(); Observable<Response> observable = Observable.create(f -> { try { f.onNext(FallbackPolicyManager.getFallbackResponse(type, cause, invocation)); f.onCompleted(); } catch (Exception e) { LOG.warn("fallback failed due to:" + e.getMessage()); throw e; } }); return observable; } protected BizkeeperCommand(String type, Invocation invocation, HystrixObservableCommand.Setter setter); }
|
BizkeeperCommand extends HystrixObservableCommand<Response> { @Override protected Observable<Response> resumeWithFallback() { Throwable cause = getFailedExecutionException(); Observable<Response> observable = Observable.create(f -> { try { f.onNext(FallbackPolicyManager.getFallbackResponse(type, cause, invocation)); f.onCompleted(); } catch (Exception e) { LOG.warn("fallback failed due to:" + e.getMessage()); throw e; } }); return observable; } protected BizkeeperCommand(String type, Invocation invocation, HystrixObservableCommand.Setter setter); }
|
@Test public void testConstructProvider() { Invocation invocation = Mockito.mock(Invocation.class); Mockito.when(invocation.getOperationMeta()).thenReturn(Mockito.mock(OperationMeta.class)); Mockito.when(invocation.getOperationMeta().getMicroserviceQualifiedName()).thenReturn("test1"); HystrixCommandProperties.Setter setter = HystrixCommandProperties.Setter() .withRequestCacheEnabled(true) .withRequestLogEnabled(false); BizkeeperCommand bizkeeperCommand = new ProviderBizkeeperCommand("groupname", invocation, HystrixObservableCommand.Setter .withGroupKey(CommandKey.toHystrixCommandGroupKey("groupname", invocation)) .andCommandKey(CommandKey.toHystrixCommandKey("groupname", invocation)) .andCommandPropertiesDefaults(setter)); Observable<Response> response = bizkeeperCommand.construct(); Assert.assertNotNull(response); }
|
@Override protected Observable<Response> construct() { Observable<Response> observable = Observable.create(f -> { try { invocation.next(resp -> { if (isFailedResponse(resp)) { LOG.warn("bizkeeper command {} failed due to {}", invocation.getInvocationQualifiedName(), resp.getResult()); f.onError(resp.getResult()); FallbackPolicyManager.record(type, invocation, resp, false); } else { f.onNext(resp); f.onCompleted(); FallbackPolicyManager.record(type, invocation, resp, true); } }); } catch (Exception e) { LOG.warn("bizkeeper command {} execute failed due to {}", invocation.getInvocationQualifiedName(), e.getClass().getName()); f.onError(e); } }); return observable; }
|
BizkeeperCommand extends HystrixObservableCommand<Response> { @Override protected Observable<Response> construct() { Observable<Response> observable = Observable.create(f -> { try { invocation.next(resp -> { if (isFailedResponse(resp)) { LOG.warn("bizkeeper command {} failed due to {}", invocation.getInvocationQualifiedName(), resp.getResult()); f.onError(resp.getResult()); FallbackPolicyManager.record(type, invocation, resp, false); } else { f.onNext(resp); f.onCompleted(); FallbackPolicyManager.record(type, invocation, resp, true); } }); } catch (Exception e) { LOG.warn("bizkeeper command {} execute failed due to {}", invocation.getInvocationQualifiedName(), e.getClass().getName()); f.onError(e); } }); return observable; } }
|
BizkeeperCommand extends HystrixObservableCommand<Response> { @Override protected Observable<Response> construct() { Observable<Response> observable = Observable.create(f -> { try { invocation.next(resp -> { if (isFailedResponse(resp)) { LOG.warn("bizkeeper command {} failed due to {}", invocation.getInvocationQualifiedName(), resp.getResult()); f.onError(resp.getResult()); FallbackPolicyManager.record(type, invocation, resp, false); } else { f.onNext(resp); f.onCompleted(); FallbackPolicyManager.record(type, invocation, resp, true); } }); } catch (Exception e) { LOG.warn("bizkeeper command {} execute failed due to {}", invocation.getInvocationQualifiedName(), e.getClass().getName()); f.onError(e); } }); return observable; } protected BizkeeperCommand(String type, Invocation invocation, HystrixObservableCommand.Setter setter); }
|
BizkeeperCommand extends HystrixObservableCommand<Response> { @Override protected Observable<Response> construct() { Observable<Response> observable = Observable.create(f -> { try { invocation.next(resp -> { if (isFailedResponse(resp)) { LOG.warn("bizkeeper command {} failed due to {}", invocation.getInvocationQualifiedName(), resp.getResult()); f.onError(resp.getResult()); FallbackPolicyManager.record(type, invocation, resp, false); } else { f.onNext(resp); f.onCompleted(); FallbackPolicyManager.record(type, invocation, resp, true); } }); } catch (Exception e) { LOG.warn("bizkeeper command {} execute failed due to {}", invocation.getInvocationQualifiedName(), e.getClass().getName()); f.onError(e); } }); return observable; } protected BizkeeperCommand(String type, Invocation invocation, HystrixObservableCommand.Setter setter); }
|
BizkeeperCommand extends HystrixObservableCommand<Response> { @Override protected Observable<Response> construct() { Observable<Response> observable = Observable.create(f -> { try { invocation.next(resp -> { if (isFailedResponse(resp)) { LOG.warn("bizkeeper command {} failed due to {}", invocation.getInvocationQualifiedName(), resp.getResult()); f.onError(resp.getResult()); FallbackPolicyManager.record(type, invocation, resp, false); } else { f.onNext(resp); f.onCompleted(); FallbackPolicyManager.record(type, invocation, resp, true); } }); } catch (Exception e) { LOG.warn("bizkeeper command {} execute failed due to {}", invocation.getInvocationQualifiedName(), e.getClass().getName()); f.onError(e); } }); return observable; } protected BizkeeperCommand(String type, Invocation invocation, HystrixObservableCommand.Setter setter); }
|
@Test public void testGetCacheKeyWithContextInitializedProvider() { Invocation invocation = Mockito.mock(Invocation.class); Mockito.when(invocation.getOperationMeta()).thenReturn(Mockito.mock(OperationMeta.class)); Mockito.when(invocation.getOperationMeta().getMicroserviceQualifiedName()).thenReturn("test1"); HystrixCommandProperties.Setter setter = HystrixCommandProperties.Setter() .withRequestCacheEnabled(true) .withRequestLogEnabled(false); BizkeeperCommand bizkeeperCommand = new ProviderBizkeeperCommand("groupname", invocation, HystrixObservableCommand.Setter .withGroupKey(CommandKey.toHystrixCommandGroupKey("groupname", invocation)) .andCommandKey(CommandKey.toHystrixCommandKey("groupname", invocation)) .andCommandPropertiesDefaults(setter)); HystrixRequestContext.initializeContext(); String cacheKey = bizkeeperCommand.getCacheKey(); Assert.assertNotNull(cacheKey); }
|
@Override protected String getCacheKey() { if (HystrixRequestContext.isCurrentThreadInitialized()) { StringBuilder sb = new StringBuilder(); sb.append(this.getCommandGroup().name()); sb.append("-"); sb.append(this.getCommandKey().name()); return sb.toString(); } else { return super.getCacheKey(); } }
|
BizkeeperCommand extends HystrixObservableCommand<Response> { @Override protected String getCacheKey() { if (HystrixRequestContext.isCurrentThreadInitialized()) { StringBuilder sb = new StringBuilder(); sb.append(this.getCommandGroup().name()); sb.append("-"); sb.append(this.getCommandKey().name()); return sb.toString(); } else { return super.getCacheKey(); } } }
|
BizkeeperCommand extends HystrixObservableCommand<Response> { @Override protected String getCacheKey() { if (HystrixRequestContext.isCurrentThreadInitialized()) { StringBuilder sb = new StringBuilder(); sb.append(this.getCommandGroup().name()); sb.append("-"); sb.append(this.getCommandKey().name()); return sb.toString(); } else { return super.getCacheKey(); } } protected BizkeeperCommand(String type, Invocation invocation, HystrixObservableCommand.Setter setter); }
|
BizkeeperCommand extends HystrixObservableCommand<Response> { @Override protected String getCacheKey() { if (HystrixRequestContext.isCurrentThreadInitialized()) { StringBuilder sb = new StringBuilder(); sb.append(this.getCommandGroup().name()); sb.append("-"); sb.append(this.getCommandKey().name()); return sb.toString(); } else { return super.getCacheKey(); } } protected BizkeeperCommand(String type, Invocation invocation, HystrixObservableCommand.Setter setter); }
|
BizkeeperCommand extends HystrixObservableCommand<Response> { @Override protected String getCacheKey() { if (HystrixRequestContext.isCurrentThreadInitialized()) { StringBuilder sb = new StringBuilder(); sb.append(this.getCommandGroup().name()); sb.append("-"); sb.append(this.getCommandKey().name()); return sb.toString(); } else { return super.getCacheKey(); } } protected BizkeeperCommand(String type, Invocation invocation, HystrixObservableCommand.Setter setter); }
|
@Test public void testResumeWithFallbackConsumer() { Invocation invocation = Mockito.mock(Invocation.class); Mockito.when(invocation.getOperationMeta()).thenReturn(Mockito.mock(OperationMeta.class)); Mockito.when(invocation.getOperationMeta().getMicroserviceQualifiedName()).thenReturn("test1"); HystrixCommandProperties.Setter setter = HystrixCommandProperties.Setter() .withRequestCacheEnabled(true) .withRequestLogEnabled(false); BizkeeperCommand bizkeeperCommand = new ConsumerBizkeeperCommand("groupname", invocation, HystrixObservableCommand.Setter .withGroupKey(CommandKey.toHystrixCommandGroupKey("groupname", invocation)) .andCommandKey(CommandKey.toHystrixCommandKey("groupname", invocation)) .andCommandPropertiesDefaults(setter)); Observable<Response> observe = bizkeeperCommand.resumeWithFallback(); Assert.assertNotNull(observe); }
|
@Override protected Observable<Response> resumeWithFallback() { Throwable cause = getFailedExecutionException(); Observable<Response> observable = Observable.create(f -> { try { f.onNext(FallbackPolicyManager.getFallbackResponse(type, cause, invocation)); f.onCompleted(); } catch (Exception e) { LOG.warn("fallback failed due to:" + e.getMessage()); throw e; } }); return observable; }
|
BizkeeperCommand extends HystrixObservableCommand<Response> { @Override protected Observable<Response> resumeWithFallback() { Throwable cause = getFailedExecutionException(); Observable<Response> observable = Observable.create(f -> { try { f.onNext(FallbackPolicyManager.getFallbackResponse(type, cause, invocation)); f.onCompleted(); } catch (Exception e) { LOG.warn("fallback failed due to:" + e.getMessage()); throw e; } }); return observable; } }
|
BizkeeperCommand extends HystrixObservableCommand<Response> { @Override protected Observable<Response> resumeWithFallback() { Throwable cause = getFailedExecutionException(); Observable<Response> observable = Observable.create(f -> { try { f.onNext(FallbackPolicyManager.getFallbackResponse(type, cause, invocation)); f.onCompleted(); } catch (Exception e) { LOG.warn("fallback failed due to:" + e.getMessage()); throw e; } }); return observable; } protected BizkeeperCommand(String type, Invocation invocation, HystrixObservableCommand.Setter setter); }
|
BizkeeperCommand extends HystrixObservableCommand<Response> { @Override protected Observable<Response> resumeWithFallback() { Throwable cause = getFailedExecutionException(); Observable<Response> observable = Observable.create(f -> { try { f.onNext(FallbackPolicyManager.getFallbackResponse(type, cause, invocation)); f.onCompleted(); } catch (Exception e) { LOG.warn("fallback failed due to:" + e.getMessage()); throw e; } }); return observable; } protected BizkeeperCommand(String type, Invocation invocation, HystrixObservableCommand.Setter setter); }
|
BizkeeperCommand extends HystrixObservableCommand<Response> { @Override protected Observable<Response> resumeWithFallback() { Throwable cause = getFailedExecutionException(); Observable<Response> observable = Observable.create(f -> { try { f.onNext(FallbackPolicyManager.getFallbackResponse(type, cause, invocation)); f.onCompleted(); } catch (Exception e) { LOG.warn("fallback failed due to:" + e.getMessage()); throw e; } }); return observable; } protected BizkeeperCommand(String type, Invocation invocation, HystrixObservableCommand.Setter setter); }
|
@Test public void add() { Assert.assertTrue(opPerf.getStages().isEmpty()); OperationPerf otherOpPerf = Utils.createOperationPerf(op); opPerf.add(otherOpPerf); Assert.assertEquals(op, otherOpPerf.getOperation()); PerfInfo perfInfo = opPerf.findStage(MeterInvocationConst.STAGE_TOTAL); Assert.assertEquals(10, perfInfo.getTps(), 0); Assert.assertEquals(1000, perfInfo.calcMsLatency(), 0); Assert.assertEquals(100000, perfInfo.getMsMaxLatency(), 0); perfInfo = opPerf.findStage(MeterInvocationConst.STAGE_EXECUTION); Assert.assertEquals(10, perfInfo.getTps(), 0); Assert.assertEquals(1000, perfInfo.calcMsLatency(), 0); Assert.assertEquals(100000, perfInfo.getMsMaxLatency(), 0); }
|
public void add(OperationPerf operationPerf) { operationPerf.stages.forEach((key, value) -> { PerfInfo perfInfo = stages.computeIfAbsent(key, n -> new PerfInfo()); perfInfo.add(value); }); if (operationPerf.getLatencyDistribution() == null) { return; } if (latencyDistribution == null) { latencyDistribution = new Integer[operationPerf.getLatencyDistribution().length]; Arrays.fill(latencyDistribution, 0); } for (int idx = 0; idx < operationPerf.getLatencyDistribution().length; idx++) { latencyDistribution[idx] += operationPerf.getLatencyDistribution()[idx]; } }
|
OperationPerf { public void add(OperationPerf operationPerf) { operationPerf.stages.forEach((key, value) -> { PerfInfo perfInfo = stages.computeIfAbsent(key, n -> new PerfInfo()); perfInfo.add(value); }); if (operationPerf.getLatencyDistribution() == null) { return; } if (latencyDistribution == null) { latencyDistribution = new Integer[operationPerf.getLatencyDistribution().length]; Arrays.fill(latencyDistribution, 0); } for (int idx = 0; idx < operationPerf.getLatencyDistribution().length; idx++) { latencyDistribution[idx] += operationPerf.getLatencyDistribution()[idx]; } } }
|
OperationPerf { public void add(OperationPerf operationPerf) { operationPerf.stages.forEach((key, value) -> { PerfInfo perfInfo = stages.computeIfAbsent(key, n -> new PerfInfo()); perfInfo.add(value); }); if (operationPerf.getLatencyDistribution() == null) { return; } if (latencyDistribution == null) { latencyDistribution = new Integer[operationPerf.getLatencyDistribution().length]; Arrays.fill(latencyDistribution, 0); } for (int idx = 0; idx < operationPerf.getLatencyDistribution().length; idx++) { latencyDistribution[idx] += operationPerf.getLatencyDistribution()[idx]; } } }
|
OperationPerf { public void add(OperationPerf operationPerf) { operationPerf.stages.forEach((key, value) -> { PerfInfo perfInfo = stages.computeIfAbsent(key, n -> new PerfInfo()); perfInfo.add(value); }); if (operationPerf.getLatencyDistribution() == null) { return; } if (latencyDistribution == null) { latencyDistribution = new Integer[operationPerf.getLatencyDistribution().length]; Arrays.fill(latencyDistribution, 0); } for (int idx = 0; idx < operationPerf.getLatencyDistribution().length; idx++) { latencyDistribution[idx] += operationPerf.getLatencyDistribution()[idx]; } } String getOperation(); void setOperation(String operation); Map<String, PerfInfo> getStages(); Integer[] getLatencyDistribution(); void setLatencyDistribution(Integer[] latencyDistribution); void setStages(Map<String, PerfInfo> stages); PerfInfo findStage(String stage); void add(OperationPerf operationPerf); }
|
OperationPerf { public void add(OperationPerf operationPerf) { operationPerf.stages.forEach((key, value) -> { PerfInfo perfInfo = stages.computeIfAbsent(key, n -> new PerfInfo()); perfInfo.add(value); }); if (operationPerf.getLatencyDistribution() == null) { return; } if (latencyDistribution == null) { latencyDistribution = new Integer[operationPerf.getLatencyDistribution().length]; Arrays.fill(latencyDistribution, 0); } for (int idx = 0; idx < operationPerf.getLatencyDistribution().length; idx++) { latencyDistribution[idx] += operationPerf.getLatencyDistribution()[idx]; } } String getOperation(); void setOperation(String operation); Map<String, PerfInfo> getStages(); Integer[] getLatencyDistribution(); void setLatencyDistribution(Integer[] latencyDistribution); void setStages(Map<String, PerfInfo> stages); PerfInfo findStage(String stage); void add(OperationPerf operationPerf); }
|
@Test public void testConstructConsumer() { Invocation invocation = Mockito.mock(Invocation.class); Mockito.when(invocation.getOperationMeta()).thenReturn(Mockito.mock(OperationMeta.class)); Mockito.when(invocation.getOperationMeta().getMicroserviceQualifiedName()).thenReturn("test1"); HystrixCommandProperties.Setter setter = HystrixCommandProperties.Setter() .withRequestCacheEnabled(true) .withRequestLogEnabled(false); BizkeeperCommand bizkeeperCommand = new ConsumerBizkeeperCommand("groupname", invocation, HystrixObservableCommand.Setter .withGroupKey(CommandKey.toHystrixCommandGroupKey("groupname", invocation)) .andCommandKey(CommandKey.toHystrixCommandKey("groupname", invocation)) .andCommandPropertiesDefaults(setter)); Observable<Response> response = bizkeeperCommand.construct(); Assert.assertNotNull(response); }
|
@Override protected Observable<Response> construct() { Observable<Response> observable = Observable.create(f -> { try { invocation.next(resp -> { if (isFailedResponse(resp)) { LOG.warn("bizkeeper command {} failed due to {}", invocation.getInvocationQualifiedName(), resp.getResult()); f.onError(resp.getResult()); FallbackPolicyManager.record(type, invocation, resp, false); } else { f.onNext(resp); f.onCompleted(); FallbackPolicyManager.record(type, invocation, resp, true); } }); } catch (Exception e) { LOG.warn("bizkeeper command {} execute failed due to {}", invocation.getInvocationQualifiedName(), e.getClass().getName()); f.onError(e); } }); return observable; }
|
BizkeeperCommand extends HystrixObservableCommand<Response> { @Override protected Observable<Response> construct() { Observable<Response> observable = Observable.create(f -> { try { invocation.next(resp -> { if (isFailedResponse(resp)) { LOG.warn("bizkeeper command {} failed due to {}", invocation.getInvocationQualifiedName(), resp.getResult()); f.onError(resp.getResult()); FallbackPolicyManager.record(type, invocation, resp, false); } else { f.onNext(resp); f.onCompleted(); FallbackPolicyManager.record(type, invocation, resp, true); } }); } catch (Exception e) { LOG.warn("bizkeeper command {} execute failed due to {}", invocation.getInvocationQualifiedName(), e.getClass().getName()); f.onError(e); } }); return observable; } }
|
BizkeeperCommand extends HystrixObservableCommand<Response> { @Override protected Observable<Response> construct() { Observable<Response> observable = Observable.create(f -> { try { invocation.next(resp -> { if (isFailedResponse(resp)) { LOG.warn("bizkeeper command {} failed due to {}", invocation.getInvocationQualifiedName(), resp.getResult()); f.onError(resp.getResult()); FallbackPolicyManager.record(type, invocation, resp, false); } else { f.onNext(resp); f.onCompleted(); FallbackPolicyManager.record(type, invocation, resp, true); } }); } catch (Exception e) { LOG.warn("bizkeeper command {} execute failed due to {}", invocation.getInvocationQualifiedName(), e.getClass().getName()); f.onError(e); } }); return observable; } protected BizkeeperCommand(String type, Invocation invocation, HystrixObservableCommand.Setter setter); }
|
BizkeeperCommand extends HystrixObservableCommand<Response> { @Override protected Observable<Response> construct() { Observable<Response> observable = Observable.create(f -> { try { invocation.next(resp -> { if (isFailedResponse(resp)) { LOG.warn("bizkeeper command {} failed due to {}", invocation.getInvocationQualifiedName(), resp.getResult()); f.onError(resp.getResult()); FallbackPolicyManager.record(type, invocation, resp, false); } else { f.onNext(resp); f.onCompleted(); FallbackPolicyManager.record(type, invocation, resp, true); } }); } catch (Exception e) { LOG.warn("bizkeeper command {} execute failed due to {}", invocation.getInvocationQualifiedName(), e.getClass().getName()); f.onError(e); } }); return observable; } protected BizkeeperCommand(String type, Invocation invocation, HystrixObservableCommand.Setter setter); }
|
BizkeeperCommand extends HystrixObservableCommand<Response> { @Override protected Observable<Response> construct() { Observable<Response> observable = Observable.create(f -> { try { invocation.next(resp -> { if (isFailedResponse(resp)) { LOG.warn("bizkeeper command {} failed due to {}", invocation.getInvocationQualifiedName(), resp.getResult()); f.onError(resp.getResult()); FallbackPolicyManager.record(type, invocation, resp, false); } else { f.onNext(resp); f.onCompleted(); FallbackPolicyManager.record(type, invocation, resp, true); } }); } catch (Exception e) { LOG.warn("bizkeeper command {} execute failed due to {}", invocation.getInvocationQualifiedName(), e.getClass().getName()); f.onError(e); } }); return observable; } protected BizkeeperCommand(String type, Invocation invocation, HystrixObservableCommand.Setter setter); }
|
@Test public void testGetCacheKeyWithContextInitializedConsumer() { Invocation invocation = Mockito.mock(Invocation.class); Mockito.when(invocation.getOperationMeta()).thenReturn(Mockito.mock(OperationMeta.class)); Mockito.when(invocation.getOperationMeta().getMicroserviceQualifiedName()).thenReturn("test1"); HystrixCommandProperties.Setter setter = HystrixCommandProperties.Setter() .withRequestCacheEnabled(true) .withRequestLogEnabled(false); BizkeeperCommand bizkeeperCommand = new ConsumerBizkeeperCommand("groupname", invocation, HystrixObservableCommand.Setter .withGroupKey(CommandKey.toHystrixCommandGroupKey("groupname", invocation)) .andCommandKey(CommandKey.toHystrixCommandKey("groupname", invocation)) .andCommandPropertiesDefaults(setter)); HystrixRequestContext.initializeContext(); String cacheKey = bizkeeperCommand.getCacheKey(); Assert.assertNotNull(cacheKey); }
|
@Override protected String getCacheKey() { if (HystrixRequestContext.isCurrentThreadInitialized()) { StringBuilder sb = new StringBuilder(); sb.append(this.getCommandGroup().name()); sb.append("-"); sb.append(this.getCommandKey().name()); return sb.toString(); } else { return super.getCacheKey(); } }
|
BizkeeperCommand extends HystrixObservableCommand<Response> { @Override protected String getCacheKey() { if (HystrixRequestContext.isCurrentThreadInitialized()) { StringBuilder sb = new StringBuilder(); sb.append(this.getCommandGroup().name()); sb.append("-"); sb.append(this.getCommandKey().name()); return sb.toString(); } else { return super.getCacheKey(); } } }
|
BizkeeperCommand extends HystrixObservableCommand<Response> { @Override protected String getCacheKey() { if (HystrixRequestContext.isCurrentThreadInitialized()) { StringBuilder sb = new StringBuilder(); sb.append(this.getCommandGroup().name()); sb.append("-"); sb.append(this.getCommandKey().name()); return sb.toString(); } else { return super.getCacheKey(); } } protected BizkeeperCommand(String type, Invocation invocation, HystrixObservableCommand.Setter setter); }
|
BizkeeperCommand extends HystrixObservableCommand<Response> { @Override protected String getCacheKey() { if (HystrixRequestContext.isCurrentThreadInitialized()) { StringBuilder sb = new StringBuilder(); sb.append(this.getCommandGroup().name()); sb.append("-"); sb.append(this.getCommandKey().name()); return sb.toString(); } else { return super.getCacheKey(); } } protected BizkeeperCommand(String type, Invocation invocation, HystrixObservableCommand.Setter setter); }
|
BizkeeperCommand extends HystrixObservableCommand<Response> { @Override protected String getCacheKey() { if (HystrixRequestContext.isCurrentThreadInitialized()) { StringBuilder sb = new StringBuilder(); sb.append(this.getCommandGroup().name()); sb.append("-"); sb.append(this.getCommandKey().name()); return sb.toString(); } else { return super.getCacheKey(); } } protected BizkeeperCommand(String type, Invocation invocation, HystrixObservableCommand.Setter setter); }
|
@Test public void testToHystrixCommandGroupKey() { Invocation invocation = Mockito.mock(Invocation.class); Mockito.when(invocation.getOperationMeta()).thenReturn(Mockito.mock(OperationMeta.class)); Mockito.when(invocation.getOperationMeta().getMicroserviceQualifiedName()).thenReturn("test1"); Assert.assertNotNull(invocation); HystrixCommandGroupKey hystrixCommandGroupKey = CommandKey.toHystrixCommandGroupKey("groupname", invocation); Assert.assertNotNull(hystrixCommandGroupKey); }
|
public static HystrixCommandGroupKey toHystrixCommandGroupKey(String type, Invocation invocation) { return CustomizeCommandGroupKey.asKey(type + "." + invocation.getOperationMeta().getMicroserviceQualifiedName(), invocation); }
|
CommandKey { public static HystrixCommandGroupKey toHystrixCommandGroupKey(String type, Invocation invocation) { return CustomizeCommandGroupKey.asKey(type + "." + invocation.getOperationMeta().getMicroserviceQualifiedName(), invocation); } }
|
CommandKey { public static HystrixCommandGroupKey toHystrixCommandGroupKey(String type, Invocation invocation) { return CustomizeCommandGroupKey.asKey(type + "." + invocation.getOperationMeta().getMicroserviceQualifiedName(), invocation); } private CommandKey(); }
|
CommandKey { public static HystrixCommandGroupKey toHystrixCommandGroupKey(String type, Invocation invocation) { return CustomizeCommandGroupKey.asKey(type + "." + invocation.getOperationMeta().getMicroserviceQualifiedName(), invocation); } private CommandKey(); static HystrixCommandGroupKey toHystrixCommandGroupKey(String type, Invocation invocation); static HystrixCommandKey toHystrixCommandKey(String type, Invocation invocation); }
|
CommandKey { public static HystrixCommandGroupKey toHystrixCommandGroupKey(String type, Invocation invocation) { return CustomizeCommandGroupKey.asKey(type + "." + invocation.getOperationMeta().getMicroserviceQualifiedName(), invocation); } private CommandKey(); static HystrixCommandGroupKey toHystrixCommandGroupKey(String type, Invocation invocation); static HystrixCommandKey toHystrixCommandKey(String type, Invocation invocation); }
|
@Test public void testToHystrixCommandKey() { Invocation invocation = Mockito.mock(Invocation.class); Mockito.when(invocation.getOperationMeta()).thenReturn(Mockito.mock(OperationMeta.class)); Mockito.when(invocation.getOperationMeta().getMicroserviceQualifiedName()).thenReturn("test1"); Assert.assertNotNull(invocation); HystrixCommandKey hystrixCommandGroupKey = CommandKey.toHystrixCommandKey("groupname", invocation); Assert.assertNotNull(hystrixCommandGroupKey); }
|
public static HystrixCommandKey toHystrixCommandKey(String type, Invocation invocation) { return HystrixCommandKey.Factory .asKey(type + "." + invocation.getOperationMeta().getMicroserviceQualifiedName()); }
|
CommandKey { public static HystrixCommandKey toHystrixCommandKey(String type, Invocation invocation) { return HystrixCommandKey.Factory .asKey(type + "." + invocation.getOperationMeta().getMicroserviceQualifiedName()); } }
|
CommandKey { public static HystrixCommandKey toHystrixCommandKey(String type, Invocation invocation) { return HystrixCommandKey.Factory .asKey(type + "." + invocation.getOperationMeta().getMicroserviceQualifiedName()); } private CommandKey(); }
|
CommandKey { public static HystrixCommandKey toHystrixCommandKey(String type, Invocation invocation) { return HystrixCommandKey.Factory .asKey(type + "." + invocation.getOperationMeta().getMicroserviceQualifiedName()); } private CommandKey(); static HystrixCommandGroupKey toHystrixCommandGroupKey(String type, Invocation invocation); static HystrixCommandKey toHystrixCommandKey(String type, Invocation invocation); }
|
CommandKey { public static HystrixCommandKey toHystrixCommandKey(String type, Invocation invocation) { return HystrixCommandKey.Factory .asKey(type + "." + invocation.getOperationMeta().getMicroserviceQualifiedName()); } private CommandKey(); static HystrixCommandGroupKey toHystrixCommandGroupKey(String type, Invocation invocation); static HystrixCommandKey toHystrixCommandKey(String type, Invocation invocation); }
|
@Test public void testCreateBizkeeperCommand() { HystrixPlugins.reset(); ConsumerBizkeeperHandler consumerBizkeeperHandler = new ConsumerBizkeeperHandler(); Invocation invocation = Mockito.mock(Invocation.class); Mockito.when(invocation.getOperationMeta()).thenReturn(Mockito.mock(OperationMeta.class)); Mockito.when(invocation.getOperationMeta().getMicroserviceQualifiedName()).thenReturn("test1"); CommandKey.toHystrixCommandGroupKey("groupname", invocation); CommandKey.toHystrixCommandKey("groupname", invocation); BizkeeperCommand command = consumerBizkeeperHandler.createBizkeeperCommand(invocation); Assert.assertNotNull(command); }
|
@Override protected BizkeeperCommand createBizkeeperCommand(Invocation invocation) { HystrixCommandProperties.Setter setter = HystrixCommandProperties.Setter() .withRequestCacheEnabled(true) .withRequestLogEnabled(false); setCommonProperties(invocation, setter); BizkeeperCommand command = new ConsumerBizkeeperCommand(groupname, invocation, HystrixObservableCommand.Setter .withGroupKey(CommandKey.toHystrixCommandGroupKey(groupname, invocation)) .andCommandKey(CommandKey.toHystrixCommandKey(groupname, invocation)) .andCommandPropertiesDefaults(setter)); return command; }
|
ConsumerBizkeeperHandler extends BizkeeperHandler { @Override protected BizkeeperCommand createBizkeeperCommand(Invocation invocation) { HystrixCommandProperties.Setter setter = HystrixCommandProperties.Setter() .withRequestCacheEnabled(true) .withRequestLogEnabled(false); setCommonProperties(invocation, setter); BizkeeperCommand command = new ConsumerBizkeeperCommand(groupname, invocation, HystrixObservableCommand.Setter .withGroupKey(CommandKey.toHystrixCommandGroupKey(groupname, invocation)) .andCommandKey(CommandKey.toHystrixCommandKey(groupname, invocation)) .andCommandPropertiesDefaults(setter)); return command; } }
|
ConsumerBizkeeperHandler extends BizkeeperHandler { @Override protected BizkeeperCommand createBizkeeperCommand(Invocation invocation) { HystrixCommandProperties.Setter setter = HystrixCommandProperties.Setter() .withRequestCacheEnabled(true) .withRequestLogEnabled(false); setCommonProperties(invocation, setter); BizkeeperCommand command = new ConsumerBizkeeperCommand(groupname, invocation, HystrixObservableCommand.Setter .withGroupKey(CommandKey.toHystrixCommandGroupKey(groupname, invocation)) .andCommandKey(CommandKey.toHystrixCommandKey(groupname, invocation)) .andCommandPropertiesDefaults(setter)); return command; } ConsumerBizkeeperHandler(); }
|
ConsumerBizkeeperHandler extends BizkeeperHandler { @Override protected BizkeeperCommand createBizkeeperCommand(Invocation invocation) { HystrixCommandProperties.Setter setter = HystrixCommandProperties.Setter() .withRequestCacheEnabled(true) .withRequestLogEnabled(false); setCommonProperties(invocation, setter); BizkeeperCommand command = new ConsumerBizkeeperCommand(groupname, invocation, HystrixObservableCommand.Setter .withGroupKey(CommandKey.toHystrixCommandGroupKey(groupname, invocation)) .andCommandKey(CommandKey.toHystrixCommandKey(groupname, invocation)) .andCommandPropertiesDefaults(setter)); return command; } ConsumerBizkeeperHandler(); }
|
ConsumerBizkeeperHandler extends BizkeeperHandler { @Override protected BizkeeperCommand createBizkeeperCommand(Invocation invocation) { HystrixCommandProperties.Setter setter = HystrixCommandProperties.Setter() .withRequestCacheEnabled(true) .withRequestLogEnabled(false); setCommonProperties(invocation, setter); BizkeeperCommand command = new ConsumerBizkeeperCommand(groupname, invocation, HystrixObservableCommand.Setter .withGroupKey(CommandKey.toHystrixCommandGroupKey(groupname, invocation)) .andCommandKey(CommandKey.toHystrixCommandKey(groupname, invocation)) .andCommandPropertiesDefaults(setter)); return command; } ConsumerBizkeeperHandler(); }
|
@Test public void testInitializeContext() { BizkeeperRequestContext bizkeeperRequestContext = BizkeeperRequestContext.initializeContext(); Assert.assertNotNull(bizkeeperRequestContext); }
|
public static BizkeeperRequestContext initializeContext() { return new BizkeeperRequestContext(HystrixRequestContext.initializeContext()); }
|
BizkeeperRequestContext { public static BizkeeperRequestContext initializeContext() { return new BizkeeperRequestContext(HystrixRequestContext.initializeContext()); } }
|
BizkeeperRequestContext { public static BizkeeperRequestContext initializeContext() { return new BizkeeperRequestContext(HystrixRequestContext.initializeContext()); } private BizkeeperRequestContext(HystrixRequestContext context); }
|
BizkeeperRequestContext { public static BizkeeperRequestContext initializeContext() { return new BizkeeperRequestContext(HystrixRequestContext.initializeContext()); } private BizkeeperRequestContext(HystrixRequestContext context); static BizkeeperRequestContext initializeContext(); void shutdown(); }
|
BizkeeperRequestContext { public static BizkeeperRequestContext initializeContext() { return new BizkeeperRequestContext(HystrixRequestContext.initializeContext()); } private BizkeeperRequestContext(HystrixRequestContext context); static BizkeeperRequestContext initializeContext(); void shutdown(); }
|
@Test public void testShutdown() { BizkeeperRequestContext bizkeeperRequestContext = BizkeeperRequestContext.initializeContext(); boolean validAssert; try { bizkeeperRequestContext.shutdown(); validAssert = true; } catch (Exception e) { validAssert = false; } Assert.assertTrue(validAssert); }
|
public void shutdown() { this.context.shutdown(); }
|
BizkeeperRequestContext { public void shutdown() { this.context.shutdown(); } }
|
BizkeeperRequestContext { public void shutdown() { this.context.shutdown(); } private BizkeeperRequestContext(HystrixRequestContext context); }
|
BizkeeperRequestContext { public void shutdown() { this.context.shutdown(); } private BizkeeperRequestContext(HystrixRequestContext context); static BizkeeperRequestContext initializeContext(); void shutdown(); }
|
BizkeeperRequestContext { public void shutdown() { this.context.shutdown(); } private BizkeeperRequestContext(HystrixRequestContext context); static BizkeeperRequestContext initializeContext(); void shutdown(); }
|
@Test public void testHandleWithException() { boolean validAssert; HystrixPlugins.reset(); try { validAssert = true; bizkeeperHandler.handle(invocation, asyncResp); } catch (Exception e) { validAssert = false; } Assert.assertFalse(validAssert); }
|
@Override public void handle(Invocation invocation, AsyncResponse asyncResp) { HystrixObservable<Response> command = delegate.createBizkeeperCommand(invocation); Observable<Response> observable = command.toObservable(); observable.subscribe(asyncResp::complete, error -> { LOG.warn("catch error in bizkeeper:" + error.getMessage()); asyncResp.fail(invocation.getInvocationType(), error); }, () -> { }); }
|
BizkeeperHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) { HystrixObservable<Response> command = delegate.createBizkeeperCommand(invocation); Observable<Response> observable = command.toObservable(); observable.subscribe(asyncResp::complete, error -> { LOG.warn("catch error in bizkeeper:" + error.getMessage()); asyncResp.fail(invocation.getInvocationType(), error); }, () -> { }); } }
|
BizkeeperHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) { HystrixObservable<Response> command = delegate.createBizkeeperCommand(invocation); Observable<Response> observable = command.toObservable(); observable.subscribe(asyncResp::complete, error -> { LOG.warn("catch error in bizkeeper:" + error.getMessage()); asyncResp.fail(invocation.getInvocationType(), error); }, () -> { }); } BizkeeperHandler(String groupname); }
|
BizkeeperHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) { HystrixObservable<Response> command = delegate.createBizkeeperCommand(invocation); Observable<Response> observable = command.toObservable(); observable.subscribe(asyncResp::complete, error -> { LOG.warn("catch error in bizkeeper:" + error.getMessage()); asyncResp.fail(invocation.getInvocationType(), error); }, () -> { }); } BizkeeperHandler(String groupname); @Override void handle(Invocation invocation, AsyncResponse asyncResp); }
|
BizkeeperHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) { HystrixObservable<Response> command = delegate.createBizkeeperCommand(invocation); Observable<Response> observable = command.toObservable(); observable.subscribe(asyncResp::complete, error -> { LOG.warn("catch error in bizkeeper:" + error.getMessage()); asyncResp.fail(invocation.getInvocationType(), error); }, () -> { }); } BizkeeperHandler(String groupname); @Override void handle(Invocation invocation, AsyncResponse asyncResp); }
|
@Test public void testHandle() { boolean validAssert; try { Assert.assertNotNull(bizkeeperHandler); Mockito.when(invocation.getMicroserviceName()).thenReturn("test1"); Mockito.when(invocation.getOperationMeta()).thenReturn(Mockito.mock(OperationMeta.class)); Mockito.when(invocation.getOperationMeta().getMicroserviceQualifiedName()).thenReturn("test1"); validAssert = true; bizkeeperHandler.handle(invocation, asyncResp); } catch (Exception exce) { validAssert = false; } Assert.assertTrue(validAssert); }
|
@Override public void handle(Invocation invocation, AsyncResponse asyncResp) { HystrixObservable<Response> command = delegate.createBizkeeperCommand(invocation); Observable<Response> observable = command.toObservable(); observable.subscribe(asyncResp::complete, error -> { LOG.warn("catch error in bizkeeper:" + error.getMessage()); asyncResp.fail(invocation.getInvocationType(), error); }, () -> { }); }
|
BizkeeperHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) { HystrixObservable<Response> command = delegate.createBizkeeperCommand(invocation); Observable<Response> observable = command.toObservable(); observable.subscribe(asyncResp::complete, error -> { LOG.warn("catch error in bizkeeper:" + error.getMessage()); asyncResp.fail(invocation.getInvocationType(), error); }, () -> { }); } }
|
BizkeeperHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) { HystrixObservable<Response> command = delegate.createBizkeeperCommand(invocation); Observable<Response> observable = command.toObservable(); observable.subscribe(asyncResp::complete, error -> { LOG.warn("catch error in bizkeeper:" + error.getMessage()); asyncResp.fail(invocation.getInvocationType(), error); }, () -> { }); } BizkeeperHandler(String groupname); }
|
BizkeeperHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) { HystrixObservable<Response> command = delegate.createBizkeeperCommand(invocation); Observable<Response> observable = command.toObservable(); observable.subscribe(asyncResp::complete, error -> { LOG.warn("catch error in bizkeeper:" + error.getMessage()); asyncResp.fail(invocation.getInvocationType(), error); }, () -> { }); } BizkeeperHandler(String groupname); @Override void handle(Invocation invocation, AsyncResponse asyncResp); }
|
BizkeeperHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) { HystrixObservable<Response> command = delegate.createBizkeeperCommand(invocation); Observable<Response> observable = command.toObservable(); observable.subscribe(asyncResp::complete, error -> { LOG.warn("catch error in bizkeeper:" + error.getMessage()); asyncResp.fail(invocation.getInvocationType(), error); }, () -> { }); } BizkeeperHandler(String groupname); @Override void handle(Invocation invocation, AsyncResponse asyncResp); }
|
@Test public void testSetCommonProperties() { boolean validAssert; try { validAssert = true; HystrixPlugins.reset(); HystrixCommandProperties.Setter setter = Mockito.mock(HystrixCommandProperties.Setter.class); bizkeeperHandler.setCommonProperties(invocation, setter); } catch (Exception e) { validAssert = false; } Assert.assertTrue(validAssert); }
|
protected void setCommonProperties(Invocation invocation, HystrixCommandProperties.Setter setter) { }
|
BizkeeperHandler implements Handler { protected void setCommonProperties(Invocation invocation, HystrixCommandProperties.Setter setter) { } }
|
BizkeeperHandler implements Handler { protected void setCommonProperties(Invocation invocation, HystrixCommandProperties.Setter setter) { } BizkeeperHandler(String groupname); }
|
BizkeeperHandler implements Handler { protected void setCommonProperties(Invocation invocation, HystrixCommandProperties.Setter setter) { } BizkeeperHandler(String groupname); @Override void handle(Invocation invocation, AsyncResponse asyncResp); }
|
BizkeeperHandler implements Handler { protected void setCommonProperties(Invocation invocation, HystrixCommandProperties.Setter setter) { } BizkeeperHandler(String groupname); @Override void handle(Invocation invocation, AsyncResponse asyncResp); }
|
@Test public void init_enabled_default() { Holder<Boolean> registered = new Holder<>(false); new MockUp<EventBus>(eventBus) { @Mock void register(Object object) { registered.value = true; } }; publisher.init(globalRegistry, eventBus, new MetricsBootstrapConfig()); Assert.assertFalse(registered.value); }
|
@Override public void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config) { if (!DynamicPropertyFactory.getInstance() .getBooleanProperty(ENABLED, false) .get()) { return; } initLatencyDistribution(); eventBus.register(this); }
|
DefaultLogPublisher implements MetricsInitializer { @Override public void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config) { if (!DynamicPropertyFactory.getInstance() .getBooleanProperty(ENABLED, false) .get()) { return; } initLatencyDistribution(); eventBus.register(this); } }
|
DefaultLogPublisher implements MetricsInitializer { @Override public void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config) { if (!DynamicPropertyFactory.getInstance() .getBooleanProperty(ENABLED, false) .get()) { return; } initLatencyDistribution(); eventBus.register(this); } }
|
DefaultLogPublisher implements MetricsInitializer { @Override public void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config) { if (!DynamicPropertyFactory.getInstance() .getBooleanProperty(ENABLED, false) .get()) { return; } initLatencyDistribution(); eventBus.register(this); } @Override void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config); @Subscribe void onPolledEvent(PolledEvent event); }
|
DefaultLogPublisher implements MetricsInitializer { @Override public void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config) { if (!DynamicPropertyFactory.getInstance() .getBooleanProperty(ENABLED, false) .get()) { return; } initLatencyDistribution(); eventBus.register(this); } @Override void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config); @Subscribe void onPolledEvent(PolledEvent event); static final String ENABLED; static final String ENDPOINTS_CLIENT_DETAIL_ENABLED; }
|
@Test public void testBadPublishAddress_BadPort() { thrown.expect(ServiceCombException.class); ArchaiusUtils.setProperty(PrometheusPublisher.METRICS_PROMETHEUS_ADDRESS, "localhost:xxxx"); publisher.init(globalRegistry, null, null); }
|
@Override public void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config) { this.globalRegistry = globalRegistry; String address = DynamicPropertyFactory.getInstance().getStringProperty(METRICS_PROMETHEUS_ADDRESS, "0.0.0.0:9696").get(); try { InetSocketAddress socketAddress = getSocketAddress(address); register(); this.httpServer = new HTTPServer(socketAddress, CollectorRegistry.defaultRegistry, true); LOGGER.info("Prometheus httpServer listened : {}.", address); } catch (Exception e) { throw new ServiceCombException("create http publish server failed,may bad address : " + address, e); } }
|
PrometheusPublisher extends Collector implements Collector.Describable, MetricsInitializer { @Override public void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config) { this.globalRegistry = globalRegistry; String address = DynamicPropertyFactory.getInstance().getStringProperty(METRICS_PROMETHEUS_ADDRESS, "0.0.0.0:9696").get(); try { InetSocketAddress socketAddress = getSocketAddress(address); register(); this.httpServer = new HTTPServer(socketAddress, CollectorRegistry.defaultRegistry, true); LOGGER.info("Prometheus httpServer listened : {}.", address); } catch (Exception e) { throw new ServiceCombException("create http publish server failed,may bad address : " + address, e); } } }
|
PrometheusPublisher extends Collector implements Collector.Describable, MetricsInitializer { @Override public void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config) { this.globalRegistry = globalRegistry; String address = DynamicPropertyFactory.getInstance().getStringProperty(METRICS_PROMETHEUS_ADDRESS, "0.0.0.0:9696").get(); try { InetSocketAddress socketAddress = getSocketAddress(address); register(); this.httpServer = new HTTPServer(socketAddress, CollectorRegistry.defaultRegistry, true); LOGGER.info("Prometheus httpServer listened : {}.", address); } catch (Exception e) { throw new ServiceCombException("create http publish server failed,may bad address : " + address, e); } } }
|
PrometheusPublisher extends Collector implements Collector.Describable, MetricsInitializer { @Override public void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config) { this.globalRegistry = globalRegistry; String address = DynamicPropertyFactory.getInstance().getStringProperty(METRICS_PROMETHEUS_ADDRESS, "0.0.0.0:9696").get(); try { InetSocketAddress socketAddress = getSocketAddress(address); register(); this.httpServer = new HTTPServer(socketAddress, CollectorRegistry.defaultRegistry, true); LOGGER.info("Prometheus httpServer listened : {}.", address); } catch (Exception e) { throw new ServiceCombException("create http publish server failed,may bad address : " + address, e); } } @Override void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config); @Override List<MetricFamilySamples> describe(); @Override List<MetricFamilySamples> collect(); @Override void destroy(); }
|
PrometheusPublisher extends Collector implements Collector.Describable, MetricsInitializer { @Override public void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config) { this.globalRegistry = globalRegistry; String address = DynamicPropertyFactory.getInstance().getStringProperty(METRICS_PROMETHEUS_ADDRESS, "0.0.0.0:9696").get(); try { InetSocketAddress socketAddress = getSocketAddress(address); register(); this.httpServer = new HTTPServer(socketAddress, CollectorRegistry.defaultRegistry, true); LOGGER.info("Prometheus httpServer listened : {}.", address); } catch (Exception e) { throw new ServiceCombException("create http publish server failed,may bad address : " + address, e); } } @Override void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config); @Override List<MetricFamilySamples> describe(); @Override List<MetricFamilySamples> collect(); @Override void destroy(); }
|
@Test public void testHandleForceThrowException() throws Exception { Mockito.when(invocation.getMicroserviceName()).thenReturn("testHandleForceThrowException"); Mockito.when(invocation.getOperationMeta()).thenReturn(Mockito.mock(OperationMeta.class)); Mockito.when(invocation.getOperationMeta().getMicroserviceQualifiedName()) .thenReturn("testHandleForceThrowException"); System.setProperty("servicecomb.fallback.Group_Name.testHandleForceThrowException.force", "true"); System.setProperty("servicecomb.fallbackpolicy.Group_Name.testHandleForceThrowException.policy", "throwexception"); bizkeeperHandler.handle(invocation, f -> { Assert.assertTrue(f.isFailed()); }); }
|
@Override public void handle(Invocation invocation, AsyncResponse asyncResp) { HystrixObservable<Response> command = delegate.createBizkeeperCommand(invocation); Observable<Response> observable = command.toObservable(); observable.subscribe(asyncResp::complete, error -> { LOG.warn("catch error in bizkeeper:" + error.getMessage()); asyncResp.fail(invocation.getInvocationType(), error); }, () -> { }); }
|
BizkeeperHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) { HystrixObservable<Response> command = delegate.createBizkeeperCommand(invocation); Observable<Response> observable = command.toObservable(); observable.subscribe(asyncResp::complete, error -> { LOG.warn("catch error in bizkeeper:" + error.getMessage()); asyncResp.fail(invocation.getInvocationType(), error); }, () -> { }); } }
|
BizkeeperHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) { HystrixObservable<Response> command = delegate.createBizkeeperCommand(invocation); Observable<Response> observable = command.toObservable(); observable.subscribe(asyncResp::complete, error -> { LOG.warn("catch error in bizkeeper:" + error.getMessage()); asyncResp.fail(invocation.getInvocationType(), error); }, () -> { }); } BizkeeperHandler(String groupname); }
|
BizkeeperHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) { HystrixObservable<Response> command = delegate.createBizkeeperCommand(invocation); Observable<Response> observable = command.toObservable(); observable.subscribe(asyncResp::complete, error -> { LOG.warn("catch error in bizkeeper:" + error.getMessage()); asyncResp.fail(invocation.getInvocationType(), error); }, () -> { }); } BizkeeperHandler(String groupname); @Override void handle(Invocation invocation, AsyncResponse asyncResp); }
|
BizkeeperHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) { HystrixObservable<Response> command = delegate.createBizkeeperCommand(invocation); Observable<Response> observable = command.toObservable(); observable.subscribe(asyncResp::complete, error -> { LOG.warn("catch error in bizkeeper:" + error.getMessage()); asyncResp.fail(invocation.getInvocationType(), error); }, () -> { }); } BizkeeperHandler(String groupname); @Override void handle(Invocation invocation, AsyncResponse asyncResp); }
|
@Test public void testHandleForceReturnnull() throws Exception { Mockito.when(invocation.getMicroserviceName()).thenReturn("testHandleForceReturnnull"); Mockito.when(invocation.getOperationMeta()).thenReturn(Mockito.mock(OperationMeta.class)); Mockito.when(invocation.getOperationMeta().getMicroserviceQualifiedName()) .thenReturn("testHandleForceReturnnull"); System.setProperty("servicecomb.fallback.Group_Name.testHandleForceReturnnull.force", "true"); System.setProperty("servicecomb.fallbackpolicy.Group_Name.testHandleForceReturnnull.policy", "returnnull"); bizkeeperHandler.handle(invocation, f -> { Assert.assertTrue(f.isSuccessed()); Assert.assertNull(f.getResult()); }); }
|
@Override public void handle(Invocation invocation, AsyncResponse asyncResp) { HystrixObservable<Response> command = delegate.createBizkeeperCommand(invocation); Observable<Response> observable = command.toObservable(); observable.subscribe(asyncResp::complete, error -> { LOG.warn("catch error in bizkeeper:" + error.getMessage()); asyncResp.fail(invocation.getInvocationType(), error); }, () -> { }); }
|
BizkeeperHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) { HystrixObservable<Response> command = delegate.createBizkeeperCommand(invocation); Observable<Response> observable = command.toObservable(); observable.subscribe(asyncResp::complete, error -> { LOG.warn("catch error in bizkeeper:" + error.getMessage()); asyncResp.fail(invocation.getInvocationType(), error); }, () -> { }); } }
|
BizkeeperHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) { HystrixObservable<Response> command = delegate.createBizkeeperCommand(invocation); Observable<Response> observable = command.toObservable(); observable.subscribe(asyncResp::complete, error -> { LOG.warn("catch error in bizkeeper:" + error.getMessage()); asyncResp.fail(invocation.getInvocationType(), error); }, () -> { }); } BizkeeperHandler(String groupname); }
|
BizkeeperHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) { HystrixObservable<Response> command = delegate.createBizkeeperCommand(invocation); Observable<Response> observable = command.toObservable(); observable.subscribe(asyncResp::complete, error -> { LOG.warn("catch error in bizkeeper:" + error.getMessage()); asyncResp.fail(invocation.getInvocationType(), error); }, () -> { }); } BizkeeperHandler(String groupname); @Override void handle(Invocation invocation, AsyncResponse asyncResp); }
|
BizkeeperHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) { HystrixObservable<Response> command = delegate.createBizkeeperCommand(invocation); Observable<Response> observable = command.toObservable(); observable.subscribe(asyncResp::complete, error -> { LOG.warn("catch error in bizkeeper:" + error.getMessage()); asyncResp.fail(invocation.getInvocationType(), error); }, () -> { }); } BizkeeperHandler(String groupname); @Override void handle(Invocation invocation, AsyncResponse asyncResp); }
|
@Test public void testHandleInError() throws Exception { Mockito.when(invocation.getMicroserviceName()).thenReturn("testHandleInError"); Mockito.when(invocation.getOperationMeta()).thenReturn(Mockito.mock(OperationMeta.class)); Mockito.when(invocation.getOperationMeta().getMicroserviceQualifiedName()) .thenReturn("testHandleInError"); FallbackPolicy policy = Mockito.mock(FallbackPolicy.class); Mockito.when(policy.name()).thenReturn("throwException"); Mockito.when(policy.getFallbackResponse(Mockito.any(Invocation.class), Mockito.any(null))) .thenThrow(new RuntimeException()); FallbackPolicyManager.addPolicy(policy); System.setProperty("servicecomb.fallbackpolicy.groupname.testHandleInError.policy", "throwException"); Mockito.doAnswer(new Answer<Void>() { @Override public Void answer(InvocationOnMock invocation) { AsyncResponse asyncRsp = invocation.getArgumentAt(0, AsyncResponse.class); asyncRsp.fail(InvocationType.CONSUMER, new Exception("testHandleInError")); return null; } }).when(invocation).next(Mockito.any(AsyncResponse.class)); bizkeeperHandler.handle(invocation, f -> { Assert.assertTrue(f.isFailed()); }); }
|
@Override public void handle(Invocation invocation, AsyncResponse asyncResp) { HystrixObservable<Response> command = delegate.createBizkeeperCommand(invocation); Observable<Response> observable = command.toObservable(); observable.subscribe(asyncResp::complete, error -> { LOG.warn("catch error in bizkeeper:" + error.getMessage()); asyncResp.fail(invocation.getInvocationType(), error); }, () -> { }); }
|
BizkeeperHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) { HystrixObservable<Response> command = delegate.createBizkeeperCommand(invocation); Observable<Response> observable = command.toObservable(); observable.subscribe(asyncResp::complete, error -> { LOG.warn("catch error in bizkeeper:" + error.getMessage()); asyncResp.fail(invocation.getInvocationType(), error); }, () -> { }); } }
|
BizkeeperHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) { HystrixObservable<Response> command = delegate.createBizkeeperCommand(invocation); Observable<Response> observable = command.toObservable(); observable.subscribe(asyncResp::complete, error -> { LOG.warn("catch error in bizkeeper:" + error.getMessage()); asyncResp.fail(invocation.getInvocationType(), error); }, () -> { }); } BizkeeperHandler(String groupname); }
|
BizkeeperHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) { HystrixObservable<Response> command = delegate.createBizkeeperCommand(invocation); Observable<Response> observable = command.toObservable(); observable.subscribe(asyncResp::complete, error -> { LOG.warn("catch error in bizkeeper:" + error.getMessage()); asyncResp.fail(invocation.getInvocationType(), error); }, () -> { }); } BizkeeperHandler(String groupname); @Override void handle(Invocation invocation, AsyncResponse asyncResp); }
|
BizkeeperHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) { HystrixObservable<Response> command = delegate.createBizkeeperCommand(invocation); Observable<Response> observable = command.toObservable(); observable.subscribe(asyncResp::complete, error -> { LOG.warn("catch error in bizkeeper:" + error.getMessage()); asyncResp.fail(invocation.getInvocationType(), error); }, () -> { }); } BizkeeperHandler(String groupname); @Override void handle(Invocation invocation, AsyncResponse asyncResp); }
|
@Test public void testHandlNextException() throws Exception { Mockito.when(invocation.getMicroserviceName()).thenReturn("testHandlNextException"); Mockito.when(invocation.getOperationMeta()).thenReturn(Mockito.mock(OperationMeta.class)); Mockito.when(invocation.getOperationMeta().getMicroserviceQualifiedName()) .thenReturn("testHandlNextException"); Mockito.doThrow(new Exception("testHandlNextException")).when(invocation).next(Mockito.any(AsyncResponse.class)); bizkeeperHandler.handle(invocation, f -> { Assert.assertTrue(f.isFailed()); }); }
|
@Override public void handle(Invocation invocation, AsyncResponse asyncResp) { HystrixObservable<Response> command = delegate.createBizkeeperCommand(invocation); Observable<Response> observable = command.toObservable(); observable.subscribe(asyncResp::complete, error -> { LOG.warn("catch error in bizkeeper:" + error.getMessage()); asyncResp.fail(invocation.getInvocationType(), error); }, () -> { }); }
|
BizkeeperHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) { HystrixObservable<Response> command = delegate.createBizkeeperCommand(invocation); Observable<Response> observable = command.toObservable(); observable.subscribe(asyncResp::complete, error -> { LOG.warn("catch error in bizkeeper:" + error.getMessage()); asyncResp.fail(invocation.getInvocationType(), error); }, () -> { }); } }
|
BizkeeperHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) { HystrixObservable<Response> command = delegate.createBizkeeperCommand(invocation); Observable<Response> observable = command.toObservable(); observable.subscribe(asyncResp::complete, error -> { LOG.warn("catch error in bizkeeper:" + error.getMessage()); asyncResp.fail(invocation.getInvocationType(), error); }, () -> { }); } BizkeeperHandler(String groupname); }
|
BizkeeperHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) { HystrixObservable<Response> command = delegate.createBizkeeperCommand(invocation); Observable<Response> observable = command.toObservable(); observable.subscribe(asyncResp::complete, error -> { LOG.warn("catch error in bizkeeper:" + error.getMessage()); asyncResp.fail(invocation.getInvocationType(), error); }, () -> { }); } BizkeeperHandler(String groupname); @Override void handle(Invocation invocation, AsyncResponse asyncResp); }
|
BizkeeperHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) { HystrixObservable<Response> command = delegate.createBizkeeperCommand(invocation); Observable<Response> observable = command.toObservable(); observable.subscribe(asyncResp::complete, error -> { LOG.warn("catch error in bizkeeper:" + error.getMessage()); asyncResp.fail(invocation.getInvocationType(), error); }, () -> { }); } BizkeeperHandler(String groupname); @Override void handle(Invocation invocation, AsyncResponse asyncResp); }
|
@Test public void testHandleSuccess() throws Exception { Mockito.when(invocation.getMicroserviceName()).thenReturn("testHandleSuccess"); Mockito.when(invocation.getOperationMeta()).thenReturn(Mockito.mock(OperationMeta.class)); Mockito.when(invocation.getOperationMeta().getMicroserviceQualifiedName()) .thenReturn("testHandleSuccess"); Mockito.doAnswer(new Answer<Void>() { @Override public Void answer(InvocationOnMock invocation) { AsyncResponse asyncRsp = invocation.getArgumentAt(0, AsyncResponse.class); asyncRsp.success(""); return null; } }).when(invocation).next(Mockito.any(AsyncResponse.class)); bizkeeperHandler.handle(invocation, f -> { Assert.assertTrue(f.isSuccessed()); }); }
|
@Override public void handle(Invocation invocation, AsyncResponse asyncResp) { HystrixObservable<Response> command = delegate.createBizkeeperCommand(invocation); Observable<Response> observable = command.toObservable(); observable.subscribe(asyncResp::complete, error -> { LOG.warn("catch error in bizkeeper:" + error.getMessage()); asyncResp.fail(invocation.getInvocationType(), error); }, () -> { }); }
|
BizkeeperHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) { HystrixObservable<Response> command = delegate.createBizkeeperCommand(invocation); Observable<Response> observable = command.toObservable(); observable.subscribe(asyncResp::complete, error -> { LOG.warn("catch error in bizkeeper:" + error.getMessage()); asyncResp.fail(invocation.getInvocationType(), error); }, () -> { }); } }
|
BizkeeperHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) { HystrixObservable<Response> command = delegate.createBizkeeperCommand(invocation); Observable<Response> observable = command.toObservable(); observable.subscribe(asyncResp::complete, error -> { LOG.warn("catch error in bizkeeper:" + error.getMessage()); asyncResp.fail(invocation.getInvocationType(), error); }, () -> { }); } BizkeeperHandler(String groupname); }
|
BizkeeperHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) { HystrixObservable<Response> command = delegate.createBizkeeperCommand(invocation); Observable<Response> observable = command.toObservable(); observable.subscribe(asyncResp::complete, error -> { LOG.warn("catch error in bizkeeper:" + error.getMessage()); asyncResp.fail(invocation.getInvocationType(), error); }, () -> { }); } BizkeeperHandler(String groupname); @Override void handle(Invocation invocation, AsyncResponse asyncResp); }
|
BizkeeperHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) { HystrixObservable<Response> command = delegate.createBizkeeperCommand(invocation); Observable<Response> observable = command.toObservable(); observable.subscribe(asyncResp::complete, error -> { LOG.warn("catch error in bizkeeper:" + error.getMessage()); asyncResp.fail(invocation.getInvocationType(), error); }, () -> { }); } BizkeeperHandler(String groupname); @Override void handle(Invocation invocation, AsyncResponse asyncResp); }
|
@Test public void testConfiguration() { assertNotNull(Configuration.INSTANCE); assertEquals("returnnull", Configuration.FALLBACKPOLICY_POLICY_RETURN); assertEquals("throwexception", Configuration.FALLBACKPOLICY_POLICY_THROW); Configuration c = Configuration.INSTANCE; Invocation invocation = Mockito.mock(Invocation.class); String test2 = invocation.getMicroserviceName(); Mockito.when(invocation.getOperationMeta()).thenReturn(Mockito.mock(OperationMeta.class)); Mockito.when(invocation.getOperationMeta().getMicroserviceName()).thenReturn("testqualify"); int res = c.getIsolationTimeoutInMilliseconds("groupname", test2, "testqualify"); assertEquals(30000, res); boolean b1 = c.getIsolationTimeoutEnabled("groupname", test2, "testqualify"); assertFalse(b1); int res1 = c.getIsolationMaxConcurrentRequests("groupname", test2, "testqualify"); assertEquals(1000, res1); boolean b2 = c.isCircuitBreakerEnabled("groupname", test2, "testqualify"); assertTrue(b2); String str = c.getFallbackPolicyPolicy("groupname", test2, "testqualify"); assertEquals(null, str); assertFalse(c.isCircuitBreakerForceOpen("groupname", test2, "testqualify")); assertFalse(c.isCircuitBreakerForceClosed("groupname", test2, "testqualify")); assertEquals(15000, c.getCircuitBreakerSleepWindowInMilliseconds("groupname", test2, "testqualify")); assertEquals(20, c.getCircuitBreakerRequestVolumeThreshold("groupname", test2, "testqualify")); assertEquals(50, c.getCircuitBreakerErrorThresholdPercentage("groupname", test2, "testqualify")); assertTrue(c.isFallbackEnabled("groupname", test2, "testqualify")); }
|
private Configuration() { }
|
Configuration { private Configuration() { } }
|
Configuration { private Configuration() { } private Configuration(); }
|
Configuration { private Configuration() { } private Configuration(); int getIsolationTimeoutInMilliseconds(String type, String microserviceName,
String qualifiedOperationName); boolean getIsolationTimeoutEnabled(String type, String microserviceName,
String qualifiedOperationName); int getIsolationMaxConcurrentRequests(String type, String microserviceName,
String qualifiedOperationName); boolean isCircuitBreakerEnabled(String type, String microserviceName, String qualifiedOperationName); boolean isCircuitBreakerForceOpen(String type, String microserviceName, String qualifiedOperationName); boolean isCircuitBreakerForceClosed(String type, String microserviceName, String qualifiedOperationName); int getCircuitBreakerSleepWindowInMilliseconds(String type, String microserviceName,
String qualifiedOperationName); int getCircuitBreakerRequestVolumeThreshold(String type, String microserviceName,
String qualifiedOperationName); int getCircuitBreakerErrorThresholdPercentage(String type, String microserviceName,
String qualifiedOperationName); boolean isFallbackEnabled(String type, String microserviceName, String qualifiedOperationName); boolean isFallbackForce(String type, String microserviceName, String qualifiedOperationName); int getFallbackMaxConcurrentRequests(String type, String microserviceName, String qualifiedOperationName); String getFallbackPolicyPolicy(String type, String microserviceName, String qualifiedOperationName); }
|
Configuration { private Configuration() { } private Configuration(); int getIsolationTimeoutInMilliseconds(String type, String microserviceName,
String qualifiedOperationName); boolean getIsolationTimeoutEnabled(String type, String microserviceName,
String qualifiedOperationName); int getIsolationMaxConcurrentRequests(String type, String microserviceName,
String qualifiedOperationName); boolean isCircuitBreakerEnabled(String type, String microserviceName, String qualifiedOperationName); boolean isCircuitBreakerForceOpen(String type, String microserviceName, String qualifiedOperationName); boolean isCircuitBreakerForceClosed(String type, String microserviceName, String qualifiedOperationName); int getCircuitBreakerSleepWindowInMilliseconds(String type, String microserviceName,
String qualifiedOperationName); int getCircuitBreakerRequestVolumeThreshold(String type, String microserviceName,
String qualifiedOperationName); int getCircuitBreakerErrorThresholdPercentage(String type, String microserviceName,
String qualifiedOperationName); boolean isFallbackEnabled(String type, String microserviceName, String qualifiedOperationName); boolean isFallbackForce(String type, String microserviceName, String qualifiedOperationName); int getFallbackMaxConcurrentRequests(String type, String microserviceName, String qualifiedOperationName); String getFallbackPolicyPolicy(String type, String microserviceName, String qualifiedOperationName); static final String FALLBACKPOLICY_POLICY_THROW; static final String FALLBACKPOLICY_POLICY_RETURN; static final Configuration INSTANCE; }
|
@Test public void testCreateBizkeeperException() { Assert.assertEquals("servicecomb.bizkeeper.fallback", BizkeeperExceptionUtils.SERVICECOMB_BIZKEEPER_FALLBACK); CseException cseException = BizkeeperExceptionUtils.createBizkeeperException("servicecomb.bizkeeper.fallback", new Throwable(), "ARGS"); Assert.assertNotNull(cseException); }
|
public static CseException createBizkeeperException(String code, Throwable cause, Object... args) { String msg = String.format(ERROR_DESC_MGR.ensureFindValue(code), args); return new CseException(code, msg, cause); }
|
BizkeeperExceptionUtils extends ExceptionUtils { public static CseException createBizkeeperException(String code, Throwable cause, Object... args) { String msg = String.format(ERROR_DESC_MGR.ensureFindValue(code), args); return new CseException(code, msg, cause); } }
|
BizkeeperExceptionUtils extends ExceptionUtils { public static CseException createBizkeeperException(String code, Throwable cause, Object... args) { String msg = String.format(ERROR_DESC_MGR.ensureFindValue(code), args); return new CseException(code, msg, cause); } private BizkeeperExceptionUtils(); }
|
BizkeeperExceptionUtils extends ExceptionUtils { public static CseException createBizkeeperException(String code, Throwable cause, Object... args) { String msg = String.format(ERROR_DESC_MGR.ensureFindValue(code), args); return new CseException(code, msg, cause); } private BizkeeperExceptionUtils(); static CseException createBizkeeperException(String code, Throwable cause, Object... args); }
|
BizkeeperExceptionUtils extends ExceptionUtils { public static CseException createBizkeeperException(String code, Throwable cause, Object... args) { String msg = String.format(ERROR_DESC_MGR.ensureFindValue(code), args); return new CseException(code, msg, cause); } private BizkeeperExceptionUtils(); static CseException createBizkeeperException(String code, Throwable cause, Object... args); static final String SERVICECOMB_BIZKEEPER_FALLBACK; }
|
@Test public void testGetCommandPropertiesCacheKey() { assertNotNull(HystrixPropertiesStrategyExt.getInstance()); HystrixPropertiesStrategyExt hps = HystrixPropertiesStrategyExt.getInstance(); HystrixCommandKey commandKey = Mockito.mock(HystrixCommandKey.class); Invocation invocation = Mockito.mock(Invocation.class); Mockito.when(invocation.getOperationMeta()).thenReturn(Mockito.mock(OperationMeta.class)); Mockito.when(invocation.getOperationMeta().getMicroserviceName()).thenReturn("testqualify"); HystrixCommandProperties.Setter setter = HystrixCommandProperties.Setter() .withRequestCacheEnabled(true) .withRequestLogEnabled(false) .withFallbackIsolationSemaphoreMaxConcurrentRequests( Configuration.INSTANCE.getFallbackMaxConcurrentRequests("groupname", "testing", invocation.getOperationMeta().getMicroserviceQualifiedName())); String str1 = hps.getCommandPropertiesCacheKey(commandKey, setter); Assert.assertNull(str1); }
|
public static HystrixPropertiesStrategyExt getInstance() { return INSTANCE; }
|
HystrixPropertiesStrategyExt extends HystrixPropertiesStrategy { public static HystrixPropertiesStrategyExt getInstance() { return INSTANCE; } }
|
HystrixPropertiesStrategyExt extends HystrixPropertiesStrategy { public static HystrixPropertiesStrategyExt getInstance() { return INSTANCE; } private HystrixPropertiesStrategyExt(); }
|
HystrixPropertiesStrategyExt extends HystrixPropertiesStrategy { public static HystrixPropertiesStrategyExt getInstance() { return INSTANCE; } private HystrixPropertiesStrategyExt(); static HystrixPropertiesStrategyExt getInstance(); @Override HystrixCommandProperties getCommandProperties(HystrixCommandKey commandKey, Setter builder); }
|
HystrixPropertiesStrategyExt extends HystrixPropertiesStrategy { public static HystrixPropertiesStrategyExt getInstance() { return INSTANCE; } private HystrixPropertiesStrategyExt(); static HystrixPropertiesStrategyExt getInstance(); @Override HystrixCommandProperties getCommandProperties(HystrixCommandKey commandKey, Setter builder); }
|
@Test public void testgetCommandProperties() { HystrixCommandKey commandKey = Mockito.mock(HystrixCommandKey.class); Mockito.when(commandKey.name()) .thenReturn("provider.HystrixPropertiesStrategyExtTest.testgetCommandProperties"); HystrixCommandProperties commandPro = HystrixPropertiesStrategyExt.getInstance() .getCommandProperties(commandKey, HystrixCommandProperties.Setter()); Assert.assertTrue(commandPro.circuitBreakerEnabled().get()); Assert.assertEquals(Integer.valueOf(50), commandPro.circuitBreakerErrorThresholdPercentage().get()); Assert.assertFalse(commandPro.circuitBreakerForceClosed().get()); Assert.assertFalse(commandPro.circuitBreakerForceOpen().get()); Assert.assertEquals(Integer.valueOf(20), commandPro.circuitBreakerRequestVolumeThreshold().get()); Assert.assertEquals(Integer.valueOf(15000), commandPro.circuitBreakerSleepWindowInMilliseconds().get()); Assert.assertEquals(Integer.valueOf(1000), commandPro.executionIsolationSemaphoreMaxConcurrentRequests().get()); Assert.assertTrue(commandPro.executionIsolationThreadInterruptOnTimeout().get()); Assert.assertEquals(null, commandPro.executionIsolationThreadPoolKeyOverride().get()); Assert.assertEquals(Integer.valueOf(30000), commandPro.executionTimeoutInMilliseconds().get()); Assert.assertFalse(commandPro.executionTimeoutEnabled().get()); Assert.assertEquals(Integer.valueOf(10), commandPro.fallbackIsolationSemaphoreMaxConcurrentRequests().get()); Assert.assertTrue(commandPro.fallbackEnabled().get()); Assert.assertEquals(Integer.valueOf(100), commandPro.metricsRollingPercentileBucketSize().get()); Assert.assertFalse(commandPro.metricsRollingPercentileEnabled().get()); }
|
@Override public HystrixCommandProperties getCommandProperties(HystrixCommandKey commandKey, Setter builder) { HystrixCommandProperties commandProperties = commandPropertiesMap.get(commandKey.name()); if (commandProperties == null) { commandProperties = new HystrixCommandPropertiesExt(commandKey, builder); commandPropertiesMap.putIfAbsent(commandKey.name(), commandProperties); } return commandProperties; }
|
HystrixPropertiesStrategyExt extends HystrixPropertiesStrategy { @Override public HystrixCommandProperties getCommandProperties(HystrixCommandKey commandKey, Setter builder) { HystrixCommandProperties commandProperties = commandPropertiesMap.get(commandKey.name()); if (commandProperties == null) { commandProperties = new HystrixCommandPropertiesExt(commandKey, builder); commandPropertiesMap.putIfAbsent(commandKey.name(), commandProperties); } return commandProperties; } }
|
HystrixPropertiesStrategyExt extends HystrixPropertiesStrategy { @Override public HystrixCommandProperties getCommandProperties(HystrixCommandKey commandKey, Setter builder) { HystrixCommandProperties commandProperties = commandPropertiesMap.get(commandKey.name()); if (commandProperties == null) { commandProperties = new HystrixCommandPropertiesExt(commandKey, builder); commandPropertiesMap.putIfAbsent(commandKey.name(), commandProperties); } return commandProperties; } private HystrixPropertiesStrategyExt(); }
|
HystrixPropertiesStrategyExt extends HystrixPropertiesStrategy { @Override public HystrixCommandProperties getCommandProperties(HystrixCommandKey commandKey, Setter builder) { HystrixCommandProperties commandProperties = commandPropertiesMap.get(commandKey.name()); if (commandProperties == null) { commandProperties = new HystrixCommandPropertiesExt(commandKey, builder); commandPropertiesMap.putIfAbsent(commandKey.name(), commandProperties); } return commandProperties; } private HystrixPropertiesStrategyExt(); static HystrixPropertiesStrategyExt getInstance(); @Override HystrixCommandProperties getCommandProperties(HystrixCommandKey commandKey, Setter builder); }
|
HystrixPropertiesStrategyExt extends HystrixPropertiesStrategy { @Override public HystrixCommandProperties getCommandProperties(HystrixCommandKey commandKey, Setter builder) { HystrixCommandProperties commandProperties = commandPropertiesMap.get(commandKey.name()); if (commandProperties == null) { commandProperties = new HystrixCommandPropertiesExt(commandKey, builder); commandPropertiesMap.putIfAbsent(commandKey.name(), commandProperties); } return commandProperties; } private HystrixPropertiesStrategyExt(); static HystrixPropertiesStrategyExt getInstance(); @Override HystrixCommandProperties getCommandProperties(HystrixCommandKey commandKey, Setter builder); }
|
@Test public void testMarkEvent() { Mockito.when(commandKey.name()).thenReturn("Consumer.springmvc.springmvcHello.sayHi"); new Expectations(HystrixCommandMetrics.class) { { HystrixCommandMetrics.getInstance(commandKey); result = null; } }; circutBreakerEventNotifier.markEvent(HystrixEventType.SHORT_CIRCUITED, commandKey); Assert.assertEquals(1, taskList.size()); circutBreakerEventNotifier.markEvent(HystrixEventType.SUCCESS, commandKey); Assert.assertEquals(2, taskList.size()); }
|
@Override public void markEvent(HystrixEventType eventType, HystrixCommandKey key) { String keyName = key.name(); AtomicBoolean flag = circuitFlag.computeIfAbsent(keyName, k -> new AtomicBoolean()); switch (eventType) { case SHORT_CIRCUITED: if (flag.compareAndSet(false, true)) { eventBus.post(new CircutBreakerEvent(key, Type.OPEN)); } break; case SUCCESS: if (flag.compareAndSet(true, false)) { eventBus.post(new CircutBreakerEvent(key, Type.CLOSE)); } break; default: break; } }
|
CircutBreakerEventNotifier extends HystrixEventNotifier { @Override public void markEvent(HystrixEventType eventType, HystrixCommandKey key) { String keyName = key.name(); AtomicBoolean flag = circuitFlag.computeIfAbsent(keyName, k -> new AtomicBoolean()); switch (eventType) { case SHORT_CIRCUITED: if (flag.compareAndSet(false, true)) { eventBus.post(new CircutBreakerEvent(key, Type.OPEN)); } break; case SUCCESS: if (flag.compareAndSet(true, false)) { eventBus.post(new CircutBreakerEvent(key, Type.CLOSE)); } break; default: break; } } }
|
CircutBreakerEventNotifier extends HystrixEventNotifier { @Override public void markEvent(HystrixEventType eventType, HystrixCommandKey key) { String keyName = key.name(); AtomicBoolean flag = circuitFlag.computeIfAbsent(keyName, k -> new AtomicBoolean()); switch (eventType) { case SHORT_CIRCUITED: if (flag.compareAndSet(false, true)) { eventBus.post(new CircutBreakerEvent(key, Type.OPEN)); } break; case SUCCESS: if (flag.compareAndSet(true, false)) { eventBus.post(new CircutBreakerEvent(key, Type.CLOSE)); } break; default: break; } } }
|
CircutBreakerEventNotifier extends HystrixEventNotifier { @Override public void markEvent(HystrixEventType eventType, HystrixCommandKey key) { String keyName = key.name(); AtomicBoolean flag = circuitFlag.computeIfAbsent(keyName, k -> new AtomicBoolean()); switch (eventType) { case SHORT_CIRCUITED: if (flag.compareAndSet(false, true)) { eventBus.post(new CircutBreakerEvent(key, Type.OPEN)); } break; case SUCCESS: if (flag.compareAndSet(true, false)) { eventBus.post(new CircutBreakerEvent(key, Type.CLOSE)); } break; default: break; } } @Override void markEvent(HystrixEventType eventType, HystrixCommandKey key); }
|
CircutBreakerEventNotifier extends HystrixEventNotifier { @Override public void markEvent(HystrixEventType eventType, HystrixCommandKey key) { String keyName = key.name(); AtomicBoolean flag = circuitFlag.computeIfAbsent(keyName, k -> new AtomicBoolean()); switch (eventType) { case SHORT_CIRCUITED: if (flag.compareAndSet(false, true)) { eventBus.post(new CircutBreakerEvent(key, Type.OPEN)); } break; case SUCCESS: if (flag.compareAndSet(true, false)) { eventBus.post(new CircutBreakerEvent(key, Type.CLOSE)); } break; default: break; } } @Override void markEvent(HystrixEventType eventType, HystrixCommandKey key); }
|
@Test public void init_enabled_true() { Holder<Boolean> registered = new Holder<>(); new MockUp<EventBus>(eventBus) { @Mock void register(Object object) { registered.value = true; } }; ArchaiusUtils.setProperty(DefaultLogPublisher.ENABLED, true); publisher.init(globalRegistry, eventBus, new MetricsBootstrapConfig()); Assert.assertTrue(registered.value); }
|
@Override public void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config) { if (!DynamicPropertyFactory.getInstance() .getBooleanProperty(ENABLED, false) .get()) { return; } initLatencyDistribution(); eventBus.register(this); }
|
DefaultLogPublisher implements MetricsInitializer { @Override public void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config) { if (!DynamicPropertyFactory.getInstance() .getBooleanProperty(ENABLED, false) .get()) { return; } initLatencyDistribution(); eventBus.register(this); } }
|
DefaultLogPublisher implements MetricsInitializer { @Override public void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config) { if (!DynamicPropertyFactory.getInstance() .getBooleanProperty(ENABLED, false) .get()) { return; } initLatencyDistribution(); eventBus.register(this); } }
|
DefaultLogPublisher implements MetricsInitializer { @Override public void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config) { if (!DynamicPropertyFactory.getInstance() .getBooleanProperty(ENABLED, false) .get()) { return; } initLatencyDistribution(); eventBus.register(this); } @Override void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config); @Subscribe void onPolledEvent(PolledEvent event); }
|
DefaultLogPublisher implements MetricsInitializer { @Override public void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config) { if (!DynamicPropertyFactory.getInstance() .getBooleanProperty(ENABLED, false) .get()) { return; } initLatencyDistribution(); eventBus.register(this); } @Override void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config); @Subscribe void onPolledEvent(PolledEvent event); static final String ENABLED; static final String ENDPOINTS_CLIENT_DETAIL_ENABLED; }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.