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/12 01:10:10 UTC
[servicecomb-service-center] branch master updated: [SCB-2094]
Restructure database/mongo (#894)
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 b024cd5 [SCB-2094] Restructure database/mongo (#894)
b024cd5 is described below
commit b024cd54e13e4f73c362159aa14e4159351ac036
Author: robotLJW <79...@qq.com>
AuthorDate: Fri Mar 12 09:10:01 2021 +0800
[SCB-2094] Restructure database/mongo (#894)
1.rename db to model
2.[SCB-2094] Restructure database/mongo
---
datasource/mongo/account.go | 37 +-
datasource/mongo/dep.go | 67 ++--
datasource/mongo/dep_util.go | 4 +-
datasource/mongo/dependency_query.go | 143 +++----
datasource/mongo/engine.go | 13 +-
datasource/mongo/event/instance_event_handler.go | 20 +-
.../mongo/event/instance_event_handler_test.go | 6 +-
datasource/mongo/heartbeat/cache/heartbeat.go | 34 +-
datasource/mongo/heartbeat/cache/heartbeat_test.go | 20 +-
.../mongo/heartbeat/cache/heartbeatcache_test.go | 12 +-
datasource/mongo/heartbeat/checker/heartbeat.go | 10 +-
.../mongo/heartbeat/checker/heartbeat_test.go | 20 +-
.../heartbeat/checker/heartbeatchecker_test.go | 10 +-
datasource/mongo/{db => model}/types.go | 2 +-
datasource/mongo/mongo.go | 69 ++--
datasource/mongo/ms.go | 423 +++++++++++----------
datasource/mongo/ms_test.go | 22 +-
datasource/mongo/role.go | 28 +-
datasource/mongo/rule_util.go | 6 +-
datasource/mongo/rule_util_test.go | 8 +-
datasource/mongo/sd/listwatch_inner.go | 6 +-
datasource/mongo/sd/listwatch_test.go | 4 +-
datasource/mongo/sd/mongo_cacher.go | 10 +-
datasource/mongo/sd/mongo_cacher_test.go | 8 +-
datasource/mongo/system.go | 6 +-
datasource/mongo/system_test.go | 6 +-
datasource/mongo/util.go | 22 +-
datasource/mongo/util/db.go | 71 ++++
datasource/mongo/{common.go => util/errors.go} | 20 +-
datasource/mongo/util/string.go | 32 ++
30 files changed, 617 insertions(+), 522 deletions(-)
diff --git a/datasource/mongo/account.go b/datasource/mongo/account.go
index 044c8bf..99b1678 100644
--- a/datasource/mongo/account.go
+++ b/datasource/mongo/account.go
@@ -26,7 +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/db"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/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"
"github.com/apache/servicecomb-service-center/pkg/util"
@@ -47,7 +48,7 @@ func (ds *DataSource) CreateAccount(ctx context.Context, a *rbac.Account) error
return err
}
a.ID = util.GenerateUUID()
- _, err = client.GetMongoClient().Insert(ctx, db.CollectionAccount, a)
+ _, err = client.GetMongoClient().Insert(ctx, model.CollectionAccount, a)
if err != nil {
if client.IsDuplicateKey(err) {
return datasource.ErrAccountDuplicated
@@ -60,9 +61,9 @@ func (ds *DataSource) CreateAccount(ctx context.Context, a *rbac.Account) error
func (ds *DataSource) AccountExist(ctx context.Context, name string) (bool, error) {
filter := bson.M{
- db.ColumnAccountName: name,
+ model.ColumnAccountName: name,
}
- count, err := client.GetMongoClient().Count(ctx, db.CollectionAccount, filter)
+ count, err := client.GetMongoClient().Count(ctx, model.CollectionAccount, filter)
if err != nil {
return false, err
}
@@ -74,9 +75,9 @@ 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{
- db.ColumnAccountName: name,
+ model.ColumnAccountName: name,
}
- result, err := client.GetMongoClient().FindOne(ctx, db.CollectionAccount, filter)
+ result, err := client.GetMongoClient().FindOne(ctx, model.CollectionAccount, filter)
if err != nil {
return nil, err
}
@@ -94,7 +95,7 @@ func (ds *DataSource) GetAccount(ctx context.Context, name string) (*rbac.Accoun
}
func (ds *DataSource) ListAccount(ctx context.Context) ([]*rbac.Account, int64, error) {
- cursor, err := client.GetMongoClient().Find(ctx, db.CollectionAccount, bson.M{})
+ cursor, err := client.GetMongoClient().Find(ctx, model.CollectionAccount, bson.M{})
if err != nil {
return nil, 0, err
}
@@ -118,9 +119,9 @@ func (ds *DataSource) DeleteAccount(ctx context.Context, names []string) (bool,
return false, nil
}
filter := bson.M{
- db.ColumnAccountName: names[0],
+ model.ColumnAccountName: names[0],
}
- result, err := client.GetMongoClient().Delete(ctx, db.CollectionAccount, filter)
+ result, err := client.GetMongoClient().Delete(ctx, model.CollectionAccount, filter)
if err != nil {
return false, err
}
@@ -132,24 +133,24 @@ 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{
- db.ColumnAccountName: name,
+ model.ColumnAccountName: name,
}
update := bson.M{
"$set": bson.M{
- db.ColumnID: account.ID,
- db.ColumnPassword: account.Password,
- db.ColumnRoles: account.Roles,
- db.ColumnTokenExpirationTime: account.TokenExpirationTime,
- db.ColumnCurrentPassword: account.CurrentPassword,
- db.ColumnStatus: account.Status,
+ 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, db.CollectionAccount, filter, update)
+ res, err := client.GetMongoClient().Update(ctx, model.CollectionAccount, filter, update)
if err != nil {
return err
}
if res.ModifiedCount == 0 {
- return ErrUpdateNodata
+ return mutil.ErrNoDataToUpdate
}
return nil
}
diff --git a/datasource/mongo/dep.go b/datasource/mongo/dep.go
index f8e42be..ea83355 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/db"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/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"
)
@@ -147,14 +148,14 @@ func (ds *DataSource) AddOrUpdateDependencies(ctx context.Context, dependencys [
domain := util.ParseDomain(ctx)
project := util.ParseProject(ctx)
- data := &db.ConsumerDep{
+ data := &model.ConsumerDep{
Domain: domain,
Project: project,
ConsumerID: consumerID,
UUID: id,
ConsumerDep: dependency,
}
- insertRes, err := client.GetMongoClient().Insert(ctx, db.CollectionDep, data)
+ insertRes, err := client.GetMongoClient().Insert(ctx, model.CollectionDep, data)
if err != nil {
log.Error("failed to insert dep to mongodb", err)
return discovery.CreateResponse(discovery.ErrInternal, err.Error()), err
@@ -203,7 +204,7 @@ func GetOldProviderRules(dep *datasource.Dependency) (*discovery.MicroServiceDep
Dependency: []*discovery.MicroServiceKey{},
}
filter := GenerateConsumerDependencyRuleKey(dep.DomainProject, dep.Consumer)
- findRes, err := client.GetMongoClient().FindOne(context.TODO(), db.CollectionDep, filter)
+ findRes, err := client.GetMongoClient().FindOne(context.TODO(), model.CollectionDep, filter)
if err != nil {
log.Error(fmt.Sprintf("get dependency rule [%v] failed", filter), err)
return nil, err
@@ -213,7 +214,7 @@ func GetOldProviderRules(dep *datasource.Dependency) (*discovery.MicroServiceDep
return microServiceDependency, nil
}
- var depRule *db.DependencyRule
+ var depRule *model.DependencyRule
err = findRes.Decode(&depRule)
if err != nil {
return nil, err
@@ -225,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(), db.CollectionDep, filter, bson.M{"$pull": bson.M{StringBuilder([]string{db.ColumnDep, db.ColumnDependency}): dep.Consumer}})
+ _, err := client.GetMongoClient().Update(context.TODO(), model.CollectionDep, filter, bson.M{"$pull": bson.M{StringBuilder([]string{model.ColumnDep, model.ColumnDependency}): dep.Consumer}})
if err != nil {
return err
}
@@ -236,9 +237,9 @@ 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{db.ColumnDep, db.ColumnDependency}): dep.Consumer},
+ "$addToSet": bson.M{StringBuilder([]string{model.ColumnDep, model.ColumnDependency}): dep.Consumer},
}
- _, err := client.GetMongoClient().Update(context.TODO(), db.CollectionDep, filter, data, &options.UpdateOptions{Upsert: &upsert})
+ _, err := client.GetMongoClient().Update(context.TODO(), model.CollectionDep, filter, data, &options.UpdateOptions{Upsert: &upsert})
if err != nil {
return err
}
@@ -248,15 +249,15 @@ func updateDeps(domainProject string, dep *datasource.Dependency) error {
}
filter := GenerateConsumerDependencyRuleKey(domainProject, dep.Consumer)
if len(dep.ProvidersRule) == 0 {
- _, err := client.GetMongoClient().Delete(context.TODO(), db.CollectionDep, filter)
+ _, err := client.GetMongoClient().Delete(context.TODO(), model.CollectionDep, filter)
if err != nil {
return err
}
} else {
updateData := bson.M{
- "$set": bson.M{StringBuilder([]string{db.ColumnDep, db.ColumnDependency}): dep.ProvidersRule},
+ "$set": bson.M{StringBuilder([]string{model.ColumnDep, model.ColumnDependency}): dep.ProvidersRule},
}
- _, err := client.GetMongoClient().Update(context.TODO(), db.CollectionDep, filter, updateData, &options.UpdateOptions{Upsert: &upsert})
+ _, err := client.GetMongoClient().Update(context.TODO(), model.CollectionDep, filter, updateData, &options.UpdateOptions{Upsert: &upsert})
if err != nil {
return err
}
@@ -272,10 +273,10 @@ func updateDeps(domainProject string, dep *datasource.Dependency) error {
func CleanUpDepRules(ctx context.Context, domainProject string) error {
if len(domainProject) == 0 {
- return ErrInvalidDomainProject
+ return mutil.ErrInvalidDomainProject
}
- cache := make(map[*db.DelDepCacheKey]bool)
+ cache := make(map[*model.DelDepCacheKey]bool)
err := removeProviderRuleOfConsumer(ctx, domainProject, cache)
if err != nil {
@@ -285,7 +286,7 @@ func CleanUpDepRules(ctx context.Context, domainProject string) error {
return removeProviderRuleKeys(ctx, domainProject, cache)
}
-func removeProviderRuleOfConsumer(ctx context.Context, domainProject string, cache map[*db.DelDepCacheKey]bool) error {
+func removeProviderRuleOfConsumer(ctx context.Context, domainProject string, cache map[*model.DelDepCacheKey]bool) error {
filter := GenerateConsumerDependencyRuleKey(domainProject, nil)
depRules, err := GetDepRules(ctx, filter)
if err != nil {
@@ -300,7 +301,7 @@ func removeProviderRuleOfConsumer(ctx context.Context, domainProject string, cac
return nil
}
-func removeProviderRuleKeys(ctx context.Context, domainProject string, cache map[*db.DelDepCacheKey]bool) error {
+func removeProviderRuleKeys(ctx context.Context, domainProject string, cache map[*model.DelDepCacheKey]bool) error {
filter := GenerateProviderDependencyRuleKey(domainProject, nil)
depRules, err := GetDepRules(ctx, filter)
if err != nil {
@@ -315,15 +316,15 @@ func removeProviderRuleKeys(ctx context.Context, domainProject string, cache map
return nil
}
-func GetDepRules(ctx context.Context, filter bson.M) ([]*db.DependencyRule, error) {
- findRes, err := client.GetMongoClient().Find(ctx, db.CollectionDep, filter)
+func GetDepRules(ctx context.Context, filter bson.M) ([]*model.DependencyRule, error) {
+ findRes, err := client.GetMongoClient().Find(ctx, model.CollectionDep, filter)
if err != nil {
return nil, err
}
- var depRules []*db.DependencyRule
+ var depRules []*model.DependencyRule
for findRes.Next(ctx) {
- var depRule *db.DependencyRule
+ var depRule *model.DependencyRule
err := findRes.Decode(&depRule)
if err != nil {
return nil, err
@@ -333,8 +334,8 @@ func GetDepRules(ctx context.Context, filter bson.M) ([]*db.DependencyRule, erro
return depRules, nil
}
-func removeProviderDeps(ctx context.Context, depRule *db.DependencyRule, cache map[*db.DelDepCacheKey]bool) (err error) {
- id := &db.DelDepCacheKey{
+func removeProviderDeps(ctx context.Context, depRule *model.DependencyRule, cache map[*model.DelDepCacheKey]bool) (err error) {
+ id := &model.DelDepCacheKey{
Key: depRule.ServiceKey,
Type: path.DepsConsumer,
}
@@ -353,10 +354,10 @@ func removeProviderDeps(ctx context.Context, depRule *db.DependencyRule, cache m
}
filter := bson.M{
- db.ColumnServiceKey: depRule.ServiceKey,
+ model.ColumnServiceKey: depRule.ServiceKey,
}
if !exist {
- _, err = client.GetMongoClient().DocDelete(ctx, db.CollectionDep, filter)
+ _, err = client.GetMongoClient().DocDelete(ctx, model.CollectionDep, filter)
if err != nil {
return err
}
@@ -364,7 +365,7 @@ func removeProviderDeps(ctx context.Context, depRule *db.DependencyRule, cache m
return nil
}
-func removeConsumerDeps(ctx context.Context, depRule *db.DependencyRule, cache map[*db.DelDepCacheKey]bool) (err error) {
+func removeConsumerDeps(ctx context.Context, depRule *model.DependencyRule, cache map[*model.DelDepCacheKey]bool) (err error) {
var left []*discovery.MicroServiceKey
for _, key := range depRule.Dep.Dependency {
if key.ServiceName == "*" {
@@ -372,7 +373,7 @@ func removeConsumerDeps(ctx context.Context, depRule *db.DependencyRule, cache m
continue
}
- id := &db.DelDepCacheKey{
+ id := &model.DelDepCacheKey{
Key: key,
Type: path.DepsProvider,
}
@@ -394,15 +395,15 @@ func removeConsumerDeps(ctx context.Context, depRule *db.DependencyRule, cache m
}
filter := bson.M{
- db.ColumnServiceKey: depRule.ServiceKey,
+ model.ColumnServiceKey: depRule.ServiceKey,
}
if len(left) == 0 {
- _, err = client.GetMongoClient().DocDelete(ctx, db.CollectionDep, filter)
+ _, err = client.GetMongoClient().DocDelete(ctx, model.CollectionDep, filter)
} else {
updateData := bson.M{
- "$set": bson.M{StringBuilder([]string{db.ColumnDep, db.ColumnDependency}): left},
+ "$set": bson.M{StringBuilder([]string{model.ColumnDep, model.ColumnDependency}): left},
}
- _, err = client.GetMongoClient().Update(ctx, db.CollectionDep, filter, updateData)
+ _, err = client.GetMongoClient().Update(ctx, model.CollectionDep, filter, updateData)
}
if err != nil {
return err
@@ -414,12 +415,12 @@ func TransferToMicroServiceDependency(ctx context.Context, filter bson.M) (*disc
microServiceDependency := &discovery.MicroServiceDependency{
Dependency: []*discovery.MicroServiceKey{},
}
- findRes, err := client.GetMongoClient().FindOne(context.TODO(), db.CollectionDep, filter)
+ findRes, err := client.GetMongoClient().FindOne(context.TODO(), model.CollectionDep, filter)
if err != nil {
return nil, err
}
if findRes.Err() == nil {
- var depRule *db.DependencyRule
+ var depRule *model.DependencyRule
err := findRes.Decode(&depRule)
if err != nil {
return nil, err
@@ -433,13 +434,13 @@ func TransferToMicroServiceDependency(ctx context.Context, filter bson.M) (*disc
func GetConsumerDepInfo(ctx context.Context, filter bson.M) ([]*discovery.ConsumerDependency, error) {
var ConsumerDeps []*discovery.ConsumerDependency
- findRes, err := client.GetMongoClient().Find(context.TODO(), db.CollectionDep, filter)
+ findRes, err := client.GetMongoClient().Find(context.TODO(), model.CollectionDep, filter)
if err != nil {
return nil, err
}
for findRes.Next(ctx) {
- var dep *db.ConsumerDep
+ var dep *model.ConsumerDep
err = findRes.Decode(&dep)
if err != nil {
return nil, err
diff --git a/datasource/mongo/dep_util.go b/datasource/mongo/dep_util.go
index 3150457..d50ca89 100644
--- a/datasource/mongo/dep_util.go
+++ b/datasource/mongo/dep_util.go
@@ -23,7 +23,7 @@ import (
pb "github.com/go-chassis/cari/discovery"
- "github.com/apache/servicecomb-service-center/datasource/mongo/db"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/model"
"github.com/apache/servicecomb-service-center/pkg/log"
"github.com/apache/servicecomb-service-center/pkg/util"
)
@@ -48,7 +48,7 @@ func GetAllConsumerIds(ctx context.Context, provider *pb.MicroService) (allow []
return allow, deny, nil
}
-func GetConsumerIDsWithFilter(ctx context.Context, provider *pb.MicroService, rules []*db.Rule) (allow []string, deny []string, err error) {
+func GetConsumerIDsWithFilter(ctx context.Context, provider *pb.MicroService, rules []*model.Rule) (allow []string, deny []string, err error) {
domainProject := util.ParseDomainProject(ctx)
dr := NewProviderDependencyRelation(ctx, domainProject, provider)
consumerIDs, err := dr.GetDependencyConsumerIds()
diff --git a/datasource/mongo/dependency_query.go b/datasource/mongo/dependency_query.go
index 8a7acab..cc482ea 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/db"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/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"
)
@@ -144,7 +145,7 @@ func (dr *DependencyRelation) GetDependencyConsumers(opts ...DependencyRelationF
func (dr *DependencyRelation) GetDependencyConsumersOfProvider() ([]*pb.MicroServiceKey, error) {
if dr.provider == nil {
- return nil, ErrInvalidConsumer
+ return nil, util.ErrInvalidConsumer
}
consumerDependAllList, err := dr.getConsumerOfDependAllServices()
if err != nil {
@@ -231,7 +232,7 @@ func (dr *DependencyRelation) GetServiceByMicroServiceKey(service *pb.MicroServi
log.Error("get serivce failed", err)
return nil, err
}
- findRes, err := client.GetMongoClient().Find(dr.ctx, db.CollectionService, filter)
+ findRes, err := client.GetMongoClient().Find(dr.ctx, model.CollectionService, filter)
if err != nil {
return nil, err
}
@@ -240,7 +241,7 @@ func (dr *DependencyRelation) GetServiceByMicroServiceKey(service *pb.MicroServi
}
for findRes.Next(dr.ctx) {
- var service db.Service
+ var service model.Service
err = findRes.Decode(&service)
if err != nil {
return nil, err
@@ -256,7 +257,7 @@ func (dr *DependencyRelation) getConsumerOfDependAllServices() ([]*pb.MicroServi
providerService := pb.MicroServiceToKey(dr.domainProject, dr.provider)
providerService.ServiceName = "*"
filter := GenerateProviderDependencyRuleKey(dr.domainProject, providerService)
- findRes, err := client.GetMongoClient().Find(dr.ctx, db.CollectionDep, filter)
+ findRes, err := client.GetMongoClient().Find(dr.ctx, model.CollectionDep, filter)
if err != nil {
return nil, err
}
@@ -266,7 +267,7 @@ func (dr *DependencyRelation) getConsumerOfDependAllServices() ([]*pb.MicroServi
var msKeys []*pb.MicroServiceKey
for findRes.Next(dr.ctx) {
- var depRule *db.DependencyRule
+ var depRule *model.DependencyRule
err = findRes.Decode(&depRule)
if err != nil {
return nil, err
@@ -276,15 +277,15 @@ func (dr *DependencyRelation) getConsumerOfDependAllServices() ([]*pb.MicroServi
return msKeys, nil
}
-func getServiceKeysInDep(ctx context.Context, filter interface{}) ([]*db.DependencyRule, error) {
- findRes, err := client.GetMongoClient().Find(ctx, db.CollectionDep, filter)
+func getServiceKeysInDep(ctx context.Context, filter interface{}) ([]*model.DependencyRule, error) {
+ findRes, err := client.GetMongoClient().Find(ctx, model.CollectionDep, filter)
if err != nil {
return nil, err
}
defer findRes.Close(ctx)
- var depRules []*db.DependencyRule
+ var depRules []*model.DependencyRule
for findRes.Next(ctx) {
- var tmp *db.DependencyRule
+ var tmp *model.DependencyRule
err := findRes.Decode(&tmp)
if err != nil {
return nil, err
@@ -296,7 +297,7 @@ func getServiceKeysInDep(ctx context.Context, filter interface{}) ([]*db.Depende
func (dr *DependencyRelation) getProviderKeys() ([]*pb.MicroServiceKey, error) {
if dr.consumer == nil {
- return nil, ErrInvalidConsumer
+ return nil, util.ErrInvalidConsumer
}
consumerMicroServiceKey := pb.MicroServiceToKey(dr.domainProject, dr.consumer)
filter := GenerateConsumerDependencyRuleKey(dr.domainProject, consumerMicroServiceKey)
@@ -318,12 +319,12 @@ func (dr *DependencyRelation) parseDependencyRule(dependencyRule *pb.MicroServic
log.Error("get serivce failed", err)
return nil, err
}
- findRes, err := client.GetMongoClient().Find(dr.ctx, db.CollectionService, filter)
+ findRes, err := client.GetMongoClient().Find(dr.ctx, model.CollectionService, filter)
if err != nil {
return nil, err
}
for findRes.Next(dr.ctx) {
- var service db.Service
+ var service model.Service
err = findRes.Decode(&service)
if err != nil {
return nil, err
@@ -362,26 +363,26 @@ func (dr *DependencyRelation) GetDependencyConsumerIds() ([]string, error) {
func MicroServiceKeyFilter(key *pb.MicroServiceKey) (bson.M, error) {
tenant := strings.Split(key.Tenant, "/")
if len(tenant) != 2 {
- return nil, ErrInvalidDomainProject
+ return nil, util.ErrInvalidDomainProject
}
return bson.M{
- db.ColumnDomain: tenant[0],
- db.ColumnProject: tenant[1],
- StringBuilder([]string{db.ColumnService, db.ColumnEnv}): key.Environment,
- StringBuilder([]string{db.ColumnService, db.ColumnAppID}): key.AppId,
- StringBuilder([]string{db.ColumnService, db.ColumnAlias}): key.Alias,
- StringBuilder([]string{db.ColumnService, db.ColumnVersion}): key.Version}, nil
+ 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
}
func RelyAllServiceKey(key *pb.MicroServiceKey) (bson.M, error) {
tenant := strings.Split(key.Tenant, "/")
if len(tenant) != 2 {
- return nil, ErrInvalidDomainProject
+ return nil, util.ErrInvalidDomainProject
}
return bson.M{
- db.ColumnDomain: tenant[0],
- db.ColumnProject: tenant[1],
- StringBuilder([]string{db.ColumnService, db.ColumnEnv}): key.Environment}, nil
+ model.ColumnDomain: tenant[0],
+ model.ColumnProject: tenant[1],
+ StringBuilder([]string{model.ColumnService, model.ColumnEnv}): key.Environment}, nil
}
func FindServiceIds(ctx context.Context, versionRule string, key *pb.MicroServiceKey) ([]string, bool, error) {
@@ -391,14 +392,14 @@ func FindServiceIds(ctx context.Context, versionRule string, key *pb.MicroServic
tenant := strings.Split(key.Tenant, "/")
if len(tenant) != 2 {
- return nil, false, ErrInvalidDomainProject
+ return nil, false, util.ErrInvalidDomainProject
}
baseFilter := bson.D{
- {Key: db.ColumnDomain, Value: tenant[0]},
- {Key: db.ColumnProject, Value: tenant[1]},
- {Key: StringBuilder([]string{db.ColumnService, db.ColumnEnv}), Value: key.Environment},
- {Key: StringBuilder([]string{db.ColumnService, db.ColumnAppID}), Value: key.AppId}}
+ {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}}
serviceIds, exist, err := findServiceKeysByServiceName(ctx, versionRule, key, baseFilter)
if err != nil {
@@ -422,7 +423,7 @@ func FindServiceIds(ctx context.Context, versionRule string, key *pb.MicroServic
}
func serviceVersionFilter(ctx context.Context, versionRule string, filter bson.D) ([]string, bool, error) {
- baseExist, err := client.GetMongoClient().DocExist(ctx, db.CollectionService, filter)
+ baseExist, err := client.GetMongoClient().DocExist(ctx, model.CollectionService, filter)
if err != nil || !baseExist {
return nil, false, err
}
@@ -445,13 +446,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{db.ColumnService, db.ColumnServiceName}), Value: key.ServiceName})
+ bson.E{Key: StringBuilder([]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{db.ColumnService, db.ColumnAlias}), Value: key.Alias})
+ bson.E{Key: StringBuilder([]string{model.ColumnService, model.ColumnAlias}), Value: key.Alias})
return serviceVersionFilter(ctx, versionRule, filter)
}
@@ -464,23 +465,23 @@ 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{db.ColumnService, db.ColumnVersion}), Value: bson.M{"$gte": start}})
+ filter = append(filter, bson.E{Key: StringBuilder([]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{db.ColumnService, db.ColumnVersion}), Value: bson.M{"$gte": start, "$lt": end}})
+ filter = append(filter, bson.E{Key: StringBuilder([]string{model.ColumnService, model.ColumnVersion}), Value: bson.M{"$gte": start, "$lt": end}})
return GetVersionService, filter
default:
- filter = append(filter, bson.E{Key: StringBuilder([]string{db.ColumnService, db.ColumnVersion}), Value: versionRule})
+ filter = append(filter, bson.E{Key: StringBuilder([]string{model.ColumnService, model.ColumnVersion}), Value: versionRule})
return nil, filter
}
}
func GetVersionServiceLatest(ctx context.Context, m bson.D) (serviceIds []string, err error) {
- findRes, err := client.GetMongoClient().Find(ctx, db.CollectionService, m,
+ findRes, err := client.GetMongoClient().Find(ctx, model.CollectionService, m,
&options.FindOptions{
- Sort: bson.M{StringBuilder([]string{db.ColumnService, db.ColumnVersion}): -1}})
+ Sort: bson.M{StringBuilder([]string{model.ColumnService, model.ColumnVersion}): -1}})
if err != nil {
return nil, err
}
@@ -488,7 +489,7 @@ func GetVersionServiceLatest(ctx context.Context, m bson.D) (serviceIds []string
return nil, findRes.Err()
}
for findRes.Next(ctx) {
- var service *db.Service
+ var service *model.Service
err = findRes.Decode(&service)
if err != nil {
return
@@ -502,8 +503,8 @@ 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, db.CollectionService, m, &options.FindOptions{
- Sort: bson.M{StringBuilder([]string{db.ColumnService, db.ColumnVersion}): -1}})
+ findRes, err := client.GetMongoClient().Find(ctx, model.CollectionService, m, &options.FindOptions{
+ Sort: bson.M{StringBuilder([]string{model.ColumnService, model.ColumnVersion}): -1}})
if err != nil {
return
}
@@ -511,7 +512,7 @@ func GetVersionService(ctx context.Context, m bson.D) (serviceIds []string, err
return nil, findRes.Err()
}
for findRes.Next(ctx) {
- var service *db.Service
+ var service *model.Service
err = findRes.Decode(&service)
if err != nil {
return
@@ -524,7 +525,7 @@ func GetVersionService(ctx context.Context, m bson.D) (serviceIds []string, err
func ParseVersionRule(ctx context.Context, versionRule string, key *pb.MicroServiceKey) ([]string, error) {
tenant := strings.Split(key.Tenant, "/")
if len(tenant) != 2 {
- return nil, ErrInvalidDomainProject
+ return nil, util.ErrInvalidDomainProject
}
if len(versionRule) == 0 {
return nil, nil
@@ -534,23 +535,23 @@ func ParseVersionRule(ctx context.Context, versionRule string, key *pb.MicroServ
switch {
case versionRule == "latest":
filter := bson.M{
- db.ColumnDomain: tenant[0],
- db.ColumnProject: tenant[1]}
+ model.ColumnDomain: tenant[0],
+ model.ColumnProject: tenant[1]}
return GetFilterVersionServiceLatest(ctx, filter)
case versionRule[len(versionRule)-1:] == "+":
start := versionRule[:len(versionRule)-1]
filter := bson.M{
- db.ColumnDomain: tenant[0],
- db.ColumnProject: tenant[1],
- StringBuilder([]string{db.ColumnService, db.ColumnVersion}): bson.M{"$gte": start}}
+ model.ColumnDomain: tenant[0],
+ model.ColumnProject: tenant[1],
+ StringBuilder([]string{model.ColumnService, model.ColumnVersion}): bson.M{"$gte": start}}
return GetFilterVersionService(ctx, filter)
case rangeIdx > 0:
start := versionRule[:rangeIdx]
end := versionRule[rangeIdx+1:]
filter := bson.M{
- db.ColumnDomain: tenant[0],
- db.ColumnProject: tenant[1],
- StringBuilder([]string{db.ColumnService, db.ColumnVersion}): bson.M{"$gte": start, "$lte": end}}
+ model.ColumnDomain: tenant[0],
+ model.ColumnProject: tenant[1],
+ StringBuilder([]string{model.ColumnService, model.ColumnVersion}): bson.M{"$gte": start, "$lte": end}}
return GetFilterVersionService(ctx, filter)
default:
return nil, nil
@@ -558,7 +559,7 @@ func ParseVersionRule(ctx context.Context, versionRule string, key *pb.MicroServ
}
func GetFilterVersionService(ctx context.Context, m bson.M) (serviceIDs []string, err error) {
- findRes, err := client.GetMongoClient().Find(ctx, db.CollectionService, m)
+ findRes, err := client.GetMongoClient().Find(ctx, model.CollectionService, m)
if err != nil {
return nil, err
}
@@ -566,7 +567,7 @@ func GetFilterVersionService(ctx context.Context, m bson.M) (serviceIDs []string
return nil, findRes.Err()
}
for findRes.Next(ctx) {
- var service db.Service
+ var service model.Service
err = findRes.Decode(&service)
if err != nil {
return nil, err
@@ -577,9 +578,9 @@ 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, db.CollectionService, m,
+ findRes, err := client.GetMongoClient().Find(ctx, model.CollectionService, m,
&options.FindOptions{
- Sort: bson.M{StringBuilder([]string{db.ColumnService, db.ColumnVersion}): -1}})
+ Sort: bson.M{StringBuilder([]string{model.ColumnService, model.ColumnVersion}): -1}})
if err != nil {
return nil, err
}
@@ -587,7 +588,7 @@ func GetFilterVersionServiceLatest(ctx context.Context, m bson.M) (serviceIDs []
return nil, findRes.Err()
}
for findRes.Next(ctx) {
- var service db.Service
+ var service model.Service
err = findRes.Decode(&service)
if err != nil {
return nil, err
@@ -640,30 +641,30 @@ func GenerateProviderDependencyRuleKey(domainProject string, in *pb.MicroService
func GenerateRuleKeyWithSameServiceNameAndAppID(serviceType string, domainProject string, in *pb.MicroServiceKey) bson.M {
return bson.M{
- db.ColumnServiceType: serviceType,
- StringBuilder([]string{db.ColumnServiceKey, db.ColumnTenant}): domainProject,
- StringBuilder([]string{db.ColumnServiceKey, db.ColumnAppID}): in.AppId,
- StringBuilder([]string{db.ColumnServiceKey, db.ColumnServiceName}): in.ServiceName}
+ 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}
}
func GenerateServiceDependencyRuleKey(serviceType string, domainProject string, in *pb.MicroServiceKey) bson.M {
if in == nil {
return bson.M{
- db.ColumnServiceType: serviceType,
- StringBuilder([]string{db.ColumnServiceKey, db.ColumnTenant}): domainProject}
+ model.ColumnServiceType: serviceType,
+ StringBuilder([]string{model.ColumnServiceKey, model.ColumnTenant}): domainProject}
}
if in.ServiceName == "*" {
return bson.M{
- db.ColumnServiceType: serviceType,
- StringBuilder([]string{db.ColumnServiceKey, db.ColumnTenant}): domainProject,
- StringBuilder([]string{db.ColumnServiceKey, db.ColumnEnv}): in.Environment,
- StringBuilder([]string{db.ColumnServiceKey, db.ColumnServiceName}): in.ServiceName}
+ 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{
- db.ColumnServiceType: serviceType,
- StringBuilder([]string{db.ColumnServiceKey, db.ColumnTenant}): domainProject,
- StringBuilder([]string{db.ColumnServiceKey, db.ColumnEnv}): in.Environment,
- StringBuilder([]string{db.ColumnServiceKey, db.ColumnAppID}): in.AppId,
- StringBuilder([]string{db.ColumnServiceKey, db.ColumnVersion}): in.Version,
- StringBuilder([]string{db.ColumnServiceKey, db.ColumnServiceName}): in.ServiceName}
+ 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}
}
diff --git a/datasource/mongo/engine.go b/datasource/mongo/engine.go
index e781927..96dfe2b 100644
--- a/datasource/mongo/engine.go
+++ b/datasource/mongo/engine.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/db"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/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"
"github.com/apache/servicecomb-service-center/pkg/log"
@@ -154,7 +155,7 @@ func (ds *DataSource) registryService(pCtx context.Context) error {
respG, err := datasource.Instance().GetService(ctx, core.GetServiceRequest(respE.ServiceId))
if respG.Response.GetCode() != pb.ResponseSuccess {
log.Error(fmt.Sprintf("query service center service[%s] info failed", respE.ServiceId), err)
- return ErrServiceFileLost
+ return mutil.ErrLostServiceFile
}
core.Service = respG.Service
return nil
@@ -239,7 +240,7 @@ func GetAllServicesAcrossDomainProject(ctx context.Context) (map[string][]*pb.Mi
filter := bson.M{"domain": domain, "project": project}
- findRes, err := client.GetMongoClient().Find(ctx, db.CollectionService, filter)
+ findRes, err := client.GetMongoClient().Find(ctx, model.CollectionService, filter)
if err != nil {
return nil, err
}
@@ -247,7 +248,7 @@ func GetAllServicesAcrossDomainProject(ctx context.Context) (map[string][]*pb.Mi
services := make(map[string][]*pb.MicroService)
for findRes.Next(ctx) {
- var mongoService db.Service
+ var mongoService model.Service
err := findRes.Decode(&mongoService)
if err != nil {
return nil, err
@@ -261,7 +262,7 @@ func GetAllServicesAcrossDomainProject(ctx context.Context) (map[string][]*pb.Mi
func ctxFromDomainProject(pCtx context.Context, domainProject string) (ctx context.Context, err error) {
splitIndex := strings.Index(domainProject, path.SPLIT)
if splitIndex == -1 {
- return nil, NewError("invalid domainProject: ", domainProject)
+ return nil, mutil.NewError("invalid domainProject: ", domainProject)
}
domain := domainProject[:splitIndex]
project := domainProject[splitIndex+1:]
@@ -283,7 +284,7 @@ func shouldClear(ctx context.Context, timeLimitStamp string, svc *pb.MicroServic
return false, err
}
if getInstsResp.Response.GetCode() != pb.ResponseSuccess {
- return false, NewError("get instance failed: ", getInstsResp.Response.GetMessage())
+ return false, mutil.NewError("get instance failed: ", getInstsResp.Response.GetMessage())
}
//ignore a service if it has instances
if len(getInstsResp.Instances) > 0 {
diff --git a/datasource/mongo/event/instance_event_handler.go b/datasource/mongo/event/instance_event_handler.go
index 7f4291b..a2804ab 100644
--- a/datasource/mongo/event/instance_event_handler.go
+++ b/datasource/mongo/event/instance_event_handler.go
@@ -28,7 +28,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/db"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/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"
@@ -44,19 +44,19 @@ type InstanceEventHandler struct {
}
func (h InstanceEventHandler) Type() string {
- return db.CollectionInstance
+ return model.CollectionInstance
}
func (h InstanceEventHandler) OnEvent(evt sd.MongoEvent) {
action := evt.Type
- instance := evt.Value.(db.Instance)
+ instance := evt.Value.(model.Instance)
providerID := instance.Instance.ServiceId
providerInstanceID := instance.Instance.InstanceId
domainProject := instance.Domain + "/" + instance.Project
cacheService := sd.Store().Service().Cache().Get(providerID)
var microService *discovery.MicroService
if cacheService != nil {
- microService = cacheService.(db.Service).Service
+ microService = cacheService.(model.Service).Service
}
if microService == nil {
log.Info("get cached service failed, then get from database")
@@ -101,7 +101,7 @@ func PublishInstanceEvent(evt sd.MongoEvent, domainProject string, serviceKey *d
Response: discovery.CreateResponse(discovery.ResponseSuccess, "Watch instance successfully."),
Action: string(evt.Type),
Key: serviceKey,
- Instance: evt.Value.(db.Instance).Instance,
+ Instance: evt.Value.(model.Instance).Instance,
}
for _, consumerID := range subscribers {
evt := notify.NewInstanceEventWithTime(consumerID, domainProject, -1, simple.FromTime(time.Now()), response)
@@ -113,10 +113,10 @@ func PublishInstanceEvent(evt sd.MongoEvent, domainProject string, serviceKey *d
}
func NotifySyncerInstanceEvent(event sd.MongoEvent, microService *discovery.MicroService) {
- instance := event.Value.(db.Instance).Instance
+ instance := event.Value.(model.Instance).Instance
log.Info(fmt.Sprintf("instanceId : %s and serviceId : %s in NotifySyncerInstanceEvent", instance.InstanceId, instance.ServiceId))
- instanceKey := util.StringJoin([]string{datasource.InstanceKeyPrefix, event.Value.(db.Instance).Domain,
- event.Value.(db.Instance).Project, instance.ServiceId, instance.InstanceId}, datasource.SPLIT)
+ instanceKey := util.StringJoin([]string{datasource.InstanceKeyPrefix, event.Value.(model.Instance).Domain,
+ event.Value.(model.Instance).Project, instance.ServiceId, instance.InstanceId}, datasource.SPLIT)
instanceKv := dump.KV{
Key: instanceKey,
@@ -127,8 +127,8 @@ func NotifySyncerInstanceEvent(event sd.MongoEvent, microService *discovery.Micr
KV: &instanceKv,
Value: instance,
}
- serviceKey := util.StringJoin([]string{datasource.ServiceKeyPrefix, event.Value.(db.Instance).Domain,
- event.Value.(db.Instance).Project, instance.ServiceId}, datasource.SPLIT)
+ serviceKey := util.StringJoin([]string{datasource.ServiceKeyPrefix, event.Value.(model.Instance).Domain,
+ event.Value.(model.Instance).Project, instance.ServiceId}, datasource.SPLIT)
serviceKv := dump.KV{
Key: serviceKey,
Value: microService,
diff --git a/datasource/mongo/event/instance_event_handler_test.go b/datasource/mongo/event/instance_event_handler_test.go
index 88063da..1813f01 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/db"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/model"
"github.com/apache/servicecomb-service-center/datasource/mongo/sd"
"github.com/apache/servicecomb-service-center/server/syncernotify"
@@ -90,7 +90,7 @@ func mongoAssign() sd.MongoEvent {
ServiceId: "2a20507274fc71c925d138341517dce14b600744",
Endpoints: endPoints,
}
- mongoInstance := db.Instance{}
+ mongoInstance := model.Instance{}
mongoInstance.Instance = &instance
mongoInstance.Domain = "default"
mongoInstance.Project = "default"
@@ -110,7 +110,7 @@ func mongoEventWronServiceId() sd.MongoEvent {
ServiceId: "2a20507274fc71c925d138341517dce14b6007443333",
Endpoints: endPoints,
}
- mongoInstance := db.Instance{}
+ mongoInstance := model.Instance{}
mongoInstance.Instance = &instance
mongoInstance.Domain = "default"
mongoInstance.Project = "default"
diff --git a/datasource/mongo/heartbeat/cache/heartbeat.go b/datasource/mongo/heartbeat/cache/heartbeat.go
index 0da74a9..506fd55 100644
--- a/datasource/mongo/heartbeat/cache/heartbeat.go
+++ b/datasource/mongo/heartbeat/cache/heartbeat.go
@@ -29,7 +29,7 @@ import (
"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/db"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/model"
"github.com/apache/servicecomb-service-center/pkg/gopool"
"github.com/apache/servicecomb-service-center/pkg/log"
"github.com/apache/servicecomb-service-center/server/config"
@@ -131,16 +131,16 @@ func cleanInstance(ctx context.Context, serviceID string, instanceID string) err
defer session.EndSession(ctx)
filter := bson.M{
- mongo.StringBuilder([]string{db.ColumnInstance, db.ColumnServiceID}): serviceID,
- mongo.StringBuilder([]string{db.ColumnInstance, db.ColumnInstanceID}): instanceID,
+ mongo.StringBuilder([]string{model.ColumnInstance, model.ColumnServiceID}): serviceID,
+ mongo.StringBuilder([]string{model.ColumnInstance, model.ColumnInstanceID}): instanceID,
}
- result, err := client.GetMongoClient().FindOne(ctx, db.CollectionInstance, filter)
+ result, err := client.GetMongoClient().FindOne(ctx, model.CollectionInstance, filter)
if err != nil {
log.Error("failed to query instance: %v", err)
return err
}
- var ins db.Instance
+ var ins model.Instance
err = result.Decode(&ins)
if err != nil {
log.Error("decode instance failed: %v", err)
@@ -168,10 +168,10 @@ 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{db.ColumnInstance, db.ColumnServiceID}): serviceID,
- mongo.StringBuilder([]string{db.ColumnInstance, db.ColumnInstanceID}): instanceID,
+ mongo.StringBuilder([]string{model.ColumnInstance, model.ColumnServiceID}): serviceID,
+ mongo.StringBuilder([]string{model.ColumnInstance, model.ColumnInstanceID}): instanceID,
}
- res, err := client.GetMongoClient().DeleteOne(ctx, db.CollectionInstance, filter)
+ res, err := client.GetMongoClient().DeleteOne(ctx, model.CollectionInstance, filter)
if err != nil {
log.Error("failed to clean instance", err)
return err
@@ -180,16 +180,16 @@ func removeDBInstance(ctx context.Context, serviceID string, instanceID string)
return nil
}
-func findInstance(ctx context.Context, serviceID string, instanceID string) (*db.Instance, error) {
+func findInstance(ctx context.Context, serviceID string, instanceID string) (*model.Instance, error) {
filter := bson.M{
- mongo.StringBuilder([]string{db.ColumnInstance, db.ColumnServiceID}): serviceID,
- mongo.StringBuilder([]string{db.ColumnInstance, db.ColumnInstanceID}): instanceID,
+ mongo.StringBuilder([]string{model.ColumnInstance, model.ColumnServiceID}): serviceID,
+ mongo.StringBuilder([]string{model.ColumnInstance, model.ColumnInstanceID}): instanceID,
}
- result, err := client.GetMongoClient().FindOne(ctx, db.CollectionInstance, filter)
+ result, err := client.GetMongoClient().FindOne(ctx, model.CollectionInstance, filter)
if err != nil {
return nil, err
}
- var ins db.Instance
+ var ins model.Instance
err = result.Decode(&ins)
if err != nil {
log.Error("decode instance failed: ", err)
@@ -200,13 +200,13 @@ func findInstance(ctx context.Context, serviceID string, instanceID string) (*db
func updateInstance(ctx context.Context, serviceID string, instanceID string) error {
filter := bson.M{
- mongo.StringBuilder([]string{db.ColumnInstance, db.ColumnServiceID}): serviceID,
- mongo.StringBuilder([]string{db.ColumnInstance, db.ColumnInstanceID}): instanceID,
+ mongo.StringBuilder([]string{model.ColumnInstance, model.ColumnServiceID}): serviceID,
+ mongo.StringBuilder([]string{model.ColumnInstance, model.ColumnInstanceID}): instanceID,
}
update := bson.M{
- "$set": bson.M{db.ColumnRefreshTime: time.Now()},
+ "$set": bson.M{model.ColumnRefreshTime: time.Now()},
}
- result, err := client.GetMongoClient().FindOneAndUpdate(ctx, db.CollectionInstance, filter, update)
+ result, err := client.GetMongoClient().FindOneAndUpdate(ctx, model.CollectionInstance, filter, update)
if err != nil {
log.Error("failed to update refresh time of instance: ", err)
return err
diff --git a/datasource/mongo/heartbeat/cache/heartbeat_test.go b/datasource/mongo/heartbeat/cache/heartbeat_test.go
index 49bb7ca..91c503b 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/db"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/model"
)
func init() {
@@ -44,7 +44,7 @@ func init() {
func TestAddCacheInstance(t *testing.T) {
t.Run("add cache instance: set the ttl to 2 seconds", func(t *testing.T) {
- instance1 := db.Instance{
+ instance1 := model.Instance{
RefreshTime: time.Now(),
Instance: &pb.MicroServiceInstance{
InstanceId: "instanceID1",
@@ -57,7 +57,7 @@ func TestAddCacheInstance(t *testing.T) {
}
err := addHeartbeatTask(instance1.Instance.ServiceId, instance1.Instance.InstanceId, instance1.Instance.HealthCheck.Interval*(instance1.Instance.HealthCheck.Times+1))
assert.Equal(t, nil, err)
- _, err = client.GetMongoClient().Insert(context.Background(), db.CollectionInstance, instance1)
+ _, err = client.GetMongoClient().Insert(context.Background(), model.CollectionInstance, instance1)
assert.Equal(t, nil, err)
info, ok := instanceHeartbeatStore.Get(instance1.Instance.InstanceId)
assert.Equal(t, true, ok)
@@ -69,12 +69,12 @@ func TestAddCacheInstance(t *testing.T) {
time.Sleep(2 * time.Second)
_, ok = instanceHeartbeatStore.Get(instance1.Instance.InstanceId)
assert.Equal(t, false, ok)
- _, err = client.GetMongoClient().Delete(context.Background(), db.CollectionInstance, instance1)
+ _, err = client.GetMongoClient().Delete(context.Background(), model.CollectionInstance, instance1)
assert.Equal(t, nil, err)
})
t.Run("add cache instance: do not set interval time", func(t *testing.T) {
- instance1 := db.Instance{
+ instance1 := model.Instance{
RefreshTime: time.Now(),
Instance: &pb.MicroServiceInstance{
InstanceId: "instanceID1",
@@ -87,7 +87,7 @@ func TestAddCacheInstance(t *testing.T) {
}
err := addHeartbeatTask(instance1.Instance.ServiceId, instance1.Instance.InstanceId, instance1.Instance.HealthCheck.Interval*(instance1.Instance.HealthCheck.Times+1))
assert.Equal(t, nil, err)
- _, err = client.GetMongoClient().Insert(context.Background(), db.CollectionInstance, instance1)
+ _, err = client.GetMongoClient().Insert(context.Background(), model.CollectionInstance, instance1)
assert.Equal(t, nil, err)
info, ok := instanceHeartbeatStore.Get(instance1.Instance.InstanceId)
assert.Equal(t, true, ok)
@@ -99,14 +99,14 @@ func TestAddCacheInstance(t *testing.T) {
time.Sleep(defaultTTL * time.Second)
_, ok = instanceHeartbeatStore.Get(instance1.Instance.InstanceId)
assert.Equal(t, false, ok)
- _, err = client.GetMongoClient().Delete(context.Background(), db.CollectionInstance, instance1)
+ _, err = client.GetMongoClient().Delete(context.Background(), model.CollectionInstance, instance1)
assert.Equal(t, nil, err)
})
}
func TestRemoveCacheInstance(t *testing.T) {
t.Run("remove cache instance: the instance has cache and can be deleted successfully", func(t *testing.T) {
- instance1 := db.Instance{
+ instance1 := model.Instance{
RefreshTime: time.Now(),
Instance: &pb.MicroServiceInstance{
InstanceId: "instanceID1",
@@ -119,7 +119,7 @@ func TestRemoveCacheInstance(t *testing.T) {
}
err := addHeartbeatTask(instance1.Instance.ServiceId, instance1.Instance.InstanceId, instance1.Instance.HealthCheck.Interval*(instance1.Instance.HealthCheck.Times+1))
assert.Equal(t, nil, err)
- _, err = client.GetMongoClient().Insert(context.Background(), db.CollectionInstance, instance1)
+ _, err = client.GetMongoClient().Insert(context.Background(), model.CollectionInstance, instance1)
assert.Equal(t, nil, err)
info, ok := instanceHeartbeatStore.Get(instance1.Instance.InstanceId)
assert.Equal(t, true, ok)
@@ -132,7 +132,7 @@ func TestRemoveCacheInstance(t *testing.T) {
RemoveCacheInstance(instance1.Instance.InstanceId)
_, ok = instanceHeartbeatStore.Get(instance1.Instance.InstanceId)
assert.Equal(t, false, ok)
- _, err = client.GetMongoClient().Delete(context.Background(), db.CollectionInstance, instance1)
+ _, err = client.GetMongoClient().Delete(context.Background(), model.CollectionInstance, instance1)
assert.Equal(t, nil, err)
})
}
diff --git a/datasource/mongo/heartbeat/cache/heartbeatcache_test.go b/datasource/mongo/heartbeat/cache/heartbeatcache_test.go
index 2d4ad86..835dd2f 100644
--- a/datasource/mongo/heartbeat/cache/heartbeatcache_test.go
+++ b/datasource/mongo/heartbeat/cache/heartbeatcache_test.go
@@ -28,7 +28,7 @@ import (
"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/db"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/model"
)
func TestHeartBeatCheck(t *testing.T) {
@@ -56,7 +56,7 @@ func TestHeartBeatCheck(t *testing.T) {
t.Run("heartbeat check: data exists in the cache and db,it can be update successfully", func(t *testing.T) {
heartBeatCheck := &HeartBeatCheck{}
- instanceDB := db.Instance{
+ instanceDB := model.Instance{
RefreshTime: time.Now(),
Instance: &pb.MicroServiceInstance{
InstanceId: "instanceIdDB",
@@ -68,10 +68,10 @@ func TestHeartBeatCheck(t *testing.T) {
},
}
filter := bson.M{
- mongo.StringBuilder([]string{db.ColumnInstance, db.ColumnInstanceID}): instanceDB.Instance.InstanceId,
+ mongo.StringBuilder([]string{model.ColumnInstance, model.ColumnInstanceID}): instanceDB.Instance.InstanceId,
}
- _, _ = client.GetMongoClient().Delete(context.Background(), db.CollectionInstance, filter)
- _, err := client.GetMongoClient().Insert(context.Background(), db.CollectionInstance, instanceDB)
+ _, _ = client.GetMongoClient().Delete(context.Background(), model.CollectionInstance, filter)
+ _, err := client.GetMongoClient().Insert(context.Background(), model.CollectionInstance, instanceDB)
assert.Equal(t, nil, err)
err = addHeartbeatTask(instanceDB.Instance.ServiceId, instanceDB.Instance.InstanceId, instanceDB.Instance.HealthCheck.Interval*(instanceDB.Instance.HealthCheck.Times+1))
assert.Equal(t, nil, err)
@@ -81,7 +81,7 @@ func TestHeartBeatCheck(t *testing.T) {
})
assert.Nil(t, err)
assert.Equal(t, pb.ResponseSuccess, resp.Response.GetCode())
- _, err = client.GetMongoClient().Delete(context.Background(), db.CollectionInstance, filter)
+ _, err = client.GetMongoClient().Delete(context.Background(), model.CollectionInstance, filter)
assert.Nil(t, err)
})
}
diff --git a/datasource/mongo/heartbeat/checker/heartbeat.go b/datasource/mongo/heartbeat/checker/heartbeat.go
index 80a64af..a5fb039 100644
--- a/datasource/mongo/heartbeat/checker/heartbeat.go
+++ b/datasource/mongo/heartbeat/checker/heartbeat.go
@@ -25,19 +25,19 @@ import (
"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/db"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/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{db.ColumnInstance, db.ColumnServiceID}): serviceID,
- mongo.StringBuilder([]string{db.ColumnInstance, db.ColumnInstanceID}): instanceID,
+ mongo.StringBuilder([]string{model.ColumnInstance, model.ColumnServiceID}): serviceID,
+ mongo.StringBuilder([]string{model.ColumnInstance, model.ColumnInstanceID}): instanceID,
}
update := bson.M{
- "$set": bson.M{db.ColumnRefreshTime: time.Now()},
+ "$set": bson.M{model.ColumnRefreshTime: time.Now()},
}
- result, err := client.GetMongoClient().FindOneAndUpdate(ctx, db.CollectionInstance, filter, update)
+ result, err := client.GetMongoClient().FindOneAndUpdate(ctx, model.CollectionInstance, filter, update)
if err != nil {
log.Error("failed to update refresh time of instance: ", err)
return err
diff --git a/datasource/mongo/heartbeat/checker/heartbeat_test.go b/datasource/mongo/heartbeat/checker/heartbeat_test.go
index 8ac65c0..c97ab27 100644
--- a/datasource/mongo/heartbeat/checker/heartbeat_test.go
+++ b/datasource/mongo/heartbeat/checker/heartbeat_test.go
@@ -32,7 +32,7 @@ import (
"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/db"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/model"
"github.com/apache/servicecomb-service-center/pkg/log"
)
@@ -51,32 +51,32 @@ func TestUpdateInstanceRefreshTime(t *testing.T) {
})
t.Run("update instance refresh time: if the instance does exist,the update should succeed", func(t *testing.T) {
- instance1 := db.Instance{
+ instance1 := model.Instance{
RefreshTime: time.Now(),
Instance: &pb.MicroServiceInstance{
InstanceId: "instanceId1",
ServiceId: "serviceId1",
},
}
- _, err := client.GetMongoClient().Insert(context.Background(), db.CollectionInstance, instance1)
+ _, err := client.GetMongoClient().Insert(context.Background(), model.CollectionInstance, instance1)
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{db.ColumnInstance, db.ColumnServiceID}): instance1.Instance.ServiceId,
- mongo.StringBuilder([]string{db.ColumnInstance, db.ColumnInstanceID}): instance1.Instance.InstanceId,
+ mongo.StringBuilder([]string{model.ColumnInstance, model.ColumnServiceID}): instance1.Instance.ServiceId,
+ mongo.StringBuilder([]string{model.ColumnInstance, model.ColumnInstanceID}): instance1.Instance.InstanceId,
}
- result, err := client.GetMongoClient().FindOne(context.Background(), db.CollectionInstance, filter)
+ result, err := client.GetMongoClient().FindOne(context.Background(), model.CollectionInstance, filter)
assert.Nil(t, err)
- var ins db.Instance
+ 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{db.ColumnInstance, db.ColumnServiceID}): instance1.Instance.ServiceId,
- mongo.StringBuilder([]string{db.ColumnInstance, db.ColumnInstanceID}): instance1.Instance.InstanceId,
+ mongo.StringBuilder([]string{model.ColumnInstance, model.ColumnServiceID}): instance1.Instance.ServiceId,
+ mongo.StringBuilder([]string{model.ColumnInstance, model.ColumnInstanceID}): instance1.Instance.InstanceId,
}
- _, err = client.GetMongoClient().Delete(context.Background(), db.CollectionInstance, filter)
+ _, 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 6efbb9d..6724a48 100644
--- a/datasource/mongo/heartbeat/checker/heartbeatchecker_test.go
+++ b/datasource/mongo/heartbeat/checker/heartbeatchecker_test.go
@@ -28,7 +28,7 @@ import (
"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/db"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/model"
)
func TestHeartbeat(t *testing.T) {
@@ -43,14 +43,14 @@ func TestHeartbeat(t *testing.T) {
})
t.Run("heartbeat: if the instance does exist,the heartbeat should succeed", func(t *testing.T) {
- instance1 := db.Instance{
+ instance1 := model.Instance{
RefreshTime: time.Now(),
Instance: &pb.MicroServiceInstance{
InstanceId: "instanceId1",
ServiceId: "serviceId1",
},
}
- _, err := client.GetMongoClient().Insert(context.Background(), db.CollectionInstance, instance1)
+ _, err := client.GetMongoClient().Insert(context.Background(), model.CollectionInstance, instance1)
assert.Equal(t, nil, err)
heartBeatChecker := &HeartBeatChecker{}
resp, err := heartBeatChecker.Heartbeat(context.Background(), &pb.HeartbeatRequest{
@@ -60,9 +60,9 @@ func TestHeartbeat(t *testing.T) {
assert.Nil(t, err)
assert.Equal(t, pb.ResponseSuccess, resp.Response.GetCode())
filter := bson.M{
- mongo.StringBuilder([]string{db.ColumnInstance, db.ColumnInstanceID}): instance1.Instance.InstanceId,
+ mongo.StringBuilder([]string{model.ColumnInstance, model.ColumnInstanceID}): instance1.Instance.InstanceId,
}
- _, err = client.GetMongoClient().Delete(context.Background(), db.CollectionInstance, filter)
+ _, err = client.GetMongoClient().Delete(context.Background(), model.CollectionInstance, filter)
assert.Nil(t, err)
})
}
diff --git a/datasource/mongo/db/types.go b/datasource/mongo/model/types.go
similarity index 99%
rename from datasource/mongo/db/types.go
rename to datasource/mongo/model/types.go
index 905606b..fc9d9a4 100644
--- a/datasource/mongo/db/types.go
+++ b/datasource/mongo/model/types.go
@@ -15,7 +15,7 @@
* limitations under the License.
*/
-package db
+package model
import (
"time"
diff --git a/datasource/mongo/mongo.go b/datasource/mongo/mongo.go
index 39c8372..f7e813f 100644
--- a/datasource/mongo/mongo.go
+++ b/datasource/mongo/mongo.go
@@ -26,9 +26,10 @@ 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/db"
"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"
"github.com/apache/servicecomb-service-center/server/config"
)
@@ -115,90 +116,90 @@ func EnsureDB() {
}
func EnsureService() {
- err := client.GetMongoClient().GetDB().CreateCollection(context.Background(), db.CollectionService, options.CreateCollection().SetValidator(nil))
+ err := client.GetMongoClient().GetDB().CreateCollection(context.Background(), model.CollectionService, options.CreateCollection().SetValidator(nil))
wrapCreateCollectionError(err)
- serviceIDIndex := BuildIndexDoc(
- StringBuilder([]string{db.ColumnService, db.ColumnServiceID}))
+ serviceIDIndex := mutil.BuildIndexDoc(
+ StringBuilder([]string{model.ColumnService, model.ColumnServiceID}))
serviceIDIndex.Options = options.Index().SetUnique(true)
- serviceIndex := BuildIndexDoc(
- StringBuilder([]string{db.ColumnService, db.ColumnAppID}),
- StringBuilder([]string{db.ColumnService, db.ColumnServiceName}),
- StringBuilder([]string{db.ColumnService, db.ColumnEnv}),
- StringBuilder([]string{db.ColumnService, db.ColumnVersion}),
- db.ColumnDomain,
- db.ColumnProject)
+ 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}),
+ model.ColumnDomain,
+ model.ColumnProject)
serviceIndex.Options = options.Index().SetUnique(true)
var serviceIndexs []mongo.IndexModel
serviceIndexs = append(serviceIndexs, serviceIDIndex, serviceIndex)
- err = client.GetMongoClient().CreateIndexes(context.Background(), db.CollectionService, serviceIndexs)
+ err = client.GetMongoClient().CreateIndexes(context.Background(), model.CollectionService, serviceIndexs)
wrapCreateIndexesError(err)
}
func EnsureInstance() {
- err := client.GetMongoClient().GetDB().CreateCollection(context.Background(), db.CollectionInstance, options.CreateCollection().SetValidator(nil))
+ err := client.GetMongoClient().GetDB().CreateCollection(context.Background(), model.CollectionInstance, options.CreateCollection().SetValidator(nil))
wrapCreateCollectionError(err)
- instanceIndex := BuildIndexDoc(db.ColumnRefreshTime)
+ instanceIndex := mutil.BuildIndexDoc(model.ColumnRefreshTime)
instanceIndex.Options = options.Index().SetExpireAfterSeconds(defaultExpireTime)
- instanceServiceIndex := BuildIndexDoc(StringBuilder([]string{db.ColumnInstance, db.ColumnServiceID}))
+ instanceServiceIndex := mutil.BuildIndexDoc(StringBuilder([]string{model.ColumnInstance, model.ColumnServiceID}))
var instanceIndexs []mongo.IndexModel
instanceIndexs = append(instanceIndexs, instanceIndex, instanceServiceIndex)
- err = client.GetMongoClient().CreateIndexes(context.Background(), db.CollectionInstance, instanceIndexs)
+ err = client.GetMongoClient().CreateIndexes(context.Background(), model.CollectionInstance, instanceIndexs)
wrapCreateIndexesError(err)
}
func EnsureSchema() {
- err := client.GetMongoClient().GetDB().CreateCollection(context.Background(), db.CollectionSchema, options.CreateCollection().SetValidator(nil))
+ err := client.GetMongoClient().GetDB().CreateCollection(context.Background(), model.CollectionSchema, options.CreateCollection().SetValidator(nil))
wrapCreateCollectionError(err)
- schemaServiceIndex := BuildIndexDoc(
- db.ColumnDomain,
- db.ColumnProject,
- db.ColumnServiceID)
+ schemaServiceIndex := mutil.BuildIndexDoc(
+ model.ColumnDomain,
+ model.ColumnProject,
+ model.ColumnServiceID)
var schemaIndexs []mongo.IndexModel
schemaIndexs = append(schemaIndexs, schemaServiceIndex)
- err = client.GetMongoClient().CreateIndexes(context.Background(), db.CollectionSchema, schemaIndexs)
+ err = client.GetMongoClient().CreateIndexes(context.Background(), model.CollectionSchema, schemaIndexs)
wrapCreateIndexesError(err)
}
func EnsureRule() {
- err := client.GetMongoClient().GetDB().CreateCollection(context.Background(), db.CollectionRule, options.CreateCollection().SetValidator(nil))
+ err := client.GetMongoClient().GetDB().CreateCollection(context.Background(), model.CollectionRule, options.CreateCollection().SetValidator(nil))
wrapCreateCollectionError(err)
- ruleServiceIndex := BuildIndexDoc(
- db.ColumnDomain,
- db.ColumnProject,
- db.ColumnServiceID)
+ ruleServiceIndex := mutil.BuildIndexDoc(
+ model.ColumnDomain,
+ model.ColumnProject,
+ model.ColumnServiceID)
var ruleIndexs []mongo.IndexModel
ruleIndexs = append(ruleIndexs, ruleServiceIndex)
- err = client.GetMongoClient().CreateIndexes(context.Background(), db.CollectionRule, ruleIndexs)
+ err = client.GetMongoClient().CreateIndexes(context.Background(), model.CollectionRule, ruleIndexs)
wrapCreateIndexesError(err)
}
func EnsureDep() {
- err := client.GetMongoClient().GetDB().CreateCollection(context.Background(), db.CollectionDep, options.CreateCollection().SetValidator(nil))
+ err := client.GetMongoClient().GetDB().CreateCollection(context.Background(), model.CollectionDep, options.CreateCollection().SetValidator(nil))
wrapCreateCollectionError(err)
- depServiceIndex := BuildIndexDoc(
- db.ColumnDomain,
- db.ColumnProject,
- db.ColumnServiceKey)
+ depServiceIndex := mutil.BuildIndexDoc(
+ model.ColumnDomain,
+ model.ColumnProject,
+ model.ColumnServiceKey)
var depIndexs []mongo.IndexModel
depIndexs = append(depIndexs, depServiceIndex)
- err = client.GetMongoClient().CreateIndexes(context.Background(), db.CollectionDep, depIndexs)
+ err = client.GetMongoClient().CreateIndexes(context.Background(), model.CollectionDep, depIndexs)
if err != nil {
log.Fatal("failed to create dep collection indexs", err)
return
diff --git a/datasource/mongo/ms.go b/datasource/mongo/ms.go
index f63dcac..386b56f 100644
--- a/datasource/mongo/ms.go
+++ b/datasource/mongo/ms.go
@@ -37,9 +37,10 @@ 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/db"
"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"
"github.com/apache/servicecomb-service-center/pkg/log"
"github.com/apache/servicecomb-service-center/pkg/util"
@@ -94,7 +95,7 @@ func (ds *DataSource) RegisterService(ctx context.Context, request *discovery.Cr
}, nil
}
}
- insertRes, err := client.GetMongoClient().Insert(ctx, db.CollectionService, &db.Service{Domain: domain, Project: project, Service: service})
+ insertRes, err := client.GetMongoClient().Insert(ctx, model.CollectionService, &model.Service{Domain: domain, Project: project, Service: service})
if err != nil {
if client.IsDuplicateKey(err) {
serviceIDInner, err := GetServiceID(ctx, &discovery.MicroServiceKey{
@@ -141,7 +142,7 @@ func (ds *DataSource) GetServices(ctx context.Context, request *discovery.GetSer
domain := util.ParseDomain(ctx)
project := util.ParseProject(ctx)
- filter := bson.M{db.ColumnDomain: domain, db.ColumnProject: project}
+ filter := bson.M{model.ColumnDomain: domain, model.ColumnProject: project}
services, err := GetServices(ctx, filter)
if err != nil {
@@ -161,9 +162,9 @@ func (ds *DataSource) GetApplications(ctx context.Context, request *discovery.Ge
project := util.ParseProject(ctx)
filter := bson.M{
- db.ColumnDomain: domain,
- db.ColumnProject: project,
- StringBuilder([]string{db.ColumnService, db.ColumnEnv}): request.Environment}
+ model.ColumnDomain: domain,
+ model.ColumnProject: project,
+ StringBuilder([]string{model.ColumnService, model.ColumnEnv}): request.Environment}
services, err := GetServices(ctx, filter)
if err != nil {
@@ -288,8 +289,8 @@ func (ds *DataSource) DelServicePri(ctx context.Context, serviceID string, force
}
if serviceID == apt.Service.ServiceId {
- log.Error(fmt.Sprintf("%s micro-service %s failed, operator: %s", title, serviceID, remoteIP), ErrNotAllowDeleteSC)
- return discovery.CreateResponse(discovery.ErrInvalidParams, ErrNotAllowDeleteSC.Error()), nil
+ 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))
if err != nil {
@@ -317,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, db.CollectionInstance, bson.M{StringBuilder([]string{db.ColumnInstance, db.ColumnServiceID}): serviceID})
+ instancesExist, err := client.GetMongoClient().DocExist(ctx, model.CollectionInstance, bson.M{StringBuilder([]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)
@@ -331,10 +332,10 @@ func (ds *DataSource) DelServicePri(ctx context.Context, serviceID string, force
}
- schemaOps := client.MongoOperation{Table: db.CollectionSchema, Models: []mongo.WriteModel{mongo.NewDeleteManyModel().SetFilter(bson.M{db.ColumnServiceID: serviceID})}}
- rulesOps := client.MongoOperation{Table: db.CollectionRule, Models: []mongo.WriteModel{mongo.NewDeleteManyModel().SetFilter(bson.M{db.ColumnServiceID: serviceID})}}
- instanceOps := client.MongoOperation{Table: db.CollectionInstance, Models: []mongo.WriteModel{mongo.NewDeleteManyModel().SetFilter(bson.M{StringBuilder([]string{db.ColumnInstance, db.ColumnServiceID}): serviceID})}}
- serviceOps := client.MongoOperation{Table: db.CollectionService, Models: []mongo.WriteModel{mongo.NewDeleteOneModel().SetFilter(bson.M{StringBuilder([]string{db.ColumnService, db.ColumnServiceID}): serviceID})}}
+ 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})}}
err = client.GetMongoClient().MultiTableBatchUpdate(ctx, []client.MongoOperation{schemaOps, rulesOps, instanceOps, serviceOps})
if err != nil {
@@ -365,8 +366,8 @@ func (ds *DataSource) UpdateService(ctx context.Context, request *discovery.Upda
*discovery.UpdateServicePropsResponse, error) {
updateData := bson.M{
"$set": bson.M{
- StringBuilder([]string{db.ColumnService, db.ColumnModTime}): strconv.FormatInt(time.Now().Unix(), 10),
- StringBuilder([]string{db.ColumnService, db.ColumnProperty}): request.Properties}}
+ 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)
if err != nil {
log.Error(fmt.Sprintf("update service %s properties failed, update mongo failed", request.ServiceId), err)
@@ -511,7 +512,7 @@ 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{db.ColumnTag: request.Tags}})
+ err := UpdateService(ctx, GeneratorServiceFilter(ctx, request.ServiceId), bson.M{"$set": bson.M{model.ColumnTag: request.Tags}})
if err == nil {
return &discovery.AddServiceTagsResponse{
Response: discovery.CreateResponse(discovery.ResponseSuccess, "Add service tags successfully."),
@@ -576,7 +577,7 @@ func (ds *DataSource) UpdateTag(ctx context.Context, request *discovery.UpdateSe
}
newTags[request.Key] = request.Value
- err = UpdateService(ctx, GeneratorServiceFilter(ctx, request.ServiceId), bson.M{"$set": bson.M{db.ColumnTag: newTags}})
+ err = UpdateService(ctx, GeneratorServiceFilter(ctx, request.ServiceId), bson.M{"$set": bson.M{model.ColumnTag: newTags}})
if err != nil {
log.Error(fmt.Sprintf("update service %s tags failed", request.ServiceId), err)
return &discovery.UpdateServiceTagResponse{
@@ -617,7 +618,7 @@ 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{db.ColumnTag: newTags}})
+ err = UpdateService(ctx, GeneratorServiceFilter(ctx, request.ServiceId), bson.M{"$set": bson.M{model.ColumnTag: newTags}})
if err != nil {
log.Error(fmt.Sprintf("delete service %s tags failed", request.ServiceId), err)
return &discovery.DeleteServiceTagsResponse{
@@ -750,7 +751,7 @@ func (ds *DataSource) DeleteSchema(ctx context.Context, request *discovery.Delet
}, nil
}
filter := GeneratorSchemaFilter(ctx, request.ServiceId, request.SchemaId)
- res, err := client.GetMongoClient().DocDelete(ctx, db.CollectionSchema, filter)
+ res, err := client.GetMongoClient().DocDelete(ctx, model.CollectionSchema, filter)
if err != nil {
return &discovery.DeleteSchemaResponse{
Response: discovery.CreateResponse(discovery.ErrUnavailableBackend, "DeleteSchema failed for delete schema failed."),
@@ -822,7 +823,7 @@ func (ds *DataSource) modifySchemas(ctx context.Context, service *discovery.Micr
remoteIP := util.GetIPFromContext(ctx)
serviceID := service.ServiceId
- schemasFromDatabase, err := GetSchemas(ctx, bson.M{db.ColumnServiceID: serviceID})
+ schemasFromDatabase, err := GetSchemas(ctx, bson.M{model.ColumnServiceID: serviceID})
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())
@@ -841,7 +842,7 @@ 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{db.ColumnService, db.ColumnSchemas}): nonExistSchemaIds}}).SetFilter(GeneratorServiceFilter(ctx, serviceID)))
+ serviceOps = append(serviceOps, mongo.NewUpdateOneModel().SetUpdate(bson.M{"$set": bson.M{StringBuilder([]string{model.ColumnService, model.ColumnSchemas}): nonExistSchemaIds}}).SetFilter(GeneratorServiceFilter(ctx, serviceID)))
} else {
if len(nonExistSchemaIds) != 0 {
errInfo := fmt.Errorf("non-existent schemaIDs %v", nonExistSchemaIds)
@@ -854,7 +855,7 @@ func (ds *DataSource) modifySchemas(ctx context.Context, service *discovery.Micr
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{db.ColumnSchema: needUpdateSchema.Schema, db.ColumnSchemaSummary: needUpdateSchema.Summary}}))
+ 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}}))
} else {
log.Warn(fmt.Sprintf("schema[%s/%s] and it's summary already exist, skip to update, operator: %s",
serviceID, needUpdateSchema.SchemaId, remoteIP))
@@ -864,7 +865,7 @@ func (ds *DataSource) modifySchemas(ctx context.Context, service *discovery.Micr
for _, schema := range needAddSchemas {
log.Info(fmt.Sprintf("add new schema[%s/%s], operator: %s", serviceID, schema.SchemaId, remoteIP))
- schemasOps = append(schemasOps, mongo.NewInsertOneModel().SetDocument(&db.Schema{
+ schemasOps = append(schemasOps, mongo.NewInsertOneModel().SetDocument(&model.Schema{
Domain: domain,
Project: project,
ServiceID: serviceID,
@@ -886,7 +887,7 @@ func (ds *DataSource) modifySchemas(ctx context.Context, service *discovery.Micr
var schemaIDs []string
for _, schema := range needAddSchemas {
log.Info(fmt.Sprintf("add new schema[%s/%s], operator: %s", serviceID, schema.SchemaId, remoteIP))
- schemasOps = append(schemasOps, mongo.NewInsertOneModel().SetDocument(&db.Schema{
+ schemasOps = append(schemasOps, mongo.NewInsertOneModel().SetDocument(&model.Schema{
Domain: domain,
Project: project,
ServiceID: serviceID,
@@ -899,7 +900,7 @@ 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{db.ColumnSchema: schema.Schema, db.ColumnSchemaSummary: schema.Summary}}))
+ 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}}))
schemaIDs = append(schemaIDs, schema.SchemaId)
}
@@ -908,16 +909,16 @@ func (ds *DataSource) modifySchemas(ctx context.Context, service *discovery.Micr
schemasOps = append(schemasOps, mongo.NewDeleteOneModel().SetFilter(GeneratorSchemaFilter(ctx, serviceID, schema.SchemaId)))
}
- serviceOps = append(serviceOps, mongo.NewUpdateOneModel().SetUpdate(bson.M{"$set": bson.M{StringBuilder([]string{db.ColumnService, db.ColumnSchemas}): schemaIDs}}).SetFilter(GeneratorServiceFilter(ctx, serviceID)))
+ serviceOps = append(serviceOps, mongo.NewUpdateOneModel().SetUpdate(bson.M{"$set": bson.M{StringBuilder([]string{model.ColumnService, model.ColumnSchemas}): schemaIDs}}).SetFilter(GeneratorServiceFilter(ctx, serviceID)))
}
if len(schemasOps) > 0 {
- _, err = client.GetMongoClient().BatchUpdate(ctx, db.CollectionSchema, schemasOps)
+ _, err = client.GetMongoClient().BatchUpdate(ctx, model.CollectionSchema, schemasOps)
if err != nil {
return discovery.NewError(discovery.ErrInternal, err.Error())
}
}
if len(serviceOps) > 0 {
- _, err = client.GetMongoClient().BatchUpdate(ctx, db.CollectionService, serviceOps)
+ _, err = client.GetMongoClient().BatchUpdate(ctx, model.CollectionService, serviceOps)
if err != nil {
return discovery.NewError(discovery.ErrInternal, err.Error())
}
@@ -980,13 +981,13 @@ func (ds *DataSource) modifySchema(ctx context.Context, serviceID string, schema
}
}
if len(newSchemas) != 0 {
- updateData := bson.M{StringBuilder([]string{db.ColumnService, db.ColumnSchemas}): newSchemas}
+ updateData := bson.M{StringBuilder([]string{model.ColumnService, model.ColumnSchemas}): newSchemas}
err = UpdateService(ctx, GeneratorServiceFilter(ctx, serviceID), bson.M{"$set": updateData})
if err != nil {
return discovery.NewError(discovery.ErrInternal, err.Error())
}
}
- newSchema := bson.M{"$set": bson.M{db.ColumnSchema: schema.Schema, db.ColumnSchemaSummary: schema.Summary}}
+ 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))
if err != nil {
return discovery.NewError(discovery.ErrInternal, err.Error())
@@ -1048,7 +1049,7 @@ func (ds *DataSource) AddRule(ctx context.Context, request *discovery.AddService
continue
}
timestamp := strconv.FormatInt(time.Now().Unix(), 10)
- ruleAdd := &db.Rule{
+ ruleAdd := &model.Rule{
Domain: util.ParseDomain(ctx),
Project: util.ParseProject(ctx),
ServiceID: request.ServiceId,
@@ -1063,7 +1064,7 @@ func (ds *DataSource) AddRule(ctx context.Context, request *discovery.AddService
},
}
ruleIDs = append(ruleIDs, ruleAdd.Rule.RuleId)
- _, err = client.GetMongoClient().Insert(ctx, db.CollectionRule, ruleAdd)
+ _, err = client.GetMongoClient().Insert(ctx, model.CollectionRule, ruleAdd)
if err != nil {
return &discovery.AddServiceRulesResponse{
Response: discovery.CreateResponse(discovery.ErrInternal, err.Error()),
@@ -1129,7 +1130,7 @@ func (ds *DataSource) DeleteRule(ctx context.Context, request *discovery.DeleteS
delRules = append(delRules, mongo.NewDeleteOneModel().SetFilter(GeneratorRuleFilter(ctx, request.ServiceId, ruleID)))
}
if len(delRules) > 0 {
- _, err := client.GetMongoClient().BatchDelete(ctx, db.CollectionRule, delRules)
+ _, err := client.GetMongoClient().BatchDelete(ctx, model.CollectionRule, delRules)
if err != nil {
return &discovery.DeleteServiceRulesResponse{
Response: discovery.CreateResponse(discovery.ErrInternal, err.Error()),
@@ -1177,11 +1178,11 @@ func (ds *DataSource) UpdateRule(ctx context.Context, request *discovery.UpdateS
}
newRule := bson.M{
- StringBuilder([]string{db.ColumnRule, db.ColumnRuleType}): request.Rule.RuleType,
- StringBuilder([]string{db.ColumnRule, db.ColumnPattern}): request.Rule.Pattern,
- StringBuilder([]string{db.ColumnRule, db.ColumnAttribute}): request.Rule.Attribute,
- StringBuilder([]string{db.ColumnRule, db.ColumnDescription}): request.Rule.Description,
- StringBuilder([]string{db.ColumnRule, db.ColumnModTime}): strconv.FormatInt(time.Now().Unix(), 10)}
+ 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})
if err != nil {
@@ -1200,20 +1201,20 @@ func (ds *DataSource) isSchemaEditable(service *discovery.MicroService) bool {
func ServiceExist(ctx context.Context, service *discovery.MicroServiceKey) (bool, error) {
filter := GeneratorServiceNameFilter(ctx, service)
- return client.GetMongoClient().DocExist(ctx, db.CollectionService, filter)
+ return client.GetMongoClient().DocExist(ctx, model.CollectionService, filter)
}
func ServiceExistID(ctx context.Context, serviceID string) (bool, error) {
filter := GeneratorServiceFilter(ctx, serviceID)
- return client.GetMongoClient().DocExist(ctx, db.CollectionService, filter)
+ return client.GetMongoClient().DocExist(ctx, model.CollectionService, filter)
}
-func GetService(ctx context.Context, filter bson.M) (*db.Service, error) {
- findRes, err := client.GetMongoClient().FindOne(ctx, db.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 *db.Service
+ var svc *model.Service
if findRes.Err() != nil {
//not get any service,not db err
return nil, datasource.ErrNoData
@@ -1226,13 +1227,13 @@ func GetService(ctx context.Context, filter bson.M) (*db.Service, error) {
}
func GetServices(ctx context.Context, filter bson.M) ([]*discovery.MicroService, error) {
- res, err := client.GetMongoClient().Find(ctx, db.CollectionService, filter)
+ 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 db.Service
+ var tmp model.Service
err := res.Decode(&tmp)
if err != nil {
return nil, err
@@ -1242,14 +1243,14 @@ func GetServices(ctx context.Context, filter bson.M) ([]*discovery.MicroService,
return services, nil
}
-func GetMongoServices(ctx context.Context, filter bson.M) ([]*db.Service, error) {
- res, err := client.GetMongoClient().Find(ctx, db.CollectionService, filter)
+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 []*db.Service
+ var services []*model.Service
for res.Next(ctx) {
- var tmp *db.Service
+ var tmp *model.Service
err := res.Decode(&tmp)
if err != nil {
return nil, err
@@ -1260,13 +1261,13 @@ func GetMongoServices(ctx context.Context, filter bson.M) ([]*db.Service, error)
}
func GetServicesVersions(ctx context.Context, filter interface{}) ([]string, error) {
- res, err := client.GetMongoClient().Find(ctx, db.CollectionService, filter)
+ res, err := client.GetMongoClient().Find(ctx, model.CollectionService, filter)
if err != nil {
return nil, nil
}
var versions []string
for res.Next(ctx) {
- var tmp db.Service
+ var tmp model.Service
err := res.Decode(&tmp)
if err != nil {
return nil, err
@@ -1276,7 +1277,7 @@ func GetServicesVersions(ctx context.Context, filter interface{}) ([]string, err
return versions, nil
}
-func getServiceDetailUtil(ctx context.Context, mgs *db.Service, countOnly bool, options []string) (*discovery.ServiceDetail, error) {
+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)
@@ -1349,21 +1350,21 @@ func getServiceDetailUtil(ctx context.Context, mgs *db.Service, countOnly bool,
}
func UpdateService(ctx context.Context, filter interface{}, m bson.M) error {
- return client.GetMongoClient().DocUpdate(ctx, db.CollectionService, filter, m)
+ 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{db.ColumnDomain: domain, db.ColumnProject: project, db.ColumnServiceID: serviceID}
+ filter := bson.M{model.ColumnDomain: domain, model.ColumnProject: project, model.ColumnServiceID: serviceID}
- ruleRes, err := client.GetMongoClient().Find(ctx, db.CollectionRule, filter)
+ 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 *db.Rule
+ var tmpRule *model.Rule
err := ruleRes.Decode(&tmpRule)
if err != nil {
return nil, err
@@ -1374,11 +1375,11 @@ func GetRules(ctx context.Context, serviceID string) ([]*discovery.ServiceRule,
}
func UpdateRule(ctx context.Context, filter interface{}, m bson.M) error {
- return client.GetMongoClient().DocUpdate(ctx, db.CollectionRule, filter, m)
+ 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, db.CollectionSchema, filter, m, opts...)
+ _, err := client.GetMongoClient().FindOneAndUpdate(ctx, model.CollectionSchema, filter, m, opts...)
if err != nil {
return err
}
@@ -1386,18 +1387,18 @@ func UpdateSchema(ctx context.Context, filter interface{}, m bson.M, opts ...*op
}
func DeleteSchema(ctx context.Context, filter interface{}) error {
- res, err := client.GetMongoClient().DocDelete(ctx, db.CollectionSchema, filter)
+ res, err := client.GetMongoClient().DocDelete(ctx, model.CollectionSchema, filter)
if err != nil {
return err
}
if !res {
- return ErrDeleteSchemaFailed
+ return mutil.ErrDeleteSchemaFailed
}
return nil
}
func RuleExist(ctx context.Context, filter bson.M) (bool, error) {
- return client.GetMongoClient().DocExist(ctx, db.CollectionRule, filter)
+ return client.GetMongoClient().DocExist(ctx, model.CollectionRule, filter)
}
func GeneratorServiceFilter(ctx context.Context, serviceID string) bson.M {
@@ -1405,9 +1406,9 @@ func GeneratorServiceFilter(ctx context.Context, serviceID string) bson.M {
project := util.ParseProject(ctx)
return bson.M{
- db.ColumnDomain: domain,
- db.ColumnProject: project,
- StringBuilder([]string{db.ColumnService, db.ColumnServiceID}): serviceID}
+ model.ColumnDomain: domain,
+ model.ColumnProject: project,
+ StringBuilder([]string{model.ColumnService, model.ColumnServiceID}): serviceID}
}
func GeneratorServiceNameFilter(ctx context.Context, service *discovery.MicroServiceKey) bson.M {
@@ -1415,12 +1416,12 @@ func GeneratorServiceNameFilter(ctx context.Context, service *discovery.MicroSer
project := util.ParseProject(ctx)
return bson.M{
- db.ColumnDomain: domain,
- db.ColumnProject: project,
- StringBuilder([]string{db.ColumnService, db.ColumnEnv}): service.Environment,
- StringBuilder([]string{db.ColumnService, db.ColumnAppID}): service.AppId,
- StringBuilder([]string{db.ColumnService, db.ColumnServiceName}): service.ServiceName,
- StringBuilder([]string{db.ColumnService, db.ColumnVersion}): service.Version}
+ 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 {
@@ -1428,26 +1429,26 @@ func GeneratorServiceAliasFilter(ctx context.Context, service *discovery.MicroSe
project := util.ParseProject(ctx)
return bson.M{
- db.ColumnDomain: domain,
- db.ColumnProject: project,
- StringBuilder([]string{db.ColumnService, db.ColumnEnv}): service.Environment,
- StringBuilder([]string{db.ColumnService, db.ColumnAppID}): service.AppId,
- StringBuilder([]string{db.ColumnService, db.ColumnAlias}): service.Alias,
- StringBuilder([]string{db.ColumnService, db.ColumnVersion}): service.Version}
+ 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{
- db.ColumnServiceID: serviceID,
- StringBuilder([]string{db.ColumnRule, db.ColumnAttribute}): attribute,
- StringBuilder([]string{db.ColumnRule, db.ColumnPattern}): pattern}
+ 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{db.ColumnDomain: domain, db.ColumnProject: project, db.ColumnServiceID: serviceID, db.ColumnSchemaID: schemaID}
+ 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 {
@@ -1455,20 +1456,20 @@ func GeneratorRuleFilter(ctx context.Context, serviceID, ruleID string) bson.M {
project := util.ParseProject(ctx)
return bson.M{
- db.ColumnDomain: domain,
- db.ColumnProject: project,
- db.ColumnServiceID: serviceID,
- StringBuilder([]string{db.ColumnRule, db.ColumnRuleID}): ruleID}
+ 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, db.CollectionSchema, filter)
+ 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 *db.Schema
+ var tmp *model.Schema
err = getRes.Decode(&tmp)
if err != nil {
return nil, err
@@ -1482,8 +1483,8 @@ func GetSchemas(ctx context.Context, filter bson.M) ([]*discovery.Schema, error)
return schemas, nil
}
-func GetSchema(ctx context.Context, filter bson.M) (*db.Schema, error) {
- findRes, err := client.GetMongoClient().FindOne(ctx, db.CollectionSchema, filter)
+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
}
@@ -1491,7 +1492,7 @@ func GetSchema(ctx context.Context, filter bson.M) (*db.Schema, error) {
//not get any service,not db err
return nil, nil
}
- var schema *db.Schema
+ var schema *model.Schema
err = findRes.Decode(&schema)
if err != nil {
return nil, err
@@ -1500,14 +1501,14 @@ func GetSchema(ctx context.Context, filter bson.M) (*db.Schema, error) {
}
func SchemaSummaryExist(ctx context.Context, serviceID, schemaID string) (bool, error) {
- res, err := client.GetMongoClient().FindOne(ctx, db.CollectionSchema, GeneratorSchemaFilter(ctx, serviceID, schemaID))
+ 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 db.Schema
+ var s model.Schema
err = res.Decode(&s)
if err != nil {
return false, err
@@ -1572,7 +1573,7 @@ func (ds *DataSource) RegisterInstance(ctx context.Context, request *discovery.R
// GetInstance returns instance under the current domain
func (ds *DataSource) GetInstance(ctx context.Context, request *discovery.GetOneInstanceRequest) (*discovery.GetOneInstanceResponse, error) {
- var service *db.Service
+ var service *model.Service
var err error
var serviceIDs []string
if len(request.ConsumerServiceId) > 0 {
@@ -1677,7 +1678,7 @@ func (ds *DataSource) GetInstance(ctx context.Context, request *discovery.GetOne
}
func (ds *DataSource) GetInstances(ctx context.Context, request *discovery.GetInstancesRequest) (*discovery.GetInstancesResponse, error) {
- service := &db.Service{}
+ service := &model.Service{}
var err error
if len(request.ConsumerServiceId) > 0 {
@@ -1723,7 +1724,7 @@ func (ds *DataSource) GetInstances(ctx context.Context, request *discovery.GetIn
}
rev, _ := ctx.Value(util.CtxRequestRevision).(string)
- serviceIDs := filterServiceIDs(ctx, request.ConsumerServiceId, request.Tags, []*db.Service{provider})
+ serviceIDs := filterServiceIDs(ctx, request.ConsumerServiceId, request.Tags, []*model.Service{provider})
if len(serviceIDs) == 0 {
mes := fmt.Errorf("%s failed, provider does not exist", findFlag())
log.Error("query service failed", mes)
@@ -1754,17 +1755,17 @@ func (ds *DataSource) GetProviderInstances(ctx context.Context, request *discove
domain := util.ParseDomain(ctx)
project := util.ParseProject(ctx)
filter := bson.M{
- db.ColumnDomain: domain,
- db.ColumnProject: project,
- StringBuilder([]string{db.ColumnInstance, db.ColumnServiceID}): request.ProviderServiceId}
+ model.ColumnDomain: domain,
+ model.ColumnProject: project,
+ StringBuilder([]string{model.ColumnInstance, model.ColumnServiceID}): request.ProviderServiceId}
- findRes, err := client.GetMongoClient().Find(ctx, db.CollectionInstance, filter)
+ findRes, err := client.GetMongoClient().Find(ctx, model.CollectionInstance, filter)
if err != nil {
return
}
for findRes.Next(ctx) {
- var mongoInstance db.Instance
+ var mongoInstance model.Instance
err := findRes.Decode(&mongoInstance)
if err == nil {
instances = append(instances, mongoInstance.Instance)
@@ -1779,9 +1780,9 @@ func (ds *DataSource) GetAllInstances(ctx context.Context, request *discovery.Ge
domain := util.ParseDomain(ctx)
project := util.ParseProject(ctx)
- filter := bson.M{db.ColumnDomain: domain, db.ColumnProject: project}
+ filter := bson.M{model.ColumnDomain: domain, model.ColumnProject: project}
- findRes, err := client.GetMongoClient().Find(ctx, db.CollectionInstance, filter)
+ findRes, err := client.GetMongoClient().Find(ctx, model.CollectionInstance, filter)
if err != nil {
return nil, err
}
@@ -1790,7 +1791,7 @@ func (ds *DataSource) GetAllInstances(ctx context.Context, request *discovery.Ge
}
for findRes.Next(ctx) {
- var instance db.Instance
+ var instance model.Instance
err := findRes.Decode(&instance)
if err != nil {
return &discovery.GetAllInstancesResponse{
@@ -1805,7 +1806,7 @@ func (ds *DataSource) GetAllInstances(ctx context.Context, request *discovery.Ge
func (ds *DataSource) BatchGetProviderInstances(ctx context.Context, request *discovery.BatchGetInstancesRequest) (instances []*discovery.MicroServiceInstance, rev string, err error) {
if request == nil || len(request.ServiceIds) == 0 {
- return nil, "", ErrInvalidParamBatchGetInstancesRequest
+ return nil, "", mutil.ErrInvalidParam
}
domain := util.ParseDomain(ctx)
@@ -1813,16 +1814,16 @@ func (ds *DataSource) BatchGetProviderInstances(ctx context.Context, request *di
for _, providerServiceID := range request.ServiceIds {
filter := bson.M{
- db.ColumnDomain: domain,
- db.ColumnProject: project,
- StringBuilder([]string{db.ColumnInstance, db.ColumnServiceID}): providerServiceID}
- findRes, err := client.GetMongoClient().Find(ctx, db.CollectionInstance, filter)
+ model.ColumnDomain: domain,
+ model.ColumnProject: project,
+ StringBuilder([]string{model.ColumnInstance, model.ColumnServiceID}): providerServiceID}
+ findRes, err := client.GetMongoClient().Find(ctx, model.CollectionInstance, filter)
if err != nil {
return instances, "", nil
}
for findRes.Next(ctx) {
- var mongoInstance db.Instance
+ var mongoInstance model.Instance
err := findRes.Decode(&mongoInstance)
if err == nil {
instances = append(instances, mongoInstance.Instance)
@@ -1945,11 +1946,11 @@ func (ds *DataSource) UnregisterInstance(ctx context.Context, request *discovery
domain := util.ParseDomain(ctx)
project := util.ParseProject(ctx)
filter := bson.M{
- db.ColumnDomain: domain,
- db.ColumnProject: project,
- StringBuilder([]string{db.ColumnInstance, db.ColumnServiceID}): serviceID,
- StringBuilder([]string{db.ColumnInstance, db.ColumnInstanceID}): instanceID}
- result, err := client.GetMongoClient().Delete(ctx, db.CollectionInstance, filter)
+ model.ColumnDomain: domain,
+ model.ColumnProject: project,
+ StringBuilder([]string{model.ColumnInstance, model.ColumnServiceID}): serviceID,
+ StringBuilder([]string{model.ColumnInstance, model.ColumnInstanceID}): 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)
return &discovery.UnregisterInstanceResponse{
@@ -2066,7 +2067,7 @@ func registryInstance(ctx context.Context, request *discovery.RegisterInstanceRe
remoteIP := util.GetIPFromContext(ctx)
instance := request.Instance
instanceID := instance.InstanceId
- data := &db.Instance{
+ data := &model.Instance{
Domain: domain,
Project: project,
RefreshTime: time.Now(),
@@ -2076,7 +2077,7 @@ func registryInstance(ctx context.Context, request *discovery.RegisterInstanceRe
instanceFlag := fmt.Sprintf("endpoints %v, host '%s', serviceID %s",
instance.Endpoints, instance.HostName, instance.ServiceId)
- insertRes, err := client.GetMongoClient().Insert(ctx, db.CollectionInstance, data)
+ insertRes, err := client.GetMongoClient().Insert(ctx, model.CollectionInstance, data)
if err != nil {
log.Error(fmt.Sprintf("register instance failed %s instanceID %s operator %s", instanceFlag, instanceID, remoteIP), err)
return &discovery.RegisterInstanceResponse{
@@ -2154,7 +2155,7 @@ func (ds *DataSource) findSharedServiceInstance(ctx context.Context, request *di
func (ds *DataSource) findInstance(ctx context.Context, request *discovery.FindInstancesRequest, provider *discovery.MicroServiceKey, rev string) (*discovery.FindInstancesResponse, error) {
var err error
domainProject := util.ParseDomainProject(ctx)
- service := &db.Service{Service: &discovery.MicroService{Environment: request.Environment}}
+ service := &model.Service{Service: &discovery.MicroService{Environment: request.Environment}}
if len(request.ConsumerServiceId) > 0 {
filter := GeneratorServiceFilter(ctx, request.ConsumerServiceId)
service, err = GetService(ctx, filter)
@@ -2318,19 +2319,19 @@ func DependencyRuleExistUtil(ctx context.Context, key bson.M, target *discovery.
return false, nil
}
-func GetInstance(ctx context.Context, serviceID string, instanceID string) (*db.Instance, error) {
+func GetInstance(ctx context.Context, serviceID string, instanceID string) (*model.Instance, error) {
domain := util.ParseDomain(ctx)
project := util.ParseProject(ctx)
filter := bson.M{
- db.ColumnDomain: domain,
- db.ColumnProject: project,
- StringBuilder([]string{db.ColumnInstance, db.ColumnServiceID}): serviceID,
- StringBuilder([]string{db.ColumnInstance, db.ColumnInstanceID}): instanceID}
- findRes, err := client.GetMongoClient().FindOne(ctx, db.CollectionInstance, filter)
+ 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 *db.Instance
+ var instance *model.Instance
if findRes.Err() != nil {
//not get any service,not db err
return nil, nil
@@ -2346,11 +2347,11 @@ func UpdateInstanceS(ctx context.Context, instance *discovery.MicroServiceInstan
domain := util.ParseDomain(ctx)
project := util.ParseProject(ctx)
filter := bson.M{
- db.ColumnDomain: domain,
- db.ColumnProject: project,
- StringBuilder([]string{db.ColumnInstance, db.ColumnServiceID}): instance.ServiceId,
- StringBuilder([]string{db.ColumnInstance, db.ColumnInstanceID}): instance.InstanceId}
- _, err := client.GetMongoClient().Update(ctx, db.CollectionInstance, filter, bson.M{"$set": bson.M{"instance.motTimestamp": strconv.FormatInt(time.Now().Unix(), 10), "instance.status": instance.Status}})
+ 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())
}
@@ -2361,11 +2362,11 @@ func UpdateInstanceP(ctx context.Context, instance *discovery.MicroServiceInstan
domain := util.ParseDomain(ctx)
project := util.ParseProject(ctx)
filter := bson.M{
- db.ColumnDomain: domain,
- db.ColumnProject: project,
- StringBuilder([]string{db.ColumnInstance, db.ColumnServiceID}): instance.ServiceId,
- StringBuilder([]string{db.ColumnInstance, db.ColumnInstanceID}): instance.InstanceId}
- _, err := client.GetMongoClient().Update(ctx, db.CollectionInstance, filter, bson.M{"$set": bson.M{"instance.motTimestamp": strconv.FormatInt(time.Now().Unix(), 10), "instance.properties": instance.Properties}})
+ 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())
}
@@ -2539,18 +2540,18 @@ func preProcessRegisterInstance(ctx context.Context, instance *discovery.MicroSe
}
// servicesBasicFilter query services with domain, project, env, appID, serviceName, alias
-func servicesBasicFilter(ctx context.Context, key *discovery.MicroServiceKey) ([]*db.Service, error) {
+func servicesBasicFilter(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'")
}
filter := bson.M{
- db.ColumnDomain: tenant[0],
- db.ColumnProject: tenant[1],
- StringBuilder([]string{db.ColumnService, db.ColumnEnv}): key.Environment,
- StringBuilder([]string{db.ColumnService, db.ColumnAppID}): key.AppId,
- StringBuilder([]string{db.ColumnService, db.ColumnServiceName}): key.ServiceName,
- StringBuilder([]string{db.ColumnService, db.ColumnAlias}): key.Alias,
+ 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,
}
rangeIdx := strings.Index(key.Version, "-")
// if the version number is clear, need to add the version number to query
@@ -2562,39 +2563,39 @@ func servicesBasicFilter(ctx context.Context, key *discovery.MicroServiceKey) ([
case rangeIdx > 0:
return servicesFilter(ctx, filter)
default:
- filter[StringBuilder([]string{db.ColumnService, db.ColumnVersion})] = key.Version
+ filter[StringBuilder([]string{model.ColumnService, model.ColumnVersion})] = key.Version
return servicesFilter(ctx, filter)
}
}
-func findServices(ctx context.Context, key *discovery.MicroServiceKey) ([]*db.Service, error) {
+func findServices(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{
- db.ColumnDomain: tenant[0],
- db.ColumnProject: tenant[1],
- StringBuilder([]string{db.ColumnService, db.ColumnEnv}): key.Environment,
- StringBuilder([]string{db.ColumnService, db.ColumnAppID}): key.AppId,
- StringBuilder([]string{db.ColumnService, db.ColumnServiceName}): key.ServiceName,
- StringBuilder([]string{db.ColumnService, db.ColumnAlias}): key.Alias,
+ 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,
}
switch {
case key.Version == "latest":
return latestServicesFilter(ctx, filter)
case len(key.Version) > 0 && key.Version[len(key.Version)-1:] == "+":
start := key.Version[:len(key.Version)-1]
- filter[StringBuilder([]string{db.ColumnService, db.ColumnVersion})] = bson.M{"$gte": start}
+ filter[StringBuilder([]string{model.ColumnService, model.ColumnVersion})] = bson.M{"$gte": start}
return servicesFilter(ctx, filter)
case rangeIdx > 0:
start := key.Version[:rangeIdx]
end := key.Version[rangeIdx+1:]
- filter[StringBuilder([]string{db.ColumnService, db.ColumnVersion})] = bson.M{"$gte": start, "$lte": end}
+ filter[StringBuilder([]string{model.ColumnService, model.ColumnVersion})] = bson.M{"$gte": start, "$lte": end}
return servicesFilter(ctx, filter)
default:
- filter[StringBuilder([]string{db.ColumnService, db.ColumnVersion})] = key.Version
+ filter[StringBuilder([]string{model.ColumnService, model.ColumnVersion})] = key.Version
return servicesFilter(ctx, filter)
}
}
@@ -2604,8 +2605,8 @@ func instancesFilter(ctx context.Context, serviceIDs []string) ([]*discovery.Mic
if len(serviceIDs) == 0 {
return instances, nil
}
- resp, err := client.GetMongoClient().Find(ctx, db.CollectionInstance, bson.M{StringBuilder([]string{db.ColumnInstance, db.ColumnServiceID}): bson.M{"$in": serviceIDs}}, &options.FindOptions{
- Sort: bson.M{StringBuilder([]string{db.ColumnInstance, db.ColumnVersion}): -1}})
+ 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
}
@@ -2613,7 +2614,7 @@ func instancesFilter(ctx context.Context, serviceIDs []string) ([]*discovery.Mic
return nil, errors.New("no related instances were found")
}
for resp.Next(ctx) {
- var instance db.Instance
+ var instance model.Instance
err := resp.Decode(&instance)
if err != nil {
return nil, err
@@ -2623,8 +2624,8 @@ func instancesFilter(ctx context.Context, serviceIDs []string) ([]*discovery.Mic
return instances, nil
}
-func filterServiceIDs(ctx context.Context, consumerID string, tags []string, services []*db.Service) []string {
- var filterService []*db.Service
+func filterServiceIDs(ctx context.Context, consumerID string, tags []string, services []*model.Service) []string {
+ var filterService []*model.Service
var serviceIDs []string
if len(services) == 0 {
return serviceIDs
@@ -2637,11 +2638,11 @@ func filterServiceIDs(ctx context.Context, consumerID string, tags []string, ser
return serviceIDs
}
-func tagsFilter(services []*db.Service, tags []string) []*db.Service {
+func tagsFilter(services []*model.Service, tags []string) []*model.Service {
if len(tags) == 0 {
return services
}
- var newServices []*db.Service
+ var newServices []*model.Service
for _, service := range services {
index := 0
for ; index < len(tags); index++ {
@@ -2656,8 +2657,8 @@ func tagsFilter(services []*db.Service, tags []string) []*db.Service {
return newServices
}
-func accessibleFilter(ctx context.Context, consumerID string, services []*db.Service) []*db.Service {
- var newServices []*db.Service
+func accessibleFilter(ctx context.Context, consumerID string, services []*model.Service) []*model.Service {
+ var newServices []*model.Service
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,
@@ -2670,17 +2671,17 @@ func accessibleFilter(ctx context.Context, consumerID string, services []*db.Ser
return newServices
}
-func servicesFilter(ctx context.Context, filter bson.M) ([]*db.Service, error) {
- resp, err := client.GetMongoClient().Find(ctx, db.CollectionService, filter)
+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 []*db.Service
+ var services []*model.Service
for resp.Next(ctx) {
- var service db.Service
+ var service model.Service
err := resp.Decode(&service)
if err != nil {
log.Error("type conversion error", err)
@@ -2691,18 +2692,18 @@ func servicesFilter(ctx context.Context, filter bson.M) ([]*db.Service, error) {
return services, nil
}
-func latestServicesFilter(ctx context.Context, filter bson.M) ([]*db.Service, error) {
- resp, err := client.GetMongoClient().Find(ctx, db.CollectionService, filter, &options.FindOptions{
- Sort: bson.M{StringBuilder([]string{db.ColumnService, db.ColumnVersion}): -1}})
+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 []*db.Service
+ var services []*model.Service
for resp.Next(ctx) {
- var service db.Service
+ var service model.Service
err := resp.Decode(&service)
if err != nil {
log.Error("type conversion error", err)
@@ -2718,18 +2719,18 @@ func latestServicesFilter(ctx context.Context, filter bson.M) ([]*db.Service, er
func getTags(ctx context.Context, domain string, project string, serviceID string) (tags map[string]string, err error) {
filter := bson.M{
- db.ColumnDomain: domain,
- db.ColumnProject: project,
- StringBuilder([]string{db.ColumnService, db.ColumnServiceID}): serviceID,
+ model.ColumnDomain: domain,
+ model.ColumnProject: project,
+ StringBuilder([]string{model.ColumnService, model.ColumnServiceID}): serviceID,
}
- result, err := client.GetMongoClient().FindOne(ctx, db.CollectionService, filter)
+ 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 db.Service
+ var service model.Service
err = result.Decode(&service)
if err != nil {
log.Error("type conversion error", err)
@@ -2738,20 +2739,20 @@ func getTags(ctx context.Context, domain string, project string, serviceID strin
return service.Tags, nil
}
-func getService(ctx context.Context, domain string, project string, serviceID string) (*db.Service, error) {
+func getService(ctx context.Context, domain string, project string, serviceID string) (*model.Service, error) {
filter := bson.M{
- db.ColumnDomain: domain,
- db.ColumnProject: project,
- StringBuilder([]string{db.ColumnService, db.ColumnServiceID}): serviceID,
+ model.ColumnDomain: domain,
+ model.ColumnProject: project,
+ StringBuilder([]string{model.ColumnService, model.ColumnServiceID}): serviceID,
}
- result, err := client.GetMongoClient().FindOne(ctx, db.CollectionService, filter)
+ 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 db.Service
+ var svc model.Service
err = result.Decode(&svc)
if err != nil {
return nil, err
@@ -2805,7 +2806,7 @@ func accessible(ctx context.Context, consumerID string, providerID string) *disc
return MatchRules(rules, consumerService.Service, validateTags)
}
-func MatchRules(rulesOfProvider []*db.Rule, consumer *discovery.MicroService, tagsOfConsumer map[string]string) *discovery.Error {
+func MatchRules(rulesOfProvider []*model.Rule, consumer *discovery.MicroService, tagsOfConsumer map[string]string) *discovery.Error {
if consumer == nil {
return discovery.NewError(discovery.ErrInvalidParams, "consumer is nil")
}
@@ -2838,7 +2839,7 @@ func parsePattern(v reflect.Value, rule *discovery.ServiceRule, tagsOfConsumer m
}
-func patternWhiteList(rulesOfProvider []*db.Rule, tagsOfConsumer map[string]string, consumer *discovery.MicroService) *discovery.Error {
+func patternWhiteList(rulesOfProvider []*model.Rule, tagsOfConsumer map[string]string, consumer *discovery.MicroService) *discovery.Error {
v := reflect.Indirect(reflect.ValueOf(consumer))
consumerID := consumer.ServiceId
for _, rule := range rulesOfProvider {
@@ -2861,7 +2862,7 @@ func patternWhiteList(rulesOfProvider []*db.Rule, tagsOfConsumer map[string]stri
return discovery.NewError(discovery.ErrPermissionDeny, "not found in white list")
}
-func patternBlackList(rulesOfProvider []*db.Rule, tagsOfConsumer map[string]string, consumer *discovery.MicroService) *discovery.Error {
+func patternBlackList(rulesOfProvider []*model.Rule, tagsOfConsumer map[string]string, consumer *discovery.MicroService) *discovery.Error {
v := reflect.Indirect(reflect.ValueOf(consumer))
consumerID := consumer.ServiceId
for _, rule := range rulesOfProvider {
@@ -2885,23 +2886,23 @@ func patternBlackList(rulesOfProvider []*db.Rule, tagsOfConsumer map[string]stri
return nil
}
-func getRulesUtil(ctx context.Context, domain string, project string, serviceID string) ([]*db.Rule, error) {
+func getRulesUtil(ctx context.Context, domain string, project string, serviceID string) ([]*model.Rule, error) {
filter := bson.M{
- db.ColumnDomain: domain,
- db.ColumnProject: project,
- db.ColumnServiceID: serviceID,
+ model.ColumnDomain: domain,
+ model.ColumnProject: project,
+ model.ColumnServiceID: serviceID,
}
- cursor, err := client.GetMongoClient().Find(ctx, db.CollectionRule, filter)
+ 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 []*db.Rule
+ var rules []*model.Rule
defer cursor.Close(ctx)
for cursor.Next(ctx) {
- var rule db.Rule
+ var rule model.Rule
err := cursor.Decode(&rule)
if err != nil {
log.Error("type conversion error", err)
@@ -2912,7 +2913,7 @@ func getRulesUtil(ctx context.Context, domain string, project string, serviceID
return rules, nil
}
-func allowAcrossDimension(ctx context.Context, providerService *db.Service, consumerService *db.Service) error {
+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 {
return fmt.Errorf("not allow across app access")
@@ -2931,7 +2932,7 @@ func allowAcrossDimension(ctx context.Context, providerService *db.Service, cons
func GetInstanceCountOfOneService(ctx context.Context, serviceID string) (int64, error) {
filter := GeneratorServiceInstanceFilter(ctx, serviceID)
- count, err := client.GetMongoClient().Count(ctx, db.CollectionInstance, filter)
+ count, err := client.GetMongoClient().Count(ctx, model.CollectionInstance, filter)
if err != nil {
return 0, nil
}
@@ -2940,13 +2941,13 @@ func GetInstanceCountOfOneService(ctx context.Context, serviceID string) (int64,
func GetAllInstancesOfOneService(ctx context.Context, serviceID string) ([]*discovery.MicroServiceInstance, error) {
filter := GeneratorServiceInstanceFilter(ctx, serviceID)
- res, err := client.GetMongoClient().Find(ctx, db.CollectionInstance, filter)
+ 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 db.Instance
+ var tmp model.Instance
err := res.Decode(&tmp)
if err != nil {
return nil, err
@@ -2956,14 +2957,14 @@ func GetAllInstancesOfOneService(ctx context.Context, serviceID string) ([]*disc
return instances, nil
}
-func GetInstances(ctx context.Context, filter bson.M) ([]*db.Instance, error) {
- res, err := client.GetMongoClient().Find(ctx, db.CollectionInstance, filter)
+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 []*db.Instance
+ var instances []*model.Instance
for res.Next(ctx) {
- var tmp *db.Instance
+ var tmp *model.Instance
err := res.Decode(&tmp)
if err != nil {
return nil, err
@@ -2978,24 +2979,24 @@ func GeneratorServiceVersionsFilter(ctx context.Context, service *discovery.Micr
project := util.ParseProject(ctx)
return bson.M{
- db.ColumnDomain: domain,
- db.ColumnProject: project,
- StringBuilder([]string{db.ColumnService, db.ColumnEnv}): service.Environment,
- StringBuilder([]string{db.ColumnService, db.ColumnAppID}): service.AppId,
- StringBuilder([]string{db.ColumnService, db.ColumnServiceName}): service.ServiceName}
+ 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{
- db.ColumnDomain: domain,
- db.ColumnProject: project,
- StringBuilder([]string{db.ColumnInstance, db.ColumnServiceID}): serviceID}
+ model.ColumnDomain: domain,
+ model.ColumnProject: project,
+ StringBuilder([]string{model.ColumnInstance, model.ColumnServiceID}): serviceID}
}
-func GetServiceByID(ctx context.Context, serviceID string) (*db.Service, error) {
- cacheService, ok := sd.Store().Service().Cache().Get(serviceID).(db.Service)
+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))
@@ -3003,8 +3004,8 @@ func GetServiceByID(ctx context.Context, serviceID string) (*db.Service, error)
return cacheToService(cacheService), nil
}
-func cacheToService(service db.Service) *db.Service {
- return &db.Service{
+func cacheToService(service model.Service) *model.Service {
+ return &model.Service{
Domain: service.Domain,
Project: service.Project,
Tags: service.Tags,
@@ -3017,7 +3018,7 @@ func GetInstancesByServiceID(ctx context.Context, serviceID string) ([]*discover
var cacheUnavailable bool
cacheInstances := sd.Store().Instance().Cache().GetIndexData(serviceID)
for _, instID := range cacheInstances {
- inst, ok := sd.Store().Instance().Cache().Get(instID).(db.Instance)
+ inst, ok := sd.Store().Instance().Cache().Get(instID).(model.Instance)
if !ok {
cacheUnavailable = true
break
diff --git a/datasource/mongo/ms_test.go b/datasource/mongo/ms_test.go
index 235b717..59da2b2 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/db"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/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"
@@ -2533,10 +2533,10 @@ func TestInstance_Update(t *testing.T) {
})
t.Run("delete test data", func(t *testing.T) {
- _, err := client.GetMongoClient().Delete(getContext(), db.CollectionService, bson.M{"domain": "default", "project": "default"})
+ _, err := client.GetMongoClient().Delete(getContext(), model.CollectionService, bson.M{"domain": "default", "project": "default"})
assert.NoError(t, err)
- _, err = client.GetMongoClient().Delete(getContext(), db.CollectionInstance, bson.M{"domain": "default", "project": "default"})
+ _, err = client.GetMongoClient().Delete(getContext(), model.CollectionInstance, bson.M{"domain": "default", "project": "default"})
assert.NoError(t, err)
})
}
@@ -3067,16 +3067,16 @@ func TestInstance_Query(t *testing.T) {
})
t.Run("delete test data", func(t *testing.T) {
- _, err := client.GetMongoClient().Delete(getContext(), db.CollectionService, bson.M{"domain": "default", "project": "default"})
+ _, err := client.GetMongoClient().Delete(getContext(), model.CollectionService, bson.M{"domain": "default", "project": "default"})
assert.NoError(t, err)
- _, err = client.GetMongoClient().Delete(getContext(), db.CollectionInstance, bson.M{"domain": "default", "project": "default"})
+ _, err = client.GetMongoClient().Delete(getContext(), model.CollectionInstance, bson.M{"domain": "default", "project": "default"})
assert.NoError(t, err)
- _, err = client.GetMongoClient().Delete(getContext(), db.CollectionService, bson.M{"domain": "user", "project": "user"})
+ _, err = client.GetMongoClient().Delete(getContext(), model.CollectionService, bson.M{"domain": "user", "project": "user"})
assert.NoError(t, err)
- _, err = client.GetMongoClient().Delete(getContext(), db.CollectionInstance, bson.M{"domain": "user", "project": "user"})
+ _, err = client.GetMongoClient().Delete(getContext(), model.CollectionInstance, bson.M{"domain": "user", "project": "user"})
assert.NoError(t, err)
})
}
@@ -3200,10 +3200,10 @@ func TestInstance_GetOne(t *testing.T) {
})
t.Run("delete test data", func(t *testing.T) {
- _, err := client.GetMongoClient().Delete(getContext(), db.CollectionService, bson.M{"domain": "default", "project": "default"})
+ _, err := client.GetMongoClient().Delete(getContext(), model.CollectionService, bson.M{"domain": "default", "project": "default"})
assert.NoError(t, err)
- _, err = client.GetMongoClient().Delete(getContext(), db.CollectionInstance, bson.M{"domain": "default", "project": "default"})
+ _, err = client.GetMongoClient().Delete(getContext(), model.CollectionInstance, bson.M{"domain": "default", "project": "default"})
assert.NoError(t, err)
})
}
@@ -3283,10 +3283,10 @@ func TestInstance_GetAll(t *testing.T) {
})
t.Run("delete test data", func(t *testing.T) {
- _, err := client.GetMongoClient().Delete(getContext(), db.CollectionService, bson.M{"domain": "TestInstance_GetAll", "project": "1"})
+ _, err := client.GetMongoClient().Delete(getContext(), model.CollectionService, bson.M{"domain": "TestInstance_GetAll", "project": "1"})
assert.NoError(t, err)
- _, err = client.GetMongoClient().Delete(getContext(), db.CollectionInstance, bson.M{"domain": "TestInstance_GetAll", "project": "1"})
+ _, err = client.GetMongoClient().Delete(getContext(), model.CollectionInstance, bson.M{"domain": "TestInstance_GetAll", "project": "1"})
assert.NoError(t, err)
})
}
diff --git a/datasource/mongo/role.go b/datasource/mongo/role.go
index 0b00cb6..b516921 100644
--- a/datasource/mongo/role.go
+++ b/datasource/mongo/role.go
@@ -24,7 +24,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/db"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/model"
"github.com/apache/servicecomb-service-center/pkg/log"
"github.com/apache/servicecomb-service-center/pkg/util"
"github.com/go-chassis/cari/rbac"
@@ -40,7 +40,7 @@ func (ds *DataSource) CreateRole(ctx context.Context, r *rbac.Role) error {
return datasource.ErrRoleDuplicated
}
r.ID = util.GenerateUUID()
- _, err = client.GetMongoClient().Insert(ctx, db.CollectionRole, r)
+ _, err = client.GetMongoClient().Insert(ctx, model.CollectionRole, r)
if err != nil {
if client.IsDuplicateKey(err) {
return datasource.ErrRoleDuplicated
@@ -53,9 +53,9 @@ func (ds *DataSource) CreateRole(ctx context.Context, r *rbac.Role) error {
func (ds *DataSource) RoleExist(ctx context.Context, name string) (bool, error) {
filter := bson.M{
- db.ColumnRoleName: name,
+ model.ColumnRoleName: name,
}
- count, err := client.GetMongoClient().Count(ctx, db.CollectionRole, filter)
+ count, err := client.GetMongoClient().Count(ctx, model.CollectionRole, filter)
if err != nil {
return false, err
}
@@ -67,9 +67,9 @@ 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{
- db.ColumnRoleName: name,
+ model.ColumnRoleName: name,
}
- result, err := client.GetMongoClient().FindOne(ctx, db.CollectionRole, filter)
+ result, err := client.GetMongoClient().FindOne(ctx, model.CollectionRole, filter)
if err != nil {
return nil, err
}
@@ -86,7 +86,7 @@ func (ds *DataSource) GetRole(ctx context.Context, name string) (*rbac.Role, err
}
func (ds *DataSource) ListRole(ctx context.Context) ([]*rbac.Role, int64, error) {
- cursor, err := client.GetMongoClient().Find(ctx, db.CollectionRole, bson.M{})
+ cursor, err := client.GetMongoClient().Find(ctx, model.CollectionRole, bson.M{})
if err != nil {
return nil, 0, err
}
@@ -106,9 +106,9 @@ 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{
- db.ColumnRoleName: name,
+ model.ColumnRoleName: name,
}
- result, err := client.GetMongoClient().Delete(ctx, db.CollectionRole, filter)
+ result, err := client.GetMongoClient().Delete(ctx, model.CollectionRole, filter)
if err != nil {
return false, err
}
@@ -120,16 +120,16 @@ 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{
- db.ColumnRoleName: name,
+ model.ColumnRoleName: name,
}
update := bson.M{
"$set": bson.M{
- db.ColumnID: role.ID,
- db.ColumnRoleName: role.Name,
- db.ColumnPerms: role.Perms,
+ model.ColumnID: role.ID,
+ model.ColumnRoleName: role.Name,
+ model.ColumnPerms: role.Perms,
},
}
- _, err := client.GetMongoClient().Update(ctx, db.CollectionRole, filter, update)
+ _, err := client.GetMongoClient().Update(ctx, model.CollectionRole, filter, update)
if err != nil {
return err
}
diff --git a/datasource/mongo/rule_util.go b/datasource/mongo/rule_util.go
index 3f99524..4fae9ca 100644
--- a/datasource/mongo/rule_util.go
+++ b/datasource/mongo/rule_util.go
@@ -22,11 +22,11 @@ import (
"github.com/go-chassis/cari/discovery"
- "github.com/apache/servicecomb-service-center/datasource/mongo/db"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/model"
"github.com/apache/servicecomb-service-center/pkg/util"
)
-func Filter(ctx context.Context, rules []*db.Rule, consumerID string) (bool, error) {
+func Filter(ctx context.Context, rules []*model.Rule, consumerID string) (bool, error) {
consumer, err := GetServiceByID(ctx, consumerID)
if consumer == nil {
return false, err
@@ -52,7 +52,7 @@ func Filter(ctx context.Context, rules []*db.Rule, consumerID string) (bool, err
return true, nil
}
-func FilterAll(ctx context.Context, consumerIDs []string, rules []*db.Rule) (allow []string, deny []string, err error) {
+func FilterAll(ctx context.Context, consumerIDs []string, rules []*model.Rule) (allow []string, deny []string, err error) {
l := len(consumerIDs)
if l == 0 || len(rules) == 0 {
return consumerIDs, nil, nil
diff --git a/datasource/mongo/rule_util_test.go b/datasource/mongo/rule_util_test.go
index 7fd0e6b..86d4ffa 100644
--- a/datasource/mongo/rule_util_test.go
+++ b/datasource/mongo/rule_util_test.go
@@ -26,27 +26,27 @@ import (
"github.com/apache/servicecomb-service-center/datasource"
"github.com/apache/servicecomb-service-center/datasource/mongo"
- "github.com/apache/servicecomb-service-center/datasource/mongo/db"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/model"
)
func TestRuleFilter_Filter(t *testing.T) {
var err error
t.Run("when there is no such a customer in db", func(t *testing.T) {
- _, err = mongo.Filter(context.Background(), []*db.Rule{}, "")
+ _, err = mongo.Filter(context.Background(), []*model.Rule{}, "")
if err != nil && !errors.Is(err, datasource.ErrNoData) {
t.Fatalf("RuleFilter Filter failed")
}
assert.Equal(t, datasource.ErrNoData, err, "no data found")
})
t.Run("FilterAll when customer not exist", func(t *testing.T) {
- _, _, err = mongo.FilterAll(context.Background(), []string{""}, []*db.Rule{})
+ _, _, err = mongo.FilterAll(context.Background(), []string{""}, []*model.Rule{})
if err != nil && !errors.Is(err, datasource.ErrNoData) {
t.Fatalf("RuleFilter FilterAll failed")
}
assert.Equal(t, nil, err, "no customer found err is nil")
})
t.Run("FilterAll when ProviderRules not nil and service not exist", func(t *testing.T) {
- _, _, err = mongo.FilterAll(context.Background(), []string{""}, []*db.Rule{{}})
+ _, _, err = mongo.FilterAll(context.Background(), []string{""}, []*model.Rule{{}})
if err != nil && !errors.Is(err, datasource.ErrNoData) {
t.Fatalf("RuleFilter FilterAll failed")
}
diff --git a/datasource/mongo/sd/listwatch_inner.go b/datasource/mongo/sd/listwatch_inner.go
index d4324e2..2ee4d35 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/db"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/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"
@@ -126,7 +126,7 @@ func (lw *mongoListWatch) doParseDocumentToResource(fullDocument bson.Raw) (reso
switch lw.Key {
case instance:
- instance := db.Instance{}
+ instance := model.Instance{}
err = bson.Unmarshal(fullDocument, &instance)
if err != nil {
log.Error("error to parse bson raw to documentInfo", err)
@@ -136,7 +136,7 @@ func (lw *mongoListWatch) doParseDocumentToResource(fullDocument bson.Raw) (reso
resource.Value = instance
resource.Index = instance.Instance.ServiceId
case service:
- service := db.Service{}
+ service := model.Service{}
err := bson.Unmarshal(fullDocument, &service)
if err != nil {
log.Error("error to parse bson raw to documentInfo", err)
diff --git a/datasource/mongo/sd/listwatch_test.go b/datasource/mongo/sd/listwatch_test.go
index 1e2bce3..8f2d8c2 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/db"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/model"
"github.com/apache/servicecomb-service-center/datasource/sdcommon"
)
@@ -71,7 +71,7 @@ func TestDoParseWatchRspToMongoInfo(t *testing.T) {
info = ilw.doParseWatchRspToResource(mockWatchRsp)
assert.Equal(t, documentID.Hex(), info.DocumentID)
assert.Equal(t, "8064a600438511eb8584fa163e8a81c9", info.Key)
- assert.Equal(t, "1608552622", info.Value.(db.Instance).Instance.ModTimestamp)
+ assert.Equal(t, "1608552622", info.Value.(model.Instance).Instance.ModTimestamp)
// case delete
mockWatchRsp.OperationType = deleteOp
diff --git a/datasource/mongo/sd/mongo_cacher.go b/datasource/mongo/sd/mongo_cacher.go
index 7938c0b..0686fc1 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/db"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/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"
@@ -368,16 +368,16 @@ func (c *MongoCacher) isValueNotUpdated(value interface{}, newValue interface{})
switch c.Options.Key {
case instance:
- instance := value.(db.Instance)
- newInstance := newValue.(db.Instance)
+ instance := value.(model.Instance)
+ newInstance := newValue.(model.Instance)
if instance.Instance == nil || newInstance.Instance == nil {
return true
}
modTime = instance.Instance.ModTimestamp
newModTime = newInstance.Instance.ModTimestamp
case service:
- service := value.(db.Service)
- newService := newValue.(db.Service)
+ service := value.(model.Service)
+ newService := newValue.(model.Service)
if service.Service == nil || newService.Service == nil {
return true
}
diff --git a/datasource/mongo/sd/mongo_cacher_test.go b/datasource/mongo/sd/mongo_cacher_test.go
index 4477baa..8e6cfd0 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/db"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/model"
"github.com/apache/servicecomb-service-center/datasource/sdcommon"
"github.com/apache/servicecomb-service-center/pkg/gopool"
)
@@ -103,7 +103,7 @@ func TestNewMongoCacher(t *testing.T) {
bson.Marshal(bson.M{"_data": "825FDB4272000000012B022C0100296E5A10043E2D15AC82D9484C8090E68AF36FED2A46645F696400645FD76265066A6D2DF2AAC8D80004"})
var resources []*sdcommon.Resource
- resource := &sdcommon.Resource{Key: mockResourceID, DocumentID: mockDocumentID, Value: db.Instance{Domain: "default", Project: "default",
+ resource := &sdcommon.Resource{Key: mockResourceID, DocumentID: mockDocumentID, Value: model.Instance{Domain: "default", Project: "default",
Instance: &pb.MicroServiceInstance{InstanceId: mockResourceID, ModTimestamp: "100000"}}}
resources = append(resources, resource)
test := &sdcommon.ListWatchResp{
@@ -160,7 +160,7 @@ func TestNewMongoCacher(t *testing.T) {
// prepare updateOp data
dataUpdate := &sdcommon.Resource{Key: mockResourceID, DocumentID: mockDocumentID,
- Value: db.Instance{Domain: "default", Project: "default",
+ Value: model.Instance{Domain: "default", Project: "default",
Instance: &pb.MicroServiceInstance{InstanceId: mockResourceID, HostName: "test", ModTimestamp: "100001"}}}
var mongoUpdateResources []*sdcommon.Resource
@@ -253,7 +253,7 @@ func TestNewMongoCacher(t *testing.T) {
t.Run("case watch: caught updateOp event", func(t *testing.T) {
// prepare updateOp data
dataUpdate := &sdcommon.Resource{Key: mockResourceID, DocumentID: mockDocumentID,
- Value: db.Instance{Domain: "default", Project: "default",
+ Value: model.Instance{Domain: "default", Project: "default",
Instance: &pb.MicroServiceInstance{InstanceId: mockResourceID, HostName: "test", ModTimestamp: "100001"}}}
var mongoUpdateResources []*sdcommon.Resource
diff --git a/datasource/mongo/system.go b/datasource/mongo/system.go
index 83dc5f9..9ad647b 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/db"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/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"
@@ -49,7 +49,7 @@ func (ds *DataSource) DUnlock(ctx context.Context, request *datasource.DUnlockRe
func setServiceValue(e *sd.MongoCacher, setter dump.Setter) {
e.Cache().ForEach(func(k string, kv interface{}) (next bool) {
- service := kv.(cache.Item).Object.(db.Service)
+ service := kv.(cache.Item).Object.(model.Service)
setter.SetValue(&dump.KV{
Key: util.StringJoin([]string{datasource.ServiceKeyPrefix, service.Domain, service.Project, k},
datasource.SPLIT),
@@ -61,7 +61,7 @@ func setServiceValue(e *sd.MongoCacher, setter dump.Setter) {
func setInstanceValue(e *sd.MongoCacher, setter dump.Setter) {
e.Cache().ForEach(func(k string, kv interface{}) (next bool) {
- instance := kv.(cache.Item).Object.(db.Instance)
+ instance := kv.(cache.Item).Object.(model.Instance)
setter.SetValue(&dump.KV{
Key: util.StringJoin([]string{datasource.InstanceKeyPrefix, instance.Domain, instance.Project,
instance.Instance.ServiceId, k}, datasource.SPLIT),
diff --git a/datasource/mongo/system_test.go b/datasource/mongo/system_test.go
index 0501745..e38b181 100644
--- a/datasource/mongo/system_test.go
+++ b/datasource/mongo/system_test.go
@@ -26,14 +26,14 @@ 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/db"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/model"
"github.com/apache/servicecomb-service-center/datasource/mongo/sd"
)
func init() {
// clean the mongodb
- client.GetMongoClient().Delete(getContext(), db.CollectionInstance, bson.M{})
- client.GetMongoClient().Delete(getContext(), db.CollectionService, bson.M{})
+ client.GetMongoClient().Delete(getContext(), model.CollectionInstance, bson.M{})
+ client.GetMongoClient().Delete(getContext(), model.CollectionService, bson.M{})
}
func TestDumpCache(t *testing.T) {
diff --git a/datasource/mongo/util.go b/datasource/mongo/util.go
index dda5380..a886599 100644
--- a/datasource/mongo/util.go
+++ b/datasource/mongo/util.go
@@ -21,15 +21,12 @@ import (
"context"
"strings"
- pb "github.com/go-chassis/cari/discovery"
- "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"
- "github.com/apache/servicecomb-service-center/datasource/mongo/db"
+ "github.com/apache/servicecomb-service-center/datasource/mongo/model"
"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
@@ -46,17 +43,6 @@ func (s InstanceSlice) Less(i, j int) bool {
return s[i].InstanceId < s[j].InstanceId
}
-func BuildIndexDoc(keys ...string) mongo.IndexModel {
- keysDoc := bsonx.Doc{}
- for _, key := range keys {
- keysDoc = keysDoc.Append(key, bsonx.Int32(1))
- }
- index := mongo.IndexModel{
- Keys: keysDoc,
- }
- return index
-}
-
func StringBuilder(data []string) string {
var str strings.Builder
for index, value := range data {
@@ -78,7 +64,7 @@ func statistics(ctx context.Context, withShared bool) (*pb.Statistics, error) {
domain := util.ParseDomain(ctx)
project := util.ParseProject(ctx)
- filter := bson.M{db.ColumnDomain: domain, db.ColumnProject: project}
+ filter := bson.M{model.ColumnDomain: domain, model.ColumnProject: project}
services, err := GetServices(ctx, filter)
if err != nil {
diff --git a/datasource/mongo/util/db.go b/datasource/mongo/util/db.go
new file mode 100644
index 0000000..9c5f437
--- /dev/null
+++ b/datasource/mongo/util/db.go
@@ -0,0 +1,71 @@
+/*
+ * 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 util
+
+import (
+ "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"
+)
+
+type Option func(filter bson.M)
+
+func Domain(domain string) Option {
+ return func(filter bson.M) {
+ filter[model.ColumnDomain] = domain
+ }
+}
+
+func Project(project string) Option {
+ return func(filter bson.M) {
+ filter[model.ColumnProject] = project
+ }
+}
+
+func NewFilter(options ...func(filter bson.M)) bson.M {
+ filter := bson.M{}
+ for _, option := range options {
+ option(filter)
+ }
+ return filter
+}
+
+func InstanceServiceID(serviceID string) Option {
+ return func(filter bson.M) {
+ filter[StringBuilder([]string{model.ColumnInstance, model.ColumnServiceID})] = serviceID
+ }
+}
+
+func InstanceInstanceID(instanceID string) Option {
+ return func(filter bson.M) {
+ filter[StringBuilder([]string{model.ColumnInstance, model.ColumnInstanceID})] = instanceID
+ }
+}
+
+func BuildIndexDoc(keys ...string) mongo.IndexModel {
+ keysDoc := bsonx.Doc{}
+ for _, key := range keys {
+ keysDoc = keysDoc.Append(key, bsonx.Int32(1))
+ }
+ index := mongo.IndexModel{
+ Keys: keysDoc,
+ }
+ return index
+}
diff --git a/datasource/mongo/common.go b/datasource/mongo/util/errors.go
similarity index 50%
rename from datasource/mongo/common.go
rename to datasource/mongo/util/errors.go
index 8cab32c..836df80 100644
--- a/datasource/mongo/common.go
+++ b/datasource/mongo/util/errors.go
@@ -3,30 +3,30 @@
* 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 request compliance with
+ * (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 request writing, software
+ * 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 mongo
+package util
import "errors"
var (
- ErrInvalidConsumer = errors.New("Invalid consumer")
- ErrUpdateNodata = errors.New("UpdateAccount: no data to update")
- ErrServiceFileLost = errors.New("service center service file lost")
- ErrInvalidDomainProject = errors.New("invalid domainProject")
- ErrNotAllowDeleteSC = errors.New("not allow to delete service center")
- ErrDeleteSchemaFailed = errors.New("delete schema failed")
- ErrInvalidParamBatchGetInstancesRequest = errors.New("invalid param BatchGetInstancesRequest")
+ ErrInvalidConsumer = errors.New("invalid consumer")
+ ErrNoDataToUpdate = errors.New("there is no data to update")
+ ErrLostServiceFile = errors.New("service center service file lost")
+ ErrInvalidDomainProject = errors.New("invalid domainProject")
+ ErrNotAllowDeleteSC = errors.New("not allow to delete service center")
+ ErrDeleteSchemaFailed = errors.New("delete schema failed")
+ ErrInvalidParam = errors.New("invalid param")
)
func NewError(errInfo string, errMsg string) error {
diff --git a/datasource/mongo/util/string.go b/datasource/mongo/util/string.go
new file mode 100644
index 0000000..aadad1b
--- /dev/null
+++ b/datasource/mongo/util/string.go
@@ -0,0 +1,32 @@
+/*
+ * 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 util
+
+import "strings"
+
+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()
+}