milvus-io
/
milvus
mirror of https://github.com/milvus-io/milvus.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Etcd config source support TLS (#20874) 

Signed-off-by: Enwei Jiao <enwei.jiao@zilliz.com>

Signed-off-by: Enwei Jiao <enwei.jiao@zilliz.com>
pull/20911/head
Enwei Jiao 2022-11-30 18:23:15 +08:00 committed by GitHub
parent 4c5ffc832c
commit 2ecdb4ba4a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
60 changed files with 716 additions and 144 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
cmd/milvus/mck.go
View File

@ -220,7 +220,14 @@ func (c *mck) connectEctd() {
if c.etcdIP != "" {
etcdCli, err = etcd.GetRemoteEtcdClient([]string{c.etcdIP})
} else {
etcdCli, err = etcd.GetEtcdClient(&c.params.EtcdCfg)
etcdCli, err = etcd.GetEtcdClient(
c.params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
c.params.EtcdCfg.EtcdUseSSL.GetAsBool(),
c.params.EtcdCfg.Endpoints.GetAsStrings(),
c.params.EtcdCfg.EtcdTLSCert.GetValue(),
c.params.EtcdCfg.EtcdTLSKey.GetValue(),
c.params.EtcdCfg.EtcdTLSCACert.GetValue(),
c.params.EtcdCfg.EtcdTLSMinVersion.GetValue())
}
if err != nil {
log.Fatal("failed to connect to etcd", zap.Error(err))

7
cmd/roles/roles.go
View File

@ -223,7 +223,12 @@ func (mr *MilvusRoles) Run(local bool, alias string) {
if params.EtcdCfg.UseEmbedEtcd.GetAsBool() {
// Start etcd server.
etcd.InitEtcdServer(&params.EtcdCfg)
etcd.InitEtcdServer(
params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
params.EtcdCfg.ConfigPath.GetValue(),
params.EtcdCfg.DataDir.GetValue(),
params.EtcdCfg.EtcdLogPath.GetValue(),
params.EtcdCfg.EtcdLogLevel.GetValue())
defer etcd.StopEtcdServer()
}
} else {

9
cmd/tools/migration/backend/etcd.go
View File

@ -19,7 +19,14 @@ func (b etcdBasedBackend) CleanWithPrefix(prefix string) error {
}
func newEtcdBasedBackend(cfg *configs.MilvusConfig) (*etcdBasedBackend, error) {
etcdCli, err := etcd.GetEtcdClient(cfg.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
cfg.EtcdCfg.UseEmbedEtcd.GetAsBool(),
cfg.EtcdCfg.EtcdUseSSL.GetAsBool(),
cfg.EtcdCfg.Endpoints.GetAsStrings(),
cfg.EtcdCfg.EtcdTLSCert.GetValue(),
cfg.EtcdCfg.EtcdTLSKey.GetValue(),
cfg.EtcdCfg.EtcdTLSCACert.GetValue(),
cfg.EtcdCfg.EtcdTLSMinVersion.GetValue())
if err != nil {
return nil, err
}

9
cmd/tools/migration/migration/runner.go
View File

@ -73,7 +73,14 @@ func (r *Runner) WatchSessions() {
}
func (r *Runner) initEtcdCli() {
cli, err := etcd.GetEtcdClient(r.cfg.EtcdCfg)
cli, err := etcd.GetEtcdClient(
r.cfg.EtcdCfg.UseEmbedEtcd.GetAsBool(),
r.cfg.EtcdCfg.EtcdUseSSL.GetAsBool(),
r.cfg.EtcdCfg.Endpoints.GetAsStrings(),
r.cfg.EtcdCfg.EtcdTLSCert.GetValue(),
r.cfg.EtcdCfg.EtcdTLSKey.GetValue(),
r.cfg.EtcdCfg.EtcdTLSCACert.GetValue(),
r.cfg.EtcdCfg.EtcdTLSMinVersion.GetValue())
console.AbnormalExitIf(err, r.backupFinished.Load())
r.etcdCli = cli
}

20
internal/config/etcd_source.go
View File

@ -21,8 +21,8 @@ import (
"fmt"
"strings"
"sync"
"time"
"github.com/milvus-io/milvus/internal/util/etcd"
clientv3 "go.etcd.io/etcd/client/v3"
)
@ -37,11 +37,15 @@ type EtcdSource struct {
eh EventHandler
}
func NewEtcdSource(remoteInfo *EtcdInfo) (*EtcdSource, error) {
etcdCli, err := clientv3.New(clientv3.Config{
Endpoints: remoteInfo.Endpoints,
DialTimeout: 5 * time.Second,
})
func NewEtcdSource(etcdInfo *EtcdInfo) (*EtcdSource, error) {
etcdCli, err := etcd.GetEtcdClient(
etcdInfo.UseEmbed,
etcdInfo.UseSSL,
etcdInfo.Endpoints,
etcdInfo.CertFile,
etcdInfo.KeyFile,
etcdInfo.CaCertFile,
etcdInfo.MinVersion)
if err != nil {
return nil, err
}
@ -49,9 +53,9 @@ func NewEtcdSource(remoteInfo *EtcdInfo) (*EtcdSource, error) {
etcdCli: etcdCli,
ctx: context.Background(),
currentConfig: make(map[string]string),
keyPrefix: remoteInfo.KeyPrefix,
keyPrefix: etcdInfo.KeyPrefix,
}
es.configRefresher = newRefresher(remoteInfo.RefreshInterval, es.refreshConfigurations)
es.configRefresher = newRefresher(etcdInfo.RefreshInterval, es.refreshConfigurations)
return es, nil
}

10
internal/config/source.go
View File

@ -39,8 +39,14 @@ type EventHandler interface {
// EtcdInfo has attribute for config center source initialization
type EtcdInfo struct {
Endpoints []string
KeyPrefix string
UseEmbed bool
UseSSL bool
Endpoints []string
KeyPrefix string
CertFile string
KeyFile string
CaCertFile string
MinVersion string
//Pull Configuration interval, unit is second
RefreshInterval time.Duration

18
internal/datacoord/garbage_collector_test.go
View File

@ -48,7 +48,14 @@ func Test_garbageCollector_basic(t *testing.T) {
meta, err := newMemoryMeta()
assert.Nil(t, err)
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.Nil(t, err)
etcdKV := etcdkv.NewEtcdKV(etcdCli, Params.EtcdCfg.MetaRootPath.GetValue())
segRefer, err := NewSegmentReferenceManager(etcdKV, nil)
@ -110,7 +117,14 @@ func Test_garbageCollector_scan(t *testing.T) {
meta, err := newMemoryMeta()
assert.Nil(t, err)
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.Nil(t, err)
etcdKV := etcdkv.NewEtcdKV(etcdCli, Params.EtcdCfg.MetaRootPath.GetValue())
segRefer, err := NewSegmentReferenceManager(etcdKV, nil)

9
internal/datacoord/segment_reference_manager_test.go
View File

@ -36,7 +36,14 @@ func Test_SegmentReferenceManager(t *testing.T) {
var segRefer *SegmentReferenceManager
var err error
Params.Init()
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.Nil(t, err)
etcdKV := etcdkv.NewEtcdKV(etcdCli, "unittest")

45
internal/datacoord/server_test.go
View File

@ -915,7 +915,14 @@ func TestService_WatchServices(t *testing.T) {
func TestServer_watchQueryCoord(t *testing.T) {
Params.Init()
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.Nil(t, err)
etcdKV := etcdkv.NewEtcdKV(etcdCli, Params.EtcdCfg.MetaRootPath.GetValue())
assert.NotNil(t, etcdKV)
@ -3361,7 +3368,14 @@ func newTestServer(t *testing.T, receiveCh chan any, opts ...Option) *Server {
Params.CommonCfg.DataCoordTimeTick = Params.CommonCfg.DataCoordTimeTick + strconv.Itoa(rand.Int())
factory := dependency.NewDefaultFactory(true)
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.Nil(t, err)
sessKey := path.Join(Params.EtcdCfg.MetaRootPath.GetValue(), sessionutil.DefaultServiceRoot)
_, err = etcdCli.Delete(context.Background(), sessKey, clientv3.WithPrefix())
@ -3400,7 +3414,14 @@ func newTestServerWithMeta(t *testing.T, receiveCh chan any, meta *meta, opts ..
Params.CommonCfg.DataCoordTimeTick = Params.CommonCfg.DataCoordTimeTick + strconv.Itoa(rand.Int())
factory := dependency.NewDefaultFactory(true)
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.Nil(t, err)
sessKey := path.Join(Params.EtcdCfg.MetaRootPath.GetValue(), sessionutil.DefaultServiceRoot)
_, err = etcdCli.Delete(context.Background(), sessKey, clientv3.WithPrefix())
@ -3448,7 +3469,14 @@ func newTestServer2(t *testing.T, receiveCh chan any, opts ...Option) *Server {
Params.CommonCfg.DataCoordTimeTick = Params.CommonCfg.DataCoordTimeTick + strconv.Itoa(rand.Int())
factory := dependency.NewDefaultFactory(true)
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.Nil(t, err)
sessKey := path.Join(Params.EtcdCfg.MetaRootPath.GetValue(), sessionutil.DefaultServiceRoot)
_, err = etcdCli.Delete(context.Background(), sessKey, clientv3.WithPrefix())
@ -3646,7 +3674,14 @@ func testDataCoordBase(t *testing.T, opts ...Option) *Server {
Params.CommonCfg.DataCoordTimeTick = Params.CommonCfg.DataCoordTimeTick + strconv.Itoa(rand.Int())
factory := dependency.NewDefaultFactory(true)
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.Nil(t, err)
sessKey := path.Join(Params.EtcdCfg.MetaRootPath.GetValue(), sessionutil.DefaultServiceRoot)
_, err = etcdCli.Delete(context.Background(), sessKey, clientv3.WithPrefix())

45
internal/datanode/data_node_test.go
View File

@ -84,7 +84,14 @@ func TestDataNode(t *testing.T) {
defer cancel()
node := newIDLEDataNodeMock(ctx, schemapb.DataType_Int64)
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.Nil(t, err)
defer etcdCli.Close()
node.SetEtcdClient(etcdCli)
@ -655,7 +662,14 @@ func TestDataNode(t *testing.T) {
chanName := "fake-by-dev-rootcoord-dml-test-syncsegments-1"
node := newIDLEDataNodeMock(ctx, schemapb.DataType_Int64)
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.Nil(t, err)
defer etcdCli.Close()
node.SetEtcdClient(etcdCli)
@ -750,7 +764,14 @@ func TestDataNode_AddSegment(t *testing.T) {
defer cancel()
node := newIDLEDataNodeMock(ctx, schemapb.DataType_Int64)
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.Nil(t, err)
defer etcdCli.Close()
node.SetEtcdClient(etcdCli)
@ -819,7 +840,14 @@ func TestDataNode_AddSegment(t *testing.T) {
func TestWatchChannel(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
node := newIDLEDataNodeMock(ctx, schemapb.DataType_Int64)
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.Nil(t, err)
defer etcdCli.Close()
node.SetEtcdClient(etcdCli)
@ -1090,7 +1118,14 @@ func TestDataNode_GetComponentStates(t *testing.T) {
}
func TestDataNode_ResendSegmentStats(t *testing.T) {
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.Nil(t, err)
defer etcdCli.Close()
dmChannelName := "fake-by-dev-rootcoord-dml-channel-test-ResendSegmentStats"

9
internal/datanode/flow_graph_manager_test.go
View File

@ -33,7 +33,14 @@ func TestFlowGraphManager(t *testing.T) {
ctx, cancel := context.WithCancel(context.TODO())
defer cancel()
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.Nil(t, err)
defer etcdCli.Close()

9
internal/datanode/mock_test.go
View File

@ -134,7 +134,14 @@ func makeNewChannelNames(names []string, suffix string) []string {
}
func clearEtcd(rootPath string) error {
client, err := etcd.GetEtcdClient(&Params.EtcdCfg)
client, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
if err != nil {
return err
}

9
internal/distributed/datacoord/client/client_test.go
View File

@ -33,7 +33,14 @@ func Test_NewClient(t *testing.T) {
proxy.Params.InitOnce()
ctx := context.Background()
etcdCli, err := etcd.GetEtcdClient(&proxy.Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.Nil(t, err)
client, err := NewClient(ctx, proxy.Params.EtcdCfg.MetaRootPath.GetValue(), etcdCli)
assert.Nil(t, err)

9
internal/distributed/datacoord/service.go
View File

@ -88,7 +88,14 @@ func (s *Server) init() error {
closer := trace.InitTracing("datacoord")
s.closer = closer
etcdCli, err := etcd.GetEtcdClient(&datacoord.Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
if err != nil {
log.Debug("DataCoord connect to etcd failed", zap.Error(err))
return err

9
internal/distributed/datanode/service.go
View File

@ -230,7 +230,14 @@ func (s *Server) init() error {
log.Warn("DataNode found available port during init", zap.Int("port", Params.Port))
}
etcdCli, err := etcd.GetEtcdClient(&dn.Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
if err != nil {
log.Error("failed to connect to etcd", zap.Error(err))
return err

9
internal/distributed/indexcoord/client/client_test.go
View File

@ -44,7 +44,14 @@ func TestIndexCoordClient(t *testing.T) {
server, err := grpcindexcoord.NewServer(ctx, factory)
assert.NoError(t, err)
icm := indexcoord.NewIndexCoordMock()
etcdCli, err := etcd.GetEtcdClient(&ClientParams.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.NoError(t, err)
var address string

9
internal/distributed/indexcoord/service.go
View File

@ -97,7 +97,14 @@ func (s *Server) init() error {
closer := trace.InitTracing("IndexCoord")
s.closer = closer
etcdCli, err := etcd.GetEtcdClient(&indexcoord.Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
if err != nil {
log.Debug("IndexCoord connect to etcd failed", zap.Error(err))
return err

9
internal/distributed/indexnode/client/client_test.go
View File

@ -135,7 +135,14 @@ func TestIndexNodeClient(t *testing.T) {
inm := indexnode.NewIndexNodeMock()
ParamsGlobal.InitOnce()
etcdCli, err := etcd.GetEtcdClient(&ParamsGlobal.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.NoError(t, err)
inm.SetEtcdClient(etcdCli)
err = ins.SetClient(inm)

9
internal/distributed/indexnode/service.go
View File

@ -152,7 +152,14 @@ func (s *Server) init() error {
return err
}
etcdCli, err := etcd.GetEtcdClient(&indexnode.Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
if err != nil {
log.Debug("IndexNode connect to etcd failed", zap.Error(err))
return err

9
internal/distributed/indexnode/service_test.go
View File

@ -45,7 +45,14 @@ func TestIndexNodeServer(t *testing.T) {
inm := indexnode.NewIndexNodeMock()
ParamsGlobal.InitOnce()
etcdCli, err := etcd.GetEtcdClient(&ParamsGlobal.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
ParamsGlobal.EtcdCfg.UseEmbedEtcd.GetAsBool(),
ParamsGlobal.EtcdCfg.EtcdUseSSL.GetAsBool(),
ParamsGlobal.EtcdCfg.Endpoints.GetAsStrings(),
ParamsGlobal.EtcdCfg.EtcdTLSCert.GetValue(),
ParamsGlobal.EtcdCfg.EtcdTLSKey.GetValue(),
ParamsGlobal.EtcdCfg.EtcdTLSCACert.GetValue(),
ParamsGlobal.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.NoError(t, err)
inm.SetEtcdClient(etcdCli)
err = server.SetClient(inm)

9
internal/distributed/proxy/service.go
View File

@ -323,7 +323,14 @@ func (s *Server) init() error {
s.closer = closer
log.Debug("init Proxy's tracer done", zap.String("service name", serviceName))
etcdCli, err := etcd.GetEtcdClient(&proxy.Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
if err != nil {
log.Debug("Proxy connect to etcd failed", zap.Error(err))
return err

9
internal/distributed/querycoord/client/client_test.go
View File

@ -35,7 +35,14 @@ func Test_NewClient(t *testing.T) {
ctx := context.Background()
etcdCli, err := etcd.GetEtcdClient(&proxy.Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.NoError(t, err)
client, err := NewClient(ctx, proxy.Params.EtcdCfg.MetaRootPath.GetValue(), etcdCli)
assert.Nil(t, err)

9
internal/distributed/querycoord/service.go
View File

@ -115,7 +115,14 @@ func (s *Server) init() error {
closer := trace.InitTracing("querycoord")
s.closer = closer
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
if err != nil {
log.Debug("QueryCoord connect to etcd failed", zap.Error(err))
return err

9
internal/distributed/querynode/service.go
View File

@ -100,7 +100,14 @@ func (s *Server) init() error {
log.Debug("QueryNode", zap.Int("port", Params.Port))
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
if err != nil {
log.Debug("QueryNode connect to etcd failed", zap.Error(err))
return err

9
internal/distributed/rootcoord/client/client_test.go
View File

@ -35,7 +35,14 @@ func Test_NewClient(t *testing.T) {
proxy.Params.InitOnce()
ctx := context.Background()
etcdCli, err := etcd.GetEtcdClient(&proxy.Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.NoError(t, err)
client, err := NewClient(ctx, proxy.Params.EtcdCfg.MetaRootPath.GetValue(), etcdCli)
assert.Nil(t, err)

9
internal/distributed/rootcoord/service.go
View File

@ -159,7 +159,14 @@ func (s *Server) init() error {
closer := trace.InitTracing("root_coord")
s.closer = closer
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
if err != nil {
log.Debug("RootCoord connect to etcd failed", zap.Error(err))
return err

9
internal/distributed/rootcoord/service_test.go
View File

@ -184,7 +184,14 @@ func TestRun(t *testing.T) {
rootcoord.Params.BaseTable.Save("etcd.rootPath", rootPath)
rootcoord.Params.Init()
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.Nil(t, err)
sessKey := path.Join(rootcoord.Params.EtcdCfg.MetaRootPath.GetValue(), sessionutil.DefaultServiceRoot)
_, err = etcdCli.Delete(ctx, sessKey, clientv3.WithPrefix())

18
internal/indexcoord/index_coord_test.go
View File

@ -51,7 +51,14 @@ func TestMockEtcd(t *testing.T) {
Params.InitOnce()
Params.BaseTable.Save("etcd.rootPath", "/test/datanode/root/indexcoord-mock")
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.NoError(t, err)
etcdKV := etcdkv.NewEtcdKV(etcdCli, Params.EtcdCfg.MetaRootPath.GetValue())
@ -98,7 +105,14 @@ func testIndexCoord(t *testing.T) {
// first start an IndexNode
inm0 := indexnode.NewIndexNodeMock()
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.NoError(t, err)
// start IndexCoord

1
internal/kv/etcd/embed_etcd_config_test.go
View File

@ -33,7 +33,6 @@ func TestEtcdConfigLoad(te *testing.T) {
param := new(paramtable.ServiceParam)
te.Setenv("etcd.use.embed", "true")
// TODO, not sure if the relative path works for ci environment
te.Setenv("etcd.config.path", "../../../configs/advanced/etcd.yaml")
te.Setenv("etcd.data.dir", "etcd.test.data.dir")

9
internal/kv/etcd/etcd_kv_test.go
View File

@ -40,7 +40,14 @@ func TestMain(m *testing.M) {
}
func TestEtcdKV_Load(te *testing.T) {
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
defer etcdCli.Close()
assert.NoError(te, err)
te.Run("EtcdKV SaveAndLoad", func(t *testing.T) {

9
internal/kv/etcd/metakv_factory.go
View File

@ -50,7 +50,14 @@ func NewMetaKvFactory(rootPath string, etcdCfg *paramtable.EtcdConfig) (kv.MetaK
}
return metaKv, err
}
client, err := etcd.GetEtcdClient(etcdCfg)
client, err := etcd.GetEtcdClient(
etcdCfg.UseEmbedEtcd.GetAsBool(),
etcdCfg.EtcdUseSSL.GetAsBool(),
etcdCfg.Endpoints.GetAsStrings(),
etcdCfg.EtcdTLSCert.GetValue(),
etcdCfg.EtcdTLSKey.GetValue(),
etcdCfg.EtcdTLSCACert.GetValue(),
etcdCfg.EtcdTLSMinVersion.GetValue())
if err != nil {
return nil, err
}

63
internal/metastore/kv/rootcoord/meta_snapshot_test.go
View File

@ -48,7 +48,14 @@ func TestMetaSnapshot(t *testing.T) {
rootPath := fmt.Sprintf("/test/meta/%d", randVal)
tsKey := "timestamp"
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.Nil(t, err)
defer etcdCli.Close()
@ -188,7 +195,14 @@ func TestGetRevOnEtcd(t *testing.T) {
tsKey := "timestamp"
key := path.Join(rootPath, tsKey)
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.Nil(t, err)
defer etcdCli.Close()
@ -232,7 +246,14 @@ func TestLoad(t *testing.T) {
rootPath := fmt.Sprintf("/test/meta/%d", randVal)
tsKey := "timestamp"
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.Nil(t, err)
defer etcdCli.Close()
@ -280,7 +301,14 @@ func TestMultiSave(t *testing.T) {
rootPath := fmt.Sprintf("/test/meta/%d", randVal)
tsKey := "timestamp"
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.Nil(t, err)
defer etcdCli.Close()
@ -344,7 +372,14 @@ func TestMultiSaveAndRemoveWithPrefix(t *testing.T) {
rootPath := fmt.Sprintf("/test/meta/%d", randVal)
tsKey := "timestamp"
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.Nil(t, err)
defer etcdCli.Close()
@ -422,7 +457,14 @@ func TestTsBackward(t *testing.T) {
rootPath := fmt.Sprintf("/test/meta/%d", randVal)
tsKey := "timestamp"
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.Nil(t, err)
defer etcdCli.Close()
@ -449,7 +491,14 @@ func TestFix7150(t *testing.T) {
rootPath := fmt.Sprintf("/test/meta/%d", randVal)
tsKey := "timestamp"
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.Nil(t, err)
defer etcdCli.Close()

27
internal/metastore/kv/rootcoord/suffix_snapshot_test.go
View File

@ -263,7 +263,14 @@ func Test_SuffixSnapshotLoad(t *testing.T) {
rootPath := fmt.Sprintf("/test/meta/%d", randVal)
sep := "_ts"
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
require.Nil(t, err)
defer etcdCli.Close()
etcdkv := etcdkv.NewEtcdKV(etcdCli, rootPath)
@ -315,7 +322,14 @@ func Test_SuffixSnapshotMultiSave(t *testing.T) {
Params.Init()
rootPath := fmt.Sprintf("/test/meta/%d", randVal)
sep := "_ts"
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
require.Nil(t, err)
defer etcdCli.Close()
etcdkv := etcdkv.NewEtcdKV(etcdCli, rootPath)
@ -391,7 +405,14 @@ func Test_SuffixSnapshotMultiSaveAndRemoveWithPrefix(t *testing.T) {
rootPath := fmt.Sprintf("/test/meta/%d", randVal)
sep := "_ts"
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
require.Nil(t, err)
defer etcdCli.Close()
etcdkv := etcdkv.NewEtcdKV(etcdCli, rootPath)

18
internal/proxy/proxy_test.go
View File

@ -282,7 +282,14 @@ func runIndexNode(ctx context.Context, localMsg bool, alias string) *grpcindexno
panic(err)
}
wg.Done()
etcd, err := etcd.GetEtcdClient(&indexnode.Params.EtcdCfg)
etcd, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
if err != nil {
panic(err)
}
@ -496,7 +503,14 @@ func TestProxy(t *testing.T) {
assert.NoError(t, err)
assert.NotNil(t, proxy)
etcdcli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdcli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
defer etcdcli.Close()
assert.NoError(t, err)
proxy.SetEtcdClient(etcdcli)

9
internal/querycoordv2/balance/rowcount_based_balancer_test.go
View File

@ -45,7 +45,14 @@ func (suite *RowCountBasedBalancerTestSuite) SetupSuite() {
func (suite *RowCountBasedBalancerTestSuite) SetupTest() {
var err error
config := GenerateEtcdConfig()
cli, err := etcd.GetEtcdClient(config)
cli, err := etcd.GetEtcdClient(
config.UseEmbedEtcd.GetAsBool(),
config.EtcdUseSSL.GetAsBool(),
config.Endpoints.GetAsStrings(),
config.EtcdTLSCert.GetValue(),
config.EtcdTLSKey.GetValue(),
config.EtcdTLSCACert.GetValue(),
config.EtcdTLSMinVersion.GetValue())
suite.Require().NoError(err)
suite.kv = etcdkv.NewEtcdKV(cli, config.MetaRootPath.GetValue())
suite.broker = meta.NewMockBroker(suite.T())

9
internal/querycoordv2/checkers/channel_checker_test.go
View File

@ -48,7 +48,14 @@ func (suite *ChannelCheckerTestSuite) SetupSuite() {
func (suite *ChannelCheckerTestSuite) SetupTest() {
var err error
config := GenerateEtcdConfig()
cli, err := etcd.GetEtcdClient(config)
cli, err := etcd.GetEtcdClient(
config.UseEmbedEtcd.GetAsBool(),
config.EtcdUseSSL.GetAsBool(),
config.Endpoints.GetAsStrings(),
config.EtcdTLSCert.GetValue(),
config.EtcdTLSKey.GetValue(),
config.EtcdTLSCACert.GetValue(),
config.EtcdTLSMinVersion.GetValue())
suite.Require().NoError(err)
suite.kv = etcdkv.NewEtcdKV(cli, config.MetaRootPath.GetValue())

9
internal/querycoordv2/checkers/segment_checker_test.go
View File

@ -50,7 +50,14 @@ func (suite *SegmentCheckerTestSuite) SetupSuite() {
func (suite *SegmentCheckerTestSuite) SetupTest() {
var err error
config := GenerateEtcdConfig()
cli, err := etcd.GetEtcdClient(config)
cli, err := etcd.GetEtcdClient(
config.UseEmbedEtcd.GetAsBool(),
config.EtcdUseSSL.GetAsBool(),
config.Endpoints.GetAsStrings(),
config.EtcdTLSCert.GetValue(),
config.EtcdTLSKey.GetValue(),
config.EtcdTLSCACert.GetValue(),
config.EtcdTLSMinVersion.GetValue())
suite.Require().NoError(err)
suite.kv = etcdkv.NewEtcdKV(cli, config.MetaRootPath.GetValue())

9
internal/querycoordv2/dist/dist_controller_test.go vendored
View File

@ -51,7 +51,14 @@ func (suite *DistControllerTestSuite) SetupTest() {
var err error
config := GenerateEtcdConfig()
cli, err := etcd.GetEtcdClient(config)
cli, err := etcd.GetEtcdClient(
config.UseEmbedEtcd.GetAsBool(),
config.EtcdUseSSL.GetAsBool(),
config.Endpoints.GetAsStrings(),
config.EtcdTLSCert.GetValue(),
config.EtcdTLSKey.GetValue(),
config.EtcdTLSCACert.GetValue(),
config.EtcdTLSMinVersion.GetValue())
suite.Require().NoError(err)
suite.kv = etcdkv.NewEtcdKV(cli, config.MetaRootPath.GetValue())

9
internal/querycoordv2/job/job_test.go
View File

@ -116,7 +116,14 @@ func (suite *JobSuite) SetupSuite() {
func (suite *JobSuite) SetupTest() {
config := GenerateEtcdConfig()
cli, err := etcd.GetEtcdClient(config)
cli, err := etcd.GetEtcdClient(
config.UseEmbedEtcd.GetAsBool(),
config.EtcdUseSSL.GetAsBool(),
config.Endpoints.GetAsStrings(),
config.EtcdTLSCert.GetValue(),
config.EtcdTLSKey.GetValue(),
config.EtcdTLSCACert.GetValue(),
config.EtcdTLSMinVersion.GetValue())
suite.Require().NoError(err)
suite.kv = etcdkv.NewEtcdKV(cli, config.MetaRootPath.GetValue())

9
internal/querycoordv2/meta/collection_manager_test.go
View File

@ -68,7 +68,14 @@ func (suite *CollectionManagerSuite) SetupSuite() {
func (suite *CollectionManagerSuite) SetupTest() {
var err error
config := GenerateEtcdConfig()
cli, err := etcd.GetEtcdClient(config)
cli, err := etcd.GetEtcdClient(
config.UseEmbedEtcd.GetAsBool(),
config.EtcdUseSSL.GetAsBool(),
config.Endpoints.GetAsStrings(),
config.EtcdTLSCert.GetValue(),
config.EtcdTLSKey.GetValue(),
config.EtcdTLSCACert.GetValue(),
config.EtcdTLSMinVersion.GetValue())
suite.Require().NoError(err)
suite.kv = etcdkv.NewEtcdKV(cli, config.MetaRootPath.GetValue())
suite.store = NewMetaStore(suite.kv)

9
internal/querycoordv2/meta/replica_manager_test.go
View File

@ -51,7 +51,14 @@ func (suite *ReplicaManagerSuite) SetupSuite() {
func (suite *ReplicaManagerSuite) SetupTest() {
var err error
config := GenerateEtcdConfig()
cli, err := etcd.GetEtcdClient(config)
cli, err := etcd.GetEtcdClient(
config.UseEmbedEtcd.GetAsBool(),
config.EtcdUseSSL.GetAsBool(),
config.Endpoints.GetAsStrings(),
config.EtcdTLSCert.GetValue(),
config.EtcdTLSKey.GetValue(),
config.EtcdTLSCACert.GetValue(),
config.EtcdTLSMinVersion.GetValue())
suite.Require().NoError(err)
suite.kv = etcdkv.NewEtcdKV(cli, config.MetaRootPath.GetValue())
suite.store = NewMetaStore(suite.kv)

9
internal/querycoordv2/meta/target_manager_test.go
View File

@ -87,7 +87,14 @@ func (suite *TargetManagerSuite) SetupSuite() {
func (suite *TargetManagerSuite) SetupTest() {
var err error
config := GenerateEtcdConfig()
cli, err := etcd.GetEtcdClient(config)
cli, err := etcd.GetEtcdClient(
config.UseEmbedEtcd.GetAsBool(),
config.EtcdUseSSL.GetAsBool(),
config.Endpoints.GetAsStrings(),
config.EtcdTLSCert.GetValue(),
config.EtcdTLSKey.GetValue(),
config.EtcdTLSCACert.GetValue(),
config.EtcdTLSMinVersion.GetValue())
suite.Require().NoError(err)
suite.kv = etcdkv.NewEtcdKV(cli, config.MetaRootPath.GetValue())

9
internal/querycoordv2/observers/collection_observer_test.go
View File

@ -145,7 +145,14 @@ func (suite *CollectionObserverSuite) SetupTest() {
suite.idAllocator = RandomIncrementIDAllocator()
log.Debug("create embedded etcd KV...")
config := GenerateEtcdConfig()
client, err := etcd.GetEtcdClient(config)
client, err := etcd.GetEtcdClient(
config.UseEmbedEtcd.GetAsBool(),
config.EtcdUseSSL.GetAsBool(),
config.Endpoints.GetAsStrings(),
config.EtcdTLSCert.GetValue(),
config.EtcdTLSKey.GetValue(),
config.EtcdTLSCACert.GetValue(),
config.EtcdTLSMinVersion.GetValue())
suite.Require().NoError(err)
suite.kv = etcdkv.NewEtcdKV(client, Params.EtcdCfg.MetaRootPath.GetValue()+"-"+RandomMetaRootPath())
suite.Require().NoError(err)

9
internal/querycoordv2/observers/leader_observer_test.go
View File

@ -53,7 +53,14 @@ func (suite *LeaderObserverTestSuite) SetupSuite() {
func (suite *LeaderObserverTestSuite) SetupTest() {
var err error
config := GenerateEtcdConfig()
cli, err := etcd.GetEtcdClient(config)
cli, err := etcd.GetEtcdClient(
config.UseEmbedEtcd.GetAsBool(),
config.EtcdUseSSL.GetAsBool(),
config.Endpoints.GetAsStrings(),
config.EtcdTLSCert.GetValue(),
config.EtcdTLSKey.GetValue(),
config.EtcdTLSCACert.GetValue(),
config.EtcdTLSMinVersion.GetValue())
suite.Require().NoError(err)
suite.kv = etcdkv.NewEtcdKV(cli, config.MetaRootPath.GetValue())

9
internal/querycoordv2/observers/target_observer_test.go
View File

@ -58,7 +58,14 @@ func (suite *TargetObserverSuite) SetupSuite() {
func (suite *TargetObserverSuite) SetupTest() {
var err error
config := GenerateEtcdConfig()
cli, err := etcd.GetEtcdClient(config)
cli, err := etcd.GetEtcdClient(
config.UseEmbedEtcd.GetAsBool(),
config.EtcdUseSSL.GetAsBool(),
config.Endpoints.GetAsStrings(),
config.EtcdTLSCert.GetValue(),
config.EtcdTLSKey.GetValue(),
config.EtcdTLSCACert.GetValue(),
config.EtcdTLSMinVersion.GetValue())
suite.Require().NoError(err)
suite.kv = etcdkv.NewEtcdKV(cli, config.MetaRootPath.GetValue())

9
internal/querycoordv2/server_test.go
View File

@ -407,7 +407,14 @@ func newQueryCoord() (*Server, error) {
return nil, err
}
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
if err != nil {
return nil, err
}

9
internal/querycoordv2/services_test.go
View File

@ -109,7 +109,14 @@ func (suite *ServiceSuite) SetupSuite() {
func (suite *ServiceSuite) SetupTest() {
config := params.GenerateEtcdConfig()
cli, err := etcd.GetEtcdClient(config)
cli, err := etcd.GetEtcdClient(
config.UseEmbedEtcd.GetAsBool(),
config.EtcdUseSSL.GetAsBool(),
config.Endpoints.GetAsStrings(),
config.EtcdTLSCert.GetValue(),
config.EtcdTLSKey.GetValue(),
config.EtcdTLSCACert.GetValue(),
config.EtcdTLSMinVersion.GetValue())
suite.Require().NoError(err)
suite.kv = etcdkv.NewEtcdKV(cli, config.MetaRootPath.GetValue())

9
internal/querycoordv2/task/task_test.go
View File

@ -118,7 +118,14 @@ func (suite *TaskSuite) SetupSuite() {
func (suite *TaskSuite) SetupTest() {
config := GenerateEtcdConfig()
cli, err := etcd.GetEtcdClient(config)
cli, err := etcd.GetEtcdClient(
config.UseEmbedEtcd.GetAsBool(),
config.EtcdUseSSL.GetAsBool(),
config.Endpoints.GetAsStrings(),
config.EtcdTLSCert.GetValue(),
config.EtcdTLSKey.GetValue(),
config.EtcdTLSCACert.GetValue(),
config.EtcdTLSMinVersion.GetValue())
suite.Require().NoError(err)
suite.kv = etcdkv.NewEtcdKV(cli, config.MetaRootPath.GetValue())

18
internal/querynode/impl_test.go
View File

@ -444,7 +444,14 @@ func TestImpl_isHealthy(t *testing.T) {
func TestImpl_ShowConfigurations(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.NoError(t, err)
defer etcdCli.Close()
@ -486,7 +493,14 @@ func TestImpl_GetMetrics(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.NoError(t, err)
defer etcdCli.Close()

18
internal/querynode/metrics_info_test.go
View File

@ -39,7 +39,14 @@ func TestGetSystemInfoMetrics(t *testing.T) {
require.NoError(t, err)
defer node.Stop()
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.NoError(t, err)
defer etcdCli.Close()
node.session = sessionutil.NewSession(node.queryNodeLoopCtx, Params.EtcdCfg.MetaRootPath.GetValue(), etcdCli)
@ -67,7 +74,14 @@ func TestGetComponentConfigurationsFailed(t *testing.T) {
require.NoError(t, err)
defer node.Stop()
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.NoError(t, err)
defer etcdCli.Close()
node.session = sessionutil.NewSession(node.queryNodeLoopCtx, Params.EtcdCfg.MetaRootPath.GetValue(), etcdCli)

18
internal/querynode/mock_test.go
View File

@ -530,7 +530,14 @@ func genCollectionMeta(collectionID UniqueID, schema *schemapb.CollectionSchema)
// ---------- unittest util functions ----------
// functions of third-party
func genEtcdKV() (*etcdkv.EtcdKV, error) {
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
if err != nil {
return nil, err
}
@ -1698,7 +1705,14 @@ func saveChangeInfo(key string, value string) error {
func genSimpleQueryNodeWithMQFactory(ctx context.Context, fac dependency.Factory) (*QueryNode, error) {
node := NewQueryNode(ctx, fac)
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
if err != nil {
return nil, err
}

27
internal/querynode/query_node_test.go
View File

@ -84,7 +84,14 @@ func newQueryNodeMock() *QueryNode {
cancel()
}()
}
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
if err != nil {
panic(err)
}
@ -177,7 +184,14 @@ func TestQueryNode_register(t *testing.T) {
require.NoError(t, err)
defer node.Stop()
etcdcli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdcli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.NoError(t, err)
defer etcdcli.Close()
node.SetEtcdClient(etcdcli)
@ -197,7 +211,14 @@ func TestQueryNode_init(t *testing.T) {
require.NoError(t, err)
defer node.Stop()
etcdcli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdcli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.NoError(t, err)
defer etcdcli.Close()
node.SetEtcdClient(etcdcli)

18
internal/rootcoord/proxy_client_manager_test.go
View File

@ -106,7 +106,14 @@ func TestProxyClientManager_GetProxyClients(t *testing.T) {
core, err := NewCore(context.Background(), nil)
assert.Nil(t, err)
cli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
cli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
defer cli.Close()
assert.Nil(t, err)
core.etcdCli = cli
@ -130,7 +137,14 @@ func TestProxyClientManager_AddProxyClient(t *testing.T) {
core, err := NewCore(context.Background(), nil)
assert.Nil(t, err)
cli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
cli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.Nil(t, err)
defer cli.Close()
core.etcdCli = cli

18
internal/rootcoord/proxy_manager_test.go
View File

@ -34,7 +34,14 @@ import (
func TestProxyManager(t *testing.T) {
Params.Init()
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.Nil(t, err)
defer etcdCli.Close()
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
@ -103,7 +110,14 @@ func TestProxyManager(t *testing.T) {
func TestProxyManager_ErrCompacted(t *testing.T) {
Params.Init()
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.Nil(t, err)
defer etcdCli.Close()
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)

9
internal/rootcoord/root_coord_test.go
View File

@ -1336,7 +1336,14 @@ func TestRootcoord_EnableActiveStandby(t *testing.T) {
ctx := context.Background()
coreFactory := dependency.NewDefaultFactory(true)
etcdCli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
assert.NoError(t, err)
defer etcdCli.Close()
core, err := NewCore(ctx, coreFactory)

9
internal/rootcoord/timestamp_bench_test.go
View File

@ -21,7 +21,14 @@ import (
func getTestEtcdCli() *clientv3.Client {
Params.InitOnce()
cli, err := etcd.GetEtcdClient(&Params.EtcdCfg)
cli, err := etcd.GetEtcdClient(
Params.EtcdCfg.UseEmbedEtcd.GetAsBool(),
Params.EtcdCfg.EtcdUseSSL.GetAsBool(),
Params.EtcdCfg.Endpoints.GetAsStrings(),
Params.EtcdCfg.EtcdTLSCert.GetValue(),
Params.EtcdCfg.EtcdTLSKey.GetValue(),
Params.EtcdCfg.EtcdTLSCACert.GetValue(),
Params.EtcdCfg.EtcdTLSMinVersion.GetValue())
if err != nil {
panic(err)
}

25
internal/util/etcd/etcd_server.go
View File

@ -4,7 +4,6 @@ import (
"sync"
"github.com/milvus-io/milvus/internal/log"
"github.com/milvus-io/milvus/internal/util/paramtable"
clientv3 "go.etcd.io/etcd/client/v3"
"go.etcd.io/etcd/server/v3/embed"
"go.etcd.io/etcd/server/v3/etcdserver/api/v3client"
@ -25,11 +24,17 @@ func GetEmbedEtcdClient() (*clientv3.Client, error) {
}
// InitEtcdServer initializes embedded etcd server singleton.
func InitEtcdServer(etcdCfg *paramtable.EtcdConfig) error {
if etcdCfg.UseEmbedEtcd.GetAsBool() {
func InitEtcdServer(
useEmbedEtcd bool,
configPath string,
dataDir string,
logPath string,
logLevel string,
) error {
if useEmbedEtcd {
var initError error
initOnce.Do(func() {
path := etcdCfg.ConfigPath.GetValue()
path := configPath
var cfg *embed.Config
if len(path) > 0 {
cfgFromFile, err := embed.ConfigFromFile(path)
@ -40,22 +45,26 @@ func InitEtcdServer(etcdCfg *paramtable.EtcdConfig) error {
} else {
cfg = embed.NewConfig()
}
cfg.Dir = etcdCfg.DataDir.GetValue()
cfg.LogOutputs = []string{etcdCfg.EtcdLogPath.GetValue()}
cfg.LogLevel = etcdCfg.EtcdLogLevel.GetValue()
cfg.Dir = dataDir
cfg.LogOutputs = []string{logPath}
cfg.LogLevel = logLevel
e, err := embed.StartEtcd(cfg)
if err != nil {
log.Error("failed to init embedded Etcd server", zap.Error(err))
initError = err
}
etcdServer = e
log.Info("finish init Etcd config", zap.String("path", path), zap.String("data", etcdCfg.DataDir.GetValue()))
log.Info("finish init Etcd config", zap.String("path", path), zap.String("data", dataDir))
})
return initError
}
return nil
}
func HasServer() bool {
return etcdServer != nil
}
// StopEtcdServer stops embedded etcd server singleton.
func StopEtcdServer() {
if etcdServer != nil {

18
internal/util/etcd/etcd_util.go
View File

@ -25,7 +25,6 @@ import (
"github.com/pkg/errors"
"github.com/milvus-io/milvus/internal/util/paramtable"
clientv3 "go.etcd.io/etcd/client/v3"
)
@ -34,14 +33,21 @@ var (
)
// GetEtcdClient returns etcd client
func GetEtcdClient(cfg *paramtable.EtcdConfig) (*clientv3.Client, error) {
if cfg.UseEmbedEtcd.GetAsBool() {
func GetEtcdClient(
useEmbedEtcd bool,
useSSL bool,
endpoints []string,
certFile string,
keyFile string,
caCertFile string,
minVersion string) (*clientv3.Client, error) {
if useEmbedEtcd {
return GetEmbedEtcdClient()
}
if cfg.EtcdUseSSL.GetAsBool() {
return GetRemoteEtcdSSLClient(cfg.Endpoints.GetAsStrings(), cfg.EtcdTLSCert.GetValue(), cfg.EtcdTLSKey.GetValue(), cfg.EtcdTLSCACert.GetValue(), cfg.EtcdTLSMinVersion.GetValue())
if useSSL {
return GetRemoteEtcdSSLClient(endpoints, certFile, keyFile, caCertFile, minVersion)
}
return GetRemoteEtcdClient(cfg.Endpoints.GetAsStrings())
return GetRemoteEtcdClient(endpoints)
}
// GetRemoteEtcdClient returns client of remote etcd by given endpoints

45
internal/util/etcd/etcd_util_test.go
View File

@ -19,28 +19,18 @@ package etcd
import (
"context"
"errors"
"os"
"path"
"testing"
"github.com/milvus-io/milvus/internal/util/metricsinfo"
"github.com/milvus-io/milvus/internal/util/paramtable"
"github.com/stretchr/testify/assert"
)
var Params paramtable.ServiceParam
func TestEtcd(t *testing.T) {
t.Setenv(metricsinfo.DeployModeEnvKey, metricsinfo.StandaloneDeployMode)
t.Setenv("ETCD_USE_EMBED", "true")
Params.Init()
Params.BaseTable.Save("etcd.data.dir", "/tmp/data")
err := InitEtcdServer(&Params.EtcdCfg)
err := InitEtcdServer(true, "", "/tmp/data", "stdout", "info")
assert.NoError(t, err)
defer os.RemoveAll(Params.EtcdCfg.DataDir.GetValue())
defer StopEtcdServer()
etcdCli, err := GetEtcdClient(&Params.EtcdCfg)
etcdCli, err := GetEtcdClient(true, false, []string{}, "", "", "", "")
assert.NoError(t, err)
key := path.Join("test", "test")
@ -52,26 +42,25 @@ func TestEtcd(t *testing.T) {
assert.False(t, resp.Count < 1)
assert.Equal(t, string(resp.Kvs[0].Value), "value")
t.Setenv("ETCD_USE_EMBED", "false")
Params.Init()
Params.BaseTable.Save("etcd.ssl.enabled", "true")
Params.BaseTable.Save("etcd.ssl.tlsMinVersion", "1.3")
Params.BaseTable.Save("etcd.ssl.tlsCACert", "../../../configs/cert/ca.pem")
Params.BaseTable.Save("etcd.ssl.tlsCert", "../../../configs/cert/client.pem")
Params.BaseTable.Save("etcd.ssl.tlsKey", "../../../configs/cert/client.key")
assert.NoError(t, err)
Params.BaseTable.Save("etcd.ssl.tlsMinVersion", "some not right word")
etcdCli, err = GetEtcdClient(&Params.EtcdCfg)
etcdCli, err = GetEtcdClient(false, true, []string{},
"../../../configs/cert/client.pem",
"../../../configs/cert/client.key",
"../../../configs/cert/ca.pem",
"some not right word")
assert.NotNil(t, err)
Params.BaseTable.Save("etcd.ssl.tlsMinVersion", "1.2")
Params.BaseTable.Save("etcd.ssl.tlsCACert", "wrong/file")
etcdCli, err = GetEtcdClient(&Params.EtcdCfg)
etcdCli, err = GetEtcdClient(false, true, []string{},
"../../../configs/cert/client.pem",
"../../../configs/cert/client.key",
"wrong/file",
"1.2")
assert.NotNil(t, err)
Params.BaseTable.Save("etcd.ssl.tlsCACert", "../../../configs/cert/ca.pem")
Params.BaseTable.Save("etcd.ssl.tlsCert", "wrong/file")
etcdCli, err = GetEtcdClient(false, true, []string{},
"wrong/file",
"../../../configs/cert/client.key",
"../../../configs/cert/ca.pem",
"1.2")
assert.NotNil(t, err)
}

32
internal/util/paramtable/base_table.go
View File

@ -23,6 +23,7 @@ import (
config "github.com/milvus-io/milvus/internal/config"
"github.com/milvus-io/milvus/internal/log"
"github.com/milvus-io/milvus/internal/util/etcd"
"github.com/milvus-io/milvus/internal/util/typeutil"
"go.uber.org/zap"
)
@ -142,28 +143,35 @@ func (gp *BaseTable) initConfigsFromLocal(formatter func(key string) string) {
}
func (gp *BaseTable) initConfigsFromRemote(formatter func(key string) string) {
endpoints, err := gp.mgr.GetConfig("etcd.endpoints")
if err != nil {
log.Info("cannot find etcd.endpoints")
etcdConfig := EtcdConfig{}
etcdConfig.Init(gp)
if etcdConfig.Endpoints.GetValue() == "" {
return
}
rootPath, err := gp.mgr.GetConfig("etcd.rootPath")
if err != nil {
log.Info("cannot find etcd.rootPath")
if etcdConfig.UseEmbedEtcd.GetAsBool() && !etcd.HasServer() {
return
}
info := &config.EtcdInfo{
UseEmbed: etcdConfig.UseEmbedEtcd.GetAsBool(),
UseSSL: etcdConfig.EtcdUseSSL.GetAsBool(),
Endpoints: etcdConfig.Endpoints.GetAsStrings(),
CertFile: etcdConfig.EtcdTLSCert.GetValue(),
KeyFile: etcdConfig.EtcdTLSKey.GetValue(),
CaCertFile: etcdConfig.EtcdTLSCACert.GetValue(),
MinVersion: etcdConfig.EtcdTLSMinVersion.GetValue(),
KeyPrefix: etcdConfig.RootPath.GetValue(),
RefreshInterval: 10 * time.Second,
}
configFilePath := gp.configDir + "/" + gp.YamlFile
gp.mgr, err = config.Init(config.WithEnvSource(formatter),
var err error
gp.mgr, err = config.Init(
config.WithEnvSource(formatter),
config.WithFilesSource(&config.FileInfo{
Filepath: configFilePath,
RefreshInterval: 10 * time.Second,
}),
config.WithEtcdSource(&config.EtcdInfo{
Endpoints: strings.Split(endpoints, ","),
KeyPrefix: rootPath,
RefreshInterval: 10 * time.Second,
}))
config.WithEtcdSource(info))
if err != nil {
log.Info("init with etcd failed", zap.Error(err))
return