diff --git a/.github/workflows/github-actions.yml b/.github/workflows/github-actions.yml
index 79f6f2066e38f91d862453c39f0c25797546a42a..48a3feba4b29e9de039cbf73b4ab76f7e1d6ac30 100644
--- a/.github/workflows/github-actions.yml
+++ b/.github/workflows/github-actions.yml
@@ -53,7 +53,7 @@ jobs:
else
go get -v -t -d ./...
fi
-
+
- name: Verify
run: |
make verify
@@ -61,6 +61,12 @@ jobs:
- name: Integrate Test
run: |
chmod +x integrate_test.sh && ./integrate_test.sh
+
+ - name: Install go ci lint
+ run: curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $(go env GOPATH)/bin v1.27.0
+
+ - name: Run Linter
+ run: golangci-lint run --timeout=10m -v
- name: Post Coverage
run: bash <(curl -s https://codecov.io/bash)
diff --git a/cluster/cluster_impl/failback_cluster_invoker.go b/cluster/cluster_impl/failback_cluster_invoker.go
index 62f48045ec6edbc19d6603509fa1ae8c2d4ce9ee..5e0d133a670160df4acf321ea05356cb2a45a8b5 100644
--- a/cluster/cluster_impl/failback_cluster_invoker.go
+++ b/cluster/cluster_impl/failback_cluster_invoker.go
@@ -77,8 +77,7 @@ func (invoker *failbackClusterInvoker) tryTimerTaskProc(ctx context.Context, ret
invoked = append(invoked, retryTask.lastInvoker)
retryInvoker := invoker.doSelect(retryTask.loadbalance, retryTask.invocation, retryTask.invokers, invoked)
- var result protocol.Result
- result = retryInvoker.Invoke(ctx, retryTask.invocation)
+ result := retryInvoker.Invoke(ctx, retryTask.invocation)
if result.Error() != nil {
retryTask.lastInvoker = retryInvoker
invoker.checkRetry(retryTask, result.Error())
@@ -121,8 +120,11 @@ func (invoker *failbackClusterInvoker) checkRetry(retryTask *retryTimerTask, err
if retryTask.retries > invoker.maxRetries {
logger.Errorf("Failed retry times exceed threshold (%v), We have to abandon, invocation-> %v.\n",
retryTask.retries, retryTask.invocation)
- } else {
- invoker.taskList.Put(retryTask)
+ return
+ }
+
+ if err := invoker.taskList.Put(retryTask); err != nil {
+ logger.Errorf("invoker.taskList.Put(retryTask:%#v) = error:%v", retryTask, err)
}
}
diff --git a/cluster/router/chain/chain.go b/cluster/router/chain/chain.go
index 0e175ddf2304d3713452a9897c98823ee653b65b..13cb1ff3528414a3c164c6b634cfd92a3cd17664 100644
--- a/cluster/router/chain/chain.go
+++ b/cluster/router/chain/chain.go
@@ -187,7 +187,7 @@ func (c *RouterChain) copyInvokerIfNecessary(cache *InvokerCache) []protocol.Inv
func (c *RouterChain) buildCache() {
origin := c.loadCache()
invokers := c.copyInvokerIfNecessary(origin)
- if invokers == nil || len(invokers) == 0 {
+ if len(invokers) == 0 {
return
}
diff --git a/cluster/router/chain/chain_test.go b/cluster/router/chain/chain_test.go
index b4b3d72700b6aff6906622f732664b72fe6a0765..06e905a351d9b7f508342e73ddbdc092601c6299 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))
@@ -160,11 +166,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))
@@ -204,11 +214,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))
@@ -230,12 +244,17 @@ conditions:
func TestRouterChainRouteNoRoute(t *testing.T) {
ts, z, _, err := zookeeper.NewMockZookeeperClient("test", 15*time.Second)
- defer ts.Stop()
- defer z.Close()
+ assert.Nil(t, err)
+ 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)
config.GetEnvInstance().SetDynamicConfiguration(configuration)
+ assert.Nil(t, err)
chain, err := NewRouterChain(getConditionNoRouteUrl(applicationKey))
assert.Nil(t, err)
diff --git a/cluster/router/condition/app_router_test.go b/cluster/router/condition/app_router_test.go
index 29fddfb89513b2c59467c8a51d386cd9837cd10b..b4c3056f8a70f752f96278cf95fe608ee7468f6b 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)
@@ -121,8 +124,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)
@@ -166,8 +172,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 d609c7dcedb798da04f698e4f3e463a61a16f55c..9035e9559223e30cc2a56873b5aa0e4432c0a358 100644
--- a/cluster/router/condition/file_test.go
+++ b/cluster/router/condition/file_test.go
@@ -89,30 +89,35 @@ func TestParseServiceRouterKey(t *testing.T) {
assert.Equal(t, "mock-group", grp)
assert.Equal(t, "mock-service", srv)
assert.Equal(t, "1.0.0", ver)
+ assert.Nil(t, err)
testString = "mock-group/mock-service"
grp, srv, ver, err = parseServiceRouterKey(testString)
assert.Equal(t, "mock-group", grp)
assert.Equal(t, "mock-service", srv)
assert.Equal(t, "", ver)
+ assert.Nil(t, err)
testString = "mock-service:1.0.0"
grp, srv, ver, err = parseServiceRouterKey(testString)
assert.Equal(t, "", grp)
assert.Equal(t, "mock-service", srv)
assert.Equal(t, "1.0.0", ver)
+ assert.Nil(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 = "/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)
@@ -126,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/cluster/router/tag/file.go b/cluster/router/tag/file.go
index 85507f7eb189739f8e9354bb9a726b4148598a02..81c25109dd85f2e358db57633967a851618bf924 100644
--- a/cluster/router/tag/file.go
+++ b/cluster/router/tag/file.go
@@ -41,7 +41,7 @@ type FileTagRouter struct {
router *tagRouter
routerRule *RouterRule
url *common.URL
- force bool
+ //force bool
}
// NewFileTagRouter Create file tag router instance with content (from config file)
diff --git a/cluster/router/tag/router_rule.go b/cluster/router/tag/router_rule.go
index c0a2d763ae7396ae41694f558f443d46084c3357..512d8f10795b04a18947396be8ae7fa6c4f49d4a 100644
--- a/cluster/router/tag/router_rule.go
+++ b/cluster/router/tag/router_rule.go
@@ -84,9 +84,9 @@ func (t *RouterRule) getTagNames() []string {
return result
}
-func (t *RouterRule) hasTag(tag string) bool {
- return len(t.TagNameToAddresses[tag]) > 0
-}
+//func (t *RouterRule) hasTag(tag string) bool {
+// return len(t.TagNameToAddresses[tag]) > 0
+//}
func (t *RouterRule) getAddressToTagNames() map[string][]string {
return t.AddressToTagNames
@@ -96,10 +96,10 @@ func (t *RouterRule) getTagNameToAddresses() map[string][]string {
return t.TagNameToAddresses
}
-func (t *RouterRule) getTags() []Tag {
- return t.Tags
-}
+//func (t *RouterRule) getTags() []Tag {
+// return t.Tags
+//}
-func (t *RouterRule) setTags(tags []Tag) {
- t.Tags = tags
-}
+//func (t *RouterRule) setTags(tags []Tag) {
+// t.Tags = tags
+//}
diff --git a/cluster/router/tag/tag_router.go b/cluster/router/tag/tag_router.go
index 87f944a25a175dc7a2ef319b87f3322795df51c7..3d0393a487deb3eb592da3edb9f37becc394d7df 100644
--- a/cluster/router/tag/tag_router.go
+++ b/cluster/router/tag/tag_router.go
@@ -53,7 +53,7 @@ type addrMetadata struct {
// application name
application string
// is rule a runtime rule
- ruleRuntime bool
+ //ruleRuntime bool
// is rule a force rule
ruleForce bool
// is rule a valid rule
@@ -230,7 +230,7 @@ func (c *tagRouter) Pool(invokers []protocol.Invoker) (router.AddrPool, router.A
// fetchRuleIfNecessary fetches, parses rule and register listener for the further change
func (c *tagRouter) fetchRuleIfNecessary(invokers []protocol.Invoker) {
- if invokers == nil || len(invokers) == 0 {
+ if len(invokers) == 0 {
return
}
diff --git a/cluster/router/tag/tag_router_test.go b/cluster/router/tag/tag_router_test.go
index d7234a3392ccbbf43059e95feb6f12ad18259397..8dccc3420a476ce1d583e9f778886b3d9230b83a 100644
--- a/cluster/router/tag/tag_router_test.go
+++ b/cluster/router/tag/tag_router_test.go
@@ -73,8 +73,7 @@ const (
)
var (
- zkFormat = "zookeeper://%s:%d"
- conditionFormat = "condition://%s/com.foo.BarService"
+ zkFormat = "zookeeper://%s:%d"
)
// MockInvoker is only mock the Invoker to support test tagRouter
@@ -262,7 +261,7 @@ func TestRouteBeijingInvoker(t *testing.T) {
type DynamicTagRouter struct {
suite.Suite
- rule *RouterRule
+ //rule *RouterRule
route *tagRouter
zkClient *zookeeper.ZookeeperClient
@@ -340,7 +339,8 @@ tags:
func (suite *DynamicTagRouter) TearDownTest() {
suite.zkClient.Close()
- suite.testCluster.Stop()
+ err := suite.testCluster.Stop()
+ suite.Nil(err)
}
func (suite *DynamicTagRouter) TestDynamicTagRouterSetByIPv4() {
diff --git a/common/config/environment.go b/common/config/environment.go
index 44cdd1fca18bfed306b135fe38ef536779e148aa..c5651a335444e06f12eb5af831d878ffdbbaeb9f 100644
--- a/common/config/environment.go
+++ b/common/config/environment.go
@@ -34,8 +34,8 @@ import (
// We just have config center configuration which can override configuration in consumer.yaml & provider.yaml.
// But for add these features in future ,I finish the environment struct following Environment class in java.
type Environment struct {
- configCenterFirst bool
- externalConfigs sync.Map
+ configCenterFirst bool
+ //externalConfigs sync.Map
externalConfigMap sync.Map
appExternalConfigMap sync.Map
dynamicConfiguration config_center.DynamicConfiguration
diff --git a/common/constant/key.go b/common/constant/key.go
index 4376f742e022e51563ff872bc06f1e175c020376..6b754a23fb75c82b9b21b88508c1a60273e6303d 100644
--- a/common/constant/key.go
+++ b/common/constant/key.go
@@ -17,6 +17,8 @@
package constant
+type DubboCtxKey string
+
const (
ASYNC_KEY = "async" // it's value should be "true" or "false" of string type
)
@@ -47,8 +49,8 @@ const (
PORT_KEY = "port"
PROTOCOL_KEY = "protocol"
PATH_SEPARATOR = "/"
- DUBBO_KEY = "dubbo"
- SSL_ENABLED_KEY = "ssl-enabled"
+ //DUBBO_KEY = "dubbo"
+ SSL_ENABLED_KEY = "ssl-enabled"
)
const (
@@ -93,7 +95,7 @@ const (
)
const (
- DUBBOGO_CTX_KEY = "dubbogo-ctx"
+ DUBBOGO_CTX_KEY = DubboCtxKey("dubbogo-ctx")
)
const (
@@ -199,11 +201,9 @@ const (
)
const (
- TRACING_REMOTE_SPAN_CTX = "tracing.remote.span.ctx"
+ TRACING_REMOTE_SPAN_CTX = DubboCtxKey("tracing.remote.span.ctx")
)
-type AttachmentCtxKey string
-
// Use for router module
const (
// ConditionRouterName Specify file condition router name
diff --git a/common/logger/logger.go b/common/logger/logger.go
index 63eda231ddd174468602577d8b042bc0664700d0..4a2f07cb30ee6b5840a3915b441ae0a554f5d5cb 100644
--- a/common/logger/logger.go
+++ b/common/logger/logger.go
@@ -163,6 +163,7 @@ type OpsLogger interface {
// SetLoggerLevel use for set logger level
func (dl *DubboLogger) SetLoggerLevel(level string) {
l := new(zapcore.Level)
- l.Set(level)
- dl.dynamicLevel.SetLevel(*l)
+ if err := l.Set(level); err == nil {
+ dl.dynamicLevel.SetLevel(*l)
+ }
}
diff --git a/common/proxy/proxy_test.go b/common/proxy/proxy_test.go
index c6f659666180310887f2101966e59669df707e54..cbac1f3bb4e5c793e19cd0b56ff1aab515aadb9e 100644
--- a/common/proxy/proxy_test.go
+++ b/common/proxy/proxy_test.go
@@ -19,6 +19,7 @@ package proxy
import (
"context"
+ "fmt"
"reflect"
"testing"
)
@@ -145,11 +146,14 @@ type TestProxyInvoker struct {
protocol.BaseInvoker
}
-func (bi *TestProxyInvoker) Invoke(context context.Context, inv protocol.Invocation) protocol.Result {
+func (bi *TestProxyInvoker) Invoke(_ context.Context, inv protocol.Invocation) protocol.Result {
rpcInv := inv.(*invocation.RPCInvocation)
mapV := inv.Attachments()
mapV["TestProxyInvoker"] = "TestProxyInvokerValue"
- hessian2.ReflectResponse(mapV, rpcInv.Reply())
+ if err := hessian2.ReflectResponse(mapV, rpcInv.Reply()); err != nil {
+ fmt.Printf("hessian2.ReflectResponse(mapV:%v) = error:%v", mapV, err)
+ }
+
return &protocol.RPCResult{
Rest: inv.Arguments(),
}
diff --git a/common/rpc_service_test.go b/common/rpc_service_test.go
index 048e623c64db4a56cbb1cb202601d650a47c366c..e8bd3933da89b0a6c607f776eae1bb8603f8f467 100644
--- a/common/rpc_service_test.go
+++ b/common/rpc_service_test.go
@@ -27,6 +27,10 @@ import (
"github.com/stretchr/testify/assert"
)
+import (
+ "github.com/apache/dubbo-go/common/constant"
+)
+
const (
referenceTestPath = "com.test.Path"
referenceTestPathDistinct = "com.test.Path1"
@@ -125,7 +129,7 @@ func TestServiceMapUnRegister(t *testing.T) {
err = ServiceMap.UnRegister("", testProtocol, ServiceKey("TestService", "", "v0"))
assert.EqualError(t, err, "no service for TestService:v0")
- // succ
+ // success
err = ServiceMap.UnRegister("TestService", testProtocol, ServiceKey("TestService", "", "v1"))
assert.NoError(t, err)
}
@@ -133,16 +137,12 @@ func TestServiceMapUnRegister(t *testing.T) {
func TestMethodTypeSuiteContext(t *testing.T) {
mt := &MethodType{ctxType: reflect.TypeOf(context.TODO())}
ctx := context.Background()
- type ctxKey string
- key := ctxKey("key")
+ key := constant.DubboCtxKey("key")
ctx = context.WithValue(ctx, key, "value")
assert.Equal(t, reflect.ValueOf(ctx), mt.SuiteContext(ctx))
-
- assert.Equal(t, reflect.Zero(mt.ctxType), mt.SuiteContext(nil))
}
func TestSuiteMethod(t *testing.T) {
-
s := &TestService{}
method, ok := reflect.TypeOf(s).MethodByName("MethodOne")
assert.True(t, ok)
diff --git a/common/url.go b/common/url.go
index 1ea2bc4321afcf93f148fea07019a892966fd720..ac49465346a95e6aa0ac1e6915bc6c42b91713c6 100644
--- a/common/url.go
+++ b/common/url.go
@@ -21,7 +21,6 @@ import (
"bytes"
"encoding/base64"
"fmt"
- cm "github.com/Workiva/go-datastructures/common"
"math"
"net"
"net/url"
@@ -31,7 +30,9 @@ import (
)
import (
+ cm "github.com/Workiva/go-datastructures/common"
gxset "github.com/dubbogo/gost/container/set"
+
"github.com/jinzhu/copier"
perrors "github.com/pkg/errors"
"github.com/satori/go.uuid"
@@ -89,9 +90,7 @@ type baseUrl struct {
Location string // ip+port
Ip string
Port string
- //url.Values is not safe map, add to avoid concurrent map read and map write error
- paramsLock sync.RWMutex
- params url.Values
+
PrimitiveURL string
}
@@ -115,6 +114,10 @@ type URL struct {
noCopy noCopy
baseUrl
+ //url.Values is not safe map, add to avoid concurrent map read and map write error
+ paramsLock sync.RWMutex
+ params url.Values
+
Path string // like /com.ikurento.dubbo.UserProvider
Username string
Password string
@@ -217,12 +220,12 @@ func WithToken(token string) Option {
// NewURLWithOptions will create a new url with options
func NewURLWithOptions(opts ...Option) *URL {
- newUrl := &URL{}
+ newURL := &URL{}
for _, opt := range opts {
- opt(newUrl)
+ opt(newURL)
}
- newUrl.Location = newUrl.Ip + ":" + newUrl.Port
- return newUrl
+ newURL.Location = newURL.Ip + ":" + newURL.Port
+ return newURL
}
// NewURL will create a new url
@@ -414,6 +417,9 @@ func (c *URL) Service() string {
func (c *URL) AddParam(key string, value string) {
c.paramsLock.Lock()
defer c.paramsLock.Unlock()
+ if c.params == nil {
+ c.params = url.Values{}
+ }
c.params.Add(key, value)
}
@@ -432,6 +438,9 @@ func (c *URL) AddParamAvoidNil(key string, value string) {
func (c *URL) SetParam(key string, value string) {
c.paramsLock.Lock()
defer c.paramsLock.Unlock()
+ if c.params == nil {
+ c.params = url.Values{}
+ }
c.params.Set(key, value)
}
@@ -439,7 +448,9 @@ func (c *URL) SetParam(key string, value string) {
func (c *URL) DelParam(key string) {
c.paramsLock.Lock()
defer c.paramsLock.Unlock()
- c.params.Del(key)
+ if c.params != nil {
+ c.params.Del(key)
+ }
}
// ReplaceParams will replace the URL.params
@@ -465,10 +476,15 @@ func (c *URL) RangeParams(f func(key, value string) bool) {
func (c *URL) GetParam(s string, d string) string {
c.paramsLock.RLock()
defer c.paramsLock.RUnlock()
- r := c.params.Get(s)
+
+ var r string
+ if len(c.params) > 0 {
+ r = c.params.Get(s)
+ }
if len(r) == 0 {
r = d
}
+
return r
}
@@ -679,27 +695,34 @@ func MergeUrl(serviceUrl *URL, referenceUrl *URL) *URL {
// Clone will copy the url
func (c *URL) Clone() *URL {
- newUrl := &URL{}
- copier.Copy(newUrl, c)
- newUrl.params = url.Values{}
+ newURL := &URL{}
+ if err := copier.Copy(newURL, c); err != nil {
+ // this is impossible
+ return newURL
+ }
+ newURL.params = url.Values{}
c.RangeParams(func(key, value string) bool {
- newUrl.SetParam(key, value)
+ newURL.SetParam(key, value)
return true
})
- return newUrl
+
+ return newURL
}
func (c *URL) CloneExceptParams(excludeParams *gxset.HashSet) *URL {
- newUrl := &URL{}
- copier.Copy(newUrl, c)
- newUrl.params = url.Values{}
+ newURL := &URL{}
+ if err := copier.Copy(newURL, c); err != nil {
+ // this is impossible
+ return newURL
+ }
+ newURL.params = url.Values{}
c.RangeParams(func(key, value string) bool {
if !excludeParams.Contains(key) {
- newUrl.SetParam(key, value)
+ newURL.SetParam(key, value)
}
return true
})
- return newUrl
+ return newURL
}
func (c *URL) Compare(comp cm.Comparator) int {
diff --git a/common/url_test.go b/common/url_test.go
index 9f413494c685ecb908e102aa5e8181fd473445e0..c645f1a046777ddf298b54ae5cb19124dd7808c1 100644
--- a/common/url_test.go
+++ b/common/url_test.go
@@ -68,12 +68,17 @@ func TestURL(t *testing.T) {
"side=provider&timeout=3000×tamp=1556509797245")
assert.NoError(t, err)
+ urlInst := URL{}
+ urlInst.noCopy.Lock()
+ urlInst.SetParam("hello", "world")
+ urlInst.noCopy.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-"+
@@ -156,7 +161,10 @@ func TestURLEqual(t *testing.T) {
func TestURLGetParam(t *testing.T) {
params := url.Values{}
params.Set("key", "value")
- u := URL{baseUrl: baseUrl{params: params}}
+
+ u := URL{}
+ u.SetParams(params)
+
v := u.GetParam("key", "default")
assert.Equal(t, "value", v)
@@ -167,8 +175,11 @@ func TestURLGetParam(t *testing.T) {
func TestURLGetParamInt(t *testing.T) {
params := url.Values{}
- params.Set("key", "")
- u := URL{baseUrl: baseUrl{params: params}}
+ params.Set("key", "value")
+
+ u := URL{}
+ u.SetParams(params)
+
v := u.GetParamInt("key", 1)
assert.Equal(t, int64(1), v)
@@ -180,7 +191,10 @@ func TestURLGetParamInt(t *testing.T) {
func TestURLGetParamIntValue(t *testing.T) {
params := url.Values{}
params.Set("key", "0")
- u := URL{baseUrl: baseUrl{params: params}}
+
+ u := URL{}
+ u.SetParams(params)
+
v := u.GetParamInt("key", 1)
assert.Equal(t, int64(0), v)
@@ -192,7 +206,10 @@ func TestURLGetParamIntValue(t *testing.T) {
func TestURLGetParamBool(t *testing.T) {
params := url.Values{}
params.Set("force", "true")
- u := URL{baseUrl: baseUrl{params: params}}
+
+ u := URL{}
+ u.SetParams(params)
+
v := u.GetParamBool("force", false)
assert.Equal(t, true, v)
@@ -205,7 +222,10 @@ func TestURLGetParamAndDecoded(t *testing.T) {
rule := "host = 2.2.2.2,1.1.1.1,3.3.3.3 & host !=1.1.1.1 => host = 1.2.3.4"
params := url.Values{}
params.Set("rule", base64.URLEncoding.EncodeToString([]byte(rule)))
- u := URL{baseUrl: baseUrl{params: params}}
+
+ u := URL{}
+ u.SetParams(params)
+
v, _ := u.GetParamAndDecoded("rule")
assert.Equal(t, rule, v)
}
@@ -242,7 +262,10 @@ func TestURLToMap(t *testing.T) {
func TestURLGetMethodParamInt(t *testing.T) {
params := url.Values{}
params.Set("methods.GetValue.timeout", "3")
- u := URL{baseUrl: baseUrl{params: params}}
+
+ u := URL{}
+ u.SetParams(params)
+
v := u.GetMethodParamInt("GetValue", "timeout", 1)
assert.Equal(t, int64(3), v)
@@ -254,7 +277,10 @@ func TestURLGetMethodParamInt(t *testing.T) {
func TestURLGetMethodParam(t *testing.T) {
params := url.Values{}
params.Set("methods.GetValue.timeout", "3s")
- u := URL{baseUrl: baseUrl{params: params}}
+
+ u := URL{}
+ u.SetParams(params)
+
v := u.GetMethodParam("GetValue", "timeout", "1s")
assert.Equal(t, "3s", v)
@@ -266,7 +292,10 @@ func TestURLGetMethodParam(t *testing.T) {
func TestURLGetMethodParamBool(t *testing.T) {
params := url.Values{}
params.Set("methods.GetValue.async", "true")
- u := URL{baseUrl: baseUrl{params: params}}
+
+ u := URL{}
+ u.SetParams(params)
+
v := u.GetMethodParamBool("GetValue", "async", false)
assert.Equal(t, true, v)
diff --git a/config/base_config.go b/config/base_config.go
index 0cc6eec26c51cb7dfc164a3d43545f6b22658ca0..7cb25a50793b94f2ec2fd8c60e6b93a50b8e77ab 100644
--- a/config/base_config.go
+++ b/config/base_config.go
@@ -45,7 +45,7 @@ type BaseConfig struct {
// application config
ApplicationConfig *ApplicationConfig `yaml:"application" json:"application,omitempty" property:"application"`
- prefix string
+ //prefix string
fatherConfig interface{}
EventDispatcherType string `default:"direct" yaml:"event_dispatcher_type" json:"event_dispatcher_type,omitempty"`
MetricConfig *MetricConfig `yaml:"metrics" json:"metrics,omitempty"`
diff --git a/config/base_config_test.go b/config/base_config_test.go
index 849a9c4586c0c8cd2d74e3dd1011aaab466f0e93..566b49bea7df8a14543347a196d136a8c059a0b5 100644
--- a/config/base_config_test.go
+++ b/config/base_config_test.go
@@ -17,7 +17,6 @@
package config
import (
- "fmt"
"reflect"
"testing"
)
@@ -108,6 +107,7 @@ var baseMockRef = map[string]*ReferenceConfig{
func TestRefresh(t *testing.T) {
c := &BaseConfig{}
+ c.fileStream = nil
mockMap := getMockMap()
mockMap["dubbo.shutdown.timeout"] = "12s"
@@ -285,8 +285,7 @@ func TestInitializeStruct(t *testing.T) {
tp := reflect.TypeOf(ConsumerConfig{})
v := reflect.New(tp)
initializeStruct(tp, v.Elem())
- fmt.Println(reflect.ValueOf(testConsumerConfig).Elem().Type().String())
- fmt.Println(v.Elem().Type().String())
+ t.Logf("testConsumerConfig type:%s", reflect.ValueOf(testConsumerConfig).Elem().Type().String())
reflect.ValueOf(testConsumerConfig).Elem().Set(v.Elem())
assert.Condition(t, func() (success bool) {
diff --git a/config/config_center_config.go b/config/config_center_config.go
index 3bb856415d77344658055f03ccc4a6edd8c0f48a..940b7be951d83a041ebc8121e65a9bd2fd09594b 100644
--- a/config/config_center_config.go
+++ b/config/config_center_config.go
@@ -18,10 +18,8 @@
package config
import (
- "context"
"net/url"
"reflect"
- "time"
)
import (
@@ -46,7 +44,7 @@ import (
//
// ConfigCenter has currently supported Zookeeper, Nacos, Etcd, Consul, Apollo
type ConfigCenterConfig struct {
- context context.Context
+ //context context.Context
Protocol string `required:"true" yaml:"protocol" json:"protocol,omitempty"`
Address string `yaml:"address" json:"address,omitempty"`
Cluster string `yaml:"cluster" json:"cluster,omitempty"`
@@ -60,7 +58,7 @@ type ConfigCenterConfig struct {
AppId string `default:"dubbo" yaml:"app_id" json:"app_id,omitempty"`
TimeoutStr string `yaml:"timeout" json:"timeout,omitempty"`
RemoteRef string `required:"false" yaml:"remote_ref" json:"remote_ref,omitempty"`
- timeout time.Duration
+ //timeout time.Duration
}
// UnmarshalYAML unmarshals the ConfigCenterConfig by @unmarshal function
diff --git a/config/config_loader.go b/config/config_loader.go
index ec591aad6526e5841656465e71465413d01ad5ba..35910981d128bdca7d63973328e2752ecfef6933 100644
--- a/config/config_loader.go
+++ b/config/config_loader.go
@@ -406,9 +406,9 @@ func GetBaseConfig() *BaseConfig {
baseConfig = &BaseConfig{
MetricConfig: &MetricConfig{},
ConfigCenterConfig: &ConfigCenterConfig{},
- Remotes: make(map[string]*RemoteConfig, 0),
+ Remotes: make(map[string]*RemoteConfig),
ApplicationConfig: &ApplicationConfig{},
- ServiceDiscoveries: make(map[string]*ServiceDiscoveryConfig, 0),
+ ServiceDiscoveries: make(map[string]*ServiceDiscoveryConfig),
}
}
}
diff --git a/config/config_loader_test.go b/config/config_loader_test.go
index c3c3eb93526a51fe8f2041b17049144b4ec7b703..ef76bc090877281d2e12b48378476b4042b55943 100644
--- a/config/config_loader_test.go
+++ b/config/config_loader_test.go
@@ -143,7 +143,8 @@ func TestLoadWithSingleReg(t *testing.T) {
conServices = map[string]common.RPCService{}
proServices = map[string]common.RPCService{}
- common.ServiceMap.UnRegister("com.MockService", "mock", common.ServiceKey("com.MockService", "huadong_idc", "1.0.0"))
+ err := common.ServiceMap.UnRegister("com.MockService", "mock", common.ServiceKey("com.MockService", "huadong_idc", "1.0.0"))
+ assert.Nil(t, err)
consumerConfig = nil
providerConfig = nil
}
@@ -182,7 +183,8 @@ func TestWithNoRegLoad(t *testing.T) {
conServices = map[string]common.RPCService{}
proServices = map[string]common.RPCService{}
- common.ServiceMap.UnRegister("com.MockService", "mock", common.ServiceKey("com.MockService", "huadong_idc", "1.0.0"))
+ err := common.ServiceMap.UnRegister("com.MockService", "mock", common.ServiceKey("com.MockService", "huadong_idc", "1.0.0"))
+ assert.Nil(t, err)
consumerConfig = nil
providerConfig = nil
}
@@ -203,10 +205,12 @@ func TestConfigLoaderWithConfigCenter(t *testing.T) {
assert.Equal(t, ProviderConfig{}, GetProviderConfig())
err = ConsumerInit(conPath)
- configCenterRefreshConsumer()
+ assert.NoError(t, err)
+ err = configCenterRefreshConsumer()
assert.NoError(t, err)
err = ProviderInit(proPath)
- configCenterRefreshProvider()
+ assert.NoError(t, err)
+ err = configCenterRefreshProvider()
assert.NoError(t, err)
assert.NotNil(t, consumerConfig)
@@ -256,13 +260,15 @@ func TestConfigLoaderWithConfigCenterSingleRegistry(t *testing.T) {
assert.Equal(t, ProviderConfig{}, GetProviderConfig())
err = ConsumerInit(conPath)
+ assert.NoError(t, err)
checkApplicationName(consumerConfig.ApplicationConfig)
- configCenterRefreshConsumer()
+ err = configCenterRefreshConsumer()
checkRegistries(consumerConfig.Registries, consumerConfig.Registry)
assert.NoError(t, err)
err = ProviderInit(proPath)
+ assert.NoError(t, err)
checkApplicationName(providerConfig.ApplicationConfig)
- configCenterRefreshProvider()
+ err = configCenterRefreshProvider()
checkRegistries(providerConfig.Registries, providerConfig.Registry)
assert.NoError(t, err)
diff --git a/config/registry_config_test.go b/config/registry_config_test.go
index 6e5dedc34ff5489fc190841bce73cd015eb78132..8bd2de1735496ab9e785759609d8bc3459fc1505 100644
--- a/config/registry_config_test.go
+++ b/config/registry_config_test.go
@@ -17,7 +17,6 @@
package config
import (
- "fmt"
"testing"
)
@@ -43,7 +42,7 @@ func TestLoadRegistries(t *testing.T) {
},
}
urls := loadRegistries(target, regs, common.CONSUMER)
- fmt.Println(urls[0])
+ t.Logf("loadRegistries() = urls:%v", urls)
assert.Equal(t, "127.0.0.2:2181,128.0.0.1:2181", urls[0].Location)
}
@@ -61,6 +60,6 @@ func TestLoadRegistries1(t *testing.T) {
},
}
urls := loadRegistries(target, regs, common.CONSUMER)
- fmt.Println(urls[0])
+ t.Logf("loadRegistries() = urls:%v", urls)
assert.Equal(t, "127.0.0.2:2181", urls[0].Location)
}
diff --git a/config/service_config_test.go b/config/service_config_test.go
index 61c8864b6ab7eb146a92e76187cd6363bbdb8dc8..aea0bde7a25d14bb720af0b83f06f44bdd6806c9 100644
--- a/config/service_config_test.go
+++ b/config/service_config_test.go
@@ -176,7 +176,8 @@ func TestExport(t *testing.T) {
service := providerConfig.Services[i]
service.Implement(&MockService{})
service.Protocols = providerConfig.Protocols
- service.Export()
+ err := service.Export()
+ assert.Nil(t, err)
}
providerConfig = nil
}
diff --git a/config_center/apollo/impl.go b/config_center/apollo/impl.go
index c69fc2f66b23cd877b447fc78084fb9197c253aa..cb0f03d54a2ea180543ec528e3a46be45067179c 100644
--- a/config_center/apollo/impl.go
+++ b/config_center/apollo/impl.go
@@ -146,8 +146,7 @@ func (c *apolloConfiguration) getAddressWithProtocolPrefix(url *common.URL) stri
address := url.Location
converted := address
if len(address) != 0 {
- reg := regexp.MustCompile("\\s+")
- address = reg.ReplaceAllString(address, "")
+ address := regexp.MustCompile(`\s+`).ReplaceAllString(address, "")
parts := strings.Split(address, ",")
addrs := make([]string, 0)
for _, part := range parts {
diff --git a/config_center/apollo/impl_test.go b/config_center/apollo/impl_test.go
index 404457022b42fe921ae0b0a62b968d848af1bb8d..3b2cb168402534c1a8071e644827a0f948282f75 100644
--- a/config_center/apollo/impl_test.go
+++ b/config_center/apollo/impl_test.go
@@ -143,7 +143,7 @@ func serviceConfigResponse(rw http.ResponseWriter, _ *http.Request) {
// run mock config server
func runMockConfigServer(handlerMap map[string]func(http.ResponseWriter, *http.Request),
notifyHandler func(http.ResponseWriter, *http.Request)) *httptest.Server {
- uriHandlerMap := make(map[string]func(http.ResponseWriter, *http.Request), 0)
+ uriHandlerMap := make(map[string]func(http.ResponseWriter, *http.Request))
for namespace, handler := range handlerMap {
uri := fmt.Sprintf("/configs/%s/%s/%s", mockAppId, mockCluster, namespace)
uriHandlerMap[uri] = handler
@@ -227,7 +227,7 @@ func TestListener(t *testing.T) {
apollo.listeners.Range(func(_, value interface{}) bool {
apolloListener := value.(*apolloListener)
for e := range apolloListener.listeners {
- fmt.Println(e)
+ t.Logf("listener:%v", e)
listenerCount++
}
return true
diff --git a/config_center/apollo/listener.go b/config_center/apollo/listener.go
index ace5ed026875d2478e5d81b1974a6c60f856378c..44d325582f3b04871aaadc5b39cbc17ab7a0eeea 100644
--- a/config_center/apollo/listener.go
+++ b/config_center/apollo/listener.go
@@ -36,7 +36,7 @@ type apolloListener struct {
// nolint
func newApolloListener() *apolloListener {
return &apolloListener{
- listeners: make(map[config_center.ConfigurationListener]struct{}, 0),
+ listeners: make(map[config_center.ConfigurationListener]struct{}),
}
}
diff --git a/config_center/nacos/client.go b/config_center/nacos/client.go
index f3942c023d6bc7b7c7afe09863283cbc315fdb1f..1e96b36a4f19b8548d2ffc9818251ebfa96f365b 100644
--- a/config_center/nacos/client.go
+++ b/config_center/nacos/client.go
@@ -18,7 +18,6 @@
package nacos
import (
- "path/filepath"
"strconv"
"strings"
"sync"
@@ -38,9 +37,6 @@ import (
"github.com/apache/dubbo-go/common/logger"
)
-// Nacos Log dir, it can be override when creating client by config_center.log_dir
-var logDir = filepath.Join("logs", "nacos", "log")
-
// NacosClient Nacos client
type NacosClient struct {
name string
@@ -69,7 +65,7 @@ type option func(*options)
type options struct {
nacosName string
- client *NacosClient
+ //client *NacosClient
}
// WithNacosName Set nacos name
diff --git a/config_center/nacos/impl_test.go b/config_center/nacos/impl_test.go
index 710fef09dde625f87d2dcb04488d49a893f627d5..b7bd94bf96bfdafed1591e58f338fa23a0b96a6f 100644
--- a/config_center/nacos/impl_test.go
+++ b/config_center/nacos/impl_test.go
@@ -40,7 +40,7 @@ import (
// run mock config server
func runMockConfigServer(configHandler func(http.ResponseWriter, *http.Request),
configListenHandler func(http.ResponseWriter, *http.Request)) *httptest.Server {
- uriHandlerMap := make(map[string]func(http.ResponseWriter, *http.Request), 0)
+ uriHandlerMap := make(map[string]func(http.ResponseWriter, *http.Request))
uriHandlerMap["/nacos/v1/cs/configs"] = configHandler
uriHandlerMap["/nacos/v1/cs/configs/listener"] = configListenHandler
@@ -102,7 +102,8 @@ func TestNacosDynamicConfiguration_GetConfigKeysByGroup(t *testing.T) {
}
`
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- w.Write([]byte(data))
+ _, err := w.Write([]byte(data))
+ assert.Nil(t, err)
}))
nacosURL := strings.ReplaceAll(ts.URL, "http", "registry")
diff --git a/config_center/zookeeper/impl.go b/config_center/zookeeper/impl.go
index 17812e917f533d28c052c7cda3411de44b9aa7b5..f3b2235025c033cd125c9a87b2c277a5a3d70243 100644
--- a/config_center/zookeeper/impl.go
+++ b/config_center/zookeeper/impl.go
@@ -52,7 +52,7 @@ type zookeeperDynamicConfiguration struct {
done chan struct{}
client *zookeeper.ZookeeperClient
- listenerLock sync.Mutex
+ //listenerLock sync.Mutex
listener *zookeeper.ZkEventListener
cacheListener *CacheListener
parser parser.ConfigurationParser
diff --git a/config_center/zookeeper/impl_test.go b/config_center/zookeeper/impl_test.go
index 808bf8fd573c757dffbcee896140975464fade14..a518bb6ec05d01aa953173c9c98aef69ae31348b 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/filter/filter_impl/active_filter_test.go b/filter/filter_impl/active_filter_test.go
index 9f024fec34521b8445fa1a61295e4b3c0eb85e34..2397503dc8f46381a131bed6f924d465a71a9193 100644
--- a/filter/filter_impl/active_filter_test.go
+++ b/filter/filter_impl/active_filter_test.go
@@ -37,7 +37,7 @@ import (
)
func TestActiveFilterInvoke(t *testing.T) {
- invoc := invocation.NewRPCInvocation("test", []interface{}{"OK"}, make(map[string]interface{}, 0))
+ invoc := invocation.NewRPCInvocation("test", []interface{}{"OK"}, make(map[string]interface{}))
url, _ := common.NewURL("dubbo://192.168.10.10:20000/com.ikurento.user.UserProvider")
filter := ActiveFilter{}
ctrl := gomock.NewController(t)
diff --git a/filter/filter_impl/auth/sign_util.go b/filter/filter_impl/auth/sign_util.go
index 45170bb8117284275a87a3a57d14ce68d6cc4e9c..4c12c762ed6715af551f6e37c251cf095bb43dc4 100644
--- a/filter/filter_impl/auth/sign_util.go
+++ b/filter/filter_impl/auth/sign_util.go
@@ -26,6 +26,10 @@ import (
"strings"
)
+import (
+ "github.com/apache/dubbo-go/common/logger"
+)
+
// Sign gets a signature string with given bytes
func Sign(metadata, key string) string {
return doSign([]byte(metadata), key)
@@ -33,7 +37,7 @@ func Sign(metadata, key string) string {
// SignWithParams returns a signature with giving params and metadata.
func SignWithParams(params []interface{}, metadata, key string) (string, error) {
- if params == nil || len(params) == 0 {
+ if len(params) == 0 {
return Sign(metadata, key), nil
}
@@ -56,7 +60,9 @@ func toBytes(data []interface{}) ([]byte, error) {
func doSign(bytes []byte, key string) string {
mac := hmac.New(sha256.New, []byte(key))
- mac.Write(bytes)
+ if _, err := mac.Write(bytes); err != nil {
+ logger.Error(err)
+ }
signature := mac.Sum(nil)
return base64.URLEncoding.EncodeToString(signature)
}
diff --git a/filter/filter_impl/execute_limit_filter_test.go b/filter/filter_impl/execute_limit_filter_test.go
index 2aebcaa8fa62278da3092d6359d2a01571be37d0..682f8fa8b475348624a33d44d9a08190fe270fa8 100644
--- a/filter/filter_impl/execute_limit_filter_test.go
+++ b/filter/filter_impl/execute_limit_filter_test.go
@@ -36,7 +36,7 @@ import (
func TestExecuteLimitFilterInvokeIgnored(t *testing.T) {
methodName := "hello"
- invoc := invocation.NewRPCInvocation(methodName, []interface{}{"OK"}, make(map[string]interface{}, 0))
+ invoc := invocation.NewRPCInvocation(methodName, []interface{}{"OK"}, make(map[string]interface{}))
invokeUrl := common.NewURLWithOptions(
common.WithParams(url.Values{}),
@@ -51,7 +51,7 @@ func TestExecuteLimitFilterInvokeIgnored(t *testing.T) {
func TestExecuteLimitFilterInvokeConfigureError(t *testing.T) {
methodName := "hello1"
- invoc := invocation.NewRPCInvocation(methodName, []interface{}{"OK"}, make(map[string]interface{}, 0))
+ invoc := invocation.NewRPCInvocation(methodName, []interface{}{"OK"}, make(map[string]interface{}))
invokeUrl := common.NewURLWithOptions(
common.WithParams(url.Values{}),
@@ -68,7 +68,7 @@ func TestExecuteLimitFilterInvokeConfigureError(t *testing.T) {
func TestExecuteLimitFilterInvoke(t *testing.T) {
methodName := "hello1"
- invoc := invocation.NewRPCInvocation(methodName, []interface{}{"OK"}, make(map[string]interface{}, 0))
+ invoc := invocation.NewRPCInvocation(methodName, []interface{}{"OK"}, make(map[string]interface{}))
invokeUrl := common.NewURLWithOptions(
common.WithParams(url.Values{}),
diff --git a/filter/filter_impl/graceful_shutdown_filter_test.go b/filter/filter_impl/graceful_shutdown_filter_test.go
index c2c1ef874d1696217b34b50fbbf66aa8faf7803d..b16956e01c85b52ec0009f96998a72e2a4314911 100644
--- a/filter/filter_impl/graceful_shutdown_filter_test.go
+++ b/filter/filter_impl/graceful_shutdown_filter_test.go
@@ -39,10 +39,8 @@ import (
)
func TestGenericFilterInvoke(t *testing.T) {
- invoc := invocation.NewRPCInvocation("GetUser", []interface{}{"OK"}, make(map[string]interface{}, 0))
-
- invokeUrl := common.NewURLWithOptions(
- common.WithParams(url.Values{}))
+ invoc := invocation.NewRPCInvocation("GetUser", []interface{}{"OK"}, make(map[string]interface{}))
+ invokeUrl := common.NewURLWithOptions(common.WithParams(url.Values{}))
shutdownFilter := extension.GetFilter(constant.PROVIDER_SHUTDOWN_FILTER).(*gracefulShutdownFilter)
diff --git a/filter/filter_impl/seata_filter.go b/filter/filter_impl/seata_filter.go
index 7722d2954f905ece4a1b48628c31c06debf45614..b7b7b0e94b4633dda10278e9674566a82701b7f6 100644
--- a/filter/filter_impl/seata_filter.go
+++ b/filter/filter_impl/seata_filter.go
@@ -23,6 +23,7 @@ import (
)
import (
+ "github.com/apache/dubbo-go/common/constant"
"github.com/apache/dubbo-go/common/extension"
"github.com/apache/dubbo-go/common/logger"
"github.com/apache/dubbo-go/filter"
@@ -30,12 +31,12 @@ import (
)
const (
- SEATA = "seata"
- SEATA_XID = "SEATA_XID"
+ SEATA = constant.DubboCtxKey("seata")
+ SEATA_XID = constant.DubboCtxKey("SEATA_XID")
)
func init() {
- extension.SetFilter(SEATA, getSeataFilter)
+ extension.SetFilter(string(SEATA), getSeataFilter)
}
// SeataFilter when use seata-golang, use this filter to transfer xid
@@ -45,7 +46,7 @@ type SeataFilter struct{}
// Invoke Get Xid by attachment key `SEATA_XID`
func (sf *SeataFilter) Invoke(ctx context.Context, invoker protocol.Invoker, invocation protocol.Invocation) protocol.Result {
logger.Infof("invoking seata filter.")
- xid := invocation.AttachmentsByKey(SEATA_XID, "")
+ xid := invocation.AttachmentsByKey(string(SEATA_XID), "")
if strings.TrimSpace(xid) != "" {
logger.Debugf("Method: %v,Xid: %v", invocation.MethodName(), xid)
return invoker.Invoke(context.WithValue(ctx, SEATA_XID, xid), invocation)
diff --git a/filter/filter_impl/seata_filter_test.go b/filter/filter_impl/seata_filter_test.go
index 45817e95cbd2eaa7365adc8a299523af8310f797..1705eba787f5569064841d6a713ed2f2e428314c 100644
--- a/filter/filter_impl/seata_filter_test.go
+++ b/filter/filter_impl/seata_filter_test.go
@@ -50,7 +50,7 @@ func TestSeataFilter_Invoke(t *testing.T) {
filter := getSeataFilter()
result := filter.Invoke(context.Background(), &testMockSeataInvoker{}, invocation.NewRPCInvocation("$echo",
[]interface{}{"OK"}, map[string]interface{}{
- SEATA_XID: "10.30.21.227:8091:2000047792",
+ string(SEATA_XID): "10.30.21.227:8091:2000047792",
}))
assert.Equal(t, "10.30.21.227:8091:2000047792", result.Result())
}
diff --git a/filter/filter_impl/sentinel_filter.go b/filter/filter_impl/sentinel_filter.go
index b5f8b45876717551cecd3639579a07a825a74d40..f662db35637593f4ab92a2b12e50d5a9e4305730 100644
--- a/filter/filter_impl/sentinel_filter.go
+++ b/filter/filter_impl/sentinel_filter.go
@@ -204,8 +204,8 @@ const (
DefaultProviderPrefix = "dubbo:provider:"
DefaultConsumerPrefix = "dubbo:consumer:"
- MethodEntryKey = "$$sentinelMethodEntry"
- InterfaceEntryKey = "$$sentinelInterfaceEntry"
+ MethodEntryKey = constant.DubboCtxKey("$$sentinelMethodEntry")
+ InterfaceEntryKey = constant.DubboCtxKey("$$sentinelInterfaceEntry")
)
func getResourceName(invoker protocol.Invoker, invocation protocol.Invocation, prefix string) (interfaceResourceName, methodResourceName string) {
diff --git a/filter/filter_impl/token_filter_test.go b/filter/filter_impl/token_filter_test.go
index 9ef8c98d6868c3d545fe963ab13eb3f27bb88cd0..024ae2ae3142b1e193d6a24001f51f00badf537a 100644
--- a/filter/filter_impl/token_filter_test.go
+++ b/filter/filter_impl/token_filter_test.go
@@ -40,7 +40,7 @@ func TestTokenFilterInvoke(t *testing.T) {
url := common.NewURLWithOptions(
common.WithParams(url.Values{}),
common.WithParamsValue(constant.TOKEN_KEY, "ori_key"))
- attch := make(map[string]interface{}, 0)
+ attch := make(map[string]interface{})
attch[constant.TOKEN_KEY] = "ori_key"
result := filter.Invoke(context.Background(),
protocol.NewBaseInvoker(url),
@@ -54,7 +54,7 @@ func TestTokenFilterInvokeEmptyToken(t *testing.T) {
filter := GetTokenFilter()
testUrl := common.URL{}
- attch := make(map[string]interface{}, 0)
+ attch := make(map[string]interface{})
attch[constant.TOKEN_KEY] = "ori_key"
result := filter.Invoke(context.Background(), protocol.NewBaseInvoker(&testUrl), invocation.NewRPCInvocation("MethodName", []interface{}{"OK"}, attch))
assert.Nil(t, result.Error())
@@ -67,7 +67,7 @@ func TestTokenFilterInvokeEmptyAttach(t *testing.T) {
testUrl := common.NewURLWithOptions(
common.WithParams(url.Values{}),
common.WithParamsValue(constant.TOKEN_KEY, "ori_key"))
- attch := make(map[string]interface{}, 0)
+ attch := make(map[string]interface{})
result := filter.Invoke(context.Background(), protocol.NewBaseInvoker(testUrl), invocation.NewRPCInvocation("MethodName", []interface{}{"OK"}, attch))
assert.NotNil(t, result.Error())
}
@@ -78,7 +78,7 @@ func TestTokenFilterInvokeNotEqual(t *testing.T) {
testUrl := common.NewURLWithOptions(
common.WithParams(url.Values{}),
common.WithParamsValue(constant.TOKEN_KEY, "ori_key"))
- attch := make(map[string]interface{}, 0)
+ attch := make(map[string]interface{})
attch[constant.TOKEN_KEY] = "err_key"
result := filter.Invoke(context.Background(),
protocol.NewBaseInvoker(testUrl), invocation.NewRPCInvocation("MethodName", []interface{}{"OK"}, attch))
diff --git a/filter/filter_impl/tps/tps_limiter_method_service_test.go b/filter/filter_impl/tps/tps_limiter_method_service_test.go
index 7435d9b92ac8270de0244c8a257aec82f9acc9a1..4ff0a232e47e76a46db64812cf26f3d09b063b03 100644
--- a/filter/filter_impl/tps/tps_limiter_method_service_test.go
+++ b/filter/filter_impl/tps/tps_limiter_method_service_test.go
@@ -36,7 +36,7 @@ import (
func TestMethodServiceTpsLimiterImplIsAllowableOnlyServiceLevel(t *testing.T) {
methodName := "hello"
- invoc := invocation.NewRPCInvocation(methodName, []interface{}{"OK"}, make(map[string]interface{}, 0))
+ invoc := invocation.NewRPCInvocation(methodName, []interface{}{"OK"}, make(map[string]interface{}))
ctrl := gomock.NewController(t)
defer ctrl.Finish()
@@ -63,7 +63,7 @@ func TestMethodServiceTpsLimiterImplIsAllowableOnlyServiceLevel(t *testing.T) {
func TestMethodServiceTpsLimiterImplIsAllowableNoConfig(t *testing.T) {
methodName := "hello1"
- invoc := invocation.NewRPCInvocation(methodName, []interface{}{"OK"}, make(map[string]interface{}, 0))
+ invoc := invocation.NewRPCInvocation(methodName, []interface{}{"OK"}, make(map[string]interface{}))
// ctrl := gomock.NewController(t)
// defer ctrl.Finish()
@@ -80,7 +80,7 @@ func TestMethodServiceTpsLimiterImplIsAllowableNoConfig(t *testing.T) {
func TestMethodServiceTpsLimiterImplIsAllowableMethodLevelOverride(t *testing.T) {
methodName := "hello2"
methodConfigPrefix := "methods." + methodName + "."
- invoc := invocation.NewRPCInvocation(methodName, []interface{}{"OK"}, make(map[string]interface{}, 0))
+ invoc := invocation.NewRPCInvocation(methodName, []interface{}{"OK"}, make(map[string]interface{}))
ctrl := gomock.NewController(t)
defer ctrl.Finish()
@@ -113,7 +113,7 @@ func TestMethodServiceTpsLimiterImplIsAllowableMethodLevelOverride(t *testing.T)
func TestMethodServiceTpsLimiterImplIsAllowableBothMethodAndService(t *testing.T) {
methodName := "hello3"
methodConfigPrefix := "methods." + methodName + "."
- invoc := invocation.NewRPCInvocation(methodName, []interface{}{"OK"}, make(map[string]interface{}, 0))
+ invoc := invocation.NewRPCInvocation(methodName, []interface{}{"OK"}, make(map[string]interface{}))
ctrl := gomock.NewController(t)
defer ctrl.Finish()
diff --git a/filter/filter_impl/tps_limit_filter_test.go b/filter/filter_impl/tps_limit_filter_test.go
index 88e778105081129463b68618804bd9204d2f7113..55a3a55fab28efc7c27d9f5ccc4a3ec454bb6d15 100644
--- a/filter/filter_impl/tps_limit_filter_test.go
+++ b/filter/filter_impl/tps_limit_filter_test.go
@@ -44,7 +44,7 @@ func TestTpsLimitFilterInvokeWithNoTpsLimiter(t *testing.T) {
invokeUrl := common.NewURLWithOptions(
common.WithParams(url.Values{}),
common.WithParamsValue(constant.TPS_LIMITER_KEY, ""))
- attch := make(map[string]interface{}, 0)
+ attch := make(map[string]interface{})
result := tpsFilter.Invoke(context.Background(),
protocol.NewBaseInvoker(invokeUrl),
@@ -68,7 +68,7 @@ func TestGenericFilterInvokeWithDefaultTpsLimiter(t *testing.T) {
invokeUrl := common.NewURLWithOptions(
common.WithParams(url.Values{}),
common.WithParamsValue(constant.TPS_LIMITER_KEY, constant.DEFAULT_KEY))
- attch := make(map[string]interface{}, 0)
+ attch := make(map[string]interface{})
result := tpsFilter.Invoke(context.Background(),
protocol.NewBaseInvoker(invokeUrl),
@@ -99,7 +99,7 @@ func TestGenericFilterInvokeWithDefaultTpsLimiterNotAllow(t *testing.T) {
invokeUrl := common.NewURLWithOptions(
common.WithParams(url.Values{}),
common.WithParamsValue(constant.TPS_LIMITER_KEY, constant.DEFAULT_KEY))
- attch := make(map[string]interface{}, 0)
+ attch := make(map[string]interface{})
result := tpsFilter.Invoke(context.Background(),
protocol.NewBaseInvoker(
diff --git a/filter/filter_impl/tracing_filter_test.go b/filter/filter_impl/tracing_filter_test.go
index e159b7400d46069018a00a849319423285072dc2..bf96a7d064b3919825d26c505b637f5ea539d9d6 100644
--- a/filter/filter_impl/tracing_filter_test.go
+++ b/filter/filter_impl/tracing_filter_test.go
@@ -57,6 +57,6 @@ func TestTracingFilterInvoke(t *testing.T) {
tf.Invoke(ctx, invoker, inv)
// has remote ctx
- ctx = context.WithValue(context.Background(), constant.TRACING_REMOTE_SPAN_CTX, span.Context())
+ ctx = context.WithValue(context.Background(), constant.DubboCtxKey(constant.TRACING_REMOTE_SPAN_CTX), span.Context())
tf.Invoke(ctx, invoker, inv)
}
diff --git a/metadata/mapping/dynamic/service_name_mapping_test.go b/metadata/mapping/dynamic/service_name_mapping_test.go
index 2896b0fd4aa4fb6bada132c276c70a1653e59f99..af21704b69c674a2cd1b8963bb252ac73c0abf1e 100644
--- a/metadata/mapping/dynamic/service_name_mapping_test.go
+++ b/metadata/mapping/dynamic/service_name_mapping_test.go
@@ -39,6 +39,7 @@ func TestDynamicConfigurationServiceNameMapping(t *testing.T) {
dc, err := (&config_center.MockDynamicConfigurationFactory{
Content: appName,
}).GetDynamicConfiguration(nil)
+ assert.NoError(t, err)
config.GetApplicationConfig().Name = appName
mapping := &DynamicConfigurationServiceNameMapping{dc: dc}
diff --git a/metadata/report/consul/report_test.go b/metadata/report/consul/report_test.go
index 13d0c419bc0f0ff8426f73d4de5c85a346416770..51e93179a21851f4a81039180ecdff7519ae36fe 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 836a8f9ef4aac23558e44c1c9c5adedd585d6da4..f364087fdc8c2fb2a595190d7ca0d9564ac5d171 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/delegate/delegate_report_test.go b/metadata/report/delegate/delegate_report_test.go
index 9c30ed9ffdb8424be38d273fd0a78f3351d6e0d5..f60acf6e117c866cba716c538806f278d77363f0 100644
--- a/metadata/report/delegate/delegate_report_test.go
+++ b/metadata/report/delegate/delegate_report_test.go
@@ -46,13 +46,10 @@ func TestMetadataReport_MetadataReportRetry(t *testing.T) {
})
assert.NoError(t, err)
retry.startRetryTask()
- itsTime := time.After(2500 * time.Millisecond)
- select {
- case <-itsTime:
- retry.scheduler.Clear()
- assert.Equal(t, counter.Load(), int64(3))
- logger.Info("over")
- }
+ <-time.After(2500 * time.Millisecond)
+ retry.scheduler.Clear()
+ assert.Equal(t, counter.Load(), int64(3))
+ logger.Info("over")
}
func TestMetadataReport_MetadataReportRetryWithLimit(t *testing.T) {
@@ -64,13 +61,10 @@ func TestMetadataReport_MetadataReportRetryWithLimit(t *testing.T) {
})
assert.NoError(t, err)
retry.startRetryTask()
- itsTime := time.After(2500 * time.Millisecond)
- select {
- case <-itsTime:
- retry.scheduler.Clear()
- assert.Equal(t, counter.Load(), int64(2))
- logger.Info("over")
- }
+ <-time.After(2500 * time.Millisecond)
+ retry.scheduler.Clear()
+ assert.Equal(t, counter.Load(), int64(2))
+ logger.Info("over")
}
func mockNewMetadataReport(t *testing.T) *MetadataReport {
diff --git a/metadata/report/etcd/report_test.go b/metadata/report/etcd/report_test.go
index 28c04869822b166f99d98e91ec6ec3b7fe6626cc..59d0975ca675ef9550d3b2669a24ebd70ce94ec0 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/report/zookeeper/report_test.go b/metadata/report/zookeeper/report_test.go
index adedaaa6f4bd71511385085118f55538a5deb091..3f927b1af7ae30ac3dc4af3743e38dba00bb0ae9 100644
--- a/metadata/report/zookeeper/report_test.go
+++ b/metadata/report/zookeeper/report_test.go
@@ -144,7 +144,10 @@ func (suite *zookeeperMetadataReportTestSuite) testGetServiceDefinition() {
func test1(t *testing.T) {
testCluster, err := zk.StartTestCluster(1, nil, nil)
assert.NoError(t, err)
- defer testCluster.Stop()
+ defer func() {
+ err := testCluster.Stop()
+ assert.Nil(t, err)
+ }()
url := newProviderRegistryUrl("127.0.0.1", testCluster.Servers[0].Port)
mf := extension.GetMetadataReportFactory("zookeeper")
diff --git a/metadata/service/inmemory/service_proxy.go b/metadata/service/inmemory/service_proxy.go
index 7e14293a6766492c1c1b02eef9429d1adeb539ae..8b93aab9accfd8375ded971c27f898069e73e231 100644
--- a/metadata/service/inmemory/service_proxy.go
+++ b/metadata/service/inmemory/service_proxy.go
@@ -39,8 +39,8 @@ import (
// this is the stub, or proxy
// for now, only GetExportedURLs need to be implemented
type MetadataServiceProxy struct {
- invkr protocol.Invoker
- golangServer bool
+ invkr protocol.Invoker
+ //golangServer bool
}
func (m *MetadataServiceProxy) GetExportedURLs(serviceInterface string, group string, version string, protocol string) ([]interface{}, error) {
@@ -67,11 +67,7 @@ func (m *MetadataServiceProxy) GetExportedURLs(serviceInterface string, group st
urlStrs := res.Result().(*[]interface{})
ret := make([]interface{}, 0, len(*urlStrs))
-
- for _, s := range *urlStrs {
- ret = append(ret, s)
- }
- return ret, nil
+ return append(ret, *urlStrs...), nil
}
func (m *MetadataServiceProxy) MethodMapper() map[string]string {
diff --git a/metadata/service/inmemory/service_proxy_test.go b/metadata/service/inmemory/service_proxy_test.go
index f7fc8fd88e5f31804253dc996cb99b241a519d14..9278fd9d6cf1b4657d35028aa8c244fdbc16d106 100644
--- a/metadata/service/inmemory/service_proxy_test.go
+++ b/metadata/service/inmemory/service_proxy_test.go
@@ -48,19 +48,33 @@ func TestMetadataServiceProxy_GetExportedURLs(t *testing.T) {
// when we implement them, adding UT
func TestNewMetadataService(t *testing.T) {
pxy := createPxy()
- pxy.ServiceName()
- pxy.PublishServiceDefinition(&common.URL{})
- pxy.GetServiceDefinition(constant.ANY_VALUE, constant.ANY_VALUE, constant.ANY_VALUE)
- 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.RefreshMetadata(constant.ANY_VALUE, constant.ANY_VALUE)
-
+ _, err := pxy.ServiceName()
+ assert.Nil(t, err)
+ err = pxy.PublishServiceDefinition(&common.URL{})
+ assert.Nil(t, err)
+ _, err = pxy.GetServiceDefinition(constant.ANY_VALUE, constant.ANY_VALUE, constant.ANY_VALUE)
+ assert.Nil(t, err)
+ _, err = pxy.Version()
+ assert.Nil(t, err)
+ _, err = pxy.GetSubscribedURLs()
+ assert.Nil(t, err)
+ err = pxy.UnsubscribeURL(&common.URL{})
+ assert.Nil(t, err)
+ _, err = pxy.GetServiceDefinitionByServiceKey("any")
+ assert.Nil(t, err)
+ 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 256412c2917d39c0ff15db11121718ba983cd7ab..e50cd6208a4d86f8238cc68538493c309870c455 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.go b/metadata/service/remote/service.go
index ae1c344d27a0c5be08739ab05f0c909bcc2b8fdb..d21cc88a3d31ec2920a78c608ed13a491fd6c634 100644
--- a/metadata/service/remote/service.go
+++ b/metadata/service/remote/service.go
@@ -188,7 +188,7 @@ func (mts *MetadataService) RefreshMetadata(exportedRevision string, subscribedR
logger.Errorf("Error occur when execute remote.MetadataService.RefreshMetadata, error message is %v+", err)
return false, err
}
- if urls != nil && len(urls) > 0 {
+ if len(urls) > 0 {
id := &identifier.SubscriberMetadataIdentifier{
MetadataIdentifier: identifier.MetadataIdentifier{
Application: config.GetApplicationConfig().Name,
diff --git a/metadata/service/remote/service_proxy.go b/metadata/service/remote/service_proxy.go
index 3199aa6dfff6f5e8b6036c44f452d16480b0380c..d0caa182b2efdc709af11e4bc40f807e89276a56 100644
--- a/metadata/service/remote/service_proxy.go
+++ b/metadata/service/remote/service_proxy.go
@@ -146,7 +146,7 @@ func newMetadataServiceProxy(ins registry.ServiceInstance) service.MetadataServi
}
func parse(key string) []string {
- arr := make([]string, 3, 3)
+ arr := make([]string, 3)
tmp := strings.SplitN(key, "/", 2)
if len(tmp) > 1 {
arr[0] = tmp[0]
diff --git a/metadata/service/remote/service_proxy_test.go b/metadata/service/remote/service_proxy_test.go
index 8bccbb8bbb70d1533fa3dad78bab59e82ff2e5b3..1899d02205e17f62637488e68630649e60cff061 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/metadata/service/remote/service_test.go b/metadata/service/remote/service_test.go
index 71586cc1dcc87dc8644a25c9a89842bd84fe9f0a..d6028152ccb275238491accc055e67d0b903bc55 100644
--- a/metadata/service/remote/service_test.go
+++ b/metadata/service/remote/service_test.go
@@ -95,7 +95,7 @@ func (metadataReport) GetServiceDefinition(*identifier.MetadataIdentifier) (stri
func TestMetadataService(t *testing.T) {
extension.SetMetadataReportFactory("mock", getMetadataReportFactory)
- u, err := common.NewURL(fmt.Sprintf("mock://127.0.0.1:20000/?sync.report=true"))
+ u, err := common.NewURL("mock://127.0.0.1:20000/?sync.report=true")
assert.NoError(t, err)
instance.GetMetadataReportInstance(u)
mts, err := newMetadataService()
diff --git a/protocol/dubbo/dubbo_codec.go b/protocol/dubbo/dubbo_codec.go
index ccecbee2e2b04083cbda3118978da0f7450b4d3f..f92da4aa7f164fce131f9f869f9550b6e7168943 100644
--- a/protocol/dubbo/dubbo_codec.go
+++ b/protocol/dubbo/dubbo_codec.go
@@ -177,10 +177,7 @@ func (c *DubboCodec) Decode(data []byte) (remoting.DecodeResult, int, error) {
}
func (c *DubboCodec) isRequest(data []byte) bool {
- if data[2]&byte(0x80) == 0x00 {
- return false
- }
- return true
+ return data[2]&byte(0x80) != 0x00
}
// decode request
diff --git a/protocol/dubbo/dubbo_invoker_test.go b/protocol/dubbo/dubbo_invoker_test.go
index c7a9a2697529d096e57585347b0a8b0a535451b0..fecb3b01ab286d4900cba4628cb80ea6d9920a9a 100644
--- a/protocol/dubbo/dubbo_invoker_test.go
+++ b/protocol/dubbo/dubbo_invoker_test.go
@@ -169,7 +169,7 @@ type (
}
UserProvider struct {
- user map[string]User
+ //user map[string]User
}
)
diff --git a/protocol/dubbo/dubbo_protocol.go b/protocol/dubbo/dubbo_protocol.go
index 4f03b8aba061ea9b37b35d89142eb7bec80f3a97..1f7cd50187d14252ec7e4b2f5c78e8b5bd9228e2 100644
--- a/protocol/dubbo/dubbo_protocol.go
+++ b/protocol/dubbo/dubbo_protocol.go
@@ -222,13 +222,13 @@ func getExchangeClient(url *common.URL) *remoting.ExchangeClient {
// Once we decided to transfer more context's key-value, we should change this.
// now we only support rebuild the tracing context
func rebuildCtx(inv *invocation.RPCInvocation) context.Context {
- ctx := context.WithValue(context.Background(), "attachment", inv.Attachments())
+ ctx := context.WithValue(context.Background(), constant.DubboCtxKey("attachment"), inv.Attachments())
// actually, if user do not use any opentracing framework, the err will not be nil.
spanCtx, err := opentracing.GlobalTracer().Extract(opentracing.TextMap,
opentracing.TextMapCarrier(filterContext(inv.Attachments())))
if err == nil {
- ctx = context.WithValue(ctx, constant.TRACING_REMOTE_SPAN_CTX, spanCtx)
+ ctx = context.WithValue(ctx, constant.DubboCtxKey(constant.TRACING_REMOTE_SPAN_CTX), spanCtx)
}
return ctx
}
diff --git a/protocol/dubbo/hessian2/const.go b/protocol/dubbo/hessian2/const.go
index 74a00b601db22397916aab215ccd33bc918d91e7..0c95390fbfff152a926ca2d1ff09682a4cb893ae 100644
--- a/protocol/dubbo/hessian2/const.go
+++ b/protocol/dubbo/hessian2/const.go
@@ -28,11 +28,6 @@ import (
perrors "github.com/pkg/errors"
)
-const (
- mask = byte(127)
- flag = byte(128)
-)
-
const (
// Zero : byte zero
Zero = byte(0x00)
@@ -84,10 +79,6 @@ const (
BC_LIST_FIXED = byte('V')
BC_LIST_VARIABLE_UNTYPED = byte(0x57)
BC_LIST_FIXED_UNTYPED = byte(0x58)
- _listFixedTypedLenTagMin = byte(0x70)
- _listFixedTypedLenTagMax = byte(0x77)
- _listFixedUntypedLenTagMin = byte(0x78)
- _listFixedUntypedLenTagMax = byte(0x7f)
BC_LIST_DIRECT = byte(0x70)
BC_LIST_DIRECT_UNTYPED = byte(0x78)
diff --git a/protocol/dubbo/hessian2/hessian_request.go b/protocol/dubbo/hessian2/hessian_request.go
index 4ebb4aa1be05d4d1941661fed452dda06cf55fa0..efcbd95d293fa84e8dfd6eddd9fdc14f05c3e6a2 100644
--- a/protocol/dubbo/hessian2/hessian_request.go
+++ b/protocol/dubbo/hessian2/hessian_request.go
@@ -30,6 +30,10 @@ import (
perrors "github.com/pkg/errors"
)
+import (
+ "github.com/apache/dubbo-go/common/logger"
+)
+
/////////////////////////////////////////
// dubbo
/////////////////////////////////////////
@@ -39,7 +43,7 @@ func getArgType(v interface{}) string {
return "V"
}
- switch v.(type) {
+ switch v := v.(type) {
// Serialized tags for base types
case nil:
return "V"
@@ -216,23 +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
- encoder.Encode(DEFAULT_DUBBO_PROTOCOL_VERSION)
- encoder.Encode(service.Path)
- encoder.Encode(service.Version)
- encoder.Encode(service.Method)
+ if err := encoder.Encode(DEFAULT_DUBBO_PROTOCOL_VERSION); err != nil {
+ logger.Warnf("Encode(DEFAULT_DUBBO_PROTOCOL_VERSION) = error: %v", err)
+ }
+ if err := encoder.Encode(service.Path); err != nil {
+ logger.Warnf("Encode(service.Path) = error: %v", err)
+ }
+ if err := encoder.Encode(service.Version); err != nil {
+ logger.Warnf("Encode(service.Version) = error: %v", err)
+ }
+ if err := encoder.Encode(service.Method); err != nil {
+ 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
@@ -247,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 982960ed87e74b325687ac364c97a347efe6c38f..b95e1c2711e8922b280260035eaba1cc03f50aa4 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/const.go b/protocol/dubbo/impl/const.go
index 70d8bae6cad63d436f5d9f1ef69c397ee8a052f3..492a87a194eeb9ef673f1c83a499872cfb9724cb 100644
--- a/protocol/dubbo/impl/const.go
+++ b/protocol/dubbo/impl/const.go
@@ -28,11 +28,6 @@ const (
DUBBO = "dubbo"
)
-const (
- mask = byte(127)
- flag = byte(128)
-)
-
const (
// Zero : byte zero
Zero = byte(0x00)
@@ -84,10 +79,6 @@ const (
BC_LIST_FIXED = byte('V')
BC_LIST_VARIABLE_UNTYPED = byte(0x57)
BC_LIST_FIXED_UNTYPED = byte(0x58)
- _listFixedTypedLenTagMin = byte(0x70)
- _listFixedTypedLenTagMax = byte(0x77)
- _listFixedUntypedLenTagMin = byte(0x78)
- _listFixedUntypedLenTagMax = byte(0x7f)
BC_LIST_DIRECT = byte(0x70)
BC_LIST_DIRECT_UNTYPED = byte(0x78)
diff --git a/protocol/dubbo/impl/hessian.go b/protocol/dubbo/impl/hessian.go
index 5fa1f2ece337e268c4907465bdc69ced76641ce7..e355276c37f9d1babc12f7e3b694ec7a193aed80 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)
@@ -418,7 +417,7 @@ func getArgType(v interface{}) string {
return "V"
}
- switch v.(type) {
+ switch v := v.(type) {
// Serialized tags for base types
case nil:
return "V"
diff --git a/protocol/dubbo/opentracing.go b/protocol/dubbo/opentracing.go
index 2dcd6a4d0d9f491ba6d51ea7a3ba96812a6f9e08..f45e6fdc71af6279c2fadadd0576cde629a535e1 100644
--- a/protocol/dubbo/opentracing.go
+++ b/protocol/dubbo/opentracing.go
@@ -35,14 +35,6 @@ func injectTraceCtx(currentSpan opentracing.Span, inv *invocation_impl.RPCInvoca
return err
}
-func extractTraceCtx(inv *invocation_impl.RPCInvocation) (opentracing.SpanContext, error) {
- traceAttachments := filterContext(inv.Attachments())
- // actually, if user do not use any opentracing framework, the err will not be nil.
- spanCtx, err := opentracing.GlobalTracer().Extract(opentracing.TextMap,
- opentracing.TextMapCarrier(traceAttachments))
- return spanCtx, err
-}
-
func filterContext(attachments map[string]interface{}) map[string]string {
var traceAttchment = make(map[string]string)
for k, v := range attachments {
diff --git a/protocol/grpc/grpc_invoker.go b/protocol/grpc/grpc_invoker.go
index 02e7716115e6bb22f3de5a8c4d8a2131995e81c6..9647ecb9c9498c78d9df49a2223a905fda8c5c6e 100644
--- a/protocol/grpc/grpc_invoker.go
+++ b/protocol/grpc/grpc_invoker.go
@@ -63,7 +63,7 @@ func (gi *GrpcInvoker) Invoke(ctx context.Context, invocation protocol.Invocatio
}
var in []reflect.Value
- in = append(in, reflect.ValueOf(context.Background()))
+ in = append(in, reflect.ValueOf(ctx))
in = append(in, invocation.ParameterValues()...)
methodName := invocation.MethodName()
diff --git a/protocol/grpc/protoc-gen-dubbo/plugin/dubbo/dubbo.go b/protocol/grpc/protoc-gen-dubbo/plugin/dubbo/dubbo.go
index a9f50e82879e1d6448300ec7b2a92e2a68070dc8..ba84f36b74016f1495fa7d616315deda7c54bbcc 100644
--- a/protocol/grpc/protoc-gen-dubbo/plugin/dubbo/dubbo.go
+++ b/protocol/grpc/protoc-gen-dubbo/plugin/dubbo/dubbo.go
@@ -28,19 +28,11 @@ import (
"github.com/golang/protobuf/protoc-gen-go/generator"
)
-// generatedCodeVersion indicates a version of the generated code.
-// It is incremented whenever an incompatibility between the generated code and
-// the grpc package is introduced; the generated code references
-// a constant, grpc.SupportPackageIsVersionN (where N is generatedCodeVersion).
-const generatedCodeVersion = 4
-
// Paths for packages used by code generated in this file,
// relative to the import_prefix of the generator.Generator.
const (
contextPkgPath = "context"
grpcPkgPath = "google.golang.org/grpc"
- codePkgPath = "google.golang.org/grpc/codes"
- statusPkgPath = "google.golang.org/grpc/status"
)
func init() {
@@ -262,8 +254,8 @@ func (g *dubboGrpc) generateClientSignature(servName string, method *pb.MethodDe
return fmt.Sprintf("%s func(ctx %s.Context%s, %s) error", methName, contextPkg, reqArg, respName)
}
-func (g *dubboGrpc) generateClientMethod(servName, fullServName, serviceDescVar string, method *pb.MethodDescriptorProto, descExpr string) {
-}
+//func (g *dubboGrpc) generateClientMethod(servName, fullServName, serviceDescVar string, method *pb.MethodDescriptorProto, descExpr string) {
+//}
func (g *dubboGrpc) generateServerMethod(servName, fullServName string, method *pb.MethodDescriptorProto) string {
methName := generator.CamelCase(method.GetName())
@@ -281,7 +273,7 @@ func (g *dubboGrpc) generateServerMethod(servName, fullServName string, method *
g.P(`invo := invocation.NewRPCInvocation("`, methName, `", args, nil)`)
g.P("if interceptor == nil {")
- g.P("result := base.GetProxyImpl().Invoke(context.Background(), invo)")
+ g.P("result := base.GetProxyImpl().Invoke(ctx, invo)")
g.P("return result.Result(), result.Error()")
g.P("}")
@@ -291,7 +283,7 @@ func (g *dubboGrpc) generateServerMethod(servName, fullServName string, method *
g.P("}")
g.P("handler := func(ctx ", contextPkg, ".Context, req interface{}) (interface{}, error) {")
- g.P("result := base.GetProxyImpl().Invoke(context.Background(), invo)")
+ g.P("result := base.GetProxyImpl().Invoke(ctx, invo)")
g.P("return result.Result(), result.Error()")
g.P("}")
diff --git a/protocol/jsonrpc/http.go b/protocol/jsonrpc/http.go
index 869617ea4eb512df6287d21e9d811145c1944e57..037744cf09c4aa229fd7d5f0a7444fd86e70f06f 100644
--- a/protocol/jsonrpc/http.go
+++ b/protocol/jsonrpc/http.go
@@ -49,14 +49,14 @@ import (
// Request is HTTP protocol request
type Request struct {
- ID int64
- group string
- protocol string
- version string
- service string
- method string
- args interface{}
- contentType string
+ ID int64
+ group string
+ protocol string
+ version string
+ service string
+ method string
+ args interface{}
+ //contentType string
}
// ////////////////////////////////////////////
@@ -181,15 +181,17 @@ func (c *HTTPClient) Do(addr, path string, httpHeader http.Header, body []byte)
return nil, perrors.WithStack(err)
}
defer tcpConn.Close()
- setNetConnTimeout := func(conn net.Conn, timeout time.Duration) {
+ setNetConnTimeout := func(conn net.Conn, timeout time.Duration) error {
t := time.Time{}
if timeout > time.Duration(0) {
t = time.Now().Add(timeout)
}
- conn.SetDeadline(t)
+ return conn.SetDeadline(t)
+ }
+ if err := setNetConnTimeout(tcpConn, c.options.HTTPTimeout); err != nil {
+ return nil, err
}
- setNetConnTimeout(tcpConn, c.options.HTTPTimeout)
if _, err = reqBuf.WriteTo(tcpConn); err != nil {
return nil, perrors.WithStack(err)
diff --git a/protocol/jsonrpc/http_test.go b/protocol/jsonrpc/http_test.go
index c4801c8db883353c82762162a7b658f964fc6ffa..5ef40649b1fcb209f29d9bbe871e47b1fcda8a59 100644
--- a/protocol/jsonrpc/http_test.go
+++ b/protocol/jsonrpc/http_test.go
@@ -44,7 +44,7 @@ type (
}
UserProvider struct {
- user map[string]User
+ //user map[string]User
}
)
diff --git a/protocol/jsonrpc/json.go b/protocol/jsonrpc/json.go
index 506c4c953b1b1113b43669171efdeeaeb6fca10d..57d36d2eadd761aa359d55c350772745f1cde819 100644
--- a/protocol/jsonrpc/json.go
+++ b/protocol/jsonrpc/json.go
@@ -53,8 +53,6 @@ const (
CodeMethodNotFound = -32601
CodeInvalidParams = -32602
CodeInternalError = -32603
- codeServerErrorStart = -32099
- codeServerErrorEnd = -32000
)
// Error response Error
diff --git a/protocol/jsonrpc/server.go b/protocol/jsonrpc/server.go
index 755aa7da79384842d5a3f3c4364fc991d84b47df..76901bff6e62748e103d8691f75aedcf68dd202a 100644
--- a/protocol/jsonrpc/server.go
+++ b/protocol/jsonrpc/server.go
@@ -92,7 +92,9 @@ func (s *Server) handlePkg(conn net.Conn) {
t = time.Now().Add(timeout)
}
- conn.SetDeadline(t)
+ if err := conn.SetDeadline(t); err != nil {
+ logger.Error("connection.SetDeadline(t:%v) = error:%v", t, err)
+ }
}
sendErrorResp := func(header http.Header, body []byte) error {
@@ -239,7 +241,9 @@ func (s *Server) Start(url *common.URL) {
s.wg.Add(1)
go func() {
- accept(listener, func(conn net.Conn) { s.handlePkg(conn) })
+ if err := accept(listener, func(conn net.Conn) { s.handlePkg(conn) }); err != nil {
+ logger.Error("accept() = error:%v", err)
+ }
s.wg.Done()
}()
diff --git a/protocol/protocolwrapper/mock_protocol_filter.go b/protocol/protocolwrapper/mock_protocol_filter.go
index 18a4e1562107939e9c72090778422e0d8bb56a60..d1baba813416ff688c5f9ccccf05e276c55c2bba 100644
--- a/protocol/protocolwrapper/mock_protocol_filter.go
+++ b/protocol/protocolwrapper/mock_protocol_filter.go
@@ -45,5 +45,4 @@ func (pfw *mockProtocolFilter) Refer(url *common.URL) protocol.Invoker {
// Destroy will do nothing
func (pfw *mockProtocolFilter) Destroy() {
- return
}
diff --git a/registry/base_configuration_listener.go b/registry/base_configuration_listener.go
index 3b36510306680486ba9d269472450df8867b61b1..31e859eec279f08f4fd286bf021414bdb297a333 100644
--- a/registry/base_configuration_listener.go
+++ b/registry/base_configuration_listener.go
@@ -20,6 +20,7 @@ package registry
import (
perrors "github.com/pkg/errors"
)
+
import (
"github.com/apache/dubbo-go/common"
"github.com/apache/dubbo-go/common/config"
@@ -42,7 +43,9 @@ func (bcl *BaseConfigurationListener) Configurators() []config_center.Configurat
}
// InitWith will init BaseConfigurationListener by @key+@Listener+@f
-func (bcl *BaseConfigurationListener) InitWith(key string, listener config_center.ConfigurationListener, f func(url *common.URL) config_center.Configurator) {
+func (bcl *BaseConfigurationListener) InitWith(key string, listener config_center.ConfigurationListener,
+ f func(url *common.URL) config_center.Configurator) {
+
bcl.dynamicConfiguration = config.GetEnvInstance().GetDynamicConfiguration()
if bcl.dynamicConfiguration == nil {
//set configurators to empty
@@ -51,12 +54,15 @@ func (bcl *BaseConfigurationListener) InitWith(key string, listener config_cente
}
bcl.defaultConfiguratorFunc = f
bcl.dynamicConfiguration.AddListener(key, listener)
- if rawConfig, err := bcl.dynamicConfiguration.GetInternalProperty(key, config_center.WithGroup(constant.DUBBO)); err != nil {
+ if rawConfig, err := bcl.dynamicConfiguration.GetInternalProperty(key,
+ config_center.WithGroup(constant.DUBBO)); err != nil {
//set configurators to empty
bcl.configurators = []config_center.Configurator{}
return
} else if len(rawConfig) > 0 {
- bcl.genConfiguratorFromRawRule(rawConfig)
+ if err := bcl.genConfiguratorFromRawRule(rawConfig); err != nil {
+ logger.Error("bcl.genConfiguratorFromRawRule(rawConfig:%v) = error:%v", rawConfig, err)
+ }
}
}
diff --git a/registry/base_registry.go b/registry/base_registry.go
index ee0d340387a0d270d8254f5038db312977f1f001..e97cc1a4ed6c85fa464d3398b4706e99f7a7f535 100644
--- a/registry/base_registry.go
+++ b/registry/base_registry.go
@@ -18,7 +18,6 @@
package registry
import (
- "context"
"fmt"
"net/url"
"os"
@@ -93,7 +92,7 @@ type FacadeBasedRegistry interface {
// BaseRegistry is a common logic abstract for registry. It implement Registry interface.
type BaseRegistry struct {
- context context.Context
+ //context context.Context
facadeBasedRegistry FacadeBasedRegistry
*common.URL
birth int64 // time of file birth, seconds since Epoch; 0 if unknown
diff --git a/registry/consul/service_discovery.go b/registry/consul/service_discovery.go
index a64fabb1b9edc9cd196c4d25f6659c499bca064b..6674909b15afc225515ff080fb341da65c17a05f 100644
--- a/registry/consul/service_discovery.go
+++ b/registry/consul/service_discovery.go
@@ -252,7 +252,7 @@ func (csd *consulServiceDiscovery) GetServices() *gxset.HashSet {
return res
}
- for service, _ := range services {
+ for service := range services {
res.Add(service)
}
return res
diff --git a/registry/consul/service_discovery_test.go b/registry/consul/service_discovery_test.go
index 2169857ee8f79a92322234a0b17a4d7122a0d975..3f97d841d56111746f396ba753142324ac4555d2 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)}
@@ -138,7 +141,8 @@ func TestConsulServiceDiscovery_CRUD(t *testing.T) {
assert.Equal(t, 1, len(page.GetData()))
instanceResult = page.GetData()[0].(*registry.DefaultServiceInstance)
- v, _ := instanceResult.Metadata["aaa"]
+ v, ok := instanceResult.Metadata["aaa"]
+ assert.True(t, ok)
assert.Equal(t, "bbb", v)
// test dispatcher event
diff --git a/registry/consul/utils_test.go b/registry/consul/utils_test.go
index d78c534e931f9aa3e0220bb08aa29222220ce619..b7e2929cec13c839a8ebaa9cb8a3000ab2cafef3 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/directory/directory.go b/registry/directory/directory.go
index 7b78e618fed35920282b419554f3ed81c44694db..a392b3a042e0b10668e90a54182fab349297c553 100644
--- a/registry/directory/directory.go
+++ b/registry/directory/directory.go
@@ -26,7 +26,6 @@ import (
import (
perrors "github.com/pkg/errors"
- "go.uber.org/atomic"
)
import (
@@ -64,9 +63,9 @@ type RegistryDirectory struct {
configurators []config_center.Configurator
consumerConfigurationListener *consumerConfigurationListener
referenceConfigurationListener *referenceConfigurationListener
- serviceKey string
- forbidden atomic.Bool
- registerLock sync.Mutex // this lock if for register
+ //serviceKey string
+ //forbidden atomic.Bool
+ registerLock sync.Mutex // this lock if for register
}
// NewRegistryDirectory will create a new RegistryDirectory
@@ -102,7 +101,9 @@ func (dir *RegistryDirectory) subscribe(url *common.URL) {
logger.Debugf("subscribe service :%s for RegistryDirectory.", url.Key())
dir.consumerConfigurationListener.addNotifyListener(dir)
dir.referenceConfigurationListener = newReferenceConfigurationListener(dir, url)
- dir.registry.Subscribe(url, dir)
+ if err := dir.registry.Subscribe(url, dir); err != nil {
+ logger.Error("registry.Subscribe(url:%v, dir:%v) = error:%v", url, dir, err)
+ }
}
// Notify monitor changes from registry,and update the cacheServices
@@ -152,7 +153,6 @@ func (dir *RegistryDirectory) refreshAllInvokers(events []*registry.ServiceEvent
if event.Action != remoting.EventTypeUpdate {
panic("Your implements of register center is wrong, " +
"please check the Action of ServiceEvent should be EventTypeUpdate")
- return
}
// Originally it will Merge URL many times, now we just execute once.
// MergeUrl is executed once and put the result into Event. After this, the key will get from Event.Key().
@@ -295,11 +295,7 @@ func (dir *RegistryDirectory) toGroupInvokers() []protocol.Invoker {
for _, invoker := range newInvokersList {
group := invoker.GetUrl().GetParam(constant.GROUP_KEY, "")
- if _, ok := groupInvokersMap[group]; ok {
- groupInvokersMap[group] = append(groupInvokersMap[group], invoker)
- } else {
- groupInvokersMap[group] = []protocol.Invoker{invoker}
- }
+ groupInvokersMap[group] = append(groupInvokersMap[group], invoker)
}
groupInvokersList := make([]protocol.Invoker, 0, len(groupInvokersMap))
if len(groupInvokersMap) == 1 {
diff --git a/registry/etcdv3/service_discovery.go b/registry/etcdv3/service_discovery.go
index e8d4aea9a42634896c3c30e5c6b527a935179873..b9d8b5f895cf8257fa75da87c5548c7a8bdad3b9 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())
}
}
@@ -162,7 +165,7 @@ func (e *etcdV3ServiceDiscovery) GetInstances(serviceName string) []registry.Ser
logger.Infof("could not getChildrenKVList the err is:%v", err)
}
- return make([]registry.ServiceInstance, 0, 0)
+ return make([]registry.ServiceInstance, 0)
}
// GetInstancesByPage will return a page containing instances of ServiceInstance with the serviceName
@@ -319,5 +322,5 @@ func newEtcdV3ServiceDiscovery(name string) (registry.ServiceDiscovery, error) {
descriptor := fmt.Sprintf("etcd-service-discovery[%s]", remoteConfig.Address)
- return &etcdV3ServiceDiscovery{descriptor, client, nil, gxset.NewSet(), make(map[string]*etcdv3.EventListener, 0)}, nil
+ return &etcdV3ServiceDiscovery{descriptor, client, nil, gxset.NewSet(), make(map[string]*etcdv3.EventListener)}, nil
}
diff --git a/registry/file/service_discovery.go b/registry/file/service_discovery.go
index 254c12688f47282343e0004dac86844ba51a3eb2..21482d329e0e252a4af612e872c4153a5afdd25c 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() {
@@ -210,7 +212,7 @@ func (fssd *fileSystemServiceDiscovery) GetInstances(serviceName string) []regis
if err != nil {
logger.Errorf("[FileServiceDiscovery] Could not query the instances for service{%s}, error = err{%v} ",
serviceName, err)
- return make([]registry.ServiceInstance, 0, 0)
+ return make([]registry.ServiceInstance, 0)
}
res := make([]registry.ServiceInstance, 0, set.Size())
@@ -221,7 +223,7 @@ func (fssd *fileSystemServiceDiscovery) GetInstances(serviceName string) []regis
logger.Errorf("[FileServiceDiscovery] Could not get the properties for id{%s}, service{%s}, "+
"error = err{%v} ",
id, serviceName, err)
- return make([]registry.ServiceInstance, 0, 0)
+ return make([]registry.ServiceInstance, 0)
}
dsi := ®istry.DefaultServiceInstance{}
@@ -230,7 +232,7 @@ func (fssd *fileSystemServiceDiscovery) GetInstances(serviceName string) []regis
logger.Errorf("[FileServiceDiscovery] Could not unmarshal the properties for id{%s}, service{%s}, "+
"error = err{%v} ",
id, serviceName, err)
- return make([]registry.ServiceInstance, 0, 0)
+ return make([]registry.ServiceInstance, 0)
}
res = append(res, dsi)
diff --git a/registry/file/service_discovery_test.go b/registry/file/service_discovery_test.go
index 0bffcae31d039a49d8cf696a6de2f6858c42ada2..2f52eb52e1be1f7f06f29d30cd7761e71ecd1bee 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/kubernetes/listener_test.go b/registry/kubernetes/listener_test.go
index f1d8ff41761a841aa2bec888336756854ff16874..ef6e8fb1fceed9aa84a0f9099b8c782ceb624910 100644
--- a/registry/kubernetes/listener_test.go
+++ b/registry/kubernetes/listener_test.go
@@ -31,138 +31,6 @@ import (
"github.com/apache/dubbo-go/remoting"
)
-var clientPodJsonData = `{
- "apiVersion": "v1",
- "kind": "Pod",
- "metadata": {
- "annotations": {
- "dubbo.io/annotation": "W3siayI6Ii9kdWJibyIsInYiOiIifSx7ImsiOiIvZHViYm8vY29tLmlrdXJlbnRvLnVzZXIuVXNlclByb3ZpZGVyIiwidiI6IiJ9LHsiayI6Ii9kdWJiby9jb20uaWt1cmVudG8udXNlci5Vc2VyUHJvdmlkZXIvY29uc3VtZXJzIiwidiI6IiJ9LHsiayI6Ii9kdWJibyIsInYiOiIifSx7ImsiOiIvZHViYm8vY29tLmlrdXJlbnRvLnVzZXIuVXNlclByb3ZpZGVyIiwidiI6IiJ9LHsiayI6Ii9kdWJiby9jb20uaWt1cmVudG8udXNlci5Vc2VyUHJvdmlkZXIvcHJvdmlkZXJzIiwidiI6IiJ9LHsiayI6Ii9kdWJiby9jb20uaWt1cmVudG8udXNlci5Vc2VyUHJvdmlkZXIvY29uc3VtZXJzL2NvbnN1bWVyJTNBJTJGJTJGMTcyLjE3LjAuOCUyRlVzZXJQcm92aWRlciUzRmNhdGVnb3J5JTNEY29uc3VtZXJzJTI2ZHViYm8lM0RkdWJib2dvLWNvbnN1bWVyLTIuNi4wJTI2cHJvdG9jb2wlM0RkdWJibyIsInYiOiIifV0="
- },
- "creationTimestamp": "2020-03-13T03:38:57Z",
- "labels": {
- "dubbo.io/label": "dubbo.io-value"
- },
- "name": "client",
- "namespace": "default",
- "resourceVersion": "2449700",
- "selfLink": "/api/v1/namespaces/default/pods/client",
- "uid": "3ec394f5-dcc6-49c3-8061-57b4b2b41344"
- },
- "spec": {
- "containers": [
- {
- "env": [
- {
- "name": "NAMESPACE",
- "valueFrom": {
- "fieldRef": {
- "apiVersion": "v1",
- "fieldPath": "metadata.namespace"
- }
- }
- }
- ],
- "image": "registry.cn-hangzhou.aliyuncs.com/scottwang/dubbogo-client",
- "imagePullPolicy": "Always",
- "name": "client",
- "resources": {},
- "terminationMessagePath": "/dev/termination-log",
- "terminationMessagePolicy": "File",
- "volumeMounts": [
- {
- "mountPath": "/var/run/secrets/kubernetes.io/serviceaccount",
- "name": "dubbo-sa-token-l2lzh",
- "readOnly": true
- }
- ]
- }
- ],
- "dnsPolicy": "ClusterFirst",
- "enableServiceLinks": true,
- "nodeName": "minikube",
- "priority": 0,
- "restartPolicy": "Never",
- "schedulerName": "default-scheduler",
- "securityContext": {},
- "serviceAccount": "dubbo-sa",
- "serviceAccountName": "dubbo-sa",
- "terminationGracePeriodSeconds": 30,
- "tolerations": [
- {
- "effect": "NoExecute",
- "key": "node.kubernetes.io/not-ready",
- "operator": "Exists",
- "tolerationSeconds": 300
- },
- {
- "effect": "NoExecute",
- "key": "node.kubernetes.io/unreachable",
- "operator": "Exists",
- "tolerationSeconds": 300
- }
- ],
- "volumes": [
- {
- "name": "dubbo-sa-token-l2lzh",
- "secret": {
- "defaultMode": 420,
- "secretName": "dubbo-sa-token-l2lzh"
- }
- }
- ]
- },
- "status": {
- "conditions": [
- {
- "lastProbeTime": null,
- "lastTransitionTime": "2020-03-13T03:38:57Z",
- "status": "True",
- "type": "Initialized"
- },
- {
- "lastProbeTime": null,
- "lastTransitionTime": "2020-03-13T03:40:18Z",
- "status": "True",
- "type": "Ready"
- },
- {
- "lastProbeTime": null,
- "lastTransitionTime": "2020-03-13T03:40:18Z",
- "status": "True",
- "type": "ContainersReady"
- },
- {
- "lastProbeTime": null,
- "lastTransitionTime": "2020-03-13T03:38:57Z",
- "status": "True",
- "type": "PodScheduled"
- }
- ],
- "containerStatuses": [
- {
- "containerID": "docker://2870d6abc19ca7fe22ca635ebcfac5d48c6d5550a659bafd74fb48104f6dfe3c",
- "image": "registry.cn-hangzhou.aliyuncs.com/scottwang/dubbogo-client:latest",
- "imageID": "docker-pullable://registry.cn-hangzhou.aliyuncs.com/scottwang/dubbogo-client@sha256:1f075131f708a0d400339e81549d7c4d4ed917ab0b6bd38ef458dd06ad25a559",
- "lastState": {},
- "name": "client",
- "ready": true,
- "restartCount": 0,
- "state": {
- "running": {
- "startedAt": "2020-03-13T03:40:17Z"
- }
- }
- }
- ],
- "hostIP": "10.0.2.15",
- "phase": "Running",
- "podIP": "172.17.0.8",
- "qosClass": "BestEffort",
- "startTime": "2020-03-13T03:38:57Z"
- }
-}
-`
-
func Test_DataChange(t *testing.T) {
listener := NewRegistryDataListener(&MockDataListener{})
url, _ := common.NewURL("jsonrpc%3A%2F%2F127.0.0.1%3A20001%2Fcom.ikurento.user.UserProvider%3Fanyhost%3Dtrue%26app.version%3D0.0.1%26application%3DBDTService%26category%3Dproviders%26cluster%3Dfailover%26dubbo%3Ddubbo-provider-golang-2.6.0%26environment%3Ddev%26group%3D%26interface%3Dcom.ikurento.user.UserProvider%26ip%3D10.32.20.124%26loadbalance%3Drandom%26methods.GetUser.loadbalance%3Drandom%26methods.GetUser.retries%3D1%26methods.GetUser.weight%3D0%26module%3Ddubbogo%2Buser-info%2Bserver%26name%3DBDTService%26organization%3Dikurento.com%26owner%3DZX%26pid%3D74500%26retries%3D0%26service.filter%3Decho%26side%3Dprovider%26timestamp%3D1560155407%26version%3D%26warmup%3D100")
diff --git a/registry/kubernetes/registry.go b/registry/kubernetes/registry.go
index c1e559e48dcc64972c9405e15405d7e6febcc845..55be4c392abcc14557c60af15b92bc84855b4b31 100644
--- a/registry/kubernetes/registry.go
+++ b/registry/kubernetes/registry.go
@@ -19,7 +19,6 @@ package kubernetes
import (
"fmt"
- "os"
"path"
"sync"
"time"
@@ -40,10 +39,10 @@ import (
"github.com/apache/dubbo-go/remoting/kubernetes"
)
-var (
- processID = ""
- localIP = ""
-)
+//var (
+// processID = ""
+// localIP = ""
+//)
const (
Name = "kubernetes"
@@ -52,8 +51,8 @@ const (
)
func init() {
- processID = fmt.Sprintf("%d", os.Getpid())
- localIP = common.GetLocalIp()
+ //processID = fmt.Sprintf("%d", os.Getpid())
+ //localIP = common.GetLocalIp()
extension.SetRegistry(Name, newKubernetesRegistry)
}
diff --git a/registry/mock_registry.go b/registry/mock_registry.go
index 7c269c3a4044079d19c7c41b53a9ae04b9eab86b..6287bb0d168f18f166618b7c6505b2f8b012be04 100644
--- a/registry/mock_registry.go
+++ b/registry/mock_registry.go
@@ -137,10 +137,7 @@ type listener struct {
}
func (l *listener) Next() (*ServiceEvent, error) {
- select {
- case e := <-l.listenChan:
- return e, nil
- }
+ return <-l.listenChan, nil
}
func (*listener) Close() {
diff --git a/registry/nacos/listener.go b/registry/nacos/listener.go
index 7f27326d6d7b1000688cb03cd6406ea53745a119..6783bf4684c09808326f04ee8ffb7c993045c896 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 078b8ce59c29acae35ccbefafbb9cbfb3d0b205d..a852c00b14ac82ffc64206d6880c9f0e9af7aff6 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/nacos/service_discovery.go b/registry/nacos/service_discovery.go
index b38e150e51075ce47ee38c9c8c9c7280e4437c53..9a2e1f11729d33e6b22bcd2514d97ac5adc29888 100644
--- a/registry/nacos/service_discovery.go
+++ b/registry/nacos/service_discovery.go
@@ -143,7 +143,7 @@ func (n *nacosServiceDiscovery) GetInstances(serviceName string) []registry.Serv
if err != nil {
logger.Errorf("Could not query the instances for service: %+v, group: %+v . It happened err %+v",
serviceName, n.group, err)
- return make([]registry.ServiceInstance, 0, 0)
+ return make([]registry.ServiceInstance, 0)
}
res := make([]registry.ServiceInstance, 0, len(instances))
for _, ins := range instances {
diff --git a/registry/nacos/service_discovery_test.go b/registry/nacos/service_discovery_test.go
index 3b09136d2e273090bea339e0a15b25dde719b6ac..2af1d5b6f564b5389574cc9107ef912cd506db8a 100644
--- a/registry/nacos/service_discovery_test.go
+++ b/registry/nacos/service_discovery_test.go
@@ -151,7 +151,8 @@ func TestNacosServiceDiscovery_CRUD(t *testing.T) {
assert.Equal(t, 1, len(page.GetData()))
instance = page.GetData()[0].(*registry.DefaultServiceInstance)
- v, _ := instance.Metadata["a"]
+ v, ok := instance.Metadata["a"]
+ assert.True(t, ok)
assert.Equal(t, "b", v)
// test dispatcher event
diff --git a/registry/protocol/protocol.go b/registry/protocol/protocol.go
index 3be88c3beb6d909c619ff5c8ff51b90359a31d7b..4fcdf93c0fa36812b69daacbbc829ddac5d2e101 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/service_instance.go b/registry/service_instance.go
index dbb458284d48aa350f2d5d3408b187b437ac81cd..43a1640eead7be1774556f25c9b8f97a75588801 100644
--- a/registry/service_instance.go
+++ b/registry/service_instance.go
@@ -91,7 +91,7 @@ func (d *DefaultServiceInstance) IsHealthy() bool {
// GetMetadata will return the metadata, it will never return nil
func (d *DefaultServiceInstance) GetMetadata() map[string]string {
if d.Metadata == nil {
- d.Metadata = make(map[string]string, 0)
+ d.Metadata = make(map[string]string)
}
return d.Metadata
}
diff --git a/registry/servicediscovery/service_discovery_registry.go b/registry/servicediscovery/service_discovery_registry.go
index ad6ec981ded9e224cecc0fa37c8e7f8c0254a932..2ca4b8015bc8dbc51a47a46c1bec0301ac961339 100644
--- a/registry/servicediscovery/service_discovery_registry.go
+++ b/registry/servicediscovery/service_discovery_registry.go
@@ -462,7 +462,7 @@ func (s *serviceDiscoveryRegistry) initRevisionExportedURLsByInst(serviceInstanc
}
revisionExportedURLs := revisionExportedURLsMap[revision]
firstGet := false
- if revisionExportedURLs == nil || len(revisionExportedURLs) == 0 {
+ if len(revisionExportedURLs) == 0 {
if len(revisionExportedURLsMap) > 0 {
// The case is that current ServiceInstance with the different revision
logger.Warnf("The ServiceInstance[id: %s, host : %s , port : %s] has different revision : %s"+
diff --git a/registry/servicediscovery/service_discovery_registry_test.go b/registry/servicediscovery/service_discovery_registry_test.go
index ad6b73d3b4da77e5fe21a3085cdc21d3eca0246d..a65e6e404a22c2304b4f2ad44fd0a0bc5ede2d19 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/servicediscovery/synthesizer/rest/rest_subscribed_urls_synthesizer.go b/registry/servicediscovery/synthesizer/rest/rest_subscribed_urls_synthesizer.go
index d1ab6113b31a779529cc7e33ffd0f14233dd9ad6..c6b3aeaad09ebfa01d832a92478b7638a6cff432 100644
--- a/registry/servicediscovery/synthesizer/rest/rest_subscribed_urls_synthesizer.go
+++ b/registry/servicediscovery/synthesizer/rest/rest_subscribed_urls_synthesizer.go
@@ -38,14 +38,11 @@ type RestSubscribedURLsSynthesizer struct {
}
func (r RestSubscribedURLsSynthesizer) Support(subscribedURL *common.URL) bool {
- if "rest" == subscribedURL.Protocol {
- return true
- }
- return false
+ return "rest" == subscribedURL.Protocol
}
func (r RestSubscribedURLsSynthesizer) Synthesize(subscribedURL *common.URL, serviceInstances []registry.ServiceInstance) []*common.URL {
- urls := make([]*common.URL, len(serviceInstances), len(serviceInstances))
+ urls := make([]*common.URL, len(serviceInstances))
for i, s := range serviceInstances {
splitHost := strings.Split(s.GetHost(), ":")
u := common.NewURLWithOptions(common.WithProtocol(subscribedURL.Protocol), common.WithIp(splitHost[0]),
diff --git a/registry/zookeeper/registry.go b/registry/zookeeper/registry.go
index fe492c2b12712e0935ccd6fdd264e0fe8f24e213..8b61e8092ce5b0d8081095555ed49734db9a48b4 100644
--- a/registry/zookeeper/registry.go
+++ b/registry/zookeeper/registry.go
@@ -129,7 +129,7 @@ func (r *zkRegistry) InitListeners() {
defer oldDataListener.mutex.Unlock()
r.dataListener.closed = true
recovered := r.dataListener.subscribed
- if recovered != nil && len(recovered) > 0 {
+ if len(recovered) > 0 {
// recover all subscribed url
for _, oldListener := range recovered {
var (
diff --git a/registry/zookeeper/registry_test.go b/registry/zookeeper/registry_test.go
index e630db7e41092e48592bf99690f11863a23e23d3..5959a903bc883141f158c5462b0a775c711f8f51 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,17 +49,21 @@ 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)
+ assert.NoError(t, err)
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)
assert.NoError(t, err)
err = reg.UnRegister(url)
+ assert.NoError(t, err)
children, err = reg.client.GetChildren("/dubbo/com.ikurento.user.UserProvider/providers")
assert.Equal(t, 0, len(children))
assert.Error(t, err)
@@ -67,13 +73,12 @@ func Test_UnRegister(t *testing.T) {
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)
assert.NoError(t, err)
-
}
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,10 +89,11 @@ 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))
- reg2.Register(url)
+ err = reg2.Register(url)
+ assert.Nil(t, err)
listener, _ := reg2.DoSubscribe(url)
serviceEvent, _ := listener.Next()
@@ -96,13 +102,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)
@@ -113,10 +121,11 @@ 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))
- reg2.Register(url)
+ err = reg2.Register(url)
+ assert.Nil(t, err)
listener, _ := reg2.DoSubscribe(url)
serviceEvent, _ := listener.Next()
@@ -126,18 +135,22 @@ func Test_UnSubscribe(t *testing.T) {
}
assert.Regexp(t, ".*ServiceEvent{Action{add}.*", serviceEvent.String())
- reg2.UnSubscribe(url, nil)
+ 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)
@@ -149,18 +162,20 @@ 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)
- reg.Register(url)
+ err = reg.Register(url)
+ assert.Nil(t, err)
//listener.Close()
time.Sleep(1e9)
diff --git a/registry/zookeeper/service_discovery.go b/registry/zookeeper/service_discovery.go
index 6d9582f33a7b2517c4edc96d00d00ad6b57a4835..a515e22d041859211a7a8dcb28bb94b32ed6ae42 100644
--- a/registry/zookeeper/service_discovery.go
+++ b/registry/zookeeper/service_discovery.go
@@ -60,9 +60,9 @@ func init() {
}
type zookeeperServiceDiscovery struct {
- client *zookeeper.ZookeeperClient
- csd *curator_discovery.ServiceDiscovery
- listener *zookeeper.ZkEventListener
+ client *zookeeper.ZookeeperClient
+ csd *curator_discovery.ServiceDiscovery
+ //listener *zookeeper.ZkEventListener
url *common.URL
wg sync.WaitGroup
cltLock sync.Mutex
@@ -214,7 +214,7 @@ func (zksd *zookeeperServiceDiscovery) GetInstances(serviceName string) []regist
if err != nil {
logger.Errorf("[zkServiceDiscovery] Could not query the instances for service{%s}, error = err{%v} ",
serviceName, err)
- return make([]registry.ServiceInstance, 0, 0)
+ return make([]registry.ServiceInstance, 0)
}
iss := make([]registry.ServiceInstance, 0, len(criss))
for _, cris := range criss {
diff --git a/registry/zookeeper/service_discovery_test.go b/registry/zookeeper/service_discovery_test.go
index ea3c7ddd48adc0adc4162d8306d28283575f694a..b7d4677deb4efc56f1d246dc1eabdb0033c94702 100644
--- a/registry/zookeeper/service_discovery_test.go
+++ b/registry/zookeeper/service_discovery_test.go
@@ -75,10 +75,15 @@ func TestNewZookeeperServiceDiscovery(t *testing.T) {
func TestCURDZookeeperServiceDiscovery(t *testing.T) {
ts := prepareData(t)
- defer ts.Stop()
+ defer func() {
+ _ = ts.Stop()
+ }()
sd, err := newZookeeperServiceDiscovery(testName)
assert.Nil(t, err)
- defer sd.Destroy()
+ defer func() {
+ err := sd.Destroy()
+ assert.Nil(t, err)
+ }()
md := make(map[string]string)
md["t1"] = "test1"
err = sd.Register(®istry.DefaultServiceInstance{
@@ -140,10 +145,15 @@ func TestCURDZookeeperServiceDiscovery(t *testing.T) {
func TestAddListenerZookeeperServiceDiscovery(t *testing.T) {
ts := prepareData(t)
- defer ts.Stop()
+ defer func() {
+ _ = ts.Stop()
+ }()
sd, err := newZookeeperServiceDiscovery(testName)
assert.Nil(t, err)
- defer sd.Destroy()
+ defer func() {
+ err := sd.Destroy()
+ assert.Nil(t, err)
+ }()
err = sd.Register(®istry.DefaultServiceInstance{
Id: "testId",
@@ -170,7 +180,7 @@ func TestAddListenerZookeeperServiceDiscovery(t *testing.T) {
extension.SetAndInitGlobalDispatcher("direct")
extension.GetGlobalDispatcher().AddEventListener(sicl)
err = sd.AddListener(sicl)
- assert.Nil(t, err)
+ assert.NoError(t, err)
err = sd.Update(®istry.DefaultServiceInstance{
Id: "testId",
@@ -181,6 +191,7 @@ func TestAddListenerZookeeperServiceDiscovery(t *testing.T) {
Healthy: true,
Metadata: nil,
})
+ assert.NoError(t, err)
tn.wg.Wait()
}
diff --git a/remoting/etcdv3/client.go b/remoting/etcdv3/client.go
index ebd454242d49ee82c81fe1a1fae1a19980c238a4..34ee31bd94afcc48776bfc81d73bbd5c87a2b7f8 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 da31136ed3207c8139cc9abd0cabd963cce7bb93..787c24d45fba17584dbdd4cb6485cf31ad0e5d2c 100644
--- a/remoting/etcdv3/client_test.go
+++ b/remoting/etcdv3/client_test.go
@@ -108,7 +108,6 @@ func (suite *ClientTestSuite) SetupSuite() {
}
suite.etcd = e
- return
}
// stop etcd server
@@ -133,9 +132,9 @@ 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
}
func (suite *ClientTestSuite) TestClientClose() {
diff --git a/remoting/getty/dubbo_codec_for_test.go b/remoting/getty/dubbo_codec_for_test.go
index b33fb7422e6d0099d86cdf6410f4ea8daf626a0d..be6d9db07c681839485ddad65ce989d7235ec5af 100644
--- a/remoting/getty/dubbo_codec_for_test.go
+++ b/remoting/getty/dubbo_codec_for_test.go
@@ -171,10 +171,7 @@ func (c *DubboTestCodec) Decode(data []byte) (remoting.DecodeResult, int, error)
}
func (c *DubboTestCodec) isRequest(data []byte) bool {
- if data[2]&byte(0x80) == 0x00 {
- return false
- }
- return true
+ return data[2]&byte(0x80) != 0x00
}
// decode request
diff --git a/remoting/getty/getty_client.go b/remoting/getty/getty_client.go
index 17b5231917b220c4e88d0103ca68dbc28be53dd9..da31c0bf4c3a0fec8284f613a6409b100ffbb12f 100644
--- a/remoting/getty/getty_client.go
+++ b/remoting/getty/getty_client.go
@@ -38,8 +38,6 @@ import (
)
var (
- errInvalidCodecType = perrors.New("illegal CodecType")
- errInvalidAddress = perrors.New("remote address invalid or empty")
errSessionNotExist = perrors.New("session not exist")
errClientClosed = perrors.New("client closed")
errClientReadTimeout = perrors.New("client read timeout")
diff --git a/remoting/getty/getty_client_test.go b/remoting/getty/getty_client_test.go
index 0b18e973cd2ea7a3f6aae59e822aaf68ee983331..c32e0c23f4b3705c3400a96a8bb1247c7e3eae40 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
}
@@ -394,9 +396,11 @@ func InitTest(t *testing.T) (*Server, *common.URL) {
"environment=dev&interface=com.ikurento.user.UserProvider&ip=127.0.0.1&methods=GetUser%2C&" +
"module=dubbogo+user-info+server&org=ikurento.com&owner=ZX&pid=1447&revision=0.0.1&" +
"side=provider&timeout=3000×tamp=1556509797245&bean.name=UserProvider")
+ assert.NoError(t, err)
// 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),
}
@@ -429,7 +433,7 @@ type (
}
UserProvider struct {
- user map[string]User
+ //user map[string]User
}
)
diff --git a/remoting/getty/listener_test.go b/remoting/getty/listener_test.go
index 956ecf9849528bf8da2145beb5661897ce30415a..2700ed8cd8e03f0a37c2d978cd03932ef8d5f8cb 100644
--- a/remoting/getty/listener_test.go
+++ b/remoting/getty/listener_test.go
@@ -23,14 +23,14 @@ import (
)
import (
+ "github.com/opentracing/opentracing-go"
+ "github.com/opentracing/opentracing-go/mocktracer"
"github.com/stretchr/testify/assert"
)
import (
"github.com/apache/dubbo-go/common/constant"
"github.com/apache/dubbo-go/protocol/invocation"
- "github.com/opentracing/opentracing-go"
- "github.com/opentracing/opentracing-go/mocktracer"
)
// test rebuild the ctx
@@ -63,7 +63,7 @@ func TestRebuildCtx(t *testing.T) {
// Once we decided to transfer more context's key-value, we should change this.
// now we only support rebuild the tracing context
func rebuildCtx(inv *invocation.RPCInvocation) context.Context {
- ctx := context.WithValue(context.Background(), "attachment", inv.Attachments())
+ ctx := context.WithValue(context.Background(), constant.DubboCtxKey("attachment"), inv.Attachments())
// actually, if user do not use any opentracing framework, the err will not be nil.
spanCtx, err := opentracing.GlobalTracer().Extract(opentracing.TextMap,
diff --git a/remoting/getty/opentracing.go b/remoting/getty/opentracing.go
index 7db733cbe919f2bef46cfc477bda836dc2da0d45..4ba4fde9d880dee8437f8bb3dfdfec910f96fdcc 100644
--- a/remoting/getty/opentracing.go
+++ b/remoting/getty/opentracing.go
@@ -35,14 +35,6 @@ func injectTraceCtx(currentSpan opentracing.Span, inv *invocation_impl.RPCInvoca
return err
}
-func extractTraceCtx(inv *invocation_impl.RPCInvocation) (opentracing.SpanContext, error) {
- traceAttachments := filterContext(inv.Attachments())
- // actually, if user do not use any opentracing framework, the err will not be nil.
- spanCtx, err := opentracing.GlobalTracer().Extract(opentracing.TextMap,
- opentracing.TextMapCarrier(traceAttachments))
- return spanCtx, err
-}
-
func filterContext(attachments map[string]interface{}) map[string]string {
var traceAttchment = make(map[string]string)
for k, v := range attachments {
diff --git a/remoting/getty/pool.go b/remoting/getty/pool.go
index 9689175bcf9838de595f292779b099ae9615d8e8..63c9c1a1fb4659ec2d4b07f14008acc99b9b9c3a 100644
--- a/remoting/getty/pool.go
+++ b/remoting/getty/pool.go
@@ -91,7 +91,7 @@ func newGettyRPCClientConn(pool *gettyRPCClientPool, addr string) (*gettyRPCClie
break
}
- if time.Now().Sub(start) > connectTimeout {
+ if time.Since(start) > connectTimeout {
c.gettyClient.Close()
return nil, perrors.New(fmt.Sprintf("failed to create client connection to %s in %s", addr, connectTimeout))
}
@@ -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)
@@ -282,11 +292,7 @@ func (c *gettyRPCClient) getClientRpcSession(session getty.Session) (rpcSession,
}
func (c *gettyRPCClient) isAvailable() bool {
- if c.selectSession() == nil {
- return false
- }
-
- return true
+ return c.selectSession() != nil
}
func (c *gettyRPCClient) close() error {
@@ -304,9 +310,7 @@ func (c *gettyRPCClient) close() error {
c.gettyClient = nil
sessions = make([]*rpcSession, 0, len(c.sessions))
- for _, s := range c.sessions {
- sessions = append(sessions, s)
- }
+ sessions = append(sessions, c.sessions...)
c.sessions = c.sessions[:0]
}()
diff --git a/remoting/kubernetes/client.go b/remoting/kubernetes/client.go
index 5399e5f21b6acb70420bd054aa9b83a3d8ad98f0..ce6bcccea50643cd49f3f99fcf4b86e73309b28c 100644
--- a/remoting/kubernetes/client.go
+++ b/remoting/kubernetes/client.go
@@ -186,12 +186,12 @@ func ValidateClient(container clientFacade) error {
// NewMockClient exports for registry package test
func NewMockClient(podList *v1.PodList) (*Client, error) {
-
ctx, cancel := context.WithCancel(context.Background())
controller, err := newDubboRegistryController(ctx, common.CONSUMER, func() (kubernetes.Interface, error) {
return fake.NewSimpleClientset(podList), nil
})
if err != nil {
+ cancel()
return nil, perrors.WithMessage(err, "new dubbo-registry controller")
}
diff --git a/remoting/kubernetes/client_test.go b/remoting/kubernetes/client_test.go
index fdaee96b4451cba3fd6ba043be9d6b96feadf8c0..9cc421225ea15c250c3ea1196432cb65635144a2 100644
--- a/remoting/kubernetes/client_test.go
+++ b/remoting/kubernetes/client_test.go
@@ -317,7 +317,8 @@ func TestClientGetChildrenKVList(t *testing.T) {
wc, done, err := client.WatchWithPrefix(prefix)
if err != nil {
- t.Fatal(err)
+ t.Error(err)
+ return
}
wg.Done()
diff --git a/remoting/kubernetes/facade_test.go b/remoting/kubernetes/facade_test.go
index 00e2e1171c54c2b07973b66cb96cf64e67683f00..a6c6c02b515b6e1ebc815bb5b388ae68db68621d 100644
--- a/remoting/kubernetes/facade_test.go
+++ b/remoting/kubernetes/facade_test.go
@@ -19,7 +19,6 @@ package kubernetes
import (
"strconv"
- "sync"
"testing"
)
@@ -30,9 +29,9 @@ import (
type mockFacade struct {
*common.URL
- client *Client
- cltLock sync.Mutex
- done chan struct{}
+ client *Client
+ //cltLock sync.Mutex
+ //done chan struct{}
}
func (r *mockFacade) Client() *Client {
diff --git a/remoting/kubernetes/watch.go b/remoting/kubernetes/watch.go
index 07eeb09b4dd4627fdd3b18ee4d59356911b3a9b1..7bb5ef1754836b481089d67b9cf34437567ffa9a 100644
--- a/remoting/kubernetes/watch.go
+++ b/remoting/kubernetes/watch.go
@@ -116,21 +116,17 @@ type watcherSetImpl struct {
// closeWatchers
// when the watcher-set was closed
func (s *watcherSetImpl) closeWatchers() {
-
- select {
- case <-s.ctx.Done():
-
- // parent ctx be canceled, close the watch-set's watchers
- s.lock.Lock()
- watchers := s.watchers
- s.lock.Unlock()
-
- for _, w := range watchers {
- // stop data stream
- // close(w.ch)
- // stop watcher
- w.stop()
- }
+ <-s.ctx.Done()
+ // parent ctx be canceled, close the watch-set's watchers
+ s.lock.Lock()
+ watchers := s.watchers
+ s.lock.Unlock()
+
+ for _, w := range watchers {
+ // stop data stream
+ // close(w.ch)
+ // stop watcher
+ w.stop()
}
}
diff --git a/remoting/kubernetes/watch_test.go b/remoting/kubernetes/watch_test.go
index 8889103be212381c07ffff3c3d4399f41aeee564..efefcc5dc9db629aa0f109a8da4f4227c18504fa 100644
--- a/remoting/kubernetes/watch_test.go
+++ b/remoting/kubernetes/watch_test.go
@@ -42,7 +42,8 @@ func TestWatchSet(t *testing.T) {
defer wg.Done()
w, err := s.Watch("key-1", false)
if err != nil {
- t.Fatal(err)
+ t.Error(err)
+ return
}
for {
select {
@@ -64,7 +65,8 @@ func TestWatchSet(t *testing.T) {
defer wg.Done()
w, err := s.Watch("key", true)
if err != nil {
- t.Fatal(err)
+ t.Error(err)
+ return
}
for {
@@ -86,7 +88,8 @@ func TestWatchSet(t *testing.T) {
Key: "key-" + strconv.Itoa(i),
Value: strconv.Itoa(i),
}); err != nil {
- t.Fatal(err)
+ t.Error(err)
+ return
}
}(i)
}
diff --git a/remoting/zookeeper/client_test.go b/remoting/zookeeper/client_test.go
index 34741700ca2a9d86ee5321b0b19ed64b2b1a25a8..af09edba48815044ff9002a68b438463113c4652 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 3d5798c947fb0fb33adce708e1bcdb8fb24e530f..4a76a80ef13edf9c38c2f54bbdca0b8c8203530f 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.go b/remoting/zookeeper/listener.go
index e5ddcadeaca9c3ce972cbe781413ebec7393afce..7b90e523364b6a1a77b8e30ef73ddca6caffda6a 100644
--- a/remoting/zookeeper/listener.go
+++ b/remoting/zookeeper/listener.go
@@ -362,9 +362,9 @@ func (l *ZkEventListener) ListenServiceEvent(conf *common.URL, zkPath string, li
}(zkPath, listener)
}
-func (l *ZkEventListener) valid() bool {
- return l.client.ZkConnValid()
-}
+//func (l *ZkEventListener) valid() bool {
+// return l.client.ZkConnValid()
+//}
// Close will let client listen exit
func (l *ZkEventListener) Close() {
diff --git a/remoting/zookeeper/listener_test.go b/remoting/zookeeper/listener_test.go
index 37ef1b4b967d2f6708a4a099875ae90f273ae483..07976dc31db5909a261ed7f76223a12220249207 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)