This is an automated email from the ASF dual-hosted git repository.
alexstocks pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/dubbo-go.git
commit 8eebbe66804096ecf73ffb15f012167bf8e9560f
Author: AlexStocks <alexsto...@foxmail.com>
AuthorDate: Sun Jan 3 03:36:55 2021 +0800
fix remoting linter error
---
cluster/router/chain/chain_test.go | 9 +++--
config_center/zookeeper/impl_test.go | 20 ++++++++---
metadata/report/delegate/delegate_report.go | 19 ++++++++--
metadata/report/etcd/report_test.go | 5 +--
metadata/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 | 21 +++++++----
protocol/dubbo/hessian2/hessian_response.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/protocol/protocol.go | 6 +++-
.../service_discovery_registry_test.go | 5 ++-
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 +++-
22 files changed, 225 insertions(+), 80 deletions(-)
diff --git a/cluster/router/chain/chain_test.go
b/cluster/router/chain/chain_test.go
index b21990b..0c3b218 100644
--- a/cluster/router/chain/chain_test.go
+++ b/cluster/router/chain/chain_test.go
@@ -133,6 +133,7 @@ conditions:
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 +155,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))
diff --git a/config_center/zookeeper/impl_test.go
b/config_center/zookeeper/impl_test.go
index 808bf8f..a518bb6 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/delegate/delegate_report.go
b/metadata/report/delegate/delegate_report.go
index 836a8f9..f364087 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 28c0486..59d0975 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 01d9206..9278fd9 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 256412c..e50cd62 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 8bccbb8..1899d02 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 2a1d5f7..14a8af7 100644
--- a/protocol/dubbo/hessian2/hessian_request.go
+++ b/protocol/dubbo/hessian2/hessian_request.go
@@ -220,31 +220,38 @@ 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)
+ if err := encoder.Encode(types); err != nil {
+ logger.Warnf("Encode(types:%v) = error: %v", types, err)
+ }
+
for _, v := range args {
- encoder.Encode(v)
+ if err := encoder.Encode(v); err != nil {
+ logger.Warnf("Encode(v:%v) = error:%v", v, err)
+ }
}
request.Attachments[PATH_KEY] = service.Path
diff --git a/protocol/dubbo/hessian2/hessian_response.go
b/protocol/dubbo/hessian2/hessian_response.go
index 982960e..3c2a278 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])
diff --git a/registry/consul/utils_test.go b/registry/consul/utils_test.go
index d78c534..b7e2929 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 e8d4aea..4d5b878 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 254c126..d19d1f3 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 0bffcae..2f52eb5 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/protocol/protocol.go b/registry/protocol/protocol.go
index 3be88c3..4fcdf93 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 ad6b73d..a65e6e4 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/remoting/etcdv3/client.go b/remoting/etcdv3/client.go
index ebd4542..34ee31b 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 da31136..181f5c6 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 0b18e97..982c509 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 9689175..c70aeea 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 3474170..af09edb 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 3d5798c..4a76a80 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 37ef1b4..07976dc 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)
