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 9f3aa12 Change: remove the option 'SchemaNotEditable' (#1272)
9f3aa12 is described below
commit 9f3aa1292c72d7e908f192b555c3fe454bdf04d2
Author: little-cui <[email protected]>
AuthorDate: Wed Feb 23 19:26:44 2022 +0800
Change: remove the option 'SchemaNotEditable' (#1272)
---
datasource/etcd/etcd.go | 1 -
datasource/etcd/ms.go | 229 ++++++++++++--------------------------------
datasource/etcd/util.go | 12 ---
datasource/mongo/mongo.go | 1 -
datasource/mongo/ms.go | 183 +++++++++--------------------------
datasource/options.go | 3 +-
datasource/schema_test.go | 52 +---------
etc/conf/app.yaml | 2 -
examples/dev/conf/app.yaml | 2 -
server/config/config.go | 3 +-
server/config/server.go | 2 -
server/core/microservice.go | 4 -
server/server.go | 1 -
13 files changed, 113 insertions(+), 382 deletions(-)
diff --git a/datasource/etcd/etcd.go b/datasource/etcd/etcd.go
index e4f0cdd..7d88a33 100644
--- a/datasource/etcd/etcd.go
+++ b/datasource/etcd/etcd.go
@@ -104,7 +104,6 @@ func NewDataSource(opts datasource.Options)
(datasource.DataSource, error) {
return nil, err
}
inst.metadataManager = &MetadataManager{
- SchemaNotEditable: opts.SchemaNotEditable,
InstanceTTL: opts.InstanceTTL,
InstanceProperties: opts.InstanceProperties,
}
diff --git a/datasource/etcd/ms.go b/datasource/etcd/ms.go
index 917f270..470e4de 100644
--- a/datasource/etcd/ms.go
+++ b/datasource/etcd/ms.go
@@ -47,14 +47,7 @@ import (
"github.com/apache/servicecomb-service-center/syncer/service/event"
)
-var (
- ErrUndefinedSchemaID = pb.NewError(pb.ErrUndefinedSchemaID,
datasource.ErrUndefinedSchemaID.Error())
- ErrModifySchemaNotAllow = pb.NewError(pb.ErrModifySchemaNotAllow,
datasource.ErrModifySchemaNotAllow.Error())
-)
-
type MetadataManager struct {
- // SchemaNotEditable determines whether schema modification is not
allowed
- SchemaNotEditable bool
// InstanceTTL options
InstanceTTL int64
InstanceProperties map[string]string
@@ -133,35 +126,36 @@ func (ds *MetadataManager) RegisterService(ctx
context.Context, request *pb.Crea
serviceFlag, remoteIP), err)
return nil, pb.NewError(pb.ErrUnavailableBackend, err.Error())
}
- if !resp.Succeeded {
- if len(requestServiceID) != 0 {
- if len(resp.Kvs) == 0 || requestServiceID !=
util.BytesToStringWithNoCopy(resp.Kvs[0].Value) {
- log.Warn(fmt.Sprintf("create micro-service[%s]
failed, service already exists, operator: %s",
- serviceFlag, remoteIP))
- return nil,
pb.NewError(pb.ErrServiceAlreadyExists,
- "ServiceID conflict or found the same
service with different id.")
- }
- }
-
- if len(resp.Kvs) == 0 {
- // internal error?
- log.Error(fmt.Sprintf("create micro-service[%s] failed,
unexpected txn response, operator: %s",
- serviceFlag, remoteIP), nil)
- return nil, pb.NewError(pb.ErrInternal, "Unexpected txn
response.")
- }
- existServiceID :=
util.BytesToStringWithNoCopy(resp.Kvs[0].Value)
- log.Warn(fmt.Sprintf("create micro-service[%s][%s] failed,
service already exists, operator: %s",
- existServiceID, serviceFlag, remoteIP))
+ if resp.Succeeded {
+ log.Info(fmt.Sprintf("create micro-service[%s][%s]
successfully, operator: %s",
+ service.ServiceId, serviceFlag, remoteIP))
return &pb.CreateServiceResponse{
- ServiceId: existServiceID,
+ ServiceId: service.ServiceId,
}, nil
}
- log.Info(fmt.Sprintf("create micro-service[%s][%s] successfully,
operator: %s",
- service.ServiceId, serviceFlag, remoteIP))
+ if len(requestServiceID) != 0 {
+ if len(resp.Kvs) == 0 || requestServiceID !=
util.BytesToStringWithNoCopy(resp.Kvs[0].Value) {
+ log.Warn(fmt.Sprintf("create micro-service[%s] failed,
service already exists, operator: %s",
+ serviceFlag, remoteIP))
+ return nil, pb.NewError(pb.ErrServiceAlreadyExists,
+ "ServiceID conflict or found the same service
with different id.")
+ }
+ }
+
+ if len(resp.Kvs) == 0 {
+ // internal error?
+ log.Error(fmt.Sprintf("create micro-service[%s] failed,
unexpected txn response, operator: %s",
+ serviceFlag, remoteIP), nil)
+ return nil, pb.NewError(pb.ErrInternal, "Unexpected txn
response.")
+ }
+
+ existServiceID := util.BytesToStringWithNoCopy(resp.Kvs[0].Value)
+ log.Warn(fmt.Sprintf("create micro-service[%s][%s] failed, service
already exists, operator: %s",
+ existServiceID, serviceFlag, remoteIP))
return &pb.CreateServiceResponse{
- ServiceId: service.ServiceId,
+ ServiceId: existServiceID,
}, nil
}
@@ -1415,96 +1409,49 @@ func (ds *MetadataManager) modifySchemas(ctx
context.Context, domainProject stri
return pb.NewError(pb.ErrUnavailableBackend, err.Error())
}
- needUpdateSchemas, needAddSchemas, needDeleteSchemas, nonExistSchemaIds
:=
+ needUpdateSchemas, needAddSchemas, needDeleteSchemas, _ :=
datasource.SchemasAnalysis(schemas, schemasFromDatabase,
service.Schemas)
pluginOps := make([]etcdadpt.OpOptions, 0)
- if !ds.isSchemaEditable() {
- if len(service.Schemas) == 0 {
- errQuota := quotasvc.ApplySchema(ctx, serviceID,
int64(len(nonExistSchemaIds)))
- if errQuota != nil {
- log.Error(fmt.Sprintf("modify service[%s]
schemas failed, operator: %s", serviceID, remoteIP), errQuota)
- return errQuota
- }
-
- service.Schemas = nonExistSchemaIds
- opts, err := eutil.UpdateService(ctx, domainProject,
serviceID, service)
- if err != nil {
- log.Error(fmt.Sprintf("modify service[%s]
schemas failed, update service.Schemas failed, operator: %s",
- serviceID, remoteIP), err)
- return pb.NewError(pb.ErrInternal, err.Error())
- }
- pluginOps = append(pluginOps, opts...)
- } else {
- if len(nonExistSchemaIds) != 0 {
- errInfo := fmt.Errorf("non-existent schemaIDs
%v", nonExistSchemaIds)
- log.Error(fmt.Sprintf("modify service[%s]
schemas failed, operator: %s", serviceID, remoteIP), errInfo)
- return pb.NewError(pb.ErrUndefinedSchemaID,
errInfo.Error())
- }
- for _, needUpdateSchema := range needUpdateSchemas {
- exist, err := isExistSchemaSummary(ctx,
domainProject, serviceID, needUpdateSchema.SchemaId)
- if err != nil {
- return pb.NewError(pb.ErrInternal,
err.Error())
- }
- if !exist {
- opts, err := putSchema(ctx,
domainProject, serviceID, needUpdateSchema)
- if err != nil {
- return
pb.NewError(pb.ErrInternal, err.Error())
- }
- pluginOps = append(pluginOps, opts...)
- } else {
- log.Warn(fmt.Sprintf("schema[%s/%s] and
it's summary already exist, skip to update, operator: %s",
- serviceID,
needUpdateSchema.SchemaId, remoteIP))
- }
- }
- }
-
- for _, schema := range needAddSchemas {
- log.Info(fmt.Sprintf("add new schema[%s/%s], operator:
%s", serviceID, schema.SchemaId, remoteIP))
- opts, _ := putSchema(ctx, domainProject,
service.ServiceId, schema)
- pluginOps = append(pluginOps, opts...)
- }
- } else {
- quotaSize := len(needAddSchemas) - len(needDeleteSchemas)
- if quotaSize > 0 {
- errQuota := quotasvc.ApplySchema(ctx, serviceID,
int64(quotaSize))
- if errQuota != nil {
- log.Error(fmt.Sprintf("modify service[%s]
schemas failed, operator: %s", serviceID, remoteIP), errQuota)
- return errQuota
- }
- }
-
- var schemaIDs []string
- for _, schema := range needAddSchemas {
- log.Info(fmt.Sprintf("add new schema[%s/%s], operator:
%s", serviceID, schema.SchemaId, remoteIP))
- opts, _ := putSchema(ctx, domainProject,
service.ServiceId, schema)
- pluginOps = append(pluginOps, opts...)
- schemaIDs = append(schemaIDs, schema.SchemaId)
+ quotaSize := len(needAddSchemas) - len(needDeleteSchemas)
+ if quotaSize > 0 {
+ errQuota := quotasvc.ApplySchema(ctx, serviceID,
int64(quotaSize))
+ if errQuota != nil {
+ log.Error(fmt.Sprintf("modify service[%s] schemas
failed, operator: %s", serviceID, remoteIP), errQuota)
+ return errQuota
}
+ }
- for _, schema := range needUpdateSchemas {
- log.Info(fmt.Sprintf("update schema[%s/%s], operator:
%s", serviceID, schema.SchemaId, remoteIP))
- opts, _ := putSchema(ctx, domainProject, serviceID,
schema)
- pluginOps = append(pluginOps, opts...)
- schemaIDs = append(schemaIDs, schema.SchemaId)
- }
+ var schemaIDs []string
+ for _, schema := range needAddSchemas {
+ log.Info(fmt.Sprintf("add new schema[%s/%s], operator: %s",
serviceID, schema.SchemaId, remoteIP))
+ opts, _ := putSchema(ctx, domainProject, service.ServiceId,
schema)
+ pluginOps = append(pluginOps, opts...)
+ schemaIDs = append(schemaIDs, schema.SchemaId)
+ }
- for _, schema := range needDeleteSchemas {
- log.Info(fmt.Sprintf("delete non-existent
schema[%s/%s], operator: %s", serviceID, schema.SchemaId, remoteIP))
- opts, _ := deleteSchema(ctx, domainProject, serviceID,
schema)
- pluginOps = append(pluginOps, opts...)
- }
+ for _, schema := range needUpdateSchemas {
+ log.Info(fmt.Sprintf("update schema[%s/%s], operator: %s",
serviceID, schema.SchemaId, remoteIP))
+ opts, _ := putSchema(ctx, domainProject, serviceID, schema)
+ pluginOps = append(pluginOps, opts...)
+ schemaIDs = append(schemaIDs, schema.SchemaId)
+ }
- service.Schemas = schemaIDs
- opts, err := eutil.UpdateService(ctx, domainProject, serviceID,
service)
- if err != nil {
- log.Error(fmt.Sprintf("modify service[%s] schemas
failed, update service.Schemas failed, operator: %s",
- serviceID, remoteIP), err)
- return pb.NewError(pb.ErrInternal, err.Error())
- }
+ for _, schema := range needDeleteSchemas {
+ log.Info(fmt.Sprintf("delete non-existent schema[%s/%s],
operator: %s", serviceID, schema.SchemaId, remoteIP))
+ opts, _ := deleteSchema(ctx, domainProject, serviceID, schema)
pluginOps = append(pluginOps, opts...)
}
+ service.Schemas = schemaIDs
+ opts, err := eutil.UpdateService(ctx, domainProject, serviceID, service)
+ if err != nil {
+ log.Error(fmt.Sprintf("modify service[%s] schemas failed,
update service.Schemas failed, operator: %s",
+ serviceID, remoteIP), err)
+ return pb.NewError(pb.ErrInternal, err.Error())
+ }
+ pluginOps = append(pluginOps, opts...)
+
if len(pluginOps) != 0 {
resp, err := etcdadpt.TxnWithCmp(ctx, pluginOps,
etcdadpt.If(etcdadpt.NotEqualVer(path.GenerateServiceKey(domainProject,
serviceID), 0)),
@@ -1519,10 +1466,6 @@ func (ds *MetadataManager) modifySchemas(ctx
context.Context, domainProject stri
return nil
}
-func (ds *MetadataManager) isSchemaEditable() bool {
- return !ds.SchemaNotEditable
-}
-
func (ds *MetadataManager) modifySchema(ctx context.Context, serviceID string,
schema *pb.Schema) *errsvc.Error {
remoteIP := util.GetIPFromContext(ctx)
domainProject := util.ParseDomainProject(ctx)
@@ -1542,61 +1485,15 @@ func (ds *MetadataManager) modifySchema(ctx
context.Context, serviceID string, s
var pluginOps []etcdadpt.OpOptions
isExist := isExistSchemaID(microService, []*pb.Schema{schema})
-
- if !ds.isSchemaEditable() {
- if len(microService.Schemas) != 0 && !isExist {
- return ErrUndefinedSchemaID
- }
-
- key := path.GenerateServiceSchemaKey(domainProject, serviceID,
schemaID)
- respSchema, err := sd.Schema().Search(ctx,
etcdadpt.WithStrKey(key), etcdadpt.WithCountOnly())
+ if !isExist {
+ microService.Schemas = append(microService.Schemas, schemaID)
+ opts, err := eutil.UpdateService(ctx, domainProject, serviceID,
microService)
if err != nil {
- log.Error(fmt.Sprintf("modify schema[%s/%s] failed, get
schema summary failed, operator: %s",
+ log.Error(fmt.Sprintf("modify schema[%s/%s] failed,
update microService.Schemas failed, operator: %s",
serviceID, schemaID, remoteIP), err)
- return pb.NewError(pb.ErrUnavailableBackend,
err.Error())
- }
-
- if respSchema.Count != 0 {
- if len(schema.Summary) == 0 {
- log.Error(fmt.Sprintf("schema readonly mode,
schema[%s/%s] already exists, can not be changed, operator: %s",
- serviceID, schemaID, remoteIP), err)
- return ErrModifySchemaNotAllow
- }
-
- exist, err := isExistSchemaSummary(ctx, domainProject,
serviceID, schemaID)
- if err != nil {
- log.Error(fmt.Sprintf("check schema[%s/%s]
summary existence failed, operator: %s",
- serviceID, schemaID, remoteIP), err)
- return pb.NewError(pb.ErrInternal, err.Error())
- }
- if exist {
- log.Error(fmt.Sprintf("schema readonly mode,
schema[%s/%s] already exist, can not be changed, operator: %s",
- serviceID, schemaID, remoteIP), err)
- return ErrModifySchemaNotAllow
- }
- }
-
- if len(microService.Schemas) == 0 {
- microService.Schemas = append(microService.Schemas,
schemaID)
- opts, err := eutil.UpdateService(ctx, domainProject,
serviceID, microService)
- if err != nil {
- log.Error(fmt.Sprintf("modify schema[%s/%s]
failed, update microService.Schemas failed, operator: %s",
- serviceID, schemaID, remoteIP), err)
- return pb.NewError(pb.ErrInternal, err.Error())
- }
- pluginOps = append(pluginOps, opts...)
- }
- } else {
- if !isExist {
- microService.Schemas = append(microService.Schemas,
schemaID)
- opts, err := eutil.UpdateService(ctx, domainProject,
serviceID, microService)
- if err != nil {
- log.Error(fmt.Sprintf("modify schema[%s/%s]
failed, update microService.Schemas failed, operator: %s",
- serviceID, schemaID, remoteIP), err)
- return pb.NewError(pb.ErrInternal, err.Error())
- }
- pluginOps = append(pluginOps, opts...)
+ return pb.NewError(pb.ErrInternal, err.Error())
}
+ pluginOps = append(pluginOps, opts...)
}
opts, err := commitSchemaInfo(ctx, domainProject, serviceID, schema)
diff --git a/datasource/etcd/util.go b/datasource/etcd/util.go
index 25e9fd3..6aca94e 100644
--- a/datasource/etcd/util.go
+++ b/datasource/etcd/util.go
@@ -95,18 +95,6 @@ func checkSchemaInfoExist(ctx context.Context, key string)
(bool, error) {
return true, nil
}
-func isExistSchemaSummary(ctx context.Context, domainProject, serviceID,
schemaID string) (bool, error) {
- key := path.GenerateServiceSchemaSummaryKey(domainProject, serviceID,
schemaID)
- resp, err := sd.SchemaSummary().Search(ctx, etcdadpt.WithStrKey(key),
etcdadpt.WithCountOnly())
- if err != nil {
- return true, err
- }
- if resp.Count == 0 {
- return false, nil
- }
- return true, nil
-}
-
func putSchema(ctx context.Context, domainProject string, serviceID string,
schema *pb.Schema) ([]etcdadpt.OpOptions, error) {
opts := make([]etcdadpt.OpOptions, 0)
key := path.GenerateServiceSchemaKey(domainProject, serviceID,
schema.SchemaId)
diff --git a/datasource/mongo/mongo.go b/datasource/mongo/mongo.go
index bbde3f4..d6c2a2c 100644
--- a/datasource/mongo/mongo.go
+++ b/datasource/mongo/mongo.go
@@ -82,7 +82,6 @@ func NewDataSource(opts datasource.Options)
(datasource.DataSource, error) {
inst.depManager = &DepManager{}
inst.sysManager = &SysManager{}
inst.metadataManager = &MetadataManager{
- SchemaNotEditable: opts.SchemaNotEditable,
InstanceTTL: opts.InstanceTTL,
InstanceProperties: opts.InstanceProperties,
}
diff --git a/datasource/mongo/ms.go b/datasource/mongo/ms.go
index fd8a837..286207b 100644
--- a/datasource/mongo/ms.go
+++ b/datasource/mongo/ms.go
@@ -55,14 +55,7 @@ import (
const baseTen = 10
-var (
- ErrUndefinedSchemaID =
discovery.NewError(discovery.ErrUndefinedSchemaID,
datasource.ErrUndefinedSchemaID.Error())
- ErrModifySchemaNotAllow =
discovery.NewError(discovery.ErrModifySchemaNotAllow,
datasource.ErrModifySchemaNotAllow.Error())
-)
-
type MetadataManager struct {
- // SchemaNotEditable determines whether schema modification is not
allowed
- SchemaNotEditable bool
// InstanceTTL options
InstanceTTL int64
InstanceProperties map[string]string
@@ -746,108 +739,56 @@ func (ds *MetadataManager) modifySchemas(ctx
context.Context, service *discovery
return discovery.NewError(discovery.ErrUnavailableBackend,
err.Error())
}
- needUpdateSchemas, needAddSchemas, needDeleteSchemas, nonExistSchemaIds
:=
+ needUpdateSchemas, needAddSchemas, needDeleteSchemas, _ :=
datasource.SchemasAnalysis(schemas, schemasFromDatabase,
service.Schemas)
var schemasOps []mongo.WriteModel
var serviceOps []mongo.WriteModel
- if !ds.isSchemaEditable() {
- if len(service.Schemas) == 0 {
- errQuota := quotasvc.ApplySchema(ctx, serviceID,
int64(len(nonExistSchemaIds)))
- if errQuota != nil {
- log.Error(fmt.Sprintf("modify service[%s]
schemas failed, operator: %s", serviceID, remoteIP), errQuota)
- return errQuota
- }
- filter = mutil.NewDomainProjectFilter(domain, project,
mutil.ServiceServiceID(serviceID))
- setFilter :=
mutil.NewFilter(mutil.ServiceSchemas(nonExistSchemaIds))
- updateFilter := mutil.NewFilter(mutil.Set(setFilter))
- serviceOps = append(serviceOps,
mongo.NewUpdateOneModel().SetUpdate(updateFilter).SetFilter(filter))
- } else {
- if len(nonExistSchemaIds) != 0 {
- errInfo := fmt.Errorf("non-existent schemaIDs
%v", nonExistSchemaIds)
- log.Error(fmt.Sprintf("modify service %s
schemas failed, operator: %s", serviceID, remoteIP), err)
- return
discovery.NewError(discovery.ErrUndefinedSchemaID, errInfo.Error())
- }
- for _, needUpdateSchema := range needUpdateSchemas {
- exist, err := dao.SchemaSummaryExist(ctx,
serviceID, needUpdateSchema.SchemaId)
- if err != nil {
- return
discovery.NewError(discovery.ErrInternal, err.Error())
- }
- if !exist {
- filter =
mutil.NewDomainProjectFilter(domain, project, mutil.ServiceID(serviceID),
mutil.SchemaID(needUpdateSchema.SchemaId))
- setFilter := mutil.NewFilter(
-
mutil.Schema(needUpdateSchema.Schema),
-
mutil.SchemaSummary(needUpdateSchema.Summary),
- )
- updateFilter := mutil.NewFilter(
- mutil.Set(setFilter),
- )
- schemasOps = append(schemasOps,
mongo.NewUpdateOneModel().SetFilter(filter).SetUpdate(updateFilter))
- } else {
- log.Warn(fmt.Sprintf("schema[%s/%s] and
it's summary already exist, skip to update, operator: %s",
- serviceID,
needUpdateSchema.SchemaId, remoteIP))
- }
- }
- }
+ quotaSize := len(needAddSchemas) - len(needDeleteSchemas)
+ if quotaSize > 0 {
+ errQuota := quotasvc.ApplySchema(ctx, serviceID,
int64(quotaSize))
+ if errQuota != nil {
+ log.Error(fmt.Sprintf("modify service[%s] schemas
failed, operator: %s", serviceID, remoteIP), errQuota)
+ return errQuota
+ }
+ }
+ 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(&model.Schema{
+ Domain: domain,
+ Project: project,
+ ServiceID: serviceID,
+ SchemaID: schema.SchemaId,
+ Schema: schema.Schema,
+ SchemaSummary: schema.Summary,
+ }))
+ schemaIDs = append(schemaIDs, schema.SchemaId)
+ }
+
+ for _, schema := range needUpdateSchemas {
+ log.Info(fmt.Sprintf("update schema[%s/%s], operator: %s",
serviceID, schema.SchemaId, remoteIP))
+ filter := mutil.NewDomainProjectFilter(domain, project,
mutil.ServiceID(serviceID), mutil.SchemaID(schema.SchemaId))
+ setFilter := mutil.NewFilter(
+ mutil.Schema(schema.Schema),
+ mutil.SchemaSummary(schema.Summary),
+ )
+ updateFilter := mutil.NewFilter(
+ mutil.Set(setFilter),
+ )
+ schemasOps = append(schemasOps,
mongo.NewUpdateOneModel().SetFilter(filter).SetUpdate(updateFilter))
+ schemaIDs = append(schemaIDs, schema.SchemaId)
+ }
- for _, schema := range needAddSchemas {
- log.Info(fmt.Sprintf("add new schema[%s/%s], operator:
%s", serviceID, schema.SchemaId, remoteIP))
- schemasOps = append(schemasOps,
mongo.NewInsertOneModel().SetDocument(&model.Schema{
- Domain: domain,
- Project: project,
- ServiceID: serviceID,
- SchemaID: schema.SchemaId,
- Schema: schema.Schema,
- SchemaSummary: schema.Summary,
- }))
- }
- } else {
- quotaSize := len(needAddSchemas) - len(needDeleteSchemas)
- if quotaSize > 0 {
- errQuota := quotasvc.ApplySchema(ctx, serviceID,
int64(quotaSize))
- if errQuota != nil {
- log.Error(fmt.Sprintf("modify service[%s]
schemas failed, operator: %s", serviceID, remoteIP), errQuota)
- return errQuota
- }
- }
- 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(&model.Schema{
- Domain: domain,
- Project: project,
- ServiceID: serviceID,
- SchemaID: schema.SchemaId,
- Schema: schema.Schema,
- SchemaSummary: schema.Summary,
- }))
- schemaIDs = append(schemaIDs, schema.SchemaId)
- }
-
- for _, schema := range needUpdateSchemas {
- log.Info(fmt.Sprintf("update schema[%s/%s], operator:
%s", serviceID, schema.SchemaId, remoteIP))
- filter = mutil.NewDomainProjectFilter(domain, project,
mutil.ServiceID(serviceID), mutil.SchemaID(schema.SchemaId))
- setFilter := mutil.NewFilter(
- mutil.Schema(schema.Schema),
- mutil.SchemaSummary(schema.Summary),
- )
- updateFilter := mutil.NewFilter(
- mutil.Set(setFilter),
- )
- schemasOps = append(schemasOps,
mongo.NewUpdateOneModel().SetFilter(filter).SetUpdate(updateFilter))
- schemaIDs = append(schemaIDs, schema.SchemaId)
- }
-
- for _, schema := range needDeleteSchemas {
- log.Info(fmt.Sprintf("delete non-existent
schema[%s/%s], operator: %s", serviceID, schema.SchemaId, remoteIP))
- filter := mutil.NewDomainProjectFilter(domain, project,
mutil.ServiceID(serviceID), mutil.SchemaID(schema.SchemaId))
- schemasOps = append(schemasOps,
mongo.NewDeleteOneModel().SetFilter(filter))
- }
- filter := mutil.NewDomainProjectFilter(domain, project,
mutil.ServiceServiceID(serviceID))
- setFilter := mutil.NewFilter(mutil.ServiceSchemas(schemaIDs))
- updateFilter := mutil.NewFilter(mutil.Set(setFilter))
- serviceOps = append(serviceOps,
mongo.NewUpdateOneModel().SetUpdate(updateFilter).SetFilter(filter))
+ for _, schema := range needDeleteSchemas {
+ log.Info(fmt.Sprintf("delete non-existent schema[%s/%s],
operator: %s", serviceID, schema.SchemaId, remoteIP))
+ filter := mutil.NewDomainProjectFilter(domain, project,
mutil.ServiceID(serviceID), mutil.SchemaID(schema.SchemaId))
+ schemasOps = append(schemasOps,
mongo.NewDeleteOneModel().SetFilter(filter))
}
+ filter = mutil.NewDomainProjectFilter(domain, project,
mutil.ServiceServiceID(serviceID))
+ setFilter := mutil.NewFilter(mutil.ServiceSchemas(schemaIDs))
+ updateFilter := mutil.NewFilter(mutil.Set(setFilter))
+ serviceOps = append(serviceOps,
mongo.NewUpdateOneModel().SetUpdate(updateFilter).SetFilter(filter))
if len(schemasOps) > 0 {
_, err =
dmongo.GetClient().GetDB().Collection(model.CollectionSchema).BulkWrite(ctx,
schemasOps)
if err != nil {
@@ -871,7 +812,6 @@ func (ds *MetadataManager) modifySchemas(ctx
context.Context, service *discovery
func (ds *MetadataManager) modifySchema(ctx context.Context, serviceID string,
schema *discovery.Schema) *errsvc.Error {
domain := util.ParseDomain(ctx)
project := util.ParseProject(ctx)
- remoteIP := util.GetIPFromContext(ctx)
svc, err := GetServiceByID(ctx, serviceID)
if err != nil {
if errors.Is(err, datasource.ErrNoData) {
@@ -888,35 +828,8 @@ func (ds *MetadataManager) modifySchema(ctx
context.Context, serviceID string, s
}
}
var newSchemas []string
- if !ds.isSchemaEditable() {
- if len(microservice.Schemas) != 0 && !isExist {
- return ErrUndefinedSchemaID
- }
- filter := mutil.NewDomainProjectFilter(domain, project,
mutil.ServiceID(serviceID), mutil.SchemaID(schema.SchemaId))
- respSchema, err := dao.GetSchema(ctx, filter)
- if err != nil {
- return
discovery.NewError(discovery.ErrUnavailableBackend, err.Error())
- }
- if respSchema != nil {
- if len(schema.Summary) == 0 {
- log.Error(fmt.Sprintf("modify schema %s %s
failed, get schema summary failed, operator: %s",
- serviceID, schema.SchemaId, remoteIP),
err)
- return ErrModifySchemaNotAllow
- }
- if len(respSchema.SchemaSummary) != 0 {
- log.Error(fmt.Sprintf("mode, schema %s %s
already exist, can not be changed, operator: %s",
- serviceID, schema.SchemaId, remoteIP),
err)
- return ErrModifySchemaNotAllow
- }
- }
- if len(microservice.Schemas) == 0 {
- copy(newSchemas, microservice.Schemas)
- newSchemas = append(newSchemas, schema.SchemaId)
- }
- } else {
- if !isExist {
- newSchemas = append(microservice.Schemas,
schema.SchemaId)
- }
+ if !isExist {
+ newSchemas = append(microservice.Schemas, schema.SchemaId)
}
if len(newSchemas) != 0 {
filter := mutil.NewDomainProjectFilter(domain, project,
mutil.ServiceServiceID(serviceID))
@@ -944,10 +857,6 @@ func (ds *MetadataManager) modifySchema(ctx
context.Context, serviceID string, s
return nil
}
-func (ds *MetadataManager) isSchemaEditable() bool {
- return !ds.SchemaNotEditable
-}
-
func getServiceDetailUtil(ctx context.Context, mgs *model.Service, countOnly
bool, options []string) (*discovery.ServiceDetail, error) {
serviceDetail := new(discovery.ServiceDetail)
serviceID := mgs.Service.ServiceId
diff --git a/datasource/options.go b/datasource/options.go
index e9ce0d7..be36aa4 100644
--- a/datasource/options.go
+++ b/datasource/options.go
@@ -25,8 +25,7 @@ import (
type Options struct {
etcdadpt.Config
- EnableCache bool
- SchemaNotEditable bool
+ EnableCache bool
// InstanceTTL: the default ttl of instance lease
InstanceTTL int64
InstanceProperties map[string]string
diff --git a/datasource/schema_test.go b/datasource/schema_test.go
index 93f97c5..8a7e8e6 100644
--- a/datasource/schema_test.go
+++ b/datasource/schema_test.go
@@ -22,36 +22,13 @@ import (
"testing"
"github.com/apache/servicecomb-service-center/datasource"
- "github.com/apache/servicecomb-service-center/datasource/etcd"
- "github.com/apache/servicecomb-service-center/datasource/mongo"
"github.com/apache/servicecomb-service-center/pkg/log"
quotasvc
"github.com/apache/servicecomb-service-center/server/service/quota"
pb "github.com/go-chassis/cari/discovery"
"github.com/go-chassis/cari/pkg/errsvc"
- "github.com/go-chassis/go-archaius"
- "github.com/little-cui/etcdadpt"
"github.com/stretchr/testify/assert"
)
-func genLocalDatasource(editable bool) datasource.DataSource {
- t := archaius.Get("TEST_MODE")
- if t == nil {
- t = "etcd"
- }
- if t == "etcd" {
- ds, _ := etcd.NewDataSource(datasource.Options{
- Config: etcdadpt.Config{Kind: "etcd"},
- SchemaNotEditable: !editable,
- })
-
- return ds
- }
- ds, _ := mongo.NewDataSource(datasource.Options{
- SchemaNotEditable: !editable,
- })
- return ds
-}
-
func TestSchema_Create(t *testing.T) {
var (
serviceIdDev string
@@ -426,20 +403,8 @@ func TestSchema_Create(t *testing.T) {
Summary: "second0summary_ms",
},
}
- log.Info("schema edit not allowed, add a schema with new
schemaId should fail")
-
- localMicroServiceDs :=
genLocalDatasource(false).MetadataManager()
- _, err = localMicroServiceDs.ModifySchemas(getContext(),
&pb.ModifySchemasRequest{
- ServiceId: serviceIdPro1,
- Schemas: schemas,
- })
- testErr := err.(*errsvc.Error)
- assert.Error(t, testErr)
- assert.Equal(t, pb.ErrUndefinedSchemaID, testErr.Code)
-
log.Info("schema edit allowed, add a schema with new schemaId,
should pass")
- localMicroServiceDs = genLocalDatasource(true).MetadataManager()
- _, err = localMicroServiceDs.ModifySchemas(getContext(),
&pb.ModifySchemasRequest{
+ _, err =
datasource.GetMetadataManager().ModifySchemas(getContext(),
&pb.ModifySchemasRequest{
ServiceId: serviceIdPro1,
Schemas: schemas,
})
@@ -484,21 +449,8 @@ func TestSchema_Create(t *testing.T) {
assert.NoError(t, err)
assert.Equal(t, []string{"first_schemaId_ms"}, service.Schemas)
- log.Info("schema edit not allowed, modify schema should fail")
- localMicroServiceDs :=
genLocalDatasource(false).MetadataManager()
- _, err = localMicroServiceDs.ModifySchema(getContext(),
&pb.ModifySchemaRequest{
- ServiceId: serviceIdPro1,
- SchemaId: schemas[0].SchemaId,
- Summary: schemas[0].Summary,
- Schema: schemas[0].SchemaId,
- })
- testErr := err.(*errsvc.Error)
- assert.Error(t, testErr)
- assert.Equal(t, pb.ErrModifySchemaNotAllow, testErr.Code)
-
log.Info("schema edit allowed, add a schema with new schemaId,
should pass")
- localMicroServiceDs = genLocalDatasource(true).MetadataManager()
- _, err = localMicroServiceDs.ModifySchema(getContext(),
&pb.ModifySchemaRequest{
+ _, err =
datasource.GetMetadataManager().ModifySchema(getContext(),
&pb.ModifySchemaRequest{
ServiceId: serviceIdPro1,
SchemaId: schemas[0].SchemaId,
Summary: schemas[0].Summary,
diff --git a/etc/conf/app.yaml b/etc/conf/app.yaml
index f822961..94b940c 100644
--- a/etc/conf/app.yaml
+++ b/etc/conf/app.yaml
@@ -151,8 +151,6 @@ registry:
schema:
# if want disable Test Schema, SchemaDisable set true
disable: false
- # if want disable modification of Schema, SchemaNotEditable set true
- notEditable: false
# remove the schema without refs every 7d
retire:
cron: '0 2 * * *'
diff --git a/examples/dev/conf/app.yaml b/examples/dev/conf/app.yaml
index 2e4a585..2c1853d 100644
--- a/examples/dev/conf/app.yaml
+++ b/examples/dev/conf/app.yaml
@@ -135,8 +135,6 @@ registry:
schema:
# if want disable Test Schema, SchemaDisable set true
disable: false
- # if want disable modification of Schema, SchemaNotEditable set true
- notEditable: false
# enable to register sc itself when startup
selfRegister: 1
diff --git a/server/config/config.go b/server/config/config.go
index 5568dc6..786589a 100644
--- a/server/config/config.go
+++ b/server/config/config.go
@@ -175,8 +175,7 @@ func loadServerConfig() ServerConfig {
GlobalVisible:
GetString("registry.service.globalVisible", "", WithENV("CSE_SHARED_SERVICES")),
InstanceTTL: GetInt64("registry.instance.ttl", 0,
WithENV("INSTANCE_TTL")),
- SchemaDisable: GetBool("registry.schema.disable",
false, WithENV("SCHEMA_DISABLE")),
- SchemaNotEditable:
GetBool("registry.schema.notEditable", false, WithENV("SCHEMA_NOT_EDITABLE")),
+ SchemaDisable: GetBool("registry.schema.disable",
false, WithENV("SCHEMA_DISABLE")),
EnableRBAC: GetBool("rbac.enable", false,
WithStandby("rbac_enabled")),
},
diff --git a/server/config/server.go b/server/config/server.go
index c8c8a7f..8091697 100644
--- a/server/config/server.go
+++ b/server/config/server.go
@@ -70,8 +70,6 @@ type ServerConfigDetail struct {
// if want disable Test Schema, SchemaDisable set true
SchemaDisable bool `json:"schemaDisable"`
- // if want disable modification of Schema, SchemaNotEditable set true
- SchemaNotEditable bool `json:"-"`
// instance ttl in seconds
InstanceTTL int64 `json:"-"`
diff --git a/server/core/microservice.go b/server/core/microservice.go
index b104c38..ebb04d4 100644
--- a/server/core/microservice.go
+++ b/server/core/microservice.go
@@ -53,10 +53,6 @@ func InitRegistration() {
Version: version.Ver().Version,
Status: discovery.MS_UP,
Level: "BACK",
- Schemas: []string{
- "servicecenter.grpc.api.ServiceCtrl",
- "servicecenter.grpc.api.ServiceInstanceCtrl",
- },
Properties: map[string]string{
discovery.PropAllowCrossApp: "true",
},
diff --git a/server/server.go b/server/server.go
index fe7672c..34d63dd 100644
--- a/server/server.go
+++ b/server/server.go
@@ -122,7 +122,6 @@ func (s *ServiceCenterServer) initDatasource() {
},
},
EnableCache: config.GetRegistry().EnableCache,
- SchemaNotEditable: config.GetRegistry().SchemaNotEditable,
InstanceTTL: config.GetRegistry().InstanceTTL,
InstanceProperties:
config.GetStringMap("registry.instance.properties"),
}); err != nil {
