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/18 06:25:50 UTC
[servicecomb-service-center] branch master updated: [SCB-2094]
Restructure database/mongo (#896)
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 c063b9a [SCB-2094] Restructure database/mongo (#896)
c063b9a is described below
commit c063b9a1b79ea98c98f283ab481ad88c96c798c5
Author: robotLJW <79...@qq.com>
AuthorDate: Thu Mar 18 14:25:43 2021 +0800
[SCB-2094] Restructure database/mongo (#896)
1.create dao
---
datasource/account.go | 8 +-
datasource/account_test.go | 4 +-
datasource/etcd/account.go | 13 +-
datasource/mongo/account.go | 64 +-
datasource/mongo/client/common.go | 1 +
datasource/mongo/client/dao/instance.go | 95 ++
datasource/mongo/client/dao/microservice.go | 108 +++
datasource/mongo/client/dao/rule.go | 85 ++
datasource/mongo/client/dao/schema.go | 81 ++
.../checker/heartbeat.go => client/dao/tag.go} | 32 +-
datasource/mongo/client/errortypes.go | 6 -
datasource/mongo/{ => client}/model/types.go | 0
datasource/mongo/dep.go | 40 +-
datasource/mongo/dep_util.go | 7 +-
datasource/mongo/dependency_query.go | 107 ++-
datasource/mongo/engine.go | 8 +-
datasource/mongo/event/instance_event_handler.go | 5 +-
.../mongo/event/instance_event_handler_test.go | 2 +-
datasource/mongo/heartbeat/cache/heartbeat.go | 25 +-
datasource/mongo/heartbeat/cache/heartbeat_test.go | 2 +-
.../mongo/heartbeat/cache/heartbeatcache_test.go | 6 +-
datasource/mongo/heartbeat/checker/heartbeat.go | 9 +-
.../mongo/heartbeat/checker/heartbeat_test.go | 20 +-
.../heartbeat/checker/heartbeatchecker_test.go | 12 +-
datasource/mongo/mongo.go | 14 +-
datasource/mongo/ms.go | 966 ++++++---------------
datasource/mongo/ms_test.go | 2 +-
datasource/mongo/role.go | 46 +-
datasource/mongo/rule_util.go | 8 +-
datasource/mongo/rule_util_test.go | 2 +-
datasource/mongo/sd/listwatch_inner.go | 2 +-
datasource/mongo/sd/listwatch_test.go | 2 +-
datasource/mongo/sd/mongo_cacher.go | 2 +-
datasource/mongo/sd/mongo_cacher_test.go | 2 +-
datasource/mongo/system.go | 2 +-
datasource/mongo/system_test.go | 2 +-
datasource/mongo/util.go | 31 +-
datasource/mongo/util/db.go | 277 +++++-
datasource/mongo/util/string.go | 2 +-
39 files changed, 1138 insertions(+), 962 deletions(-)
diff --git a/datasource/account.go b/datasource/account.go
index c5a2df7..70faaa0 100644
--- a/datasource/account.go
+++ b/datasource/account.go
@@ -24,9 +24,11 @@ import (
)
var (
- ErrAccountDuplicated = errors.New("account is duplicated")
- ErrAccountCanNotEdit = errors.New("account can not be edited")
- ErrDLockNotFound = errors.New("dlock not found")
+ ErrAccountDuplicated = errors.New("account is duplicated")
+ ErrAccountCanNotEdit = errors.New("account can not be edited")
+ ErrDLockNotFound = errors.New("dlock not found")
+ ErrDeleteAccountFailed = errors.New("failed to delete account")
+ ErrQueryAccountFailed = errors.New("failed to query account")
)
// AccountManager contains the RBAC CRUD
diff --git a/datasource/account_test.go b/datasource/account_test.go
index f7bce08..b61845d 100644
--- a/datasource/account_test.go
+++ b/datasource/account_test.go
@@ -52,10 +52,12 @@ func TestAccount(t *testing.T) {
t.Run("add and get account", func(t *testing.T) {
err := datasource.Instance().CreateAccount(context.Background(), &a1)
assert.NoError(t, err)
+ err = datasource.Instance().CreateAccount(context.Background(), &a2)
+ assert.NoError(t, err)
r, err := datasource.Instance().GetAccount(context.Background(), a1.Name)
assert.NoError(t, err)
assert.Equal(t, a1, *r)
- _, err = datasource.Instance().DeleteAccount(context.Background(), []string{a1.Name})
+ _, err = datasource.Instance().DeleteAccount(context.Background(), []string{a1.Name, a2.Name})
assert.NoError(t, err)
})
t.Run("account should exist", func(t *testing.T) {
diff --git a/datasource/etcd/account.go b/datasource/etcd/account.go
index 0b677c2..d954959 100644
--- a/datasource/etcd/account.go
+++ b/datasource/etcd/account.go
@@ -121,12 +121,15 @@ func (ds *DataSource) DeleteAccount(ctx context.Context, names []string) (bool,
if len(names) == 0 {
return false, nil
}
- resp, err := client.Instance().Do(ctx, client.DEL,
- client.WithStrKey(path.GenerateRBACAccountKey(names[0])))
- if err != nil {
- return false, err
+ for _, name := range names {
+ _, err := client.Instance().Do(ctx, client.DEL,
+ client.WithStrKey(path.GenerateRBACAccountKey(name)))
+ if err != nil {
+ log.Error(datasource.ErrDeleteAccountFailed.Error(), err)
+ return false, err
+ }
}
- return resp.Succeeded, nil
+ return true, nil
}
func (ds *DataSource) UpdateAccount(ctx context.Context, name string, account *rbac.Account) error {
value, err := json.Marshal(account)
diff --git a/datasource/mongo/account.go b/datasource/mongo/account.go
index 99b1678..c4e816c 100644
--- a/datasource/mongo/account.go
+++ b/datasource/mongo/account.go
@@ -19,14 +19,13 @@ package mongo
import (
"context"
- "errors"
+ "fmt"
"github.com/go-chassis/cari/rbac"
- "go.mongodb.org/mongo-driver/bson"
"github.com/apache/servicecomb-service-center/datasource"
"github.com/apache/servicecomb-service-center/datasource/mongo/client"
- "github.com/apache/servicecomb-service-center/datasource/mongo/model"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/model"
mutil "github.com/apache/servicecomb-service-center/datasource/mongo/util"
"github.com/apache/servicecomb-service-center/pkg/log"
"github.com/apache/servicecomb-service-center/pkg/privacy"
@@ -36,7 +35,8 @@ import (
func (ds *DataSource) CreateAccount(ctx context.Context, a *rbac.Account) error {
exist, err := ds.AccountExist(ctx, a.Name)
if err != nil {
- log.Error("can not save account info", err)
+ msg := fmt.Sprintf("failed to query account, account name %s", a.Name)
+ log.Error(msg, err)
return err
}
if exist {
@@ -44,7 +44,8 @@ func (ds *DataSource) CreateAccount(ctx context.Context, a *rbac.Account) error
}
a.Password, err = privacy.HashPassword(a.Password)
if err != nil {
- log.Error("pwd hash failed", err)
+ msg := fmt.Sprintf("failed to hash account pwd, account name %s", a.Name)
+ log.Error(msg, err)
return err
}
a.ID = util.GenerateUUID()
@@ -55,14 +56,12 @@ func (ds *DataSource) CreateAccount(ctx context.Context, a *rbac.Account) error
}
return err
}
- log.Info("create new account: " + a.ID)
+ log.Info("succeed to create new account: " + a.ID)
return nil
}
func (ds *DataSource) AccountExist(ctx context.Context, name string) (bool, error) {
- filter := bson.M{
- model.ColumnAccountName: name,
- }
+ filter := mutil.NewFilter(mutil.AccountName(name))
count, err := client.GetMongoClient().Count(ctx, model.CollectionAccount, filter)
if err != nil {
return false, err
@@ -74,28 +73,30 @@ func (ds *DataSource) AccountExist(ctx context.Context, name string) (bool, erro
}
func (ds *DataSource) GetAccount(ctx context.Context, name string) (*rbac.Account, error) {
- filter := bson.M{
- model.ColumnAccountName: name,
- }
+ filter := mutil.NewFilter(mutil.AccountName(name))
result, err := client.GetMongoClient().FindOne(ctx, model.CollectionAccount, filter)
if err != nil {
+ msg := fmt.Sprintf("failed to query account, account name %s", name)
+ log.Error(msg, err)
return nil, err
}
if result.Err() != nil {
- log.Error("failed to get account: ", result.Err())
- return nil, errors.New("failed to get account")
+ msg := fmt.Sprintf("failed to query account, account name %s", name)
+ log.Error(msg, result.Err())
+ return nil, datasource.ErrQueryAccountFailed
}
var account rbac.Account
err = result.Decode(&account)
if err != nil {
- log.Error("decode account failed: ", err)
+ log.Error("failed to decode account", err)
return nil, err
}
return &account, nil
}
func (ds *DataSource) ListAccount(ctx context.Context) ([]*rbac.Account, int64, error) {
- cursor, err := client.GetMongoClient().Find(ctx, model.CollectionAccount, bson.M{})
+ filter := mutil.NewFilter()
+ cursor, err := client.GetMongoClient().Find(ctx, model.CollectionAccount, filter)
if err != nil {
return nil, 0, err
}
@@ -105,7 +106,7 @@ func (ds *DataSource) ListAccount(ctx context.Context) ([]*rbac.Account, int64,
var account rbac.Account
err = cursor.Decode(&account)
if err != nil {
- log.Error("decode account failed: ", err)
+ log.Error("failed to decode account", err)
continue
}
account.Password = ""
@@ -118,9 +119,8 @@ func (ds *DataSource) DeleteAccount(ctx context.Context, names []string) (bool,
if len(names) == 0 {
return false, nil
}
- filter := bson.M{
- model.ColumnAccountName: names[0],
- }
+ inFilter := mutil.NewFilter(mutil.In(names))
+ filter := mutil.NewFilter(mutil.AccountName(inFilter))
result, err := client.GetMongoClient().Delete(ctx, model.CollectionAccount, filter)
if err != nil {
return false, err
@@ -132,20 +132,16 @@ func (ds *DataSource) DeleteAccount(ctx context.Context, names []string) (bool,
}
func (ds *DataSource) UpdateAccount(ctx context.Context, name string, account *rbac.Account) error {
- filter := bson.M{
- model.ColumnAccountName: name,
- }
- update := bson.M{
- "$set": bson.M{
- model.ColumnID: account.ID,
- model.ColumnPassword: account.Password,
- model.ColumnRoles: account.Roles,
- model.ColumnTokenExpirationTime: account.TokenExpirationTime,
- model.ColumnCurrentPassword: account.CurrentPassword,
- model.ColumnStatus: account.Status,
- },
- }
- res, err := client.GetMongoClient().Update(ctx, model.CollectionAccount, filter, update)
+ filter := mutil.NewFilter(mutil.AccountName(name))
+ setFilter := mutil.NewFilter(
+ mutil.ID(account.ID),
+ mutil.Password(account.Password), mutil.Roles(account.Roles),
+ mutil.TokenExpirationTime(account.TokenExpirationTime),
+ mutil.CurrentPassword(account.CurrentPassword),
+ mutil.Status(account.Status),
+ )
+ updateFilter := mutil.NewFilter(mutil.Set(setFilter))
+ res, err := client.GetMongoClient().Update(ctx, model.CollectionAccount, filter, updateFilter)
if err != nil {
return err
}
diff --git a/datasource/mongo/client/common.go b/datasource/mongo/client/common.go
index 1fa44d5..dbc6f9c 100644
--- a/datasource/mongo/client/common.go
+++ b/datasource/mongo/client/common.go
@@ -23,4 +23,5 @@ var (
ErrCollectionsNil = errors.New("collection is nil")
ErrOpenDbFailed = errors.New("open db failed")
ErrRootCAMissing = errors.New("rootCAFile is empty in config file")
+ ErrNoDocuments = errors.New("no doc found")
)
diff --git a/datasource/mongo/client/dao/instance.go b/datasource/mongo/client/dao/instance.go
new file mode 100644
index 0000000..a59be3e
--- /dev/null
+++ b/datasource/mongo/client/dao/instance.go
@@ -0,0 +1,95 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dao
+
+import (
+ "context"
+
+ "github.com/go-chassis/cari/discovery"
+ "go.mongodb.org/mongo-driver/mongo/options"
+
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/model"
+)
+
+func GetInstance(ctx context.Context, filter interface{}) (*model.Instance, error) {
+ findRes, err := client.GetMongoClient().FindOne(ctx, model.CollectionInstance, filter)
+ if err != nil {
+ return nil, err
+ }
+ var instance *model.Instance
+ if findRes.Err() != nil {
+ //not get any service,not db err
+ return nil, nil
+ }
+ err = findRes.Decode(&instance)
+ if err != nil {
+ return nil, err
+ }
+ return instance, nil
+}
+
+func GetInstances(ctx context.Context, filter interface{}) ([]*model.Instance, error) {
+ res, err := client.GetMongoClient().Find(ctx, model.CollectionInstance, filter)
+ if err != nil {
+ return nil, err
+ }
+ var instances []*model.Instance
+ for res.Next(ctx) {
+ var tmp *model.Instance
+ err := res.Decode(&tmp)
+ if err != nil {
+ return nil, err
+ }
+ instances = append(instances, tmp)
+ }
+ return instances, nil
+}
+
+func GetMicroServiceInstances(ctx context.Context, filter interface{}, opts ...*options.FindOptions) ([]*discovery.MicroServiceInstance, error) {
+ res, err := client.GetMongoClient().Find(ctx, model.CollectionInstance, filter, opts...)
+ if err != nil {
+ return nil, err
+ }
+ var instances []*discovery.MicroServiceInstance
+ for res.Next(ctx) {
+ var tmp model.Instance
+ err := res.Decode(&tmp)
+ if err != nil {
+ return nil, err
+ }
+ instances = append(instances, tmp.Instance)
+ }
+ return instances, nil
+}
+
+func CountInstance(ctx context.Context, filter interface{}) (int64, error) {
+ count, err := client.GetMongoClient().Count(ctx, model.CollectionInstance, filter)
+ if err != nil {
+ return 0, err
+ }
+ return count, nil
+}
+
+func UpdateInstance(ctx context.Context, filter interface{}, update interface{}, opts ...*options.UpdateOptions) *discovery.Error {
+ _, err := client.GetMongoClient().Update(ctx, model.CollectionInstance, filter, update, opts...)
+ if err != nil {
+ return discovery.NewError(discovery.ErrUnavailableBackend, err.Error())
+ }
+ return nil
+}
diff --git a/datasource/mongo/client/dao/microservice.go b/datasource/mongo/client/dao/microservice.go
new file mode 100644
index 0000000..51b1c58
--- /dev/null
+++ b/datasource/mongo/client/dao/microservice.go
@@ -0,0 +1,108 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dao
+
+import (
+ "context"
+ "github.com/go-chassis/cari/discovery"
+ "go.mongodb.org/mongo-driver/mongo/options"
+
+ "github.com/apache/servicecomb-service-center/datasource"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/model"
+)
+
+func GetService(ctx context.Context, filter interface{}, opts ...*options.FindOneOptions) (*model.Service, error) {
+ result, err := client.GetMongoClient().FindOne(ctx, model.CollectionService, filter, opts...)
+ if err != nil {
+ return nil, err
+ }
+ var svc *model.Service
+ if result.Err() != nil {
+ //not get any service,not db err
+ return nil, datasource.ErrNoData
+ }
+ err = result.Decode(&svc)
+ if err != nil {
+ return nil, err
+ }
+ return svc, nil
+}
+
+func GetServices(ctx context.Context, filter interface{}, opts ...*options.FindOptions) ([]*model.Service, error) {
+ res, err := client.GetMongoClient().Find(ctx, model.CollectionService, filter, opts...)
+ if err != nil {
+ return nil, err
+ }
+ var services []*model.Service
+ for res.Next(ctx) {
+ var tmp *model.Service
+ err := res.Decode(&tmp)
+ if err != nil {
+ return nil, err
+ }
+ services = append(services, tmp)
+ }
+ return services, nil
+}
+
+func GetMicroServices(ctx context.Context, filter interface{}, opts ...*options.FindOptions) ([]*discovery.MicroService, error) {
+ res, err := client.GetMongoClient().Find(ctx, model.CollectionService, filter, opts...)
+ if err != nil {
+ return nil, err
+ }
+ var services []*discovery.MicroService
+ for res.Next(ctx) {
+ var tmp model.Service
+ err := res.Decode(&tmp)
+ if err != nil {
+ return nil, err
+ }
+ services = append(services, tmp.Service)
+ }
+ return services, nil
+}
+
+func UpdateService(ctx context.Context, filter interface{}, update interface{}, opts ...*options.FindOneAndUpdateOptions) error {
+ res, err := client.GetMongoClient().FindOneAndUpdate(ctx, model.CollectionService, filter, update, opts...)
+ if err != nil {
+ return err
+ }
+ if res.Err() != nil {
+ // means no doc find, if the operation is update,should return err
+ return client.ErrNoDocuments
+ }
+ return nil
+}
+
+func GetServicesVersions(ctx context.Context, filter interface{}) ([]string, error) {
+ res, err := client.GetMongoClient().Find(ctx, model.CollectionService, filter)
+ if err != nil {
+ return nil, nil
+ }
+ var versions []string
+ for res.Next(ctx) {
+ var tmp model.Service
+ err := res.Decode(&tmp)
+ if err != nil {
+ return nil, err
+ }
+ versions = append(versions, tmp.Service.Version)
+ }
+ return versions, nil
+}
diff --git a/datasource/mongo/client/dao/rule.go b/datasource/mongo/client/dao/rule.go
new file mode 100644
index 0000000..522a119
--- /dev/null
+++ b/datasource/mongo/client/dao/rule.go
@@ -0,0 +1,85 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dao
+
+import (
+ "context"
+
+ "github.com/go-chassis/cari/discovery"
+ "go.mongodb.org/mongo-driver/bson"
+ "go.mongodb.org/mongo-driver/mongo/options"
+
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/model"
+ "github.com/apache/servicecomb-service-center/pkg/log"
+)
+
+func GetRules(ctx context.Context, filter interface{}) ([]*model.Rule, error) {
+ cursor, err := client.GetMongoClient().Find(ctx, model.CollectionRule, filter)
+ if err != nil {
+ return nil, err
+ }
+ if cursor.Err() != nil {
+ return nil, cursor.Err()
+ }
+ var rules []*model.Rule
+ defer cursor.Close(ctx)
+ for cursor.Next(ctx) {
+ var rule model.Rule
+ err := cursor.Decode(&rule)
+ if err != nil {
+ log.Error("type conversion error", err)
+ return nil, err
+ }
+ rules = append(rules, &rule)
+ }
+ return rules, nil
+}
+
+func GetServiceRules(ctx context.Context, filter interface{}, opts ...*options.FindOptions) ([]*discovery.ServiceRule, error) {
+ ruleRes, err := client.GetMongoClient().Find(ctx, model.CollectionRule, filter, opts...)
+ if err != nil {
+ return nil, err
+ }
+ var rules []*discovery.ServiceRule
+ for ruleRes.Next(ctx) {
+ var tempRule *model.Rule
+ err := ruleRes.Decode(&tempRule)
+ if err != nil {
+ return nil, err
+ }
+ rules = append(rules, tempRule.Rule)
+ }
+ return rules, nil
+}
+
+func RuleExist(ctx context.Context, filter interface{}) (bool, error) {
+ return client.GetMongoClient().DocExist(ctx, model.CollectionRule, filter)
+}
+
+func UpdateRule(ctx context.Context, filter interface{}, m bson.M) error {
+ return client.GetMongoClient().DocUpdate(ctx, model.CollectionRule, filter, m)
+}
+
+func UpdateSchema(ctx context.Context, filter interface{}, update interface{}, opts ...*options.FindOneAndUpdateOptions) error {
+ _, err := client.GetMongoClient().FindOneAndUpdate(ctx, model.CollectionSchema, filter, update, opts...)
+ if err != nil {
+ return err
+ }
+ return nil
+}
diff --git a/datasource/mongo/client/dao/schema.go b/datasource/mongo/client/dao/schema.go
new file mode 100644
index 0000000..fbf6d28
--- /dev/null
+++ b/datasource/mongo/client/dao/schema.go
@@ -0,0 +1,81 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package dao
+
+import (
+ "context"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/model"
+ mutil "github.com/apache/servicecomb-service-center/datasource/mongo/util"
+ "github.com/go-chassis/cari/discovery"
+)
+
+func GetSchema(ctx context.Context, filter interface{}) (*model.Schema, error) {
+ findRes, err := client.GetMongoClient().FindOne(ctx, model.CollectionSchema, filter)
+ if err != nil {
+ return nil, err
+ }
+ if findRes.Err() != nil {
+ //not get any service,not db err
+ return nil, nil
+ }
+ var schema *model.Schema
+ err = findRes.Decode(&schema)
+ if err != nil {
+ return nil, err
+ }
+ return schema, nil
+}
+
+func GetSchemas(ctx context.Context, filter interface{}) ([]*discovery.Schema, error) {
+ getRes, err := client.GetMongoClient().Find(ctx, model.CollectionSchema, filter)
+ if err != nil {
+ return nil, err
+ }
+ var schemas []*discovery.Schema
+ for getRes.Next(ctx) {
+ var tmp *model.Schema
+ err = getRes.Decode(&tmp)
+ if err != nil {
+ return nil, err
+ }
+ schemas = append(schemas, &discovery.Schema{
+ SchemaId: tmp.SchemaID,
+ Summary: tmp.SchemaSummary,
+ Schema: tmp.Schema,
+ })
+ }
+ return schemas, nil
+}
+
+func SchemaSummaryExist(ctx context.Context, serviceID, schemaID string) (bool, error) {
+ filter := mutil.NewBasicFilter(ctx, mutil.ServiceID(serviceID), mutil.SchemaID(schemaID))
+ res, err := client.GetMongoClient().FindOne(ctx, model.CollectionSchema, filter)
+ if err != nil {
+ return false, err
+ }
+ if res.Err() != nil {
+ return false, nil
+ }
+ var s model.Schema
+ err = res.Decode(&s)
+ if err != nil {
+ return false, err
+ }
+ return len(s.SchemaSummary) != 0, nil
+}
diff --git a/datasource/mongo/heartbeat/checker/heartbeat.go b/datasource/mongo/client/dao/tag.go
similarity index 59%
copy from datasource/mongo/heartbeat/checker/heartbeat.go
copy to datasource/mongo/client/dao/tag.go
index a5fb039..36ce4dc 100644
--- a/datasource/mongo/heartbeat/checker/heartbeat.go
+++ b/datasource/mongo/client/dao/tag.go
@@ -15,35 +15,29 @@
* limitations under the License.
*/
-package checker
+package dao
import (
"context"
- "time"
- "go.mongodb.org/mongo-driver/bson"
-
- "github.com/apache/servicecomb-service-center/datasource/mongo"
"github.com/apache/servicecomb-service-center/datasource/mongo/client"
- "github.com/apache/servicecomb-service-center/datasource/mongo/model"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/model"
"github.com/apache/servicecomb-service-center/pkg/log"
)
-func updateInstanceRefreshTime(ctx context.Context, serviceID string, instanceID string) error {
- filter := bson.M{
- mongo.StringBuilder([]string{model.ColumnInstance, model.ColumnServiceID}): serviceID,
- mongo.StringBuilder([]string{model.ColumnInstance, model.ColumnInstanceID}): instanceID,
- }
- update := bson.M{
- "$set": bson.M{model.ColumnRefreshTime: time.Now()},
- }
- result, err := client.GetMongoClient().FindOneAndUpdate(ctx, model.CollectionInstance, filter, update)
+func GetTags(ctx context.Context, filter interface{}) (tags map[string]string, err error) {
+ result, err := client.GetMongoClient().FindOne(ctx, model.CollectionService, filter)
if err != nil {
- log.Error("failed to update refresh time of instance: ", err)
- return err
+ return nil, err
}
if result.Err() != nil {
- return result.Err()
+ return nil, result.Err()
+ }
+ var service model.Service
+ err = result.Decode(&service)
+ if err != nil {
+ log.Error("type conversion error", err)
+ return nil, err
}
- return nil
+ return service.Tags, nil
}
diff --git a/datasource/mongo/client/errortypes.go b/datasource/mongo/client/errortypes.go
index 423401b..759315f 100644
--- a/datasource/mongo/client/errortypes.go
+++ b/datasource/mongo/client/errortypes.go
@@ -16,15 +16,9 @@
package client
import (
- "errors"
-
"go.mongodb.org/mongo-driver/mongo"
)
-var (
- ErrNoDocuments = errors.New("no doc found")
-)
-
const (
DuplicateKey = 11000
CollectionsExists = 48
diff --git a/datasource/mongo/model/types.go b/datasource/mongo/client/model/types.go
similarity index 100%
rename from datasource/mongo/model/types.go
rename to datasource/mongo/client/model/types.go
diff --git a/datasource/mongo/dep.go b/datasource/mongo/dep.go
index ea83355..18af64f 100644
--- a/datasource/mongo/dep.go
+++ b/datasource/mongo/dep.go
@@ -29,7 +29,8 @@ import (
"github.com/apache/servicecomb-service-center/datasource"
"github.com/apache/servicecomb-service-center/datasource/etcd/path"
"github.com/apache/servicecomb-service-center/datasource/mongo/client"
- "github.com/apache/servicecomb-service-center/datasource/mongo/model"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/dao"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/model"
mutil "github.com/apache/servicecomb-service-center/datasource/mongo/util"
"github.com/apache/servicecomb-service-center/pkg/log"
"github.com/apache/servicecomb-service-center/pkg/util"
@@ -38,8 +39,8 @@ import (
func (ds *DataSource) SearchProviderDependency(ctx context.Context, request *discovery.GetDependenciesRequest) (*discovery.GetProDependenciesResponse, error) {
domainProject := util.ParseDomainProject(ctx)
providerServiceID := request.ServiceId
- filter := GeneratorServiceFilter(ctx, providerServiceID)
- provider, err := GetService(ctx, filter)
+ filter := mutil.NewBasicFilter(ctx, mutil.ServiceServiceID(providerServiceID))
+ provider, err := dao.GetService(ctx, filter)
if err != nil {
if errors.Is(err, datasource.ErrNoData) {
log.Debug(fmt.Sprintf("query provider service failed, there is no provider %s in db", providerServiceID))
@@ -76,9 +77,8 @@ func (ds *DataSource) SearchProviderDependency(ctx context.Context, request *dis
func (ds *DataSource) SearchConsumerDependency(ctx context.Context, request *discovery.GetDependenciesRequest) (*discovery.GetConDependenciesResponse, error) {
domainProject := util.ParseDomainProject(ctx)
consumerID := request.ServiceId
-
- filter := GeneratorServiceFilter(ctx, consumerID)
- consumer, err := GetService(ctx, filter)
+ filter := mutil.NewBasicFilter(ctx, mutil.ServiceServiceID(consumerID))
+ consumer, err := dao.GetService(ctx, filter)
if err != nil {
if errors.Is(err, datasource.ErrNoData) {
log.Debug(fmt.Sprintf("query consumer service failed, there is no consumer %s in db", consumerID))
@@ -226,7 +226,7 @@ func updateDeps(domainProject string, dep *datasource.Dependency) error {
var upsert = true
for _, r := range dep.DeleteDependencyRuleList {
filter := GenerateProviderDependencyRuleKey(domainProject, r)
- _, err := client.GetMongoClient().Update(context.TODO(), model.CollectionDep, filter, bson.M{"$pull": bson.M{StringBuilder([]string{model.ColumnDep, model.ColumnDependency}): dep.Consumer}})
+ _, err := client.GetMongoClient().Update(context.TODO(), model.CollectionDep, filter, bson.M{"$pull": bson.M{mutil.ConnectWithDot([]string{model.ColumnDep, model.ColumnDependency}): dep.Consumer}})
if err != nil {
return err
}
@@ -237,7 +237,7 @@ func updateDeps(domainProject string, dep *datasource.Dependency) error {
for _, r := range dep.CreateDependencyRuleList {
filter := GenerateProviderDependencyRuleKey(domainProject, r)
data := bson.M{
- "$addToSet": bson.M{StringBuilder([]string{model.ColumnDep, model.ColumnDependency}): dep.Consumer},
+ "$addToSet": bson.M{mutil.ConnectWithDot([]string{model.ColumnDep, model.ColumnDependency}): dep.Consumer},
}
_, err := client.GetMongoClient().Update(context.TODO(), model.CollectionDep, filter, data, &options.UpdateOptions{Upsert: &upsert})
if err != nil {
@@ -255,7 +255,7 @@ func updateDeps(domainProject string, dep *datasource.Dependency) error {
}
} else {
updateData := bson.M{
- "$set": bson.M{StringBuilder([]string{model.ColumnDep, model.ColumnDependency}): dep.ProvidersRule},
+ "$set": bson.M{mutil.ConnectWithDot([]string{model.ColumnDep, model.ColumnDependency}): dep.ProvidersRule},
}
_, err := client.GetMongoClient().Update(context.TODO(), model.CollectionDep, filter, updateData, &options.UpdateOptions{Upsert: &upsert})
if err != nil {
@@ -401,7 +401,7 @@ func removeConsumerDeps(ctx context.Context, depRule *model.DependencyRule, cach
_, err = client.GetMongoClient().DocDelete(ctx, model.CollectionDep, filter)
} else {
updateData := bson.M{
- "$set": bson.M{StringBuilder([]string{model.ColumnDep, model.ColumnDependency}): left},
+ "$set": bson.M{mutil.ConnectWithDot([]string{model.ColumnDep, model.ColumnDependency}): left},
}
_, err = client.GetMongoClient().Update(ctx, model.CollectionDep, filter, updateData)
}
@@ -451,18 +451,32 @@ func GetConsumerDepInfo(ctx context.Context, filter bson.M) ([]*discovery.Consum
}
func GetServiceID(ctx context.Context, key *discovery.MicroServiceKey) (string, error) {
- id, err := getServiceID(ctx, GeneratorServiceNameFilter(ctx, key))
+ filter := mutil.NewBasicFilter(
+ ctx,
+ mutil.ServiceEnv(key.Environment),
+ mutil.ServiceAppID(key.AppId),
+ mutil.ServiceServiceName(key.ServiceName),
+ mutil.ServiceVersion(key.Version),
+ )
+ id, err := getServiceID(ctx, filter)
if err != nil && !errors.Is(err, datasource.ErrNoData) {
return "", err
}
if len(id) == 0 && len(key.Alias) != 0 {
- return getServiceID(ctx, GeneratorServiceAliasFilter(ctx, key))
+ filter = mutil.NewBasicFilter(
+ ctx,
+ mutil.ServiceEnv(key.Environment),
+ mutil.ServiceAppID(key.AppId),
+ mutil.ServiceAlias(key.Alias),
+ mutil.ServiceVersion(key.Version),
+ )
+ return getServiceID(ctx, filter)
}
return id, nil
}
func getServiceID(ctx context.Context, filter bson.M) (serviceID string, err error) {
- svc, err := GetService(ctx, filter)
+ svc, err := dao.GetService(ctx, filter)
if err != nil {
return
}
diff --git a/datasource/mongo/dep_util.go b/datasource/mongo/dep_util.go
index d50ca89..6a39b4e 100644
--- a/datasource/mongo/dep_util.go
+++ b/datasource/mongo/dep_util.go
@@ -23,7 +23,9 @@ import (
pb "github.com/go-chassis/cari/discovery"
- "github.com/apache/servicecomb-service-center/datasource/mongo/model"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/dao"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/model"
+ mutil "github.com/apache/servicecomb-service-center/datasource/mongo/util"
"github.com/apache/servicecomb-service-center/pkg/log"
"github.com/apache/servicecomb-service-center/pkg/util"
)
@@ -36,7 +38,8 @@ func GetAllConsumerIds(ctx context.Context, provider *pb.MicroService) (allow []
//todo 删除服务，最后实例推送有误差
domain := util.ParseDomainProject(ctx)
project := util.ParseProject(ctx)
- providerRules, err := getRulesUtil(ctx, domain, project, provider.ServiceId)
+ filter := mutil.NewDomainProjectFilter(domain, project, mutil.ServiceID(provider.ServiceId))
+ providerRules, err := dao.GetRules(ctx, filter)
if err != nil {
return nil, nil, err
}
diff --git a/datasource/mongo/dependency_query.go b/datasource/mongo/dependency_query.go
index cc482ea..f307680 100644
--- a/datasource/mongo/dependency_query.go
+++ b/datasource/mongo/dependency_query.go
@@ -30,7 +30,8 @@ import (
"github.com/apache/servicecomb-service-center/datasource"
"github.com/apache/servicecomb-service-center/datasource/etcd/path"
"github.com/apache/servicecomb-service-center/datasource/mongo/client"
- "github.com/apache/servicecomb-service-center/datasource/mongo/model"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/dao"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/model"
"github.com/apache/servicecomb-service-center/datasource/mongo/util"
"github.com/apache/servicecomb-service-center/pkg/log"
"github.com/apache/servicecomb-service-center/pkg/validate"
@@ -90,8 +91,8 @@ func (dr *DependencyRelation) GetDependencyProviders(opts ...DependencyRelationF
}
for _, providerID := range providerIDs {
- filter := GeneratorServiceFilter(dr.ctx, providerID)
- provider, err := GetService(dr.ctx, filter)
+ filter := util.NewBasicFilter(dr.ctx, util.ServiceServiceID(providerID))
+ provider, err := dao.GetService(dr.ctx, filter)
if err != nil {
if errors.Is(err, datasource.ErrNoData) {
log.Warn(fmt.Sprintf("provider[%s/%s/%s/%s] does not exist",
@@ -365,13 +366,13 @@ func MicroServiceKeyFilter(key *pb.MicroServiceKey) (bson.M, error) {
if len(tenant) != 2 {
return nil, util.ErrInvalidDomainProject
}
- return bson.M{
- model.ColumnDomain: tenant[0],
- model.ColumnProject: tenant[1],
- StringBuilder([]string{model.ColumnService, model.ColumnEnv}): key.Environment,
- StringBuilder([]string{model.ColumnService, model.ColumnAppID}): key.AppId,
- StringBuilder([]string{model.ColumnService, model.ColumnAlias}): key.Alias,
- StringBuilder([]string{model.ColumnService, model.ColumnVersion}): key.Version}, nil
+ filter := util.NewDomainProjectFilter(tenant[0], tenant[1],
+ util.ServiceEnv(key.Environment),
+ util.ServiceAppID(key.AppId),
+ util.ServiceAlias(key.Alias),
+ util.ServiceVersion(key.Version),
+ )
+ return filter, nil
}
func RelyAllServiceKey(key *pb.MicroServiceKey) (bson.M, error) {
@@ -379,10 +380,8 @@ func RelyAllServiceKey(key *pb.MicroServiceKey) (bson.M, error) {
if len(tenant) != 2 {
return nil, util.ErrInvalidDomainProject
}
- return bson.M{
- model.ColumnDomain: tenant[0],
- model.ColumnProject: tenant[1],
- StringBuilder([]string{model.ColumnService, model.ColumnEnv}): key.Environment}, nil
+ filter := util.NewDomainProjectFilter(tenant[0], tenant[1], util.ServiceEnv(key.Environment))
+ return filter, nil
}
func FindServiceIds(ctx context.Context, versionRule string, key *pb.MicroServiceKey) ([]string, bool, error) {
@@ -398,8 +397,8 @@ func FindServiceIds(ctx context.Context, versionRule string, key *pb.MicroServic
baseFilter := bson.D{
{Key: model.ColumnDomain, Value: tenant[0]},
{Key: model.ColumnProject, Value: tenant[1]},
- {Key: StringBuilder([]string{model.ColumnService, model.ColumnEnv}), Value: key.Environment},
- {Key: StringBuilder([]string{model.ColumnService, model.ColumnAppID}), Value: key.AppId}}
+ {Key: util.ConnectWithDot([]string{model.ColumnService, model.ColumnEnv}), Value: key.Environment},
+ {Key: util.ConnectWithDot([]string{model.ColumnService, model.ColumnAppID}), Value: key.AppId}}
serviceIds, exist, err := findServiceKeysByServiceName(ctx, versionRule, key, baseFilter)
if err != nil {
@@ -446,13 +445,13 @@ func serviceVersionFilter(ctx context.Context, versionRule string, filter bson.D
func findServiceKeysByServiceName(ctx context.Context, versionRule string, key *pb.MicroServiceKey, baseFilter bson.D) ([]string, bool, error) {
filter := append(baseFilter,
- bson.E{Key: StringBuilder([]string{model.ColumnService, model.ColumnServiceName}), Value: key.ServiceName})
+ bson.E{Key: util.ConnectWithDot([]string{model.ColumnService, model.ColumnServiceName}), Value: key.ServiceName})
return serviceVersionFilter(ctx, versionRule, filter)
}
func findServiceKeysByAlias(ctx context.Context, versionRule string, key *pb.MicroServiceKey, baseFilter bson.D) ([]string, bool, error) {
filter := append(baseFilter,
- bson.E{Key: StringBuilder([]string{model.ColumnService, model.ColumnAlias}), Value: key.Alias})
+ bson.E{Key: util.ConnectWithDot([]string{model.ColumnService, model.ColumnAlias}), Value: key.Alias})
return serviceVersionFilter(ctx, versionRule, filter)
}
@@ -465,15 +464,15 @@ func findServiceKeys(ctx context.Context, versionRule string, filter bson.D) (fi
return GetVersionServiceLatest, filter
case versionRule[len(versionRule)-1:] == "+":
start := versionRule[:len(versionRule)-1]
- filter = append(filter, bson.E{Key: StringBuilder([]string{model.ColumnService, model.ColumnVersion}), Value: bson.M{"$gte": start}})
+ filter = append(filter, bson.E{Key: util.ConnectWithDot([]string{model.ColumnService, model.ColumnVersion}), Value: bson.M{"$gte": start}})
return GetVersionService, filter
case rangeIdx > 0:
start := versionRule[:rangeIdx]
end := versionRule[rangeIdx+1:]
- filter = append(filter, bson.E{Key: StringBuilder([]string{model.ColumnService, model.ColumnVersion}), Value: bson.M{"$gte": start, "$lt": end}})
+ filter = append(filter, bson.E{Key: util.ConnectWithDot([]string{model.ColumnService, model.ColumnVersion}), Value: bson.M{"$gte": start, "$lt": end}})
return GetVersionService, filter
default:
- filter = append(filter, bson.E{Key: StringBuilder([]string{model.ColumnService, model.ColumnVersion}), Value: versionRule})
+ filter = append(filter, bson.E{Key: util.ConnectWithDot([]string{model.ColumnService, model.ColumnVersion}), Value: versionRule})
return nil, filter
}
}
@@ -481,7 +480,7 @@ func findServiceKeys(ctx context.Context, versionRule string, filter bson.D) (fi
func GetVersionServiceLatest(ctx context.Context, m bson.D) (serviceIds []string, err error) {
findRes, err := client.GetMongoClient().Find(ctx, model.CollectionService, m,
&options.FindOptions{
- Sort: bson.M{StringBuilder([]string{model.ColumnService, model.ColumnVersion}): -1}})
+ Sort: bson.M{util.ConnectWithDot([]string{model.ColumnService, model.ColumnVersion}): -1}})
if err != nil {
return nil, err
}
@@ -504,7 +503,7 @@ func GetVersionServiceLatest(ctx context.Context, m bson.D) (serviceIds []string
func GetVersionService(ctx context.Context, m bson.D) (serviceIds []string, err error) {
findRes, err := client.GetMongoClient().Find(ctx, model.CollectionService, m, &options.FindOptions{
- Sort: bson.M{StringBuilder([]string{model.ColumnService, model.ColumnVersion}): -1}})
+ Sort: bson.M{util.ConnectWithDot([]string{model.ColumnService, model.ColumnVersion}): -1}})
if err != nil {
return
}
@@ -534,24 +533,16 @@ func ParseVersionRule(ctx context.Context, versionRule string, key *pb.MicroServ
rangeIdx := strings.Index(versionRule, "-")
switch {
case versionRule == "latest":
- filter := bson.M{
- model.ColumnDomain: tenant[0],
- model.ColumnProject: tenant[1]}
+ filter := util.NewDomainProjectFilter(tenant[0], tenant[1])
return GetFilterVersionServiceLatest(ctx, filter)
case versionRule[len(versionRule)-1:] == "+":
start := versionRule[:len(versionRule)-1]
- filter := bson.M{
- model.ColumnDomain: tenant[0],
- model.ColumnProject: tenant[1],
- StringBuilder([]string{model.ColumnService, model.ColumnVersion}): bson.M{"$gte": start}}
+ filter := util.NewDomainProjectFilter(tenant[0], tenant[1], util.ServiceVersion(bson.M{"$gte": start}))
return GetFilterVersionService(ctx, filter)
case rangeIdx > 0:
start := versionRule[:rangeIdx]
end := versionRule[rangeIdx+1:]
- filter := bson.M{
- model.ColumnDomain: tenant[0],
- model.ColumnProject: tenant[1],
- StringBuilder([]string{model.ColumnService, model.ColumnVersion}): bson.M{"$gte": start, "$lte": end}}
+ filter := util.NewDomainProjectFilter(tenant[0], tenant[1], util.ServiceVersion(bson.M{"$gte": start, "$lte": end}))
return GetFilterVersionService(ctx, filter)
default:
return nil, nil
@@ -580,7 +571,7 @@ func GetFilterVersionService(ctx context.Context, m bson.M) (serviceIDs []string
func GetFilterVersionServiceLatest(ctx context.Context, m bson.M) (serviceIDs []string, err error) {
findRes, err := client.GetMongoClient().Find(ctx, model.CollectionService, m,
&options.FindOptions{
- Sort: bson.M{StringBuilder([]string{model.ColumnService, model.ColumnVersion}): -1}})
+ Sort: bson.M{util.ConnectWithDot([]string{model.ColumnService, model.ColumnVersion}): -1}})
if err != nil {
return nil, err
}
@@ -640,31 +631,35 @@ func GenerateProviderDependencyRuleKey(domainProject string, in *pb.MicroService
}
func GenerateRuleKeyWithSameServiceNameAndAppID(serviceType string, domainProject string, in *pb.MicroServiceKey) bson.M {
- return bson.M{
- model.ColumnServiceType: serviceType,
- StringBuilder([]string{model.ColumnServiceKey, model.ColumnTenant}): domainProject,
- StringBuilder([]string{model.ColumnServiceKey, model.ColumnAppID}): in.AppId,
- StringBuilder([]string{model.ColumnServiceKey, model.ColumnServiceName}): in.ServiceName}
+ return util.NewFilter(
+ util.ServiceType(serviceType),
+ util.ServiceKeyTenant(domainProject),
+ util.ServiceKeyAppID(in.AppId),
+ util.ServiceServiceName(in.ServiceName),
+ )
}
func GenerateServiceDependencyRuleKey(serviceType string, domainProject string, in *pb.MicroServiceKey) bson.M {
if in == nil {
- return bson.M{
- model.ColumnServiceType: serviceType,
- StringBuilder([]string{model.ColumnServiceKey, model.ColumnTenant}): domainProject}
+ return util.NewFilter(
+ util.ServiceType(serviceType),
+ util.ServiceKeyTenant(domainProject),
+ )
}
if in.ServiceName == "*" {
- return bson.M{
- model.ColumnServiceType: serviceType,
- StringBuilder([]string{model.ColumnServiceKey, model.ColumnTenant}): domainProject,
- StringBuilder([]string{model.ColumnServiceKey, model.ColumnEnv}): in.Environment,
- StringBuilder([]string{model.ColumnServiceKey, model.ColumnServiceName}): in.ServiceName}
- }
- return bson.M{
- model.ColumnServiceType: serviceType,
- StringBuilder([]string{model.ColumnServiceKey, model.ColumnTenant}): domainProject,
- StringBuilder([]string{model.ColumnServiceKey, model.ColumnEnv}): in.Environment,
- StringBuilder([]string{model.ColumnServiceKey, model.ColumnAppID}): in.AppId,
- StringBuilder([]string{model.ColumnServiceKey, model.ColumnVersion}): in.Version,
- StringBuilder([]string{model.ColumnServiceKey, model.ColumnServiceName}): in.ServiceName}
+ return util.NewFilter(
+ util.ServiceType(serviceType),
+ util.ServiceKeyTenant(domainProject),
+ util.ServiceKeyServiceEnv(in.Environment),
+ util.ServiceKeyServiceName(in.ServiceName),
+ )
+ }
+ return util.NewFilter(
+ util.ServiceType(serviceType),
+ util.ServiceKeyTenant(domainProject),
+ util.ServiceKeyServiceEnv(in.Environment),
+ util.ServiceKeyAppID(in.AppId),
+ util.ServiceKeyServiceVersion(in.Version),
+ util.ServiceServiceName(in.ServiceName),
+ )
}
diff --git a/datasource/mongo/engine.go b/datasource/mongo/engine.go
index 96dfe2b..7346733 100644
--- a/datasource/mongo/engine.go
+++ b/datasource/mongo/engine.go
@@ -25,12 +25,11 @@ import (
"time"
pb "github.com/go-chassis/cari/discovery"
- "go.mongodb.org/mongo-driver/bson"
"github.com/apache/servicecomb-service-center/datasource"
"github.com/apache/servicecomb-service-center/datasource/etcd/path"
"github.com/apache/servicecomb-service-center/datasource/mongo/client"
- "github.com/apache/servicecomb-service-center/datasource/mongo/model"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/model"
mutil "github.com/apache/servicecomb-service-center/datasource/mongo/util"
"github.com/apache/servicecomb-service-center/pkg/cluster"
"github.com/apache/servicecomb-service-center/pkg/gopool"
@@ -235,10 +234,7 @@ func (ds *DataSource) autoSelfHeartBeat() {
}
func GetAllServicesAcrossDomainProject(ctx context.Context) (map[string][]*pb.MicroService, error) {
- domain := util.ParseDomain(ctx)
- project := util.ParseProject(ctx)
-
- filter := bson.M{"domain": domain, "project": project}
+ filter := mutil.NewBasicFilter(ctx)
findRes, err := client.GetMongoClient().Find(ctx, model.CollectionService, filter)
if err != nil {
diff --git a/datasource/mongo/event/instance_event_handler.go b/datasource/mongo/event/instance_event_handler.go
index a2804ab..9dbe5bc 100644
--- a/datasource/mongo/event/instance_event_handler.go
+++ b/datasource/mongo/event/instance_event_handler.go
@@ -28,7 +28,8 @@ import (
"github.com/apache/servicecomb-service-center/datasource"
"github.com/apache/servicecomb-service-center/datasource/mongo"
- "github.com/apache/servicecomb-service-center/datasource/mongo/model"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/dao"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/model"
"github.com/apache/servicecomb-service-center/datasource/mongo/sd"
"github.com/apache/servicecomb-service-center/pkg/dump"
"github.com/apache/servicecomb-service-center/pkg/log"
@@ -60,7 +61,7 @@ func (h InstanceEventHandler) OnEvent(evt sd.MongoEvent) {
}
if microService == nil {
log.Info("get cached service failed, then get from database")
- service, err := mongo.GetService(context.Background(), bson.M{"serviceinfo.serviceid": providerID})
+ service, err := dao.GetService(context.Background(), bson.M{"serviceinfo.serviceid": providerID})
if err != nil {
if errors.Is(err, datasource.ErrNoData) {
log.Warn(fmt.Sprintf("there is no service with id [%s] in the database", providerID))
diff --git a/datasource/mongo/event/instance_event_handler_test.go b/datasource/mongo/event/instance_event_handler_test.go
index 1813f01..a080e18 100644
--- a/datasource/mongo/event/instance_event_handler_test.go
+++ b/datasource/mongo/event/instance_event_handler_test.go
@@ -29,7 +29,7 @@ import (
"github.com/stretchr/testify/assert"
"github.com/apache/servicecomb-service-center/datasource/mongo/client"
- "github.com/apache/servicecomb-service-center/datasource/mongo/model"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/model"
"github.com/apache/servicecomb-service-center/datasource/mongo/sd"
"github.com/apache/servicecomb-service-center/server/syncernotify"
diff --git a/datasource/mongo/heartbeat/cache/heartbeat.go b/datasource/mongo/heartbeat/cache/heartbeat.go
index 506fd55..61e9b53 100644
--- a/datasource/mongo/heartbeat/cache/heartbeat.go
+++ b/datasource/mongo/heartbeat/cache/heartbeat.go
@@ -27,9 +27,9 @@ import (
"github.com/patrickmn/go-cache"
"go.mongodb.org/mongo-driver/bson"
- "github.com/apache/servicecomb-service-center/datasource/mongo"
"github.com/apache/servicecomb-service-center/datasource/mongo/client"
- "github.com/apache/servicecomb-service-center/datasource/mongo/model"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/model"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/util"
"github.com/apache/servicecomb-service-center/pkg/gopool"
"github.com/apache/servicecomb-service-center/pkg/log"
"github.com/apache/servicecomb-service-center/server/config"
@@ -130,11 +130,7 @@ func cleanInstance(ctx context.Context, serviceID string, instanceID string) err
}
defer session.EndSession(ctx)
- filter := bson.M{
- mongo.StringBuilder([]string{model.ColumnInstance, model.ColumnServiceID}): serviceID,
- mongo.StringBuilder([]string{model.ColumnInstance, model.ColumnInstanceID}): instanceID,
- }
-
+ filter := util.NewFilter(util.InstanceServiceID(serviceID), util.InstanceInstanceID(instanceID))
result, err := client.GetMongoClient().FindOne(ctx, model.CollectionInstance, filter)
if err != nil {
log.Error("failed to query instance: %v", err)
@@ -167,10 +163,7 @@ func cleanInstance(ctx context.Context, serviceID string, instanceID string) err
}
func removeDBInstance(ctx context.Context, serviceID string, instanceID string) error {
- filter := bson.M{
- mongo.StringBuilder([]string{model.ColumnInstance, model.ColumnServiceID}): serviceID,
- mongo.StringBuilder([]string{model.ColumnInstance, model.ColumnInstanceID}): instanceID,
- }
+ filter := util.NewFilter(util.InstanceServiceID(serviceID), util.InstanceInstanceID(instanceID))
res, err := client.GetMongoClient().DeleteOne(ctx, model.CollectionInstance, filter)
if err != nil {
log.Error("failed to clean instance", err)
@@ -181,10 +174,7 @@ func removeDBInstance(ctx context.Context, serviceID string, instanceID string)
}
func findInstance(ctx context.Context, serviceID string, instanceID string) (*model.Instance, error) {
- filter := bson.M{
- mongo.StringBuilder([]string{model.ColumnInstance, model.ColumnServiceID}): serviceID,
- mongo.StringBuilder([]string{model.ColumnInstance, model.ColumnInstanceID}): instanceID,
- }
+ filter := util.NewFilter(util.InstanceServiceID(serviceID), util.InstanceInstanceID(instanceID))
result, err := client.GetMongoClient().FindOne(ctx, model.CollectionInstance, filter)
if err != nil {
return nil, err
@@ -199,10 +189,7 @@ func findInstance(ctx context.Context, serviceID string, instanceID string) (*mo
}
func updateInstance(ctx context.Context, serviceID string, instanceID string) error {
- filter := bson.M{
- mongo.StringBuilder([]string{model.ColumnInstance, model.ColumnServiceID}): serviceID,
- mongo.StringBuilder([]string{model.ColumnInstance, model.ColumnInstanceID}): instanceID,
- }
+ filter := util.NewFilter(util.InstanceServiceID(serviceID), util.InstanceInstanceID(instanceID))
update := bson.M{
"$set": bson.M{model.ColumnRefreshTime: time.Now()},
}
diff --git a/datasource/mongo/heartbeat/cache/heartbeat_test.go b/datasource/mongo/heartbeat/cache/heartbeat_test.go
index 91c503b..d6845e6 100644
--- a/datasource/mongo/heartbeat/cache/heartbeat_test.go
+++ b/datasource/mongo/heartbeat/cache/heartbeat_test.go
@@ -32,7 +32,7 @@ import (
"github.com/stretchr/testify/assert"
"github.com/apache/servicecomb-service-center/datasource/mongo/client"
- "github.com/apache/servicecomb-service-center/datasource/mongo/model"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/model"
)
func init() {
diff --git a/datasource/mongo/heartbeat/cache/heartbeatcache_test.go b/datasource/mongo/heartbeat/cache/heartbeatcache_test.go
index 835dd2f..028eb66 100644
--- a/datasource/mongo/heartbeat/cache/heartbeatcache_test.go
+++ b/datasource/mongo/heartbeat/cache/heartbeatcache_test.go
@@ -26,9 +26,9 @@ import (
"github.com/stretchr/testify/assert"
"go.mongodb.org/mongo-driver/bson"
- "github.com/apache/servicecomb-service-center/datasource/mongo"
"github.com/apache/servicecomb-service-center/datasource/mongo/client"
- "github.com/apache/servicecomb-service-center/datasource/mongo/model"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/model"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/util"
)
func TestHeartBeatCheck(t *testing.T) {
@@ -68,7 +68,7 @@ func TestHeartBeatCheck(t *testing.T) {
},
}
filter := bson.M{
- mongo.StringBuilder([]string{model.ColumnInstance, model.ColumnInstanceID}): instanceDB.Instance.InstanceId,
+ util.ConnectWithDot([]string{model.ColumnInstance, model.ColumnInstanceID}): instanceDB.Instance.InstanceId,
}
_, _ = client.GetMongoClient().Delete(context.Background(), model.CollectionInstance, filter)
_, err := client.GetMongoClient().Insert(context.Background(), model.CollectionInstance, instanceDB)
diff --git a/datasource/mongo/heartbeat/checker/heartbeat.go b/datasource/mongo/heartbeat/checker/heartbeat.go
index a5fb039..1bb3998 100644
--- a/datasource/mongo/heartbeat/checker/heartbeat.go
+++ b/datasource/mongo/heartbeat/checker/heartbeat.go
@@ -23,17 +23,14 @@ import (
"go.mongodb.org/mongo-driver/bson"
- "github.com/apache/servicecomb-service-center/datasource/mongo"
"github.com/apache/servicecomb-service-center/datasource/mongo/client"
- "github.com/apache/servicecomb-service-center/datasource/mongo/model"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/model"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/util"
"github.com/apache/servicecomb-service-center/pkg/log"
)
func updateInstanceRefreshTime(ctx context.Context, serviceID string, instanceID string) error {
- filter := bson.M{
- mongo.StringBuilder([]string{model.ColumnInstance, model.ColumnServiceID}): serviceID,
- mongo.StringBuilder([]string{model.ColumnInstance, model.ColumnInstanceID}): instanceID,
- }
+ filter := util.NewFilter(util.InstanceServiceID(serviceID), util.InstanceInstanceID(instanceID))
update := bson.M{
"$set": bson.M{model.ColumnRefreshTime: time.Now()},
}
diff --git a/datasource/mongo/heartbeat/checker/heartbeat_test.go b/datasource/mongo/heartbeat/checker/heartbeat_test.go
index c97ab27..520e5bb 100644
--- a/datasource/mongo/heartbeat/checker/heartbeat_test.go
+++ b/datasource/mongo/heartbeat/checker/heartbeat_test.go
@@ -25,15 +25,13 @@ import (
_ "github.com/apache/servicecomb-service-center/server/init"
_ "github.com/apache/servicecomb-service-center/server/plugin/security/cipher/buildin"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/model"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/util"
+ "github.com/apache/servicecomb-service-center/pkg/log"
pb "github.com/go-chassis/cari/discovery"
"github.com/go-chassis/go-chassis/v2/storage"
"github.com/stretchr/testify/assert"
- "go.mongodb.org/mongo-driver/bson"
-
- "github.com/apache/servicecomb-service-center/datasource/mongo"
- "github.com/apache/servicecomb-service-center/datasource/mongo/client"
- "github.com/apache/servicecomb-service-center/datasource/mongo/model"
- "github.com/apache/servicecomb-service-center/pkg/log"
)
func init() {
@@ -62,20 +60,14 @@ func TestUpdateInstanceRefreshTime(t *testing.T) {
assert.Equal(t, nil, err)
err = updateInstanceRefreshTime(context.Background(), instance1.Instance.ServiceId, instance1.Instance.InstanceId)
assert.Equal(t, nil, err)
- filter := bson.M{
- mongo.StringBuilder([]string{model.ColumnInstance, model.ColumnServiceID}): instance1.Instance.ServiceId,
- mongo.StringBuilder([]string{model.ColumnInstance, model.ColumnInstanceID}): instance1.Instance.InstanceId,
- }
+ filter := util.NewFilter(util.InstanceServiceID(instance1.Instance.ServiceId), util.InstanceInstanceID(instance1.Instance.InstanceId))
result, err := client.GetMongoClient().FindOne(context.Background(), model.CollectionInstance, filter)
assert.Nil(t, err)
var ins model.Instance
err = result.Decode(&ins)
assert.Nil(t, err)
assert.NotEqual(t, instance1.RefreshTime, ins.RefreshTime)
- filter = bson.M{
- mongo.StringBuilder([]string{model.ColumnInstance, model.ColumnServiceID}): instance1.Instance.ServiceId,
- mongo.StringBuilder([]string{model.ColumnInstance, model.ColumnInstanceID}): instance1.Instance.InstanceId,
- }
+ filter = util.NewFilter(util.InstanceServiceID(instance1.Instance.ServiceId), util.InstanceInstanceID(instance1.Instance.InstanceId))
_, err = client.GetMongoClient().Delete(context.Background(), model.CollectionInstance, filter)
assert.Nil(t, err)
})
diff --git a/datasource/mongo/heartbeat/checker/heartbeatchecker_test.go b/datasource/mongo/heartbeat/checker/heartbeatchecker_test.go
index 6724a48..1abf13c 100644
--- a/datasource/mongo/heartbeat/checker/heartbeatchecker_test.go
+++ b/datasource/mongo/heartbeat/checker/heartbeatchecker_test.go
@@ -22,13 +22,11 @@ import (
"testing"
"time"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/model"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/util"
pb "github.com/go-chassis/cari/discovery"
"github.com/stretchr/testify/assert"
- "go.mongodb.org/mongo-driver/bson"
-
- "github.com/apache/servicecomb-service-center/datasource/mongo"
- "github.com/apache/servicecomb-service-center/datasource/mongo/client"
- "github.com/apache/servicecomb-service-center/datasource/mongo/model"
)
func TestHeartbeat(t *testing.T) {
@@ -59,9 +57,7 @@ func TestHeartbeat(t *testing.T) {
})
assert.Nil(t, err)
assert.Equal(t, pb.ResponseSuccess, resp.Response.GetCode())
- filter := bson.M{
- mongo.StringBuilder([]string{model.ColumnInstance, model.ColumnInstanceID}): instance1.Instance.InstanceId,
- }
+ filter := util.NewFilter(util.InstanceInstanceID(instance1.Instance.InstanceId))
_, err = client.GetMongoClient().Delete(context.Background(), model.CollectionInstance, filter)
assert.Nil(t, err)
})
diff --git a/datasource/mongo/mongo.go b/datasource/mongo/mongo.go
index f7e813f..2d8ee89 100644
--- a/datasource/mongo/mongo.go
+++ b/datasource/mongo/mongo.go
@@ -26,8 +26,8 @@ import (
"github.com/apache/servicecomb-service-center/datasource"
"github.com/apache/servicecomb-service-center/datasource/mongo/client"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/model"
"github.com/apache/servicecomb-service-center/datasource/mongo/heartbeat"
- "github.com/apache/servicecomb-service-center/datasource/mongo/model"
"github.com/apache/servicecomb-service-center/datasource/mongo/sd"
mutil "github.com/apache/servicecomb-service-center/datasource/mongo/util"
"github.com/apache/servicecomb-service-center/pkg/log"
@@ -120,14 +120,14 @@ func EnsureService() {
wrapCreateCollectionError(err)
serviceIDIndex := mutil.BuildIndexDoc(
- StringBuilder([]string{model.ColumnService, model.ColumnServiceID}))
+ mutil.ConnectWithDot([]string{model.ColumnService, model.ColumnServiceID}))
serviceIDIndex.Options = options.Index().SetUnique(true)
serviceIndex := mutil.BuildIndexDoc(
- StringBuilder([]string{model.ColumnService, model.ColumnAppID}),
- StringBuilder([]string{model.ColumnService, model.ColumnServiceName}),
- StringBuilder([]string{model.ColumnService, model.ColumnEnv}),
- StringBuilder([]string{model.ColumnService, model.ColumnVersion}),
+ mutil.ConnectWithDot([]string{model.ColumnService, model.ColumnAppID}),
+ mutil.ConnectWithDot([]string{model.ColumnService, model.ColumnServiceName}),
+ mutil.ConnectWithDot([]string{model.ColumnService, model.ColumnEnv}),
+ mutil.ConnectWithDot([]string{model.ColumnService, model.ColumnVersion}),
model.ColumnDomain,
model.ColumnProject)
serviceIndex.Options = options.Index().SetUnique(true)
@@ -146,7 +146,7 @@ func EnsureInstance() {
instanceIndex := mutil.BuildIndexDoc(model.ColumnRefreshTime)
instanceIndex.Options = options.Index().SetExpireAfterSeconds(defaultExpireTime)
- instanceServiceIndex := mutil.BuildIndexDoc(StringBuilder([]string{model.ColumnInstance, model.ColumnServiceID}))
+ instanceServiceIndex := mutil.BuildIndexDoc(mutil.ConnectWithDot([]string{model.ColumnInstance, model.ColumnServiceID}))
var instanceIndexs []mongo.IndexModel
instanceIndexs = append(instanceIndexs, instanceIndex, instanceServiceIndex)
diff --git a/datasource/mongo/ms.go b/datasource/mongo/ms.go
index 386b56f..ac2f231 100644
--- a/datasource/mongo/ms.go
+++ b/datasource/mongo/ms.go
@@ -37,8 +37,9 @@ import (
"github.com/apache/servicecomb-service-center/datasource"
"github.com/apache/servicecomb-service-center/datasource/mongo/client"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/dao"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/model"
"github.com/apache/servicecomb-service-center/datasource/mongo/heartbeat"
- "github.com/apache/servicecomb-service-center/datasource/mongo/model"
"github.com/apache/servicecomb-service-center/datasource/mongo/sd"
mutil "github.com/apache/servicecomb-service-center/datasource/mongo/util"
"github.com/apache/servicecomb-service-center/pkg/gopool"
@@ -49,8 +50,9 @@ import (
"github.com/apache/servicecomb-service-center/server/plugin/uuid"
)
-func (ds *DataSource) RegisterService(ctx context.Context, request *discovery.CreateServiceRequest) (
- *discovery.CreateServiceResponse, error) {
+const baseTen = 10
+
+func (ds *DataSource) RegisterService(ctx context.Context, request *discovery.CreateServiceRequest) (*discovery.CreateServiceResponse, error) {
service := request.Service
remoteIP := util.GetIPFromContext(ctx)
domain := util.ParseDomain(ctx)
@@ -136,15 +138,13 @@ func (ds *DataSource) RegisterService(ctx context.Context, request *discovery.Cr
}, nil
}
-func (ds *DataSource) GetServices(ctx context.Context, request *discovery.GetServicesRequest) (
- *discovery.GetServicesResponse, error) {
-
+func (ds *DataSource) GetServices(ctx context.Context, request *discovery.GetServicesRequest) (*discovery.GetServicesResponse, error) {
domain := util.ParseDomain(ctx)
project := util.ParseProject(ctx)
filter := bson.M{model.ColumnDomain: domain, model.ColumnProject: project}
- services, err := GetServices(ctx, filter)
+ services, err := dao.GetMicroServices(ctx, filter)
if err != nil {
return &discovery.GetServicesResponse{
Response: discovery.CreateResponse(discovery.ErrInternal, "get services data failed."),
@@ -164,9 +164,9 @@ func (ds *DataSource) GetApplications(ctx context.Context, request *discovery.Ge
filter := bson.M{
model.ColumnDomain: domain,
model.ColumnProject: project,
- StringBuilder([]string{model.ColumnService, model.ColumnEnv}): request.Environment}
+ mutil.ConnectWithDot([]string{model.ColumnService, model.ColumnEnv}): request.Environment}
- services, err := GetServices(ctx, filter)
+ services, err := dao.GetMicroServices(ctx, filter)
if err != nil {
return &discovery.GetAppsResponse{
Response: discovery.CreateResponse(discovery.ErrInternal, "get services data failed."),
@@ -196,8 +196,7 @@ func (ds *DataSource) GetApplications(ctx context.Context, request *discovery.Ge
}, nil
}
-func (ds *DataSource) GetService(ctx context.Context, request *discovery.GetServiceRequest) (
- *discovery.GetServiceResponse, error) {
+func (ds *DataSource) GetService(ctx context.Context, request *discovery.GetServiceRequest) (*discovery.GetServiceResponse, error) {
svc, err := GetServiceByID(ctx, request.ServiceId)
if err != nil {
if errors.Is(err, datasource.ErrNoData) {
@@ -292,7 +291,8 @@ func (ds *DataSource) DelServicePri(ctx context.Context, serviceID string, force
log.Error(fmt.Sprintf("%s micro-service %s failed, operator: %s", title, serviceID, remoteIP), mutil.ErrNotAllowDeleteSC)
return discovery.CreateResponse(discovery.ErrInvalidParams, mutil.ErrNotAllowDeleteSC.Error()), nil
}
- microservice, err := GetService(ctx, GeneratorServiceFilter(ctx, serviceID))
+ filter := mutil.NewBasicFilter(ctx, mutil.ServiceServiceID(serviceID))
+ microservice, err := dao.GetService(ctx, filter)
if err != nil {
if errors.Is(err, datasource.ErrNoData) {
log.Debug(fmt.Sprintf("%s micro-service %s failed, service does not exist, operator: %s",
@@ -318,7 +318,7 @@ func (ds *DataSource) DelServicePri(ctx context.Context, serviceID string, force
return discovery.CreateResponse(discovery.ErrDependedOnConsumer, "Can not delete this service, other service rely it."), err
}
//todo wait for dep interface
- instancesExist, err := client.GetMongoClient().DocExist(ctx, model.CollectionInstance, bson.M{StringBuilder([]string{model.ColumnInstance, model.ColumnServiceID}): serviceID})
+ instancesExist, err := client.GetMongoClient().DocExist(ctx, model.CollectionInstance, bson.M{mutil.ConnectWithDot([]string{model.ColumnInstance, model.ColumnServiceID}): serviceID})
if err != nil {
log.Error(fmt.Sprintf("delete micro-service[%s] failed, get instances number failed, operator: %s",
serviceID, remoteIP), err)
@@ -334,8 +334,8 @@ func (ds *DataSource) DelServicePri(ctx context.Context, serviceID string, force
schemaOps := client.MongoOperation{Table: model.CollectionSchema, Models: []mongo.WriteModel{mongo.NewDeleteManyModel().SetFilter(bson.M{model.ColumnServiceID: serviceID})}}
rulesOps := client.MongoOperation{Table: model.CollectionRule, Models: []mongo.WriteModel{mongo.NewDeleteManyModel().SetFilter(bson.M{model.ColumnServiceID: serviceID})}}
- instanceOps := client.MongoOperation{Table: model.CollectionInstance, Models: []mongo.WriteModel{mongo.NewDeleteManyModel().SetFilter(bson.M{StringBuilder([]string{model.ColumnInstance, model.ColumnServiceID}): serviceID})}}
- serviceOps := client.MongoOperation{Table: model.CollectionService, Models: []mongo.WriteModel{mongo.NewDeleteOneModel().SetFilter(bson.M{StringBuilder([]string{model.ColumnService, model.ColumnServiceID}): serviceID})}}
+ instanceOps := client.MongoOperation{Table: model.CollectionInstance, Models: []mongo.WriteModel{mongo.NewDeleteManyModel().SetFilter(bson.M{mutil.ConnectWithDot([]string{model.ColumnInstance, model.ColumnServiceID}): serviceID})}}
+ serviceOps := client.MongoOperation{Table: model.CollectionService, Models: []mongo.WriteModel{mongo.NewDeleteOneModel().SetFilter(bson.M{mutil.ConnectWithDot([]string{model.ColumnService, model.ColumnServiceID}): serviceID})}}
err = client.GetMongoClient().MultiTableBatchUpdate(ctx, []client.MongoOperation{schemaOps, rulesOps, instanceOps, serviceOps})
if err != nil {
@@ -362,13 +362,16 @@ func (ds *DataSource) DelServicePri(ctx context.Context, serviceID string, force
return discovery.CreateResponse(discovery.ResponseSuccess, "Unregister service successfully."), nil
}
-func (ds *DataSource) UpdateService(ctx context.Context, request *discovery.UpdateServicePropsRequest) (
- *discovery.UpdateServicePropsResponse, error) {
- updateData := bson.M{
- "$set": bson.M{
- StringBuilder([]string{model.ColumnService, model.ColumnModTime}): strconv.FormatInt(time.Now().Unix(), 10),
- StringBuilder([]string{model.ColumnService, model.ColumnProperty}): request.Properties}}
- err := UpdateService(ctx, GeneratorServiceFilter(ctx, request.ServiceId), updateData)
+func (ds *DataSource) UpdateService(ctx context.Context, request *discovery.UpdateServicePropsRequest) (*discovery.UpdateServicePropsResponse, error) {
+ filter := mutil.NewBasicFilter(ctx, mutil.ServiceServiceID(request.ServiceId))
+ setFilter := mutil.NewFilter(
+ mutil.ServiceModTime(strconv.FormatInt(time.Now().Unix(), baseTen)),
+ mutil.ServiceProperty(request.Properties),
+ )
+ updateFilter := mutil.NewFilter(
+ mutil.Set(setFilter),
+ )
+ err := dao.UpdateService(ctx, filter, updateFilter)
if err != nil {
log.Error(fmt.Sprintf("update service %s properties failed, update mongo failed", request.ServiceId), err)
return &discovery.UpdateServicePropsResponse{
@@ -380,8 +383,7 @@ func (ds *DataSource) UpdateService(ctx context.Context, request *discovery.Upda
}, nil
}
-func (ds *DataSource) GetDeleteServiceFunc(ctx context.Context, serviceID string, force bool,
- serviceRespChan chan<- *discovery.DelServicesRspInfo) func(context.Context) {
+func (ds *DataSource) GetDeleteServiceFunc(ctx context.Context, serviceID string, force bool, serviceRespChan chan<- *discovery.DelServicesRspInfo) func(context.Context) {
return func(_ context.Context) {
serviceRst := &discovery.DelServicesRspInfo{
ServiceId: serviceID,
@@ -398,9 +400,9 @@ func (ds *DataSource) GetDeleteServiceFunc(ctx context.Context, serviceID string
}
}
-func (ds *DataSource) GetServiceDetail(ctx context.Context, request *discovery.GetServiceRequest) (
- *discovery.GetServiceDetailResponse, error) {
- mgSvc, err := GetService(ctx, GeneratorServiceFilter(ctx, request.ServiceId))
+func (ds *DataSource) GetServiceDetail(ctx context.Context, request *discovery.GetServiceRequest) (*discovery.GetServiceDetailResponse, error) {
+ filter := mutil.NewBasicFilter(ctx, mutil.ServiceServiceID(request.ServiceId))
+ mgSvc, err := dao.GetService(ctx, filter)
if err != nil {
if errors.Is(err, datasource.ErrNoData) {
return &discovery.GetServiceDetailResponse{
@@ -417,7 +419,12 @@ func (ds *DataSource) GetServiceDetail(ctx context.Context, request *discovery.G
AppId: svc.AppId,
ServiceName: svc.ServiceName,
}
- versions, err := GetServicesVersions(ctx, GeneratorServiceVersionsFilter(ctx, key))
+ filter = mutil.NewBasicFilter(ctx,
+ mutil.ServiceEnv(key.Environment),
+ mutil.ServiceAppID(key.AppId),
+ mutil.ServiceServiceName(key.ServiceName),
+ )
+ versions, err := dao.GetServicesVersions(ctx, filter)
if err != nil {
log.Error(fmt.Sprintf("get service %s %s %s all versions failed", svc.Environment, svc.AppId, svc.ServiceName), err)
return &discovery.GetServiceDetailResponse{
@@ -440,8 +447,7 @@ func (ds *DataSource) GetServiceDetail(ctx context.Context, request *discovery.G
}
-func (ds *DataSource) GetServicesInfo(ctx context.Context, request *discovery.GetServicesInfoRequest) (
- *discovery.GetServicesInfoResponse, error) {
+func (ds *DataSource) GetServicesInfo(ctx context.Context, request *discovery.GetServicesInfoRequest) (*discovery.GetServicesInfoResponse, error) {
optionMap := make(map[string]struct{}, len(request.Options))
for _, opt := range request.Options {
optionMap[opt] = struct{}{}
@@ -472,7 +478,7 @@ func (ds *DataSource) GetServicesInfo(ctx context.Context, request *discovery.Ge
}, nil
}
}
- services, err := GetMongoServices(ctx, bson.M{})
+ services, err := dao.GetServices(ctx, bson.M{})
if err != nil {
log.Error("get all services by domain failed", err)
return &discovery.GetServicesInfoResponse{
@@ -512,7 +518,14 @@ func (ds *DataSource) GetServicesInfo(ctx context.Context, request *discovery.Ge
}
func (ds *DataSource) AddTags(ctx context.Context, request *discovery.AddServiceTagsRequest) (*discovery.AddServiceTagsResponse, error) {
- err := UpdateService(ctx, GeneratorServiceFilter(ctx, request.ServiceId), bson.M{"$set": bson.M{model.ColumnTag: request.Tags}})
+ filter := mutil.NewBasicFilter(ctx, mutil.ServiceServiceID(request.ServiceId))
+ setFilter := mutil.NewFilter(
+ mutil.Tags(request.Tags),
+ )
+ updateFilter := mutil.NewFilter(
+ mutil.Set(setFilter),
+ )
+ err := dao.UpdateService(ctx, filter, updateFilter)
if err == nil {
return &discovery.AddServiceTagsResponse{
Response: discovery.CreateResponse(discovery.ResponseSuccess, "Add service tags successfully."),
@@ -530,7 +543,8 @@ func (ds *DataSource) AddTags(ctx context.Context, request *discovery.AddService
}
func (ds *DataSource) GetTags(ctx context.Context, request *discovery.GetServiceTagsRequest) (*discovery.GetServiceTagsResponse, error) {
- svc, err := GetService(ctx, GeneratorServiceFilter(ctx, request.ServiceId))
+ filter := mutil.NewBasicFilter(ctx, mutil.ServiceServiceID(request.ServiceId))
+ svc, err := dao.GetService(ctx, filter)
if err != nil {
if errors.Is(err, datasource.ErrNoData) {
log.Debug(fmt.Sprintf("service %s not exist in db", request.ServiceId))
@@ -550,7 +564,8 @@ func (ds *DataSource) GetTags(ctx context.Context, request *discovery.GetService
}
func (ds *DataSource) UpdateTag(ctx context.Context, request *discovery.UpdateServiceTagRequest) (*discovery.UpdateServiceTagResponse, error) {
- svc, err := GetService(ctx, GeneratorServiceFilter(ctx, request.ServiceId))
+ filter := mutil.NewBasicFilter(ctx, mutil.ServiceServiceID(request.ServiceId))
+ svc, err := dao.GetService(ctx, filter)
if err != nil {
if errors.Is(err, datasource.ErrNoData) {
log.Debug(fmt.Sprintf("service %s not exist in db", request.ServiceId))
@@ -576,8 +591,13 @@ func (ds *DataSource) UpdateTag(ctx context.Context, request *discovery.UpdateSe
newTags[k] = v
}
newTags[request.Key] = request.Value
-
- err = UpdateService(ctx, GeneratorServiceFilter(ctx, request.ServiceId), bson.M{"$set": bson.M{model.ColumnTag: newTags}})
+ setFilter := mutil.NewFilter(
+ mutil.Tags(newTags),
+ )
+ updateFilter := mutil.NewFilter(
+ mutil.Set(setFilter),
+ )
+ err = dao.UpdateService(ctx, filter, updateFilter)
if err != nil {
log.Error(fmt.Sprintf("update service %s tags failed", request.ServiceId), err)
return &discovery.UpdateServiceTagResponse{
@@ -590,7 +610,8 @@ func (ds *DataSource) UpdateTag(ctx context.Context, request *discovery.UpdateSe
}
func (ds *DataSource) DeleteTags(ctx context.Context, request *discovery.DeleteServiceTagsRequest) (*discovery.DeleteServiceTagsResponse, error) {
- svc, err := GetService(ctx, GeneratorServiceFilter(ctx, request.ServiceId))
+ filter := mutil.NewBasicFilter(ctx, mutil.ServiceServiceID(request.ServiceId))
+ svc, err := dao.GetService(ctx, filter)
if err != nil {
if errors.Is(err, datasource.ErrNoData) {
log.Debug(fmt.Sprintf("service %s not exist in db", request.ServiceId))
@@ -618,7 +639,13 @@ func (ds *DataSource) DeleteTags(ctx context.Context, request *discovery.DeleteS
delete(newTags, key)
}
}
- err = UpdateService(ctx, GeneratorServiceFilter(ctx, request.ServiceId), bson.M{"$set": bson.M{model.ColumnTag: newTags}})
+ setFilter := mutil.NewFilter(
+ mutil.Tags(newTags),
+ )
+ updateFilter := mutil.NewFilter(
+ mutil.Set(setFilter),
+ )
+ err = dao.UpdateService(ctx, filter, updateFilter)
if err != nil {
log.Error(fmt.Sprintf("delete service %s tags failed", request.ServiceId), err)
return &discovery.DeleteServiceTagsResponse{
@@ -642,7 +669,8 @@ func (ds *DataSource) GetSchema(ctx context.Context, request *discovery.GetSchem
Response: discovery.CreateResponse(discovery.ErrServiceNotExists, "GetSchema service does not exist."),
}, nil
}
- schema, err := GetSchema(ctx, GeneratorSchemaFilter(ctx, request.ServiceId, request.SchemaId))
+ filter := mutil.NewBasicFilter(ctx, mutil.ServiceID(request.ServiceId), mutil.SchemaID(request.SchemaId))
+ schema, err := dao.GetSchema(ctx, filter)
if err != nil {
return &discovery.GetSchemaResponse{
Response: discovery.CreateResponse(discovery.ErrInternal, "GetSchema failed from mongodb."),
@@ -661,7 +689,10 @@ func (ds *DataSource) GetSchema(ctx context.Context, request *discovery.GetSchem
}
func (ds *DataSource) GetAllSchemas(ctx context.Context, request *discovery.GetAllSchemaRequest) (*discovery.GetAllSchemaResponse, error) {
- svc, err := GetService(ctx, GeneratorServiceFilter(ctx, request.ServiceId))
+ domain := util.ParseDomain(ctx)
+ project := util.ParseProject(ctx)
+ filter := mutil.NewDomainProjectFilter(domain, project, mutil.ServiceServiceID(request.ServiceId))
+ svc, err := dao.GetService(ctx, filter)
if err != nil {
if errors.Is(err, datasource.ErrNoData) {
log.Debug(fmt.Sprintf("service %s not exist in db", request.ServiceId))
@@ -685,7 +716,8 @@ func (ds *DataSource) GetAllSchemas(ctx context.Context, request *discovery.GetA
for _, schemaID := range schemasList {
tempSchema := &discovery.Schema{}
tempSchema.SchemaId = schemaID
- schema, err := GetSchema(ctx, GeneratorSchemaFilter(ctx, request.ServiceId, schemaID))
+ filter := mutil.NewDomainProjectFilter(domain, project, mutil.ServiceID(request.ServiceId), mutil.SchemaID(schemaID))
+ schema, err := dao.GetSchema(ctx, filter)
if err != nil {
return &discovery.GetAllSchemaResponse{
Response: discovery.CreateResponse(discovery.ErrInternal, err.Error()),
@@ -719,7 +751,8 @@ func (ds *DataSource) ExistSchema(ctx context.Context, request *discovery.GetExi
Response: discovery.CreateResponse(discovery.ErrServiceNotExists, "ExistSchema failed for service not exist"),
}, nil
}
- Schema, err := GetSchema(ctx, GeneratorSchemaFilter(ctx, request.ServiceId, request.SchemaId))
+ filter := mutil.NewBasicFilter(ctx, mutil.ServiceID(request.ServiceId), mutil.SchemaID(request.SchemaId))
+ Schema, err := dao.GetSchema(ctx, filter)
if err != nil {
return &discovery.GetExistenceResponse{
Response: discovery.CreateResponse(discovery.ErrInternal, "ExistSchema failed for get schema failed."),
@@ -750,7 +783,7 @@ func (ds *DataSource) DeleteSchema(ctx context.Context, request *discovery.Delet
Response: discovery.CreateResponse(discovery.ErrServiceNotExists, "DeleteSchema failed for service not exist."),
}, nil
}
- filter := GeneratorSchemaFilter(ctx, request.ServiceId, request.SchemaId)
+ filter := mutil.NewBasicFilter(ctx, mutil.ServiceID(request.ServiceId), mutil.SchemaID(request.SchemaId))
res, err := client.GetMongoClient().DocDelete(ctx, model.CollectionSchema, filter)
if err != nil {
return &discovery.DeleteSchemaResponse{
@@ -794,7 +827,8 @@ func (ds *DataSource) ModifySchema(ctx context.Context, request *discovery.Modif
}
func (ds *DataSource) ModifySchemas(ctx context.Context, request *discovery.ModifySchemasRequest) (*discovery.ModifySchemasResponse, error) {
- svc, err := GetService(ctx, GeneratorServiceFilter(ctx, request.ServiceId))
+ filter := mutil.NewBasicFilter(ctx, mutil.ServiceServiceID(request.ServiceId))
+ svc, err := dao.GetService(ctx, filter)
if err != nil {
if errors.Is(err, datasource.ErrNoData) {
return &discovery.ModifySchemasResponse{Response: discovery.CreateResponse(discovery.ErrServiceNotExists, "Service not exist")}, nil
@@ -821,9 +855,9 @@ func (ds *DataSource) modifySchemas(ctx context.Context, service *discovery.Micr
domain := util.ParseDomain(ctx)
project := util.ParseProject(ctx)
remoteIP := util.GetIPFromContext(ctx)
-
serviceID := service.ServiceId
- schemasFromDatabase, err := GetSchemas(ctx, bson.M{model.ColumnServiceID: serviceID})
+ filter := mutil.NewFilter(mutil.ServiceID(serviceID))
+ schemasFromDatabase, err := dao.GetSchemas(ctx, filter)
if err != nil {
log.Error(fmt.Sprintf("modify service %s schemas failed, get schemas failed, operator: %s", serviceID, remoteIP), err)
return discovery.NewError(discovery.ErrUnavailableBackend, err.Error())
@@ -842,7 +876,10 @@ func (ds *DataSource) modifySchemas(ctx context.Context, service *discovery.Micr
log.Error(fmt.Sprintf("modify service[%s] schemas failed, operator: %s", serviceID, remoteIP), errQuota)
return errQuota
}
- serviceOps = append(serviceOps, mongo.NewUpdateOneModel().SetUpdate(bson.M{"$set": bson.M{StringBuilder([]string{model.ColumnService, model.ColumnSchemas}): nonExistSchemaIds}}).SetFilter(GeneratorServiceFilter(ctx, serviceID)))
+ filter = mutil.NewDomainProjectFilter(domain, project, mutil.ServiceServiceID(serviceID))
+ setFilter := mutil.NewFilter(mutil.ServiceSchemas(nonExistSchemaIds))
+ updateFilter := mutil.NewFilter(mutil.Set(setFilter))
+ serviceOps = append(serviceOps, mongo.NewUpdateOneModel().SetUpdate(updateFilter).SetFilter(filter))
} else {
if len(nonExistSchemaIds) != 0 {
errInfo := fmt.Errorf("non-existent schemaIDs %v", nonExistSchemaIds)
@@ -850,12 +887,20 @@ func (ds *DataSource) modifySchemas(ctx context.Context, service *discovery.Micr
return discovery.NewError(discovery.ErrUndefinedSchemaID, errInfo.Error())
}
for _, needUpdateSchema := range needUpdateSchemas {
- exist, err := SchemaSummaryExist(ctx, serviceID, needUpdateSchema.SchemaId)
+ exist, err := dao.SchemaSummaryExist(ctx, serviceID, needUpdateSchema.SchemaId)
if err != nil {
return discovery.NewError(discovery.ErrInternal, err.Error())
}
if !exist {
- schemasOps = append(schemasOps, mongo.NewUpdateOneModel().SetFilter(GeneratorSchemaFilter(ctx, serviceID, needUpdateSchema.SchemaId)).SetUpdate(bson.M{"$set": bson.M{model.ColumnSchema: needUpdateSchema.Schema, model.ColumnSchemaSummary: needUpdateSchema.Summary}}))
+ filter = mutil.NewDomainProjectFilter(domain, project, mutil.ServiceID(serviceID), mutil.SchemaID(needUpdateSchema.SchemaId))
+ setFilter := mutil.NewFilter(
+ mutil.Schema(needUpdateSchema.Schema),
+ mutil.SchemaSummary(needUpdateSchema.Summary),
+ )
+ updateFilter := mutil.NewFilter(
+ mutil.Set(setFilter),
+ )
+ schemasOps = append(schemasOps, mongo.NewUpdateOneModel().SetFilter(filter).SetUpdate(updateFilter))
} else {
log.Warn(fmt.Sprintf("schema[%s/%s] and it's summary already exist, skip to update, operator: %s",
serviceID, needUpdateSchema.SchemaId, remoteIP))
@@ -900,16 +945,27 @@ func (ds *DataSource) modifySchemas(ctx context.Context, service *discovery.Micr
for _, schema := range needUpdateSchemas {
log.Info(fmt.Sprintf("update schema[%s/%s], operator: %s", serviceID, schema.SchemaId, remoteIP))
- schemasOps = append(schemasOps, mongo.NewUpdateOneModel().SetFilter(GeneratorSchemaFilter(ctx, serviceID, schema.SchemaId)).SetUpdate(bson.M{"$set": bson.M{model.ColumnSchema: schema.Schema, model.ColumnSchemaSummary: schema.Summary}}))
+ filter = mutil.NewDomainProjectFilter(domain, project, mutil.ServiceID(serviceID), mutil.SchemaID(schema.SchemaId))
+ setFilter := mutil.NewFilter(
+ mutil.Schema(schema.Schema),
+ mutil.SchemaSummary(schema.Summary),
+ )
+ updateFilter := mutil.NewFilter(
+ mutil.Set(setFilter),
+ )
+ schemasOps = append(schemasOps, mongo.NewUpdateOneModel().SetFilter(filter).SetUpdate(updateFilter))
schemaIDs = append(schemaIDs, schema.SchemaId)
}
for _, schema := range needDeleteSchemas {
log.Info(fmt.Sprintf("delete non-existent schema[%s/%s], operator: %s", serviceID, schema.SchemaId, remoteIP))
- schemasOps = append(schemasOps, mongo.NewDeleteOneModel().SetFilter(GeneratorSchemaFilter(ctx, serviceID, schema.SchemaId)))
+ filter := mutil.NewDomainProjectFilter(domain, project, mutil.ServiceID(serviceID), mutil.SchemaID(schema.SchemaId))
+ schemasOps = append(schemasOps, mongo.NewDeleteOneModel().SetFilter(filter))
}
-
- serviceOps = append(serviceOps, mongo.NewUpdateOneModel().SetUpdate(bson.M{"$set": bson.M{StringBuilder([]string{model.ColumnService, model.ColumnSchemas}): schemaIDs}}).SetFilter(GeneratorServiceFilter(ctx, serviceID)))
+ filter := mutil.NewDomainProjectFilter(domain, project, mutil.ServiceServiceID(serviceID))
+ setFilter := mutil.NewFilter(mutil.ServiceSchemas(schemaIDs))
+ updateFilter := mutil.NewFilter(mutil.Set(setFilter))
+ serviceOps = append(serviceOps, mongo.NewUpdateOneModel().SetUpdate(updateFilter).SetFilter(filter))
}
if len(schemasOps) > 0 {
_, err = client.GetMongoClient().BatchUpdate(ctx, model.CollectionSchema, schemasOps)
@@ -932,8 +988,11 @@ func (ds *DataSource) modifySchemas(ctx context.Context, service *discovery.Micr
// 3.service is editable && service have no relation with the schema --> update the schema && update the service
// 4.service can't edit && service have relation with the schema && schema summary not exist --> update the schema
func (ds *DataSource) modifySchema(ctx context.Context, serviceID string, schema *discovery.Schema) *discovery.Error {
+ domain := util.ParseDomain(ctx)
+ project := util.ParseProject(ctx)
+ filter := mutil.NewDomainProjectFilter(domain, project, mutil.ServiceServiceID(serviceID))
remoteIP := util.GetIPFromContext(ctx)
- svc, err := GetService(ctx, GeneratorServiceFilter(ctx, serviceID))
+ svc, err := dao.GetService(ctx, filter)
if err != nil {
if errors.Is(err, datasource.ErrNoData) {
return discovery.NewError(discovery.ErrServiceNotExists, "Service does not exist.")
@@ -953,7 +1012,8 @@ func (ds *DataSource) modifySchema(ctx context.Context, serviceID string, schema
if len(microservice.Schemas) != 0 && !isExist {
return discovery.NewError(discovery.ErrUndefinedSchemaID, "Non-existent schemaID can't be added request "+discovery.ENV_PROD)
}
- respSchema, err := GetSchema(ctx, GeneratorSchemaFilter(ctx, serviceID, schema.SchemaId))
+ filter = mutil.NewDomainProjectFilter(domain, project, mutil.ServiceID(serviceID), mutil.SchemaID(schema.SchemaId))
+ respSchema, err := dao.GetSchema(ctx, filter)
if err != nil {
return discovery.NewError(discovery.ErrUnavailableBackend, err.Error())
}
@@ -981,14 +1041,25 @@ func (ds *DataSource) modifySchema(ctx context.Context, serviceID string, schema
}
}
if len(newSchemas) != 0 {
- updateData := bson.M{StringBuilder([]string{model.ColumnService, model.ColumnSchemas}): newSchemas}
- err = UpdateService(ctx, GeneratorServiceFilter(ctx, serviceID), bson.M{"$set": updateData})
+ filter = mutil.NewDomainProjectFilter(domain, project, mutil.ServiceServiceID(serviceID))
+ setFilter := mutil.NewFilter(
+ mutil.ServiceSchemas(newSchemas),
+ )
+ updateFilter := mutil.NewFilter(
+ mutil.Set(setFilter),
+ )
+ err = dao.UpdateService(ctx, filter, updateFilter)
if err != nil {
return discovery.NewError(discovery.ErrInternal, err.Error())
}
}
- newSchema := bson.M{"$set": bson.M{model.ColumnSchema: schema.Schema, model.ColumnSchemaSummary: schema.Summary}}
- err = UpdateSchema(ctx, GeneratorSchemaFilter(ctx, serviceID, schema.SchemaId), newSchema, options.FindOneAndUpdate().SetUpsert(true))
+ filter = mutil.NewDomainProjectFilter(domain, project, mutil.ServiceID(serviceID), mutil.SchemaID(schema.SchemaId))
+ setFilter := mutil.NewFilter(
+ mutil.Schema(schema.Schema),
+ mutil.SchemaSummary(schema.Summary),
+ )
+ updateFilter := mutil.NewFilter(mutil.Set(setFilter))
+ err = dao.UpdateSchema(ctx, filter, updateFilter, options.FindOneAndUpdate().SetUpsert(true))
if err != nil {
return discovery.NewError(discovery.ErrInternal, err.Error())
}
@@ -997,6 +1068,8 @@ func (ds *DataSource) modifySchema(ctx context.Context, serviceID string, schema
func (ds *DataSource) AddRule(ctx context.Context, request *discovery.AddServiceRulesRequest) (*discovery.AddServiceRulesResponse, error) {
remoteIP := util.GetIPFromContext(ctx)
+ domain := util.ParseDomain(ctx)
+ project := util.ParseProject(ctx)
exist, err := ServiceExistID(ctx, request.ServiceId)
if err != nil {
log.Error(fmt.Sprintf("failed to add rules for service %s for get service failed", request.ServiceId), err)
@@ -1019,7 +1092,8 @@ func (ds *DataSource) AddRule(ctx context.Context, request *discovery.AddService
}
return response, nil
}
- rules, err := GetRules(ctx, request.ServiceId)
+ filter := mutil.NewDomainProjectFilter(domain, project, mutil.ServiceID(request.ServiceId))
+ rules, err := dao.GetServiceRules(ctx, filter)
if err != nil {
return &discovery.AddServiceRulesResponse{
Response: discovery.CreateResponse(discovery.ErrInternal, err.Error()),
@@ -1039,7 +1113,12 @@ func (ds *DataSource) AddRule(ctx context.Context, request *discovery.AddService
}, nil
}
//the rule unique index is (serviceid,attribute,pattern)
- exist, err := RuleExist(ctx, GeneratorRuleAttFilter(ctx, request.ServiceId, rule.Attribute, rule.Pattern))
+ filter = mutil.NewFilter(
+ mutil.ServiceID(request.ServiceId),
+ mutil.RuleAttribute(rule.Attribute),
+ mutil.RulePattern(rule.Pattern),
+ )
+ exist, err := dao.RuleExist(ctx, filter)
if err != nil {
return &discovery.AddServiceRulesResponse{
Response: discovery.CreateResponse(discovery.ErrUnavailableBackend, "Can not check rule if exist."),
@@ -1077,8 +1156,7 @@ func (ds *DataSource) AddRule(ctx context.Context, request *discovery.AddService
}, nil
}
-func (ds *DataSource) GetRules(ctx context.Context, request *discovery.GetServiceRulesRequest) (
- *discovery.GetServiceRulesResponse, error) {
+func (ds *DataSource) GetRules(ctx context.Context, request *discovery.GetServiceRulesRequest) (*discovery.GetServiceRulesResponse, error) {
exist, err := ServiceExistID(ctx, request.ServiceId)
if err != nil {
return &discovery.GetServiceRulesResponse{
@@ -1090,7 +1168,8 @@ func (ds *DataSource) GetRules(ctx context.Context, request *discovery.GetServic
Response: discovery.CreateResponse(discovery.ErrServiceNotExists, "GetRules failed for service not exist."),
}, nil
}
- rules, err := GetRules(ctx, request.ServiceId)
+ filter := mutil.NewBasicFilter(ctx, mutil.ServiceID(request.ServiceId))
+ rules, err := dao.GetServiceRules(ctx, filter)
if err != nil {
return &discovery.GetServiceRulesResponse{
Response: discovery.CreateResponse(discovery.ErrInternal, err.Error()),
@@ -1102,9 +1181,10 @@ func (ds *DataSource) GetRules(ctx context.Context, request *discovery.GetServic
}, nil
}
-func (ds *DataSource) DeleteRule(ctx context.Context, request *discovery.DeleteServiceRulesRequest) (
- *discovery.DeleteServiceRulesResponse, error) {
+func (ds *DataSource) DeleteRule(ctx context.Context, request *discovery.DeleteServiceRulesRequest) (*discovery.DeleteServiceRulesResponse, error) {
exist, err := ServiceExistID(ctx, request.ServiceId)
+ domain := util.ParseDomain(ctx)
+ project := util.ParseProject(ctx)
if err != nil {
log.Error(fmt.Sprintf("failed to add tags for service %s for get service failed", request.ServiceId), err)
return &discovery.DeleteServiceRulesResponse{
@@ -1116,7 +1196,8 @@ func (ds *DataSource) DeleteRule(ctx context.Context, request *discovery.DeleteS
}
var delRules []mongo.WriteModel
for _, ruleID := range request.RuleIds {
- exist, err := RuleExist(ctx, GeneratorRuleFilter(ctx, request.ServiceId, ruleID))
+ filter := mutil.NewDomainProjectFilter(domain, project, mutil.ServiceID(request.ServiceId), mutil.RuleRuleID(ruleID))
+ exist, err := dao.RuleExist(ctx, filter)
if err != nil {
return &discovery.DeleteServiceRulesResponse{
Response: discovery.CreateResponse(discovery.ErrInternal, err.Error()),
@@ -1127,7 +1208,8 @@ func (ds *DataSource) DeleteRule(ctx context.Context, request *discovery.DeleteS
Response: discovery.CreateResponse(discovery.ErrRuleNotExists, "This rule does not exist."),
}, nil
}
- delRules = append(delRules, mongo.NewDeleteOneModel().SetFilter(GeneratorRuleFilter(ctx, request.ServiceId, ruleID)))
+ filter = mutil.NewDomainProjectFilter(domain, project, mutil.ServiceID(request.ServiceId), mutil.RuleRuleID(ruleID))
+ delRules = append(delRules, mongo.NewDeleteOneModel().SetFilter(filter))
}
if len(delRules) > 0 {
_, err := client.GetMongoClient().BatchDelete(ctx, model.CollectionRule, delRules)
@@ -1141,8 +1223,10 @@ func (ds *DataSource) DeleteRule(ctx context.Context, request *discovery.DeleteS
Response: discovery.CreateResponse(discovery.ResponseSuccess, "Delete service rules successfully."),
}, nil
}
-func (ds *DataSource) UpdateRule(ctx context.Context, request *discovery.UpdateServiceRuleRequest) (
- *discovery.UpdateServiceRuleResponse, error) {
+
+func (ds *DataSource) UpdateRule(ctx context.Context, request *discovery.UpdateServiceRuleRequest) (*discovery.UpdateServiceRuleResponse, error) {
+ domain := util.ParseDomain(ctx)
+ project := util.ParseProject(ctx)
exist, err := ServiceExistID(ctx, request.ServiceId)
if err != nil {
return &discovery.UpdateServiceRuleResponse{
@@ -1154,7 +1238,8 @@ func (ds *DataSource) UpdateRule(ctx context.Context, request *discovery.UpdateS
Response: discovery.CreateResponse(discovery.ErrServiceNotExists, "UpdateRule failed for service not exist."),
}, nil
}
- rules, err := GetRules(ctx, request.ServiceId)
+ filter := mutil.NewDomainProjectFilter(domain, project, mutil.ServiceID(request.ServiceId))
+ rules, err := dao.GetServiceRules(ctx, filter)
if err != nil {
return &discovery.UpdateServiceRuleResponse{
Response: discovery.CreateResponse(discovery.ErrUnavailableBackend, "UpdateRule failed for get rule."),
@@ -1165,7 +1250,8 @@ func (ds *DataSource) UpdateRule(ctx context.Context, request *discovery.UpdateS
Response: discovery.CreateResponse(discovery.ErrModifyRuleNotAllow, "Exist multiple rules, can not change rule type. Rule type is ."+rules[0].RuleType),
}, nil
}
- exist, err = RuleExist(ctx, GeneratorRuleFilter(ctx, request.ServiceId, request.RuleId))
+ filter = mutil.NewDomainProjectFilter(domain, project, mutil.ServiceID(request.ServiceId), mutil.RuleRuleID(request.RuleId))
+ exist, err = dao.RuleExist(ctx, filter)
if err != nil {
return &discovery.UpdateServiceRuleResponse{
Response: discovery.CreateResponse(discovery.ErrInternal, err.Error()),
@@ -1176,15 +1262,16 @@ func (ds *DataSource) UpdateRule(ctx context.Context, request *discovery.UpdateS
Response: discovery.CreateResponse(discovery.ErrRuleNotExists, "This rule does not exist."),
}, nil
}
-
- newRule := bson.M{
- StringBuilder([]string{model.ColumnRule, model.ColumnRuleType}): request.Rule.RuleType,
- StringBuilder([]string{model.ColumnRule, model.ColumnPattern}): request.Rule.Pattern,
- StringBuilder([]string{model.ColumnRule, model.ColumnAttribute}): request.Rule.Attribute,
- StringBuilder([]string{model.ColumnRule, model.ColumnDescription}): request.Rule.Description,
- StringBuilder([]string{model.ColumnRule, model.ColumnModTime}): strconv.FormatInt(time.Now().Unix(), 10)}
-
- err = UpdateRule(ctx, GeneratorRuleFilter(ctx, request.ServiceId, request.RuleId), bson.M{"$set": newRule})
+ filter = mutil.NewDomainProjectFilter(domain, project, mutil.ServiceID(request.ServiceId), mutil.RuleRuleID(request.RuleId))
+ setFilter := mutil.NewFilter(
+ mutil.RuleRuleType(request.Rule.RuleType),
+ mutil.RulePattern(request.Rule.Pattern),
+ mutil.RuleAttribute(request.Rule.Attribute),
+ mutil.RuleDescription(request.Rule.Description),
+ mutil.RuleModTime(strconv.FormatInt(time.Now().Unix(), baseTen)),
+ )
+ updateFilter := mutil.NewFilter(mutil.Set(setFilter))
+ err = dao.UpdateRule(ctx, filter, updateFilter)
if err != nil {
return &discovery.UpdateServiceRuleResponse{
Response: discovery.CreateResponse(discovery.ErrInternal, err.Error()),
@@ -1199,88 +1286,17 @@ func (ds *DataSource) isSchemaEditable(service *discovery.MicroService) bool {
return (len(service.Environment) != 0 && service.Environment != discovery.ENV_PROD) || ds.SchemaEditable
}
-func ServiceExist(ctx context.Context, service *discovery.MicroServiceKey) (bool, error) {
- filter := GeneratorServiceNameFilter(ctx, service)
- return client.GetMongoClient().DocExist(ctx, model.CollectionService, filter)
-}
-
func ServiceExistID(ctx context.Context, serviceID string) (bool, error) {
- filter := GeneratorServiceFilter(ctx, serviceID)
+ filter := mutil.NewBasicFilter(ctx, mutil.ServiceServiceID(serviceID))
return client.GetMongoClient().DocExist(ctx, model.CollectionService, filter)
}
-func GetService(ctx context.Context, filter bson.M) (*model.Service, error) {
- findRes, err := client.GetMongoClient().FindOne(ctx, model.CollectionService, filter)
- if err != nil {
- return nil, err
- }
- var svc *model.Service
- if findRes.Err() != nil {
- //not get any service,not db err
- return nil, datasource.ErrNoData
- }
- err = findRes.Decode(&svc)
- if err != nil {
- return nil, err
- }
- return svc, nil
-}
-
-func GetServices(ctx context.Context, filter bson.M) ([]*discovery.MicroService, error) {
- res, err := client.GetMongoClient().Find(ctx, model.CollectionService, filter)
- if err != nil {
- return nil, err
- }
- var services []*discovery.MicroService
- for res.Next(ctx) {
- var tmp model.Service
- err := res.Decode(&tmp)
- if err != nil {
- return nil, err
- }
- services = append(services, tmp.Service)
- }
- return services, nil
-}
-
-func GetMongoServices(ctx context.Context, filter bson.M) ([]*model.Service, error) {
- res, err := client.GetMongoClient().Find(ctx, model.CollectionService, filter)
- if err != nil {
- return nil, err
- }
- var services []*model.Service
- for res.Next(ctx) {
- var tmp *model.Service
- err := res.Decode(&tmp)
- if err != nil {
- return nil, err
- }
- services = append(services, tmp)
- }
- return services, nil
-}
-
-func GetServicesVersions(ctx context.Context, filter interface{}) ([]string, error) {
- res, err := client.GetMongoClient().Find(ctx, model.CollectionService, filter)
- if err != nil {
- return nil, nil
- }
- var versions []string
- for res.Next(ctx) {
- var tmp model.Service
- err := res.Decode(&tmp)
- if err != nil {
- return nil, err
- }
- versions = append(versions, tmp.Service.Version)
- }
- return versions, nil
-}
-
func getServiceDetailUtil(ctx context.Context, mgs *model.Service, countOnly bool, options []string) (*discovery.ServiceDetail, error) {
serviceDetail := new(discovery.ServiceDetail)
serviceID := mgs.Service.ServiceId
domainProject := util.ParseDomainProject(ctx)
+ domain := util.ParseDomain(ctx)
+ project := util.ParseProject(ctx)
if countOnly {
serviceDetail.Statics = new(discovery.Statistics)
}
@@ -1290,7 +1306,8 @@ func getServiceDetailUtil(ctx context.Context, mgs *model.Service, countOnly boo
case "tags":
serviceDetail.Tags = mgs.Tags
case "rules":
- rules, err := GetRules(ctx, mgs.Service.ServiceId)
+ filter := mutil.NewDomainProjectFilter(domain, project, mutil.ServiceID(mgs.Service.ServiceId))
+ rules, err := dao.GetServiceRules(ctx, filter)
if err != nil {
log.Error(fmt.Sprintf("get service %s's all rules failed", mgs.Service.ServiceId), err)
return nil, err
@@ -1301,7 +1318,8 @@ func getServiceDetailUtil(ctx context.Context, mgs *model.Service, countOnly boo
serviceDetail.Rules = rules
case "instances":
if countOnly {
- instanceCount, err := GetInstanceCountOfOneService(ctx, serviceID)
+ filter := mutil.NewDomainProjectFilter(domain, project, mutil.InstanceServiceID(serviceID))
+ instanceCount, err := dao.CountInstance(ctx, filter)
if err != nil {
log.Error(fmt.Sprintf("get number of service [%s]'s instances failed", serviceID), err)
return nil, err
@@ -1311,14 +1329,16 @@ func getServiceDetailUtil(ctx context.Context, mgs *model.Service, countOnly boo
}
continue
}
- instances, err := GetAllInstancesOfOneService(ctx, serviceID)
+ filter := mutil.NewDomainProjectFilter(domain, project, mutil.InstanceServiceID(serviceID))
+ instances, err := dao.GetMicroServiceInstances(ctx, filter)
if err != nil {
log.Error(fmt.Sprintf("get service[%s]'s all instances failed", serviceID), err)
return nil, err
}
serviceDetail.Instances = instances
case "schemas":
- schemas, err := GetSchemas(ctx, GeneratorServiceFilter(ctx, mgs.Service.ServiceId))
+ filter := mutil.NewDomainProjectFilter(domain, project, mutil.ServiceServiceID(serviceID))
+ schemas, err := dao.GetSchemas(ctx, filter)
if err != nil {
log.Error(fmt.Sprintf("get service %s's all schemas failed", mgs.Service.ServiceId), err)
return nil, err
@@ -1349,173 +1369,6 @@ func getServiceDetailUtil(ctx context.Context, mgs *model.Service, countOnly boo
return serviceDetail, nil
}
-func UpdateService(ctx context.Context, filter interface{}, m bson.M) error {
- return client.GetMongoClient().DocUpdate(ctx, model.CollectionService, filter, m)
-}
-
-func GetRules(ctx context.Context, serviceID string) ([]*discovery.ServiceRule, error) {
- domain := util.ParseDomain(ctx)
- project := util.ParseProject(ctx)
- filter := bson.M{model.ColumnDomain: domain, model.ColumnProject: project, model.ColumnServiceID: serviceID}
-
- ruleRes, err := client.GetMongoClient().Find(ctx, model.CollectionRule, filter)
- if err != nil {
- return nil, err
- }
- var rules []*discovery.ServiceRule
- for ruleRes.Next(ctx) {
- var tmpRule *model.Rule
- err := ruleRes.Decode(&tmpRule)
- if err != nil {
- return nil, err
- }
- rules = append(rules, tmpRule.Rule)
- }
- return rules, nil
-}
-
-func UpdateRule(ctx context.Context, filter interface{}, m bson.M) error {
- return client.GetMongoClient().DocUpdate(ctx, model.CollectionRule, filter, m)
-}
-
-func UpdateSchema(ctx context.Context, filter interface{}, m bson.M, opts ...*options.FindOneAndUpdateOptions) error {
- _, err := client.GetMongoClient().FindOneAndUpdate(ctx, model.CollectionSchema, filter, m, opts...)
- if err != nil {
- return err
- }
- return nil
-}
-
-func DeleteSchema(ctx context.Context, filter interface{}) error {
- res, err := client.GetMongoClient().DocDelete(ctx, model.CollectionSchema, filter)
- if err != nil {
- return err
- }
- if !res {
- return mutil.ErrDeleteSchemaFailed
- }
- return nil
-}
-
-func RuleExist(ctx context.Context, filter bson.M) (bool, error) {
- return client.GetMongoClient().DocExist(ctx, model.CollectionRule, filter)
-}
-
-func GeneratorServiceFilter(ctx context.Context, serviceID string) bson.M {
- domain := util.ParseDomain(ctx)
- project := util.ParseProject(ctx)
-
- return bson.M{
- model.ColumnDomain: domain,
- model.ColumnProject: project,
- StringBuilder([]string{model.ColumnService, model.ColumnServiceID}): serviceID}
-}
-
-func GeneratorServiceNameFilter(ctx context.Context, service *discovery.MicroServiceKey) bson.M {
- domain := util.ParseDomain(ctx)
- project := util.ParseProject(ctx)
-
- return bson.M{
- model.ColumnDomain: domain,
- model.ColumnProject: project,
- StringBuilder([]string{model.ColumnService, model.ColumnEnv}): service.Environment,
- StringBuilder([]string{model.ColumnService, model.ColumnAppID}): service.AppId,
- StringBuilder([]string{model.ColumnService, model.ColumnServiceName}): service.ServiceName,
- StringBuilder([]string{model.ColumnService, model.ColumnVersion}): service.Version}
-}
-
-func GeneratorServiceAliasFilter(ctx context.Context, service *discovery.MicroServiceKey) bson.M {
- domain := util.ParseDomain(ctx)
- project := util.ParseProject(ctx)
-
- return bson.M{
- model.ColumnDomain: domain,
- model.ColumnProject: project,
- StringBuilder([]string{model.ColumnService, model.ColumnEnv}): service.Environment,
- StringBuilder([]string{model.ColumnService, model.ColumnAppID}): service.AppId,
- StringBuilder([]string{model.ColumnService, model.ColumnAlias}): service.Alias,
- StringBuilder([]string{model.ColumnService, model.ColumnVersion}): service.Version}
-}
-
-func GeneratorRuleAttFilter(ctx context.Context, serviceID, attribute, pattern string) bson.M {
- return bson.M{
- model.ColumnServiceID: serviceID,
- StringBuilder([]string{model.ColumnRule, model.ColumnAttribute}): attribute,
- StringBuilder([]string{model.ColumnRule, model.ColumnPattern}): pattern}
-}
-
-func GeneratorSchemaFilter(ctx context.Context, serviceID, schemaID string) bson.M {
- domain := util.ParseDomain(ctx)
- project := util.ParseProject(ctx)
-
- return bson.M{model.ColumnDomain: domain, model.ColumnProject: project, model.ColumnServiceID: serviceID, model.ColumnSchemaID: schemaID}
-}
-
-func GeneratorRuleFilter(ctx context.Context, serviceID, ruleID string) bson.M {
- domain := util.ParseDomain(ctx)
- project := util.ParseProject(ctx)
-
- return bson.M{
- model.ColumnDomain: domain,
- model.ColumnProject: project,
- model.ColumnServiceID: serviceID,
- StringBuilder([]string{model.ColumnRule, model.ColumnRuleID}): ruleID}
-}
-
-func GetSchemas(ctx context.Context, filter bson.M) ([]*discovery.Schema, error) {
- getRes, err := client.GetMongoClient().Find(ctx, model.CollectionSchema, filter)
- if err != nil {
- return nil, err
- }
- var schemas []*discovery.Schema
- for getRes.Next(ctx) {
- var tmp *model.Schema
- err = getRes.Decode(&tmp)
- if err != nil {
- return nil, err
- }
- schemas = append(schemas, &discovery.Schema{
- SchemaId: tmp.SchemaID,
- Summary: tmp.SchemaSummary,
- Schema: tmp.Schema,
- })
- }
- return schemas, nil
-}
-
-func GetSchema(ctx context.Context, filter bson.M) (*model.Schema, error) {
- findRes, err := client.GetMongoClient().FindOne(ctx, model.CollectionSchema, filter)
- if err != nil {
- return nil, err
- }
- if findRes.Err() != nil {
- //not get any service,not db err
- return nil, nil
- }
- var schema *model.Schema
- err = findRes.Decode(&schema)
- if err != nil {
- return nil, err
- }
- return schema, nil
-}
-
-func SchemaSummaryExist(ctx context.Context, serviceID, schemaID string) (bool, error) {
- res, err := client.GetMongoClient().FindOne(ctx, model.CollectionSchema, GeneratorSchemaFilter(ctx, serviceID, schemaID))
- if err != nil {
- return false, err
- }
- if res.Err() != nil {
- return false, nil
- }
- var s model.Schema
- err = res.Decode(&s)
- if err != nil {
- return false, err
- }
- return len(s.SchemaSummary) != 0, nil
-}
-
// Instance management
func (ds *DataSource) RegisterInstance(ctx context.Context, request *discovery.RegisterInstanceRequest) (*discovery.RegisterInstanceResponse, error) {
remoteIP := util.GetIPFromContext(ctx)
@@ -1576,9 +1429,11 @@ func (ds *DataSource) GetInstance(ctx context.Context, request *discovery.GetOne
var service *model.Service
var err error
var serviceIDs []string
+ domain := util.ParseDomain(ctx)
+ project := util.ParseProject(ctx)
if len(request.ConsumerServiceId) > 0 {
- filter := GeneratorServiceFilter(ctx, request.ConsumerServiceId)
- service, err = GetService(ctx, filter)
+ filter := mutil.NewDomainProjectFilter(domain, project, mutil.ServiceServiceID(request.ConsumerServiceId))
+ service, err = dao.GetService(ctx, filter)
if err != nil {
if errors.Is(err, datasource.ErrNoData) {
log.Debug(fmt.Sprintf("consumer does not exist, consumer %s find provider instance %s %s",
@@ -1595,9 +1450,8 @@ func (ds *DataSource) GetInstance(ctx context.Context, request *discovery.GetOne
}, err
}
}
-
- filter := GeneratorServiceFilter(ctx, request.ProviderServiceId)
- provider, err := GetService(ctx, filter)
+ filter := mutil.NewDomainProjectFilter(domain, project, mutil.ServiceServiceID(request.ProviderServiceId))
+ provider, err := dao.GetService(ctx, filter)
if err != nil {
if errors.Is(err, datasource.ErrNoData) {
log.Debug(fmt.Sprintf("provider does not exist, consumer %s find provider instance %s %s",
@@ -1621,7 +1475,7 @@ func (ds *DataSource) GetInstance(ctx context.Context, request *discovery.GetOne
}
domainProject := util.ParseDomainProject(ctx)
- services, err := findServices(ctx, discovery.MicroServiceToKey(domainProject, provider.Service))
+ services, err := filterServices(ctx, discovery.MicroServiceToKey(domainProject, provider.Service))
if err != nil {
log.Error(fmt.Sprintf("get instance failed %s", findFlag()), err)
return &discovery.GetOneInstanceResponse{
@@ -1752,36 +1606,16 @@ func (ds *DataSource) GetInstances(ctx context.Context, request *discovery.GetIn
// GetProviderInstances returns instances under the specified domain
func (ds *DataSource) GetProviderInstances(ctx context.Context, request *discovery.GetProviderInstancesRequest) (instances []*discovery.MicroServiceInstance, rev string, err error) {
- domain := util.ParseDomain(ctx)
- project := util.ParseProject(ctx)
- filter := bson.M{
- model.ColumnDomain: domain,
- model.ColumnProject: project,
- StringBuilder([]string{model.ColumnInstance, model.ColumnServiceID}): request.ProviderServiceId}
-
- findRes, err := client.GetMongoClient().Find(ctx, model.CollectionInstance, filter)
+ filter := mutil.NewBasicFilter(ctx, mutil.InstanceServiceID(request.ProviderServiceId))
+ instances, err = dao.GetMicroServiceInstances(ctx, filter)
if err != nil {
return
}
-
- for findRes.Next(ctx) {
- var mongoInstance model.Instance
- err := findRes.Decode(&mongoInstance)
- if err == nil {
- instances = append(instances, mongoInstance.Instance)
- }
- }
-
return instances, "", nil
}
func (ds *DataSource) GetAllInstances(ctx context.Context, request *discovery.GetAllInstancesRequest) (*discovery.GetAllInstancesResponse, error) {
-
- domain := util.ParseDomain(ctx)
- project := util.ParseProject(ctx)
-
- filter := bson.M{model.ColumnDomain: domain, model.ColumnProject: project}
-
+ filter := mutil.NewBasicFilter(ctx)
findRes, err := client.GetMongoClient().Find(ctx, model.CollectionInstance, filter)
if err != nil {
return nil, err
@@ -1808,15 +1642,11 @@ func (ds *DataSource) BatchGetProviderInstances(ctx context.Context, request *di
if request == nil || len(request.ServiceIds) == 0 {
return nil, "", mutil.ErrInvalidParam
}
-
domain := util.ParseDomain(ctx)
project := util.ParseProject(ctx)
for _, providerServiceID := range request.ServiceIds {
- filter := bson.M{
- model.ColumnDomain: domain,
- model.ColumnProject: project,
- StringBuilder([]string{model.ColumnInstance, model.ColumnServiceID}): providerServiceID}
+ filter := mutil.NewDomainProjectFilter(domain, project, mutil.InstanceServiceID(providerServiceID))
findRes, err := client.GetMongoClient().Find(ctx, model.CollectionInstance, filter)
if err != nil {
return instances, "", nil
@@ -1864,7 +1694,8 @@ func (ds *DataSource) UpdateInstanceStatus(ctx context.Context, request *discove
updateStatusFlag := util.StringJoin([]string{request.ServiceId, request.InstanceId, request.Status}, "/")
// todo finish get instance
- instance, err := GetInstance(ctx, request.ServiceId, request.InstanceId)
+ filter := mutil.NewBasicFilter(ctx, mutil.InstanceServiceID(request.ServiceId), mutil.InstanceInstanceID(request.InstanceId))
+ instance, err := dao.GetInstance(ctx, filter)
if err != nil {
log.Error(fmt.Sprintf("update instance %s status failed", updateStatusFlag), err)
return &discovery.UpdateInstanceStatusResponse{
@@ -1880,8 +1711,12 @@ func (ds *DataSource) UpdateInstanceStatus(ctx context.Context, request *discove
copyInstanceRef := *instance
copyInstanceRef.Instance.Status = request.Status
-
- if err := UpdateInstanceS(ctx, copyInstanceRef.Instance); err != nil {
+ setFilter := mutil.NewFilter(
+ mutil.InstanceModTime(strconv.FormatInt(time.Now().Unix(), baseTen)),
+ mutil.InstanceStatus(copyInstanceRef.Instance.Status),
+ )
+ updateFilter := mutil.NewFilter(mutil.Set(setFilter))
+ if err := dao.UpdateInstance(ctx, filter, updateFilter); err != nil {
log.Error(fmt.Sprintf("update instance %s status failed", updateStatusFlag), err)
resp := &discovery.UpdateInstanceStatusResponse{
Response: discovery.CreateResponseWithSCErr(err),
@@ -1900,8 +1735,10 @@ func (ds *DataSource) UpdateInstanceStatus(ctx context.Context, request *discove
func (ds *DataSource) UpdateInstanceProperties(ctx context.Context, request *discovery.UpdateInstancePropsRequest) (*discovery.UpdateInstancePropsResponse, error) {
instanceFlag := util.StringJoin([]string{request.ServiceId, request.InstanceId}, "/")
-
- instance, err := GetInstance(ctx, request.ServiceId, request.InstanceId)
+ domain := util.ParseDomain(ctx)
+ project := util.ParseProject(ctx)
+ filter := mutil.NewDomainProjectFilter(domain, project, mutil.InstanceServiceID(request.ServiceId), mutil.InstanceInstanceID(request.InstanceId))
+ instance, err := dao.GetInstance(ctx, filter)
if err != nil {
log.Error(fmt.Sprintf("update instance %s properties failed", instanceFlag), err)
return &discovery.UpdateInstancePropsResponse{
@@ -1919,7 +1756,13 @@ func (ds *DataSource) UpdateInstanceProperties(ctx context.Context, request *dis
copyInstanceRef.Instance.Properties = request.Properties
// todo finish update instance
- if err := UpdateInstanceP(ctx, copyInstanceRef.Instance); err != nil {
+ filter = mutil.NewDomainProjectFilter(domain, project, mutil.InstanceServiceID(request.ServiceId), mutil.InstanceInstanceID(request.InstanceId))
+ setFilter := mutil.NewFilter(
+ mutil.InstanceModTime(strconv.FormatInt(time.Now().Unix(), baseTen)),
+ mutil.InstanceProperties(copyInstanceRef.Instance.Properties),
+ )
+ updateFilter := mutil.NewFilter(mutil.Set(setFilter))
+ if err := dao.UpdateInstance(ctx, filter, updateFilter); err != nil {
log.Error(fmt.Sprintf("update instance %s properties failed", instanceFlag), err)
resp := &discovery.UpdateInstancePropsResponse{
Response: discovery.CreateResponseWithSCErr(err),
@@ -1943,13 +1786,7 @@ func (ds *DataSource) UnregisterInstance(ctx context.Context, request *discovery
instanceFlag := util.StringJoin([]string{serviceID, instanceID}, "/")
- domain := util.ParseDomain(ctx)
- project := util.ParseProject(ctx)
- filter := bson.M{
- model.ColumnDomain: domain,
- model.ColumnProject: project,
- StringBuilder([]string{model.ColumnInstance, model.ColumnServiceID}): serviceID,
- StringBuilder([]string{model.ColumnInstance, model.ColumnInstanceID}): instanceID}
+ filter := mutil.NewBasicFilter(ctx, mutil.InstanceServiceID(serviceID), mutil.InstanceInstanceID(instanceID))
result, err := client.GetMongoClient().Delete(ctx, model.CollectionInstance, filter)
if err != nil || result.DeletedCount == 0 {
log.Error(fmt.Sprintf("unregister instance failed, instance %s, operator %s revoke instance failed", instanceFlag, remoteIP), err)
@@ -2118,7 +1955,7 @@ func (ds *DataSource) findSharedServiceInstance(ctx context.Context, request *di
Response: discovery.CreateResponse(discovery.ErrInternal, err.Error()),
}, err
}
- services, err := findServices(ctx, provider)
+ services, err := filterServices(ctx, provider)
if err != nil {
log.Error(fmt.Sprintf("find shared service instance failed %s", findFlag()), err)
return &discovery.FindInstancesResponse{
@@ -2133,7 +1970,10 @@ func (ds *DataSource) findSharedServiceInstance(ctx context.Context, request *di
}, nil
}
serviceIDs := filterServiceIDs(ctx, request.ConsumerServiceId, request.Tags, services)
- instances, err := instancesFilter(ctx, serviceIDs)
+ inFilter := mutil.NewFilter(mutil.In(serviceIDs))
+ filter := mutil.NewFilter(mutil.InstanceServiceID(inFilter))
+ option := &options.FindOptions{Sort: bson.M{mutil.ConnectWithDot([]string{model.ColumnInstance, model.ColumnVersion}): -1}}
+ instances, err := dao.GetMicroServiceInstances(ctx, filter, option)
if err != nil {
log.Error(fmt.Sprintf("find shared service instance failed %s", findFlag()), err)
return &discovery.FindInstancesResponse{
@@ -2157,8 +1997,8 @@ func (ds *DataSource) findInstance(ctx context.Context, request *discovery.FindI
domainProject := util.ParseDomainProject(ctx)
service := &model.Service{Service: &discovery.MicroService{Environment: request.Environment}}
if len(request.ConsumerServiceId) > 0 {
- filter := GeneratorServiceFilter(ctx, request.ConsumerServiceId)
- service, err = GetService(ctx, filter)
+ filter := mutil.NewBasicFilter(ctx, mutil.ServiceServiceID(request.ConsumerServiceId))
+ service, err = dao.GetService(ctx, filter)
if err != nil {
if errors.Is(err, datasource.ErrNoData) {
log.Debug(fmt.Sprintf("consumer does not exist, consumer %s find provider %s/%s/%s/%s",
@@ -2194,7 +2034,7 @@ func (ds *DataSource) findInstance(ctx context.Context, request *discovery.FindI
Response: discovery.CreateResponse(discovery.ErrInternal, err.Error()),
}, err
}
- services, err := findServices(ctx, provider)
+ services, err := filterServices(ctx, provider)
if err != nil {
log.Error(fmt.Sprintf("find instance failed %s", findFlag()), err)
return &discovery.FindInstancesResponse{
@@ -2209,7 +2049,10 @@ func (ds *DataSource) findInstance(ctx context.Context, request *discovery.FindI
}, nil
}
serviceIDs := filterServiceIDs(ctx, request.ConsumerServiceId, request.Tags, services)
- instances, err := instancesFilter(ctx, serviceIDs)
+ inFilter := mutil.NewFilter(mutil.In(serviceIDs))
+ filter := mutil.NewFilter(mutil.InstanceServiceID(inFilter))
+ option := &options.FindOptions{Sort: bson.M{mutil.ConnectWithDot([]string{model.ColumnInstance, model.ColumnVersion}): -1}}
+ instances, err := dao.GetMicroServiceInstances(ctx, filter, option)
if err != nil {
log.Error(fmt.Sprintf("find instance failed %s", findFlag()), err)
return &discovery.FindInstancesResponse{
@@ -2251,11 +2094,10 @@ func (ds *DataSource) findInstance(ctx context.Context, request *discovery.FindI
}, nil
}
-func (ds *DataSource) reshapeProviderKey(ctx context.Context, provider *discovery.MicroServiceKey, providerID string) (
- *discovery.MicroServiceKey, error) {
+func (ds *DataSource) reshapeProviderKey(ctx context.Context, provider *discovery.MicroServiceKey, providerID string) (*discovery.MicroServiceKey, error) {
//维护version的规则,service name 可能是别名，所以重新获取
- filter := GeneratorServiceFilter(ctx, providerID)
- providerService, err := GetService(ctx, filter)
+ filter := mutil.NewBasicFilter(ctx, mutil.ServiceServiceID(providerID))
+ providerService, err := dao.GetService(ctx, filter)
if err != nil {
return nil, err
}
@@ -2319,60 +2161,6 @@ func DependencyRuleExistUtil(ctx context.Context, key bson.M, target *discovery.
return false, nil
}
-func GetInstance(ctx context.Context, serviceID string, instanceID string) (*model.Instance, error) {
- domain := util.ParseDomain(ctx)
- project := util.ParseProject(ctx)
- filter := bson.M{
- model.ColumnDomain: domain,
- model.ColumnProject: project,
- StringBuilder([]string{model.ColumnInstance, model.ColumnServiceID}): serviceID,
- StringBuilder([]string{model.ColumnInstance, model.ColumnInstanceID}): instanceID}
- findRes, err := client.GetMongoClient().FindOne(ctx, model.CollectionInstance, filter)
- if err != nil {
- return nil, err
- }
- var instance *model.Instance
- if findRes.Err() != nil {
- //not get any service,not db err
- return nil, nil
- }
- err = findRes.Decode(&instance)
- if err != nil {
- return nil, err
- }
- return instance, nil
-}
-
-func UpdateInstanceS(ctx context.Context, instance *discovery.MicroServiceInstance) *discovery.Error {
- domain := util.ParseDomain(ctx)
- project := util.ParseProject(ctx)
- filter := bson.M{
- model.ColumnDomain: domain,
- model.ColumnProject: project,
- StringBuilder([]string{model.ColumnInstance, model.ColumnServiceID}): instance.ServiceId,
- StringBuilder([]string{model.ColumnInstance, model.ColumnInstanceID}): instance.InstanceId}
- _, err := client.GetMongoClient().Update(ctx, model.CollectionInstance, filter, bson.M{"$set": bson.M{"instance.motTimestamp": strconv.FormatInt(time.Now().Unix(), 10), "instance.status": instance.Status}})
- if err != nil {
- return discovery.NewError(discovery.ErrUnavailableBackend, err.Error())
- }
- return nil
-}
-
-func UpdateInstanceP(ctx context.Context, instance *discovery.MicroServiceInstance) *discovery.Error {
- domain := util.ParseDomain(ctx)
- project := util.ParseProject(ctx)
- filter := bson.M{
- model.ColumnDomain: domain,
- model.ColumnProject: project,
- StringBuilder([]string{model.ColumnInstance, model.ColumnServiceID}): instance.ServiceId,
- StringBuilder([]string{model.ColumnInstance, model.ColumnInstanceID}): instance.InstanceId}
- _, err := client.GetMongoClient().Update(ctx, model.CollectionInstance, filter, bson.M{"$set": bson.M{"instance.motTimestamp": strconv.FormatInt(time.Now().Unix(), 10), "instance.properties": instance.Properties}})
- if err != nil {
- return discovery.NewError(discovery.ErrUnavailableBackend, err.Error())
- }
- return nil
-}
-
func KeepAliveLease(ctx context.Context, request *discovery.HeartbeatRequest) *discovery.Error {
_, err := heartbeat.Instance().Heartbeat(ctx, request)
if err != nil {
@@ -2403,8 +2191,7 @@ func getHeartbeatFunc(ctx context.Context, domainProject string, instancesHbRst
}
}
-func (ds *DataSource) batchFindServices(ctx context.Context, request *discovery.BatchFindInstancesRequest) (
- *discovery.BatchFindResult, error) {
+func (ds *DataSource) batchFindServices(ctx context.Context, request *discovery.BatchFindInstancesRequest) (*discovery.BatchFindResult, error) {
if len(request.Services) == 0 {
return nil, nil
}
@@ -2529,9 +2316,8 @@ func preProcessRegisterInstance(ctx context.Context, instance *discovery.MicroSe
instance.HealthCheck.Times = retryTimes
}
}
-
- filter := GeneratorServiceFilter(ctx, instance.ServiceId)
- microservice, err := GetService(ctx, filter)
+ filter := mutil.NewBasicFilter(ctx, mutil.ServiceServiceID(instance.ServiceId))
+ microservice, err := dao.GetService(ctx, filter)
if err != nil {
return discovery.NewError(discovery.ErrServiceNotExists, "invalid 'serviceID' in request body.")
}
@@ -2545,100 +2331,73 @@ func servicesBasicFilter(ctx context.Context, key *discovery.MicroServiceKey) ([
if len(tenant) != 2 {
return nil, errors.New("invalid 'domain' or 'project'")
}
- filter := bson.M{
- model.ColumnDomain: tenant[0],
- model.ColumnProject: tenant[1],
- StringBuilder([]string{model.ColumnService, model.ColumnEnv}): key.Environment,
- StringBuilder([]string{model.ColumnService, model.ColumnAppID}): key.AppId,
- StringBuilder([]string{model.ColumnService, model.ColumnServiceName}): key.ServiceName,
- StringBuilder([]string{model.ColumnService, model.ColumnAlias}): key.Alias,
- }
+ filter := mutil.NewDomainProjectFilter(tenant[0], tenant[1],
+ mutil.ServiceEnv(key.Environment),
+ mutil.ServiceAppID(key.AppId),
+ mutil.ServiceServiceName(key.ServiceName),
+ mutil.ServiceAlias(key.Alias),
+ )
rangeIdx := strings.Index(key.Version, "-")
// if the version number is clear, need to add the version number to query
switch {
case key.Version == "latest":
- return servicesFilter(ctx, filter)
+ return dao.GetServices(ctx, filter)
case len(key.Version) > 0 && key.Version[len(key.Version)-1:] == "+":
- return servicesFilter(ctx, filter)
+ return dao.GetServices(ctx, filter)
case rangeIdx > 0:
- return servicesFilter(ctx, filter)
+ return dao.GetServices(ctx, filter)
default:
- filter[StringBuilder([]string{model.ColumnService, model.ColumnVersion})] = key.Version
- return servicesFilter(ctx, filter)
+ filter[mutil.ConnectWithDot([]string{model.ColumnService, model.ColumnVersion})] = key.Version
+ return dao.GetServices(ctx, filter)
}
}
-func findServices(ctx context.Context, key *discovery.MicroServiceKey) ([]*model.Service, error) {
+func filterServices(ctx context.Context, key *discovery.MicroServiceKey) ([]*model.Service, error) {
tenant := strings.Split(key.Tenant, "/")
if len(tenant) != 2 {
return nil, errors.New("invalid 'domain' or 'project'")
}
rangeIdx := strings.Index(key.Version, "-")
- filter := bson.M{
- model.ColumnDomain: tenant[0],
- model.ColumnProject: tenant[1],
- StringBuilder([]string{model.ColumnService, model.ColumnEnv}): key.Environment,
- StringBuilder([]string{model.ColumnService, model.ColumnAppID}): key.AppId,
- StringBuilder([]string{model.ColumnService, model.ColumnServiceName}): key.ServiceName,
- StringBuilder([]string{model.ColumnService, model.ColumnAlias}): key.Alias,
- }
+ filter := mutil.NewDomainProjectFilter(tenant[0], tenant[1],
+ mutil.ServiceEnv(key.Environment),
+ mutil.ServiceAppID(key.AppId),
+ mutil.ServiceServiceName(key.ServiceName),
+ mutil.ServiceAlias(key.Alias),
+ )
switch {
case key.Version == "latest":
- return latestServicesFilter(ctx, filter)
+ findOption := &options.FindOptions{Sort: bson.M{mutil.ConnectWithDot([]string{model.ColumnService, model.ColumnVersion}): -1}}
+ return dao.GetServices(ctx, filter, findOption)
case len(key.Version) > 0 && key.Version[len(key.Version)-1:] == "+":
start := key.Version[:len(key.Version)-1]
- filter[StringBuilder([]string{model.ColumnService, model.ColumnVersion})] = bson.M{"$gte": start}
- return servicesFilter(ctx, filter)
+ filter[mutil.ConnectWithDot([]string{model.ColumnService, model.ColumnVersion})] = bson.M{"$gte": start}
+ return dao.GetServices(ctx, filter)
case rangeIdx > 0:
start := key.Version[:rangeIdx]
end := key.Version[rangeIdx+1:]
- filter[StringBuilder([]string{model.ColumnService, model.ColumnVersion})] = bson.M{"$gte": start, "$lte": end}
- return servicesFilter(ctx, filter)
+ filter[mutil.ConnectWithDot([]string{model.ColumnService, model.ColumnVersion})] = bson.M{"$gte": start, "$lte": end}
+ return dao.GetServices(ctx, filter)
default:
- filter[StringBuilder([]string{model.ColumnService, model.ColumnVersion})] = key.Version
- return servicesFilter(ctx, filter)
+ filter[mutil.ConnectWithDot([]string{model.ColumnService, model.ColumnVersion})] = key.Version
+ return dao.GetServices(ctx, filter)
}
}
-func instancesFilter(ctx context.Context, serviceIDs []string) ([]*discovery.MicroServiceInstance, error) {
- var instances []*discovery.MicroServiceInstance
- if len(serviceIDs) == 0 {
- return instances, nil
- }
- resp, err := client.GetMongoClient().Find(ctx, model.CollectionInstance, bson.M{StringBuilder([]string{model.ColumnInstance, model.ColumnServiceID}): bson.M{"$in": serviceIDs}}, &options.FindOptions{
- Sort: bson.M{StringBuilder([]string{model.ColumnInstance, model.ColumnVersion}): -1}})
- if err != nil {
- return nil, err
- }
- if resp == nil {
- return nil, errors.New("no related instances were found")
- }
- for resp.Next(ctx) {
- var instance model.Instance
- err := resp.Decode(&instance)
- if err != nil {
- return nil, err
- }
- instances = append(instances, instance.Instance)
- }
- return instances, nil
-}
-
func filterServiceIDs(ctx context.Context, consumerID string, tags []string, services []*model.Service) []string {
var filterService []*model.Service
- var serviceIDs []string
+ serviceIDs := make([]string, 0)
if len(services) == 0 {
return serviceIDs
}
- filterService = tagsFilter(services, tags)
- filterService = accessibleFilter(ctx, consumerID, filterService)
+ filterService = filterTags(services, tags)
+ filterService = filterAccess(ctx, consumerID, filterService)
for _, service := range filterService {
serviceIDs = append(serviceIDs, service.Service.ServiceId)
}
return serviceIDs
}
-func tagsFilter(services []*model.Service, tags []string) []*model.Service {
+func filterTags(services []*model.Service, tags []string) []*model.Service {
if len(tags) == 0 {
return services
}
@@ -2657,8 +2416,8 @@ func tagsFilter(services []*model.Service, tags []string) []*model.Service {
return newServices
}
-func accessibleFilter(ctx context.Context, consumerID string, services []*model.Service) []*model.Service {
- var newServices []*model.Service
+func filterAccess(ctx context.Context, consumerID string, services []*model.Service) []*model.Service {
+ newServices := make([]*model.Service, 0)
for _, service := range services {
if err := accessible(ctx, consumerID, service.Service.ServiceId); err != nil {
findFlag := fmt.Sprintf("consumer '%s' find provider %s/%s/%s", consumerID,
@@ -2671,95 +2430,6 @@ func accessibleFilter(ctx context.Context, consumerID string, services []*model.
return newServices
}
-func servicesFilter(ctx context.Context, filter bson.M) ([]*model.Service, error) {
- resp, err := client.GetMongoClient().Find(ctx, model.CollectionService, filter)
- if err != nil {
- return nil, err
- }
- if resp == nil {
- return nil, errors.New("no related services were found")
- }
- var services []*model.Service
- for resp.Next(ctx) {
- var service model.Service
- err := resp.Decode(&service)
- if err != nil {
- log.Error("type conversion error", err)
- return nil, err
- }
- services = append(services, &service)
- }
- return services, nil
-}
-
-func latestServicesFilter(ctx context.Context, filter bson.M) ([]*model.Service, error) {
- resp, err := client.GetMongoClient().Find(ctx, model.CollectionService, filter, &options.FindOptions{
- Sort: bson.M{StringBuilder([]string{model.ColumnService, model.ColumnVersion}): -1}})
- if err != nil {
- return nil, err
- }
- if resp == nil {
- return nil, errors.New("no related services were found")
- }
- var services []*model.Service
- for resp.Next(ctx) {
- var service model.Service
- err := resp.Decode(&service)
- if err != nil {
- log.Error("type conversion error", err)
- return nil, err
- }
- services = append(services, &service)
- if services != nil {
- return services, nil
- }
- }
- return services, nil
-}
-
-func getTags(ctx context.Context, domain string, project string, serviceID string) (tags map[string]string, err error) {
- filter := bson.M{
- model.ColumnDomain: domain,
- model.ColumnProject: project,
- StringBuilder([]string{model.ColumnService, model.ColumnServiceID}): serviceID,
- }
- result, err := client.GetMongoClient().FindOne(ctx, model.CollectionService, filter)
- if err != nil {
- return nil, err
- }
- if result.Err() != nil {
- return nil, result.Err()
- }
- var service model.Service
- err = result.Decode(&service)
- if err != nil {
- log.Error("type conversion error", err)
- return nil, err
- }
- return service.Tags, nil
-}
-
-func getService(ctx context.Context, domain string, project string, serviceID string) (*model.Service, error) {
- filter := bson.M{
- model.ColumnDomain: domain,
- model.ColumnProject: project,
- StringBuilder([]string{model.ColumnService, model.ColumnServiceID}): serviceID,
- }
- result, err := client.GetMongoClient().FindOne(ctx, model.CollectionService, filter)
- if err != nil {
- return nil, err
- }
- if result.Err() != nil {
- return nil, result.Err()
- }
- var svc model.Service
- err = result.Decode(&svc)
- if err != nil {
- return nil, err
- }
- return &svc, nil
-}
-
func accessible(ctx context.Context, consumerID string, providerID string) *discovery.Error {
if len(consumerID) == 0 {
return nil
@@ -2768,7 +2438,8 @@ func accessible(ctx context.Context, consumerID string, providerID string) *disc
consumerDomain, consumerProject := util.ParseDomain(ctx), util.ParseProject(ctx)
providerDomain, providerProject := util.ParseTargetDomain(ctx), util.ParseTargetProject(ctx)
- consumerService, err := getService(ctx, consumerDomain, consumerProject, consumerID)
+ filter := mutil.NewDomainProjectFilter(consumerDomain, consumerProject, mutil.ServiceServiceID(consumerID))
+ consumerService, err := dao.GetService(ctx, filter)
if err != nil {
return discovery.NewError(discovery.ErrInternal, fmt.Sprintf("an error occurred in query consumer(%s)", err.Error()))
}
@@ -2776,8 +2447,9 @@ func accessible(ctx context.Context, consumerID string, providerID string) *disc
return discovery.NewError(discovery.ErrServiceNotExists, "consumer serviceID is invalid")
}
+ filter = mutil.NewDomainProjectFilter(providerDomain, providerProject, mutil.ServiceServiceID(providerID))
// 跨应用权限
- providerService, err := getService(ctx, providerDomain, providerProject, providerID)
+ providerService, err := dao.GetService(ctx, filter)
if err != nil {
return discovery.NewError(discovery.ErrInternal, fmt.Sprintf("an error occurred in query provider(%s)", err.Error()))
}
@@ -2790,7 +2462,8 @@ func accessible(ctx context.Context, consumerID string, providerID string) *disc
}
// 黑白名单
- rules, err := getRulesUtil(ctx, providerDomain, providerProject, providerID)
+ filter = mutil.NewDomainProjectFilter(providerDomain, providerProject, mutil.ServiceID(providerID))
+ rules, err := dao.GetRules(ctx, filter)
if err != nil {
return discovery.NewError(discovery.ErrInternal, fmt.Sprintf("an error occurred in query provider rules(%s)", err.Error()))
}
@@ -2798,12 +2471,7 @@ func accessible(ctx context.Context, consumerID string, providerID string) *disc
if len(rules) == 0 {
return nil
}
-
- validateTags, err := getTags(ctx, consumerDomain, consumerProject, consumerService.Service.ServiceId)
- if err != nil {
- return discovery.NewError(discovery.ErrInternal, fmt.Sprintf("an error occurred in query consumer tags(%s)", err.Error()))
- }
- return MatchRules(rules, consumerService.Service, validateTags)
+ return MatchRules(rules, consumerService.Service, consumerService.Tags)
}
func MatchRules(rulesOfProvider []*model.Rule, consumer *discovery.MicroService, tagsOfConsumer map[string]string) *discovery.Error {
@@ -2885,34 +2553,6 @@ func patternBlackList(rulesOfProvider []*model.Rule, tagsOfConsumer map[string]s
}
return nil
}
-
-func getRulesUtil(ctx context.Context, domain string, project string, serviceID string) ([]*model.Rule, error) {
- filter := bson.M{
- model.ColumnDomain: domain,
- model.ColumnProject: project,
- model.ColumnServiceID: serviceID,
- }
- cursor, err := client.GetMongoClient().Find(ctx, model.CollectionRule, filter)
- if err != nil {
- return nil, err
- }
- if cursor.Err() != nil {
- return nil, cursor.Err()
- }
- var rules []*model.Rule
- defer cursor.Close(ctx)
- for cursor.Next(ctx) {
- var rule model.Rule
- err := cursor.Decode(&rule)
- if err != nil {
- log.Error("type conversion error", err)
- return nil, err
- }
- rules = append(rules, &rule)
- }
- return rules, nil
-}
-
func allowAcrossDimension(ctx context.Context, providerService *model.Service, consumerService *model.Service) error {
if providerService.Service.AppId != consumerService.Service.AppId {
if len(providerService.Service.Properties) == 0 {
@@ -2930,76 +2570,12 @@ func allowAcrossDimension(ctx context.Context, providerService *model.Service, c
return nil
}
-func GetInstanceCountOfOneService(ctx context.Context, serviceID string) (int64, error) {
- filter := GeneratorServiceInstanceFilter(ctx, serviceID)
- count, err := client.GetMongoClient().Count(ctx, model.CollectionInstance, filter)
- if err != nil {
- return 0, nil
- }
- return count, nil
-}
-
-func GetAllInstancesOfOneService(ctx context.Context, serviceID string) ([]*discovery.MicroServiceInstance, error) {
- filter := GeneratorServiceInstanceFilter(ctx, serviceID)
- res, err := client.GetMongoClient().Find(ctx, model.CollectionInstance, filter)
- if err != nil {
- return nil, err
- }
- var instances []*discovery.MicroServiceInstance
- for res.Next(ctx) {
- var tmp model.Instance
- err := res.Decode(&tmp)
- if err != nil {
- return nil, err
- }
- instances = append(instances, tmp.Instance)
- }
- return instances, nil
-}
-
-func GetInstances(ctx context.Context, filter bson.M) ([]*model.Instance, error) {
- res, err := client.GetMongoClient().Find(ctx, model.CollectionInstance, filter)
- if err != nil {
- return nil, err
- }
- var instances []*model.Instance
- for res.Next(ctx) {
- var tmp *model.Instance
- err := res.Decode(&tmp)
- if err != nil {
- return nil, err
- }
- instances = append(instances, tmp)
- }
- return instances, nil
-}
-
-func GeneratorServiceVersionsFilter(ctx context.Context, service *discovery.MicroServiceKey) bson.M {
- domain := util.ParseDomain(ctx)
- project := util.ParseProject(ctx)
-
- return bson.M{
- model.ColumnDomain: domain,
- model.ColumnProject: project,
- StringBuilder([]string{model.ColumnService, model.ColumnEnv}): service.Environment,
- StringBuilder([]string{model.ColumnService, model.ColumnAppID}): service.AppId,
- StringBuilder([]string{model.ColumnService, model.ColumnServiceName}): service.ServiceName}
-}
-
-func GeneratorServiceInstanceFilter(ctx context.Context, serviceID string) bson.M {
- domain := util.ParseDomain(ctx)
- project := util.ParseProject(ctx)
- return bson.M{
- model.ColumnDomain: domain,
- model.ColumnProject: project,
- StringBuilder([]string{model.ColumnInstance, model.ColumnServiceID}): serviceID}
-}
-
func GetServiceByID(ctx context.Context, serviceID string) (*model.Service, error) {
cacheService, ok := sd.Store().Service().Cache().Get(serviceID).(model.Service)
if !ok {
//no service in cache,get it from mongodb
- return GetService(ctx, GeneratorServiceFilter(ctx, serviceID))
+ filter := mutil.NewBasicFilter(ctx, mutil.ServiceServiceID(serviceID))
+ return dao.GetService(ctx, filter)
}
return cacheToService(cacheService), nil
}
@@ -3026,7 +2602,9 @@ func GetInstancesByServiceID(ctx context.Context, serviceID string) ([]*discover
res = append(res, inst.Instance)
}
if cacheUnavailable || len(res) == 0 {
- res, err := instancesFilter(ctx, []string{serviceID})
+ filter := mutil.NewFilter(mutil.InstanceServiceID(serviceID))
+ option := &options.FindOptions{Sort: bson.M{mutil.ConnectWithDot([]string{model.ColumnInstance, model.ColumnVersion}): -1}}
+ res, err := dao.GetMicroServiceInstances(ctx, filter, option)
if err != nil {
return nil, err
}
diff --git a/datasource/mongo/ms_test.go b/datasource/mongo/ms_test.go
index 59da2b2..d58bbcc 100644
--- a/datasource/mongo/ms_test.go
+++ b/datasource/mongo/ms_test.go
@@ -31,7 +31,7 @@ import (
"github.com/apache/servicecomb-service-center/datasource"
"github.com/apache/servicecomb-service-center/datasource/mongo"
"github.com/apache/servicecomb-service-center/datasource/mongo/client"
- "github.com/apache/servicecomb-service-center/datasource/mongo/model"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/model"
"github.com/apache/servicecomb-service-center/pkg/log"
"github.com/apache/servicecomb-service-center/pkg/util"
"github.com/apache/servicecomb-service-center/server/config"
diff --git a/datasource/mongo/role.go b/datasource/mongo/role.go
index b516921..db75c5d 100644
--- a/datasource/mongo/role.go
+++ b/datasource/mongo/role.go
@@ -20,14 +20,14 @@ package mongo
import (
"context"
- "go.mongodb.org/mongo-driver/bson"
+ "github.com/go-chassis/cari/rbac"
"github.com/apache/servicecomb-service-center/datasource"
"github.com/apache/servicecomb-service-center/datasource/mongo/client"
- "github.com/apache/servicecomb-service-center/datasource/mongo/model"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/model"
+ mutil "github.com/apache/servicecomb-service-center/datasource/mongo/util"
"github.com/apache/servicecomb-service-center/pkg/log"
"github.com/apache/servicecomb-service-center/pkg/util"
- "github.com/go-chassis/cari/rbac"
)
func (ds *DataSource) CreateRole(ctx context.Context, r *rbac.Role) error {
@@ -47,14 +47,12 @@ func (ds *DataSource) CreateRole(ctx context.Context, r *rbac.Role) error {
}
return err
}
- log.Info("create new role: " + r.ID)
+ log.Info("succeed to create new role: " + r.ID)
return nil
}
func (ds *DataSource) RoleExist(ctx context.Context, name string) (bool, error) {
- filter := bson.M{
- model.ColumnRoleName: name,
- }
+ filter := mutil.NewFilter(mutil.RoleName(name))
count, err := client.GetMongoClient().Count(ctx, model.CollectionRole, filter)
if err != nil {
return false, err
@@ -66,9 +64,7 @@ func (ds *DataSource) RoleExist(ctx context.Context, name string) (bool, error)
}
func (ds *DataSource) GetRole(ctx context.Context, name string) (*rbac.Role, error) {
- filter := bson.M{
- model.ColumnRoleName: name,
- }
+ filter := mutil.NewFilter(mutil.RoleName(name))
result, err := client.GetMongoClient().FindOne(ctx, model.CollectionRole, filter)
if err != nil {
return nil, err
@@ -79,14 +75,15 @@ func (ds *DataSource) GetRole(ctx context.Context, name string) (*rbac.Role, err
var role rbac.Role
err = result.Decode(&role)
if err != nil {
- log.Error("Decode role failed: ", err)
+ log.Error("failed to decode role", err)
return nil, err
}
return &role, nil
}
func (ds *DataSource) ListRole(ctx context.Context) ([]*rbac.Role, int64, error) {
- cursor, err := client.GetMongoClient().Find(ctx, model.CollectionRole, bson.M{})
+ filter := mutil.NewFilter()
+ cursor, err := client.GetMongoClient().Find(ctx, model.CollectionRole, filter)
if err != nil {
return nil, 0, err
}
@@ -96,7 +93,7 @@ func (ds *DataSource) ListRole(ctx context.Context) ([]*rbac.Role, int64, error)
var role rbac.Role
err = cursor.Decode(&role)
if err != nil {
- log.Error("decode role failed: ", err)
+ log.Error("failed to decode role", err)
continue
}
roles = append(roles, &role)
@@ -105,9 +102,7 @@ func (ds *DataSource) ListRole(ctx context.Context) ([]*rbac.Role, int64, error)
}
func (ds *DataSource) DeleteRole(ctx context.Context, name string) (bool, error) {
- filter := bson.M{
- model.ColumnRoleName: name,
- }
+ filter := mutil.NewFilter(mutil.RoleName(name))
result, err := client.GetMongoClient().Delete(ctx, model.CollectionRole, filter)
if err != nil {
return false, err
@@ -119,17 +114,14 @@ func (ds *DataSource) DeleteRole(ctx context.Context, name string) (bool, error)
}
func (ds *DataSource) UpdateRole(ctx context.Context, name string, role *rbac.Role) error {
- filter := bson.M{
- model.ColumnRoleName: name,
- }
- update := bson.M{
- "$set": bson.M{
- model.ColumnID: role.ID,
- model.ColumnRoleName: role.Name,
- model.ColumnPerms: role.Perms,
- },
- }
- _, err := client.GetMongoClient().Update(ctx, model.CollectionRole, filter, update)
+ filter := mutil.NewFilter(mutil.RoleName(name))
+ setFilter := mutil.NewFilter(
+ mutil.ID(role.ID),
+ mutil.RoleName(role.Name),
+ mutil.Perms(role.Perms),
+ )
+ updateFilter := mutil.NewFilter(mutil.Set(setFilter))
+ _, err := client.GetMongoClient().Update(ctx, model.CollectionRole, filter, updateFilter)
if err != nil {
return err
}
diff --git a/datasource/mongo/rule_util.go b/datasource/mongo/rule_util.go
index 4fae9ca..e4bd435 100644
--- a/datasource/mongo/rule_util.go
+++ b/datasource/mongo/rule_util.go
@@ -22,7 +22,9 @@ import (
"github.com/go-chassis/cari/discovery"
- "github.com/apache/servicecomb-service-center/datasource/mongo/model"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/dao"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/model"
+ mutil "github.com/apache/servicecomb-service-center/datasource/mongo/util"
"github.com/apache/servicecomb-service-center/pkg/util"
)
@@ -37,8 +39,8 @@ func Filter(ctx context.Context, rules []*model.Rule, consumerID string) (bool,
}
domain := util.ParseDomainProject(ctx)
project := util.ParseProject(ctx)
-
- tags, err := getTags(ctx, domain, project, consumerID)
+ filter := mutil.NewDomainProjectFilter(domain, project, mutil.ServiceServiceID(consumerID))
+ tags, err := dao.GetTags(ctx, filter)
if err != nil {
return false, err
}
diff --git a/datasource/mongo/rule_util_test.go b/datasource/mongo/rule_util_test.go
index 86d4ffa..f0e5bd4 100644
--- a/datasource/mongo/rule_util_test.go
+++ b/datasource/mongo/rule_util_test.go
@@ -26,7 +26,7 @@ import (
"github.com/apache/servicecomb-service-center/datasource"
"github.com/apache/servicecomb-service-center/datasource/mongo"
- "github.com/apache/servicecomb-service-center/datasource/mongo/model"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/model"
)
func TestRuleFilter_Filter(t *testing.T) {
diff --git a/datasource/mongo/sd/listwatch_inner.go b/datasource/mongo/sd/listwatch_inner.go
index 2ee4d35..da673c4 100644
--- a/datasource/mongo/sd/listwatch_inner.go
+++ b/datasource/mongo/sd/listwatch_inner.go
@@ -26,7 +26,7 @@ import (
"go.mongodb.org/mongo-driver/mongo/options"
"github.com/apache/servicecomb-service-center/datasource/mongo/client"
- "github.com/apache/servicecomb-service-center/datasource/mongo/model"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/model"
"github.com/apache/servicecomb-service-center/datasource/sdcommon"
"github.com/apache/servicecomb-service-center/pkg/log"
"github.com/apache/servicecomb-service-center/pkg/util"
diff --git a/datasource/mongo/sd/listwatch_test.go b/datasource/mongo/sd/listwatch_test.go
index 8f2d8c2..f4e8232 100644
--- a/datasource/mongo/sd/listwatch_test.go
+++ b/datasource/mongo/sd/listwatch_test.go
@@ -26,7 +26,7 @@ import (
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
- "github.com/apache/servicecomb-service-center/datasource/mongo/model"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/model"
"github.com/apache/servicecomb-service-center/datasource/sdcommon"
)
diff --git a/datasource/mongo/sd/mongo_cacher.go b/datasource/mongo/sd/mongo_cacher.go
index 0686fc1..0faeeac 100644
--- a/datasource/mongo/sd/mongo_cacher.go
+++ b/datasource/mongo/sd/mongo_cacher.go
@@ -26,7 +26,7 @@ import (
rmodel "github.com/go-chassis/cari/discovery"
- "github.com/apache/servicecomb-service-center/datasource/mongo/model"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/model"
"github.com/apache/servicecomb-service-center/datasource/sdcommon"
"github.com/apache/servicecomb-service-center/pkg/backoff"
"github.com/apache/servicecomb-service-center/pkg/gopool"
diff --git a/datasource/mongo/sd/mongo_cacher_test.go b/datasource/mongo/sd/mongo_cacher_test.go
index 8e6cfd0..6fc9870 100644
--- a/datasource/mongo/sd/mongo_cacher_test.go
+++ b/datasource/mongo/sd/mongo_cacher_test.go
@@ -26,7 +26,7 @@ import (
"github.com/stretchr/testify/assert"
"go.mongodb.org/mongo-driver/bson"
- "github.com/apache/servicecomb-service-center/datasource/mongo/model"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/model"
"github.com/apache/servicecomb-service-center/datasource/sdcommon"
"github.com/apache/servicecomb-service-center/pkg/gopool"
)
diff --git a/datasource/mongo/system.go b/datasource/mongo/system.go
index 9ad647b..e7725c0 100644
--- a/datasource/mongo/system.go
+++ b/datasource/mongo/system.go
@@ -23,7 +23,7 @@ import (
"github.com/patrickmn/go-cache"
"github.com/apache/servicecomb-service-center/datasource"
- "github.com/apache/servicecomb-service-center/datasource/mongo/model"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/model"
"github.com/apache/servicecomb-service-center/datasource/mongo/sd"
"github.com/apache/servicecomb-service-center/pkg/dump"
"github.com/apache/servicecomb-service-center/pkg/gopool"
diff --git a/datasource/mongo/system_test.go b/datasource/mongo/system_test.go
index e38b181..1ac7853 100644
--- a/datasource/mongo/system_test.go
+++ b/datasource/mongo/system_test.go
@@ -26,7 +26,7 @@ import (
"github.com/apache/servicecomb-service-center/datasource"
"github.com/apache/servicecomb-service-center/datasource/mongo/client"
- "github.com/apache/servicecomb-service-center/datasource/mongo/model"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/model"
"github.com/apache/servicecomb-service-center/datasource/mongo/sd"
)
diff --git a/datasource/mongo/util.go b/datasource/mongo/util.go
index a886599..d0954e1 100644
--- a/datasource/mongo/util.go
+++ b/datasource/mongo/util.go
@@ -19,14 +19,16 @@ package mongo
import (
"context"
- "strings"
+
+ pb "github.com/go-chassis/cari/discovery"
+ "go.mongodb.org/mongo-driver/bson"
"github.com/apache/servicecomb-service-center/datasource"
- "github.com/apache/servicecomb-service-center/datasource/mongo/model"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/dao"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/model"
+ mutil "github.com/apache/servicecomb-service-center/datasource/mongo/util"
"github.com/apache/servicecomb-service-center/pkg/gopool"
"github.com/apache/servicecomb-service-center/pkg/util"
- pb "github.com/go-chassis/cari/discovery"
- "go.mongodb.org/mongo-driver/bson"
)
type InstanceSlice []*pb.MicroServiceInstance
@@ -43,18 +45,6 @@ func (s InstanceSlice) Less(i, j int) bool {
return s[i].InstanceId < s[j].InstanceId
}
-func StringBuilder(data []string) string {
- var str strings.Builder
- for index, value := range data {
- if index == 0 {
- str.WriteString(value)
- } else {
- str.WriteString("." + value)
- }
- }
- return str.String()
-}
-
func statistics(ctx context.Context, withShared bool) (*pb.Statistics, error) {
result := &pb.Statistics{
Services: &pb.StService{},
@@ -66,7 +56,7 @@ func statistics(ctx context.Context, withShared bool) (*pb.Statistics, error) {
filter := bson.M{model.ColumnDomain: domain, model.ColumnProject: project}
- services, err := GetServices(ctx, filter)
+ services, err := dao.GetMicroServices(ctx, filter)
if err != nil {
return nil, err
}
@@ -84,7 +74,7 @@ func statistics(ctx context.Context, withShared bool) (*pb.Statistics, error) {
getInstanceCountByDomain(ctx, svcIDToNonVerKey, respGetInstanceCountByDomain)
})
- instances, err := GetInstances(ctx, filter)
+ instances, err := dao.GetInstances(ctx, filter)
if err != nil {
return nil, err
}
@@ -104,8 +94,11 @@ func statistics(ctx context.Context, withShared bool) (*pb.Statistics, error) {
func getInstanceCountByDomain(ctx context.Context, svcIDToNonVerKey map[string]string, resp chan datasource.GetInstanceCountByDomainResponse) {
ret := datasource.GetInstanceCountByDomainResponse{}
+ domain := util.ParseDomain(ctx)
+ project := util.ParseProject(ctx)
for _, sid := range svcIDToNonVerKey {
- num, err := GetInstanceCountOfOneService(ctx, sid)
+ filter := mutil.NewDomainProjectFilter(domain, project, mutil.InstanceServiceID(sid))
+ num, err := dao.CountInstance(ctx, filter)
if err != nil {
ret.Err = err
return
diff --git a/datasource/mongo/util/db.go b/datasource/mongo/util/db.go
index 9c5f437..7c97c0e 100644
--- a/datasource/mongo/util/db.go
+++ b/datasource/mongo/util/db.go
@@ -18,11 +18,15 @@
package util
import (
+ "context"
+
+ "github.com/go-chassis/cari/rbac"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/x/bsonx"
- "github.com/apache/servicecomb-service-center/datasource/mongo/model"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/client/model"
+ "github.com/apache/servicecomb-service-center/pkg/util"
)
type Option func(filter bson.M)
@@ -39,6 +43,72 @@ func Project(project string) Option {
}
}
+func AccountName(name interface{}) Option {
+ return func(filter bson.M) {
+ filter[model.ColumnAccountName] = name
+ }
+}
+
+func Password(password string) Option {
+ return func(filter bson.M) {
+ filter[model.ColumnPassword] = password
+ }
+}
+
+func Roles(roles []string) Option {
+ return func(filter bson.M) {
+ filter[model.ColumnRoles] = roles
+ }
+}
+
+func TokenExpirationTime(tokenExpirationTime string) Option {
+ return func(filter bson.M) {
+ filter[model.ColumnTokenExpirationTime] = tokenExpirationTime
+ }
+}
+
+func CurrentPassword(password string) Option {
+ return func(filter bson.M) {
+ filter[model.ColumnCurrentPassword] = password
+ }
+}
+
+func Status(status string) Option {
+ return func(filter bson.M) {
+ filter[model.ColumnStatus] = status
+ }
+}
+
+func ID(id string) Option {
+ return func(filter bson.M) {
+ filter[model.ColumnID] = id
+ }
+}
+
+func RoleName(name string) Option {
+ return func(filter bson.M) {
+ filter[model.ColumnRoleName] = name
+ }
+}
+
+func Perms(perms []*rbac.Permission) Option {
+ return func(filter bson.M) {
+ filter[model.ColumnPerms] = perms
+ }
+}
+
+func In(data interface{}) Option {
+ return func(filter bson.M) {
+ filter["$in"] = data
+ }
+}
+
+func Set(data interface{}) Option {
+ return func(filter bson.M) {
+ filter["$set"] = data
+ }
+}
+
func NewFilter(options ...func(filter bson.M)) bson.M {
filter := bson.M{}
for _, option := range options {
@@ -47,15 +117,214 @@ func NewFilter(options ...func(filter bson.M)) bson.M {
return filter
}
-func InstanceServiceID(serviceID string) Option {
+func NewDomainProjectFilter(domain string, project string, options ...func(filter bson.M)) bson.M {
+ filter := bson.M{
+ model.ColumnDomain: domain,
+ model.ColumnProject: project,
+ }
+ for _, option := range options {
+ option(filter)
+ }
+ return filter
+}
+
+func NewBasicFilter(ctx context.Context, options ...func(filter bson.M)) bson.M {
+ domain := util.ParseDomain(ctx)
+ project := util.ParseProject(ctx)
+
+ filter := bson.M{
+ model.ColumnDomain: domain,
+ model.ColumnProject: project,
+ }
+ for _, option := range options {
+ option(filter)
+ }
+ return filter
+}
+
+func InstanceServiceID(serviceID interface{}) Option {
return func(filter bson.M) {
- filter[StringBuilder([]string{model.ColumnInstance, model.ColumnServiceID})] = serviceID
+ filter[ConnectWithDot([]string{model.ColumnInstance, model.ColumnServiceID})] = serviceID
}
}
func InstanceInstanceID(instanceID string) Option {
return func(filter bson.M) {
- filter[StringBuilder([]string{model.ColumnInstance, model.ColumnInstanceID})] = instanceID
+ filter[ConnectWithDot([]string{model.ColumnInstance, model.ColumnInstanceID})] = instanceID
+ }
+}
+
+func ServiceServiceID(serviceID string) Option {
+ return func(filter bson.M) {
+ filter[ConnectWithDot([]string{model.ColumnService, model.ColumnServiceID})] = serviceID
+ }
+}
+
+func ServiceEnv(env string) Option {
+ return func(filter bson.M) {
+ filter[ConnectWithDot([]string{model.ColumnService, model.ColumnEnv})] = env
+ }
+}
+
+func ServiceAppID(appID string) Option {
+ return func(filter bson.M) {
+ filter[ConnectWithDot([]string{model.ColumnService, model.ColumnAppID})] = appID
+ }
+}
+
+func ServiceModTime(modTime string) Option {
+ return func(filter bson.M) {
+ filter[ConnectWithDot([]string{model.ColumnService, model.ColumnModTime})] = modTime
+ }
+}
+
+func ServiceProperty(property map[string]string) Option {
+ return func(filter bson.M) {
+ filter[ConnectWithDot([]string{model.ColumnService, model.ColumnProperty})] = property
+ }
+}
+
+func ServiceServiceName(serviceName string) Option {
+ return func(filter bson.M) {
+ filter[ConnectWithDot([]string{model.ColumnService, model.ColumnServiceName})] = serviceName
+ }
+}
+
+func ServiceID(serviceID string) Option {
+ return func(filter bson.M) {
+ filter[model.ColumnServiceID] = serviceID
+ }
+}
+
+func ServiceAlias(alias string) Option {
+ return func(filter bson.M) {
+ filter[ConnectWithDot([]string{model.ColumnService, model.ColumnAlias})] = alias
+ }
+}
+
+func ServiceSchemas(schemas []string) Option {
+ return func(filter bson.M) {
+ filter[ConnectWithDot([]string{model.ColumnService, model.ColumnSchemas})] = schemas
+ }
+}
+
+func ServiceVersion(version interface{}) Option {
+ return func(filter bson.M) {
+ filter[ConnectWithDot([]string{model.ColumnService, model.ColumnVersion})] = version
+ }
+}
+
+func ServiceType(serviceType string) Option {
+ return func(filter bson.M) {
+ filter[model.ColumnServiceType] = serviceType
+ }
+}
+
+func ServiceKeyTenant(tenant string) Option {
+ return func(filter bson.M) {
+ filter[ConnectWithDot([]string{model.ColumnServiceKey, model.ColumnTenant})] = tenant
+ }
+}
+
+func ServiceKeyAppID(appID string) Option {
+ return func(filter bson.M) {
+ filter[ConnectWithDot([]string{model.ColumnServiceKey, model.ColumnAppID})] = appID
+ }
+}
+
+func ServiceKeyServiceName(serviceName string) Option {
+ return func(filter bson.M) {
+ filter[ConnectWithDot([]string{model.ColumnServiceKey, model.ColumnServiceName})] = serviceName
+ }
+}
+
+func ServiceKeyServiceEnv(env string) Option {
+ return func(filter bson.M) {
+ filter[ConnectWithDot([]string{model.ColumnServiceKey, model.ColumnEnv})] = env
+ }
+}
+
+func ServiceKeyServiceVersion(version string) Option {
+ return func(filter bson.M) {
+ filter[ConnectWithDot([]string{model.ColumnServiceKey, model.ColumnVersion})] = version
+ }
+}
+
+func Schema(schema string) Option {
+ return func(filter bson.M) {
+ filter[model.ColumnSchema] = schema
+ }
+}
+
+func SchemaID(schemaID string) Option {
+ return func(filter bson.M) {
+ filter[model.ColumnSchemaID] = schemaID
+ }
+}
+
+func RuleAttribute(attribute string) Option {
+ return func(filter bson.M) {
+ filter[ConnectWithDot([]string{model.ColumnRule, model.ColumnAttribute})] = attribute
+ }
+}
+
+func RuleRuleID(ruleID string) Option {
+ return func(filter bson.M) {
+ filter[ConnectWithDot([]string{model.ColumnRule, model.ColumnRuleID})] = ruleID
+ }
+}
+
+func RuleRuleType(ruleType string) Option {
+ return func(filter bson.M) {
+ filter[ConnectWithDot([]string{model.ColumnRule, model.ColumnRuleType})] = ruleType
+ }
+}
+
+func RulePattern(pattern string) Option {
+ return func(filter bson.M) {
+ filter[ConnectWithDot([]string{model.ColumnRule, model.ColumnPattern})] = pattern
+ }
+}
+
+func RuleDescription(description string) Option {
+ return func(filter bson.M) {
+ filter[ConnectWithDot([]string{model.ColumnRule, model.ColumnDescription})] = description
+ }
+}
+
+func RuleModTime(modTime string) Option {
+ return func(filter bson.M) {
+ filter[ConnectWithDot([]string{model.ColumnRule, model.ColumnModTime})] = modTime
+ }
+}
+
+func SchemaSummary(schemaSummary string) Option {
+ return func(filter bson.M) {
+ filter[model.ColumnSchemaSummary] = schemaSummary
+ }
+}
+
+func Tags(tags map[string]string) Option {
+ return func(filter bson.M) {
+ filter[model.ColumnTag] = tags
+ }
+}
+
+func InstanceModTime(modTime string) Option {
+ return func(filter bson.M) {
+ filter[ConnectWithDot([]string{model.ColumnService, model.ColumnModTime})] = modTime
+ }
+}
+
+func InstanceStatus(status string) Option {
+ return func(filter bson.M) {
+ filter[ConnectWithDot([]string{model.ColumnInstance, model.ColumnStatus})] = status
+ }
+}
+
+func InstanceProperties(properties map[string]string) Option {
+ return func(filter bson.M) {
+ filter[ConnectWithDot([]string{model.ColumnInstance, model.ColumnProperty})] = properties
}
}
diff --git a/datasource/mongo/util/string.go b/datasource/mongo/util/string.go
index aadad1b..1aadd1e 100644
--- a/datasource/mongo/util/string.go
+++ b/datasource/mongo/util/string.go
@@ -19,7 +19,7 @@ package util
import "strings"
-func StringBuilder(data []string) string {
+func ConnectWithDot(data []string) string {
var str strings.Builder
for index, value := range data {
if index == 0 {