fix remoting linter error

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)

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)

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)
 }

common/url_test.go

@@ -68,12 +68,18 @@ func TestURL(t *testing.T) {
 		"side=provider&timeout=3000&timestamp=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-"+

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))

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")

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
 }
 

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()

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 {

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&timestamp=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&timestamp=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&timestamp=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)
 }

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 {

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()

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

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)

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)}

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()

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())
 		}
 	}

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() {

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() {

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
 }