src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
ProtocolConfig extends AbstractConfig { public void destroy() { if (name != null) { ExtensionLoader.getExtensionLoader(Protocol.class).getExtension(name).destroy(); } } ProtocolConfig(); ProtocolConfig(String name); ProtocolConfig(String name, int port); @Parameter(excluded = true) String getName(); final void setName(String name); @Parameter(excluded = true) String getHost(); void setHost(String host); @Parameter(excluded = true) Integer getPort(); final void setPort(Integer port); @Deprecated @Parameter(excluded = true) String getPath(); @Deprecated void setPath(String path); @Parameter(excluded = true) String getContextpath(); void setContextpath(String contextpath); String getThreadpool(); void setThreadpool(String threadpool); Integer getCorethreads(); void setCorethreads(Integer corethreads); Integer getThreads(); void setThreads(Integer threads); Integer getIothreads(); void setIothreads(Integer iothreads); Integer getQueues(); void setQueues(Integer queues); Integer getAccepts(); void setAccepts(Integer accepts); String getCodec(); void setCodec(String codec); String getSerialization(); void setSerialization(String serialization); String getCharset(); void setCharset(String charset); Integer getPayload(); void setPayload(Integer payload); Integer getBuffer(); void setBuffer(Integer buffer); Integer getHeartbeat(); void setHeartbeat(Integer heartbeat); String getServer(); void setServer(String server); String getClient(); void setClient(String client); String getAccesslog(); void setAccesslog(String accesslog); String getTelnet(); void setTelnet(String telnet); @Parameter(escaped = true) String getPrompt(); void setPrompt(String prompt); String getStatus(); void setStatus(String status); Boolean isRegister(); void setRegister(Boolean register); String getTransporter(); void setTransporter(String transporter); String getExchanger(); void setExchanger(String exchanger); @Deprecated @Parameter(excluded = true) String getDispather(); @Deprecated void setDispather(String dispather); String getDispatcher(); void setDispatcher(String dispatcher); String getNetworker(); void setNetworker(String networker); Map<String, String> getParameters(); void setParameters(Map<String, String> parameters); Boolean isDefault(); void setDefault(Boolean isDefault); Boolean getKeepAlive(); void setKeepAlive(Boolean keepAlive); String getOptimizer(); void setOptimizer(String optimizer); String getExtension(); void setExtension(String extension); void destroy(); @Override void refresh(); @Override @Parameter(excluded = true) boolean isValid(); } | @Test public void testDestroy() throws Exception { Protocol protocol = Mockito.mock(Protocol.class); MockProtocol2.delegate = protocol; ProtocolConfig protocolConfig = new ProtocolConfig(); protocolConfig.setName("mockprotocol2"); protocolConfig.destroy(); Mockito.verify(protocol).destroy(); } |
AbstractConfig implements Serializable { protected static void appendParameters(Map<String, String> parameters, Object config) { appendParameters(parameters, config, null); } @Parameter(excluded = true) String getId(); void setId(String id); void updateIdIfAbsent(String value); Map<String, String> getMetaData(); @Parameter(excluded = true) String getPrefix(); void setPrefix(String prefix); void refresh(); @Override String toString(); @Parameter(excluded = true) boolean isValid(); @Override boolean equals(Object obj); } | @Test public void testAppendParameters1() throws Exception { Map<String, String> parameters = new HashMap<String, String>(); parameters.put("default.num", "one"); parameters.put("num", "ONE"); AbstractConfig.appendParameters(parameters, new ParameterConfig(1, "hello/world", 30, "password"), "prefix"); Assertions.assertEquals("one", parameters.get("prefix.key.1")); Assertions.assertEquals("two", parameters.get("prefix.key.2")); Assertions.assertEquals("ONE,one,1", parameters.get("prefix.num")); Assertions.assertEquals("hello%2Fworld", parameters.get("prefix.naming")); Assertions.assertEquals("30", parameters.get("prefix.age")); Assertions.assertFalse(parameters.containsKey("prefix.key-2")); Assertions.assertFalse(parameters.containsKey("prefix.secret")); }
@Test public void testAppendParameters2() throws Exception { Assertions.assertThrows(IllegalStateException.class, () -> { Map<String, String> parameters = new HashMap<String, String>(); AbstractConfig.appendParameters(parameters, new ParameterConfig()); }); }
@Test public void testAppendParameters3() throws Exception { Map<String, String> parameters = new HashMap<String, String>(); AbstractConfig.appendParameters(parameters, null); assertTrue(parameters.isEmpty()); }
@Test public void testAppendParameters4() throws Exception { Map<String, String> parameters = new HashMap<String, String>(); AbstractConfig.appendParameters(parameters, new ParameterConfig(1, "hello/world", 30, "password")); Assertions.assertEquals("one", parameters.get("key.1")); Assertions.assertEquals("two", parameters.get("key.2")); Assertions.assertEquals("1", parameters.get("num")); Assertions.assertEquals("hello%2Fworld", parameters.get("naming")); Assertions.assertEquals("30", parameters.get("age")); } |
AbstractConfig implements Serializable { protected static void appendAttributes(Map<String, Object> parameters, Object config) { appendAttributes(parameters, config, null); } @Parameter(excluded = true) String getId(); void setId(String id); void updateIdIfAbsent(String value); Map<String, String> getMetaData(); @Parameter(excluded = true) String getPrefix(); void setPrefix(String prefix); void refresh(); @Override String toString(); @Parameter(excluded = true) boolean isValid(); @Override boolean equals(Object obj); } | @Test public void testAppendAttributes1() throws Exception { Map<String, Object> parameters = new HashMap<String, Object>(); AbstractConfig.appendAttributes(parameters, new AttributeConfig('l', true, (byte) 0x01), "prefix"); Assertions.assertEquals('l', parameters.get("prefix.let")); Assertions.assertEquals(true, parameters.get("prefix.activate")); Assertions.assertFalse(parameters.containsKey("prefix.flag")); }
@Test public void testAppendAttributes2() throws Exception { Map<String, Object> parameters = new HashMap<String, Object>(); AbstractConfig.appendAttributes(parameters, new AttributeConfig('l', true, (byte) 0x01)); Assertions.assertEquals('l', parameters.get("let")); Assertions.assertEquals(true, parameters.get("activate")); Assertions.assertFalse(parameters.containsKey("flag")); } |
AbstractConfig implements Serializable { protected static void checkExtension(Class<?> type, String property, String value) { checkName(property, value); if (StringUtils.isNotEmpty(value) && !ExtensionLoader.getExtensionLoader(type).hasExtension(value)) { throw new IllegalStateException("No such extension " + value + " for " + property + "/" + type.getName()); } } @Parameter(excluded = true) String getId(); void setId(String id); void updateIdIfAbsent(String value); Map<String, String> getMetaData(); @Parameter(excluded = true) String getPrefix(); void setPrefix(String prefix); void refresh(); @Override String toString(); @Parameter(excluded = true) boolean isValid(); @Override boolean equals(Object obj); } | @Test public void checkExtension() throws Exception { Assertions.assertThrows(IllegalStateException.class, () -> AbstractConfig.checkExtension(Greeting.class, "hello", "world")); } |
AbstractConfig implements Serializable { protected static void checkMultiExtension(Class<?> type, String property, String value) { checkMultiName(property, value); if (StringUtils.isNotEmpty(value)) { String[] values = value.split("\\s*[,]+\\s*"); for (String v : values) { if (v.startsWith(Constants.REMOVE_VALUE_PREFIX)) { v = v.substring(1); } if (Constants.DEFAULT_KEY.equals(v)) { continue; } if (!ExtensionLoader.getExtensionLoader(type).hasExtension(v)) { throw new IllegalStateException("No such extension " + v + " for " + property + "/" + type.getName()); } } } } @Parameter(excluded = true) String getId(); void setId(String id); void updateIdIfAbsent(String value); Map<String, String> getMetaData(); @Parameter(excluded = true) String getPrefix(); void setPrefix(String prefix); void refresh(); @Override String toString(); @Parameter(excluded = true) boolean isValid(); @Override boolean equals(Object obj); } | @Test public void checkMultiExtension1() throws Exception { Assertions.assertThrows(IllegalStateException.class, () -> AbstractConfig.checkMultiExtension(Greeting.class, "hello", "default,world")); }
@Test public void checkMultiExtension2() throws Exception { Assertions.assertThrows(IllegalStateException.class, () -> AbstractConfig.checkMultiExtension(Greeting.class, "hello", "default,-world")); } |
RpcContext { public static RpcContext getContext() { return LOCAL.get(); } protected RpcContext(); static RpcContext getServerContext(); static void restoreServerContext(RpcContext oldServerContext); static void removeServerContext(); static RpcContext getContext(); static void restoreContext(RpcContext oldContext); RpcContext copyOf(); static void removeContext(); Object getRequest(); void setRequest(Object request); @SuppressWarnings("unchecked") T getRequest(Class<T> clazz); Object getResponse(); void setResponse(Object response); @SuppressWarnings("unchecked") T getResponse(Class<T> clazz); boolean isProviderSide(); boolean isConsumerSide(); @SuppressWarnings("unchecked") CompletableFuture<T> getCompletableFuture(); @SuppressWarnings("unchecked") Future<T> getFuture(); void setFuture(Future<?> future); List<URL> getUrls(); void setUrls(List<URL> urls); URL getUrl(); void setUrl(URL url); String getMethodName(); void setMethodName(String methodName); Class<?>[] getParameterTypes(); void setParameterTypes(Class<?>[] parameterTypes); Object[] getArguments(); void setArguments(Object[] arguments); RpcContext setLocalAddress(String host, int port); InetSocketAddress getLocalAddress(); RpcContext setLocalAddress(InetSocketAddress address); String getLocalAddressString(); String getLocalHostName(); RpcContext setRemoteAddress(String host, int port); InetSocketAddress getRemoteAddress(); RpcContext setRemoteAddress(InetSocketAddress address); String getRemoteApplicationName(); RpcContext setRemoteApplicationName(String remoteApplicationName); String getRemoteAddressString(); String getRemoteHostName(); String getLocalHost(); int getLocalPort(); String getRemoteHost(); int getRemotePort(); String getAttachment(String key); RpcContext setAttachment(String key, String value); RpcContext removeAttachment(String key); Map<String, String> getAttachments(); RpcContext setAttachments(Map<String, String> attachment); void clearAttachments(); Map<String, Object> get(); RpcContext set(String key, Object value); RpcContext remove(String key); Object get(String key); @Deprecated boolean isServerSide(); @Deprecated boolean isClientSide(); @Deprecated @SuppressWarnings({"unchecked", "rawtypes"}) List<Invoker<?>> getInvokers(); RpcContext setInvokers(List<Invoker<?>> invokers); @Deprecated Invoker<?> getInvoker(); RpcContext setInvoker(Invoker<?> invoker); @Deprecated Invocation getInvocation(); RpcContext setInvocation(Invocation invocation); @SuppressWarnings("unchecked") CompletableFuture<T> asyncCall(Callable<T> callable); void asyncCall(Runnable runnable); @SuppressWarnings("unchecked") static AsyncContext startAsync(); boolean isAsyncStarted(); boolean stopAsync(); AsyncContext getAsyncContext(); } | @Test public void testGetContext() { RpcContext rpcContext = RpcContext.getContext(); Assertions.assertNotNull(rpcContext); RpcContext.removeContext(); Assertions.assertNotNull(RpcContext.getContext()); Assertions.assertNotEquals(rpcContext, RpcContext.getContext()); RpcContext serverRpcContext = RpcContext.getServerContext(); Assertions.assertNotNull(serverRpcContext); RpcContext.removeServerContext(); Assertions.assertNotEquals(serverRpcContext, RpcContext.getServerContext()); } |
AbstractConfig implements Serializable { protected static void checkLength(String property, String value) { checkProperty(property, value, MAX_LENGTH, null); } @Parameter(excluded = true) String getId(); void setId(String id); void updateIdIfAbsent(String value); Map<String, String> getMetaData(); @Parameter(excluded = true) String getPrefix(); void setPrefix(String prefix); void refresh(); @Override String toString(); @Parameter(excluded = true) boolean isValid(); @Override boolean equals(Object obj); } | @Test public void checkLength() throws Exception { Assertions.assertThrows(IllegalStateException.class, () -> { StringBuilder builder = new StringBuilder(); for (int i = 0; i <= 200; i++) { builder.append("a"); } AbstractConfig.checkLength("hello", builder.toString()); }); } |
AbstractConfig implements Serializable { protected static void checkPathLength(String property, String value) { checkProperty(property, value, MAX_PATH_LENGTH, null); } @Parameter(excluded = true) String getId(); void setId(String id); void updateIdIfAbsent(String value); Map<String, String> getMetaData(); @Parameter(excluded = true) String getPrefix(); void setPrefix(String prefix); void refresh(); @Override String toString(); @Parameter(excluded = true) boolean isValid(); @Override boolean equals(Object obj); } | @Test public void checkPathLength() throws Exception { Assertions.assertThrows(IllegalStateException.class, () -> { StringBuilder builder = new StringBuilder(); for (int i = 0; i <= 200; i++) { builder.append("a"); } AbstractConfig.checkPathLength("hello", builder.toString()); }); } |
AbstractConfig implements Serializable { protected static void checkName(String property, String value) { checkProperty(property, value, MAX_LENGTH, PATTERN_NAME); } @Parameter(excluded = true) String getId(); void setId(String id); void updateIdIfAbsent(String value); Map<String, String> getMetaData(); @Parameter(excluded = true) String getPrefix(); void setPrefix(String prefix); void refresh(); @Override String toString(); @Parameter(excluded = true) boolean isValid(); @Override boolean equals(Object obj); } | @Test public void checkName() throws Exception { Assertions.assertThrows(IllegalStateException.class, () -> AbstractConfig.checkName("hello", "world%")); } |
AbstractConfig implements Serializable { protected static void checkNameHasSymbol(String property, String value) { checkProperty(property, value, MAX_LENGTH, PATTERN_NAME_HAS_SYMBOL); } @Parameter(excluded = true) String getId(); void setId(String id); void updateIdIfAbsent(String value); Map<String, String> getMetaData(); @Parameter(excluded = true) String getPrefix(); void setPrefix(String prefix); void refresh(); @Override String toString(); @Parameter(excluded = true) boolean isValid(); @Override boolean equals(Object obj); } | @Test public void checkNameHasSymbol() throws Exception { try { AbstractConfig.checkNameHasSymbol("hello", ":*,/ -0123\tabcdABCD"); AbstractConfig.checkNameHasSymbol("mock", "force:return world"); } catch (Exception e) { fail("the value should be legal."); } } |
AbstractConfig implements Serializable { protected static void checkKey(String property, String value) { checkProperty(property, value, MAX_LENGTH, PATTERN_KEY); } @Parameter(excluded = true) String getId(); void setId(String id); void updateIdIfAbsent(String value); Map<String, String> getMetaData(); @Parameter(excluded = true) String getPrefix(); void setPrefix(String prefix); void refresh(); @Override String toString(); @Parameter(excluded = true) boolean isValid(); @Override boolean equals(Object obj); } | @Test public void checkKey() throws Exception { try { AbstractConfig.checkKey("hello", "*,-0123abcdABCD"); } catch (Exception e) { fail("the value should be legal."); } } |
AbstractConfig implements Serializable { protected static void checkMultiName(String property, String value) { checkProperty(property, value, MAX_LENGTH, PATTERN_MULTI_NAME); } @Parameter(excluded = true) String getId(); void setId(String id); void updateIdIfAbsent(String value); Map<String, String> getMetaData(); @Parameter(excluded = true) String getPrefix(); void setPrefix(String prefix); void refresh(); @Override String toString(); @Parameter(excluded = true) boolean isValid(); @Override boolean equals(Object obj); } | @Test public void checkMultiName() throws Exception { try { AbstractConfig.checkMultiName("hello", ",-._0123abcdABCD"); } catch (Exception e) { fail("the value should be legal."); } } |
AbstractConfig implements Serializable { protected static void checkPathName(String property, String value) { checkProperty(property, value, MAX_PATH_LENGTH, PATTERN_PATH); } @Parameter(excluded = true) String getId(); void setId(String id); void updateIdIfAbsent(String value); Map<String, String> getMetaData(); @Parameter(excluded = true) String getPrefix(); void setPrefix(String prefix); void refresh(); @Override String toString(); @Parameter(excluded = true) boolean isValid(); @Override boolean equals(Object obj); } | @Test public void checkPathName() throws Exception { try { AbstractConfig.checkPathName("hello", "/-$._0123abcdABCD"); } catch (Exception e) { fail("the value should be legal."); } } |
AbstractConfig implements Serializable { protected static void checkMethodName(String property, String value) { checkProperty(property, value, MAX_LENGTH, PATTERN_METHOD_NAME); } @Parameter(excluded = true) String getId(); void setId(String id); void updateIdIfAbsent(String value); Map<String, String> getMetaData(); @Parameter(excluded = true) String getPrefix(); void setPrefix(String prefix); void refresh(); @Override String toString(); @Parameter(excluded = true) boolean isValid(); @Override boolean equals(Object obj); } | @Test public void checkMethodName() throws Exception { try { AbstractConfig.checkMethodName("hello", "abcdABCD0123abcd"); } catch (Exception e) { fail("the value should be legal."); } try { AbstractConfig.checkMethodName("hello", "0a"); fail("the value should be illegal."); } catch (Exception e) { } } |
AbstractConfig implements Serializable { protected static void checkParameterName(Map<String, String> parameters) { if (CollectionUtils.isEmptyMap(parameters)) { return; } for (Map.Entry<String, String> entry : parameters.entrySet()) { checkNameHasSymbol(entry.getKey(), entry.getValue()); } } @Parameter(excluded = true) String getId(); void setId(String id); void updateIdIfAbsent(String value); Map<String, String> getMetaData(); @Parameter(excluded = true) String getPrefix(); void setPrefix(String prefix); void refresh(); @Override String toString(); @Parameter(excluded = true) boolean isValid(); @Override boolean equals(Object obj); } | @Test public void checkParameterName() throws Exception { Map<String, String> parameters = Collections.singletonMap("hello", ":*,/-._0123abcdABCD"); try { AbstractConfig.checkParameterName(parameters); } catch (Exception e) { fail("the value should be legal."); } } |
AbstractConfig implements Serializable { protected void appendAnnotation(Class<?> annotationClass, Object annotation) { Method[] methods = annotationClass.getMethods(); for (Method method : methods) { if (method.getDeclaringClass() != Object.class && method.getReturnType() != void.class && method.getParameterTypes().length == 0 && Modifier.isPublic(method.getModifiers()) && !Modifier.isStatic(method.getModifiers())) { try { String property = method.getName(); if ("interfaceClass".equals(property) || "interfaceName".equals(property)) { property = "interface"; } String setter = "set" + property.substring(0, 1).toUpperCase() + property.substring(1); Object value = method.invoke(annotation); if (value != null && !value.equals(method.getDefaultValue())) { Class<?> parameterType = ReflectUtils.getBoxedClass(method.getReturnType()); if ("filter".equals(property) || "listener".equals(property)) { parameterType = String.class; value = StringUtils.join((String[]) value, ","); } else if ("parameters".equals(property)) { parameterType = Map.class; value = CollectionUtils.toStringMap((String[]) value); } try { Method setterMethod = getClass().getMethod(setter, parameterType); setterMethod.invoke(this, value); } catch (NoSuchMethodException e) { } } } catch (Throwable e) { logger.error(e.getMessage(), e); } } } } @Parameter(excluded = true) String getId(); void setId(String id); void updateIdIfAbsent(String value); Map<String, String> getMetaData(); @Parameter(excluded = true) String getPrefix(); void setPrefix(String prefix); void refresh(); @Override String toString(); @Parameter(excluded = true) boolean isValid(); @Override boolean equals(Object obj); } | @Test @Config(interfaceClass = Greeting.class, filter = {"f1, f2"}, listener = {"l1, l2"}, parameters = {"k1", "v1", "k2", "v2"}) public void appendAnnotation() throws Exception { Config config = getClass().getMethod("appendAnnotation").getAnnotation(Config.class); AnnotationConfig annotationConfig = new AnnotationConfig(); annotationConfig.appendAnnotation(Config.class, config); Assertions.assertSame(Greeting.class, annotationConfig.getInterface()); Assertions.assertEquals("f1, f2", annotationConfig.getFilter()); Assertions.assertEquals("l1, l2", annotationConfig.getListener()); Assertions.assertEquals(2, annotationConfig.getParameters().size()); Assertions.assertEquals("v1", annotationConfig.getParameters().get("k1")); Assertions.assertEquals("v2", annotationConfig.getParameters().get("k2")); assertThat(annotationConfig.toString(), Matchers.containsString("filter=\"f1, f2\" ")); assertThat(annotationConfig.toString(), Matchers.containsString("listener=\"l1, l2\" ")); } |
AbstractConfig implements Serializable { public void refresh() { try { CompositeConfiguration compositeConfiguration = Environment.getInstance().getConfiguration(getPrefix(), getId()); InmemoryConfiguration config = new InmemoryConfiguration(getPrefix(), getId()); config.addProperties(getMetaData()); if (Environment.getInstance().isConfigCenterFirst()) { compositeConfiguration.addConfiguration(3, config); } else { compositeConfiguration.addConfiguration(1, config); } Method[] methods = getClass().getMethods(); for (Method method : methods) { if (MethodUtils.isSetter(method)) { try { String value = StringUtils.trim(compositeConfiguration.getString(extractPropertyName(getClass(), method))); if (StringUtils.isNotEmpty(value) && ClassUtils.isTypeMatch(method.getParameterTypes()[0], value)) { method.invoke(this, ClassUtils.convertPrimitive(method.getParameterTypes()[0], value)); } } catch (NoSuchMethodException e) { logger.info("Failed to override the property " + method.getName() + " in " + this.getClass().getSimpleName() + ", please make sure every property has getter/setter method provided."); } } } } catch (Exception e) { logger.error("Failed to override ", e); } } @Parameter(excluded = true) String getId(); void setId(String id); void updateIdIfAbsent(String value); Map<String, String> getMetaData(); @Parameter(excluded = true) String getPrefix(); void setPrefix(String prefix); void refresh(); @Override String toString(); @Parameter(excluded = true) boolean isValid(); @Override boolean equals(Object obj); } | @Test public void testRefreshAll() { try { OverrideConfig overrideConfig = new OverrideConfig(); overrideConfig.setAddress("override-config: overrideConfig.setProtocol("override-config"); overrideConfig.setEscape("override-config: overrideConfig.setExclude("override-config"); Map<String, String> external = new HashMap<>(); external.put("dubbo.override.address", "external: external.put("dubbo.override.exclude", "external"); external.put("dubbo.override.key", "external"); external.put("dubbo.override.key2", "external"); Environment.getInstance().setExternalConfigMap(external); System.setProperty("dubbo.override.address", "system: System.setProperty("dubbo.override.protocol", "system"); System.setProperty("dubbo.override.key1", "system"); System.setProperty("dubbo.override.key2", "system"); overrideConfig.refresh(); Assertions.assertEquals("system: Assertions.assertEquals("system", overrideConfig.getProtocol()); Assertions.assertEquals("override-config: Assertions.assertEquals("external", overrideConfig.getKey()); Assertions.assertEquals("system", overrideConfig.getUseKeyAsProperty()); } finally { System.clearProperty("dubbo.override.address"); System.clearProperty("dubbo.override.protocol"); System.clearProperty("dubbo.override.key1"); System.clearProperty("dubbo.override.key2"); Environment.getInstance().clearExternalConfigs(); } }
@Test public void testRefreshSystem() { try { OverrideConfig overrideConfig = new OverrideConfig(); overrideConfig.setAddress("override-config: overrideConfig.setProtocol("override-config"); overrideConfig.setEscape("override-config: overrideConfig.setExclude("override-config"); System.setProperty("dubbo.override.address", "system: System.setProperty("dubbo.override.protocol", "system"); System.setProperty("dubbo.override.key", "system"); overrideConfig.refresh(); Assertions.assertEquals("system: Assertions.assertEquals("system", overrideConfig.getProtocol()); Assertions.assertEquals("override-config: Assertions.assertEquals("system", overrideConfig.getKey()); } finally { System.clearProperty("dubbo.override.address"); System.clearProperty("dubbo.override.protocol"); System.clearProperty("dubbo.override.key1"); Environment.getInstance().clearExternalConfigs(); } }
@Test public void testRefreshProperties() throws Exception{ try { Environment.getInstance().setExternalConfigMap(new HashMap<>()); OverrideConfig overrideConfig = new OverrideConfig(); overrideConfig.setAddress("override-config: overrideConfig.setProtocol("override-config"); overrideConfig.setEscape("override-config: Properties properties = new Properties(); properties.load(this.getClass().getResourceAsStream("/dubbo.properties")); ConfigUtils.setProperties(properties); overrideConfig.refresh(); Assertions.assertEquals("override-config: Assertions.assertEquals("override-config", overrideConfig.getProtocol()); Assertions.assertEquals("override-config: } finally { Environment.getInstance().clearExternalConfigs(); ConfigUtils.setProperties(null); } }
@Test public void testRefreshExternal() { try { OverrideConfig overrideConfig = new OverrideConfig(); overrideConfig.setAddress("override-config: overrideConfig.setProtocol("override-config"); overrideConfig.setEscape("override-config: overrideConfig.setExclude("override-config"); Map<String, String> external = new HashMap<>(); external.put("dubbo.override.address", "external: external.put("dubbo.override.protocol", "external"); external.put("dubbo.override.escape", "external: external.put("dubbo.override.exclude", "external"); external.put("dubbo.override.key", "external"); external.put("dubbo.override.key2", "external"); Environment.getInstance().setExternalConfigMap(external); overrideConfig.refresh(); Assertions.assertEquals("external: Assertions.assertEquals("external", overrideConfig.getProtocol()); Assertions.assertEquals("external: Assertions.assertEquals("external", overrideConfig.getExclude()); Assertions.assertEquals("external", overrideConfig.getKey()); Assertions.assertEquals("external", overrideConfig.getUseKeyAsProperty()); } finally { Environment.getInstance().clearExternalConfigs(); } } |
AbstractServiceConfig extends AbstractInterfaceConfig { @Override @Parameter(key = Constants.SERVICE_FILTER_KEY, append = true) public String getFilter() { return super.getFilter(); } String getVersion(); void setVersion(String version); String getGroup(); void setGroup(String group); Integer getDelay(); void setDelay(Integer delay); Boolean getExport(); void setExport(Boolean export); Integer getWeight(); void setWeight(Integer weight); @Parameter(escaped = true) String getDocument(); void setDocument(String document); String getToken(); void setToken(Boolean token); void setToken(String token); Boolean isDeprecated(); void setDeprecated(Boolean deprecated); Boolean isDynamic(); void setDynamic(Boolean dynamic); List<ProtocolConfig> getProtocols(); @SuppressWarnings({"unchecked"}) void setProtocols(List<? extends ProtocolConfig> protocols); ProtocolConfig getProtocol(); void setProtocol(ProtocolConfig protocol); @Parameter(excluded = true) String getProtocolIds(); void setProtocolIds(String protocolIds); String getAccesslog(); void setAccesslog(Boolean accesslog); void setAccesslog(String accesslog); Integer getExecutes(); void setExecutes(Integer executes); @Override @Parameter(key = Constants.SERVICE_FILTER_KEY, append = true) String getFilter(); @Override @Parameter(key = Constants.EXPORTER_LISTENER_KEY, append = true) String getListener(); @Override void setListener(String listener); Boolean isRegister(); void setRegister(Boolean register); Integer getWarmup(); void setWarmup(Integer warmup); String getSerialization(); void setSerialization(String serialization); } | @Test public void testFilter() throws Exception { ServiceConfig serviceConfig = new ServiceConfig(); serviceConfig.setFilter("mockfilter"); assertThat(serviceConfig.getFilter(), equalTo("mockfilter")); Map<String, String> parameters = new HashMap<String, String>(); parameters.put(Constants.SERVICE_FILTER_KEY, "prefilter"); AbstractServiceConfig.appendParameters(parameters, serviceConfig); assertThat(parameters, hasEntry(Constants.SERVICE_FILTER_KEY, "prefilter,mockfilter")); } |
ReferenceConfigCache { public <T> void destroy(ReferenceConfig<T> referenceConfig) { String key = generator.generateKey(referenceConfig); destroyKey(key); } private ReferenceConfigCache(String name, KeyGenerator generator); static ReferenceConfigCache getCache(); static ReferenceConfigCache getCache(String name); static ReferenceConfigCache getCache(String name, KeyGenerator keyGenerator); @SuppressWarnings("unchecked") T get(ReferenceConfig<T> referenceConfig); @SuppressWarnings("unchecked") T get(String key, Class<T> type); void destroy(ReferenceConfig<T> referenceConfig); void destroyAll(); @Override String toString(); static final String DEFAULT_NAME; static final KeyGenerator DEFAULT_KEY_GENERATOR; } | @Test public void testDestroy() throws Exception { ReferenceConfigCache cache = ReferenceConfigCache.getCache(); MockReferenceConfig config = buildMockReferenceConfig("FooService", "group1", "1.0.0"); cache.get(config); MockReferenceConfig configCopy = buildMockReferenceConfig("XxxService", "group1", "1.0.0"); cache.get(configCopy); assertEquals(2, cache.cache.size()); cache.destroy(config); assertTrue(config.isDestroyMethodRun()); assertEquals(1, cache.cache.size()); cache.destroy(configCopy); assertTrue(configCopy.isDestroyMethodRun()); assertEquals(0, cache.cache.size()); } |
ReferenceConfigCache { public void destroyAll() { Set<String> set = new HashSet<String>(cache.keySet()); for (String key : set) { destroyKey(key); } } private ReferenceConfigCache(String name, KeyGenerator generator); static ReferenceConfigCache getCache(); static ReferenceConfigCache getCache(String name); static ReferenceConfigCache getCache(String name, KeyGenerator keyGenerator); @SuppressWarnings("unchecked") T get(ReferenceConfig<T> referenceConfig); @SuppressWarnings("unchecked") T get(String key, Class<T> type); void destroy(ReferenceConfig<T> referenceConfig); void destroyAll(); @Override String toString(); static final String DEFAULT_NAME; static final KeyGenerator DEFAULT_KEY_GENERATOR; } | @Test public void testDestroyAll() throws Exception { ReferenceConfigCache cache = ReferenceConfigCache.getCache(); MockReferenceConfig config = buildMockReferenceConfig("FooService", "group1", "1.0.0"); cache.get(config); MockReferenceConfig configCopy = buildMockReferenceConfig("XxxService", "group1", "1.0.0"); cache.get(configCopy); assertEquals(2, cache.cache.size()); cache.destroyAll(); assertTrue(config.isDestroyMethodRun()); assertTrue(configCopy.isDestroyMethodRun()); assertEquals(0, cache.cache.size()); } |
ServiceConfig extends AbstractServiceConfig { public synchronized void export() { checkAndUpdateSubConfigs(); if (!shouldExport()) { return; } if (shouldDelay()) { delayExportExecutor.schedule(this::doExport, getDelay(), TimeUnit.MILLISECONDS); } else { doExport(); } } ServiceConfig(); ServiceConfig(Service service); URL toUrl(); List<URL> toUrls(); @Parameter(excluded = true) boolean isExported(); @Parameter(excluded = true) boolean isUnexported(); void checkAndUpdateSubConfigs(); synchronized void export(); @Override Boolean getExport(); @Override Integer getDelay(); synchronized void unexport(); Class<?> getInterfaceClass(); void setInterfaceClass(Class<?> interfaceClass); String getInterface(); void setInterface(Class<?> interfaceClass); void setInterface(String interfaceName); T getRef(); void setRef(T ref); @Parameter(excluded = true) String getPath(); void setPath(String path); List<MethodConfig> getMethods(); @SuppressWarnings("unchecked") void setMethods(List<? extends MethodConfig> methods); ProviderConfig getProvider(); void setProvider(ProviderConfig provider); @Parameter(excluded = true) String getProviderIds(); void setProviderIds(String providerIds); String getGeneric(); void setGeneric(String generic); @Override void setMock(Boolean mock); @Override void setMock(String mock); List<URL> getExportedUrls(); @Deprecated List<ProviderConfig> getProviders(); @Deprecated void setProviders(List<ProviderConfig> providers); @Override @Parameter(excluded = true) String getPrefix(); } | @Test public void testExport() throws Exception { service.export(); assertThat(service.getExportedUrls(), hasSize(1)); URL url = service.toUrl(); assertThat(url.getProtocol(), equalTo("mockprotocol2")); assertThat(url.getPath(), equalTo(DemoService.class.getName())); assertThat(url.getParameters(), hasEntry(Constants.ANYHOST_KEY, "true")); assertThat(url.getParameters(), hasEntry(Constants.APPLICATION_KEY, "app")); assertThat(url.getParameters(), hasKey(Constants.BIND_IP_KEY)); assertThat(url.getParameters(), hasKey(Constants.BIND_PORT_KEY)); assertThat(url.getParameters(), hasEntry(Constants.EXPORT_KEY, "true")); assertThat(url.getParameters(), hasEntry("echo.0.callback", "false")); assertThat(url.getParameters(), hasEntry(Constants.GENERIC_KEY, "false")); assertThat(url.getParameters(), hasEntry(Constants.INTERFACE_KEY, DemoService.class.getName())); assertThat(url.getParameters(), hasKey(Constants.METHODS_KEY)); assertThat(url.getParameters().get(Constants.METHODS_KEY), containsString("echo")); assertThat(url.getParameters(), hasEntry(Constants.SIDE_KEY, Constants.PROVIDER)); Mockito.verify(protocolDelegate).export(Mockito.any(Invoker.class)); } |
ServiceConfig extends AbstractServiceConfig { public synchronized void unexport() { if (!exported) { return; } if (unexported) { return; } if (!exporters.isEmpty()) { for (Exporter<?> exporter : exporters) { try { exporter.unexport(); } catch (Throwable t) { logger.warn("Unexpected error occured when unexport " + exporter, t); } } exporters.clear(); } unexported = true; } ServiceConfig(); ServiceConfig(Service service); URL toUrl(); List<URL> toUrls(); @Parameter(excluded = true) boolean isExported(); @Parameter(excluded = true) boolean isUnexported(); void checkAndUpdateSubConfigs(); synchronized void export(); @Override Boolean getExport(); @Override Integer getDelay(); synchronized void unexport(); Class<?> getInterfaceClass(); void setInterfaceClass(Class<?> interfaceClass); String getInterface(); void setInterface(Class<?> interfaceClass); void setInterface(String interfaceName); T getRef(); void setRef(T ref); @Parameter(excluded = true) String getPath(); void setPath(String path); List<MethodConfig> getMethods(); @SuppressWarnings("unchecked") void setMethods(List<? extends MethodConfig> methods); ProviderConfig getProvider(); void setProvider(ProviderConfig provider); @Parameter(excluded = true) String getProviderIds(); void setProviderIds(String providerIds); String getGeneric(); void setGeneric(String generic); @Override void setMock(Boolean mock); @Override void setMock(String mock); List<URL> getExportedUrls(); @Deprecated List<ProviderConfig> getProviders(); @Deprecated void setProviders(List<ProviderConfig> providers); @Override @Parameter(excluded = true) String getPrefix(); } | @Test @Disabled("cannot pass in travis") public void testUnexport() throws Exception { System.setProperty(Constants.SHUTDOWN_WAIT_KEY, "0"); try { service.export(); service.unexport(); Thread.sleep(1000); Mockito.verify(exporter, Mockito.atLeastOnce()).unexport(); } finally { System.clearProperty(Constants.SHUTDOWN_TIMEOUT_KEY); } } |
ServiceConfig extends AbstractServiceConfig { public void setInterface(Class<?> interfaceClass) { if (interfaceClass != null && !interfaceClass.isInterface()) { throw new IllegalStateException("The interface class " + interfaceClass + " is not a interface!"); } this.interfaceClass = interfaceClass; setInterface(interfaceClass == null ? null : interfaceClass.getName()); } ServiceConfig(); ServiceConfig(Service service); URL toUrl(); List<URL> toUrls(); @Parameter(excluded = true) boolean isExported(); @Parameter(excluded = true) boolean isUnexported(); void checkAndUpdateSubConfigs(); synchronized void export(); @Override Boolean getExport(); @Override Integer getDelay(); synchronized void unexport(); Class<?> getInterfaceClass(); void setInterfaceClass(Class<?> interfaceClass); String getInterface(); void setInterface(Class<?> interfaceClass); void setInterface(String interfaceName); T getRef(); void setRef(T ref); @Parameter(excluded = true) String getPath(); void setPath(String path); List<MethodConfig> getMethods(); @SuppressWarnings("unchecked") void setMethods(List<? extends MethodConfig> methods); ProviderConfig getProvider(); void setProvider(ProviderConfig provider); @Parameter(excluded = true) String getProviderIds(); void setProviderIds(String providerIds); String getGeneric(); void setGeneric(String generic); @Override void setMock(Boolean mock); @Override void setMock(String mock); List<URL> getExportedUrls(); @Deprecated List<ProviderConfig> getProviders(); @Deprecated void setProviders(List<ProviderConfig> providers); @Override @Parameter(excluded = true) String getPrefix(); } | @Test public void testInterface1() throws Exception { Assertions.assertThrows(IllegalStateException.class, () -> { ServiceConfig<DemoService> service = new ServiceConfig<DemoService>(); service.setInterface(DemoServiceImpl.class); }); } |
ExecuteLimitFilter implements Filter { @Override public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException { URL url = invoker.getUrl(); String methodName = invocation.getMethodName(); int max = url.getMethodParameter(methodName, Constants.EXECUTES_KEY, 0); if (!RpcStatus.beginCount(url, methodName, max)) { throw new RpcException("Failed to invoke method " + invocation.getMethodName() + " in provider " + url + ", cause: The service using threads greater than <dubbo:service executes=\"" + max + "\" /> limited."); } long begin = System.currentTimeMillis(); boolean isSuccess = true; try { return invoker.invoke(invocation); } catch (Throwable t) { isSuccess = false; if (t instanceof RuntimeException) { throw (RuntimeException) t; } else { throw new RpcException("unexpected exception when ExecuteLimitFilter", t); } } finally { RpcStatus.endCount(url, methodName, System.currentTimeMillis() - begin, isSuccess); } } @Override Result invoke(Invoker<?> invoker, Invocation invocation); } | @Test public void testNoExecuteLimitInvoke() throws Exception { Invoker invoker = Mockito.mock(Invoker.class); when(invoker.invoke(any(Invocation.class))).thenReturn(new RpcResult("result")); when(invoker.getUrl()).thenReturn(URL.valueOf("test: Invocation invocation = Mockito.mock(Invocation.class); when(invocation.getMethodName()).thenReturn("testNoExecuteLimitInvoke"); Result result = executeLimitFilter.invoke(invoker, invocation); Assertions.assertEquals("result", result.getValue()); }
@Test public void testExecuteLimitInvoke() throws Exception { Invoker invoker = Mockito.mock(Invoker.class); when(invoker.invoke(any(Invocation.class))).thenReturn(new RpcResult("result")); when(invoker.getUrl()).thenReturn(URL.valueOf("test: Invocation invocation = Mockito.mock(Invocation.class); when(invocation.getMethodName()).thenReturn("testExecuteLimitInvoke"); Result result = executeLimitFilter.invoke(invoker, invocation); Assertions.assertEquals("result", result.getValue()); }
@Test public void testExecuteLimitInvokeWitException() throws Exception { Invoker invoker = Mockito.mock(Invoker.class); doThrow(new RpcException()) .when(invoker).invoke(any(Invocation.class)); URL url = URL.valueOf("test: when(invoker.getUrl()).thenReturn(url); Invocation invocation = Mockito.mock(Invocation.class); when(invocation.getMethodName()).thenReturn("testExecuteLimitInvokeWitException"); try { executeLimitFilter.invoke(invoker, invocation); } catch (Exception e) { Assertions.assertTrue(e instanceof RpcException); } Assertions.assertEquals(1, RpcStatus.getStatus(url, invocation.getMethodName()).getFailed()); }
@Test public void testMoreThanExecuteLimitInvoke() throws Exception { int maxExecute = 10; int totalExecute = 20; final AtomicInteger failed = new AtomicInteger(0); final Invocation invocation = Mockito.mock(Invocation.class); when(invocation.getMethodName()).thenReturn("testMoreThanExecuteLimitInvoke"); URL url = URL.valueOf("test: final Invoker<ExecuteLimitFilter> invoker = new BlockMyInvoker<ExecuteLimitFilter>(url, 1000); final CountDownLatch latch = new CountDownLatch(1); for (int i = 0; i < totalExecute; i++) { Thread thread = new Thread(new Runnable() { public void run() { try { latch.await(); } catch (InterruptedException e) { e.printStackTrace(); } try { executeLimitFilter.invoke(invoker, invocation); } catch (RpcException expected) { failed.incrementAndGet(); } } }); thread.start(); } latch.countDown(); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } Assertions.assertEquals(totalExecute - maxExecute, failed.get()); } |
ServiceConfig extends AbstractServiceConfig { public void setGeneric(String generic) { if (StringUtils.isEmpty(generic)) { return; } if (ProtocolUtils.isGeneric(generic)) { this.generic = generic; } else { throw new IllegalArgumentException("Unsupported generic type " + generic); } } ServiceConfig(); ServiceConfig(Service service); URL toUrl(); List<URL> toUrls(); @Parameter(excluded = true) boolean isExported(); @Parameter(excluded = true) boolean isUnexported(); void checkAndUpdateSubConfigs(); synchronized void export(); @Override Boolean getExport(); @Override Integer getDelay(); synchronized void unexport(); Class<?> getInterfaceClass(); void setInterfaceClass(Class<?> interfaceClass); String getInterface(); void setInterface(Class<?> interfaceClass); void setInterface(String interfaceName); T getRef(); void setRef(T ref); @Parameter(excluded = true) String getPath(); void setPath(String path); List<MethodConfig> getMethods(); @SuppressWarnings("unchecked") void setMethods(List<? extends MethodConfig> methods); ProviderConfig getProvider(); void setProvider(ProviderConfig provider); @Parameter(excluded = true) String getProviderIds(); void setProviderIds(String providerIds); String getGeneric(); void setGeneric(String generic); @Override void setMock(Boolean mock); @Override void setMock(String mock); List<URL> getExportedUrls(); @Deprecated List<ProviderConfig> getProviders(); @Deprecated void setProviders(List<ProviderConfig> providers); @Override @Parameter(excluded = true) String getPrefix(); } | @Test public void testGeneric2() throws Exception { Assertions.assertThrows(IllegalArgumentException.class, () -> { ServiceConfig service = new ServiceConfig(); service.setGeneric("illegal"); }); } |
ServiceConfig extends AbstractServiceConfig { @Override public void setMock(Boolean mock) { throw new IllegalArgumentException("mock doesn't support on provider side"); } ServiceConfig(); ServiceConfig(Service service); URL toUrl(); List<URL> toUrls(); @Parameter(excluded = true) boolean isExported(); @Parameter(excluded = true) boolean isUnexported(); void checkAndUpdateSubConfigs(); synchronized void export(); @Override Boolean getExport(); @Override Integer getDelay(); synchronized void unexport(); Class<?> getInterfaceClass(); void setInterfaceClass(Class<?> interfaceClass); String getInterface(); void setInterface(Class<?> interfaceClass); void setInterface(String interfaceName); T getRef(); void setRef(T ref); @Parameter(excluded = true) String getPath(); void setPath(String path); List<MethodConfig> getMethods(); @SuppressWarnings("unchecked") void setMethods(List<? extends MethodConfig> methods); ProviderConfig getProvider(); void setProvider(ProviderConfig provider); @Parameter(excluded = true) String getProviderIds(); void setProviderIds(String providerIds); String getGeneric(); void setGeneric(String generic); @Override void setMock(Boolean mock); @Override void setMock(String mock); List<URL> getExportedUrls(); @Deprecated List<ProviderConfig> getProviders(); @Deprecated void setProviders(List<ProviderConfig> providers); @Override @Parameter(excluded = true) String getPrefix(); } | @Test public void testMock() throws Exception { Assertions.assertThrows(IllegalArgumentException.class, () -> { ServiceConfig service = new ServiceConfig(); service.setMock("true"); }); }
@Test public void testMock2() throws Exception { Assertions.assertThrows(IllegalArgumentException.class, () -> { ServiceConfig service = new ServiceConfig(); service.setMock(true); }); } |
AbstractReferenceConfig extends AbstractInterfaceConfig { @Override @Parameter(key = Constants.REFERENCE_FILTER_KEY, append = true) public String getFilter() { return super.getFilter(); } Boolean isCheck(); void setCheck(Boolean check); Boolean isInit(); void setInit(Boolean init); @Parameter(excluded = true) Boolean isGeneric(); void setGeneric(Boolean generic); String getGeneric(); void setGeneric(String generic); @Deprecated Boolean isInjvm(); @Deprecated void setInjvm(Boolean injvm); @Override @Parameter(key = Constants.REFERENCE_FILTER_KEY, append = true) String getFilter(); @Override @Parameter(key = Constants.INVOKER_LISTENER_KEY, append = true) String getListener(); @Override void setListener(String listener); @Parameter(key = Constants.LAZY_CONNECT_KEY) Boolean getLazy(); void setLazy(Boolean lazy); @Override void setOnconnect(String onconnect); @Override void setOndisconnect(String ondisconnect); @Parameter(key = Constants.STUB_EVENT_KEY) Boolean getStubevent(); @Parameter(key = Constants.RECONNECT_KEY) String getReconnect(); void setReconnect(String reconnect); @Parameter(key = Constants.CLUSTER_STICKY_KEY) Boolean getSticky(); void setSticky(Boolean sticky); String getVersion(); void setVersion(String version); String getGroup(); void setGroup(String group); } | @Test public void testFilter() throws Exception { ReferenceConfig referenceConfig = new ReferenceConfig(); referenceConfig.setFilter("mockfilter"); assertThat(referenceConfig.getFilter(), equalTo("mockfilter")); Map<String, String> parameters = new HashMap<String, String>(); parameters.put(Constants.REFERENCE_FILTER_KEY, "prefilter"); AbstractInterfaceConfig.appendParameters(parameters, referenceConfig); assertThat(parameters, hasValue("prefilter,mockfilter")); } |
AbstractReferenceConfig extends AbstractInterfaceConfig { @Override public void setOnconnect(String onconnect) { if (onconnect != null && onconnect.length() > 0) { this.stubevent = true; } super.setOnconnect(onconnect); } Boolean isCheck(); void setCheck(Boolean check); Boolean isInit(); void setInit(Boolean init); @Parameter(excluded = true) Boolean isGeneric(); void setGeneric(Boolean generic); String getGeneric(); void setGeneric(String generic); @Deprecated Boolean isInjvm(); @Deprecated void setInjvm(Boolean injvm); @Override @Parameter(key = Constants.REFERENCE_FILTER_KEY, append = true) String getFilter(); @Override @Parameter(key = Constants.INVOKER_LISTENER_KEY, append = true) String getListener(); @Override void setListener(String listener); @Parameter(key = Constants.LAZY_CONNECT_KEY) Boolean getLazy(); void setLazy(Boolean lazy); @Override void setOnconnect(String onconnect); @Override void setOndisconnect(String ondisconnect); @Parameter(key = Constants.STUB_EVENT_KEY) Boolean getStubevent(); @Parameter(key = Constants.RECONNECT_KEY) String getReconnect(); void setReconnect(String reconnect); @Parameter(key = Constants.CLUSTER_STICKY_KEY) Boolean getSticky(); void setSticky(Boolean sticky); String getVersion(); void setVersion(String version); String getGroup(); void setGroup(String group); } | @Test public void testStubevent() throws Exception { ReferenceConfig referenceConfig = new ReferenceConfig(); referenceConfig.setOnconnect("onConnect"); Map<String, String> parameters = new HashMap<String, String>(); AbstractInterfaceConfig.appendParameters(parameters, referenceConfig); assertThat(parameters, hasKey(Constants.STUB_EVENT_KEY)); } |
ProviderConfig extends AbstractServiceConfig { @Deprecated public void setProtocol(String protocol) { this.protocols = new ArrayList<>(Arrays.asList(new ProtocolConfig(protocol))); } @Deprecated void setProtocol(String protocol); @Parameter(excluded = true) Boolean isDefault(); @Deprecated void setDefault(Boolean isDefault); @Parameter(excluded = true) String getHost(); void setHost(String host); @Parameter(excluded = true) Integer getPort(); @Deprecated void setPort(Integer port); @Deprecated @Parameter(excluded = true) String getPath(); @Deprecated void setPath(String path); @Parameter(excluded = true) String getContextpath(); void setContextpath(String contextpath); String getThreadpool(); void setThreadpool(String threadpool); Integer getThreads(); void setThreads(Integer threads); Integer getIothreads(); void setIothreads(Integer iothreads); Integer getQueues(); void setQueues(Integer queues); Integer getAccepts(); void setAccepts(Integer accepts); String getCodec(); void setCodec(String codec); String getCharset(); void setCharset(String charset); Integer getPayload(); void setPayload(Integer payload); Integer getBuffer(); void setBuffer(Integer buffer); String getServer(); void setServer(String server); String getClient(); void setClient(String client); String getTelnet(); void setTelnet(String telnet); @Parameter(escaped = true) String getPrompt(); void setPrompt(String prompt); String getStatus(); void setStatus(String status); @Override String getCluster(); @Override Integer getConnections(); @Override Integer getTimeout(); @Override Integer getRetries(); @Override String getLoadbalance(); @Override Boolean isAsync(); @Override Integer getActives(); String getTransporter(); void setTransporter(String transporter); String getExchanger(); void setExchanger(String exchanger); @Deprecated @Parameter(excluded = true) String getDispather(); @Deprecated void setDispather(String dispather); String getDispatcher(); void setDispatcher(String dispatcher); String getNetworker(); void setNetworker(String networker); Integer getWait(); void setWait(Integer wait); } | @Test public void testProtocol() throws Exception { ProviderConfig provider = new ProviderConfig(); provider.setProtocol("protocol"); assertThat(provider.getProtocol().getName(), equalTo("protocol")); } |
ApplicationBuilder extends AbstractBuilder<ApplicationConfig, ApplicationBuilder> { public ApplicationBuilder name(String name) { this.name = name; return getThis(); } ApplicationBuilder name(String name); ApplicationBuilder version(String version); ApplicationBuilder owner(String owner); ApplicationBuilder organization(String organization); ApplicationBuilder architecture(String architecture); ApplicationBuilder environment(String environment); ApplicationBuilder compiler(String compiler); ApplicationBuilder logger(String logger); ApplicationBuilder addRegistry(RegistryConfig registry); ApplicationBuilder addRegistries(List<? extends RegistryConfig> registries); ApplicationBuilder registryIds(String registryIds); ApplicationBuilder monitor(MonitorConfig monitor); ApplicationBuilder monitor(String monitor); ApplicationBuilder isDefault(Boolean isDefault); ApplicationBuilder dumpDirectory(String dumpDirectory); ApplicationBuilder qosEnable(Boolean qosEnable); ApplicationBuilder qosPort(Integer qosPort); ApplicationBuilder qosAcceptForeignIp(Boolean qosAcceptForeignIp); ApplicationBuilder shutwait(String shutwait); ApplicationBuilder appendParameter(String key, String value); ApplicationBuilder appendParameters(Map<String, String> appendParameters); ApplicationConfig build(); } | @Test void name() { ApplicationBuilder builder = new ApplicationBuilder(); builder.name("app"); Assertions.assertEquals("app", builder.build().getName()); } |
ApplicationBuilder extends AbstractBuilder<ApplicationConfig, ApplicationBuilder> { public ApplicationBuilder version(String version) { this.version = version; return getThis(); } ApplicationBuilder name(String name); ApplicationBuilder version(String version); ApplicationBuilder owner(String owner); ApplicationBuilder organization(String organization); ApplicationBuilder architecture(String architecture); ApplicationBuilder environment(String environment); ApplicationBuilder compiler(String compiler); ApplicationBuilder logger(String logger); ApplicationBuilder addRegistry(RegistryConfig registry); ApplicationBuilder addRegistries(List<? extends RegistryConfig> registries); ApplicationBuilder registryIds(String registryIds); ApplicationBuilder monitor(MonitorConfig monitor); ApplicationBuilder monitor(String monitor); ApplicationBuilder isDefault(Boolean isDefault); ApplicationBuilder dumpDirectory(String dumpDirectory); ApplicationBuilder qosEnable(Boolean qosEnable); ApplicationBuilder qosPort(Integer qosPort); ApplicationBuilder qosAcceptForeignIp(Boolean qosAcceptForeignIp); ApplicationBuilder shutwait(String shutwait); ApplicationBuilder appendParameter(String key, String value); ApplicationBuilder appendParameters(Map<String, String> appendParameters); ApplicationConfig build(); } | @Test void version() { ApplicationBuilder builder = new ApplicationBuilder(); builder.version("version"); Assertions.assertEquals("version", builder.build().getVersion()); } |
ApplicationBuilder extends AbstractBuilder<ApplicationConfig, ApplicationBuilder> { public ApplicationBuilder owner(String owner) { this.owner = owner; return getThis(); } ApplicationBuilder name(String name); ApplicationBuilder version(String version); ApplicationBuilder owner(String owner); ApplicationBuilder organization(String organization); ApplicationBuilder architecture(String architecture); ApplicationBuilder environment(String environment); ApplicationBuilder compiler(String compiler); ApplicationBuilder logger(String logger); ApplicationBuilder addRegistry(RegistryConfig registry); ApplicationBuilder addRegistries(List<? extends RegistryConfig> registries); ApplicationBuilder registryIds(String registryIds); ApplicationBuilder monitor(MonitorConfig monitor); ApplicationBuilder monitor(String monitor); ApplicationBuilder isDefault(Boolean isDefault); ApplicationBuilder dumpDirectory(String dumpDirectory); ApplicationBuilder qosEnable(Boolean qosEnable); ApplicationBuilder qosPort(Integer qosPort); ApplicationBuilder qosAcceptForeignIp(Boolean qosAcceptForeignIp); ApplicationBuilder shutwait(String shutwait); ApplicationBuilder appendParameter(String key, String value); ApplicationBuilder appendParameters(Map<String, String> appendParameters); ApplicationConfig build(); } | @Test void owner() { ApplicationBuilder builder = new ApplicationBuilder(); builder.owner("owner"); Assertions.assertEquals("owner", builder.build().getOwner()); } |
ApplicationBuilder extends AbstractBuilder<ApplicationConfig, ApplicationBuilder> { public ApplicationBuilder organization(String organization) { this.organization = organization; return getThis(); } ApplicationBuilder name(String name); ApplicationBuilder version(String version); ApplicationBuilder owner(String owner); ApplicationBuilder organization(String organization); ApplicationBuilder architecture(String architecture); ApplicationBuilder environment(String environment); ApplicationBuilder compiler(String compiler); ApplicationBuilder logger(String logger); ApplicationBuilder addRegistry(RegistryConfig registry); ApplicationBuilder addRegistries(List<? extends RegistryConfig> registries); ApplicationBuilder registryIds(String registryIds); ApplicationBuilder monitor(MonitorConfig monitor); ApplicationBuilder monitor(String monitor); ApplicationBuilder isDefault(Boolean isDefault); ApplicationBuilder dumpDirectory(String dumpDirectory); ApplicationBuilder qosEnable(Boolean qosEnable); ApplicationBuilder qosPort(Integer qosPort); ApplicationBuilder qosAcceptForeignIp(Boolean qosAcceptForeignIp); ApplicationBuilder shutwait(String shutwait); ApplicationBuilder appendParameter(String key, String value); ApplicationBuilder appendParameters(Map<String, String> appendParameters); ApplicationConfig build(); } | @Test void organization() { ApplicationBuilder builder = new ApplicationBuilder(); builder.organization("organization"); Assertions.assertEquals("organization", builder.build().getOrganization()); } |
ApplicationBuilder extends AbstractBuilder<ApplicationConfig, ApplicationBuilder> { public ApplicationBuilder architecture(String architecture) { this.architecture = architecture; return getThis(); } ApplicationBuilder name(String name); ApplicationBuilder version(String version); ApplicationBuilder owner(String owner); ApplicationBuilder organization(String organization); ApplicationBuilder architecture(String architecture); ApplicationBuilder environment(String environment); ApplicationBuilder compiler(String compiler); ApplicationBuilder logger(String logger); ApplicationBuilder addRegistry(RegistryConfig registry); ApplicationBuilder addRegistries(List<? extends RegistryConfig> registries); ApplicationBuilder registryIds(String registryIds); ApplicationBuilder monitor(MonitorConfig monitor); ApplicationBuilder monitor(String monitor); ApplicationBuilder isDefault(Boolean isDefault); ApplicationBuilder dumpDirectory(String dumpDirectory); ApplicationBuilder qosEnable(Boolean qosEnable); ApplicationBuilder qosPort(Integer qosPort); ApplicationBuilder qosAcceptForeignIp(Boolean qosAcceptForeignIp); ApplicationBuilder shutwait(String shutwait); ApplicationBuilder appendParameter(String key, String value); ApplicationBuilder appendParameters(Map<String, String> appendParameters); ApplicationConfig build(); } | @Test void architecture() { ApplicationBuilder builder = new ApplicationBuilder(); builder.architecture("architecture"); Assertions.assertEquals("architecture", builder.build().getArchitecture()); } |
ApplicationBuilder extends AbstractBuilder<ApplicationConfig, ApplicationBuilder> { public ApplicationBuilder environment(String environment) { this.environment = environment; return getThis(); } ApplicationBuilder name(String name); ApplicationBuilder version(String version); ApplicationBuilder owner(String owner); ApplicationBuilder organization(String organization); ApplicationBuilder architecture(String architecture); ApplicationBuilder environment(String environment); ApplicationBuilder compiler(String compiler); ApplicationBuilder logger(String logger); ApplicationBuilder addRegistry(RegistryConfig registry); ApplicationBuilder addRegistries(List<? extends RegistryConfig> registries); ApplicationBuilder registryIds(String registryIds); ApplicationBuilder monitor(MonitorConfig monitor); ApplicationBuilder monitor(String monitor); ApplicationBuilder isDefault(Boolean isDefault); ApplicationBuilder dumpDirectory(String dumpDirectory); ApplicationBuilder qosEnable(Boolean qosEnable); ApplicationBuilder qosPort(Integer qosPort); ApplicationBuilder qosAcceptForeignIp(Boolean qosAcceptForeignIp); ApplicationBuilder shutwait(String shutwait); ApplicationBuilder appendParameter(String key, String value); ApplicationBuilder appendParameters(Map<String, String> appendParameters); ApplicationConfig build(); } | @Test void environment() { ApplicationBuilder builder = new ApplicationBuilder(); Assertions.assertEquals("product", builder.build().getEnvironment()); builder.environment("develop"); Assertions.assertEquals("develop", builder.build().getEnvironment()); builder.environment("test"); Assertions.assertEquals("test", builder.build().getEnvironment()); builder.environment("product"); Assertions.assertEquals("product", builder.build().getEnvironment()); } |
ApplicationBuilder extends AbstractBuilder<ApplicationConfig, ApplicationBuilder> { public ApplicationBuilder compiler(String compiler) { this.compiler = compiler; return getThis(); } ApplicationBuilder name(String name); ApplicationBuilder version(String version); ApplicationBuilder owner(String owner); ApplicationBuilder organization(String organization); ApplicationBuilder architecture(String architecture); ApplicationBuilder environment(String environment); ApplicationBuilder compiler(String compiler); ApplicationBuilder logger(String logger); ApplicationBuilder addRegistry(RegistryConfig registry); ApplicationBuilder addRegistries(List<? extends RegistryConfig> registries); ApplicationBuilder registryIds(String registryIds); ApplicationBuilder monitor(MonitorConfig monitor); ApplicationBuilder monitor(String monitor); ApplicationBuilder isDefault(Boolean isDefault); ApplicationBuilder dumpDirectory(String dumpDirectory); ApplicationBuilder qosEnable(Boolean qosEnable); ApplicationBuilder qosPort(Integer qosPort); ApplicationBuilder qosAcceptForeignIp(Boolean qosAcceptForeignIp); ApplicationBuilder shutwait(String shutwait); ApplicationBuilder appendParameter(String key, String value); ApplicationBuilder appendParameters(Map<String, String> appendParameters); ApplicationConfig build(); } | @Test void compiler() { ApplicationBuilder builder = new ApplicationBuilder(); builder.compiler("compiler"); Assertions.assertEquals("compiler", builder.build().getCompiler()); } |
ApplicationBuilder extends AbstractBuilder<ApplicationConfig, ApplicationBuilder> { public ApplicationBuilder logger(String logger) { this.logger = logger; return getThis(); } ApplicationBuilder name(String name); ApplicationBuilder version(String version); ApplicationBuilder owner(String owner); ApplicationBuilder organization(String organization); ApplicationBuilder architecture(String architecture); ApplicationBuilder environment(String environment); ApplicationBuilder compiler(String compiler); ApplicationBuilder logger(String logger); ApplicationBuilder addRegistry(RegistryConfig registry); ApplicationBuilder addRegistries(List<? extends RegistryConfig> registries); ApplicationBuilder registryIds(String registryIds); ApplicationBuilder monitor(MonitorConfig monitor); ApplicationBuilder monitor(String monitor); ApplicationBuilder isDefault(Boolean isDefault); ApplicationBuilder dumpDirectory(String dumpDirectory); ApplicationBuilder qosEnable(Boolean qosEnable); ApplicationBuilder qosPort(Integer qosPort); ApplicationBuilder qosAcceptForeignIp(Boolean qosAcceptForeignIp); ApplicationBuilder shutwait(String shutwait); ApplicationBuilder appendParameter(String key, String value); ApplicationBuilder appendParameters(Map<String, String> appendParameters); ApplicationConfig build(); } | @Test void logger() { ApplicationBuilder builder = new ApplicationBuilder(); builder.logger("log4j"); Assertions.assertEquals("log4j", builder.build().getLogger()); } |
ApplicationBuilder extends AbstractBuilder<ApplicationConfig, ApplicationBuilder> { public ApplicationBuilder addRegistry(RegistryConfig registry) { if (this.registries == null) { this.registries = new ArrayList<>(); } this.registries.add(registry); return getThis(); } ApplicationBuilder name(String name); ApplicationBuilder version(String version); ApplicationBuilder owner(String owner); ApplicationBuilder organization(String organization); ApplicationBuilder architecture(String architecture); ApplicationBuilder environment(String environment); ApplicationBuilder compiler(String compiler); ApplicationBuilder logger(String logger); ApplicationBuilder addRegistry(RegistryConfig registry); ApplicationBuilder addRegistries(List<? extends RegistryConfig> registries); ApplicationBuilder registryIds(String registryIds); ApplicationBuilder monitor(MonitorConfig monitor); ApplicationBuilder monitor(String monitor); ApplicationBuilder isDefault(Boolean isDefault); ApplicationBuilder dumpDirectory(String dumpDirectory); ApplicationBuilder qosEnable(Boolean qosEnable); ApplicationBuilder qosPort(Integer qosPort); ApplicationBuilder qosAcceptForeignIp(Boolean qosAcceptForeignIp); ApplicationBuilder shutwait(String shutwait); ApplicationBuilder appendParameter(String key, String value); ApplicationBuilder appendParameters(Map<String, String> appendParameters); ApplicationConfig build(); } | @Test void addRegistry() { RegistryConfig registry = new RegistryConfig(); ApplicationBuilder builder = new ApplicationBuilder(); builder.addRegistry(registry); Assertions.assertNotNull(builder.build().getRegistry()); Assertions.assertEquals(1, builder.build().getRegistries().size()); Assertions.assertSame(registry, builder.build().getRegistry()); } |
ApplicationBuilder extends AbstractBuilder<ApplicationConfig, ApplicationBuilder> { public ApplicationBuilder addRegistries(List<? extends RegistryConfig> registries) { if (this.registries == null) { this.registries = new ArrayList<>(); } this.registries.addAll(registries); return getThis(); } ApplicationBuilder name(String name); ApplicationBuilder version(String version); ApplicationBuilder owner(String owner); ApplicationBuilder organization(String organization); ApplicationBuilder architecture(String architecture); ApplicationBuilder environment(String environment); ApplicationBuilder compiler(String compiler); ApplicationBuilder logger(String logger); ApplicationBuilder addRegistry(RegistryConfig registry); ApplicationBuilder addRegistries(List<? extends RegistryConfig> registries); ApplicationBuilder registryIds(String registryIds); ApplicationBuilder monitor(MonitorConfig monitor); ApplicationBuilder monitor(String monitor); ApplicationBuilder isDefault(Boolean isDefault); ApplicationBuilder dumpDirectory(String dumpDirectory); ApplicationBuilder qosEnable(Boolean qosEnable); ApplicationBuilder qosPort(Integer qosPort); ApplicationBuilder qosAcceptForeignIp(Boolean qosAcceptForeignIp); ApplicationBuilder shutwait(String shutwait); ApplicationBuilder appendParameter(String key, String value); ApplicationBuilder appendParameters(Map<String, String> appendParameters); ApplicationConfig build(); } | @Test void addRegistries() { RegistryConfig registry = new RegistryConfig(); ApplicationBuilder builder = new ApplicationBuilder(); builder.addRegistries(Collections.singletonList(registry)); Assertions.assertNotNull(builder.build().getRegistry()); Assertions.assertEquals(1, builder.build().getRegistries().size()); Assertions.assertSame(registry, builder.build().getRegistry()); } |
ApplicationBuilder extends AbstractBuilder<ApplicationConfig, ApplicationBuilder> { public ApplicationBuilder registryIds(String registryIds) { this.registryIds = registryIds; return getThis(); } ApplicationBuilder name(String name); ApplicationBuilder version(String version); ApplicationBuilder owner(String owner); ApplicationBuilder organization(String organization); ApplicationBuilder architecture(String architecture); ApplicationBuilder environment(String environment); ApplicationBuilder compiler(String compiler); ApplicationBuilder logger(String logger); ApplicationBuilder addRegistry(RegistryConfig registry); ApplicationBuilder addRegistries(List<? extends RegistryConfig> registries); ApplicationBuilder registryIds(String registryIds); ApplicationBuilder monitor(MonitorConfig monitor); ApplicationBuilder monitor(String monitor); ApplicationBuilder isDefault(Boolean isDefault); ApplicationBuilder dumpDirectory(String dumpDirectory); ApplicationBuilder qosEnable(Boolean qosEnable); ApplicationBuilder qosPort(Integer qosPort); ApplicationBuilder qosAcceptForeignIp(Boolean qosAcceptForeignIp); ApplicationBuilder shutwait(String shutwait); ApplicationBuilder appendParameter(String key, String value); ApplicationBuilder appendParameters(Map<String, String> appendParameters); ApplicationConfig build(); } | @Test void registryIds() { ApplicationBuilder builder = new ApplicationBuilder(); builder.registryIds("registryIds"); Assertions.assertEquals("registryIds", builder.build().getRegistryIds()); } |
ApplicationBuilder extends AbstractBuilder<ApplicationConfig, ApplicationBuilder> { public ApplicationBuilder monitor(MonitorConfig monitor) { this.monitor = monitor; return getThis(); } ApplicationBuilder name(String name); ApplicationBuilder version(String version); ApplicationBuilder owner(String owner); ApplicationBuilder organization(String organization); ApplicationBuilder architecture(String architecture); ApplicationBuilder environment(String environment); ApplicationBuilder compiler(String compiler); ApplicationBuilder logger(String logger); ApplicationBuilder addRegistry(RegistryConfig registry); ApplicationBuilder addRegistries(List<? extends RegistryConfig> registries); ApplicationBuilder registryIds(String registryIds); ApplicationBuilder monitor(MonitorConfig monitor); ApplicationBuilder monitor(String monitor); ApplicationBuilder isDefault(Boolean isDefault); ApplicationBuilder dumpDirectory(String dumpDirectory); ApplicationBuilder qosEnable(Boolean qosEnable); ApplicationBuilder qosPort(Integer qosPort); ApplicationBuilder qosAcceptForeignIp(Boolean qosAcceptForeignIp); ApplicationBuilder shutwait(String shutwait); ApplicationBuilder appendParameter(String key, String value); ApplicationBuilder appendParameters(Map<String, String> appendParameters); ApplicationConfig build(); } | @Test void monitor() { MonitorConfig monitor = new MonitorConfig("monitor-addr"); ApplicationBuilder builder = new ApplicationBuilder(); builder.monitor(monitor); Assertions.assertSame(monitor, builder.build().getMonitor()); Assertions.assertEquals("monitor-addr", builder.build().getMonitor().getAddress()); } |
ApplicationBuilder extends AbstractBuilder<ApplicationConfig, ApplicationBuilder> { public ApplicationBuilder isDefault(Boolean isDefault) { this.isDefault = isDefault; return getThis(); } ApplicationBuilder name(String name); ApplicationBuilder version(String version); ApplicationBuilder owner(String owner); ApplicationBuilder organization(String organization); ApplicationBuilder architecture(String architecture); ApplicationBuilder environment(String environment); ApplicationBuilder compiler(String compiler); ApplicationBuilder logger(String logger); ApplicationBuilder addRegistry(RegistryConfig registry); ApplicationBuilder addRegistries(List<? extends RegistryConfig> registries); ApplicationBuilder registryIds(String registryIds); ApplicationBuilder monitor(MonitorConfig monitor); ApplicationBuilder monitor(String monitor); ApplicationBuilder isDefault(Boolean isDefault); ApplicationBuilder dumpDirectory(String dumpDirectory); ApplicationBuilder qosEnable(Boolean qosEnable); ApplicationBuilder qosPort(Integer qosPort); ApplicationBuilder qosAcceptForeignIp(Boolean qosAcceptForeignIp); ApplicationBuilder shutwait(String shutwait); ApplicationBuilder appendParameter(String key, String value); ApplicationBuilder appendParameters(Map<String, String> appendParameters); ApplicationConfig build(); } | @Test void isDefault() { ApplicationBuilder builder = new ApplicationBuilder(); builder.isDefault(true); Assertions.assertTrue(builder.build().isDefault()); builder.isDefault(false); Assertions.assertFalse(builder.build().isDefault()); builder.isDefault(null); Assertions.assertNull(builder.build().isDefault()); } |
ApplicationBuilder extends AbstractBuilder<ApplicationConfig, ApplicationBuilder> { public ApplicationBuilder dumpDirectory(String dumpDirectory) { this.dumpDirectory = dumpDirectory; return getThis(); } ApplicationBuilder name(String name); ApplicationBuilder version(String version); ApplicationBuilder owner(String owner); ApplicationBuilder organization(String organization); ApplicationBuilder architecture(String architecture); ApplicationBuilder environment(String environment); ApplicationBuilder compiler(String compiler); ApplicationBuilder logger(String logger); ApplicationBuilder addRegistry(RegistryConfig registry); ApplicationBuilder addRegistries(List<? extends RegistryConfig> registries); ApplicationBuilder registryIds(String registryIds); ApplicationBuilder monitor(MonitorConfig monitor); ApplicationBuilder monitor(String monitor); ApplicationBuilder isDefault(Boolean isDefault); ApplicationBuilder dumpDirectory(String dumpDirectory); ApplicationBuilder qosEnable(Boolean qosEnable); ApplicationBuilder qosPort(Integer qosPort); ApplicationBuilder qosAcceptForeignIp(Boolean qosAcceptForeignIp); ApplicationBuilder shutwait(String shutwait); ApplicationBuilder appendParameter(String key, String value); ApplicationBuilder appendParameters(Map<String, String> appendParameters); ApplicationConfig build(); } | @Test void dumpDirectory() { ApplicationBuilder builder = new ApplicationBuilder(); builder.dumpDirectory("dumpDirectory"); Assertions.assertEquals("dumpDirectory", builder.build().getDumpDirectory()); } |
ApplicationBuilder extends AbstractBuilder<ApplicationConfig, ApplicationBuilder> { public ApplicationBuilder qosEnable(Boolean qosEnable) { this.qosEnable = qosEnable; return getThis(); } ApplicationBuilder name(String name); ApplicationBuilder version(String version); ApplicationBuilder owner(String owner); ApplicationBuilder organization(String organization); ApplicationBuilder architecture(String architecture); ApplicationBuilder environment(String environment); ApplicationBuilder compiler(String compiler); ApplicationBuilder logger(String logger); ApplicationBuilder addRegistry(RegistryConfig registry); ApplicationBuilder addRegistries(List<? extends RegistryConfig> registries); ApplicationBuilder registryIds(String registryIds); ApplicationBuilder monitor(MonitorConfig monitor); ApplicationBuilder monitor(String monitor); ApplicationBuilder isDefault(Boolean isDefault); ApplicationBuilder dumpDirectory(String dumpDirectory); ApplicationBuilder qosEnable(Boolean qosEnable); ApplicationBuilder qosPort(Integer qosPort); ApplicationBuilder qosAcceptForeignIp(Boolean qosAcceptForeignIp); ApplicationBuilder shutwait(String shutwait); ApplicationBuilder appendParameter(String key, String value); ApplicationBuilder appendParameters(Map<String, String> appendParameters); ApplicationConfig build(); } | @Test void qosEnable() { ApplicationBuilder builder = new ApplicationBuilder(); builder.qosEnable(true); Assertions.assertTrue(builder.build().getQosEnable()); builder.qosEnable(false); Assertions.assertFalse(builder.build().getQosEnable()); builder.qosEnable(null); Assertions.assertNull(builder.build().getQosEnable()); } |
ApplicationBuilder extends AbstractBuilder<ApplicationConfig, ApplicationBuilder> { public ApplicationBuilder qosPort(Integer qosPort) { this.qosPort = qosPort; return getThis(); } ApplicationBuilder name(String name); ApplicationBuilder version(String version); ApplicationBuilder owner(String owner); ApplicationBuilder organization(String organization); ApplicationBuilder architecture(String architecture); ApplicationBuilder environment(String environment); ApplicationBuilder compiler(String compiler); ApplicationBuilder logger(String logger); ApplicationBuilder addRegistry(RegistryConfig registry); ApplicationBuilder addRegistries(List<? extends RegistryConfig> registries); ApplicationBuilder registryIds(String registryIds); ApplicationBuilder monitor(MonitorConfig monitor); ApplicationBuilder monitor(String monitor); ApplicationBuilder isDefault(Boolean isDefault); ApplicationBuilder dumpDirectory(String dumpDirectory); ApplicationBuilder qosEnable(Boolean qosEnable); ApplicationBuilder qosPort(Integer qosPort); ApplicationBuilder qosAcceptForeignIp(Boolean qosAcceptForeignIp); ApplicationBuilder shutwait(String shutwait); ApplicationBuilder appendParameter(String key, String value); ApplicationBuilder appendParameters(Map<String, String> appendParameters); ApplicationConfig build(); } | @Test void qosPort() { ApplicationBuilder builder = new ApplicationBuilder(); builder.qosPort(8080); Assertions.assertEquals(8080, builder.build().getQosPort()); } |
ApplicationBuilder extends AbstractBuilder<ApplicationConfig, ApplicationBuilder> { public ApplicationBuilder qosAcceptForeignIp(Boolean qosAcceptForeignIp) { this.qosAcceptForeignIp = qosAcceptForeignIp; return getThis(); } ApplicationBuilder name(String name); ApplicationBuilder version(String version); ApplicationBuilder owner(String owner); ApplicationBuilder organization(String organization); ApplicationBuilder architecture(String architecture); ApplicationBuilder environment(String environment); ApplicationBuilder compiler(String compiler); ApplicationBuilder logger(String logger); ApplicationBuilder addRegistry(RegistryConfig registry); ApplicationBuilder addRegistries(List<? extends RegistryConfig> registries); ApplicationBuilder registryIds(String registryIds); ApplicationBuilder monitor(MonitorConfig monitor); ApplicationBuilder monitor(String monitor); ApplicationBuilder isDefault(Boolean isDefault); ApplicationBuilder dumpDirectory(String dumpDirectory); ApplicationBuilder qosEnable(Boolean qosEnable); ApplicationBuilder qosPort(Integer qosPort); ApplicationBuilder qosAcceptForeignIp(Boolean qosAcceptForeignIp); ApplicationBuilder shutwait(String shutwait); ApplicationBuilder appendParameter(String key, String value); ApplicationBuilder appendParameters(Map<String, String> appendParameters); ApplicationConfig build(); } | @Test void qosAcceptForeignIp() { ApplicationBuilder builder = new ApplicationBuilder(); builder.qosAcceptForeignIp(true); Assertions.assertTrue(builder.build().getQosAcceptForeignIp()); builder.qosAcceptForeignIp(false); Assertions.assertFalse(builder.build().getQosAcceptForeignIp()); builder.qosAcceptForeignIp(null); Assertions.assertNull(builder.build().getQosAcceptForeignIp()); } |
ApplicationBuilder extends AbstractBuilder<ApplicationConfig, ApplicationBuilder> { public ApplicationBuilder shutwait(String shutwait) { this.shutwait = shutwait; return getThis(); } ApplicationBuilder name(String name); ApplicationBuilder version(String version); ApplicationBuilder owner(String owner); ApplicationBuilder organization(String organization); ApplicationBuilder architecture(String architecture); ApplicationBuilder environment(String environment); ApplicationBuilder compiler(String compiler); ApplicationBuilder logger(String logger); ApplicationBuilder addRegistry(RegistryConfig registry); ApplicationBuilder addRegistries(List<? extends RegistryConfig> registries); ApplicationBuilder registryIds(String registryIds); ApplicationBuilder monitor(MonitorConfig monitor); ApplicationBuilder monitor(String monitor); ApplicationBuilder isDefault(Boolean isDefault); ApplicationBuilder dumpDirectory(String dumpDirectory); ApplicationBuilder qosEnable(Boolean qosEnable); ApplicationBuilder qosPort(Integer qosPort); ApplicationBuilder qosAcceptForeignIp(Boolean qosAcceptForeignIp); ApplicationBuilder shutwait(String shutwait); ApplicationBuilder appendParameter(String key, String value); ApplicationBuilder appendParameters(Map<String, String> appendParameters); ApplicationConfig build(); } | @Test void shutwait() { ApplicationBuilder builder = new ApplicationBuilder(); builder.shutwait("shutwait"); Assertions.assertEquals("shutwait", builder.build().getShutwait()); } |
ApplicationBuilder extends AbstractBuilder<ApplicationConfig, ApplicationBuilder> { public ApplicationBuilder appendParameter(String key, String value) { this.parameters = appendParameter(parameters, key, value); return getThis(); } ApplicationBuilder name(String name); ApplicationBuilder version(String version); ApplicationBuilder owner(String owner); ApplicationBuilder organization(String organization); ApplicationBuilder architecture(String architecture); ApplicationBuilder environment(String environment); ApplicationBuilder compiler(String compiler); ApplicationBuilder logger(String logger); ApplicationBuilder addRegistry(RegistryConfig registry); ApplicationBuilder addRegistries(List<? extends RegistryConfig> registries); ApplicationBuilder registryIds(String registryIds); ApplicationBuilder monitor(MonitorConfig monitor); ApplicationBuilder monitor(String monitor); ApplicationBuilder isDefault(Boolean isDefault); ApplicationBuilder dumpDirectory(String dumpDirectory); ApplicationBuilder qosEnable(Boolean qosEnable); ApplicationBuilder qosPort(Integer qosPort); ApplicationBuilder qosAcceptForeignIp(Boolean qosAcceptForeignIp); ApplicationBuilder shutwait(String shutwait); ApplicationBuilder appendParameter(String key, String value); ApplicationBuilder appendParameters(Map<String, String> appendParameters); ApplicationConfig build(); } | @Test void appendParameter() { ApplicationBuilder builder = new ApplicationBuilder(); builder.appendParameter("default.num", "one").appendParameter("num", "ONE"); Map<String, String> parameters = builder.build().getParameters(); Assertions.assertTrue(parameters.containsKey("default.num")); Assertions.assertEquals("ONE", parameters.get("num")); } |
ApplicationBuilder extends AbstractBuilder<ApplicationConfig, ApplicationBuilder> { public ApplicationBuilder appendParameters(Map<String, String> appendParameters) { this.parameters = appendParameters(parameters, appendParameters); return getThis(); } ApplicationBuilder name(String name); ApplicationBuilder version(String version); ApplicationBuilder owner(String owner); ApplicationBuilder organization(String organization); ApplicationBuilder architecture(String architecture); ApplicationBuilder environment(String environment); ApplicationBuilder compiler(String compiler); ApplicationBuilder logger(String logger); ApplicationBuilder addRegistry(RegistryConfig registry); ApplicationBuilder addRegistries(List<? extends RegistryConfig> registries); ApplicationBuilder registryIds(String registryIds); ApplicationBuilder monitor(MonitorConfig monitor); ApplicationBuilder monitor(String monitor); ApplicationBuilder isDefault(Boolean isDefault); ApplicationBuilder dumpDirectory(String dumpDirectory); ApplicationBuilder qosEnable(Boolean qosEnable); ApplicationBuilder qosPort(Integer qosPort); ApplicationBuilder qosAcceptForeignIp(Boolean qosAcceptForeignIp); ApplicationBuilder shutwait(String shutwait); ApplicationBuilder appendParameter(String key, String value); ApplicationBuilder appendParameters(Map<String, String> appendParameters); ApplicationConfig build(); } | @Test void appendParameters() { Map<String, String> source = new HashMap<>(); source.put("default.num", "one"); source.put("num", "ONE"); ApplicationBuilder builder = new ApplicationBuilder(); builder.appendParameters(source); Map<String, String> parameters = builder.build().getParameters(); Assertions.assertTrue(parameters.containsKey("default.num")); Assertions.assertEquals("ONE", parameters.get("num")); } |
ApplicationBuilder extends AbstractBuilder<ApplicationConfig, ApplicationBuilder> { public ApplicationConfig build() { ApplicationConfig config = new ApplicationConfig(); super.build(config); config.setName(name); config.setVersion(this.version); config.setOwner(this.owner); config.setOrganization(this.organization); config.setArchitecture(this.architecture); config.setEnvironment(this.environment); config.setCompiler(this.compiler); config.setLogger(this.logger); config.setRegistries(this.registries); config.setRegistryIds(this.registryIds); config.setMonitor(this.monitor); config.setDefault(this.isDefault); config.setDumpDirectory(this.dumpDirectory); config.setQosEnable(this.qosEnable); config.setQosPort(this.qosPort); config.setQosAcceptForeignIp(this.qosAcceptForeignIp); config.setParameters(this.parameters); if (!StringUtils.isEmpty(shutwait)) { config.setShutwait(shutwait); } return config; } ApplicationBuilder name(String name); ApplicationBuilder version(String version); ApplicationBuilder owner(String owner); ApplicationBuilder organization(String organization); ApplicationBuilder architecture(String architecture); ApplicationBuilder environment(String environment); ApplicationBuilder compiler(String compiler); ApplicationBuilder logger(String logger); ApplicationBuilder addRegistry(RegistryConfig registry); ApplicationBuilder addRegistries(List<? extends RegistryConfig> registries); ApplicationBuilder registryIds(String registryIds); ApplicationBuilder monitor(MonitorConfig monitor); ApplicationBuilder monitor(String monitor); ApplicationBuilder isDefault(Boolean isDefault); ApplicationBuilder dumpDirectory(String dumpDirectory); ApplicationBuilder qosEnable(Boolean qosEnable); ApplicationBuilder qosPort(Integer qosPort); ApplicationBuilder qosAcceptForeignIp(Boolean qosAcceptForeignIp); ApplicationBuilder shutwait(String shutwait); ApplicationBuilder appendParameter(String key, String value); ApplicationBuilder appendParameters(Map<String, String> appendParameters); ApplicationConfig build(); } | @Test void build() { MonitorConfig monitor = new MonitorConfig("monitor-addr"); RegistryConfig registry = new RegistryConfig(); ApplicationBuilder builder = new ApplicationBuilder(); builder.id("id").prefix("prefix").name("name").version("version").owner("owner").organization("organization").architecture("architecture") .environment("develop").compiler("compiler").logger("log4j").monitor(monitor).isDefault(false) .dumpDirectory("dumpDirectory").qosEnable(true).qosPort(8080).qosAcceptForeignIp(false) .shutwait("shutwait").registryIds("registryIds").addRegistry(registry) .appendParameter("default.num", "one"); ApplicationConfig config = builder.build(); ApplicationConfig config2 = builder.build(); Assertions.assertEquals("id", config.getId()); Assertions.assertEquals("prefix", config.getPrefix()); Assertions.assertEquals("name", config.getName()); Assertions.assertEquals("version", config.getVersion()); Assertions.assertEquals("owner", config.getOwner()); Assertions.assertEquals("organization", config.getOrganization()); Assertions.assertEquals("architecture", config.getArchitecture()); Assertions.assertEquals("develop", config.getEnvironment()); Assertions.assertEquals("compiler", config.getCompiler()); Assertions.assertEquals("log4j", config.getLogger()); Assertions.assertSame(monitor, config.getMonitor()); Assertions.assertFalse(config.isDefault()); Assertions.assertEquals("dumpDirectory", config.getDumpDirectory()); Assertions.assertTrue(config.getQosEnable()); Assertions.assertEquals(8080, config.getQosPort()); Assertions.assertFalse(config.getQosAcceptForeignIp()); Assertions.assertEquals("shutwait", config.getShutwait()); Assertions.assertEquals("registryIds", config.getRegistryIds()); Assertions.assertSame(registry, config.getRegistry()); Assertions.assertTrue(config.getParameters().containsKey("default.num")); Assertions.assertEquals("one", config.getParameters().get("default.num")); Assertions.assertNotSame(config, config2); } |
AccessLogFilter implements Filter { @Override public Result invoke(Invoker<?> invoker, Invocation inv) throws RpcException { try { String accessLogKey = invoker.getUrl().getParameter(Constants.ACCESS_LOG_KEY); if (ConfigUtils.isNotEmpty(accessLogKey)) { AccessLogData logData = buildAccessLogData(invoker, inv); log(accessLogKey, logData); } } catch (Throwable t) { logger.warn("Exception in AccessLogFilter of service(" + invoker + " -> " + inv + ")", t); } return invoker.invoke(inv); } AccessLogFilter(); @Override Result invoke(Invoker<?> invoker, Invocation inv); } | @Test public void testInvokeException() { Invoker<AccessLogFilterTest> invoker = new MyInvoker<AccessLogFilterTest>(null); Invocation invocation = new MockInvocation(); LogUtil.start(); accessLogFilter.invoke(invoker, invocation); assertEquals(1, LogUtil.findMessage("Exception in AccessLogFilter of service")); LogUtil.stop(); }
@Test public void testDefault() { URL url = URL.valueOf("test: Invoker<AccessLogFilterTest> invoker = new MyInvoker<AccessLogFilterTest>(url); Invocation invocation = new MockInvocation(); accessLogFilter.invoke(invoker, invocation); }
@Test public void testCustom() { URL url = URL.valueOf("test: Invoker<AccessLogFilterTest> invoker = new MyInvoker<AccessLogFilterTest>(url); Invocation invocation = new MockInvocation(); accessLogFilter.invoke(invoker, invocation); } |
HessianProtocol extends AbstractProxyProtocol { @Override public void destroy() { super.destroy(); for (String key : new ArrayList<String>(serverMap.keySet())) { HttpServer server = serverMap.remove(key); if (server != null) { try { if (logger.isInfoEnabled()) { logger.info("Close hessian server " + server.getUrl()); } server.close(); } catch (Throwable t) { logger.warn(t.getMessage(), t); } } } } HessianProtocol(); void setHttpBinder(HttpBinder httpBinder); @Override int getDefaultPort(); @Override void destroy(); } | @Test public void testGenericInvoke() { HessianServiceImpl server = new HessianServiceImpl(); Assertions.assertFalse(server.isCalled()); ProxyFactory proxyFactory = ExtensionLoader.getExtensionLoader(ProxyFactory.class).getAdaptiveExtension(); Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension(); URL url = URL.valueOf("hessian: Exporter<HessianService> exporter = protocol.export(proxyFactory.getInvoker(server, HessianService.class, url)); Invoker<GenericService> invoker = protocol.refer(GenericService.class, url); GenericService client = proxyFactory.getProxy(invoker, true); String result = (String) client.$invoke("sayHello", new String[]{"java.lang.String"}, new Object[]{"haha"}); Assertions.assertTrue(server.isCalled()); Assertions.assertEquals("Hello, haha", result); invoker.destroy(); exporter.unexport(); }
@Test public void testGenericInvokeWithNativeJava() throws IOException, ClassNotFoundException { HessianServiceImpl server = new HessianServiceImpl(); Assertions.assertFalse(server.isCalled()); ProxyFactory proxyFactory = ExtensionLoader.getExtensionLoader(ProxyFactory.class).getAdaptiveExtension(); Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension(); URL url = URL.valueOf("hessian: Exporter<HessianService> exporter = protocol.export(proxyFactory.getInvoker(server, HessianService.class, url)); Invoker<GenericService> invoker = protocol.refer(GenericService.class, url); GenericService client = proxyFactory.getProxy(invoker); Serialization serialization = new NativeJavaSerialization(); ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); ObjectOutput objectOutput = serialization.serialize(url, byteArrayOutputStream); objectOutput.writeObject("haha"); objectOutput.flushBuffer(); Object result = client.$invoke("sayHello", new String[]{"java.lang.String"}, new Object[]{byteArrayOutputStream.toByteArray()}); ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream((byte[]) result); ObjectInput objectInput = serialization.deserialize(url, byteArrayInputStream); Assertions.assertTrue(server.isCalled()); Assertions.assertEquals("Hello, haha", objectInput.readObject()); invoker.destroy(); exporter.unexport(); }
@Test public void testGenericInvokeWithRpcContext() { RpcContext.getContext().setAttachment("myContext", "123"); HessianServiceImpl server = new HessianServiceImpl(); ProxyFactory proxyFactory = ExtensionLoader.getExtensionLoader(ProxyFactory.class).getAdaptiveExtension(); Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension(); URL url = URL.valueOf("hessian: Exporter<HessianService> exporter = protocol.export(proxyFactory.getInvoker(server, HessianService.class, url)); Invoker<GenericService> invoker = protocol.refer(GenericService.class, url); GenericService client = proxyFactory.getProxy(invoker, true); String result = (String) client.$invoke("context", new String[]{"java.lang.String"}, new Object[]{"haha"}); Assertions.assertEquals("Hello, haha context, 123", result); invoker.destroy(); exporter.unexport(); }
@Test public void testGenericInvokeWithBean() { HessianServiceImpl server = new HessianServiceImpl(); Assertions.assertFalse(server.isCalled()); ProxyFactory proxyFactory = ExtensionLoader.getExtensionLoader(ProxyFactory.class).getAdaptiveExtension(); Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension(); URL url = URL.valueOf("hessian: Exporter<HessianService> exporter = protocol.export(proxyFactory.getInvoker(server, HessianService.class, url)); Invoker<GenericService> invoker = protocol.refer(GenericService.class, url); GenericService client = proxyFactory.getProxy(invoker); JavaBeanDescriptor javaBeanDescriptor = JavaBeanSerializeUtil.serialize("haha"); Object result = client.$invoke("sayHello", new String[]{"java.lang.String"}, new Object[]{javaBeanDescriptor}); Assertions.assertTrue(server.isCalled()); Assertions.assertEquals("Hello, haha", JavaBeanSerializeUtil.deserialize((JavaBeanDescriptor) result)); invoker.destroy(); exporter.unexport(); }
@Test public void testOverload() { HessianServiceImpl server = new HessianServiceImpl(); Assertions.assertFalse(server.isCalled()); ProxyFactory proxyFactory = ExtensionLoader.getExtensionLoader(ProxyFactory.class).getAdaptiveExtension(); Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension(); URL url = URL.valueOf("hessian: Exporter<HessianService> exporter = protocol.export(proxyFactory.getInvoker(server, HessianService.class, url)); Invoker<HessianService> invoker = protocol.refer(HessianService.class, url); HessianService client = proxyFactory.getProxy(invoker); String result = client.sayHello("haha"); Assertions.assertEquals("Hello, haha", result); result = client.sayHello("haha", 1); Assertions.assertEquals("Hello, haha. ", result); invoker.destroy(); exporter.unexport(); }
@Test public void testHttpClient() { HessianServiceImpl server = new HessianServiceImpl(); Assertions.assertFalse(server.isCalled()); ProxyFactory proxyFactory = ExtensionLoader.getExtensionLoader(ProxyFactory.class).getAdaptiveExtension(); Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension(); URL url = URL.valueOf("hessian: Exporter<HessianService> exporter = protocol.export(proxyFactory.getInvoker(server, HessianService.class, url)); Invoker<HessianService> invoker = protocol.refer(HessianService.class, url); HessianService client = proxyFactory.getProxy(invoker); String result = client.sayHello("haha"); Assertions.assertTrue(server.isCalled()); Assertions.assertEquals("Hello, haha", result); invoker.destroy(); exporter.unexport(); }
@Test public void testTimeOut() { HessianServiceImpl server = new HessianServiceImpl(); ProxyFactory proxyFactory = ExtensionLoader.getExtensionLoader(ProxyFactory.class).getAdaptiveExtension(); Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension(); URL url = URL.valueOf("hessian: Exporter<HessianService> exporter = protocol.export(proxyFactory.getInvoker(server, HessianService.class, url)); Invoker<HessianService> invoker = protocol.refer(HessianService.class, url); HessianService client = proxyFactory.getProxy(invoker); try { client.timeOut(6000); fail(); } catch (RpcException expected) { Assertions.assertTrue(expected.isTimeout()); } finally { invoker.destroy(); exporter.unexport(); } }
@Test public void testCustomException() { HessianServiceImpl server = new HessianServiceImpl(); ProxyFactory proxyFactory = ExtensionLoader.getExtensionLoader(ProxyFactory.class).getAdaptiveExtension(); Protocol protocol = ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension(); URL url = URL.valueOf("hessian: Exporter<HessianService> exporter = protocol.export(proxyFactory.getInvoker(server, HessianService.class, url)); Invoker<HessianService> invoker = protocol.refer(HessianService.class, url); HessianService client = proxyFactory.getProxy(invoker); try { client.customException(); fail(); } catch (MyException expected) { } invoker.destroy(); exporter.unexport(); } |
RegistryBuilder extends AbstractBuilder<RegistryConfig, RegistryBuilder> { public RegistryBuilder address(String address) { this.address = address; return getThis(); } RegistryBuilder address(String address); RegistryBuilder username(String username); RegistryBuilder password(String password); RegistryBuilder port(Integer port); RegistryBuilder protocol(String protocol); RegistryBuilder transporter(String transporter); @Deprecated RegistryBuilder transport(String transport); RegistryBuilder server(String server); RegistryBuilder client(String client); RegistryBuilder cluster(String cluster); RegistryBuilder group(String group); RegistryBuilder version(String version); RegistryBuilder timeout(Integer timeout); RegistryBuilder session(Integer session); RegistryBuilder file(String file); @Deprecated RegistryBuilder wait(Integer wait); RegistryBuilder isCheck(Boolean check); RegistryBuilder isDynamic(Boolean dynamic); RegistryBuilder register(Boolean register); RegistryBuilder subscribe(Boolean subscribe); RegistryBuilder appendParameter(String key, String value); RegistryBuilder appendParameters(Map<String, String> appendParameters); RegistryBuilder isDefault(Boolean isDefault); RegistryBuilder simplified(Boolean simplified); RegistryBuilder extraKeys(String extraKeys); RegistryConfig build(); } | @Test void address() { RegistryBuilder builder = new RegistryBuilder(); builder.address("address"); Assertions.assertEquals("address", builder.build().getAddress()); } |
RegistryBuilder extends AbstractBuilder<RegistryConfig, RegistryBuilder> { public RegistryBuilder username(String username) { this.username = username; return getThis(); } RegistryBuilder address(String address); RegistryBuilder username(String username); RegistryBuilder password(String password); RegistryBuilder port(Integer port); RegistryBuilder protocol(String protocol); RegistryBuilder transporter(String transporter); @Deprecated RegistryBuilder transport(String transport); RegistryBuilder server(String server); RegistryBuilder client(String client); RegistryBuilder cluster(String cluster); RegistryBuilder group(String group); RegistryBuilder version(String version); RegistryBuilder timeout(Integer timeout); RegistryBuilder session(Integer session); RegistryBuilder file(String file); @Deprecated RegistryBuilder wait(Integer wait); RegistryBuilder isCheck(Boolean check); RegistryBuilder isDynamic(Boolean dynamic); RegistryBuilder register(Boolean register); RegistryBuilder subscribe(Boolean subscribe); RegistryBuilder appendParameter(String key, String value); RegistryBuilder appendParameters(Map<String, String> appendParameters); RegistryBuilder isDefault(Boolean isDefault); RegistryBuilder simplified(Boolean simplified); RegistryBuilder extraKeys(String extraKeys); RegistryConfig build(); } | @Test void username() { RegistryBuilder builder = new RegistryBuilder(); builder.username("username"); Assertions.assertEquals("username", builder.build().getUsername()); } |
RegistryBuilder extends AbstractBuilder<RegistryConfig, RegistryBuilder> { public RegistryBuilder password(String password) { this.password = password; return getThis(); } RegistryBuilder address(String address); RegistryBuilder username(String username); RegistryBuilder password(String password); RegistryBuilder port(Integer port); RegistryBuilder protocol(String protocol); RegistryBuilder transporter(String transporter); @Deprecated RegistryBuilder transport(String transport); RegistryBuilder server(String server); RegistryBuilder client(String client); RegistryBuilder cluster(String cluster); RegistryBuilder group(String group); RegistryBuilder version(String version); RegistryBuilder timeout(Integer timeout); RegistryBuilder session(Integer session); RegistryBuilder file(String file); @Deprecated RegistryBuilder wait(Integer wait); RegistryBuilder isCheck(Boolean check); RegistryBuilder isDynamic(Boolean dynamic); RegistryBuilder register(Boolean register); RegistryBuilder subscribe(Boolean subscribe); RegistryBuilder appendParameter(String key, String value); RegistryBuilder appendParameters(Map<String, String> appendParameters); RegistryBuilder isDefault(Boolean isDefault); RegistryBuilder simplified(Boolean simplified); RegistryBuilder extraKeys(String extraKeys); RegistryConfig build(); } | @Test void password() { RegistryBuilder builder = new RegistryBuilder(); builder.password("password"); Assertions.assertEquals("password", builder.build().getPassword()); } |
RegistryBuilder extends AbstractBuilder<RegistryConfig, RegistryBuilder> { public RegistryBuilder port(Integer port) { this.port = port; return getThis(); } RegistryBuilder address(String address); RegistryBuilder username(String username); RegistryBuilder password(String password); RegistryBuilder port(Integer port); RegistryBuilder protocol(String protocol); RegistryBuilder transporter(String transporter); @Deprecated RegistryBuilder transport(String transport); RegistryBuilder server(String server); RegistryBuilder client(String client); RegistryBuilder cluster(String cluster); RegistryBuilder group(String group); RegistryBuilder version(String version); RegistryBuilder timeout(Integer timeout); RegistryBuilder session(Integer session); RegistryBuilder file(String file); @Deprecated RegistryBuilder wait(Integer wait); RegistryBuilder isCheck(Boolean check); RegistryBuilder isDynamic(Boolean dynamic); RegistryBuilder register(Boolean register); RegistryBuilder subscribe(Boolean subscribe); RegistryBuilder appendParameter(String key, String value); RegistryBuilder appendParameters(Map<String, String> appendParameters); RegistryBuilder isDefault(Boolean isDefault); RegistryBuilder simplified(Boolean simplified); RegistryBuilder extraKeys(String extraKeys); RegistryConfig build(); } | @Test void port() { RegistryBuilder builder = new RegistryBuilder(); builder.port(8080); Assertions.assertEquals(8080, builder.build().getPort()); } |
RegistryBuilder extends AbstractBuilder<RegistryConfig, RegistryBuilder> { public RegistryBuilder protocol(String protocol) { this.protocol = protocol; return getThis(); } RegistryBuilder address(String address); RegistryBuilder username(String username); RegistryBuilder password(String password); RegistryBuilder port(Integer port); RegistryBuilder protocol(String protocol); RegistryBuilder transporter(String transporter); @Deprecated RegistryBuilder transport(String transport); RegistryBuilder server(String server); RegistryBuilder client(String client); RegistryBuilder cluster(String cluster); RegistryBuilder group(String group); RegistryBuilder version(String version); RegistryBuilder timeout(Integer timeout); RegistryBuilder session(Integer session); RegistryBuilder file(String file); @Deprecated RegistryBuilder wait(Integer wait); RegistryBuilder isCheck(Boolean check); RegistryBuilder isDynamic(Boolean dynamic); RegistryBuilder register(Boolean register); RegistryBuilder subscribe(Boolean subscribe); RegistryBuilder appendParameter(String key, String value); RegistryBuilder appendParameters(Map<String, String> appendParameters); RegistryBuilder isDefault(Boolean isDefault); RegistryBuilder simplified(Boolean simplified); RegistryBuilder extraKeys(String extraKeys); RegistryConfig build(); } | @Test void protocol() { RegistryBuilder builder = new RegistryBuilder(); builder.protocol("protocol"); Assertions.assertEquals("protocol", builder.build().getProtocol()); } |
RegistryBuilder extends AbstractBuilder<RegistryConfig, RegistryBuilder> { public RegistryBuilder transporter(String transporter) { this.transporter = transporter; return getThis(); } RegistryBuilder address(String address); RegistryBuilder username(String username); RegistryBuilder password(String password); RegistryBuilder port(Integer port); RegistryBuilder protocol(String protocol); RegistryBuilder transporter(String transporter); @Deprecated RegistryBuilder transport(String transport); RegistryBuilder server(String server); RegistryBuilder client(String client); RegistryBuilder cluster(String cluster); RegistryBuilder group(String group); RegistryBuilder version(String version); RegistryBuilder timeout(Integer timeout); RegistryBuilder session(Integer session); RegistryBuilder file(String file); @Deprecated RegistryBuilder wait(Integer wait); RegistryBuilder isCheck(Boolean check); RegistryBuilder isDynamic(Boolean dynamic); RegistryBuilder register(Boolean register); RegistryBuilder subscribe(Boolean subscribe); RegistryBuilder appendParameter(String key, String value); RegistryBuilder appendParameters(Map<String, String> appendParameters); RegistryBuilder isDefault(Boolean isDefault); RegistryBuilder simplified(Boolean simplified); RegistryBuilder extraKeys(String extraKeys); RegistryConfig build(); } | @Test void transporter() { RegistryBuilder builder = new RegistryBuilder(); builder.transporter("transporter"); Assertions.assertEquals("transporter", builder.build().getTransporter()); } |
RegistryBuilder extends AbstractBuilder<RegistryConfig, RegistryBuilder> { @Deprecated public RegistryBuilder transport(String transport) { this.transporter = transport; return getThis(); } RegistryBuilder address(String address); RegistryBuilder username(String username); RegistryBuilder password(String password); RegistryBuilder port(Integer port); RegistryBuilder protocol(String protocol); RegistryBuilder transporter(String transporter); @Deprecated RegistryBuilder transport(String transport); RegistryBuilder server(String server); RegistryBuilder client(String client); RegistryBuilder cluster(String cluster); RegistryBuilder group(String group); RegistryBuilder version(String version); RegistryBuilder timeout(Integer timeout); RegistryBuilder session(Integer session); RegistryBuilder file(String file); @Deprecated RegistryBuilder wait(Integer wait); RegistryBuilder isCheck(Boolean check); RegistryBuilder isDynamic(Boolean dynamic); RegistryBuilder register(Boolean register); RegistryBuilder subscribe(Boolean subscribe); RegistryBuilder appendParameter(String key, String value); RegistryBuilder appendParameters(Map<String, String> appendParameters); RegistryBuilder isDefault(Boolean isDefault); RegistryBuilder simplified(Boolean simplified); RegistryBuilder extraKeys(String extraKeys); RegistryConfig build(); } | @Test void transport() { RegistryBuilder builder = new RegistryBuilder(); builder.transport("transport"); Assertions.assertEquals("transport", builder.build().getTransport()); } |
RegistryBuilder extends AbstractBuilder<RegistryConfig, RegistryBuilder> { public RegistryBuilder server(String server) { this.server = server; return getThis(); } RegistryBuilder address(String address); RegistryBuilder username(String username); RegistryBuilder password(String password); RegistryBuilder port(Integer port); RegistryBuilder protocol(String protocol); RegistryBuilder transporter(String transporter); @Deprecated RegistryBuilder transport(String transport); RegistryBuilder server(String server); RegistryBuilder client(String client); RegistryBuilder cluster(String cluster); RegistryBuilder group(String group); RegistryBuilder version(String version); RegistryBuilder timeout(Integer timeout); RegistryBuilder session(Integer session); RegistryBuilder file(String file); @Deprecated RegistryBuilder wait(Integer wait); RegistryBuilder isCheck(Boolean check); RegistryBuilder isDynamic(Boolean dynamic); RegistryBuilder register(Boolean register); RegistryBuilder subscribe(Boolean subscribe); RegistryBuilder appendParameter(String key, String value); RegistryBuilder appendParameters(Map<String, String> appendParameters); RegistryBuilder isDefault(Boolean isDefault); RegistryBuilder simplified(Boolean simplified); RegistryBuilder extraKeys(String extraKeys); RegistryConfig build(); } | @Test void server() { RegistryBuilder builder = new RegistryBuilder(); builder.server("server"); Assertions.assertEquals("server", builder.build().getServer()); } |
RegistryBuilder extends AbstractBuilder<RegistryConfig, RegistryBuilder> { public RegistryBuilder client(String client) { this.client = client; return getThis(); } RegistryBuilder address(String address); RegistryBuilder username(String username); RegistryBuilder password(String password); RegistryBuilder port(Integer port); RegistryBuilder protocol(String protocol); RegistryBuilder transporter(String transporter); @Deprecated RegistryBuilder transport(String transport); RegistryBuilder server(String server); RegistryBuilder client(String client); RegistryBuilder cluster(String cluster); RegistryBuilder group(String group); RegistryBuilder version(String version); RegistryBuilder timeout(Integer timeout); RegistryBuilder session(Integer session); RegistryBuilder file(String file); @Deprecated RegistryBuilder wait(Integer wait); RegistryBuilder isCheck(Boolean check); RegistryBuilder isDynamic(Boolean dynamic); RegistryBuilder register(Boolean register); RegistryBuilder subscribe(Boolean subscribe); RegistryBuilder appendParameter(String key, String value); RegistryBuilder appendParameters(Map<String, String> appendParameters); RegistryBuilder isDefault(Boolean isDefault); RegistryBuilder simplified(Boolean simplified); RegistryBuilder extraKeys(String extraKeys); RegistryConfig build(); } | @Test void client() { RegistryBuilder builder = new RegistryBuilder(); builder.client("client"); Assertions.assertEquals("client", builder.build().getClient()); } |
RegistryBuilder extends AbstractBuilder<RegistryConfig, RegistryBuilder> { public RegistryBuilder cluster(String cluster) { this.cluster = cluster; return getThis(); } RegistryBuilder address(String address); RegistryBuilder username(String username); RegistryBuilder password(String password); RegistryBuilder port(Integer port); RegistryBuilder protocol(String protocol); RegistryBuilder transporter(String transporter); @Deprecated RegistryBuilder transport(String transport); RegistryBuilder server(String server); RegistryBuilder client(String client); RegistryBuilder cluster(String cluster); RegistryBuilder group(String group); RegistryBuilder version(String version); RegistryBuilder timeout(Integer timeout); RegistryBuilder session(Integer session); RegistryBuilder file(String file); @Deprecated RegistryBuilder wait(Integer wait); RegistryBuilder isCheck(Boolean check); RegistryBuilder isDynamic(Boolean dynamic); RegistryBuilder register(Boolean register); RegistryBuilder subscribe(Boolean subscribe); RegistryBuilder appendParameter(String key, String value); RegistryBuilder appendParameters(Map<String, String> appendParameters); RegistryBuilder isDefault(Boolean isDefault); RegistryBuilder simplified(Boolean simplified); RegistryBuilder extraKeys(String extraKeys); RegistryConfig build(); } | @Test void cluster() { RegistryBuilder builder = new RegistryBuilder(); builder.cluster("cluster"); Assertions.assertEquals("cluster", builder.build().getCluster()); } |
RegistryBuilder extends AbstractBuilder<RegistryConfig, RegistryBuilder> { public RegistryBuilder group(String group) { this.group = group; return getThis(); } RegistryBuilder address(String address); RegistryBuilder username(String username); RegistryBuilder password(String password); RegistryBuilder port(Integer port); RegistryBuilder protocol(String protocol); RegistryBuilder transporter(String transporter); @Deprecated RegistryBuilder transport(String transport); RegistryBuilder server(String server); RegistryBuilder client(String client); RegistryBuilder cluster(String cluster); RegistryBuilder group(String group); RegistryBuilder version(String version); RegistryBuilder timeout(Integer timeout); RegistryBuilder session(Integer session); RegistryBuilder file(String file); @Deprecated RegistryBuilder wait(Integer wait); RegistryBuilder isCheck(Boolean check); RegistryBuilder isDynamic(Boolean dynamic); RegistryBuilder register(Boolean register); RegistryBuilder subscribe(Boolean subscribe); RegistryBuilder appendParameter(String key, String value); RegistryBuilder appendParameters(Map<String, String> appendParameters); RegistryBuilder isDefault(Boolean isDefault); RegistryBuilder simplified(Boolean simplified); RegistryBuilder extraKeys(String extraKeys); RegistryConfig build(); } | @Test void group() { RegistryBuilder builder = new RegistryBuilder(); builder.group("group"); Assertions.assertEquals("group", builder.build().getGroup()); } |
RegistryBuilder extends AbstractBuilder<RegistryConfig, RegistryBuilder> { public RegistryBuilder version(String version) { this.version = version; return getThis(); } RegistryBuilder address(String address); RegistryBuilder username(String username); RegistryBuilder password(String password); RegistryBuilder port(Integer port); RegistryBuilder protocol(String protocol); RegistryBuilder transporter(String transporter); @Deprecated RegistryBuilder transport(String transport); RegistryBuilder server(String server); RegistryBuilder client(String client); RegistryBuilder cluster(String cluster); RegistryBuilder group(String group); RegistryBuilder version(String version); RegistryBuilder timeout(Integer timeout); RegistryBuilder session(Integer session); RegistryBuilder file(String file); @Deprecated RegistryBuilder wait(Integer wait); RegistryBuilder isCheck(Boolean check); RegistryBuilder isDynamic(Boolean dynamic); RegistryBuilder register(Boolean register); RegistryBuilder subscribe(Boolean subscribe); RegistryBuilder appendParameter(String key, String value); RegistryBuilder appendParameters(Map<String, String> appendParameters); RegistryBuilder isDefault(Boolean isDefault); RegistryBuilder simplified(Boolean simplified); RegistryBuilder extraKeys(String extraKeys); RegistryConfig build(); } | @Test void version() { RegistryBuilder builder = new RegistryBuilder(); builder.version("version"); Assertions.assertEquals("version", builder.build().getVersion()); } |
RegistryBuilder extends AbstractBuilder<RegistryConfig, RegistryBuilder> { public RegistryBuilder timeout(Integer timeout) { this.timeout = timeout; return getThis(); } RegistryBuilder address(String address); RegistryBuilder username(String username); RegistryBuilder password(String password); RegistryBuilder port(Integer port); RegistryBuilder protocol(String protocol); RegistryBuilder transporter(String transporter); @Deprecated RegistryBuilder transport(String transport); RegistryBuilder server(String server); RegistryBuilder client(String client); RegistryBuilder cluster(String cluster); RegistryBuilder group(String group); RegistryBuilder version(String version); RegistryBuilder timeout(Integer timeout); RegistryBuilder session(Integer session); RegistryBuilder file(String file); @Deprecated RegistryBuilder wait(Integer wait); RegistryBuilder isCheck(Boolean check); RegistryBuilder isDynamic(Boolean dynamic); RegistryBuilder register(Boolean register); RegistryBuilder subscribe(Boolean subscribe); RegistryBuilder appendParameter(String key, String value); RegistryBuilder appendParameters(Map<String, String> appendParameters); RegistryBuilder isDefault(Boolean isDefault); RegistryBuilder simplified(Boolean simplified); RegistryBuilder extraKeys(String extraKeys); RegistryConfig build(); } | @Test void timeout() { RegistryBuilder builder = new RegistryBuilder(); builder.timeout(1000); Assertions.assertEquals(1000, builder.build().getTimeout()); } |
RegistryBuilder extends AbstractBuilder<RegistryConfig, RegistryBuilder> { public RegistryBuilder session(Integer session) { this.session = session; return getThis(); } RegistryBuilder address(String address); RegistryBuilder username(String username); RegistryBuilder password(String password); RegistryBuilder port(Integer port); RegistryBuilder protocol(String protocol); RegistryBuilder transporter(String transporter); @Deprecated RegistryBuilder transport(String transport); RegistryBuilder server(String server); RegistryBuilder client(String client); RegistryBuilder cluster(String cluster); RegistryBuilder group(String group); RegistryBuilder version(String version); RegistryBuilder timeout(Integer timeout); RegistryBuilder session(Integer session); RegistryBuilder file(String file); @Deprecated RegistryBuilder wait(Integer wait); RegistryBuilder isCheck(Boolean check); RegistryBuilder isDynamic(Boolean dynamic); RegistryBuilder register(Boolean register); RegistryBuilder subscribe(Boolean subscribe); RegistryBuilder appendParameter(String key, String value); RegistryBuilder appendParameters(Map<String, String> appendParameters); RegistryBuilder isDefault(Boolean isDefault); RegistryBuilder simplified(Boolean simplified); RegistryBuilder extraKeys(String extraKeys); RegistryConfig build(); } | @Test void session() { RegistryBuilder builder = new RegistryBuilder(); builder.session(2000); Assertions.assertEquals(2000, builder.build().getSession()); } |
RegistryBuilder extends AbstractBuilder<RegistryConfig, RegistryBuilder> { public RegistryBuilder file(String file) { this.file = file; return getThis(); } RegistryBuilder address(String address); RegistryBuilder username(String username); RegistryBuilder password(String password); RegistryBuilder port(Integer port); RegistryBuilder protocol(String protocol); RegistryBuilder transporter(String transporter); @Deprecated RegistryBuilder transport(String transport); RegistryBuilder server(String server); RegistryBuilder client(String client); RegistryBuilder cluster(String cluster); RegistryBuilder group(String group); RegistryBuilder version(String version); RegistryBuilder timeout(Integer timeout); RegistryBuilder session(Integer session); RegistryBuilder file(String file); @Deprecated RegistryBuilder wait(Integer wait); RegistryBuilder isCheck(Boolean check); RegistryBuilder isDynamic(Boolean dynamic); RegistryBuilder register(Boolean register); RegistryBuilder subscribe(Boolean subscribe); RegistryBuilder appendParameter(String key, String value); RegistryBuilder appendParameters(Map<String, String> appendParameters); RegistryBuilder isDefault(Boolean isDefault); RegistryBuilder simplified(Boolean simplified); RegistryBuilder extraKeys(String extraKeys); RegistryConfig build(); } | @Test void file() { RegistryBuilder builder = new RegistryBuilder(); builder.file("file"); Assertions.assertEquals("file", builder.build().getFile()); } |
RegistryBuilder extends AbstractBuilder<RegistryConfig, RegistryBuilder> { @Deprecated public RegistryBuilder wait(Integer wait) { this.wait = wait; return getThis(); } RegistryBuilder address(String address); RegistryBuilder username(String username); RegistryBuilder password(String password); RegistryBuilder port(Integer port); RegistryBuilder protocol(String protocol); RegistryBuilder transporter(String transporter); @Deprecated RegistryBuilder transport(String transport); RegistryBuilder server(String server); RegistryBuilder client(String client); RegistryBuilder cluster(String cluster); RegistryBuilder group(String group); RegistryBuilder version(String version); RegistryBuilder timeout(Integer timeout); RegistryBuilder session(Integer session); RegistryBuilder file(String file); @Deprecated RegistryBuilder wait(Integer wait); RegistryBuilder isCheck(Boolean check); RegistryBuilder isDynamic(Boolean dynamic); RegistryBuilder register(Boolean register); RegistryBuilder subscribe(Boolean subscribe); RegistryBuilder appendParameter(String key, String value); RegistryBuilder appendParameters(Map<String, String> appendParameters); RegistryBuilder isDefault(Boolean isDefault); RegistryBuilder simplified(Boolean simplified); RegistryBuilder extraKeys(String extraKeys); RegistryConfig build(); } | @Test void testWait() { RegistryBuilder builder = new RegistryBuilder(); builder.wait(Integer.valueOf(1000)); Assertions.assertEquals(1000, builder.build().getWait()); } |
RegistryBuilder extends AbstractBuilder<RegistryConfig, RegistryBuilder> { public RegistryBuilder isCheck(Boolean check) { this.check = check; return getThis(); } RegistryBuilder address(String address); RegistryBuilder username(String username); RegistryBuilder password(String password); RegistryBuilder port(Integer port); RegistryBuilder protocol(String protocol); RegistryBuilder transporter(String transporter); @Deprecated RegistryBuilder transport(String transport); RegistryBuilder server(String server); RegistryBuilder client(String client); RegistryBuilder cluster(String cluster); RegistryBuilder group(String group); RegistryBuilder version(String version); RegistryBuilder timeout(Integer timeout); RegistryBuilder session(Integer session); RegistryBuilder file(String file); @Deprecated RegistryBuilder wait(Integer wait); RegistryBuilder isCheck(Boolean check); RegistryBuilder isDynamic(Boolean dynamic); RegistryBuilder register(Boolean register); RegistryBuilder subscribe(Boolean subscribe); RegistryBuilder appendParameter(String key, String value); RegistryBuilder appendParameters(Map<String, String> appendParameters); RegistryBuilder isDefault(Boolean isDefault); RegistryBuilder simplified(Boolean simplified); RegistryBuilder extraKeys(String extraKeys); RegistryConfig build(); } | @Test void isCheck() { RegistryBuilder builder = new RegistryBuilder(); builder.isCheck(true); Assertions.assertTrue(builder.build().isCheck()); } |
RegistryBuilder extends AbstractBuilder<RegistryConfig, RegistryBuilder> { public RegistryBuilder isDynamic(Boolean dynamic) { this.dynamic = dynamic; return getThis(); } RegistryBuilder address(String address); RegistryBuilder username(String username); RegistryBuilder password(String password); RegistryBuilder port(Integer port); RegistryBuilder protocol(String protocol); RegistryBuilder transporter(String transporter); @Deprecated RegistryBuilder transport(String transport); RegistryBuilder server(String server); RegistryBuilder client(String client); RegistryBuilder cluster(String cluster); RegistryBuilder group(String group); RegistryBuilder version(String version); RegistryBuilder timeout(Integer timeout); RegistryBuilder session(Integer session); RegistryBuilder file(String file); @Deprecated RegistryBuilder wait(Integer wait); RegistryBuilder isCheck(Boolean check); RegistryBuilder isDynamic(Boolean dynamic); RegistryBuilder register(Boolean register); RegistryBuilder subscribe(Boolean subscribe); RegistryBuilder appendParameter(String key, String value); RegistryBuilder appendParameters(Map<String, String> appendParameters); RegistryBuilder isDefault(Boolean isDefault); RegistryBuilder simplified(Boolean simplified); RegistryBuilder extraKeys(String extraKeys); RegistryConfig build(); } | @Test void isDynamic() { RegistryBuilder builder = new RegistryBuilder(); builder.isDynamic(true); Assertions.assertTrue(builder.build().isDynamic()); } |
RegistryBuilder extends AbstractBuilder<RegistryConfig, RegistryBuilder> { public RegistryBuilder register(Boolean register) { this.register = register; return getThis(); } RegistryBuilder address(String address); RegistryBuilder username(String username); RegistryBuilder password(String password); RegistryBuilder port(Integer port); RegistryBuilder protocol(String protocol); RegistryBuilder transporter(String transporter); @Deprecated RegistryBuilder transport(String transport); RegistryBuilder server(String server); RegistryBuilder client(String client); RegistryBuilder cluster(String cluster); RegistryBuilder group(String group); RegistryBuilder version(String version); RegistryBuilder timeout(Integer timeout); RegistryBuilder session(Integer session); RegistryBuilder file(String file); @Deprecated RegistryBuilder wait(Integer wait); RegistryBuilder isCheck(Boolean check); RegistryBuilder isDynamic(Boolean dynamic); RegistryBuilder register(Boolean register); RegistryBuilder subscribe(Boolean subscribe); RegistryBuilder appendParameter(String key, String value); RegistryBuilder appendParameters(Map<String, String> appendParameters); RegistryBuilder isDefault(Boolean isDefault); RegistryBuilder simplified(Boolean simplified); RegistryBuilder extraKeys(String extraKeys); RegistryConfig build(); } | @Test void register() { RegistryBuilder builder = new RegistryBuilder(); builder.register(true); Assertions.assertTrue(builder.build().isRegister()); } |
RegistryBuilder extends AbstractBuilder<RegistryConfig, RegistryBuilder> { public RegistryBuilder subscribe(Boolean subscribe) { this.subscribe = subscribe; return getThis(); } RegistryBuilder address(String address); RegistryBuilder username(String username); RegistryBuilder password(String password); RegistryBuilder port(Integer port); RegistryBuilder protocol(String protocol); RegistryBuilder transporter(String transporter); @Deprecated RegistryBuilder transport(String transport); RegistryBuilder server(String server); RegistryBuilder client(String client); RegistryBuilder cluster(String cluster); RegistryBuilder group(String group); RegistryBuilder version(String version); RegistryBuilder timeout(Integer timeout); RegistryBuilder session(Integer session); RegistryBuilder file(String file); @Deprecated RegistryBuilder wait(Integer wait); RegistryBuilder isCheck(Boolean check); RegistryBuilder isDynamic(Boolean dynamic); RegistryBuilder register(Boolean register); RegistryBuilder subscribe(Boolean subscribe); RegistryBuilder appendParameter(String key, String value); RegistryBuilder appendParameters(Map<String, String> appendParameters); RegistryBuilder isDefault(Boolean isDefault); RegistryBuilder simplified(Boolean simplified); RegistryBuilder extraKeys(String extraKeys); RegistryConfig build(); } | @Test void subscribe() { RegistryBuilder builder = new RegistryBuilder(); builder.subscribe(true); Assertions.assertTrue(builder.build().isSubscribe()); } |
RegistryBuilder extends AbstractBuilder<RegistryConfig, RegistryBuilder> { public RegistryBuilder appendParameter(String key, String value) { this.parameters = appendParameter(parameters, key, value); return getThis(); } RegistryBuilder address(String address); RegistryBuilder username(String username); RegistryBuilder password(String password); RegistryBuilder port(Integer port); RegistryBuilder protocol(String protocol); RegistryBuilder transporter(String transporter); @Deprecated RegistryBuilder transport(String transport); RegistryBuilder server(String server); RegistryBuilder client(String client); RegistryBuilder cluster(String cluster); RegistryBuilder group(String group); RegistryBuilder version(String version); RegistryBuilder timeout(Integer timeout); RegistryBuilder session(Integer session); RegistryBuilder file(String file); @Deprecated RegistryBuilder wait(Integer wait); RegistryBuilder isCheck(Boolean check); RegistryBuilder isDynamic(Boolean dynamic); RegistryBuilder register(Boolean register); RegistryBuilder subscribe(Boolean subscribe); RegistryBuilder appendParameter(String key, String value); RegistryBuilder appendParameters(Map<String, String> appendParameters); RegistryBuilder isDefault(Boolean isDefault); RegistryBuilder simplified(Boolean simplified); RegistryBuilder extraKeys(String extraKeys); RegistryConfig build(); } | @Test void appendParameter() { RegistryBuilder builder = new RegistryBuilder(); builder.appendParameter("default.num", "one").appendParameter("num", "ONE"); Map<String, String> parameters = builder.build().getParameters(); Assertions.assertTrue(parameters.containsKey("default.num")); Assertions.assertEquals("ONE", parameters.get("num")); } |
RegistryBuilder extends AbstractBuilder<RegistryConfig, RegistryBuilder> { public RegistryBuilder appendParameters(Map<String, String> appendParameters) { this.parameters = appendParameters(parameters, appendParameters); return getThis(); } RegistryBuilder address(String address); RegistryBuilder username(String username); RegistryBuilder password(String password); RegistryBuilder port(Integer port); RegistryBuilder protocol(String protocol); RegistryBuilder transporter(String transporter); @Deprecated RegistryBuilder transport(String transport); RegistryBuilder server(String server); RegistryBuilder client(String client); RegistryBuilder cluster(String cluster); RegistryBuilder group(String group); RegistryBuilder version(String version); RegistryBuilder timeout(Integer timeout); RegistryBuilder session(Integer session); RegistryBuilder file(String file); @Deprecated RegistryBuilder wait(Integer wait); RegistryBuilder isCheck(Boolean check); RegistryBuilder isDynamic(Boolean dynamic); RegistryBuilder register(Boolean register); RegistryBuilder subscribe(Boolean subscribe); RegistryBuilder appendParameter(String key, String value); RegistryBuilder appendParameters(Map<String, String> appendParameters); RegistryBuilder isDefault(Boolean isDefault); RegistryBuilder simplified(Boolean simplified); RegistryBuilder extraKeys(String extraKeys); RegistryConfig build(); } | @Test void appendParameters() { Map<String, String> source = new HashMap<>(); source.put("default.num", "one"); source.put("num", "ONE"); RegistryBuilder builder = new RegistryBuilder(); builder.appendParameters(source); Map<String, String> parameters = builder.build().getParameters(); Assertions.assertTrue(parameters.containsKey("default.num")); Assertions.assertEquals("ONE", parameters.get("num")); } |
RegistryBuilder extends AbstractBuilder<RegistryConfig, RegistryBuilder> { public RegistryBuilder isDefault(Boolean isDefault) { this.isDefault = isDefault; return getThis(); } RegistryBuilder address(String address); RegistryBuilder username(String username); RegistryBuilder password(String password); RegistryBuilder port(Integer port); RegistryBuilder protocol(String protocol); RegistryBuilder transporter(String transporter); @Deprecated RegistryBuilder transport(String transport); RegistryBuilder server(String server); RegistryBuilder client(String client); RegistryBuilder cluster(String cluster); RegistryBuilder group(String group); RegistryBuilder version(String version); RegistryBuilder timeout(Integer timeout); RegistryBuilder session(Integer session); RegistryBuilder file(String file); @Deprecated RegistryBuilder wait(Integer wait); RegistryBuilder isCheck(Boolean check); RegistryBuilder isDynamic(Boolean dynamic); RegistryBuilder register(Boolean register); RegistryBuilder subscribe(Boolean subscribe); RegistryBuilder appendParameter(String key, String value); RegistryBuilder appendParameters(Map<String, String> appendParameters); RegistryBuilder isDefault(Boolean isDefault); RegistryBuilder simplified(Boolean simplified); RegistryBuilder extraKeys(String extraKeys); RegistryConfig build(); } | @Test void isDefault() { RegistryBuilder builder = new RegistryBuilder(); builder.isDefault(true); Assertions.assertTrue(builder.build().isDefault()); } |
RegistryBuilder extends AbstractBuilder<RegistryConfig, RegistryBuilder> { public RegistryBuilder simplified(Boolean simplified) { this.simplified = simplified; return getThis(); } RegistryBuilder address(String address); RegistryBuilder username(String username); RegistryBuilder password(String password); RegistryBuilder port(Integer port); RegistryBuilder protocol(String protocol); RegistryBuilder transporter(String transporter); @Deprecated RegistryBuilder transport(String transport); RegistryBuilder server(String server); RegistryBuilder client(String client); RegistryBuilder cluster(String cluster); RegistryBuilder group(String group); RegistryBuilder version(String version); RegistryBuilder timeout(Integer timeout); RegistryBuilder session(Integer session); RegistryBuilder file(String file); @Deprecated RegistryBuilder wait(Integer wait); RegistryBuilder isCheck(Boolean check); RegistryBuilder isDynamic(Boolean dynamic); RegistryBuilder register(Boolean register); RegistryBuilder subscribe(Boolean subscribe); RegistryBuilder appendParameter(String key, String value); RegistryBuilder appendParameters(Map<String, String> appendParameters); RegistryBuilder isDefault(Boolean isDefault); RegistryBuilder simplified(Boolean simplified); RegistryBuilder extraKeys(String extraKeys); RegistryConfig build(); } | @Test void simplified() { RegistryBuilder builder = new RegistryBuilder(); builder.simplified(true); Assertions.assertTrue(builder.build().getSimplified()); } |
RegistryBuilder extends AbstractBuilder<RegistryConfig, RegistryBuilder> { public RegistryBuilder extraKeys(String extraKeys) { this.extraKeys = extraKeys; return getThis(); } RegistryBuilder address(String address); RegistryBuilder username(String username); RegistryBuilder password(String password); RegistryBuilder port(Integer port); RegistryBuilder protocol(String protocol); RegistryBuilder transporter(String transporter); @Deprecated RegistryBuilder transport(String transport); RegistryBuilder server(String server); RegistryBuilder client(String client); RegistryBuilder cluster(String cluster); RegistryBuilder group(String group); RegistryBuilder version(String version); RegistryBuilder timeout(Integer timeout); RegistryBuilder session(Integer session); RegistryBuilder file(String file); @Deprecated RegistryBuilder wait(Integer wait); RegistryBuilder isCheck(Boolean check); RegistryBuilder isDynamic(Boolean dynamic); RegistryBuilder register(Boolean register); RegistryBuilder subscribe(Boolean subscribe); RegistryBuilder appendParameter(String key, String value); RegistryBuilder appendParameters(Map<String, String> appendParameters); RegistryBuilder isDefault(Boolean isDefault); RegistryBuilder simplified(Boolean simplified); RegistryBuilder extraKeys(String extraKeys); RegistryConfig build(); } | @Test void extraKeys() { RegistryBuilder builder = new RegistryBuilder(); builder.extraKeys("extraKeys"); Assertions.assertEquals("extraKeys", builder.build().getExtraKeys()); } |
TokenFilter implements Filter { @Override public Result invoke(Invoker<?> invoker, Invocation inv) throws RpcException { String token = invoker.getUrl().getParameter(Constants.TOKEN_KEY); if (ConfigUtils.isNotEmpty(token)) { Class<?> serviceType = invoker.getInterface(); Map<String, String> attachments = inv.getAttachments(); String remoteToken = attachments == null ? null : attachments.get(Constants.TOKEN_KEY); if (!token.equals(remoteToken)) { throw new RpcException("Invalid token! Forbid invoke remote service " + serviceType + " method " + inv.getMethodName() + "() from consumer " + RpcContext.getContext().getRemoteHost() + " to provider " + RpcContext.getContext().getLocalHost()); } } return invoker.invoke(inv); } @Override Result invoke(Invoker<?> invoker, Invocation inv); } | @Test public void testInvokeWithToken() throws Exception { String token = "token"; Invoker invoker = Mockito.mock(Invoker.class); URL url = URL.valueOf("test: when(invoker.getUrl()).thenReturn(url); when(invoker.invoke(any(Invocation.class))).thenReturn(new RpcResult("result")); Map<String, String> attachments = new HashMap<String, String>(); attachments.put(Constants.TOKEN_KEY, token); Invocation invocation = Mockito.mock(Invocation.class); when(invocation.getAttachments()).thenReturn(attachments); Result result = tokenFilter.invoke(invoker, invocation); Assertions.assertEquals("result", result.getValue()); }
@Test public void testInvokeWithWrongToken() throws Exception { Assertions.assertThrows(RpcException.class, () -> { String token = "token"; Invoker invoker = Mockito.mock(Invoker.class); URL url = URL.valueOf("test: when(invoker.getUrl()).thenReturn(url); when(invoker.invoke(any(Invocation.class))).thenReturn(new RpcResult("result")); Map<String, String> attachments = new HashMap<String, String>(); attachments.put(Constants.TOKEN_KEY, "wrongToken"); Invocation invocation = Mockito.mock(Invocation.class); when(invocation.getAttachments()).thenReturn(attachments); tokenFilter.invoke(invoker, invocation); }); }
@Test public void testInvokeWithoutToken() throws Exception { Assertions.assertThrows(RpcException.class, () -> { String token = "token"; Invoker invoker = Mockito.mock(Invoker.class); URL url = URL.valueOf("test: when(invoker.getUrl()).thenReturn(url); when(invoker.invoke(any(Invocation.class))).thenReturn(new RpcResult("result")); Invocation invocation = Mockito.mock(Invocation.class); tokenFilter.invoke(invoker, invocation); }); } |
RegistryBuilder extends AbstractBuilder<RegistryConfig, RegistryBuilder> { public RegistryConfig build() { RegistryConfig registry = new RegistryConfig(); super.build(registry); registry.setAddress(address); registry.setCheck(check); registry.setClient(client); registry.setCluster(cluster); registry.setDefault(isDefault); registry.setDynamic(dynamic); registry.setExtraKeys(extraKeys); registry.setFile(file); registry.setGroup(group); registry.setParameters(parameters); registry.setPassword(password); registry.setPort(port); registry.setProtocol(protocol); registry.setRegister(register); registry.setServer(server); registry.setSession(session); registry.setSimplified(simplified); registry.setSubscribe(subscribe); registry.setTimeout(timeout); registry.setTransporter(transporter); registry.setUsername(username); registry.setVersion(version); registry.setWait(wait); return registry; } RegistryBuilder address(String address); RegistryBuilder username(String username); RegistryBuilder password(String password); RegistryBuilder port(Integer port); RegistryBuilder protocol(String protocol); RegistryBuilder transporter(String transporter); @Deprecated RegistryBuilder transport(String transport); RegistryBuilder server(String server); RegistryBuilder client(String client); RegistryBuilder cluster(String cluster); RegistryBuilder group(String group); RegistryBuilder version(String version); RegistryBuilder timeout(Integer timeout); RegistryBuilder session(Integer session); RegistryBuilder file(String file); @Deprecated RegistryBuilder wait(Integer wait); RegistryBuilder isCheck(Boolean check); RegistryBuilder isDynamic(Boolean dynamic); RegistryBuilder register(Boolean register); RegistryBuilder subscribe(Boolean subscribe); RegistryBuilder appendParameter(String key, String value); RegistryBuilder appendParameters(Map<String, String> appendParameters); RegistryBuilder isDefault(Boolean isDefault); RegistryBuilder simplified(Boolean simplified); RegistryBuilder extraKeys(String extraKeys); RegistryConfig build(); } | @Test void build() { RegistryBuilder builder = new RegistryBuilder(); builder.address("address").username("username").password("password").port(8080).protocol("protocol") .transporter("transporter").server("server").client("client").cluster("cluster").group("group") .version("version").timeout(1000).session(2000).file("file").wait(Integer.valueOf(10)).isCheck(true) .isDynamic(false).register(true).subscribe(false).isDefault(true).simplified(false).extraKeys("A") .appendParameter("default.num", "one").id("id").prefix("prefix"); RegistryConfig config = builder.build(); RegistryConfig config2 = builder.build(); Assertions.assertEquals(8080, config.getPort()); Assertions.assertEquals(1000, config.getTimeout()); Assertions.assertEquals(2000, config.getSession()); Assertions.assertEquals(10, config.getWait()); Assertions.assertTrue(config.isCheck()); Assertions.assertFalse(config.isDynamic()); Assertions.assertTrue(config.isRegister()); Assertions.assertFalse(config.isSubscribe()); Assertions.assertTrue(config.isDefault()); Assertions.assertFalse(config.getSimplified()); Assertions.assertEquals("address", config.getAddress()); Assertions.assertEquals("username", config.getUsername()); Assertions.assertEquals("password", config.getPassword()); Assertions.assertEquals("protocol", config.getProtocol()); Assertions.assertEquals("transporter", config.getTransporter()); Assertions.assertEquals("server", config.getServer()); Assertions.assertEquals("client", config.getClient()); Assertions.assertEquals("cluster", config.getCluster()); Assertions.assertEquals("group", config.getGroup()); Assertions.assertEquals("version", config.getVersion()); Assertions.assertEquals("file", config.getFile()); Assertions.assertEquals("A", config.getExtraKeys()); Assertions.assertTrue(config.getParameters().containsKey("default.num")); Assertions.assertEquals("one", config.getParameters().get("default.num")); Assertions.assertEquals("id", config.getId()); Assertions.assertEquals("prefix", config.getPrefix()); Assertions.assertNotSame(config, config2); } |
ServiceBuilder extends AbstractServiceBuilder<ServiceConfig, ServiceBuilder<U>> { public ServiceBuilder<U> path(String path) { this.path = path; return getThis(); } ServiceBuilder<U> interfaceName(String interfaceName); ServiceBuilder<U> interfaceClass(Class<?> interfaceClass); ServiceBuilder<U> ref(U ref); ServiceBuilder<U> path(String path); ServiceBuilder<U> addMethod(MethodConfig method); ServiceBuilder<U> addMethods(List<? extends MethodConfig> methods); ServiceBuilder<U> provider(ProviderConfig provider); ServiceBuilder<U> providerIds(String providerIds); ServiceBuilder<U> generic(String generic); @Override ServiceBuilder<U> mock(String mock); @Override ServiceBuilder<U> mock(Boolean mock); ServiceConfig<U> build(); } | @Test void path() { ServiceBuilder builder = new ServiceBuilder(); builder.path("path"); Assertions.assertEquals("path", builder.build().getPath()); } |
ServiceBuilder extends AbstractServiceBuilder<ServiceConfig, ServiceBuilder<U>> { public ServiceBuilder<U> addMethod(MethodConfig method) { if (this.methods == null) { this.methods = new ArrayList<>(); } this.methods.add(method); return getThis(); } ServiceBuilder<U> interfaceName(String interfaceName); ServiceBuilder<U> interfaceClass(Class<?> interfaceClass); ServiceBuilder<U> ref(U ref); ServiceBuilder<U> path(String path); ServiceBuilder<U> addMethod(MethodConfig method); ServiceBuilder<U> addMethods(List<? extends MethodConfig> methods); ServiceBuilder<U> provider(ProviderConfig provider); ServiceBuilder<U> providerIds(String providerIds); ServiceBuilder<U> generic(String generic); @Override ServiceBuilder<U> mock(String mock); @Override ServiceBuilder<U> mock(Boolean mock); ServiceConfig<U> build(); } | @Test void addMethod() { MethodConfig method = new MethodConfig(); ServiceBuilder builder = new ServiceBuilder(); builder.addMethod(method); Assertions.assertTrue(builder.build().getMethods().contains(method)); Assertions.assertEquals(1, builder.build().getMethods().size()); } |
ServiceBuilder extends AbstractServiceBuilder<ServiceConfig, ServiceBuilder<U>> { public ServiceBuilder<U> addMethods(List<? extends MethodConfig> methods) { if (this.methods == null) { this.methods = new ArrayList<>(); } this.methods.addAll(methods); return getThis(); } ServiceBuilder<U> interfaceName(String interfaceName); ServiceBuilder<U> interfaceClass(Class<?> interfaceClass); ServiceBuilder<U> ref(U ref); ServiceBuilder<U> path(String path); ServiceBuilder<U> addMethod(MethodConfig method); ServiceBuilder<U> addMethods(List<? extends MethodConfig> methods); ServiceBuilder<U> provider(ProviderConfig provider); ServiceBuilder<U> providerIds(String providerIds); ServiceBuilder<U> generic(String generic); @Override ServiceBuilder<U> mock(String mock); @Override ServiceBuilder<U> mock(Boolean mock); ServiceConfig<U> build(); } | @Test void addMethods() { MethodConfig method = new MethodConfig(); ServiceBuilder builder = new ServiceBuilder(); builder.addMethods(Collections.singletonList(method)); Assertions.assertTrue(builder.build().getMethods().contains(method)); Assertions.assertEquals(1, builder.build().getMethods().size()); } |
ServiceBuilder extends AbstractServiceBuilder<ServiceConfig, ServiceBuilder<U>> { public ServiceBuilder<U> provider(ProviderConfig provider) { this.provider = provider; return getThis(); } ServiceBuilder<U> interfaceName(String interfaceName); ServiceBuilder<U> interfaceClass(Class<?> interfaceClass); ServiceBuilder<U> ref(U ref); ServiceBuilder<U> path(String path); ServiceBuilder<U> addMethod(MethodConfig method); ServiceBuilder<U> addMethods(List<? extends MethodConfig> methods); ServiceBuilder<U> provider(ProviderConfig provider); ServiceBuilder<U> providerIds(String providerIds); ServiceBuilder<U> generic(String generic); @Override ServiceBuilder<U> mock(String mock); @Override ServiceBuilder<U> mock(Boolean mock); ServiceConfig<U> build(); } | @Test void provider() { ProviderConfig provider = new ProviderConfig(); ServiceBuilder builder = new ServiceBuilder(); builder.provider(provider); Assertions.assertSame(provider, builder.build().getProvider()); } |
ServiceBuilder extends AbstractServiceBuilder<ServiceConfig, ServiceBuilder<U>> { public ServiceBuilder<U> providerIds(String providerIds) { this.providerIds = providerIds; return getThis(); } ServiceBuilder<U> interfaceName(String interfaceName); ServiceBuilder<U> interfaceClass(Class<?> interfaceClass); ServiceBuilder<U> ref(U ref); ServiceBuilder<U> path(String path); ServiceBuilder<U> addMethod(MethodConfig method); ServiceBuilder<U> addMethods(List<? extends MethodConfig> methods); ServiceBuilder<U> provider(ProviderConfig provider); ServiceBuilder<U> providerIds(String providerIds); ServiceBuilder<U> generic(String generic); @Override ServiceBuilder<U> mock(String mock); @Override ServiceBuilder<U> mock(Boolean mock); ServiceConfig<U> build(); } | @Test void providerIds() { ServiceBuilder builder = new ServiceBuilder(); builder.providerIds("providerIds"); Assertions.assertEquals("providerIds", builder.build().getProviderIds()); } |
ServiceBuilder extends AbstractServiceBuilder<ServiceConfig, ServiceBuilder<U>> { public ServiceBuilder<U> generic(String generic) { this.generic = generic; return getThis(); } ServiceBuilder<U> interfaceName(String interfaceName); ServiceBuilder<U> interfaceClass(Class<?> interfaceClass); ServiceBuilder<U> ref(U ref); ServiceBuilder<U> path(String path); ServiceBuilder<U> addMethod(MethodConfig method); ServiceBuilder<U> addMethods(List<? extends MethodConfig> methods); ServiceBuilder<U> provider(ProviderConfig provider); ServiceBuilder<U> providerIds(String providerIds); ServiceBuilder<U> generic(String generic); @Override ServiceBuilder<U> mock(String mock); @Override ServiceBuilder<U> mock(Boolean mock); ServiceConfig<U> build(); } | @Test public void generic() throws Exception { ServiceBuilder builder = new ServiceBuilder(); builder.generic(GENERIC_SERIALIZATION_DEFAULT); assertThat(builder.build().getGeneric(), equalTo(GENERIC_SERIALIZATION_DEFAULT)); builder.generic(GENERIC_SERIALIZATION_NATIVE_JAVA); assertThat(builder.build().getGeneric(), equalTo(GENERIC_SERIALIZATION_NATIVE_JAVA)); builder.generic(GENERIC_SERIALIZATION_BEAN); assertThat(builder.build().getGeneric(), equalTo(GENERIC_SERIALIZATION_BEAN)); } |
ExceptionFilter implements Filter { @Override public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException { try { return invoker.invoke(invocation); } catch (RuntimeException e) { logger.error("Got unchecked and undeclared exception which called by " + RpcContext.getContext().getRemoteHost() + ". service: " + invoker.getInterface().getName() + ", method: " + invocation.getMethodName() + ", exception: " + e.getClass().getName() + ": " + e.getMessage(), e); throw e; } } ExceptionFilter(); ExceptionFilter(Logger logger); @Override Result invoke(Invoker<?> invoker, Invocation invocation); @Override Result onResponse(Result result, Invoker<?> invoker, Invocation invocation); } | @SuppressWarnings("unchecked") @Test public void testRpcException() { Logger logger = mock(Logger.class); RpcContext.getContext().setRemoteAddress("127.0.0.1", 1234); RpcException exception = new RpcException("TestRpcException"); ExceptionFilter exceptionFilter = new ExceptionFilter(logger); RpcInvocation invocation = new RpcInvocation("sayHello", new Class<?>[]{String.class}, new Object[]{"world"}); Invoker<DemoService> invoker = mock(Invoker.class); given(invoker.getInterface()).willReturn(DemoService.class); given(invoker.invoke(eq(invocation))).willThrow(exception); try { exceptionFilter.invoke(invoker, invocation); } catch (RpcException e) { assertEquals("TestRpcException", e.getMessage()); } Mockito.verify(logger).error(eq("Got unchecked and undeclared exception which called by 127.0.0.1. service: " + DemoService.class.getName() + ", method: sayHello, exception: " + RpcException.class.getName() + ": TestRpcException"), eq(exception)); RpcContext.removeContext(); }
@SuppressWarnings("unchecked") @Test public void testJavaException() { ExceptionFilter exceptionFilter = new ExceptionFilter(); RpcInvocation invocation = new RpcInvocation("sayHello", new Class<?>[]{String.class}, new Object[]{"world"}); RpcResult rpcResult = new RpcResult(); rpcResult.setException(new IllegalArgumentException("java")); Invoker<DemoService> invoker = mock(Invoker.class); when(invoker.invoke(invocation)).thenReturn(rpcResult); when(invoker.getInterface()).thenReturn(DemoService.class); Result newResult = exceptionFilter.invoke(invoker, invocation); Assertions.assertEquals(rpcResult.getException(), newResult.getException()); }
@SuppressWarnings("unchecked") @Test public void testRuntimeException() { ExceptionFilter exceptionFilter = new ExceptionFilter(); RpcInvocation invocation = new RpcInvocation("sayHello", new Class<?>[]{String.class}, new Object[]{"world"}); RpcResult rpcResult = new RpcResult(); rpcResult.setException(new LocalException("localException")); Invoker<DemoService> invoker = mock(Invoker.class); when(invoker.invoke(invocation)).thenReturn(rpcResult); when(invoker.getInterface()).thenReturn(DemoService.class); Result newResult = exceptionFilter.invoke(invoker, invocation); Assertions.assertEquals(rpcResult.getException(), newResult.getException()); } |
ServiceBuilder extends AbstractServiceBuilder<ServiceConfig, ServiceBuilder<U>> { @Override public ServiceBuilder<U> mock(String mock) { throw new IllegalArgumentException("mock doesn't support on provider side"); } ServiceBuilder<U> interfaceName(String interfaceName); ServiceBuilder<U> interfaceClass(Class<?> interfaceClass); ServiceBuilder<U> ref(U ref); ServiceBuilder<U> path(String path); ServiceBuilder<U> addMethod(MethodConfig method); ServiceBuilder<U> addMethods(List<? extends MethodConfig> methods); ServiceBuilder<U> provider(ProviderConfig provider); ServiceBuilder<U> providerIds(String providerIds); ServiceBuilder<U> generic(String generic); @Override ServiceBuilder<U> mock(String mock); @Override ServiceBuilder<U> mock(Boolean mock); ServiceConfig<U> build(); } | @Test public void Mock() throws Exception { Assertions.assertThrows(IllegalArgumentException.class, () -> { ServiceBuilder builder = new ServiceBuilder(); builder.mock("true"); }); }
@Test public void Mock1() throws Exception { Assertions.assertThrows(IllegalArgumentException.class, () -> { ServiceBuilder builder = new ServiceBuilder(); builder.mock(true); }); } |
ServiceBuilder extends AbstractServiceBuilder<ServiceConfig, ServiceBuilder<U>> { public ServiceConfig<U> build() { ServiceConfig<U> serviceConfig = new ServiceConfig<>(); super.build(serviceConfig); serviceConfig.setInterface(interfaceName); serviceConfig.setInterface(interfaceClass); serviceConfig.setRef(ref); serviceConfig.setPath(path); serviceConfig.setMethods(methods); serviceConfig.setProvider(provider); serviceConfig.setProviderIds(providerIds); serviceConfig.setGeneric(generic); return serviceConfig; } ServiceBuilder<U> interfaceName(String interfaceName); ServiceBuilder<U> interfaceClass(Class<?> interfaceClass); ServiceBuilder<U> ref(U ref); ServiceBuilder<U> path(String path); ServiceBuilder<U> addMethod(MethodConfig method); ServiceBuilder<U> addMethods(List<? extends MethodConfig> methods); ServiceBuilder<U> provider(ProviderConfig provider); ServiceBuilder<U> providerIds(String providerIds); ServiceBuilder<U> generic(String generic); @Override ServiceBuilder<U> mock(String mock); @Override ServiceBuilder<U> mock(Boolean mock); ServiceConfig<U> build(); } | @Test void build() { MethodConfig method = new MethodConfig(); ProviderConfig provider = new ProviderConfig(); ServiceBuilder builder = new ServiceBuilder(); builder.path("path").addMethod(method).provider(provider).providerIds("providerIds") .generic(GENERIC_SERIALIZATION_DEFAULT); ServiceConfig config = builder.build(); ServiceConfig config2 = builder.build(); assertThat(config.getGeneric(), equalTo(GENERIC_SERIALIZATION_DEFAULT)); Assertions.assertEquals("path", config.getPath()); Assertions.assertEquals("providerIds", config.getProviderIds()); Assertions.assertSame(provider, config.getProvider()); Assertions.assertTrue(config.getMethods().contains(method)); Assertions.assertEquals(1, config.getMethods().size()); Assertions.assertNotSame(config, config2); } |
DeprecatedFilter implements Filter { @Override public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException { String key = invoker.getInterface().getName() + "." + invocation.getMethodName(); if (!logged.contains(key)) { logged.add(key); if (invoker.getUrl().getMethodParameter(invocation.getMethodName(), Constants.DEPRECATED_KEY, false)) { LOGGER.error("The service method " + invoker.getInterface().getName() + "." + getMethodSignature(invocation) + " is DEPRECATED! Declare from " + invoker.getUrl()); } } return invoker.invoke(invocation); } @Override Result invoke(Invoker<?> invoker, Invocation invocation); } | @Test public void testDeprecatedFilter() { URL url = URL.valueOf("test: LogUtil.start(); deprecatedFilter.invoke(new MyInvoker<DemoService>(url), new MockInvocation()); assertEquals(1, LogUtil.findMessage("The service method org.apache.dubbo.rpc.support.DemoService.echo(String) is DEPRECATED")); LogUtil.stop(); } |
ActiveLimitFilter implements Filter { @Override public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException { URL url = invoker.getUrl(); String methodName = invocation.getMethodName(); int max = invoker.getUrl().getMethodParameter(methodName, Constants.ACTIVES_KEY, 0); RpcStatus count = RpcStatus.getStatus(invoker.getUrl(), invocation.getMethodName()); if (!count.beginCount(url, methodName, max)) { long timeout = invoker.getUrl().getMethodParameter(invocation.getMethodName(), Constants.TIMEOUT_KEY, 0); long start = System.currentTimeMillis(); long remain = timeout; synchronized (count) { while (!count.beginCount(url, methodName, max)) { try { count.wait(remain); } catch (InterruptedException e) { } long elapsed = System.currentTimeMillis() - start; remain = timeout - elapsed; if (remain <= 0) { throw new RpcException("Waiting concurrent invoke timeout in client-side for service: " + invoker.getInterface().getName() + ", method: " + invocation.getMethodName() + ", elapsed: " + elapsed + ", timeout: " + timeout + ". concurrent invokes: " + count.getActive() + ". max concurrent invoke limit: " + max); } } } } boolean isSuccess = true; long begin = System.currentTimeMillis(); try { return invoker.invoke(invocation); } catch (RuntimeException t) { isSuccess = false; throw t; } finally { count.endCount(url, methodName, System.currentTimeMillis() - begin, isSuccess); if (max > 0) { synchronized (count) { count.notifyAll(); } } } } @Override Result invoke(Invoker<?> invoker, Invocation invocation); } | @Test public void testInvokeNoActives() { URL url = URL.valueOf("test: Invoker<ActiveLimitFilterTest> invoker = new MyInvoker<ActiveLimitFilterTest>(url); Invocation invocation = new MockInvocation(); activeLimitFilter.invoke(invoker, invocation); }
@Test public void testInvokeLessActives() { URL url = URL.valueOf("test: Invoker<ActiveLimitFilterTest> invoker = new MyInvoker<ActiveLimitFilterTest>(url); Invocation invocation = new MockInvocation(); activeLimitFilter.invoke(invoker, invocation); }
@Test public void testInvokeGreaterActives() { AtomicInteger count = new AtomicInteger(0); URL url = URL.valueOf("test: final Invoker<ActiveLimitFilterTest> invoker = new BlockMyInvoker<ActiveLimitFilterTest>(url, 100); final Invocation invocation = new MockInvocation(); final CountDownLatch latch = new CountDownLatch(1); for (int i = 0; i < 100; i++) { Thread thread = new Thread(new Runnable() { public void run() { try { latch.await(); } catch (InterruptedException e) { e.printStackTrace(); } for (int i = 0; i < 100; i++) { try { activeLimitFilter.invoke(invoker, invocation); } catch (RpcException expected) { count.incrementAndGet(); } } } }); thread.start(); } latch.countDown(); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } assertNotSame(0, count.intValue()); }
@Test public void testInvokeTimeOut() { int totalThread = 100; int maxActives = 10; long timeout = 1; long blockTime = 100; AtomicInteger count = new AtomicInteger(0); final CountDownLatch latch = new CountDownLatch(1); final CountDownLatch latchBlocking = new CountDownLatch(totalThread); URL url = URL.valueOf("test: final Invoker<ActiveLimitFilterTest> invoker = new BlockMyInvoker<ActiveLimitFilterTest>(url, blockTime); final Invocation invocation = new MockInvocation(); RpcStatus.removeStatus(url); RpcStatus.removeStatus(url, invocation.getMethodName()); for (int i = 0; i < totalThread; i++) { Thread thread = new Thread(new Runnable() { public void run() { try { try { latch.await(); } catch (InterruptedException e) { e.printStackTrace(); } try { activeLimitFilter.invoke(invoker, invocation); } catch (RpcException expected) { count.incrementAndGet(); } } finally { latchBlocking.countDown(); } } }); thread.start(); } latch.countDown(); try { latchBlocking.await(); } catch (InterruptedException e) { e.printStackTrace(); } assertEquals(90, count.intValue()); }
@Test public void testInvokeNotTimeOut() { int totalThread = 100; int maxActives = 10; long timeout = 1000; long blockTime = 0; AtomicInteger count = new AtomicInteger(0); final CountDownLatch latch = new CountDownLatch(1); final CountDownLatch latchBlocking = new CountDownLatch(totalThread); URL url = URL.valueOf("test: final Invoker<ActiveLimitFilterTest> invoker = new BlockMyInvoker<ActiveLimitFilterTest>(url, blockTime); final Invocation invocation = new MockInvocation(); for (int i = 0; i < totalThread; i++) { Thread thread = new Thread(new Runnable() { public void run() { try { try { latch.await(); } catch (InterruptedException e) { e.printStackTrace(); } try { activeLimitFilter.invoke(invoker, invocation); } catch (RpcException expected) { count.incrementAndGet(); } } finally { latchBlocking.countDown(); } } }); thread.start(); } latch.countDown(); try { latchBlocking.await(); } catch (InterruptedException e) { e.printStackTrace(); } assertEquals(0, count.intValue()); }
@Test public void testInvokeRuntimeException() { Assertions.assertThrows(RuntimeException.class, () -> { URL url = URL.valueOf("test: Invoker<ActiveLimitFilterTest> invoker = new RuntimeExceptionInvoker(url); Invocation invocation = new MockInvocation(); RpcStatus count = RpcStatus.getStatus(invoker.getUrl(), invocation.getMethodName()); int beforeExceptionActiveCount = count.getActive(); activeLimitFilter.invoke(invoker, invocation); int afterExceptionActiveCount = count.getActive(); assertEquals(beforeExceptionActiveCount, afterExceptionActiveCount, "After exception active count should be same"); }); }
@Test public void testInvokeRuntimeExceptionWithActiveCountMatch() { URL url = URL.valueOf("test: Invoker<ActiveLimitFilterTest> invoker = new RuntimeExceptionInvoker(url); Invocation invocation = new MockInvocation(); RpcStatus count = RpcStatus.getStatus(invoker.getUrl(), invocation.getMethodName()); int beforeExceptionActiveCount = count.getActive(); try { activeLimitFilter.invoke(invoker, invocation); } catch (RuntimeException ex) { int afterExceptionActiveCount = count.getActive(); assertEquals(beforeExceptionActiveCount, afterExceptionActiveCount, "After exception active count should be same"); } } |
MetadataReportBuilder extends AbstractBuilder<MetadataReportConfig, MetadataReportBuilder> { public MetadataReportBuilder address(String address) { this.address = address; return getThis(); } MetadataReportBuilder address(String address); MetadataReportBuilder username(String username); MetadataReportBuilder password(String password); MetadataReportBuilder timeout(Integer timeout); MetadataReportBuilder group(String group); MetadataReportBuilder appendParameters(Map<String, String> appendParameters); MetadataReportBuilder appendParameter(String key, String value); MetadataReportBuilder retryTimes(Integer retryTimes); MetadataReportBuilder retryPeriod(Integer retryPeriod); MetadataReportBuilder cycleReport(Boolean cycleReport); MetadataReportBuilder syncReport(Boolean syncReport); MetadataReportConfig build(); } | @Test void address() { MetadataReportBuilder builder = new MetadataReportBuilder(); builder.address("address"); Assertions.assertEquals("address", builder.build().getAddress()); } |
MetadataReportBuilder extends AbstractBuilder<MetadataReportConfig, MetadataReportBuilder> { public MetadataReportBuilder username(String username) { this.username = username; return getThis(); } MetadataReportBuilder address(String address); MetadataReportBuilder username(String username); MetadataReportBuilder password(String password); MetadataReportBuilder timeout(Integer timeout); MetadataReportBuilder group(String group); MetadataReportBuilder appendParameters(Map<String, String> appendParameters); MetadataReportBuilder appendParameter(String key, String value); MetadataReportBuilder retryTimes(Integer retryTimes); MetadataReportBuilder retryPeriod(Integer retryPeriod); MetadataReportBuilder cycleReport(Boolean cycleReport); MetadataReportBuilder syncReport(Boolean syncReport); MetadataReportConfig build(); } | @Test void username() { MetadataReportBuilder builder = new MetadataReportBuilder(); builder.username("username"); Assertions.assertEquals("username", builder.build().getUsername()); } |
MetadataReportBuilder extends AbstractBuilder<MetadataReportConfig, MetadataReportBuilder> { public MetadataReportBuilder password(String password) { this.password = password; return getThis(); } MetadataReportBuilder address(String address); MetadataReportBuilder username(String username); MetadataReportBuilder password(String password); MetadataReportBuilder timeout(Integer timeout); MetadataReportBuilder group(String group); MetadataReportBuilder appendParameters(Map<String, String> appendParameters); MetadataReportBuilder appendParameter(String key, String value); MetadataReportBuilder retryTimes(Integer retryTimes); MetadataReportBuilder retryPeriod(Integer retryPeriod); MetadataReportBuilder cycleReport(Boolean cycleReport); MetadataReportBuilder syncReport(Boolean syncReport); MetadataReportConfig build(); } | @Test void password() { MetadataReportBuilder builder = new MetadataReportBuilder(); builder.password("password"); Assertions.assertEquals("password", builder.build().getPassword()); } |
MetadataReportBuilder extends AbstractBuilder<MetadataReportConfig, MetadataReportBuilder> { public MetadataReportBuilder timeout(Integer timeout) { this.timeout = timeout; return getThis(); } MetadataReportBuilder address(String address); MetadataReportBuilder username(String username); MetadataReportBuilder password(String password); MetadataReportBuilder timeout(Integer timeout); MetadataReportBuilder group(String group); MetadataReportBuilder appendParameters(Map<String, String> appendParameters); MetadataReportBuilder appendParameter(String key, String value); MetadataReportBuilder retryTimes(Integer retryTimes); MetadataReportBuilder retryPeriod(Integer retryPeriod); MetadataReportBuilder cycleReport(Boolean cycleReport); MetadataReportBuilder syncReport(Boolean syncReport); MetadataReportConfig build(); } | @Test void timeout() { MetadataReportBuilder builder = new MetadataReportBuilder(); builder.timeout(1000); Assertions.assertEquals(1000, builder.build().getTimeout()); } |
MetadataReportBuilder extends AbstractBuilder<MetadataReportConfig, MetadataReportBuilder> { public MetadataReportBuilder group(String group) { this.group = group; return getThis(); } MetadataReportBuilder address(String address); MetadataReportBuilder username(String username); MetadataReportBuilder password(String password); MetadataReportBuilder timeout(Integer timeout); MetadataReportBuilder group(String group); MetadataReportBuilder appendParameters(Map<String, String> appendParameters); MetadataReportBuilder appendParameter(String key, String value); MetadataReportBuilder retryTimes(Integer retryTimes); MetadataReportBuilder retryPeriod(Integer retryPeriod); MetadataReportBuilder cycleReport(Boolean cycleReport); MetadataReportBuilder syncReport(Boolean syncReport); MetadataReportConfig build(); } | @Test void group() { MetadataReportBuilder builder = new MetadataReportBuilder(); builder.group("group"); Assertions.assertEquals("group", builder.build().getGroup()); } |
MetadataReportBuilder extends AbstractBuilder<MetadataReportConfig, MetadataReportBuilder> { public MetadataReportBuilder appendParameter(String key, String value) { this.parameters = appendParameter(this.parameters, key, value); return getThis(); } MetadataReportBuilder address(String address); MetadataReportBuilder username(String username); MetadataReportBuilder password(String password); MetadataReportBuilder timeout(Integer timeout); MetadataReportBuilder group(String group); MetadataReportBuilder appendParameters(Map<String, String> appendParameters); MetadataReportBuilder appendParameter(String key, String value); MetadataReportBuilder retryTimes(Integer retryTimes); MetadataReportBuilder retryPeriod(Integer retryPeriod); MetadataReportBuilder cycleReport(Boolean cycleReport); MetadataReportBuilder syncReport(Boolean syncReport); MetadataReportConfig build(); } | @Test void appendParameter() { MetadataReportBuilder builder = new MetadataReportBuilder(); builder.appendParameter("default.num", "one").appendParameter("num", "ONE"); Map<String, String> parameters = builder.build().getParameters(); Assertions.assertTrue(parameters.containsKey("default.num")); Assertions.assertEquals("ONE", parameters.get("num")); } |
MetadataReportBuilder extends AbstractBuilder<MetadataReportConfig, MetadataReportBuilder> { public MetadataReportBuilder appendParameters(Map<String, String> appendParameters) { this.parameters = appendParameters(this.parameters, appendParameters); return getThis(); } MetadataReportBuilder address(String address); MetadataReportBuilder username(String username); MetadataReportBuilder password(String password); MetadataReportBuilder timeout(Integer timeout); MetadataReportBuilder group(String group); MetadataReportBuilder appendParameters(Map<String, String> appendParameters); MetadataReportBuilder appendParameter(String key, String value); MetadataReportBuilder retryTimes(Integer retryTimes); MetadataReportBuilder retryPeriod(Integer retryPeriod); MetadataReportBuilder cycleReport(Boolean cycleReport); MetadataReportBuilder syncReport(Boolean syncReport); MetadataReportConfig build(); } | @Test void appendParameters() { Map<String, String> source = new HashMap<>(); source.put("default.num", "one"); source.put("num", "ONE"); MetadataReportBuilder builder = new MetadataReportBuilder(); builder.appendParameters(source); Map<String, String> parameters = builder.build().getParameters(); Assertions.assertTrue(parameters.containsKey("default.num")); Assertions.assertEquals("ONE", parameters.get("num")); } |
MetadataReportBuilder extends AbstractBuilder<MetadataReportConfig, MetadataReportBuilder> { public MetadataReportBuilder retryTimes(Integer retryTimes) { this.retryTimes = retryTimes; return getThis(); } MetadataReportBuilder address(String address); MetadataReportBuilder username(String username); MetadataReportBuilder password(String password); MetadataReportBuilder timeout(Integer timeout); MetadataReportBuilder group(String group); MetadataReportBuilder appendParameters(Map<String, String> appendParameters); MetadataReportBuilder appendParameter(String key, String value); MetadataReportBuilder retryTimes(Integer retryTimes); MetadataReportBuilder retryPeriod(Integer retryPeriod); MetadataReportBuilder cycleReport(Boolean cycleReport); MetadataReportBuilder syncReport(Boolean syncReport); MetadataReportConfig build(); } | @Test void retryTimes() { MetadataReportBuilder builder = new MetadataReportBuilder(); builder.retryTimes(1); Assertions.assertEquals(1, builder.build().getRetryTimes()); } |
MetadataReportBuilder extends AbstractBuilder<MetadataReportConfig, MetadataReportBuilder> { public MetadataReportBuilder retryPeriod(Integer retryPeriod) { this.retryPeriod = retryPeriod; return getThis(); } MetadataReportBuilder address(String address); MetadataReportBuilder username(String username); MetadataReportBuilder password(String password); MetadataReportBuilder timeout(Integer timeout); MetadataReportBuilder group(String group); MetadataReportBuilder appendParameters(Map<String, String> appendParameters); MetadataReportBuilder appendParameter(String key, String value); MetadataReportBuilder retryTimes(Integer retryTimes); MetadataReportBuilder retryPeriod(Integer retryPeriod); MetadataReportBuilder cycleReport(Boolean cycleReport); MetadataReportBuilder syncReport(Boolean syncReport); MetadataReportConfig build(); } | @Test void retryPeriod() { MetadataReportBuilder builder = new MetadataReportBuilder(); builder.retryPeriod(2); Assertions.assertEquals(2, builder.build().getRetryPeriod()); } |
MetadataReportBuilder extends AbstractBuilder<MetadataReportConfig, MetadataReportBuilder> { public MetadataReportBuilder cycleReport(Boolean cycleReport) { this.cycleReport = cycleReport; return getThis(); } MetadataReportBuilder address(String address); MetadataReportBuilder username(String username); MetadataReportBuilder password(String password); MetadataReportBuilder timeout(Integer timeout); MetadataReportBuilder group(String group); MetadataReportBuilder appendParameters(Map<String, String> appendParameters); MetadataReportBuilder appendParameter(String key, String value); MetadataReportBuilder retryTimes(Integer retryTimes); MetadataReportBuilder retryPeriod(Integer retryPeriod); MetadataReportBuilder cycleReport(Boolean cycleReport); MetadataReportBuilder syncReport(Boolean syncReport); MetadataReportConfig build(); } | @Test void cycleReport() { MetadataReportBuilder builder = new MetadataReportBuilder(); builder.cycleReport(true); Assertions.assertTrue(builder.build().getCycleReport()); builder.cycleReport(false); Assertions.assertFalse(builder.build().getCycleReport()); builder.cycleReport(null); Assertions.assertNull(builder.build().getCycleReport()); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.