blob: d9b64c2fa3b59fb89296e11e172565599c0cb974 [file] [log] [blame]
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.dubbo.rpc.protocol.dubbo;
import com.alibaba.dubbo.common.Constants;
import com.alibaba.dubbo.common.URL;
import com.alibaba.dubbo.common.extension.ExtensionLoader;
import com.alibaba.dubbo.common.utils.DubboAppender;
import com.alibaba.dubbo.common.utils.LogUtil;
import com.alibaba.dubbo.common.utils.NetUtils;
import com.alibaba.dubbo.remoting.exchange.ExchangeClient;
import com.alibaba.dubbo.rpc.Exporter;
import com.alibaba.dubbo.rpc.Invoker;
import com.alibaba.dubbo.rpc.ProxyFactory;
import org.junit.Assert;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import java.lang.reflect.Field;
public class ReferenceCountExchangeClientTest {
public static ProxyFactory proxy = ExtensionLoader.getExtensionLoader(ProxyFactory.class).getAdaptiveExtension();
private static DubboProtocol protocol = DubboProtocol.getDubboProtocol();
Exporter<?> demoExporter;
Exporter<?> helloExporter;
Invoker<IDemoService> demoServiceInvoker;
Invoker<IHelloService> helloServiceInvoker;
IDemoService demoService;
IHelloService helloService;
ExchangeClient demoClient;
ExchangeClient helloClient;
String errorMsg = "safe guard client , should not be called ,must have a bug";
@BeforeClass
public static void setUpBeforeClass() throws Exception {
}
public static Invoker<?> referInvoker(Class<?> type, URL url) {
return (Invoker<?>) protocol.refer(type, url);
}
public static <T> Exporter<T> export(T instance, Class<T> type, String url) {
return export(instance, type, URL.valueOf(url));
}
public static <T> Exporter<T> export(T instance, Class<T> type, URL url) {
return protocol.export(proxy.getInvoker(instance, type, url));
}
@Before
public void setUp() throws Exception {
}
/**
* test connection sharing
*/
@Test
public void test_share_connect() {
init(0);
Assert.assertEquals(demoClient.getLocalAddress(), helloClient.getLocalAddress());
Assert.assertEquals(demoClient, helloClient);
destoy();
}
/**
* test connection not sharing
*/
@Test
public void test_not_share_connect() {
init(1);
Assert.assertNotSame(demoClient.getLocalAddress(), helloClient.getLocalAddress());
Assert.assertNotSame(demoClient, helloClient);
destoy();
}
/**
* test counter won't count down incorrectly when invoker is destroyed for multiple times
*/
@Test
public void test_multi_destory() {
init(0);
DubboAppender.doStart();
DubboAppender.clear();
demoServiceInvoker.destroy();
demoServiceInvoker.destroy();
Assert.assertEquals("hello", helloService.hello());
Assert.assertEquals("should not warning message", 0, LogUtil.findMessage(errorMsg));
LogUtil.checkNoError();
DubboAppender.doStop();
destoy();
}
/**
* Test against invocation still succeed even if counter has error
*/
@Test
public void test_counter_error() {
init(0);
DubboAppender.doStart();
DubboAppender.clear();
ReferenceCountExchangeClient client = getReferenceClient(helloServiceInvoker);
// close once, counter counts down from 2 to 1, no warning occurs
client.close();
Assert.assertEquals("hello", helloService.hello());
Assert.assertEquals("should not warning message", 0, LogUtil.findMessage(errorMsg));
// counter is incorrect, invocation still succeeds
client.close();
Assert.assertEquals("hello", helloService.hello());
Assert.assertEquals("should warning message", 1, LogUtil.findMessage(errorMsg));
// output one error every 5000 invocations.
Assert.assertEquals("hello", helloService.hello());
Assert.assertEquals("should warning message", 1, LogUtil.findMessage(errorMsg));
DubboAppender.doStop();
// status switch to available once invoke again
Assert.assertEquals("client status available", true, helloServiceInvoker.isAvailable());
client.close();
// client has been replaced with lazy client. lazy client is fetched from referenceclientmap, and since it's
// been invoked once, it's close status is false
Assert.assertEquals("client status close", false, client.isClosed());
Assert.assertEquals("client status close", false, helloServiceInvoker.isAvailable());
destoy();
}
@SuppressWarnings("unchecked")
private void init(int connections) {
int port = NetUtils.getAvailablePort();
URL demoUrl = URL.valueOf("dubbo://127.0.0.1:" + port + "/demo?" + Constants.CONNECTIONS_KEY + "=" + connections);
URL helloUrl = URL.valueOf("dubbo://127.0.0.1:" + port + "/hello?" + Constants.CONNECTIONS_KEY + "=" + connections);
demoExporter = export(new DemoServiceImpl(), IDemoService.class, demoUrl);
helloExporter = export(new HelloServiceImpl(), IHelloService.class, helloUrl);
demoServiceInvoker = (Invoker<IDemoService>) referInvoker(IDemoService.class, demoUrl);
demoService = proxy.getProxy(demoServiceInvoker);
Assert.assertEquals("demo", demoService.demo());
helloServiceInvoker = (Invoker<IHelloService>) referInvoker(IHelloService.class, helloUrl);
helloService = proxy.getProxy(helloServiceInvoker);
Assert.assertEquals("hello", helloService.hello());
demoClient = getClient(demoServiceInvoker);
helloClient = getClient(helloServiceInvoker);
}
private void destoy() {
demoServiceInvoker.destroy();
helloServiceInvoker.destroy();
demoExporter.getInvoker().destroy();
helloExporter.getInvoker().destroy();
}
private ExchangeClient getClient(Invoker<?> invoker) {
if (invoker.getUrl().getParameter(Constants.CONNECTIONS_KEY, 1) == 1) {
return getInvokerClient(invoker);
} else {
ReferenceCountExchangeClient client = getReferenceClient(invoker);
try {
Field clientField = ReferenceCountExchangeClient.class.getDeclaredField("client");
clientField.setAccessible(true);
return (ExchangeClient) clientField.get(client);
} catch (Exception e) {
e.printStackTrace();
Assert.fail(e.getMessage());
throw new RuntimeException(e);
}
}
}
private ReferenceCountExchangeClient getReferenceClient(Invoker<?> invoker) {
return (ReferenceCountExchangeClient) getInvokerClient(invoker);
}
private ExchangeClient getInvokerClient(Invoker<?> invoker) {
@SuppressWarnings("rawtypes")
DubboInvoker dInvoker = (DubboInvoker) invoker;
try {
Field clientField = DubboInvoker.class.getDeclaredField("clients");
clientField.setAccessible(true);
ExchangeClient[] clients = (ExchangeClient[]) clientField.get(dInvoker);
return clients[0];
} catch (Exception e) {
e.printStackTrace();
Assert.fail(e.getMessage());
throw new RuntimeException(e);
}
}
public interface IDemoService {
public String demo();
}
public interface IHelloService {
public String hello();
}
public class DemoServiceImpl implements IDemoService {
public String demo() {
return "demo";
}
}
public class HelloServiceImpl implements IHelloService {
public String hello() {
return "hello";
}
}
}