From 2acf10ac93f63a88ae9ab6e0244e50137539e1f1 Mon Sep 17 00:00:00 2001
From: AlexStocks <alexstocks@foxmail.com>
Date: Sun, 3 Jan 2021 03:36:55 +0800
Subject: [PATCH] fix remoting linter error
---
cluster/router/chain/chain_test.go | 37 ++++++++---
cluster/router/condition/app_router_test.go | 21 +++++--
cluster/router/condition/file_test.go | 3 +
common/url_test.go | 8 ++-
config_center/zookeeper/impl_test.go | 20 ++++--
metadata/report/consul/report_test.go | 4 +-
metadata/report/delegate/delegate_report.go | 19 +++++-
metadata/report/etcd/report_test.go | 5 +-
.../service/inmemory/service_proxy_test.go | 19 ++++--
metadata/service/inmemory/service_test.go | 41 ++++++++----
metadata/service/remote/service_proxy_test.go | 34 ++++++----
protocol/dubbo/hessian2/hessian_request.go | 18 +++---
protocol/dubbo/hessian2/hessian_response.go | 24 +++----
protocol/dubbo/impl/hessian.go | 35 +++++------
registry/consul/service_discovery_test.go | 5 +-
registry/consul/utils_test.go | 27 ++++++--
registry/etcdv3/service_discovery.go | 7 ++-
registry/file/service_discovery.go | 4 +-
registry/file/service_discovery_test.go | 12 +++-
registry/nacos/listener.go | 4 +-
registry/nacos/registry_test.go | 4 +-
registry/protocol/protocol.go | 6 +-
.../service_discovery_registry_test.go | 5 +-
registry/zookeeper/registry_test.go | 62 +++++++++++--------
remoting/etcdv3/client.go | 4 +-
remoting/etcdv3/client_test.go | 3 +-
remoting/getty/getty_client_test.go | 7 ++-
remoting/getty/pool.go | 20 ++++--
remoting/zookeeper/client_test.go | 25 ++++++--
remoting/zookeeper/facade_test.go | 6 +-
remoting/zookeeper/listener_test.go | 6 +-
31 files changed, 341 insertions(+), 154 deletions(-)
diff --git a/cluster/router/chain/chain_test.go b/cluster/router/chain/chain_test.go
index b21990b08..92c59d76d 100644
--- a/cluster/router/chain/chain_test.go
+++ b/cluster/router/chain/chain_test.go
@@ -76,8 +76,10 @@ conditions:
_, err = z.Conn.Set(path, []byte(testyml), 0)
assert.NoError(t, err)
- defer ts.Stop()
- defer z.Close()
+ defer func() {
+ _ = ts.Stop()
+ z.Close()
+ }()
zkUrl, _ := common.NewURL(fmt.Sprintf(zkFormat, localIP, ts.Servers[0].Port))
configuration, err := extension.GetConfigCenterFactory(zk).GetDynamicConfiguration(zkUrl)
@@ -128,11 +130,15 @@ conditions:
_, err = z.Conn.Set(path, []byte(testyml), 0)
assert.NoError(t, err)
- defer ts.Stop()
- defer z.Close()
+ defer func() {
+ err := ts.Stop()
+ assert.NoError(t, err)
+ z.Close()
+ }()
zkUrl, _ := common.NewURL(fmt.Sprintf(zkFormat, localIP, ts.Servers[0].Port))
configuration, err := extension.GetConfigCenterFactory(zk).GetDynamicConfiguration(zkUrl)
+ assert.NoError(t, err)
config.GetEnvInstance().SetDynamicConfiguration(configuration)
chain, err := NewRouterChain(getConditionRouteUrl(applicationKey))
@@ -154,11 +160,15 @@ conditions:
func TestRouterChainRoute(t *testing.T) {
ts, z, _, err := zookeeper.NewMockZookeeperClient("test", 15*time.Second)
- defer ts.Stop()
- defer z.Close()
+ defer func() {
+ err = ts.Stop()
+ assert.NoError(t, err)
+ z.Close()
+ }()
zkUrl, _ := common.NewURL(fmt.Sprintf(zkFormat, localIP, ts.Servers[0].Port))
configuration, err := extension.GetConfigCenterFactory(zk).GetDynamicConfiguration(zkUrl)
+ assert.NoError(t, err)
config.GetEnvInstance().SetDynamicConfiguration(configuration)
chain, err := NewRouterChain(getConditionRouteUrl(applicationKey))
@@ -198,11 +208,15 @@ conditions:
_, err = z.Conn.Set(path, []byte(testyml), 0)
assert.NoError(t, err)
- defer ts.Stop()
- defer z.Close()
+ defer func() {
+ err := ts.Stop()
+ assert.NoError(t, err)
+ z.Close()
+ }()
zkUrl, _ := common.NewURL(fmt.Sprintf(zkFormat, localIP, ts.Servers[0].Port))
configuration, err := extension.GetConfigCenterFactory(zk).GetDynamicConfiguration(zkUrl)
+ assert.NoError(t, err)
config.GetEnvInstance().SetDynamicConfiguration(configuration)
chain, err := NewRouterChain(getConditionRouteUrl(applicationKey))
@@ -224,8 +238,11 @@ conditions:
func TestRouterChainRouteNoRoute(t *testing.T) {
ts, z, _, err := zookeeper.NewMockZookeeperClient("test", 15*time.Second)
- defer ts.Stop()
- defer z.Close()
+ defer func() {
+ err := ts.Stop()
+ assert.NoError(t, err)
+ z.Close()
+ }()
zkUrl, _ := common.NewURL(fmt.Sprintf(zkFormat, localIP, ts.Servers[0].Port))
configuration, err := extension.GetConfigCenterFactory(zk).GetDynamicConfiguration(zkUrl)
diff --git a/cluster/router/condition/app_router_test.go b/cluster/router/condition/app_router_test.go
index 879abc5cc..c8bc43eb3 100644
--- a/cluster/router/condition/app_router_test.go
+++ b/cluster/router/condition/app_router_test.go
@@ -67,8 +67,11 @@ conditions:
_, err = z.Conn.Set(routerPath, []byte(testYML), 0)
assert.NoError(t, err)
- defer ts.Stop()
- defer z.Close()
+ defer func() {
+ err = ts.Stop()
+ assert.NoError(t, err)
+ z.Close()
+ }()
zkUrl, _ := common.NewURL(fmt.Sprintf(zkFormat, routerLocalIP, ts.Servers[0].Port))
configuration, err := extension.GetConfigCenterFactory(routerZk).GetDynamicConfiguration(zkUrl)
@@ -115,8 +118,11 @@ conditions:
_, err = z.Conn.Set(routerPath, []byte(testYML), 0)
assert.NoError(t, err)
- defer ts.Stop()
- defer z.Close()
+ defer func() {
+ err = ts.Stop()
+ assert.NoError(t, err)
+ z.Close()
+ }()
zkUrl, _ := common.NewURL(fmt.Sprintf(zkFormat, routerLocalIP, ts.Servers[0].Port))
configuration, err := extension.GetConfigCenterFactory(routerZk).GetDynamicConfiguration(zkUrl)
@@ -154,8 +160,11 @@ conditions:
_, err = z.Conn.Set(routerPath, []byte(testYML), 0)
assert.NoError(t, err)
- defer ts.Stop()
- defer z.Close()
+ defer func() {
+ err = ts.Stop()
+ assert.NoError(t, err)
+ z.Close()
+ }()
zkUrl, _ := common.NewURL(fmt.Sprintf(zkFormat, routerLocalIP, ts.Servers[0].Port))
configuration, err := extension.GetConfigCenterFactory(routerZk).GetDynamicConfiguration(zkUrl)
diff --git a/cluster/router/condition/file_test.go b/cluster/router/condition/file_test.go
index 441e91ee5..9035e9559 100644
--- a/cluster/router/condition/file_test.go
+++ b/cluster/router/condition/file_test.go
@@ -110,12 +110,14 @@ func TestParseServiceRouterKey(t *testing.T) {
assert.Equal(t, "", grp)
assert.Equal(t, "mock-service", srv)
assert.Equal(t, "", ver)
+ assert.NoError(t, err)
testString = "/mock-service:"
grp, srv, ver, err = parseServiceRouterKey(testString)
assert.Equal(t, "", grp)
assert.Equal(t, "mock-service", srv)
assert.Equal(t, "", ver)
+ assert.NoError(t, err)
testString = "grp:mock-service:123"
grp, srv, ver, err = parseServiceRouterKey(testString)
@@ -129,4 +131,5 @@ func TestParseServiceRouterKey(t *testing.T) {
assert.Equal(t, "", grp)
assert.Equal(t, "", srv)
assert.Equal(t, "", ver)
+ assert.NoError(t, err)
}
diff --git a/common/url_test.go b/common/url_test.go
index 9f413494c..1f5c40937 100644
--- a/common/url_test.go
+++ b/common/url_test.go
@@ -68,12 +68,18 @@ func TestURL(t *testing.T) {
"side=provider&timeout=3000×tamp=1556509797245")
assert.NoError(t, err)
+ urlInst := URL{}
+ urlInst.noCopy.Lock()
+ urlInst.noCopy.Unlock()
+ urlInst.baseUrl.paramsLock.Lock()
+ urlInst.baseUrl.paramsLock.Unlock()
+
assert.Equal(t, "/com.ikurento.user.UserProvider", u.Path)
assert.Equal(t, "127.0.0.1:20000", u.Location)
assert.Equal(t, "dubbo", u.Protocol)
assert.Equal(t, loopbackAddress, u.Ip)
assert.Equal(t, "20000", u.Port)
- assert.Equal(t, URL{}.Methods, u.Methods)
+ assert.Equal(t, urlInst.Methods, u.Methods)
assert.Equal(t, "", u.Username)
assert.Equal(t, "", u.Password)
assert.Equal(t, "anyhost=true&application=BDTService&category=providers&default.timeout=10000&dubbo=dubbo-"+
diff --git a/config_center/zookeeper/impl_test.go b/config_center/zookeeper/impl_test.go
index 808bf8fd5..a518bb6ec 100644
--- a/config_center/zookeeper/impl_test.go
+++ b/config_center/zookeeper/impl_test.go
@@ -99,7 +99,10 @@ func initZkData(group string, t *testing.T) (*zk.TestCluster, *zookeeperDynamicC
func TestGetConfig(t *testing.T) {
ts, reg := initZkData("dubbo", t)
- defer ts.Stop()
+ defer func() {
+ err := ts.Stop()
+ assert.NoError(t, err)
+ }()
configs, err := reg.GetProperties(dubboPropertyFileName, config_center.WithGroup("dubbo"))
assert.NoError(t, err)
m, err := reg.Parser().Parse(configs)
@@ -118,7 +121,10 @@ func TestGetConfig(t *testing.T) {
func TestAddListener(t *testing.T) {
ts, reg := initZkData("", t)
- defer ts.Stop()
+ defer func() {
+ err := ts.Stop()
+ assert.NoError(t, err)
+ }()
listener := &mockDataListener{}
reg.AddListener(dubboPropertyFileName, listener)
listener.wg.Add(1)
@@ -151,7 +157,10 @@ func TestAddListener(t *testing.T) {
func TestRemoveListener(t *testing.T) {
ts, reg := initZkData("", t)
- defer ts.Stop()
+ defer func() {
+ err := ts.Stop()
+ assert.NoError(t, err)
+ }()
listener := &mockDataListener{}
reg.AddListener(dubboPropertyFileName, listener)
listener.wg.Add(1)
@@ -189,7 +198,10 @@ func TestZookeeperDynamicConfigurationPublishConfig(t *testing.T) {
customGroup := "Custom Group"
key := "myKey"
ts, zk := initZkData(config_center.DEFAULT_GROUP, t)
- defer ts.Stop()
+ defer func() {
+ err := ts.Stop()
+ assert.NoError(t, err)
+ }()
err := zk.PublishConfig(key, customGroup, value)
assert.Nil(t, err)
result, err := zk.GetInternalProperty("myKey", config_center.WithGroup(customGroup))
diff --git a/metadata/report/consul/report_test.go b/metadata/report/consul/report_test.go
index 13d0c419b..51e93179a 100644
--- a/metadata/report/consul/report_test.go
+++ b/metadata/report/consul/report_test.go
@@ -143,7 +143,9 @@ func (suite *consulMetadataReportTestSuite) testGetServiceDefinition() {
func test1(t *testing.T) {
consulAgent := consul.NewConsulAgent(t, 8500)
- defer consulAgent.Shutdown()
+ defer func() {
+ _ = consulAgent.Shutdown()
+ }()
url := newProviderRegistryUrl("localhost", 8500)
mf := extension.GetMetadataReportFactory("consul")
diff --git a/metadata/report/delegate/delegate_report.go b/metadata/report/delegate/delegate_report.go
index 836a8f9ef..f364087fd 100644
--- a/metadata/report/delegate/delegate_report.go
+++ b/metadata/report/delegate/delegate_report.go
@@ -220,7 +220,11 @@ func (mr *MetadataReport) SaveServiceMetadata(identifier *identifier.ServiceMeta
if mr.syncReport {
return report.SaveServiceMetadata(identifier, url)
}
- go report.SaveServiceMetadata(identifier, url)
+ go func() {
+ if err := report.SaveServiceMetadata(identifier, url); err != nil {
+ logger.Warnf("report.SaveServiceMetadata(identifier:%v, url:%v) = error:%v", identifier, url, err)
+ }
+ }()
return nil
}
@@ -230,7 +234,11 @@ func (mr *MetadataReport) RemoveServiceMetadata(identifier *identifier.ServiceMe
if mr.syncReport {
return report.RemoveServiceMetadata(identifier)
}
- go report.RemoveServiceMetadata(identifier)
+ go func() {
+ if err := report.RemoveServiceMetadata(identifier); err != nil {
+ logger.Warnf("report.RemoveServiceMetadata(identifier:%v) = error:%v", identifier, err)
+ }
+ }()
return nil
}
@@ -255,7 +263,12 @@ func (mr *MetadataReport) SaveSubscribedData(identifier *identifier.SubscriberMe
if mr.syncReport {
return report.SaveSubscribedData(identifier, string(bytes))
}
- go report.SaveSubscribedData(identifier, string(bytes))
+ go func() {
+ if err := report.SaveSubscribedData(identifier, string(bytes)); err != nil {
+ logger.Warnf("report.SaveSubscribedData(identifier:%v, string(bytes):%v) = error: %v",
+ identifier, string(bytes), err)
+ }
+ }()
return nil
}
diff --git a/metadata/report/etcd/report_test.go b/metadata/report/etcd/report_test.go
index 28c048698..59d0975ca 100644
--- a/metadata/report/etcd/report_test.go
+++ b/metadata/report/etcd/report_test.go
@@ -82,8 +82,9 @@ func TestEtcdMetadataReport_CRUD(t *testing.T) {
assert.Nil(t, err)
serviceMi := newServiceMetadataIdentifier()
- serviceUrl, _ := common.NewURL("registry://localhost:8848", common.WithParamsValue(constant.ROLE_KEY, strconv.Itoa(common.PROVIDER)))
- metadataReport.SaveServiceMetadata(serviceMi, serviceUrl)
+ serviceUrl, err := common.NewURL("registry://localhost:8848", common.WithParamsValue(constant.ROLE_KEY, strconv.Itoa(common.PROVIDER)))
+ assert.Nil(t, err)
+ err = metadataReport.SaveServiceMetadata(serviceMi, serviceUrl)
assert.Nil(t, err)
subMi := newSubscribeMetadataIdentifier()
diff --git a/metadata/service/inmemory/service_proxy_test.go b/metadata/service/inmemory/service_proxy_test.go
index 01d9206f4..9278fd9d6 100644
--- a/metadata/service/inmemory/service_proxy_test.go
+++ b/metadata/service/inmemory/service_proxy_test.go
@@ -62,12 +62,19 @@ func TestNewMetadataService(t *testing.T) {
assert.Nil(t, err)
_, err = pxy.GetServiceDefinitionByServiceKey("any")
assert.Nil(t, err)
- pxy.ExportURL(&common.URL{})
- pxy.SubscribeURL(&common.URL{})
- pxy.MethodMapper()
- pxy.UnexportURL(&common.URL{})
- pxy.RefreshMetadata(constant.ANY_VALUE, constant.ANY_VALUE)
-
+ ok, err := pxy.ExportURL(&common.URL{})
+ assert.False(t, ok)
+ assert.NoError(t, err)
+ ok, err = pxy.SubscribeURL(&common.URL{})
+ assert.False(t, ok)
+ assert.NoError(t, err)
+ m := pxy.MethodMapper()
+ assert.True(t, len(m) == 0)
+ err = pxy.UnexportURL(&common.URL{})
+ assert.NoError(t, err)
+ ok, err = pxy.RefreshMetadata(constant.ANY_VALUE, constant.ANY_VALUE)
+ assert.False(t, ok)
+ assert.NoError(t, err)
}
func createPxy() service.MetadataService {
diff --git a/metadata/service/inmemory/service_test.go b/metadata/service/inmemory/service_test.go
index 256412c29..e50cd6208 100644
--- a/metadata/service/inmemory/service_test.go
+++ b/metadata/service/inmemory/service_test.go
@@ -46,7 +46,9 @@ func TestMetadataService(t *testing.T) {
"owner=ZX&pid=1447&revision=0.0.1&side=provider&timeout=3000×tamp=1556509797245&group=%v&version=%v&bean.name=%v",
protocol, serviceName, group, version, beanName))
assert.NoError(t, err)
- mts.ExportURL(u2)
+ ok, err := mts.ExportURL(u2)
+ assert.True(t, ok)
+ assert.NoError(t, err)
u3, err := common.NewURL(fmt.Sprintf(
"%v://127.0.0.1:20000/com.ikurento.user.UserProvider3?anyhost=true&"+
@@ -55,7 +57,9 @@ func TestMetadataService(t *testing.T) {
"owner=ZX&pid=1447&revision=0.0.1&side=provider&timeout=3000×tamp=1556509797245&group=%v&version=%v&bean.name=%v",
protocol, serviceName, group, version, beanName))
assert.NoError(t, err)
- mts.ExportURL(u3)
+ ok, err = mts.ExportURL(u3)
+ assert.True(t, ok)
+ assert.NoError(t, err)
u, err := common.NewURL(fmt.Sprintf(
"%v://127.0.0.1:20000/com.ikurento.user.UserProvider1?anyhost=true&"+
@@ -64,32 +68,45 @@ func TestMetadataService(t *testing.T) {
"owner=ZX&pid=1447&revision=0.0.1&side=provider&timeout=3000×tamp=1556509797245&group=%v&version=%v&bean.name=%v",
protocol, serviceName, group, version, beanName))
assert.NoError(t, err)
- mts.ExportURL(u)
+ ok, err = mts.ExportURL(u)
+ assert.True(t, ok)
+ assert.NoError(t, err)
list, _ := mts.GetExportedURLs(serviceName, group, version, protocol)
assert.Equal(t, 3, len(list))
- mts.SubscribeURL(u)
+ ok, err = mts.SubscribeURL(u)
+ assert.True(t, ok)
+ assert.NoError(t, err)
- mts.SubscribeURL(u)
- list2, _ := mts.GetSubscribedURLs()
+ ok, err = mts.SubscribeURL(u)
+ assert.False(t, ok)
+ assert.NoError(t, err)
+ list2, err := mts.GetSubscribedURLs()
assert.Equal(t, 1, len(list2))
+ assert.NoError(t, err)
- mts.UnexportURL(u)
+ err = mts.UnexportURL(u)
+ assert.NoError(t, err)
list3, _ := mts.GetExportedURLs(serviceName, group, version, protocol)
assert.Equal(t, 2, len(list3))
- mts.UnsubscribeURL(u)
+ err = mts.UnsubscribeURL(u)
+ assert.NoError(t, err)
list4, _ := mts.GetSubscribedURLs()
assert.Equal(t, 0, len(list4))
userProvider := &definition.UserProvider{}
- common.ServiceMap.Register(serviceName, protocol, group, version, userProvider)
- mts.PublishServiceDefinition(u)
+ _, err = common.ServiceMap.Register(serviceName, protocol, group, version, userProvider)
+ assert.NoError(t, err)
+ err = mts.PublishServiceDefinition(u)
+ assert.NoError(t, err)
expected := "{\"CanonicalName\":\"com.ikurento.user.UserProvider\",\"CodeSource\":\"\"," +
"\"Methods\":[{\"Name\":\"GetUser\",\"ParameterTypes\":[\"slice\"],\"ReturnType\":\"ptr\"," +
"\"Parameters\":null}],\"Types\":null}"
- def1, _ := mts.GetServiceDefinition(serviceName, group, version)
+ def1, err := mts.GetServiceDefinition(serviceName, group, version)
assert.Equal(t, expected, def1)
+ assert.NoError(t, err)
serviceKey := definition.ServiceDescriperBuild(serviceName, group, version)
- def2, _ := mts.GetServiceDefinitionByServiceKey(serviceKey)
+ def2, err := mts.GetServiceDefinitionByServiceKey(serviceKey)
assert.Equal(t, expected, def2)
+ assert.NoError(t, err)
}
diff --git a/metadata/service/remote/service_proxy_test.go b/metadata/service/remote/service_proxy_test.go
index 8bccbb8bb..1899d0220 100644
--- a/metadata/service/remote/service_proxy_test.go
+++ b/metadata/service/remote/service_proxy_test.go
@@ -54,18 +54,28 @@ func TestMetadataServiceProxy_GetServiceDefinition(t *testing.T) {
// in fact, we don't use them
func TestMetadataServiceProxy(t *testing.T) {
pxy := createProxy()
- pxy.ServiceName()
- pxy.PublishServiceDefinition(&common.URL{})
- pxy.Version()
- pxy.GetSubscribedURLs()
- pxy.UnsubscribeURL(&common.URL{})
- pxy.GetServiceDefinitionByServiceKey("any")
- pxy.ExportURL(&common.URL{})
- pxy.SubscribeURL(&common.URL{})
- pxy.MethodMapper()
- pxy.UnexportURL(&common.URL{})
- pxy.Reference()
- pxy.RefreshMetadata(constant.ANY_VALUE, constant.ANY_VALUE)
+ _, err := pxy.ServiceName()
+ assert.NoError(t, err)
+ err = pxy.PublishServiceDefinition(&common.URL{})
+ assert.NoError(t, err)
+ _, err = pxy.Version()
+ assert.NoError(t, err)
+ _, err = pxy.GetSubscribedURLs()
+ assert.NoError(t, err)
+ err = pxy.UnsubscribeURL(&common.URL{})
+ assert.NoError(t, err)
+ _, err = pxy.GetServiceDefinitionByServiceKey("any")
+ assert.NoError(t, err)
+ _, err = pxy.ExportURL(&common.URL{})
+ assert.NoError(t, err)
+ _, err = pxy.SubscribeURL(&common.URL{})
+ assert.NoError(t, err)
+ _ = pxy.MethodMapper()
+ err = pxy.UnexportURL(&common.URL{})
+ assert.NoError(t, err)
+ _ = pxy.Reference()
+ _, err = pxy.RefreshMetadata(constant.ANY_VALUE, constant.ANY_VALUE)
+ assert.NoError(t, err)
}
func createProxy() service.MetadataService {
diff --git a/protocol/dubbo/hessian2/hessian_request.go b/protocol/dubbo/hessian2/hessian_request.go
index 2a1d5f736..586476fdc 100644
--- a/protocol/dubbo/hessian2/hessian_request.go
+++ b/protocol/dubbo/hessian2/hessian_request.go
@@ -220,31 +220,33 @@ func packRequest(service Service, header DubboHeader, req interface{}) ([]byte,
// body
//////////////////////////////////////////
if hb {
- encoder.Encode(nil)
+ if err := encoder.Encode(nil); err != nil {
+ logger.Warnf("Encode(nil) = error: %v", err)
+ }
goto END
}
// dubbo version + path + version + method
if err := encoder.Encode(DEFAULT_DUBBO_PROTOCOL_VERSION); err != nil {
- logger.Error("Encode(DEFAULT_DUBBO_PROTOCOL_VERSION) = error: %v", err)
+ logger.Warnf("Encode(DEFAULT_DUBBO_PROTOCOL_VERSION) = error: %v", err)
}
if err := encoder.Encode(service.Path); err != nil {
- logger.Error("Encode(service.Path) = error: %v", err)
+ logger.Warnf("Encode(service.Path) = error: %v", err)
}
if err := encoder.Encode(service.Version); err != nil {
- logger.Error("Encode(service.Version) = error: %v", err)
+ logger.Warnf("Encode(service.Version) = error: %v", err)
}
if err := encoder.Encode(service.Method); err != nil {
- logger.Error("Encode(service.Method) = error: %v", err)
+ logger.Warnf("Encode(service.Method) = error: %v", err)
}
// args = args type list + args value list
if types, err = getArgsTypeList(args); err != nil {
return nil, perrors.Wrapf(err, " PackRequest(args:%+v)", args)
}
- encoder.Encode(types)
+ _ = encoder.Encode(types)
for _, v := range args {
- encoder.Encode(v)
+ _ = encoder.Encode(v)
}
request.Attachments[PATH_KEY] = service.Path
@@ -259,7 +261,7 @@ func packRequest(service Service, header DubboHeader, req interface{}) ([]byte,
request.Attachments[TIMEOUT_KEY] = strconv.Itoa(int(service.Timeout / time.Millisecond))
}
- encoder.Encode(request.Attachments)
+ _ = encoder.Encode(request.Attachments)
END:
byteArray = encoder.Buffer()
diff --git a/protocol/dubbo/hessian2/hessian_response.go b/protocol/dubbo/hessian2/hessian_response.go
index 982960ed8..b95e1c271 100644
--- a/protocol/dubbo/hessian2/hessian_response.go
+++ b/protocol/dubbo/hessian2/hessian_response.go
@@ -18,6 +18,7 @@ package hessian2
import (
"encoding/binary"
+ "github.com/apache/dubbo-go/common/logger"
"math"
"reflect"
"strconv"
@@ -93,7 +94,9 @@ func packResponse(header DubboHeader, ret interface{}) ([]byte, error) {
if header.ResponseStatus == Response_OK {
if hb {
- encoder.Encode(nil)
+ if err := encoder.Encode(nil); err != nil {
+ logger.Warnf("Encode(nil) = %v", err)
+ }
} else {
atta := isSupportResponseAttachment(response.Attachments[DUBBO_VERSION_KEY])
@@ -109,30 +112,30 @@ func packResponse(header DubboHeader, ret interface{}) ([]byte, error) {
}
if response.Exception != nil { // throw error
- encoder.Encode(resWithException)
+ _ = encoder.Encode(resWithException)
if t, ok := response.Exception.(java_exception.Throwabler); ok {
- encoder.Encode(t)
+ _ = encoder.Encode(t)
} else {
- encoder.Encode(java_exception.NewThrowable(response.Exception.Error()))
+ _ = encoder.Encode(java_exception.NewThrowable(response.Exception.Error()))
}
} else {
if response.RspObj == nil {
- encoder.Encode(resNullValue)
+ _ = encoder.Encode(resNullValue)
} else {
- encoder.Encode(resValue)
- encoder.Encode(response.RspObj) // result
+ _ = encoder.Encode(resValue)
+ _ = encoder.Encode(response.RspObj) // result
}
}
if atta {
- encoder.Encode(response.Attachments) // attachments
+ _ = encoder.Encode(response.Attachments) // attachments
}
}
} else {
if response.Exception != nil { // throw error
- encoder.Encode(response.Exception.Error())
+ _ = encoder.Encode(response.Exception.Error())
} else {
- encoder.Encode(response.RspObj)
+ _ = encoder.Encode(response.RspObj)
}
}
@@ -145,7 +148,6 @@ func packResponse(header DubboHeader, ret interface{}) ([]byte, error) {
// byteArray{body length}
binary.BigEndian.PutUint32(byteArray[12:], uint32(pkgLen-HEADER_LENGTH))
return byteArray, nil
-
}
// hessian decode response body
diff --git a/protocol/dubbo/impl/hessian.go b/protocol/dubbo/impl/hessian.go
index 5fa1f2ece..c4efb97e4 100644
--- a/protocol/dubbo/impl/hessian.go
+++ b/protocol/dubbo/impl/hessian.go
@@ -63,7 +63,7 @@ func marshalResponse(encoder *hessian.Encoder, p DubboPackage) ([]byte, error) {
response := EnsureResponsePayload(p.Body)
if header.ResponseStatus == Response_OK {
if p.IsHeartBeat() {
- encoder.Encode(nil)
+ _ = encoder.Encode(nil)
} else {
var version string
if attachmentVersion, ok := response.Attachments[DUBBO_VERSION_KEY]; ok {
@@ -83,30 +83,30 @@ func marshalResponse(encoder *hessian.Encoder, p DubboPackage) ([]byte, error) {
}
if response.Exception != nil { // throw error
- encoder.Encode(resWithException)
+ _ = encoder.Encode(resWithException)
if t, ok := response.Exception.(java_exception.Throwabler); ok {
- encoder.Encode(t)
+ _ = encoder.Encode(t)
} else {
- encoder.Encode(java_exception.NewThrowable(response.Exception.Error()))
+ _ = encoder.Encode(java_exception.NewThrowable(response.Exception.Error()))
}
} else {
if response.RspObj == nil {
- encoder.Encode(resNullValue)
+ _ = encoder.Encode(resNullValue)
} else {
- encoder.Encode(resValue)
- encoder.Encode(response.RspObj) // result
+ _ = encoder.Encode(resValue)
+ _ = encoder.Encode(response.RspObj) // result
}
}
if atta {
- encoder.Encode(response.Attachments) // attachments
+ _ = encoder.Encode(response.Attachments) // attachments
}
}
} else {
if response.Exception != nil { // throw error
- encoder.Encode(response.Exception.Error())
+ _ = encoder.Encode(response.Exception.Error())
} else {
- encoder.Encode(response.RspObj)
+ _ = encoder.Encode(response.RspObj)
}
}
bs := encoder.Buffer()
@@ -118,10 +118,10 @@ func marshalResponse(encoder *hessian.Encoder, p DubboPackage) ([]byte, error) {
func marshalRequest(encoder *hessian.Encoder, p DubboPackage) ([]byte, error) {
service := p.Service
request := EnsureRequestPayload(p.Body)
- encoder.Encode(DEFAULT_DUBBO_PROTOCOL_VERSION)
- encoder.Encode(service.Path)
- encoder.Encode(service.Version)
- encoder.Encode(service.Method)
+ _ = encoder.Encode(DEFAULT_DUBBO_PROTOCOL_VERSION)
+ _ = encoder.Encode(service.Path)
+ _ = encoder.Encode(service.Version)
+ _ = encoder.Encode(service.Method)
args, ok := request.Params.([]interface{})
@@ -133,9 +133,9 @@ func marshalRequest(encoder *hessian.Encoder, p DubboPackage) ([]byte, error) {
if err != nil {
return nil, perrors.Wrapf(err, " PackRequest(args:%+v)", args)
}
- encoder.Encode(types)
+ _ = encoder.Encode(types)
for _, v := range args {
- encoder.Encode(v)
+ _ = encoder.Encode(v)
}
request.Attachments[PATH_KEY] = service.Path
@@ -150,9 +150,8 @@ func marshalRequest(encoder *hessian.Encoder, p DubboPackage) ([]byte, error) {
request.Attachments[TIMEOUT_KEY] = strconv.Itoa(int(service.Timeout / time.Millisecond))
}
- encoder.Encode(request.Attachments)
+ _ = encoder.Encode(request.Attachments)
return encoder.Buffer(), nil
-
}
var versionInt = make(map[string]int)
diff --git a/registry/consul/service_discovery_test.go b/registry/consul/service_discovery_test.go
index 2169857ee..348790cb1 100644
--- a/registry/consul/service_discovery_test.go
+++ b/registry/consul/service_discovery_test.go
@@ -84,7 +84,10 @@ func TestConsulServiceDiscovery_Destroy(t *testing.T) {
func TestConsulServiceDiscovery_CRUD(t *testing.T) {
// start consul agent
consulAgent := consul.NewConsulAgent(t, registryPort)
- defer consulAgent.Shutdown()
+ defer func() {
+ err := consulAgent.Shutdown()
+ assert.NoError(t, err)
+ }()
prepareData()
var eventDispatcher = MockEventDispatcher{Notify: make(chan struct{}, 1)}
diff --git a/registry/consul/utils_test.go b/registry/consul/utils_test.go
index d78c534e9..b7e2929ce 100644
--- a/registry/consul/utils_test.go
+++ b/registry/consul/utils_test.go
@@ -19,6 +19,8 @@ package consul
import (
"fmt"
+ "github.com/apache/dubbo-go/common/logger"
+ "github.com/stretchr/testify/assert"
"net"
"net/url"
"strconv"
@@ -113,15 +115,24 @@ func (server *testServer) serve() {
if err != nil {
continue
}
- conn.Write([]byte("Hello World"))
- conn.Close()
+ _, err = conn.Write([]byte("Hello World"))
+ if err != nil {
+ logger.Warnf("conn.Write() = error: %v", err)
+ }
+ err = conn.Close()
+ if err != nil {
+ logger.Warnf("conn.Close() = error: %v", err)
+ }
}
}
}
func (server *testServer) close() {
close(server.done)
- server.listener.Close()
+ if err := server.listener.Close(); err != nil {
+ fmt.Printf("server.listener.Close() = error:%v\n", err)
+ }
+
server.wg.Wait()
}
@@ -148,7 +159,10 @@ func (suite *consulRegistryTestSuite) close() {
// register -> subscribe -> unregister
func test1(t *testing.T) {
consulAgent := consul.NewConsulAgent(t, registryPort)
- defer consulAgent.Shutdown()
+ defer func() {
+ err := consulAgent.Shutdown()
+ assert.NoError(t, err)
+ }()
server := newServer(providerHost, providerPort)
defer server.close()
@@ -169,7 +183,10 @@ func test1(t *testing.T) {
// subscribe -> register -> unregister
func test2(t *testing.T) {
consulAgent := consul.NewConsulAgent(t, registryPort)
- defer consulAgent.Shutdown()
+ defer func() {
+ err := consulAgent.Shutdown()
+ assert.NoError(t, err)
+ }()
server := newServer(providerHost, providerPort)
defer server.close()
diff --git a/registry/etcdv3/service_discovery.go b/registry/etcdv3/service_discovery.go
index e8d4aea9a..4d5b8781b 100644
--- a/registry/etcdv3/service_discovery.go
+++ b/registry/etcdv3/service_discovery.go
@@ -108,8 +108,11 @@ func (e *etcdV3ServiceDiscovery) Update(instance registry.ServiceInstance) error
if nil != e.client {
ins, err := jsonutil.EncodeJSON(instance)
- if nil == err {
- e.client.RegisterTemp(path, string(ins))
+ if err == nil {
+ if err = e.client.RegisterTemp(path, string(ins)); err != nil {
+ logger.Warnf("etcdV3ServiceDiscovery.client.RegisterTemp(path:%v, instance:%v) = error:%v",
+ path, string(ins), err)
+ }
e.services.Add(instance.GetServiceName())
}
}
diff --git a/registry/file/service_discovery.go b/registry/file/service_discovery.go
index 254c12688..d19d1f310 100644
--- a/registry/file/service_discovery.go
+++ b/registry/file/service_discovery.go
@@ -82,7 +82,9 @@ func newFileSystemServiceDiscovery(name string) (registry.ServiceDiscovery, erro
}
extension.AddCustomShutdownCallback(func() {
- sd.Destroy()
+ if err := sd.Destroy(); err != nil {
+ logger.Warnf("sd.Destroy() = error:%v", err)
+ }
})
for _, v := range sd.GetServices().Values() {
diff --git a/registry/file/service_discovery_test.go b/registry/file/service_discovery_test.go
index 0bffcae31..2f52eb52e 100644
--- a/registry/file/service_discovery_test.go
+++ b/registry/file/service_discovery_test.go
@@ -44,7 +44,10 @@ func TestNewFileSystemServiceDiscoveryAndDestroy(t *testing.T) {
serviceDiscovery, err := newFileSystemServiceDiscovery(testName)
assert.NoError(t, err)
assert.NotNil(t, serviceDiscovery)
- defer serviceDiscovery.Destroy()
+ defer func () {
+ err = serviceDiscovery.Destroy()
+ assert.Nil(t, err)
+ }()
}
func TestCURDFileSystemServiceDiscovery(t *testing.T) {
@@ -78,8 +81,11 @@ func TestCURDFileSystemServiceDiscovery(t *testing.T) {
assert.NoError(t, err)
err = serviceDiscovery.Register(r1)
-
- defer serviceDiscovery.Destroy()
+ assert.NoError(t, err)
+ defer func () {
+ err = serviceDiscovery.Destroy()
+ assert.NoError(t, err)
+ }()
}
func prepareData() {
diff --git a/registry/nacos/listener.go b/registry/nacos/listener.go
index 7f27326d6..6783bf468 100644
--- a/registry/nacos/listener.go
+++ b/registry/nacos/listener.go
@@ -188,7 +188,9 @@ func (nl *nacosListener) startListen() error {
}
serviceName := getSubscribeName(nl.listenUrl)
nl.subscribeParam = &vo.SubscribeParam{ServiceName: serviceName, SubscribeCallback: nl.Callback}
- go nl.namingClient.Subscribe(nl.subscribeParam)
+ go func() {
+ _ = nl.namingClient.Subscribe(nl.subscribeParam)
+ }()
return nil
}
diff --git a/registry/nacos/registry_test.go b/registry/nacos/registry_test.go
index 078b8ce59..a852c00b1 100644
--- a/registry/nacos/registry_test.go
+++ b/registry/nacos/registry_test.go
@@ -167,7 +167,9 @@ func TestNacosRegistry_Subscribe_del(t *testing.T) {
nacosReg := reg.(*nacosRegistry)
//deregister instance to mock instance offline
- nacosReg.namingClient.DeregisterInstance(vo.DeregisterInstanceParam{Ip: "127.0.0.2", Port: 20000, ServiceName: "providers:com.ikurento.user.UserProvider:2.0.0:guangzhou-idc"})
+ _, err = nacosReg.namingClient.DeregisterInstance(vo.DeregisterInstanceParam{Ip: "127.0.0.2", Port: 20000,
+ ServiceName: "providers:com.ikurento.user.UserProvider:2.0.0:guangzhou-idc"})
+ assert.NoError(t, err)
serviceEvent3, _ := listener.Next()
assert.NoError(t, err)
diff --git a/registry/protocol/protocol.go b/registry/protocol/protocol.go
index 3be88c3be..4fcdf93c0 100644
--- a/registry/protocol/protocol.go
+++ b/registry/protocol/protocol.go
@@ -212,7 +212,11 @@ func (proto *registryProtocol) Export(invoker protocol.Invoker) protocol.Exporte
logger.Infof("The exporter has not been cached, and will return a new exporter!")
}
- go reg.Subscribe(overriderUrl, overrideSubscribeListener)
+ go func() {
+ if err = reg.Subscribe(overriderUrl, overrideSubscribeListener); err != nil {
+ logger.Warnf("reg.subscribe(overriderUrl:%v) = error:%v", overriderUrl, err)
+ }
+ }()
return cachedExporter.(protocol.Exporter)
}
diff --git a/registry/servicediscovery/service_discovery_registry_test.go b/registry/servicediscovery/service_discovery_registry_test.go
index ad6b73d3b..a65e6e404 100644
--- a/registry/servicediscovery/service_discovery_registry_test.go
+++ b/registry/servicediscovery/service_discovery_registry_test.go
@@ -79,18 +79,17 @@ func TestServiceDiscoveryRegistry_Register(t *testing.T) {
registry, err := newServiceDiscoveryRegistry(registryURL)
assert.Nil(t, err)
assert.NotNil(t, registry)
- registry.Register(url)
+ err = registry.Register(url)
+ assert.NoError(t, err)
}
type mockEventDispatcher struct {
}
func (m *mockEventDispatcher) AddEventListener(observer.EventListener) {
-
}
func (m *mockEventDispatcher) AddEventListeners([]observer.EventListener) {
-
}
func (m *mockEventDispatcher) RemoveEventListener(observer.EventListener) {
diff --git a/registry/zookeeper/registry_test.go b/registry/zookeeper/registry_test.go
index d7a011ec4..63f4b2502 100644
--- a/registry/zookeeper/registry_test.go
+++ b/registry/zookeeper/registry_test.go
@@ -34,11 +34,13 @@ import (
)
func Test_Register(t *testing.T) {
- regurl, _ := common.NewURL("registry://127.0.0.1:1111", common.WithParamsValue(constant.ROLE_KEY, strconv.Itoa(common.PROVIDER)))
+ regURL, _ := common.NewURL("registry://127.0.0.1:1111", common.WithParamsValue(constant.ROLE_KEY, strconv.Itoa(common.PROVIDER)))
url, _ := common.NewURL("dubbo://127.0.0.1:20000/com.ikurento.user.UserProvider", common.WithParamsValue(constant.CLUSTER_KEY, "mock"), common.WithParamsValue("serviceid", "soa.mock"), common.WithMethods([]string{"GetUser", "AddUser"}))
- ts, reg, _ := newMockZkRegistry(regurl)
- defer ts.Stop()
+ ts, reg, _ := newMockZkRegistry(regURL)
+ defer func() {
+ _ = ts.Stop()
+ }()
err := reg.Register(url)
children, _ := reg.client.GetChildren("/dubbo/com.ikurento.user.UserProvider/providers")
assert.Regexp(t, ".*dubbo%3A%2F%2F127.0.0.1%3A20000%2Fcom.ikurento.user.UserProvider%3Fanyhost%3Dtrue%26cluster%3Dmock%26.*.serviceid%3Dsoa.mock", children)
@@ -47,11 +49,13 @@ func Test_Register(t *testing.T) {
func Test_UnRegister(t *testing.T) {
// register
- regurl, _ := common.NewURL("registry://127.0.0.1:1111", common.WithParamsValue(constant.ROLE_KEY, strconv.Itoa(common.PROVIDER)))
+ regURL, _ := common.NewURL("registry://127.0.0.1:1111", common.WithParamsValue(constant.ROLE_KEY, strconv.Itoa(common.PROVIDER)))
url, _ := common.NewURL("dubbo://127.0.0.1:20000/com.ikurento.user.UserProvider", common.WithParamsValue(constant.CLUSTER_KEY, "mock"), common.WithParamsValue("serviceid", "soa.mock"), common.WithMethods([]string{"GetUser", "AddUser"}))
- ts, reg, _ := newMockZkRegistry(regurl)
- defer ts.Stop()
+ ts, reg, _ := newMockZkRegistry(regURL)
+ defer func() {
+ _ = ts.Stop()
+ }()
err := reg.Register(url)
children, _ := reg.client.GetChildren("/dubbo/com.ikurento.user.UserProvider/providers")
assert.Regexp(t, ".*dubbo%3A%2F%2F127.0.0.1%3A20000%2Fcom.ikurento.user.UserProvider%3Fanyhost%3Dtrue%26cluster%3Dmock%26.*.serviceid%3Dsoa.mock", children)
@@ -71,9 +75,9 @@ func Test_UnRegister(t *testing.T) {
}
func Test_Subscribe(t *testing.T) {
- regurl, _ := common.NewURL("registry://127.0.0.1:1111", common.WithParamsValue(constant.ROLE_KEY, strconv.Itoa(common.PROVIDER)))
+ regURL, _ := common.NewURL("registry://127.0.0.1:1111", common.WithParamsValue(constant.ROLE_KEY, strconv.Itoa(common.PROVIDER)))
url, _ := common.NewURL("dubbo://127.0.0.1:20000/com.ikurento.user.UserProvider", common.WithParamsValue(constant.CLUSTER_KEY, "mock"), common.WithMethods([]string{"GetUser", "AddUser"}))
- ts, reg, _ := newMockZkRegistry(regurl)
+ ts, reg, _ := newMockZkRegistry(regURL)
//provider register
err := reg.Register(url)
@@ -84,8 +88,8 @@ func Test_Subscribe(t *testing.T) {
}
//consumer register
- regurl.SetParam(constant.ROLE_KEY, strconv.Itoa(common.CONSUMER))
- _, reg2, _ := newMockZkRegistry(regurl, zookeeper.WithTestCluster(ts))
+ regURL.SetParam(constant.ROLE_KEY, strconv.Itoa(common.CONSUMER))
+ _, reg2, _ := newMockZkRegistry(regURL, zookeeper.WithTestCluster(ts))
err = reg2.Register(url)
assert.Nil(t, err)
@@ -97,13 +101,15 @@ func Test_Subscribe(t *testing.T) {
return
}
assert.Regexp(t, ".*ServiceEvent{Action{add}.*", serviceEvent.String())
- defer ts.Stop()
+ defer func() {
+ _ = ts.Stop()
+ }()
}
func Test_UnSubscribe(t *testing.T) {
- regurl, _ := common.NewURL("registry://127.0.0.1:1111", common.WithParamsValue(constant.ROLE_KEY, strconv.Itoa(common.PROVIDER)))
+ regURL, _ := common.NewURL("registry://127.0.0.1:1111", common.WithParamsValue(constant.ROLE_KEY, strconv.Itoa(common.PROVIDER)))
url, _ := common.NewURL("dubbo://127.0.0.1:20000/com.ikurento.user.UserProvider", common.WithParamsValue(constant.CLUSTER_KEY, "mock"), common.WithMethods([]string{"GetUser", "AddUser"}))
- ts, reg, _ := newMockZkRegistry(regurl)
+ ts, reg, _ := newMockZkRegistry(regURL)
//provider register
err := reg.Register(url)
@@ -114,8 +120,8 @@ func Test_UnSubscribe(t *testing.T) {
}
//consumer register
- regurl.SetParam(constant.ROLE_KEY, strconv.Itoa(common.CONSUMER))
- _, reg2, _ := newMockZkRegistry(regurl, zookeeper.WithTestCluster(ts))
+ regURL.SetParam(constant.ROLE_KEY, strconv.Itoa(common.CONSUMER))
+ _, reg2, _ := newMockZkRegistry(regURL, zookeeper.WithTestCluster(ts))
err = reg2.Register(url)
assert.Nil(t, err)
@@ -131,16 +137,19 @@ func Test_UnSubscribe(t *testing.T) {
err = reg2.UnSubscribe(url, nil)
assert.Nil(t, err)
assert.Nil(t, reg2.listener)
-
- defer ts.Stop()
+ defer func() {
+ _ = ts.Stop()
+ }()
}
-func Test_ConsumerDestory(t *testing.T) {
- regurl, _ := common.NewURL("registry://127.0.0.1:1111", common.WithParamsValue(constant.ROLE_KEY, strconv.Itoa(common.CONSUMER)))
+func Test_ConsumerDestroy(t *testing.T) {
+ regURL, _ := common.NewURL("registry://127.0.0.1:1111", common.WithParamsValue(constant.ROLE_KEY, strconv.Itoa(common.CONSUMER)))
url, _ := common.NewURL("dubbo://127.0.0.1:20000/com.ikurento.user.UserProvider", common.WithParamsValue(constant.CLUSTER_KEY, "mock"), common.WithMethods([]string{"GetUser", "AddUser"}))
- ts, reg, err := newMockZkRegistry(regurl)
- defer ts.Stop()
+ ts, reg, err := newMockZkRegistry(regURL)
+ defer func() {
+ _ = ts.Stop()
+ }()
assert.NoError(t, err)
err = reg.Register(url)
@@ -152,15 +161,16 @@ func Test_ConsumerDestory(t *testing.T) {
time.Sleep(1e9)
reg.Destroy()
assert.Equal(t, false, reg.IsAvailable())
-
}
-func Test_ProviderDestory(t *testing.T) {
- regurl, _ := common.NewURL("registry://127.0.0.1:1111", common.WithParamsValue(constant.ROLE_KEY, strconv.Itoa(common.PROVIDER)))
+func Test_ProviderDestroy(t *testing.T) {
+ regURL, _ := common.NewURL("registry://127.0.0.1:1111", common.WithParamsValue(constant.ROLE_KEY, strconv.Itoa(common.PROVIDER)))
url, _ := common.NewURL("dubbo://127.0.0.1:20000/com.ikurento.user.UserProvider", common.WithParamsValue(constant.CLUSTER_KEY, "mock"), common.WithMethods([]string{"GetUser", "AddUser"}))
- ts, reg, err := newMockZkRegistry(regurl)
- defer ts.Stop()
+ ts, reg, err := newMockZkRegistry(regURL)
+ defer func() {
+ _ = ts.Stop()
+ }()
assert.NoError(t, err)
err = reg.Register(url)
diff --git a/remoting/etcdv3/client.go b/remoting/etcdv3/client.go
index ebd454242..34ee31bd9 100644
--- a/remoting/etcdv3/client.go
+++ b/remoting/etcdv3/client.go
@@ -416,7 +416,9 @@ func (c *Client) keepAliveKV(k string, v string) error {
keepAlive, err := c.rawClient.KeepAlive(c.ctx, lease.ID)
if err != nil || keepAlive == nil {
- c.rawClient.Revoke(c.ctx, lease.ID)
+ if _, revokeErr := c.rawClient.Revoke(c.ctx, lease.ID); revokeErr != nil {
+ logger.Warnf("rawClient.Revoke() = error:%v", revokeErr)
+ }
if err != nil {
return perrors.WithMessage(err, "keep alive lease")
} else {
diff --git a/remoting/etcdv3/client_test.go b/remoting/etcdv3/client_test.go
index da31136ed..181f5c6c8 100644
--- a/remoting/etcdv3/client_test.go
+++ b/remoting/etcdv3/client_test.go
@@ -133,7 +133,8 @@ func (suite *ClientTestSuite) setUpClient() *Client {
// set up a client for suite
func (suite *ClientTestSuite) SetupTest() {
c := suite.setUpClient()
- c.CleanKV()
+ err := c.CleanKV()
+ suite.Nil(err)
suite.client = c
return
}
diff --git a/remoting/getty/getty_client_test.go b/remoting/getty/getty_client_test.go
index 0b18e973c..982c509b3 100644
--- a/remoting/getty/getty_client_test.go
+++ b/remoting/getty/getty_client_test.go
@@ -87,7 +87,9 @@ func getClient(url *common.URL) *Client {
exchangeClient := remoting.NewExchangeClient(url, client, 5*time.Second, false)
client.SetExchangeClient(exchangeClient)
- client.Connect(url)
+ if err := client.Connect(url); err != nil {
+ return nil
+ }
return client
}
@@ -396,7 +398,8 @@ func InitTest(t *testing.T) (*Server, *common.URL) {
"side=provider&timeout=3000×tamp=1556509797245&bean.name=UserProvider")
// init server
userProvider := &UserProvider{}
- common.ServiceMap.Register("", url.Protocol, "", "0.0.1", userProvider)
+ _, err = common.ServiceMap.Register("", url.Protocol, "", "0.0.1", userProvider)
+ assert.NoError(t, err)
invoker := &proxy_factory.ProxyInvoker{
BaseInvoker: *protocol.NewBaseInvoker(url),
}
diff --git a/remoting/getty/pool.go b/remoting/getty/pool.go
index 9689175bc..c70aeea51 100644
--- a/remoting/getty/pool.go
+++ b/remoting/getty/pool.go
@@ -149,13 +149,23 @@ func (c *gettyRPCClient) newSession(session getty.Session) error {
panic(fmt.Sprintf("%s, session.conn{%#v} is not tcp connection\n", session.Stat(), session.Conn()))
}
- tcpConn.SetNoDelay(conf.GettySessionParam.TcpNoDelay)
- tcpConn.SetKeepAlive(conf.GettySessionParam.TcpKeepAlive)
+ if err := tcpConn.SetNoDelay(conf.GettySessionParam.TcpNoDelay); err != nil {
+ logger.Error("tcpConn.SetNoDelay() = error:%v", err)
+ }
+ if err := tcpConn.SetKeepAlive(conf.GettySessionParam.TcpKeepAlive); err != nil {
+ logger.Error("tcpConn.SetKeepAlive() = error:%v", err)
+ }
if conf.GettySessionParam.TcpKeepAlive {
- tcpConn.SetKeepAlivePeriod(conf.GettySessionParam.keepAlivePeriod)
+ if err := tcpConn.SetKeepAlivePeriod(conf.GettySessionParam.keepAlivePeriod); err != nil {
+ logger.Error("tcpConn.SetKeepAlivePeriod() = error:%v", err)
+ }
+ }
+ if err := tcpConn.SetReadBuffer(conf.GettySessionParam.TcpRBufSize); err != nil {
+ logger.Error("tcpConn.SetReadBuffer() = error:%v", err)
+ }
+ if err := tcpConn.SetWriteBuffer(conf.GettySessionParam.TcpWBufSize); err != nil {
+ logger.Error("tcpConn.SetWriteBuffer() = error:%v", err)
}
- tcpConn.SetReadBuffer(conf.GettySessionParam.TcpRBufSize)
- tcpConn.SetWriteBuffer(conf.GettySessionParam.TcpWBufSize)
session.SetName(conf.GettySessionParam.SessionName)
session.SetMaxMsgLen(conf.GettySessionParam.MaxMsgLen)
diff --git a/remoting/zookeeper/client_test.go b/remoting/zookeeper/client_test.go
index 34741700c..af09edba4 100644
--- a/remoting/zookeeper/client_test.go
+++ b/remoting/zookeeper/client_test.go
@@ -81,7 +81,10 @@ func verifyEventStateOrder(t *testing.T, c <-chan zk.Event, expectedStates []zk.
func Test_newMockZookeeperClient(t *testing.T) {
ts, z, event, err := NewMockZookeeperClient("test", 15*time.Second)
assert.NoError(t, err)
- defer ts.Stop()
+ defer func() {
+ err := ts.Stop()
+ assert.Nil(t, err)
+ }()
states := []zk.State{zk.StateConnecting, zk.StateConnected, zk.StateHasSession}
verifyEventStateOrder(t, event, states, "event channel")
@@ -92,7 +95,10 @@ func Test_newMockZookeeperClient(t *testing.T) {
func TestCreate(t *testing.T) {
ts, z, event, err := NewMockZookeeperClient("test", 15*time.Second)
assert.NoError(t, err)
- defer ts.Stop()
+ defer func() {
+ err := ts.Stop()
+ assert.Nil(t, err)
+ }()
err = z.Create("test1/test2/test3/test4")
assert.NoError(t, err)
@@ -103,7 +109,10 @@ func TestCreate(t *testing.T) {
func TestCreateDelete(t *testing.T) {
ts, z, event, err := NewMockZookeeperClient("test", 15*time.Second)
assert.NoError(t, err)
- defer ts.Stop()
+ defer func() {
+ err := ts.Stop()
+ assert.Nil(t, err)
+ }()
states := []zk.State{zk.StateConnecting, zk.StateConnected, zk.StateHasSession}
verifyEventStateOrder(t, event, states, "event channel")
@@ -117,7 +126,10 @@ func TestCreateDelete(t *testing.T) {
func TestRegisterTemp(t *testing.T) {
ts, z, event, err := NewMockZookeeperClient("test", 15*time.Second)
assert.NoError(t, err)
- defer ts.Stop()
+ defer func() {
+ err := ts.Stop()
+ assert.Nil(t, err)
+ }()
err = z.Create("/test1/test2/test3")
assert.NoError(t, err)
@@ -131,7 +143,10 @@ func TestRegisterTemp(t *testing.T) {
func TestRegisterTempSeq(t *testing.T) {
ts, z, event, err := NewMockZookeeperClient("test", 15*time.Second)
assert.NoError(t, err)
- defer ts.Stop()
+ defer func() {
+ err := ts.Stop()
+ assert.Nil(t, err)
+ }()
err = z.Create("/test1/test2/test3")
assert.NoError(t, err)
tmpath, err := z.RegisterTempSeq("/test1/test2/test3", []byte("test"))
diff --git a/remoting/zookeeper/facade_test.go b/remoting/zookeeper/facade_test.go
index 3d5798c94..4a76a80ef 100644
--- a/remoting/zookeeper/facade_test.go
+++ b/remoting/zookeeper/facade_test.go
@@ -88,7 +88,11 @@ func (r *mockFacade) IsAvailable() bool {
func Test_Facade(t *testing.T) {
ts, z, event, err := NewMockZookeeperClient("test", 15*time.Second)
assert.NoError(t, err)
- defer ts.Stop()
+ defer func() {
+ if err := ts.Stop(); err != nil {
+ t.Errorf("tc.Stop() = error: %v", err)
+ }
+ }()
url, _ := common.NewURL("mock://127.0.0.1")
mock := newMockFacade(z, url)
go HandleClientRestart(mock)
diff --git a/remoting/zookeeper/listener_test.go b/remoting/zookeeper/listener_test.go
index 37ef1b4b9..07976dc31 100644
--- a/remoting/zookeeper/listener_test.go
+++ b/remoting/zookeeper/listener_test.go
@@ -95,7 +95,11 @@ func TestListener(t *testing.T) {
`
var wait sync.WaitGroup
ts, client, event := initZkData(t)
- defer ts.Stop()
+ defer func () {
+ if err := ts.Stop(); err != nil {
+ t.Errorf("ts.Stop() = error: %v", err)
+ }
+ }()
client.Wait.Add(1)
wait.Add(1)
go client.HandleZkEvent(event)
--
GitLab