diff --git a/.github/workflows/github-actions.yml b/.github/workflows/github-actions.yml
index 79f6f2066e38f91d862453c39f0c25797546a42a..64672af5ab6d045a6f26633079a1dce55d36432d 100644
--- a/.github/workflows/github-actions.yml
+++ b/.github/workflows/github-actions.yml
@@ -54,6 +54,12 @@ jobs:
go get -v -t -d ./...
fi
+ - 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: Verify
run: |
make verify
diff --git a/.golangci.yml b/.golangci.yml
new file mode 100644
index 0000000000000000000000000000000000000000..6f214f445ac5544b26d4fa704b7ea4524535f8bd
--- /dev/null
+++ b/.golangci.yml
@@ -0,0 +1,63 @@
+linters-settings:
+ govet:
+ check-shadowing: true
+ golint:
+ min-confidence: 0
+ gocyclo:
+ min-complexity: 10
+ maligned:
+ suggest-new: true
+ dupl:
+ threshold: 100
+ goconst:
+ min-len: 2
+ min-occurrences: 2
+ depguard:
+ list-type: blacklist
+ packages:
+ # logging is allowed only by logutils.Log, logrus
+ # is allowed to use only in logutils package
+ - github.com/sirupsen/logrus
+ misspell:
+ locale: US
+ lll:
+ line-length: 140
+ goimports:
+ local-prefixes: github.com/golangci/golangci-lint
+ gocritic:
+ enabled-tags:
+ - performance
+ - style
+ - experimental
+ disabled-checks:
+ - wrapperFunc
+
+linters:
+ disable-all: true
+ enable:
+ - govet
+ - staticcheck
+ - ineffassign
+ - misspell
+
+run:
+ skip-dirs:
+ - test/testdata_etc
+ - pkg/golinters/goanalysis/(checker|passes)
+
+issues:
+ exclude-rules:
+ - text: "weak cryptographic primitive"
+ linters:
+ - gosec
+ - linters:
+ - staticcheck
+ text: "SA1019:"
+
+# golangci.com configuration
+# https://github.com/golangci/golangci/wiki/Configuration
+service:
+ golangci-lint-version: 1.15.x # use the fixed version to not introduce new linters unexpectedly
+ prepare:
+ - echo "here I can run custom commands, but no preparation needed for this repo"
+
diff --git a/.travis.yml b/.travis.yml
index 4f79ecf3bc1439e00c88c4d0de74cc7a4bf26909..fb958136b0a61b43f0a8fa650cb1ef3bd3b9d689 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -15,7 +15,7 @@ install: true
# define ci-stage
script:
- - go fmt ./... && [[ -z `git status -s` ]]
+ - go fmt ./... && git checkout -- go.mod && [[ -z `git status -s` ]]
# license-check
- make verify
# integrate-test
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/loadbalance/random_test.go b/cluster/loadbalance/random_test.go
index b94d7da43d5bd42e6798fca750c8616830a8df8f..c24fdf0556b1323ccfc08a2f9f384c60e2fa2f5e 100644
--- a/cluster/loadbalance/random_test.go
+++ b/cluster/loadbalance/random_test.go
@@ -83,6 +83,7 @@ func TestRandomlbSelectWeight(t *testing.T) {
}
selectedInvoker = append(selectedInvoker, s)
}
+ assert.Equal(t, 10000, len(selectedInvoker))
assert.Condition(t, func() bool {
// really is 0.9999999999999
@@ -114,6 +115,8 @@ func TestRandomlbSelectWarmup(t *testing.T) {
}
selectedInvoker = append(selectedInvoker, s)
}
+ assert.Equal(t, 10000, len(selectedInvoker))
+
assert.Condition(t, func() bool {
return selected/10000 < 0.1
})
diff --git a/cluster/router/chain/chain.go b/cluster/router/chain/chain.go
index 8c4ffe01bd9fe251fab60743ad5fe2aa83e20653..fccce838bb3f6750b72b83c4991ad78e8b49f138 100644
--- a/cluster/router/chain/chain.go
+++ b/cluster/router/chain/chain.go
@@ -195,6 +195,9 @@ func (c *RouterChain) copyInvokerIfNecessary(cache *InvokerCache) []protocol.Inv
func (c *RouterChain) buildCache() {
origin := c.loadCache()
invokers := c.copyInvokerIfNecessary(origin)
+ if len(invokers) == 0 {
+ return
+ }
var (
mutex sync.Mutex
diff --git a/cluster/router/chain/chain_test.go b/cluster/router/chain/chain_test.go
index b21990b08c5b960c407a395cddf7ef7518ba5822..1bb7124a4f877a0ca65a3a683da97a44168e0275 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() {
+ _ = ts.Stop()
+ assert.NoError(t, err)
+ z.Close()
+ }()
zkUrl, _ := common.NewURL(fmt.Sprintf(zkFormat, localIP, ts.Servers[0].Port))
configuration, err := extension.GetConfigCenterFactory(zk).GetDynamicConfiguration(zkUrl)
+ assert.NoError(t, err)
config.GetEnvInstance().SetDynamicConfiguration(configuration)
chain, err := NewRouterChain(getConditionRouteUrl(applicationKey))
@@ -154,11 +160,15 @@ conditions:
func TestRouterChainRoute(t *testing.T) {
ts, z, _, err := zookeeper.NewMockZookeeperClient("test", 15*time.Second)
- defer ts.Stop()
- defer z.Close()
+ defer func() {
+ err = ts.Stop()
+ assert.NoError(t, err)
+ z.Close()
+ }()
zkUrl, _ := common.NewURL(fmt.Sprintf(zkFormat, localIP, ts.Servers[0].Port))
configuration, err := extension.GetConfigCenterFactory(zk).GetDynamicConfiguration(zkUrl)
+ assert.NoError(t, err)
config.GetEnvInstance().SetDynamicConfiguration(configuration)
chain, err := NewRouterChain(getConditionRouteUrl(applicationKey))
@@ -198,11 +208,15 @@ conditions:
_, err = z.Conn.Set(path, []byte(testyml), 0)
assert.NoError(t, err)
- defer ts.Stop()
- defer z.Close()
+ defer func() {
+ _ = ts.Stop()
+ assert.NoError(t, err)
+ z.Close()
+ }()
zkUrl, _ := common.NewURL(fmt.Sprintf(zkFormat, localIP, ts.Servers[0].Port))
configuration, err := extension.GetConfigCenterFactory(zk).GetDynamicConfiguration(zkUrl)
+ assert.NoError(t, err)
config.GetEnvInstance().SetDynamicConfiguration(configuration)
chain, err := NewRouterChain(getConditionRouteUrl(applicationKey))
@@ -224,12 +238,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() {
+ _ = 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 879abc5cc8b607ee9245ce632800b056ff740cc5..c8bc43eb33f9cbbb8bbc5c0b87a57907ac15aa62 100644
--- a/cluster/router/condition/app_router_test.go
+++ b/cluster/router/condition/app_router_test.go
@@ -67,8 +67,11 @@ conditions:
_, err = z.Conn.Set(routerPath, []byte(testYML), 0)
assert.NoError(t, err)
- defer ts.Stop()
- defer z.Close()
+ defer func() {
+ err = ts.Stop()
+ assert.NoError(t, err)
+ z.Close()
+ }()
zkUrl, _ := common.NewURL(fmt.Sprintf(zkFormat, routerLocalIP, ts.Servers[0].Port))
configuration, err := extension.GetConfigCenterFactory(routerZk).GetDynamicConfiguration(zkUrl)
@@ -115,8 +118,11 @@ conditions:
_, err = z.Conn.Set(routerPath, []byte(testYML), 0)
assert.NoError(t, err)
- defer ts.Stop()
- defer z.Close()
+ defer func() {
+ err = ts.Stop()
+ assert.NoError(t, err)
+ z.Close()
+ }()
zkUrl, _ := common.NewURL(fmt.Sprintf(zkFormat, routerLocalIP, ts.Servers[0].Port))
configuration, err := extension.GetConfigCenterFactory(routerZk).GetDynamicConfiguration(zkUrl)
@@ -154,8 +160,11 @@ conditions:
_, err = z.Conn.Set(routerPath, []byte(testYML), 0)
assert.NoError(t, err)
- defer ts.Stop()
- defer z.Close()
+ defer func() {
+ err = ts.Stop()
+ assert.NoError(t, err)
+ z.Close()
+ }()
zkUrl, _ := common.NewURL(fmt.Sprintf(zkFormat, routerLocalIP, ts.Servers[0].Port))
configuration, err := extension.GetConfigCenterFactory(routerZk).GetDynamicConfiguration(zkUrl)
diff --git a/cluster/router/condition/file_test.go b/cluster/router/condition/file_test.go
index bd19a0d18c6692af181ffef77c5cd3f9fc16d67d..9035e9559223e30cc2a56873b5aa0e4432c0a358 100644
--- a/cluster/router/condition/file_test.go
+++ b/cluster/router/condition/file_test.go
@@ -89,33 +89,41 @@ 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)
+ assert.Equal(t, "", grp)
+ assert.Equal(t, "", srv)
+ assert.Equal(t, "", ver)
assert.Error(t, err)
testString = ""
@@ -123,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/condition/listenable_router.go b/cluster/router/condition/listenable_router.go
index 0b47310dbfe9987a593bc2d0d949a76f08052114..102d766a8a787b460c878c42e8327c1a57ea9588 100644
--- a/cluster/router/condition/listenable_router.go
+++ b/cluster/router/condition/listenable_router.go
@@ -47,8 +47,8 @@ type listenableRouter struct {
conditionRouters []*ConditionRouter
routerRule *RouterRule
url *common.URL
- force bool
- priority int64
+ //force bool
+ priority int64
}
// RouterRule Get RouterRule instance from listenableRouter
diff --git a/cluster/router/condition/router.go b/cluster/router/condition/router.go
index 2fc33072d33517810f0c9ab3b8351d7bdcfea8b4..0817b32843938346610aa1e66c626e4895468372 100644
--- a/cluster/router/condition/router.go
+++ b/cluster/router/condition/router.go
@@ -46,6 +46,13 @@ var (
routerPatternReg = regexp.MustCompile(`([&!=,]*)\s*([^&!=,\s]+)`)
)
+var (
+ emptyMatchPair = MatchPair{
+ Matches: gxset.NewSet(),
+ Mismatches: gxset.NewSet(),
+ }
+)
+
// ConditionRouter Condition router struct
type ConditionRouter struct {
Pattern string
@@ -221,14 +228,14 @@ func parseRule(rule string) (map[string]MatchPair, error) {
condition[content] = pair
}
case "=":
- if &pair == nil {
+ if pair == emptyMatchPair {
var startIndex = getStartIndex(rule)
return nil, perrors.Errorf("Illegal route rule \"%s\", The error char '%s' at index %d before \"%d\".", rule, separator, startIndex, startIndex)
}
values = pair.Matches
values.Add(content)
case "!=":
- if &pair == nil {
+ if pair == emptyMatchPair {
var startIndex = getStartIndex(rule)
return nil, perrors.Errorf("Illegal route rule \"%s\", The error char '%s' at index %d before \"%d\".", rule, separator, startIndex, startIndex)
}
diff --git a/cluster/router/condition/router_test.go b/cluster/router/condition/router_test.go
index 3d33ca275828b31ed480926d486c5844dac771c6..a344b64efb5d7be1fe7e5d2a5a4c9d206cfcf5da 100644
--- a/cluster/router/condition/router_test.go
+++ b/cluster/router/condition/router_test.go
@@ -70,10 +70,12 @@ func TestNewConditionRouter(t *testing.T) {
assert.EqualValues(t, router.ThenCondition, thenRule)
router, err = NewConditionRouter(nil)
+ assert.Nil(t, router)
assert.Error(t, err)
url, _ = common.NewURL(`condition://0.0.0.0:?application=mock-app&category=routers&force=true&priority=1&router=condition&rule=YSAmT4gYiAmIGQ%3D`)
router, err = NewConditionRouter(url)
+ assert.Nil(t, router)
assert.Error(t, err)
url, _ = common.NewURL(`condition://0.0.0.0:?application=mock-app&category=routers&force=true&router=condition&rule=YSAmIGMgPT4gYiAmIGQ%3D`)
diff --git a/cluster/router/healthcheck/default_health_check_test.go b/cluster/router/healthcheck/default_health_check_test.go
index 39827c5f050a1a5ac9524345b59e37ec23efb90f..c32a607889fb096fee07e1c391f5f3461aacfbc5 100644
--- a/cluster/router/healthcheck/default_health_check_test.go
+++ b/cluster/router/healthcheck/default_health_check_test.go
@@ -56,6 +56,7 @@ func TestDefaultHealthCheckerIsHealthy(t *testing.T) {
}
hc = NewDefaultHealthChecker(url).(*DefaultHealthChecker)
healthy = hc.IsHealthy(invoker)
+ assert.False(t, false, healthy)
// the outgoing request is more than OUTSTANDING_REQUEST_COUNT_LIMIT, go to unhealthy
assert.False(t, hc.IsHealthy(invoker))
@@ -67,11 +68,13 @@ func TestDefaultHealthCheckerIsHealthy(t *testing.T) {
url.SetParam(constant.OUTSTANDING_REQUEST_COUNT_LIMIT_KEY, "1000")
hc = NewDefaultHealthChecker(url).(*DefaultHealthChecker)
healthy = hc.IsHealthy(invoker)
+ assert.False(t, false, healthy)
assert.False(t, hc.IsHealthy(invoker))
// reset successive failed count and go to healthy
request(url, healthCheckMethodTest, 0, false, true)
healthy = hc.IsHealthy(invoker)
+ assert.False(t, false, healthy)
assert.True(t, hc.IsHealthy(invoker))
}
diff --git a/cluster/router/tag/file.go b/cluster/router/tag/file.go
index 94daf1508eb7b3f4d8a8cacdbd6ed634be6852da..a51ae69cf26fa6e7d10444a23cbff339a5a99b3e 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 c7f53047c1e2beee4545a10302e9f307f06c33d8..984ecb4eeff71dd692cbda8db5e3b87dbdde4254 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
@@ -227,7 +227,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 3f7b979f3d52d51ab50c94ea32e87b5eb4f9591e..26c4b8352ba1fce4f6204628f6c09309e3b607d3 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
@@ -238,7 +237,7 @@ func TestRouteBeijingInvoker(t *testing.T) {
type DynamicTagRouter struct {
suite.Suite
- rule *RouterRule
+ //rule *RouterRule
route *tagRouter
zkClient *zookeeper.ZookeeperClient
@@ -310,7 +309,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 c256659acb91ffb2f74473e4f1bc7aafa4b98c38..50aea81371bfc8b189e80f19a5c17c5d9de7ae51 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 (
@@ -92,7 +94,7 @@ const (
)
const (
- DUBBOGO_CTX_KEY = "dubbogo-ctx"
+ DUBBOGO_CTX_KEY = DubboCtxKey("dubbogo-ctx")
)
const (
@@ -198,7 +200,7 @@ const (
)
const (
- TRACING_REMOTE_SPAN_CTX = "tracing.remote.span.ctx"
+ TRACING_REMOTE_SPAN_CTX = DubboCtxKey("tracing.remote.span.ctx")
)
// Use for router module
@@ -238,7 +240,7 @@ const (
Tagkey = "dubbo.tag"
// Attachment key in context in invoker
- AttachmentKey = "attachment"
+ AttachmentKey = DubboCtxKey("attachment")
)
const (
@@ -265,7 +267,7 @@ const (
// signature format
SIGNATURE_STRING_FORMAT = "%s#%s#%s#%s"
// key whether enable signature
- PARAMTER_SIGNATURE_ENABLE_KEY = "param.sign"
+ PARAMETER_SIGNATURE_ENABLE_KEY = "param.sign"
// consumer
CONSUMER = "consumer"
// key of access key id
@@ -293,7 +295,7 @@ const (
HEALTH_CHECKER = "health.checker"
// The name of the default implementation of HealthChecker
DEFAULT_HEALTH_CHECKER = "default"
- // The key of oustanding-request-limit
+ // The key of outstanding-request-limit
OUTSTANDING_REQUEST_COUNT_LIMIT_KEY = "outstanding.request.limit"
// The key of successive-failed-request's threshold
SUCCESSIVE_FAILED_REQUEST_THRESHOLD_KEY = "successive.failed.threshold"
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.go b/common/proxy/proxy.go
index 3a01941700ed277d9481c6c57a739c69f83b06b7..55f533cb2b95269c27c2d2eccf96c33af04bbee1 100644
--- a/common/proxy/proxy.go
+++ b/common/proxy/proxy.go
@@ -158,15 +158,11 @@ func (p *Proxy) Implement(v common.RPCService) {
}
result := p.invoke.Invoke(invCtx, inv)
- if len(result.Attachments()) > 0 {
- invCtx = context.WithValue(invCtx, constant.AttachmentKey, result.Attachments())
- }
-
err = result.Error()
if err != nil {
// the cause reason
err = perrors.Cause(err)
- // if some error happened, it should be log some info in the seperate file.
+ // if some error happened, it should be log some info in the separate file.
if throwabler, ok := err.(java_exception.Throwabler); ok {
logger.Warnf("invoke service throw exception: %v , stackTraceElements: %v", err.Error(), throwabler.GetStackTrace())
} else {
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.go b/common/rpc_service.go
index 572fc71701c411a7a0a070c2a84e9a4d96da6dfb..30d72c1420f254182f5d2f16c6fc9444881f0b71 100644
--- a/common/rpc_service.go
+++ b/common/rpc_service.go
@@ -106,10 +106,10 @@ func (m *MethodType) ReplyType() reflect.Type {
return m.replyType
}
-// SuiteContext tranfers @ctx to reflect.Value type or get it from @m.ctxType.
+// SuiteContext transfers @ctx to reflect.Value type or get it from @m.ctxType.
func (m *MethodType) SuiteContext(ctx context.Context) reflect.Value {
- if contextv := reflect.ValueOf(ctx); contextv.IsValid() {
- return contextv
+ if ctxV := reflect.ValueOf(ctx); ctxV.IsValid() {
+ return ctxV
}
return reflect.Zero(m.ctxType)
}
@@ -156,13 +156,13 @@ type serviceMap struct {
interfaceMap map[string][]*Service // interface -> service
}
-// GetService gets a service defination by protocol and name
+// GetService gets a service definition by protocol and name
func (sm *serviceMap) GetService(protocol, interfaceName, group, version string) *Service {
serviceKey := ServiceKey(interfaceName, group, version)
return sm.GetServiceByServiceKey(protocol, serviceKey)
}
-// GetService gets a service defination by protocol and service key
+// GetService gets a service definition by protocol and service key
func (sm *serviceMap) GetServiceByServiceKey(protocol, serviceKey string) *Service {
sm.mutex.RLock()
defer sm.mutex.RUnlock()
diff --git a/common/rpc_service_test.go b/common/rpc_service_test.go
index b50d8d962c4277f702388b74e5137bdf1c8bdf7e..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,21 +129,20 @@ 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)
}
func TestMethodTypeSuiteContext(t *testing.T) {
mt := &MethodType{ctxType: reflect.TypeOf(context.TODO())}
- ctx := context.WithValue(context.Background(), "key", "value")
+ ctx := context.Background()
+ 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/common/yaml/yaml_test.go b/common/yaml/yaml_test.go
index 5a271a25823f576cb9cdb10c657520bbf5666017..19f4fe148aace5baf4790f329aa228506c8b5f70 100644
--- a/common/yaml/yaml_test.go
+++ b/common/yaml/yaml_test.go
@@ -66,5 +66,5 @@ type Config struct {
}
type ChildConfig struct {
- StrTest string `default:"strTest" default:"default" yaml:"strTest" json:"strTest,omitempty"`
+ StrTest string `default:"default" yaml:"strTest" json:"strTest,omitempty"`
}
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..b9a025e8bc7e146558249ca6d8aa00455ff55523 100644
--- a/config/config_loader_test.go
+++ b/config/config_loader_test.go
@@ -27,7 +27,7 @@ import (
import (
"github.com/Workiva/go-datastructures/slice/skip"
gxset "github.com/dubbogo/gost/container/set"
- gxpage "github.com/dubbogo/gost/page"
+ gxpage "github.com/dubbogo/gost/hash/page"
"github.com/stretchr/testify/assert"
"go.uber.org/atomic"
)
@@ -104,7 +104,8 @@ func TestLoad(t *testing.T) {
conServices = map[string]common.RPCService{}
proServices = map[string]common.RPCService{}
- err := 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
@@ -143,7 +144,9 @@ 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 +185,9 @@ 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 +208,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 +263,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.go b/config/service_config.go
index 087f537b5937821fa39c042f21feb66792e22502..fd49390aa2b15938a8a4aa321d47ceafef4d9be9 100644
--- a/config/service_config.go
+++ b/config/service_config.go
@@ -176,7 +176,8 @@ func (c *ServiceConfig) Export() error {
// registry the service reflect
methods, err := common.ServiceMap.Register(c.InterfaceName, proto.Name, c.Group, c.Version, c.rpcService)
if err != nil {
- formatErr := perrors.Errorf("The service %v export the protocol %v error! Error message is %v.", c.InterfaceName, proto.Name, err.Error())
+ formatErr := perrors.Errorf("The service %v export the protocol %v error! Error message is %v.",
+ c.InterfaceName, proto.Name, err.Error())
logger.Errorf(formatErr.Error())
return formatErr
}
@@ -312,7 +313,7 @@ func (c *ServiceConfig) getUrlMap() url.Values {
// auth filter
urlMap.Set(constant.SERVICE_AUTH_KEY, c.Auth)
- urlMap.Set(constant.PARAMTER_SIGNATURE_ENABLE_KEY, c.ParamSign)
+ urlMap.Set(constant.PARAMETER_SIGNATURE_ENABLE_KEY, c.ParamSign)
// whether to export or not
urlMap.Set(constant.EXPORT_KEY, strconv.FormatBool(c.export))
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..5b74f5e15013c07de000cc18cab98238b96ac060 100644
--- a/config_center/apollo/impl.go
+++ b/config_center/apollo/impl.go
@@ -146,9 +146,8 @@ 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, "")
- parts := strings.Split(address, ",")
+ addr := regexp.MustCompile(`\s+`).ReplaceAllString(address, "")
+ parts := strings.Split(addr, ",")
addrs := make([]string, 0)
for _, part := range parts {
addr := part
diff --git a/config_center/apollo/impl_test.go b/config_center/apollo/impl_test.go
index 4720775c285f84bd4fe2146240feea87c8a20817..3b2cb168402534c1a8071e644827a0f948282f75 100644
--- a/config_center/apollo/impl_test.go
+++ b/config_center/apollo/impl_test.go
@@ -126,24 +126,24 @@ func initApollo() *httptest.Server {
}
func configResponse(rw http.ResponseWriter, _ *http.Request) {
- result := fmt.Sprintf(mockConfigRes)
+ result := mockConfigRes
fmt.Fprintf(rw, "%s", result)
}
func notifyResponse(rw http.ResponseWriter, req *http.Request) {
- result := fmt.Sprintf(mockNotifyRes)
+ result := mockNotifyRes
fmt.Fprintf(rw, "%s", result)
}
func serviceConfigResponse(rw http.ResponseWriter, _ *http.Request) {
- result := fmt.Sprintf(mockServiceConfigRes)
+ result := mockServiceConfigRes
fmt.Fprintf(rw, "%s", result)
}
// 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/file/impl.go b/config_center/file/impl.go
index f29a33d5e2519b54a5496f5ea03ff170020bb28c..9afe7c6524ab02d368f91283e39e3e4c1deacbac 100644
--- a/config_center/file/impl.go
+++ b/config_center/file/impl.go
@@ -180,7 +180,7 @@ func (fsdc *FileSystemDynamicConfiguration) GetConfigKeysByGroup(group string) (
return r, nil
}
-// RemoveConfig will remove the config whit hte (key, group)
+// RemoveConfig will remove tconfig_center/nacos/impl_testhe config whit hte (key, group)
func (fsdc *FileSystemDynamicConfiguration) RemoveConfig(key string, group string) error {
tmpPath := fsdc.GetPath(key, group)
_, err := fsdc.deleteDelay(tmpPath)
diff --git a/config_center/file/impl_test.go b/config_center/file/impl_test.go
index e912cb7078fe42b514ba510db6b7f871ab998ea9..556b6a3d7aa168a83b0861936ad1dc54f827eb18 100644
--- a/config_center/file/impl_test.go
+++ b/config_center/file/impl_test.go
@@ -63,6 +63,7 @@ func TestPublishAndGetConfig(t *testing.T) {
func TestAddListener(t *testing.T) {
file, err := initFileData(t)
+ assert.Nil(t, err)
group := "dubbogo"
value := "Test Value"
err = file.PublishConfig(key, group, value)
@@ -81,6 +82,7 @@ func TestAddListener(t *testing.T) {
func TestRemoveListener(t *testing.T) {
file, err := initFileData(t)
+ assert.NoError(t, err)
group := "dubbogo"
value := "Test Value"
err = file.PublishConfig(key, group, value)
@@ -106,9 +108,11 @@ func TestRemoveListener(t *testing.T) {
func TestGetConfigKeysByGroup(t *testing.T) {
file, err := initFileData(t)
+ assert.Nil(t, err)
group := "dubbogo"
value := "Test Value"
err = file.PublishConfig(key, group, value)
+ assert.NoError(t, err)
gs, err := file.GetConfigKeysByGroup(group)
assert.NoError(t, err)
assert.Equal(t, 1, gs.Size())
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 40efa5f4f288d0eff6d9648481cb2a14bfdb3931..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
@@ -85,6 +85,8 @@ func TestGetConfig(t *testing.T) {
nacos, err := initNacosData(t)
assert.NoError(t, err)
configs, err := nacos.GetProperties("dubbo.properties", config_center.WithGroup("dubbo"))
+ assert.Empty(t, configs)
+ assert.NoError(t, err)
_, err = nacos.Parser().Parse(configs)
assert.NoError(t, err)
}
@@ -100,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/nacos/listener.go b/config_center/nacos/listener.go
index 57df0363a1d7712e1e02a66595030c207b19c170..b0607e29b4d4d3d5caf9ee7072d9c2e44088738a 100644
--- a/config_center/nacos/listener.go
+++ b/config_center/nacos/listener.go
@@ -38,7 +38,6 @@ func callback(listener config_center.ConfigurationListener, _, _, dataId, data s
func (n *nacosDynamicConfiguration) addListener(key string, listener config_center.ConfigurationListener) {
_, loaded := n.keyListeners.Load(key)
if !loaded {
- _, cancel := context.WithCancel(context.Background())
err := (*n.client.Client()).ListenConfig(vo.ConfigParam{
DataId: key,
Group: "dubbo",
@@ -50,13 +49,15 @@ func (n *nacosDynamicConfiguration) addListener(key string, listener config_cent
logger.Errorf("nacos : listen config fail, error:%v ", err)
return
}
+ _, cancel := context.WithCancel(context.Background())
newListener := make(map[config_center.ConfigurationListener]context.CancelFunc)
newListener[listener] = cancel
n.keyListeners.Store(key, newListener)
- } else {
- // TODO check goroutine alive, but this version of go_nacos_sdk is not support.
- logger.Infof("profile:%s. this profile is already listening", key)
+ return
}
+
+ // TODO check goroutine alive, but this version of go_nacos_sdk is not support.
+ logger.Infof("profile:%s. this profile is already listening", key)
}
func (n *nacosDynamicConfiguration) removeListener(key string, listener config_center.ConfigurationListener) {
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 d4a9de41fd62d48ce4528056289839a38285c9a3..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)
@@ -107,15 +110,21 @@ func TestGetConfig(t *testing.T) {
assert.Equal(t, "5s", m["dubbo.consumer.request_timeout"])
configs, err = reg.GetProperties(dubboPropertyFileName)
assert.Error(t, err)
+ assert.Equal(t, "", configs)
configs, err = reg.GetInternalProperty(dubboPropertyFileName)
assert.Error(t, err)
+ assert.Equal(t, "", configs)
configs, err = reg.GetRule(dubboPropertyFileName)
assert.Error(t, err)
+ assert.Equal(t, "", configs)
}
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)
@@ -148,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)
@@ -186,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/access_key.go b/filter/access_key.go
index 4801d64fe46461424c5dac5aef2eebc719ee19c4..f38764bcea9fd1fc2dd5b0e7028aaf21a2c92c92 100644
--- a/filter/access_key.go
+++ b/filter/access_key.go
@@ -26,7 +26,7 @@ import (
type AccessKeyPair struct {
AccessKey string `yaml:"accessKey" json:"accessKey,omitempty" property:"accessKey"`
SecretKey string `yaml:"secretKey" json:"secretKey,omitempty" property:"secretKey"`
- ConsumerSide string `yaml:"consumerSide" json:"ConsumerSide,consumerSide" property:"consumerSide"`
+ ConsumerSide string `yaml:"consumerSide" json:"consumerSide,omitempty" property:"consumerSide"`
ProviderSide string `yaml:"providerSide" json:"providerSide,omitempty" property:"providerSide"`
Creator string `yaml:"creator" json:"creator,omitempty" property:"creator"`
Options string `yaml:"options" json:"options,omitempty" property:"options"`
diff --git a/filter/filter_impl/access_log_filter_test.go b/filter/filter_impl/access_log_filter_test.go
index a3a6151aa1b6a933c57543248f3703125fa356d9..9c4b947db4adbe0a9490f4b13964632028469d18 100644
--- a/filter/filter_impl/access_log_filter_test.go
+++ b/filter/filter_impl/access_log_filter_test.go
@@ -77,6 +77,6 @@ func TestAccessLogFilterInvokeDefaultConfig(t *testing.T) {
func TestAccessLogFilterOnResponse(t *testing.T) {
result := &protocol.RPCResult{}
accessLogFilter := GetAccessLogFilter()
- response := accessLogFilter.OnResponse(nil, result, nil, nil)
+ response := accessLogFilter.OnResponse(context.TODO(), result, nil, nil)
assert.Equal(t, result, response)
}
diff --git a/filter/filter_impl/active_filter_test.go b/filter/filter_impl/active_filter_test.go
index 9837a49c72e28c7a7209f8af6059bdc30c222cc2..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)
@@ -65,7 +65,7 @@ func TestActiveFilterOnResponse(t *testing.T) {
result := &protocol.RPCResult{
Err: errors.New("test"),
}
- filter.OnResponse(nil, result, invoker, invoc)
+ filter.OnResponse(context.TODO(), result, invoker, invoc)
methodStatus := protocol.GetMethodStatus(url, "test")
urlStatus := protocol.GetURLStatus(url)
diff --git a/filter/filter_impl/auth/default_authenticator.go b/filter/filter_impl/auth/default_authenticator.go
index 5b86fc148e42b6364bcb0752c31bfbbc3cfa2b9d..7c7131c9cf1a4abba7b2ec1b4282b49b15f3c8b9 100644
--- a/filter/filter_impl/auth/default_authenticator.go
+++ b/filter/filter_impl/auth/default_authenticator.go
@@ -69,7 +69,7 @@ func getSignature(url *common.URL, invocation protocol.Invocation, secrectKey st
requestString := fmt.Sprintf(constant.SIGNATURE_STRING_FORMAT,
url.ColonSeparatedKey(), invocation.MethodName(), secrectKey, currentTime)
var signature string
- if parameterEncrypt := url.GetParamBool(constant.PARAMTER_SIGNATURE_ENABLE_KEY, false); parameterEncrypt {
+ if parameterEncrypt := url.GetParamBool(constant.PARAMETER_SIGNATURE_ENABLE_KEY, false); parameterEncrypt {
var err error
if signature, err = SignWithParams(invocation.Arguments(), requestString, secrectKey); err != nil {
// TODO
diff --git a/filter/filter_impl/auth/default_authenticator_test.go b/filter/filter_impl/auth/default_authenticator_test.go
index 37c7e9d1837a183e72db1134506cc3f89611ac76..d915b6a16ee5ccd15a390059d74e108bdf4c2bce 100644
--- a/filter/filter_impl/auth/default_authenticator_test.go
+++ b/filter/filter_impl/auth/default_authenticator_test.go
@@ -39,7 +39,7 @@ func TestDefaultAuthenticator_Authenticate(t *testing.T) {
secret := "dubbo-sk"
access := "dubbo-ak"
testurl, _ := common.NewURL("dubbo://127.0.0.1:20000/com.ikurento.user.UserProvider?interface=com.ikurento.user.UserProvider&group=gg&version=2.6.0")
- testurl.SetParam(constant.PARAMTER_SIGNATURE_ENABLE_KEY, "true")
+ testurl.SetParam(constant.PARAMETER_SIGNATURE_ENABLE_KEY, "true")
testurl.SetParam(constant.ACCESS_KEY_ID_KEY, access)
testurl.SetParam(constant.SECRET_ACCESS_KEY_KEY, secret)
parmas := []interface{}{"OK", struct {
@@ -77,7 +77,7 @@ func TestDefaultAuthenticator_Sign(t *testing.T) {
testurl, _ := common.NewURL("dubbo://127.0.0.1:20000/com.ikurento.user.UserProvider?application=test&interface=com.ikurento.user.UserProvider&group=gg&version=2.6.0")
testurl.SetParam(constant.ACCESS_KEY_ID_KEY, "akey")
testurl.SetParam(constant.SECRET_ACCESS_KEY_KEY, "skey")
- testurl.SetParam(constant.PARAMTER_SIGNATURE_ENABLE_KEY, "false")
+ testurl.SetParam(constant.PARAMETER_SIGNATURE_ENABLE_KEY, "false")
inv := invocation.NewRPCInvocation("test", []interface{}{"OK"}, nil)
_ = authenticator.Sign(inv, testurl)
assert.NotEqual(t, inv.AttachmentsByKey(constant.REQUEST_SIGNATURE_KEY, ""), "")
@@ -113,12 +113,13 @@ func Test_getAccessKeyPairFailed(t *testing.T) {
common.WithParamsValue(constant.SECRET_ACCESS_KEY_KEY, "skey"),
common.WithParamsValue(constant.ACCESS_KEY_ID_KEY, "akey"), common.WithParamsValue(constant.ACCESS_KEY_STORAGE_KEY, "dubbo"))
_, e = getAccessKeyPair(invcation, testurl)
+ assert.NoError(t, e)
}
func Test_getSignatureWithinParams(t *testing.T) {
testurl, _ := common.NewURL("dubbo://127.0.0.1:20000/com.ikurento.user.UserProvider?interface=com.ikurento.user.UserProvider&group=gg&version=2.6.0")
- testurl.SetParam(constant.PARAMTER_SIGNATURE_ENABLE_KEY, "true")
+ testurl.SetParam(constant.PARAMETER_SIGNATURE_ENABLE_KEY, "true")
inv := invocation.NewRPCInvocation("test", []interface{}{"OK"}, map[string]interface{}{
"": "",
})
@@ -134,7 +135,7 @@ func Test_getSignatureWithinParams(t *testing.T) {
func Test_getSignature(t *testing.T) {
testurl, _ := common.NewURL("dubbo://127.0.0.1:20000/com.ikurento.user.UserProvider?interface=com.ikurento.user.UserProvider&group=gg&version=2.6.0")
- testurl.SetParam(constant.PARAMTER_SIGNATURE_ENABLE_KEY, "false")
+ testurl.SetParam(constant.PARAMETER_SIGNATURE_ENABLE_KEY, "false")
inv := invocation.NewRPCInvocation("test", []interface{}{"OK"}, nil)
secret := "dubbo"
current := strconv.Itoa(int(time.Now().Unix() * 1000))
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.go b/filter/filter_impl/execute_limit_filter.go
index 5fc309cfb49fbeef5e933a84c1b80654087da701..35611611c8a716c3799d85e4c31fd3440b3611ef 100644
--- a/filter/filter_impl/execute_limit_filter.go
+++ b/filter/filter_impl/execute_limit_filter.go
@@ -84,7 +84,7 @@ func (ef *ExecuteLimitFilter) Invoke(ctx context.Context, invoker protocol.Invok
methodConfigPrefix := "methods." + invocation.MethodName() + "."
ivkURL := invoker.GetUrl()
limitTarget := ivkURL.ServiceKey()
- limitRateConfig := constant.DEFAULT_EXECUTE_LIMIT
+ var limitRateConfig string
methodLevelConfig := ivkURL.GetParam(methodConfigPrefix+constant.EXECUTE_LIMIT_KEY, "")
if len(methodLevelConfig) > 0 {
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/generic_service_filter_test.go b/filter/filter_impl/generic_service_filter_test.go
index 8b2fb549c299bb6c1cf65c4254ba6784caec5655..c755a2d28080e8c6a56e742181b944d299e493ed 100644
--- a/filter/filter_impl/generic_service_filter_test.go
+++ b/filter/filter_impl/generic_service_filter_test.go
@@ -125,7 +125,7 @@ func TestGenericServiceFilterResponseTestStruct(t *testing.T) {
filter := GetGenericServiceFilter()
methodName := "$invoke"
rpcInvocation := invocation.NewRPCInvocation(methodName, aurguments, nil)
- r := filter.OnResponse(nil, result, nil, rpcInvocation)
+ r := filter.OnResponse(context.TODO(), result, nil, rpcInvocation)
assert.NotNil(t, r.Result())
assert.Equal(t, reflect.ValueOf(r.Result()).Kind(), reflect.Map)
}
@@ -143,7 +143,7 @@ func TestGenericServiceFilterResponseString(t *testing.T) {
filter := GetGenericServiceFilter()
methodName := "$invoke"
rpcInvocation := invocation.NewRPCInvocation(methodName, aurguments, nil)
- r := filter.OnResponse(nil, result, nil, rpcInvocation)
+ r := filter.OnResponse(context.TODO(), result, nil, rpcInvocation)
assert.NotNil(t, r.Result())
assert.Equal(t, reflect.ValueOf(r.Result()).Kind(), reflect.String)
}
diff --git a/filter/filter_impl/graceful_shutdown_filter_test.go b/filter/filter_impl/graceful_shutdown_filter_test.go
index 447a557ad5f508bf444ccae5dacb8a8559c933ea..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)
@@ -65,7 +63,8 @@ func TestGenericFilterInvoke(t *testing.T) {
shutdownFilter.shutdownConfig = providerConfig.ShutdownConfig
assert.True(t, shutdownFilter.rejectNewRequest())
- result = shutdownFilter.OnResponse(nil, nil, protocol.NewBaseInvoker(invokeUrl), invoc)
+ result = shutdownFilter.OnResponse(context.Background(), nil, protocol.NewBaseInvoker(invokeUrl), invoc)
+ assert.Nil(t, result)
rejectHandler := &common2.OnlyLogRejectedExecutionHandler{}
extension.SetRejectedExecutionHandler("mock", func() filter.RejectedExecutionHandler {
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 3787a0284f5470282c14c8b1a0aaf0187d6239e3..1de27adbac1808dbbbf8017f0119077752191d6f 100644
--- a/filter/filter_impl/sentinel_filter.go
+++ b/filter/filter_impl/sentinel_filter.go
@@ -205,8 +205,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/sentinel_filter_test.go b/filter/filter_impl/sentinel_filter_test.go
index a1ca21ce6c634b9647e586df0ac97a51d3fae7cc..c6b6d4280f08099ce3eef8bf1e5a3c37e9e67c59 100644
--- a/filter/filter_impl/sentinel_filter_test.go
+++ b/filter/filter_impl/sentinel_filter_test.go
@@ -50,11 +50,11 @@ func TestSentinelFilter_QPS(t *testing.T) {
_, err = flow.LoadRules([]*flow.Rule{
{
- Resource: interfaceResourceName,
+ Resource: interfaceResourceName,
//MetricType: flow.QPS,
TokenCalculateStrategy: flow.Direct,
ControlBehavior: flow.Reject,
- Threshold: 100,
+ Threshold: 100,
RelationStrategy: flow.CurrentResource,
},
})
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_limit_sliding_window_strategy.go b/filter/filter_impl/tps/tps_limit_sliding_window_strategy.go
index cbbba19fff65be222cb895dcbe9b2e4d02082985..bc78f6471bda2c87d9e82eccdf73700547454340 100644
--- a/filter/filter_impl/tps/tps_limit_sliding_window_strategy.go
+++ b/filter/filter_impl/tps/tps_limit_sliding_window_strategy.go
@@ -54,7 +54,7 @@ type SlidingWindowTpsLimitStrategyImpl struct {
queue *list.List
}
-// IsAllowable determins whether the number of requests within the time window overs the threshold
+// IsAllowable determines whether the number of requests within the time window overs the threshold
// It is thread-safe.
func (impl *SlidingWindowTpsLimitStrategyImpl) IsAllowable() bool {
impl.mutex.Lock()
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/go.mod b/go.mod
index e822ab4cf352c5808747f358dc831071cf6a4906..9b9255d20d0980453cd870c0ad68dacceffd0b7a 100644
--- a/go.mod
+++ b/go.mod
@@ -8,12 +8,12 @@ require (
github.com/Workiva/go-datastructures v1.0.52
github.com/afex/hystrix-go v0.0.0-20180502004556-fa1af6a1f4f5
github.com/alibaba/sentinel-golang v1.0.1
- github.com/apache/dubbo-getty v1.3.10
+ github.com/apache/dubbo-getty v1.4.1
github.com/apache/dubbo-go-hessian2 v1.8.0
github.com/coreos/etcd v3.3.25+incompatible
github.com/creasty/defaults v1.5.1
github.com/dubbogo/go-zookeeper v1.0.2
- github.com/dubbogo/gost v1.9.5
+ github.com/dubbogo/gost v1.10.1
github.com/elazarl/go-bindata-assetfs v1.0.0 // indirect
github.com/emicklei/go-restful/v3 v3.4.0
github.com/frankban/quicktest v1.4.1 // indirect
diff --git a/go.sum b/go.sum
index 7b1c1716aa6701a495dbed2f54d411927c7bd890..cd5e3b45fbea0c07f0b0c532b03e08bcf00e9731 100644
--- a/go.sum
+++ b/go.sum
@@ -64,6 +64,8 @@ github.com/Shopify/sarama v1.19.0/go.mod h1:FVkBWblsNy7DGZRfXLU0O9RCGt5g3g3yEuWX
github.com/Shopify/toxiproxy v2.1.4+incompatible/go.mod h1:OXgGpZ6Cli1/URJOF1DMxUHB2q5Ap20/P/eIdh4G0pI=
github.com/StackExchange/wmi v0.0.0-20180116203802-5d049714c4a6 h1:fLjPD/aNc3UIOA6tDi6QXUemppXK3P9BI7mr2hd6gx8=
github.com/StackExchange/wmi v0.0.0-20180116203802-5d049714c4a6/go.mod h1:3eOhrUMpNV+6aFIbp5/iudMxNCF27Vw2OZgy4xEx0Fg=
+github.com/StackExchange/wmi v0.0.0-20190523213315-cbe66965904d h1:G0m3OIz70MZUWq3EgK3CesDbo8upS2Vm9/P3FtgI+Jk=
+github.com/StackExchange/wmi v0.0.0-20190523213315-cbe66965904d/go.mod h1:3eOhrUMpNV+6aFIbp5/iudMxNCF27Vw2OZgy4xEx0Fg=
github.com/VividCortex/gohistogram v1.0.0/go.mod h1:Pf5mBqqDxYaXu3hDrrU+w6nw50o/4+TcAqDqk/vUH7g=
github.com/Workiva/go-datastructures v1.0.52 h1:PLSK6pwn8mYdaoaCZEMsXBpBotr4HHn9abU0yMQt0NI=
github.com/Workiva/go-datastructures v1.0.52/go.mod h1:Z+F2Rca0qCsVYDS8z7bAGm8f3UkzuWYS/oBZz5a7VVA=
@@ -80,8 +82,8 @@ github.com/alibaba/sentinel-golang v1.0.1 h1:WlhN0XUxRyfkiDc8TO6CcRrnakwFP9zFtvJ
github.com/alibaba/sentinel-golang v1.0.1/go.mod h1:QsB99f/z35D2AiMrAWwgWE85kDTkBUIkcmPrRt+61NI=
github.com/aliyun/alibaba-cloud-sdk-go v1.61.18 h1:zOVTBdCKFd9JbCKz9/nt+FovbjPFmb7mUnp8nH9fQBA=
github.com/aliyun/alibaba-cloud-sdk-go v1.61.18/go.mod h1:v8ESoHo4SyHmuB4b1tJqDHxfTGEciD+yhvOU/5s1Rfk=
-github.com/apache/dubbo-getty v1.3.10 h1:ys5mwjPdxG/KwkPjS6EI0RzQtU6p6FCPoKpaFEzpAL0=
-github.com/apache/dubbo-getty v1.3.10/go.mod h1:x6rraK01BL5C7jUM2fPl5KMkAxLVIx54ZB8/XEOik9Y=
+github.com/apache/dubbo-getty v1.4.1 h1:M9yaFhemThQSWtRwmJNrxNuv7FzydlFx5EY8oq1v+lw=
+github.com/apache/dubbo-getty v1.4.1/go.mod h1:ansXgKxxyhCOiQL29nO5ce1MDcEKmCyZuNR9oMs3hek=
github.com/apache/dubbo-go-hessian2 v1.8.0 h1:+GJQHxWd/WUw2p4hbfCal/zjKvGVb8yJZzOke8IEazc=
github.com/apache/dubbo-go-hessian2 v1.8.0/go.mod h1:7rEw9guWABQa6Aqb8HeZcsYPHsOS7XT1qtJvkmI6c5w=
github.com/apache/thrift v0.12.0/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb+bacwQ=
@@ -173,8 +175,9 @@ github.com/docker/spdystream v0.0.0-20160310174837-449fdfce4d96/go.mod h1:Qh8CwZ
github.com/dubbogo/go-zookeeper v1.0.2 h1:xmEnPL8SlCe3/+J5ZR9e8qE35LmFVYe8VVpDakjNM4A=
github.com/dubbogo/go-zookeeper v1.0.2/go.mod h1:fn6n2CAEer3novYgk9ULLwAjuV8/g4DdC2ENwRb6E+c=
github.com/dubbogo/gost v1.9.0/go.mod h1:pPTjVyoJan3aPxBPNUX0ADkXjPibLo+/Ib0/fADXSG8=
-github.com/dubbogo/gost v1.9.5 h1:UeG4y0O55lR3dzgdmCm/7bMWvpKrlpR7fsfKjrcXq/g=
-github.com/dubbogo/gost v1.9.5/go.mod h1:QNM5RaeRdNWehUu8S0hUP5Qa8QUfGf6KH1JhqOVFvEI=
+github.com/dubbogo/gost v1.10.1 h1:39kF9Cd5JOiMpmwG6dX1/aLWNFqFv9gHp8HrhzMmjLY=
+github.com/dubbogo/gost v1.10.1/go.mod h1:+mQGS51XQEUWZP2JeGZTxJwipjRKtJO7Tr+FOg+72rI=
+github.com/dubbogo/jsonparser v1.0.1/go.mod h1:tYAtpctvSP/tWw4MeelsowSPgXQRVHHWbqL6ynps8jU=
github.com/dustin/go-humanize v0.0.0-20171111073723-bb3d318650d4/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
github.com/dustin/go-humanize v1.0.0 h1:VSnTsYCnlFHaM2/igO1h6X3HA71jcobQuxemgkq4zYo=
github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
@@ -233,6 +236,8 @@ github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG
github.com/go-logr/logr v0.1.0/go.mod h1:ixOQHD9gLJUVQQ2ZOR7zLEifBX6tGkNJF4QyIY7sIas=
github.com/go-ole/go-ole v1.2.1 h1:2lOsA72HgjxAuMlKpFiCbHTvu44PIVkZ5hqm3RSdI/E=
github.com/go-ole/go-ole v1.2.1/go.mod h1:7FAglXiTm7HKlQRDeOQ6ZNUHidzCWXuZWq/1dTyBNF8=
+github.com/go-ole/go-ole v1.2.4 h1:nNBDSCOigTSiarFpYE9J/KtEA1IOW4CNeqT9TQDqCxI=
+github.com/go-ole/go-ole v1.2.4/go.mod h1:XCwSNxSkXRo4vlyPy93sltvi/qJq0jqQhjqQNIwKuxM=
github.com/go-openapi/jsonpointer v0.0.0-20160704185906-46af16f9f7b1/go.mod h1:+35s3my2LFTysnkMfxsJBAMHj/DoqoB9knIWoYG/Vk0=
github.com/go-openapi/jsonreference v0.0.0-20160704190145-13c6e3589ad9/go.mod h1:W3Z9FmVs9qj+KR4zFKmDPGiLdk1D9Rlm7cyMvf57TTg=
github.com/go-openapi/spec v0.0.0-20160808142527-6aced65f8501/go.mod h1:J8+jY1nAiCcj+friV/PDoE1/3eeccG9LYBs0tYvLOWc=
@@ -689,6 +694,7 @@ github.com/sean-/pager v0.0.0-20180208200047-666be9bf53b5/go.mod h1:BeybITEsBEg6
github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529 h1:nn5Wsu0esKSJiIVhscUtVbo7ada43DJhG55ua/hjS5I=
github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc=
github.com/shirou/gopsutil v0.0.0-20181107111621-48177ef5f880/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA=
+github.com/shirou/gopsutil v3.20.11-0.20201116082039-2fb5da2f2449+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA=
github.com/shirou/gopsutil v3.20.11+incompatible h1:LJr4ZQK4mPpIV5gOa4jCOKOGb4ty4DZO54I4FGqIpto=
github.com/shirou/gopsutil v3.20.11+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA=
github.com/shirou/w32 v0.0.0-20160930032740-bb4de0191aa4/go.mod h1:qsXQc7+bwAM3Q1u/4XEfrquwF8Lw7D7y5cD8CuHnfIc=
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 efd16bdc6dad555f5a99bc4b2a02ee2a08202537..d21cc88a3d31ec2920a78c608ed13a491fd6c634 100644
--- a/metadata/service/remote/service.go
+++ b/metadata/service/remote/service.go
@@ -107,7 +107,9 @@ func (mts *MetadataService) SubscribeURL(url *common.URL) (bool, error) {
// UnsubscribeURL will be implemented by in memory service
func (mts *MetadataService) UnsubscribeURL(url *common.URL) error {
- return mts.UnsubscribeURL(url)
+ // TODO remove call self.
+ return nil
+ //return mts.UnsubscribeURL(url)
}
// PublishServiceDefinition will call remote metadata's StoreProviderMetadata to store url info and service definition
@@ -186,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 5e859a7fa2254ba0e4806bc60c037c47777bc641..21376c3145d7d620d7fc12f2bc67efcd65faee4b 100644
--- a/protocol/dubbo/dubbo_codec.go
+++ b/protocol/dubbo/dubbo_codec.go
@@ -105,7 +105,7 @@ func (c *DubboCodec) EncodeRequest(request *remoting.Request) (*bytes.Buffer, er
return pkg.Marshal()
}
-// encode heartbeart request
+// encode heartbeat request
func (c *DubboCodec) encodeHeartbeartReqeust(request *remoting.Request) (*bytes.Buffer, error) {
header := impl.DubboHeader{
Type: impl.PackageHeartbeat,
@@ -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
@@ -238,7 +235,6 @@ func (c *DubboCodec) decodeRequest(data []byte) (*remoting.Request, int, error)
func (c *DubboCodec) decodeResponse(data []byte) (*remoting.Response, int, error) {
buf := bytes.NewBuffer(data)
pkg := impl.NewDubboPackage(buf)
- response := &remoting.Response{}
err := pkg.Unmarshal()
if err != nil {
originErr := perrors.Cause(err)
@@ -250,7 +246,7 @@ func (c *DubboCodec) decodeResponse(data []byte) (*remoting.Response, int, error
return nil, 0, perrors.WithStack(err)
}
- response = &remoting.Response{
+ response := &remoting.Response{
ID: pkg.Header.ID,
//Version: pkg.Header.,
SerialID: pkg.Header.SerialID,
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_dubbo.go b/protocol/dubbo/hessian2/hessian_dubbo.go
index 1afa4ec96eccbb8077852dfcc020e0eb05be3257..5ffebde54b951997057a1f161dbcf6aae1d4a7fd 100644
--- a/protocol/dubbo/hessian2/hessian_dubbo.go
+++ b/protocol/dubbo/hessian2/hessian_dubbo.go
@@ -99,7 +99,7 @@ func (h *HessianCodec) Write(service Service, header DubboHeader, body interface
return packResponse(header, body)
default:
- return nil, perrors.Errorf("Unrecognised message type: %v", header.Type)
+ return nil, perrors.Errorf("Unrecognized message type: %v", header.Type)
}
// unreachable return nil, nil
@@ -190,9 +190,9 @@ func (h *HessianCodec) ReadBody(rspObj interface{}) error {
switch h.pkgType & PackageType_BitSize {
case PackageResponse | PackageHeartbeat | PackageResponse_Exception, PackageResponse | PackageResponse_Exception:
decoder := hessian.NewDecoder(buf[:])
- exception, err := decoder.Decode()
- if err != nil {
- return perrors.WithStack(err)
+ exception, exceptionErr := decoder.Decode()
+ if exceptionErr != nil {
+ return perrors.WithStack(exceptionErr)
}
rsp, ok := rspObj.(*DubboResponse)
if !ok {
diff --git a/protocol/dubbo/hessian2/hessian_dubbo_test.go b/protocol/dubbo/hessian2/hessian_dubbo_test.go
index 13dab92ba874fb5d746c5d57134592865cbfc7bd..eaaf500738e6c77142b0c0cb267fb0d8e7ac1437 100644
--- a/protocol/dubbo/hessian2/hessian_dubbo_test.go
+++ b/protocol/dubbo/hessian2/hessian_dubbo_test.go
@@ -80,6 +80,7 @@ func doTestHessianEncodeHeader(t *testing.T, packageType PackageType, responseSt
func doTestResponse(t *testing.T, packageType PackageType, responseStatus byte, body interface{}, decodedResponse *DubboResponse, assertFunc func()) {
resp, err := doTestHessianEncodeHeader(t, packageType, responseStatus, body)
+ assert.NoError(t, err)
codecR := NewHessianCodec(bufio.NewReader(bytes.NewReader(resp)))
@@ -163,6 +164,7 @@ func TestResponse(t *testing.T) {
func doTestRequest(t *testing.T, packageType PackageType, responseStatus byte, body interface{}) {
resp, err := doTestHessianEncodeHeader(t, packageType, responseStatus, body)
+ assert.NoError(t, err)
codecR := NewHessianCodec(bufio.NewReader(bytes.NewReader(resp)))
diff --git a/protocol/dubbo/hessian2/hessian_request.go b/protocol/dubbo/hessian2/hessian_request.go
index 4ebb4aa1be05d4d1941661fed452dda06cf55fa0..94aa34dee895bc8d441f710edecabe0326da1400 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,31 @@ func packRequest(service Service, header DubboHeader, req interface{}) ([]byte,
// body
//////////////////////////////////////////
if hb {
- encoder.Encode(nil)
+ _ = encoder.Encode(nil)
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 +259,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/codec.go b/protocol/dubbo/impl/codec.go
index 17e7b57b45f2334e06b757ee07e3a9ef034c920a..6c9816f0ff9a4faee7750d16468fa65b9aa803f2 100644
--- a/protocol/dubbo/impl/codec.go
+++ b/protocol/dubbo/impl/codec.go
@@ -146,7 +146,7 @@ func (c *ProtocolCodec) Encode(p DubboPackage) ([]byte, error) {
return packResponse(p, c.serializer)
default:
- return nil, perrors.Errorf("Unrecognised message type: %v", header.Type)
+ return nil, perrors.Errorf("Unrecognized message type: %v", header.Type)
}
}
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/main.go b/protocol/grpc/protoc-gen-dubbo/main.go
index fbcfa6f9d492afa8bc7848c733358b3cf7223e99..fe3e38dddd8bfc2a30ed89e6088516cad120ef79 100644
--- a/protocol/grpc/protoc-gen-dubbo/main.go
+++ b/protocol/grpc/protoc-gen-dubbo/main.go
@@ -43,7 +43,7 @@ func main() {
g.Error(err, "reading input")
}
- if err := proto.Unmarshal(data, g.Request); err != nil {
+ if err = proto.Unmarshal(data, g.Request); err != nil {
g.Error(err, "parsing input proto")
}
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..11051df8ac05010e9e07fe14d44768dda9342201 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/protocol/rest/server/rest_server.go b/protocol/rest/server/rest_server.go
index 3a1cb19396b1c129aa836e228991a22426065f4a..b0bf0e07bdd2c1351b1d9c1f55187515e3cc852c 100644
--- a/protocol/rest/server/rest_server.go
+++ b/protocol/rest/server/rest_server.go
@@ -257,6 +257,7 @@ func assembleArgsFromQueryParams(methodConfig *rest_config.RestMethodConfig, arg
kind := t.Kind()
if kind == reflect.Ptr {
t = t.Elem()
+ kind = t.Kind()
}
if kind == reflect.Slice {
param = req.QueryParameters(v)
@@ -297,6 +298,7 @@ func assembleArgsFromPathParams(methodConfig *rest_config.RestMethodConfig, args
kind := t.Kind()
if kind == reflect.Ptr {
t = t.Elem()
+ kind = t.Kind()
}
if kind == reflect.Int {
param, err = strconv.Atoi(req.PathParameter(v))
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 a6693be3a862eb208afc216840910c323b8e826f..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
@@ -273,6 +272,10 @@ func (r *BaseRegistry) processURL(c *common.URL, f func(string, string) error, c
default:
return perrors.Errorf("@c{%v} type is not referencer or provider", c)
}
+ if err != nil {
+ return perrors.WithMessagef(err, "@c{%v} registry fail", c)
+ }
+
encodedURL = url.QueryEscape(rawURL)
dubboPath = strings.ReplaceAll(dubboPath, "$", "%24")
err = f(dubboPath, encodedURL)
diff --git a/registry/consul/registry.go b/registry/consul/registry.go
index 0b7ba9758952b072d579ae9424e2c385e59a4378..869e1c1d75769447f8e3d2c0fb7817b1dc2db163 100644
--- a/registry/consul/registry.go
+++ b/registry/consul/registry.go
@@ -193,7 +193,7 @@ func (r *consulRegistry) Destroy() {
go func() {
defer func() {
if e := recover(); e != nil {
- logger.Errorf("consulRegistry destory with panic: %v", e)
+ logger.Errorf("consulRegistry destroy with panic: %v", e)
}
done <- struct{}{}
}()
diff --git a/registry/consul/service_discovery.go b/registry/consul/service_discovery.go
index d8ab93f31ee6fdcf79aa869a35548e8192841fe4..fba142e04e4979b9c4fe123cc121111838ae2d4e 100644
--- a/registry/consul/service_discovery.go
+++ b/registry/consul/service_discovery.go
@@ -27,7 +27,7 @@ import (
import (
"github.com/dubbogo/gost/container/set"
- "github.com/dubbogo/gost/page"
+ "github.com/dubbogo/gost/hash/page"
consul "github.com/hashicorp/consul/api"
"github.com/hashicorp/consul/api/watch"
perrors "github.com/pkg/errors"
@@ -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
@@ -339,7 +339,7 @@ func (csd *consulServiceDiscovery) GetInstancesByPage(serviceName string, offset
for i := offset; i < len(all) && i < offset+pageSize; i++ {
res = append(res, all[i])
}
- return gxpage.New(offset, pageSize, res, len(all))
+ return gxpage.NewPage(offset, pageSize, res, len(all))
}
func (csd *consulServiceDiscovery) GetHealthyInstancesByPage(serviceName string, offset int, pageSize int, healthy bool) gxpage.Pager {
@@ -358,7 +358,7 @@ func (csd *consulServiceDiscovery) GetHealthyInstancesByPage(serviceName string,
}
i++
}
- return gxpage.New(offset, pageSize, res, len(all))
+ return gxpage.NewPage(offset, pageSize, res, len(all))
}
func (csd *consulServiceDiscovery) GetRequestInstances(serviceNames []string, offset int, requestedSize int) map[string]gxpage.Pager {
@@ -444,7 +444,7 @@ func (csd *consulServiceDiscovery) buildRegisterInstance(instance registry.Servi
metadata = encodeConsulMetadata(metadata)
metadata[enable] = strconv.FormatBool(instance.IsEnable())
// check
- check := csd.buildCheck(instance)
+ check := csd.buildCheck()
return &consul.AgentServiceRegistration{
ID: buildID(instance),
@@ -456,12 +456,7 @@ func (csd *consulServiceDiscovery) buildRegisterInstance(instance registry.Servi
}, nil
}
-func (csd *consulServiceDiscovery) buildCheck(instance registry.ServiceInstance) consul.AgentServiceCheck {
-
- deregister, ok := instance.GetMetadata()[constant.DEREGISTER_AFTER]
- if !ok || len(deregister) == 0 {
- deregister = constant.DEFAULT_DEREGISTER_TIME
- }
+func (csd *consulServiceDiscovery) buildCheck() consul.AgentServiceCheck {
return consul.AgentServiceCheck{
TTL: strconv.FormatInt(csd.checkPassInterval/1000, 10) + "s",
DeregisterCriticalServiceAfter: csd.deregisterCriticalServiceAfter,
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 ed1d8fb3cd310f4c0fd67d3d80f2c8ffe931ffaa..1b607351af0b527f9ace4fa77268e100aa8fa2dc 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..ca6016e49b4e174e5843b3c08beea7b559bbfb9b 100644
--- a/registry/etcdv3/service_discovery.go
+++ b/registry/etcdv3/service_discovery.go
@@ -26,7 +26,7 @@ import (
import (
gxset "github.com/dubbogo/gost/container/set"
- gxpage "github.com/dubbogo/gost/page"
+ gxpage "github.com/dubbogo/gost/hash/page"
"github.com/hashicorp/vault/sdk/helper/jsonutil"
perrors "github.com/pkg/errors"
)
@@ -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
@@ -177,7 +180,7 @@ func (e *etcdV3ServiceDiscovery) GetInstancesByPage(serviceName string, offset i
res = append(res, all[i])
}
- return gxpage.New(offset, pageSize, res, len(all))
+ return gxpage.NewPage(offset, pageSize, res, len(all))
}
// GetHealthyInstancesByPage will return a page containing instances of ServiceInstance.
@@ -199,7 +202,7 @@ func (e *etcdV3ServiceDiscovery) GetHealthyInstancesByPage(serviceName string, o
}
i++
}
- return gxpage.New(offset, pageSize, res, len(all))
+ return gxpage.NewPage(offset, pageSize, res, len(all))
}
// Batch get all instances by the specified service names
@@ -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/event/event_publishing_service_deiscovery_test.go b/registry/event/event_publishing_service_deiscovery_test.go
index 54752c03c0de598226270b27c8d7d0f3621d07d1..504f7b5faed374795bd534c9e97cf5b42fc94d4c 100644
--- a/registry/event/event_publishing_service_deiscovery_test.go
+++ b/registry/event/event_publishing_service_deiscovery_test.go
@@ -24,7 +24,7 @@ import (
import (
gxset "github.com/dubbogo/gost/container/set"
- gxpage "github.com/dubbogo/gost/page"
+ gxpage "github.com/dubbogo/gost/hash/page"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/suite"
)
diff --git a/registry/event/event_publishing_service_discovery.go b/registry/event/event_publishing_service_discovery.go
index 3ee2f4a44946065cdf7489abc391df41f251d810..773eee6e83c6b3e24c293053b55b028d0e7b2e9a 100644
--- a/registry/event/event_publishing_service_discovery.go
+++ b/registry/event/event_publishing_service_discovery.go
@@ -19,7 +19,7 @@ package event
import (
gxset "github.com/dubbogo/gost/container/set"
- gxpage "github.com/dubbogo/gost/page"
+ gxpage "github.com/dubbogo/gost/hash/page"
)
import (
diff --git a/registry/file/service_discovery.go b/registry/file/service_discovery.go
index 254c12688f47282343e0004dac86844ba51a3eb2..c3b77f6849c7566496d1b8e6f900dd48ac128b8a 100644
--- a/registry/file/service_discovery.go
+++ b/registry/file/service_discovery.go
@@ -28,7 +28,7 @@ import (
import (
gxset "github.com/dubbogo/gost/container/set"
- gxpage "github.com/dubbogo/gost/page"
+ gxpage "github.com/dubbogo/gost/hash/page"
perrors "github.com/pkg/errors"
)
@@ -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..c4a0352cfaa3273c92296be6279c0aae71f0448b 100644
--- a/registry/kubernetes/registry.go
+++ b/registry/kubernetes/registry.go
@@ -19,7 +19,6 @@ package kubernetes
import (
"fmt"
- "os"
"path"
"sync"
"time"
@@ -40,11 +39,6 @@ import (
"github.com/apache/dubbo-go/remoting/kubernetes"
)
-var (
- processID = ""
- localIP = ""
-)
-
const (
Name = "kubernetes"
ConnDelay = 3
@@ -52,8 +46,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/kubernetes/registry_test.go b/registry/kubernetes/registry_test.go
index 9fb409a222be914cad5b64e7ff3aab9bc97a6f33..a816b035c593b444665d3f259b17af1d4e5d53eb 100644
--- a/registry/kubernetes/registry_test.go
+++ b/registry/kubernetes/registry_test.go
@@ -280,7 +280,7 @@ func TestSubscribe(t *testing.T) {
defer wg.Done()
registerErr := r.Register(url)
if registerErr != nil {
- t.Fatal(registerErr)
+ t.Error(registerErr)
}
}()
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..4533e7bc6b1427f1713e8b61bf2f125c0d0bde99 100644
--- a/registry/nacos/service_discovery.go
+++ b/registry/nacos/service_discovery.go
@@ -24,7 +24,7 @@ import (
import (
"github.com/dubbogo/gost/container/set"
- "github.com/dubbogo/gost/page"
+ "github.com/dubbogo/gost/hash/page"
"github.com/nacos-group/nacos-sdk-go/clients/naming_client"
"github.com/nacos-group/nacos-sdk-go/model"
"github.com/nacos-group/nacos-sdk-go/vo"
@@ -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 {
@@ -175,7 +175,7 @@ func (n *nacosServiceDiscovery) GetInstancesByPage(serviceName string, offset in
for i := offset; i < len(all) && i < offset+pageSize; i++ {
res = append(res, all[i])
}
- return gxpage.New(offset, pageSize, res, len(all))
+ return gxpage.NewPage(offset, pageSize, res, len(all))
}
// GetHealthyInstancesByPage will return the instance
@@ -198,7 +198,7 @@ func (n *nacosServiceDiscovery) GetHealthyInstancesByPage(serviceName string, of
}
i++
}
- return gxpage.New(offset, pageSize, res, len(all))
+ return gxpage.NewPage(offset, pageSize, res, len(all))
}
// GetRequestInstances will return the 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_discovery.go b/registry/service_discovery.go
index cb7a3c0182ff88995ab9dd6c920523225c3cb36c..5ab768351508ed289cbe9b17a75ea9b8e95fff72 100644
--- a/registry/service_discovery.go
+++ b/registry/service_discovery.go
@@ -23,7 +23,7 @@ import (
import (
gxset "github.com/dubbogo/gost/container/set"
- gxpage "github.com/dubbogo/gost/page"
+ gxpage "github.com/dubbogo/gost/hash/page"
)
const DefaultPageSize = 100
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..391d92c8ad19c871756ca7426531bb01a7d54876 100644
--- a/registry/servicediscovery/service_discovery_registry_test.go
+++ b/registry/servicediscovery/service_discovery_registry_test.go
@@ -23,7 +23,7 @@ import (
import (
"github.com/dubbogo/gost/container/set"
- "github.com/dubbogo/gost/page"
+ "github.com/dubbogo/gost/hash/page"
"github.com/stretchr/testify/assert"
)
import (
@@ -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..3232ee624de909320b129a15adebef5aec5108ac 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 (
@@ -251,8 +251,7 @@ func (r *zkRegistry) getListener(conf *common.URL) (*RegistryConfigurationListen
dataListener.mutex.Lock()
defer dataListener.mutex.Unlock()
if r.dataListener.subscribed[conf.ServiceKey()] != nil {
-
- zkListener, _ := r.dataListener.subscribed[conf.ServiceKey()].(*RegistryConfigurationListener)
+ zkListener, _ = r.dataListener.subscribed[conf.ServiceKey()].(*RegistryConfigurationListener)
if zkListener != nil {
r.listenerLock.Lock()
defer r.listenerLock.Unlock()
@@ -284,7 +283,11 @@ func (r *zkRegistry) getListener(conf *common.URL) (*RegistryConfigurationListen
//Interested register to dataconfig.
r.dataListener.SubscribeURL(conf, zkListener)
- go r.listener.ListenServiceEvent(conf, fmt.Sprintf("/dubbo/%s/"+constant.DEFAULT_CATEGORY, url.QueryEscape(conf.Service())), r.dataListener)
+ go r.listener.ListenServiceEvent(
+ conf,
+ fmt.Sprintf("/dubbo/%s/"+constant.DEFAULT_CATEGORY, url.QueryEscape(conf.Service())),
+ r.dataListener,
+ )
return zkListener, nil
}
@@ -295,9 +298,9 @@ func (r *zkRegistry) getCloseListener(conf *common.URL) (*RegistryConfigurationL
r.dataListener.mutex.Lock()
configurationListener := r.dataListener.subscribed[conf.ServiceKey()]
if configurationListener != nil {
- zkListener, _ := configurationListener.(*RegistryConfigurationListener)
- if zkListener != nil {
- if zkListener.isClosed {
+ rcListener, _ := configurationListener.(*RegistryConfigurationListener)
+ if rcListener != nil {
+ if rcListener.isClosed {
r.dataListener.mutex.Unlock()
return nil, perrors.New("configListener already been closed")
}
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..095a78dc3c1650197ba1ded75218e8fd0020b6ea 100644
--- a/registry/zookeeper/service_discovery.go
+++ b/registry/zookeeper/service_discovery.go
@@ -27,7 +27,7 @@ import (
import (
"github.com/dubbogo/gost/container/set"
- "github.com/dubbogo/gost/page"
+ "github.com/dubbogo/gost/hash/page"
perrors "github.com/pkg/errors"
)
@@ -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 {
@@ -231,7 +231,7 @@ func (zksd *zookeeperServiceDiscovery) GetInstancesByPage(serviceName string, of
for i := offset; i < len(all) && i < offset+pageSize; i++ {
res = append(res, all[i])
}
- return gxpage.New(offset, pageSize, res, len(all))
+ return gxpage.NewPage(offset, pageSize, res, len(all))
}
// GetHealthyInstancesByPage will return the instance
@@ -254,7 +254,7 @@ func (zksd *zookeeperServiceDiscovery) GetHealthyInstancesByPage(serviceName str
}
i++
}
- return gxpage.New(offset, pageSize, res, len(all))
+ return gxpage.NewPage(offset, pageSize, res, len(all))
}
// GetRequestInstances will return the instances
diff --git a/registry/zookeeper/service_discovery_test.go b/registry/zookeeper/service_discovery_test.go
index ea3c7ddd48adc0adc4162d8306d28283575f694a..c9e14afd50af36e5e729f0efb768b37c56f0adf3 100644
--- a/registry/zookeeper/service_discovery_test.go
+++ b/registry/zookeeper/service_discovery_test.go
@@ -75,10 +75,14 @@ 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() {
+ _ = sd.Destroy()
+ }()
md := make(map[string]string)
md["t1"] = "test1"
err = sd.Register(®istry.DefaultServiceInstance{
@@ -140,10 +144,14 @@ 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() {
+ _ = sd.Destroy()
+ }()
err = sd.Register(®istry.DefaultServiceInstance{
Id: "testId",
@@ -154,8 +162,6 @@ func TestAddListenerZookeeperServiceDiscovery(t *testing.T) {
Healthy: true,
Metadata: nil,
})
- assert.Nil(t, err)
-
assert.Nil(t, err)
wg := &sync.WaitGroup{}
wg.Add(1)
@@ -170,7 +176,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 +187,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 3de266f42ffbc69a1e2ba4662a9a9fff1d831cd4..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() {
@@ -298,7 +297,7 @@ func (suite *ClientTestSuite) TestClientWatch() {
wc, err := c.watch(prefix)
if err != nil {
- t.Fatal(err)
+ t.Error(err)
}
events := make([]mvccpb.Event, 0)
@@ -358,7 +357,7 @@ func (suite *ClientTestSuite) TestClientRegisterTemp() {
completePath := path.Join("scott", "wang")
wc, err := observeC.watch(completePath)
if err != nil {
- t.Fatal(err)
+ t.Error(err)
}
events := make([]mvccpb.Event, 0)
diff --git a/remoting/getty/dubbo_codec_for_test.go b/remoting/getty/dubbo_codec_for_test.go
index fca5da89643adee2f5e6c1e8dca8ec3da4c987e4..9afc18a9aaf477588a2fbf051096494b6f887fa2 100644
--- a/remoting/getty/dubbo_codec_for_test.go
+++ b/remoting/getty/dubbo_codec_for_test.go
@@ -99,7 +99,7 @@ func (c *DubboTestCodec) EncodeRequest(request *remoting.Request) (*bytes.Buffer
return pkg.Marshal()
}
-// encode heartbeart request
+// encode heartbeat request
func (c *DubboTestCodec) encodeHeartbeartReqeust(request *remoting.Request) (*bytes.Buffer, error) {
header := impl.DubboHeader{
Type: impl.PackageHeartbeat,
@@ -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
@@ -230,7 +227,6 @@ func (c *DubboTestCodec) decodeRequest(data []byte) (*remoting.Request, int, err
func (c *DubboTestCodec) decodeResponse(data []byte) (*remoting.Response, int, error) {
buf := bytes.NewBuffer(data)
pkg := impl.NewDubboPackage(buf)
- response := &remoting.Response{}
err := pkg.Unmarshal()
if err != nil {
originErr := perrors.Cause(err)
@@ -240,7 +236,7 @@ func (c *DubboTestCodec) decodeResponse(data []byte) (*remoting.Response, int, e
}
return nil, 0, perrors.WithStack(err)
}
- response = &remoting.Response{
+ response := &remoting.Response{
ID: pkg.Header.ID,
//Version: pkg.Header.,
SerialID: pkg.Header.SerialID,
diff --git a/remoting/getty/getty_client.go b/remoting/getty/getty_client.go
index e432ca55a9bfb32575fad183f93438b8cb7801fb..57221cc6d7f2b9668e6a0518b6678b37e4924bf1 100644
--- a/remoting/getty/getty_client.go
+++ b/remoting/getty/getty_client.go
@@ -38,14 +38,12 @@ 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")
+ errClientReadTimeout = perrors.New("maybe the client read timeout or fail to decode tcp stream in Writer.Write")
clientConf *ClientConfig
- clientGrpool *gxsync.TaskPool
+ clientGrpool gxsync.GenericTaskPool
)
// it is init client for single protocol.
@@ -101,16 +99,13 @@ func SetClientConf(c ClientConfig) {
}
func setClientGrpool() {
- if clientConf.GrPoolSize > 1 {
- clientGrpool = gxsync.NewTaskPool(gxsync.WithTaskPoolTaskPoolSize(clientConf.GrPoolSize), gxsync.WithTaskPoolTaskQueueLength(clientConf.QueueLen),
- gxsync.WithTaskPoolTaskQueueNumber(clientConf.QueueNumber))
- }
+ clientGrpool = gxsync.NewTaskPoolSimple(clientConf.GrPoolSize)
}
// Options : param config
type Options struct {
// connect timeout
- // remove request timeout, it will be calulate for every request
+ // remove request timeout, it will be calculate for every request
ConnectTimeout time.Duration
// request timeout
RequestTimeout time.Duration
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/getty_server.go b/remoting/getty/getty_server.go
index 620a01d83b11e4dd4db0dc25bc8f5759d3a64579..4930a6ad0ee0dbcde50a16e8df6b6245fb87a617 100644
--- a/remoting/getty/getty_server.go
+++ b/remoting/getty/getty_server.go
@@ -41,8 +41,7 @@ import (
)
var (
- srvConf *ServerConfig
- srvGrpool *gxsync.TaskPool
+ srvConf *ServerConfig
)
func initServer(protocol string) {
@@ -76,7 +75,6 @@ func initServer(protocol string) {
if err := srvConf.CheckValidity(); err != nil {
panic(err)
}
- SetServerGrpool()
}
// SetServerConfig set dubbo server config.
@@ -87,7 +85,6 @@ func SetServerConfig(s ServerConfig) {
logger.Warnf("[ServerConfig CheckValidity] error: %v", err)
return
}
- SetServerGrpool()
}
// GetServerConfig get getty server config.
@@ -95,17 +92,6 @@ func GetServerConfig() ServerConfig {
return *srvConf
}
-// SetServerGrpool set getty server GrPool
-func SetServerGrpool() {
- if srvConf.GrPoolSize > 1 {
- srvGrpool = gxsync.NewTaskPool(
- gxsync.WithTaskPoolTaskPoolSize(srvConf.GrPoolSize),
- gxsync.WithTaskPoolTaskQueueLength(srvConf.QueueLen),
- gxsync.WithTaskPoolTaskQueueNumber(srvConf.QueueNumber),
- )
- }
-}
-
// Server define getty server
type Server struct {
conf ServerConfig
@@ -151,16 +137,14 @@ func (s *Server) newSession(session getty.Session) error {
session.SetMaxMsgLen(conf.GettySessionParam.MaxMsgLen)
session.SetPkgHandler(NewRpcServerPackageHandler(s))
session.SetEventListener(s.rpcHandler)
- session.SetWQLen(conf.GettySessionParam.PkgWQSize)
session.SetReadTimeout(conf.GettySessionParam.tcpReadTimeout)
session.SetWriteTimeout(conf.GettySessionParam.tcpWriteTimeout)
session.SetCronPeriod((int)(conf.heartbeatPeriod.Nanoseconds() / 1e6))
session.SetWaitTime(conf.GettySessionParam.waitTimeout)
logger.Debugf("server accepts new session:%s\n", session.Stat())
- session.SetTaskPool(srvGrpool)
return nil
}
- if tcpConn, ok = session.Conn().(*net.TCPConn); !ok {
+ if _, ok = session.Conn().(*net.TCPConn); !ok {
panic(fmt.Sprintf("%s, session.conn{%#v} is not tcp connection\n", session.Stat(), session.Conn()))
}
@@ -192,13 +176,11 @@ func (s *Server) newSession(session getty.Session) error {
session.SetMaxMsgLen(conf.GettySessionParam.MaxMsgLen)
session.SetPkgHandler(NewRpcServerPackageHandler(s))
session.SetEventListener(s.rpcHandler)
- session.SetWQLen(conf.GettySessionParam.PkgWQSize)
session.SetReadTimeout(conf.GettySessionParam.tcpReadTimeout)
session.SetWriteTimeout(conf.GettySessionParam.tcpWriteTimeout)
session.SetCronPeriod((int)(conf.heartbeatPeriod.Nanoseconds() / 1e6))
session.SetWaitTime(conf.GettySessionParam.waitTimeout)
logger.Debugf("server accepts new session: %s", session.Stat())
- session.SetTaskPool(srvGrpool)
return nil
}
@@ -210,17 +192,15 @@ func (s *Server) Start() {
)
addr = s.addr
+ serverOpts := []getty.ServerOption{getty.WithLocalAddress(addr)}
if s.conf.SSLEnabled {
- tcpServer = getty.NewTCPServer(
- getty.WithLocalAddress(addr),
- getty.WithServerSslEnabled(s.conf.SSLEnabled),
- getty.WithServerTlsConfigBuilder(config.GetServerTlsConfigBuilder()),
- )
- } else {
- tcpServer = getty.NewTCPServer(
- getty.WithLocalAddress(addr),
- )
+ serverOpts = append(serverOpts, getty.WithServerSslEnabled(s.conf.SSLEnabled),
+ getty.WithServerTlsConfigBuilder(config.GetServerTlsConfigBuilder()))
}
+
+ serverOpts = append(serverOpts, getty.WithServerTaskPool(gxsync.NewTaskPoolSimple(s.conf.GrPoolSize)))
+
+ tcpServer = getty.NewTCPServer(serverOpts...)
tcpServer.RunEventLoop(s.newSession)
logger.Debugf("s bind addr{%s} ok!", s.addr)
s.tcpServer = tcpServer
diff --git a/remoting/getty/listener.go b/remoting/getty/listener.go
index b2f7790f2ffcab6832224e07219016cb46a3fa4d..fd4c4898f2a74fae0cca1cf6c2e86e3e2f75017e 100644
--- a/remoting/getty/listener.go
+++ b/remoting/getty/listener.go
@@ -101,7 +101,7 @@ func (h *RpcClientHandler) OnMessage(session getty.Session, pkg interface{}) {
logger.Errorf("illegal package")
return
}
- // get heartbeart request from server
+ // get heartbeat request from server
if result.IsRequest {
req := result.Result.(*remoting.Request)
if req.Event {
@@ -114,12 +114,12 @@ func (h *RpcClientHandler) OnMessage(session getty.Session, pkg interface{}) {
reply(session, resp)
return
}
- logger.Errorf("illegal request but not heartbeart. {%#v}", req)
+ logger.Errorf("illegal request but not heartbeat. {%#v}", req)
return
}
h.timeoutTimes = 0
p := result.Result.(*remoting.Response)
- // get heartbeart
+ // get heartbeat
if p.Event {
logger.Debugf("get rpc heartbeat response{%#v}", p)
if p.Error != nil {
@@ -138,7 +138,7 @@ func (h *RpcClientHandler) OnMessage(session getty.Session, pkg interface{}) {
// OnCron check the session health periodic. if the session's sessionTimeout has reached, just close the session
func (h *RpcClientHandler) OnCron(session getty.Session) {
- rpcSession, err := h.conn.getClientRpcSession(session)
+ rs, err := h.conn.getClientRpcSession(session)
if err != nil {
logger.Errorf("client.getClientSession(session{%s}) = error{%v}",
session.Stat(), perrors.WithStack(err))
@@ -146,7 +146,7 @@ func (h *RpcClientHandler) OnCron(session getty.Session) {
}
if h.conn.pool.rpcClient.conf.sessionTimeout.Nanoseconds() < time.Since(session.GetActive()).Nanoseconds() {
logger.Warnf("session{%s} timeout{%s}, reqNum{%d}",
- session.Stat(), time.Since(session.GetActive()).String(), rpcSession.reqNum)
+ session.Stat(), time.Since(session.GetActive()).String(), rs.reqNum)
h.conn.removeSession(session) // -> h.conn.close() -> h.conn.pool.remove(h.conn)
return
}
@@ -237,8 +237,8 @@ func (h *RpcServerHandler) OnMessage(session getty.Session, pkg interface{}) {
}
h.rwlock.Unlock()
- decodeResult, ok := pkg.(remoting.DecodeResult)
- if !ok {
+ decodeResult, drOK := pkg.(remoting.DecodeResult)
+ if !drOK {
logger.Errorf("illegal package{%#v}", pkg)
return
}
@@ -252,7 +252,7 @@ func (h *RpcServerHandler) OnMessage(session getty.Session, pkg interface{}) {
res.Handle()
return
}
- logger.Errorf("illegal package but not heartbeart. {%#v}", pkg)
+ logger.Errorf("illegal package but not heartbeat. {%#v}", pkg)
return
}
req := decodeResult.Result.(*remoting.Request)
diff --git a/remoting/getty/listener_test.go b/remoting/getty/listener_test.go
index 7e7ac5fed440a02188057d520a944b48c8bf7b64..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
@@ -47,7 +47,7 @@ func TestRebuildCtx(t *testing.T) {
assert.Nil(t, ctx.Value(constant.TRACING_REMOTE_SPAN_CTX))
span, ctx := opentracing.StartSpanFromContext(ctx, "Test-Client")
-
+ assert.NotNil(t, ctx)
err := injectTraceCtx(span, inv)
assert.NoError(t, err)
@@ -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..2b1cdfe2f49bfee0d5291f2eaf4183db71b8aa31 100644
--- a/remoting/getty/pool.go
+++ b/remoting/getty/pool.go
@@ -60,21 +60,20 @@ func newGettyRPCClientConn(pool *gettyRPCClientPool, addr string) (*gettyRPCClie
sslEnabled bool
)
sslEnabled = pool.sslEnabled
+ clientOpts := []getty.ClientOption{
+ getty.WithServerAddress(addr),
+ getty.WithConnectionNumber((int)(pool.rpcClient.conf.ConnectionNum)),
+ getty.WithReconnectInterval(pool.rpcClient.conf.ReconnectInterval),
+ }
if sslEnabled {
- gettyClient = getty.NewTCPClient(
- getty.WithServerAddress(addr),
- getty.WithConnectionNumber((int)(pool.rpcClient.conf.ConnectionNum)),
- getty.WithReconnectInterval(pool.rpcClient.conf.ReconnectInterval),
- getty.WithClientSslEnabled(pool.sslEnabled),
- getty.WithClientTlsConfigBuilder(config.GetClientTlsConfigBuilder()),
- )
- } else {
- gettyClient = getty.NewTCPClient(
- getty.WithServerAddress(addr),
- getty.WithConnectionNumber((int)(pool.rpcClient.conf.ConnectionNum)),
- getty.WithReconnectInterval(pool.rpcClient.conf.ReconnectInterval),
- )
+ clientOpts = append(clientOpts, getty.WithClientSslEnabled(pool.sslEnabled), getty.WithClientTlsConfigBuilder(config.GetClientTlsConfigBuilder()))
+ }
+
+ if clientGrpool != nil {
+ clientOpts = append(clientOpts, getty.WithClientTaskPool(clientGrpool))
}
+
+ gettyClient = getty.NewTCPClient(clientOpts...)
c := &gettyRPCClient{
addr: addr,
pool: pool,
@@ -91,7 +90,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))
}
@@ -136,40 +135,44 @@ func (c *gettyRPCClient) newSession(session getty.Session) error {
session.SetMaxMsgLen(conf.GettySessionParam.MaxMsgLen)
session.SetPkgHandler(NewRpcClientPackageHandler(c.pool.rpcClient))
session.SetEventListener(NewRpcClientHandler(c))
- session.SetWQLen(conf.GettySessionParam.PkgWQSize)
session.SetReadTimeout(conf.GettySessionParam.tcpReadTimeout)
session.SetWriteTimeout(conf.GettySessionParam.tcpWriteTimeout)
session.SetCronPeriod((int)(conf.heartbeatPeriod.Nanoseconds() / 1e6))
session.SetWaitTime(conf.GettySessionParam.waitTimeout)
logger.Debugf("client new session:%s\n", session.Stat())
- session.SetTaskPool(clientGrpool)
return nil
}
if tcpConn, ok = session.Conn().(*net.TCPConn); !ok {
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)
session.SetPkgHandler(NewRpcClientPackageHandler(c.pool.rpcClient))
session.SetEventListener(NewRpcClientHandler(c))
- session.SetWQLen(conf.GettySessionParam.PkgWQSize)
session.SetReadTimeout(conf.GettySessionParam.tcpReadTimeout)
session.SetWriteTimeout(conf.GettySessionParam.tcpWriteTimeout)
session.SetCronPeriod((int)(conf.heartbeatPeriod.Nanoseconds() / 1e6))
session.SetWaitTime(conf.GettySessionParam.waitTimeout)
logger.Debugf("client new session:%s\n", session.Stat())
-
- session.SetTaskPool(clientGrpool)
-
return nil
}
@@ -260,33 +263,29 @@ func (c *gettyRPCClient) updateSession(session getty.Session) {
func (c *gettyRPCClient) getClientRpcSession(session getty.Session) (rpcSession, error) {
var (
- err error
- rpcSession rpcSession
+ err error
+ rs rpcSession
)
c.lock.RLock()
defer c.lock.RUnlock()
if c.sessions == nil {
- return rpcSession, errClientClosed
+ return rs, errClientClosed
}
err = errSessionNotExist
for _, s := range c.sessions {
if s.session == session {
- rpcSession = *s
+ rs = *s
err = nil
break
}
}
- return rpcSession, perrors.WithStack(err)
+ return rs, perrors.WithStack(err)
}
func (c *gettyRPCClient) isAvailable() bool {
- if c.selectSession() == nil {
- return false
- }
-
- return true
+ return c.selectSession() != nil
}
func (c *gettyRPCClient) close() error {
@@ -304,9 +303,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]
}()
@@ -359,16 +356,16 @@ func (p *gettyRPCClientPool) close() {
}
func (p *gettyRPCClientPool) getGettyRpcClient(addr string) (*gettyRPCClient, error) {
- conn, err := p.get()
- if err == nil && conn == nil {
+ conn, connErr := p.get()
+ if connErr == nil && conn == nil {
// create new conn
- rpcClientConn, err := newGettyRPCClientConn(p, addr)
- if err == nil {
+ rpcClientConn, rpcErr := newGettyRPCClientConn(p, addr)
+ if rpcErr == nil {
p.put(rpcClientConn)
}
- return rpcClientConn, perrors.WithStack(err)
+ return rpcClientConn, perrors.WithStack(rpcErr)
}
- return conn, perrors.WithStack(err)
+ return conn, perrors.WithStack(connErr)
}
func (p *gettyRPCClientPool) get() (*gettyRPCClient, error) {
diff --git a/remoting/kubernetes/client.go b/remoting/kubernetes/client.go
index fce9e80eb88b73cfbe96a4aaebeb106a902fe41d..ce6bcccea50643cd49f3f99fcf4b86e73309b28c 100644
--- a/remoting/kubernetes/client.go
+++ b/remoting/kubernetes/client.go
@@ -48,16 +48,16 @@ type Client struct {
// newClient returns Client instance for registry
func newClient(url *common.URL) (*Client, error) {
-
- ctx, cancel := context.WithCancel(context.Background())
-
// read type
r, err := strconv.Atoi(url.GetParams().Get(constant.ROLE_KEY))
if err != nil {
return nil, perrors.WithMessage(err, "atoi role")
}
+ ctx, cancel := context.WithCancel(context.Background())
+
controller, err := newDubboRegistryController(ctx, common.RoleType(r), GetInClusterKubernetesClient)
if err != nil {
+ cancel()
return nil, perrors.WithMessage(err, "new dubbo-registry controller")
}
@@ -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 d6c5a2e88057459c0a87cd9a607e9c10970b07b2..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()
@@ -365,7 +366,7 @@ func TestClientGetChildrenKVList(t *testing.T) {
// start get all children
kList, vList, err := client.GetChildren(prefix)
if err != nil {
- t.Fatal(err)
+ t.Error(err)
}
for i := 0; i < len(kList); i++ {
@@ -392,7 +393,7 @@ func TestClientWatchPrefix(t *testing.T) {
wc, done, err := client.WatchWithPrefix(prefix)
if err != nil {
- t.Fatal(err)
+ t.Error(err)
}
wg.Done()
@@ -435,7 +436,7 @@ func TestClientWatch(t *testing.T) {
wc, done, err := client.Watch(prefix)
if err != nil {
- t.Fatal(err)
+ t.Error(err)
}
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/registry_controller.go b/remoting/kubernetes/registry_controller.go
index 20be0d72ec1ce4c379f44d3218ffbd0cfd3d2a63..f66163d3c68768e99a84fbca0110e099985429be 100644
--- a/remoting/kubernetes/registry_controller.go
+++ b/remoting/kubernetes/registry_controller.go
@@ -442,7 +442,7 @@ func (c *dubboRegistryController) initCurrentPod() error {
return perrors.WithMessage(err, "get patch")
}
- currentPod, err = c.patchCurrentPod(p)
+ _, err = c.patchCurrentPod(p)
if err != nil {
return perrors.WithMessage(err, "patch to current pod")
}
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/nacos/builder_test.go b/remoting/nacos/builder_test.go
index 61d13ef26f9f1d17173bbeb11468f9babdade2f5..48199bea45b85a3929b174af21791e599284c57c 100644
--- a/remoting/nacos/builder_test.go
+++ b/remoting/nacos/builder_test.go
@@ -34,11 +34,13 @@ func TestNewNacosClient(t *testing.T) {
client, err := NewNacosClient(rc)
// address is nil
+ assert.Nil(t, client)
assert.NotNil(t, err)
rc.Address = "console.nacos.io:80:123"
client, err = NewNacosClient(rc)
// invalid address
+ assert.Nil(t, client)
assert.NotNil(t, err)
rc.Address = "console.nacos.io:80"
diff --git a/remoting/zookeeper/client.go b/remoting/zookeeper/client.go
index fbd90762eb34f361a38486ef2d8f5f10699a96f7..852a5564f955e9734be58515cf0e6840e69f2f78 100644
--- a/remoting/zookeeper/client.go
+++ b/remoting/zookeeper/client.go
@@ -128,18 +128,18 @@ func ValidateZookeeperClient(container ZkClientFacade, opts ...Option) error {
if container.ZkClient() == nil {
// in dubbo, every registry only connect one node, so this is []string{r.Address}
- timeout, err := time.ParseDuration(url.GetParam(constant.REGISTRY_TIMEOUT_KEY, constant.DEFAULT_REG_TIMEOUT))
- if err != nil {
- logger.Errorf("timeout config %v is invalid ,err is %v",
- url.GetParam(constant.REGISTRY_TIMEOUT_KEY, constant.DEFAULT_REG_TIMEOUT), err.Error())
- return perrors.WithMessagef(err, "newZookeeperClient(address:%+v)", url.Location)
+ timeout, paramErr := time.ParseDuration(url.GetParam(constant.REGISTRY_TIMEOUT_KEY, constant.DEFAULT_REG_TIMEOUT))
+ if paramErr != nil {
+ logger.Errorf("timeout config %v is invalid, err is %v",
+ url.GetParam(constant.REGISTRY_TIMEOUT_KEY, constant.DEFAULT_REG_TIMEOUT), paramErr.Error())
+ return perrors.WithMessagef(paramErr, "newZookeeperClient(address:%+v)", url.Location)
}
zkAddresses := strings.Split(url.Location, ",")
- newClient, err := NewZookeeperClient(options.zkName, zkAddresses, timeout)
- if err != nil {
+ newClient, cltErr := NewZookeeperClient(options.zkName, zkAddresses, timeout)
+ if cltErr != nil {
logger.Warnf("newZookeeperClient(name{%s}, zk address{%v}, timeout{%d}) = error{%v}",
- options.zkName, url.Location, timeout.String(), err)
- return perrors.WithMessagef(err, "newZookeeperClient(address:%+v)", url.Location)
+ options.zkName, url.Location, timeout.String(), cltErr)
+ return perrors.WithMessagef(cltErr, "newZookeeperClient(address:%+v)", url.Location)
}
container.SetZkClient(newClient)
connected = true
diff --git a/remoting/zookeeper/client_test.go b/remoting/zookeeper/client_test.go
index 34741700ca2a9d86ee5321b0b19ed64b2b1a25a8..3d0949973d0aa01acf5178d20afb854debb5c763 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() {
+ _ = 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() {
+ _ = 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() {
+ _ = 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() {
+ _ = 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..3eda6d9698e5ec244bb6c5763ebc8e459e03310e 100644
--- a/remoting/zookeeper/listener.go
+++ b/remoting/zookeeper/listener.go
@@ -135,9 +135,10 @@ func (l *ZkEventListener) handleZkNodeEvent(zkPath string, children []string, li
newChildren, err := l.client.GetChildren(zkPath)
if err != nil {
if err == errNilChildren {
- content, _, err := l.client.Conn.Get(zkPath)
- if err != nil {
- logger.Errorf("Get new node path {%v} 's content error,message is {%v}", zkPath, perrors.WithStack(err))
+ content, _, connErr := l.client.Conn.Get(zkPath)
+ if connErr != nil {
+ logger.Errorf("Get new node path {%v} 's content error,message is {%v}",
+ zkPath, perrors.WithStack(connErr))
} else {
listener.DataChange(remoting.Event{Path: zkPath, Action: remoting.EventTypeUpdate, Content: string(content)})
}
@@ -158,9 +159,10 @@ func (l *ZkEventListener) handleZkNodeEvent(zkPath string, children []string, li
newNode = path.Join(zkPath, n)
logger.Infof("add zkNode{%s}", newNode)
- content, _, err := l.client.Conn.Get(newNode)
- if err != nil {
- logger.Errorf("Get new node path {%v} 's content error,message is {%v}", newNode, perrors.WithStack(err))
+ content, _, connErr := l.client.Conn.Get(newNode)
+ if connErr != nil {
+ logger.Errorf("Get new node path {%v} 's content error,message is {%v}",
+ newNode, perrors.WithStack(connErr))
}
if !listener.DataChange(remoting.Event{Path: zkPath, Action: remoting.EventTypeAdd, Content: string(content)}) {
@@ -362,9 +364,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)