You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@servicecomb.apache.org by ti...@apache.org on 2021/03/10 04:39:10 UTC

[servicecomb-service-center] branch master updated: refactor, remove unuseful code (#889)

This is an automated email from the ASF dual-hosted git repository.

tianxiaoliang pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/servicecomb-service-center.git


The following commit(s) were added to refs/heads/master by this push:
     new e825d0d  refactor, remove unuseful code (#889)
e825d0d is described below

commit e825d0d32d57d21f2508c81b770beca0e676da16
Author: Shawn <xi...@gmail.com>
AuthorDate: Wed Mar 10 12:39:00 2021 +0800

    refactor, remove unuseful code (#889)
---
 datasource/etcd/client/buildin/buildin.go      |  3 ++-
 datasource/etcd/client/embedded/embededetcd.go |  3 ++-
 datasource/etcd/client/manager.go              | 21 +++++++++++----------
 datasource/etcd/client/options.go              |  5 -----
 datasource/etcd/client/remote/etcd.go          |  3 ++-
 datasource/etcd/client/remote/etcd_test.go     |  5 +++--
 datasource/etcd/client/types.go                |  2 --
 datasource/etcd/etcd.go                        | 15 +++++++--------
 datasource/etcd/sd/aggregate/adaptor.go        |  2 +-
 datasource/etcd/sd/manager.go                  | 12 ++++++------
 datasource/etcd/sd/manager_test.go             |  8 ++++----
 datasource/etcd/sd/options.go                  |  2 +-
 datasource/etcd/sd/types.go                    |  2 +-
 datasource/manager.go                          | 12 ++++++------
 datasource/mongo/heartbeat/common.go           |  2 +-
 datasource/options.go                          |  2 +-
 datasource/types.go                            |  2 +-
 go.mod                                         |  2 +-
 server/server.go                               |  4 ++--
 test/test.go                                   |  2 +-
 20 files changed, 53 insertions(+), 56 deletions(-)

diff --git a/datasource/etcd/client/buildin/buildin.go b/datasource/etcd/client/buildin/buildin.go
index 536b1ec..2945eab 100644
--- a/datasource/etcd/client/buildin/buildin.go
+++ b/datasource/etcd/client/buildin/buildin.go
@@ -19,6 +19,7 @@ package buildin
 
 import (
 	"context"
+	"github.com/apache/servicecomb-service-center/datasource"
 
 	"github.com/apache/servicecomb-service-center/datasource/etcd/client"
 )
@@ -73,7 +74,7 @@ func (ec *Registry) Compact(ctx context.Context, reserve int64) error {
 func (ec *Registry) Close() {
 }
 
-func NewRegistry(opts client.Options) client.Registry {
+func NewRegistry(opts datasource.Options) client.Registry {
 	return &Registry{
 		ready: make(chan int),
 	}
diff --git a/datasource/etcd/client/embedded/embededetcd.go b/datasource/etcd/client/embedded/embededetcd.go
index 6d46aeb..55d9710 100644
--- a/datasource/etcd/client/embedded/embededetcd.go
+++ b/datasource/etcd/client/embedded/embededetcd.go
@@ -21,6 +21,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"github.com/apache/servicecomb-service-center/datasource"
 	"net/url"
 	"strings"
 	"time"
@@ -535,7 +536,7 @@ func callback(action client.ActionType, rev int64, kvs []*mvccpb.KeyValue, cb cl
 	})
 }
 
-func getEmbedInstance(opts client.Options) client.Registry {
+func getEmbedInstance(opts datasource.Options) client.Registry {
 	log.Warnf("enable embedded registry mode")
 
 	hostName := "sc-0"
diff --git a/datasource/etcd/client/manager.go b/datasource/etcd/client/manager.go
index 6aa1888..0a643fc 100644
--- a/datasource/etcd/client/manager.go
+++ b/datasource/etcd/client/manager.go
@@ -19,27 +19,28 @@ package client
 
 import (
 	"fmt"
+	"github.com/apache/servicecomb-service-center/datasource"
 	"time"
 
 	"github.com/apache/servicecomb-service-center/pkg/backoff"
 	"github.com/apache/servicecomb-service-center/pkg/log"
 )
 
-type newClientFunc func(opts Options) Registry
+type newClientFunc func(opts datasource.Options) Registry
 
 var (
-	plugins    = make(map[ImplName]newClientFunc)
+	plugins    = make(map[datasource.Kind]newClientFunc)
 	pluginInst Registry
 )
 
 // load plugins configuration into plugins
 func Install(pluginImplName string, newFunc newClientFunc) {
-	plugins[ImplName(pluginImplName)] = newFunc
+	plugins[datasource.Kind(pluginImplName)] = newFunc
 }
 
 // construct storage plugin instance
 // invoked by sc main process
-func Init(opts Options) error {
+func Init(opts datasource.Options) error {
 	for i := 0; ; i++ {
 		inst, err := New(opts)
 		if err == nil {
@@ -48,21 +49,21 @@ func Init(opts Options) error {
 		}
 
 		t := backoff.GetBackoff().Delay(i)
-		log.Errorf(err, "initialize client[%v] failed, retry after %s", opts.PluginImplName, t)
+		log.Errorf(err, "initialize client[%v] failed, retry after %s", opts.Kind, t)
 		<-time.After(t)
 	}
-	log.Info(fmt.Sprintf("client plugin [%s] enabled", opts.PluginImplName))
+	log.Info(fmt.Sprintf("client plugin [%s] enabled", opts.Kind))
 	return nil
 }
 
-func New(opts Options) (Registry, error) {
-	if opts.PluginImplName == "" {
+func New(opts datasource.Options) (Registry, error) {
+	if opts.Kind == "" {
 		return nil, fmt.Errorf("plugin implement name is nil")
 	}
 
-	f, ok := plugins[opts.PluginImplName]
+	f, ok := plugins[opts.Kind]
 	if !ok {
-		return nil, fmt.Errorf("plugin implement not supported [%s]", opts.PluginImplName)
+		return nil, fmt.Errorf("plugin implement not supported [%s]", opts.Kind)
 	}
 	inst := f(opts)
 	select {
diff --git a/datasource/etcd/client/options.go b/datasource/etcd/client/options.go
index d411d28..da79e1e 100644
--- a/datasource/etcd/client/options.go
+++ b/datasource/etcd/client/options.go
@@ -22,11 +22,6 @@ import (
 	"fmt"
 )
 
-//Options contains configuration for plugins
-type Options struct {
-	PluginImplName ImplName
-}
-
 type PluginOp struct {
 	Action        ActionType
 	Key           []byte
diff --git a/datasource/etcd/client/remote/etcd.go b/datasource/etcd/client/remote/etcd.go
index 1dba232..dc66f1b 100644
--- a/datasource/etcd/client/remote/etcd.go
+++ b/datasource/etcd/client/remote/etcd.go
@@ -21,6 +21,7 @@ import (
 	"crypto/tls"
 	"errors"
 	"fmt"
+	"github.com/apache/servicecomb-service-center/datasource"
 	"net/url"
 	"strconv"
 	"strings"
@@ -878,7 +879,7 @@ func callback(action client.ActionType, rev int64, kvs []*mvccpb.KeyValue, cb cl
 	})
 }
 
-func NewRegistry(opts client.Options) client.Registry {
+func NewRegistry(opts datasource.Options) client.Registry {
 	log.Warnf("enable etcd registry mode")
 
 	inst := &Client{}
diff --git a/datasource/etcd/client/remote/etcd_test.go b/datasource/etcd/client/remote/etcd_test.go
index 8edd930..9fb8fc9 100644
--- a/datasource/etcd/client/remote/etcd_test.go
+++ b/datasource/etcd/client/remote/etcd_test.go
@@ -19,6 +19,7 @@ package remote_test
 import (
 	"context"
 	"fmt"
+	"github.com/apache/servicecomb-service-center/datasource"
 	"strconv"
 	"strings"
 	"sync"
@@ -126,7 +127,7 @@ func TestEtcdClient(t *testing.T) {
 	}
 
 	// base test
-	inst := NewRegistry(client.Options{})
+	inst := NewRegistry(datasource.Options{})
 	if inst == nil || strings.Index(endpoint, FirstEndpoint) < 0 {
 		t.Fatalf("TestEtcdClient failed, %s != %s", FirstEndpoint, endpoint)
 	}
@@ -135,7 +136,7 @@ func TestEtcdClient(t *testing.T) {
 	etcd.Configuration().ClusterAddresses = "x"
 	etcd.Configuration().InitClusterInfo()
 	etcd.Configuration().DialTimeout = dialTimeout
-	inst = NewRegistry(client.Options{})
+	inst = NewRegistry(datasource.Options{})
 	if inst == nil {
 		t.Fatalf("TestEtcdClient failed, %#v", err)
 	}
diff --git a/datasource/etcd/client/types.go b/datasource/etcd/client/types.go
index 7e11995..a36d4b5 100644
--- a/datasource/etcd/client/types.go
+++ b/datasource/etcd/client/types.go
@@ -24,8 +24,6 @@ import (
 	"github.com/coreos/etcd/mvcc/mvccpb"
 )
 
-type ImplName string
-
 type ActionType int
 
 func (at ActionType) String() string {
diff --git a/datasource/etcd/etcd.go b/datasource/etcd/etcd.go
index 096eff7..aa46051 100644
--- a/datasource/etcd/etcd.go
+++ b/datasource/etcd/etcd.go
@@ -65,16 +65,16 @@ func NewDataSource(opts datasource.Options) (datasource.DataSource, error) {
 	registryAddresses := strings.Join(Configuration().RegistryAddresses(), ",")
 	Configuration().SslEnabled = opts.SslEnabled && strings.Contains(strings.ToLower(registryAddresses), "https://")
 
-	if err := inst.initialize(); err != nil {
+	if err := inst.initialize(opts); err != nil {
 		return nil, err
 	}
 	return inst, nil
 }
 
-func (ds *DataSource) initialize() error {
+func (ds *DataSource) initialize(opts datasource.Options) error {
 	ds.initClustersIndex()
 	// init client/sd plugins
-	ds.initPlugins()
+	ds.initPlugins(opts)
 	// Add events handlers
 	event.Initialize()
 	// Wait for kv store ready
@@ -97,14 +97,13 @@ func (ds *DataSource) initClustersIndex() {
 	}
 }
 
-func (ds *DataSource) initPlugins() {
-	kind := config.GetString("registry.kind", "", config.WithStandby("registry_plugin"))
-	err := client.Init(client.Options{PluginImplName: client.ImplName(kind)})
+func (ds *DataSource) initPlugins(opts datasource.Options) {
+	err := client.Init(opts)
 	if err != nil {
 		log.Fatalf(err, "client init failed")
 	}
-	kind = config.GetString("discovery.kind", "", config.WithStandby("discovery_plugin"))
-	err = sd.Init(sd.Options{PluginImplName: sd.ImplName(kind)})
+	kind := config.GetString("discovery.kind", "", config.WithStandby("discovery_plugin"))
+	err = sd.Init(sd.Options{Kind: sd.Kind(kind)})
 	if err != nil {
 		log.Fatalf(err, "sd init failed")
 	}
diff --git a/datasource/etcd/sd/aggregate/adaptor.go b/datasource/etcd/sd/aggregate/adaptor.go
index 113174c..56fc631 100644
--- a/datasource/etcd/sd/aggregate/adaptor.go
+++ b/datasource/etcd/sd/aggregate/adaptor.go
@@ -88,7 +88,7 @@ func NewAggregator(t sd.Type, cfg *sd.Config) *Aggregator {
 	as := &Aggregator{Type: t}
 	for _, name := range repos {
 		// create and get all plugin instances
-		repo, err := sd.New(sd.Options{PluginImplName: sd.ImplName(name)})
+		repo, err := sd.New(sd.Options{Kind: sd.Kind(name)})
 		if err != nil {
 			log.Errorf(err, "failed to new plugin instance[%s]", name)
 			continue
diff --git a/datasource/etcd/sd/manager.go b/datasource/etcd/sd/manager.go
index 1348f50..69d7a00 100644
--- a/datasource/etcd/sd/manager.go
+++ b/datasource/etcd/sd/manager.go
@@ -26,13 +26,13 @@ import (
 type newCacheFunc func(opts Options) AdaptorRepository
 
 var (
-	plugins    = make(map[ImplName]newCacheFunc)
+	plugins    = make(map[Kind]newCacheFunc)
 	pluginInst AdaptorRepository
 )
 
 // load plugins configuration into plugins
 func Install(pluginImplName string, newFunc newCacheFunc) {
-	plugins[ImplName(pluginImplName)] = newFunc
+	plugins[Kind(pluginImplName)] = newFunc
 }
 
 // construct storage plugin instance
@@ -43,18 +43,18 @@ func Init(opts Options) error {
 		return err
 	}
 	pluginInst = inst
-	log.Info(fmt.Sprintf("cache plugin [%s] enabled", opts.PluginImplName))
+	log.Info(fmt.Sprintf("cache plugin [%s] enabled", opts.Kind))
 	return nil
 }
 
 func New(opts Options) (AdaptorRepository, error) {
-	if opts.PluginImplName == "" {
+	if opts.Kind == "" {
 		return nil, fmt.Errorf("plugin implement name is nil")
 	}
 
-	f, ok := plugins[opts.PluginImplName]
+	f, ok := plugins[opts.Kind]
 	if !ok {
-		return nil, fmt.Errorf("plugin implement not supported [%s]", opts.PluginImplName)
+		return nil, fmt.Errorf("plugin implement not supported [%s]", opts.Kind)
 	}
 	inst := f(opts)
 	return inst, nil
diff --git a/datasource/etcd/sd/manager_test.go b/datasource/etcd/sd/manager_test.go
index 7b73621..c997ac6 100644
--- a/datasource/etcd/sd/manager_test.go
+++ b/datasource/etcd/sd/manager_test.go
@@ -28,16 +28,16 @@ import (
 
 func TestInit(t *testing.T) {
 	t.Run("init microservice data source plugin, should not pass", func(t *testing.T) {
-		pluginName := sd.ImplName("unknown")
+		pluginName := sd.Kind("unknown")
 		err := sd.Init(sd.Options{
-			PluginImplName: pluginName,
+			Kind: pluginName,
 		})
 		assert.Error(t, err)
 	})
 	t.Run("install and init microservice data source plugin, should pass", func(t *testing.T) {
-		pluginName := sd.ImplName("etcd")
+		pluginName := sd.Kind("etcd")
 		err := sd.Init(sd.Options{
-			PluginImplName: pluginName,
+			Kind: pluginName,
 		})
 		assert.NoError(t, err)
 	})
diff --git a/datasource/etcd/sd/options.go b/datasource/etcd/sd/options.go
index cd787ac..598c45e 100644
--- a/datasource/etcd/sd/options.go
+++ b/datasource/etcd/sd/options.go
@@ -19,5 +19,5 @@ package sd
 
 //Options contains configuration for plugins
 type Options struct {
-	PluginImplName ImplName
+	Kind Kind
 }
diff --git a/datasource/etcd/sd/types.go b/datasource/etcd/sd/types.go
index 79cf785..13eb99e 100644
--- a/datasource/etcd/sd/types.go
+++ b/datasource/etcd/sd/types.go
@@ -40,7 +40,7 @@ const (
 
 type Type int
 
-type ImplName string
+type Kind string
 
 func (st Type) String() string {
 	if int(st) < 0 {
diff --git a/datasource/manager.go b/datasource/manager.go
index 940ae3d..18aa449 100644
--- a/datasource/manager.go
+++ b/datasource/manager.go
@@ -26,13 +26,13 @@ import (
 type dataSourceEngine func(opts Options) (DataSource, error)
 
 var (
-	plugins        = make(map[ImplName]dataSourceEngine)
+	plugins        = make(map[Kind]dataSourceEngine)
 	dataSourceInst DataSource
 )
 
 // load plugins configuration into plugins
 func Install(pluginImplName string, engineFunc dataSourceEngine) {
-	plugins[ImplName(pluginImplName)] = engineFunc
+	plugins[Kind(pluginImplName)] = engineFunc
 }
 
 // construct storage plugin instance
@@ -49,20 +49,20 @@ func Install(pluginImplName string, engineFunc dataSourceEngine) {
  * })
  */
 func Init(opts Options) error {
-	if opts.PluginImplName == "" {
+	if opts.Kind == "" {
 		return nil
 	}
 
-	dataSourceEngine, ok := plugins[opts.PluginImplName]
+	dataSourceEngine, ok := plugins[opts.Kind]
 	if !ok {
-		return fmt.Errorf("plugin implement not supported [%s]", opts.PluginImplName)
+		return fmt.Errorf("plugin implement not supported [%s]", opts.Kind)
 	}
 	var err error
 	dataSourceInst, err = dataSourceEngine(opts)
 	if err != nil {
 		return err
 	}
-	log.Info(fmt.Sprintf("datasource plugin [%s] enabled", opts.PluginImplName))
+	log.Info(fmt.Sprintf("datasource plugin [%s] enabled", opts.Kind))
 	return nil
 }
 
diff --git a/datasource/mongo/heartbeat/common.go b/datasource/mongo/heartbeat/common.go
index 9d5cb31..2d9b3d6 100644
--- a/datasource/mongo/heartbeat/common.go
+++ b/datasource/mongo/heartbeat/common.go
@@ -21,5 +21,5 @@ import "errors"
 
 var (
 	ErrPluginNameNil    = errors.New("plugin implement name is nil")
-	ErrPluginNotSupport = errors.New("plugin implement not supported [#{opts.PluginImplName}]")
+	ErrPluginNotSupport = errors.New("plugin implement not supported [#{opts.Kind}]")
 )
diff --git a/datasource/options.go b/datasource/options.go
index 6ee2356..b8022b4 100644
--- a/datasource/options.go
+++ b/datasource/options.go
@@ -19,7 +19,7 @@ package datasource
 
 //Options contains configuration for plugins
 type Options struct {
-	PluginImplName ImplName
+	Kind           Kind
 	SslEnabled     bool
 	SchemaEditable bool
 	// InstanceTTL: the default ttl of instance lease
diff --git a/datasource/types.go b/datasource/types.go
index dba8aca..64a470f 100644
--- a/datasource/types.go
+++ b/datasource/types.go
@@ -17,7 +17,7 @@
 
 package datasource
 
-type ImplName string
+type Kind string
 
 type DLockRequest struct {
 	// ID is the lock global unique id
diff --git a/go.mod b/go.mod
index 36914e2..7bca2b1 100644
--- a/go.mod
+++ b/go.mod
@@ -77,4 +77,4 @@ require (
 	k8s.io/client-go v0.17.0
 )
 
-go 1.13
+go 1.16
diff --git a/server/server.go b/server/server.go
index dd22263..ba69652 100644
--- a/server/server.go
+++ b/server/server.go
@@ -108,9 +108,9 @@ func (s *ServiceCenterServer) initEndpoints() {
 
 func (s *ServiceCenterServer) initDatasource() {
 	// init datasource
-	kind := datasource.ImplName(config.GetString("registry.kind", "", config.WithStandby("registry_plugin")))
+	kind := datasource.Kind(config.GetString("registry.kind", "", config.WithStandby("registry_plugin")))
 	if err := datasource.Init(datasource.Options{
-		PluginImplName: kind,
+		Kind:           kind,
 		SslEnabled:     config.GetSSL().SslEnabled,
 		InstanceTTL:    config.GetRegistry().InstanceTTL,
 		SchemaEditable: config.GetRegistry().SchemaEditable,
diff --git a/test/test.go b/test/test.go
index 9ce76f1..df8a2d0 100644
--- a/test/test.go
+++ b/test/test.go
@@ -41,6 +41,6 @@ func init() {
 	} else {
 		archaius.Set("registry.heartbeat.kind", "checker")
 	}
-	datasource.Init(datasource.Options{PluginImplName: datasource.ImplName(t.(string))})
+	datasource.Init(datasource.Options{Kind: datasource.Kind(t.(string))})
 	core.ServiceAPI, core.InstanceAPI = service.AssembleResources()
 }