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/08/02 12:50:25 UTC
[servicecomb-service-center] branch master updated: Change: Remove
RULE management (#1124)
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 3197131 Change: Remove RULE management (#1124)
3197131 is described below
commit 31971311e7c870e1261abff14e5ecbc9f3fd8084
Author: little-cui <su...@qq.com>
AuthorDate: Mon Aug 2 20:50:18 2021 +0800
Change: Remove RULE management (#1124)
---
datasource/cache/ms_cache.go | 25 -
datasource/etcd/event/event.go | 1 -
datasource/etcd/event/instance_event_handler.go | 2 +-
datasource/etcd/event/rule_event_handler.go | 129 ----
datasource/etcd/kv/kv.go | 2 -
datasource/etcd/kv/types.go | 8 -
datasource/etcd/ms.go | 330 +--------
datasource/etcd/sd/servicecenter/aggregate.go | 2 -
datasource/etcd/sd/servicecenter/syncer.go | 8 -
datasource/etcd/system.go | 2 -
datasource/etcd/util.go | 10 -
datasource/etcd/util/dependency_test.go | 7 -
datasource/etcd/util/dependency_util.go | 70 --
datasource/etcd/util/rule_util.go | 222 +-----
datasource/etcd/util/rule_util_test.go | 200 +-----
datasource/mongo/client/dao/rule.go | 93 ---
datasource/mongo/client/dao/schema.go | 10 +
datasource/mongo/client/model/types.go | 14 -
datasource/mongo/db.go | 8 -
datasource/mongo/dep_util.go | 33 +-
datasource/mongo/event/instance_event_handler.go | 2 +-
datasource/mongo/ms.go | 328 +--------
datasource/mongo/rule_util.go | 84 ---
datasource/mongo/rule_util_test.go | 55 --
datasource/mongo/sd/rule_cache.go | 163 -----
datasource/mongo/sd/types.go | 1 -
datasource/mongo/sd/typestore.go | 1 -
datasource/mongo/util/db.go | 36 -
datasource/ms.go | 6 -
datasource/rule_test.go | 554 ---------------
docs/openapi/v4.yaml | 162 -----
etc/conf/app.yaml | 2 -
integration/rules_test.go | 527 ---------------
pkg/dump/dump.go | 45 +-
pkg/proto/service.go | 4 -
server/plugin/quota/buildin/buildin.go | 6 +-
server/plugin/quota/quota.go | 10 +-
server/rest/controller/v3/query_rule_controller.go | 37 -
server/rest/controller/v3/v3.go | 1 -
server/rest/controller/v4/query_rule_controller.go | 118 ----
server/rest/controller/v4/v4.go | 1 -
server/service/disco/microservice.go | 22 +-
server/service/disco/microservice_test.go | 9 +-
server/service/disco/rule.go | 80 ---
server/service/disco/rule_test.go | 750 ---------------------
server/service/disco/tag_test.go | 50 +-
server/service/quota/quota.go | 10 -
server/service/validator/rule_validator.go | 72 --
server/service/validator/validator.go | 8 -
49 files changed, 40 insertions(+), 4280 deletions(-)
diff --git a/datasource/cache/ms_cache.go b/datasource/cache/ms_cache.go
index d9a2f1e..5325546 100644
--- a/datasource/cache/ms_cache.go
+++ b/datasource/cache/ms_cache.go
@@ -84,31 +84,6 @@ func transCacheToInsts(cache []interface{}) ([]*discovery.MicroServiceInstance,
return res, true
}
-func GetRulesByServiceID(serviceID string) ([]*model.Rule, bool) {
- cacheRes := sd.Store().Rule().Cache().GetValue(serviceID)
- return transCacheToRules(cacheRes)
-}
-
-func transCacheToRules(cacheRules []interface{}) ([]*model.Rule, bool) {
- res := make([]*model.Rule, 0, len(cacheRules))
- for _, v := range cacheRules {
- t, ok := v.(model.Rule)
- if !ok {
- return nil, false
- }
- res = append(res, &model.Rule{
- Domain: t.Domain,
- Project: t.Project,
- ServiceID: t.ServiceID,
- Rule: t.Rule,
- })
- }
- if len(res) == 0 {
- return nil, false
- }
- return res, true
-}
-
func GetServiceByID(ctx context.Context, serviceID string) (*model.Service, bool) {
if util.NoCache(ctx) {
return nil, false
diff --git a/datasource/etcd/event/event.go b/datasource/etcd/event/event.go
index 92c00fa..30a32a2 100644
--- a/datasource/etcd/event/event.go
+++ b/datasource/etcd/event/event.go
@@ -24,7 +24,6 @@ import (
func Initialize() {
sd.AddEventHandler(NewServiceEventHandler())
sd.AddEventHandler(NewInstanceEventHandler())
- sd.AddEventHandler(NewRuleEventHandler())
sd.AddEventHandler(NewTagEventHandler())
sd.AddEventHandler(NewDependencyEventHandler())
sd.AddEventHandler(NewDependencyRuleEventHandler())
diff --git a/datasource/etcd/event/instance_event_handler.go b/datasource/etcd/event/instance_event_handler.go
index ce7f9a1..93d1bd5 100644
--- a/datasource/etcd/event/instance_event_handler.go
+++ b/datasource/etcd/event/instance_event_handler.go
@@ -95,7 +95,7 @@ func (h *InstanceEventHandler) OnEvent(evt sd.KvEvent) {
providerInstanceID, instance.Endpoints)
// 查询所有consumer
- consumerIDs, _, err := serviceUtil.GetAllConsumerIds(ctx, domainProject, ms)
+ consumerIDs, err := serviceUtil.GetConsumerIds(ctx, domainProject, ms)
if err != nil {
log.Errorf(err, "get service[%s][%s/%s/%s/%s]'s consumerIDs failed",
providerID, ms.Environment, ms.AppId, ms.ServiceName, ms.Version)
diff --git a/datasource/etcd/event/rule_event_handler.go b/datasource/etcd/event/rule_event_handler.go
deleted file mode 100644
index 9955f23..0000000
--- a/datasource/etcd/event/rule_event_handler.go
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
- * 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 event
-
-import (
- "context"
- "errors"
- "fmt"
-
- pb "github.com/go-chassis/cari/discovery"
-
- "github.com/apache/servicecomb-service-center/datasource"
- "github.com/apache/servicecomb-service-center/datasource/etcd/kv"
- "github.com/apache/servicecomb-service-center/datasource/etcd/path"
- "github.com/apache/servicecomb-service-center/datasource/etcd/sd"
- serviceUtil "github.com/apache/servicecomb-service-center/datasource/etcd/util"
- "github.com/apache/servicecomb-service-center/pkg/log"
- "github.com/apache/servicecomb-service-center/pkg/task"
- "github.com/apache/servicecomb-service-center/pkg/util"
- "github.com/apache/servicecomb-service-center/server/event"
-)
-
-type RulesChangedTask struct {
- sd.KvEvent
-
- key string
- err error
-
- DomainProject string
- ProviderID string
-}
-
-func (apt *RulesChangedTask) Key() string {
- return apt.key
-}
-
-func (apt *RulesChangedTask) Do(ctx context.Context) error {
- apt.err = apt.publish(ctx, apt.DomainProject, apt.ProviderID)
- return apt.err
-}
-
-func (apt *RulesChangedTask) Err() error {
- return apt.err
-}
-
-func (apt *RulesChangedTask) publish(ctx context.Context, domainProject, providerID string) error {
- ctx = util.WithGlobal(util.WithCacheOnly(ctx))
-
- provider, err := serviceUtil.GetService(ctx, domainProject, providerID)
- if err != nil {
- if errors.Is(err, datasource.ErrNoData) {
- log.Debug(fmt.Sprintf("provider[%s] does not exist", providerID))
- } else {
- log.Error(fmt.Sprintf("get provider[%s] service file failed", providerID), err)
- }
- return err
- }
-
- consumerIds, err := serviceUtil.GetConsumerIds(ctx, domainProject, provider)
- if err != nil {
- log.Errorf(err, "get service[%s][%s/%s/%s/%s]'s consumerIds failed",
- providerID, provider.Environment, provider.AppId, provider.ServiceName, provider.Version)
- return err
- }
- providerKey := pb.MicroServiceToKey(domainProject, provider)
-
- PublishInstanceEvent(apt.KvEvent, domainProject, providerKey, consumerIds)
- return nil
-}
-
-// RuleEventHandler is the handler to handle:
-// 1. publish the EVT_EXPIRE event to subscribers when rule is changed
-// 2. reset the find instance cache
-type RuleEventHandler struct {
-}
-
-func (h *RuleEventHandler) Type() sd.Type {
- return kv.RULE
-}
-
-func (h *RuleEventHandler) OnEvent(evt sd.KvEvent) {
- action := evt.Type
- if action == pb.EVT_INIT {
- return
- }
-
- providerID, ruleID, domainProject := path.GetInfoFromRuleKV(evt.KV.Key)
- if event.Center().Closed() {
- log.Warnf("caught [%s] service rule[%s/%s] event, but notify service is closed",
- action, providerID, ruleID)
- return
- }
- log.Infof("caught [%s] service rule[%s/%s] event", action, providerID, ruleID)
-
- err := task.GetService().Add(context.Background(),
- NewRulesChangedAsyncTask(domainProject, providerID, evt))
- if err != nil {
- log.Error("", err)
- }
-}
-
-func NewRuleEventHandler() *RuleEventHandler {
- return &RuleEventHandler{}
-}
-
-func NewRulesChangedAsyncTask(domainProject, providerID string, evt sd.KvEvent) *RulesChangedTask {
- evt.Type = pb.EVT_EXPIRE
- return &RulesChangedTask{
- KvEvent: evt,
- key: "RulesChangedAsyncTask_" + providerID,
- DomainProject: domainProject,
- ProviderID: providerID,
- }
-}
diff --git a/datasource/etcd/kv/kv.go b/datasource/etcd/kv/kv.go
index 0a22207..74884ea 100644
--- a/datasource/etcd/kv/kv.go
+++ b/datasource/etcd/kv/kv.go
@@ -183,8 +183,6 @@ func (s *TypeStore) Lease() sd.Adaptor { return s.Adaptors(LEASE) }
func (s *TypeStore) ServiceIndex() sd.Adaptor { return s.Adaptors(ServiceIndex) }
func (s *TypeStore) ServiceAlias() sd.Adaptor { return s.Adaptors(ServiceAlias) }
func (s *TypeStore) ServiceTag() sd.Adaptor { return s.Adaptors(ServiceTag) }
-func (s *TypeStore) Rule() sd.Adaptor { return s.Adaptors(RULE) }
-func (s *TypeStore) RuleIndex() sd.Adaptor { return s.Adaptors(RuleIndex) }
func (s *TypeStore) Schema() sd.Adaptor { return s.Adaptors(SCHEMA) }
func (s *TypeStore) DependencyRule() sd.Adaptor { return s.Adaptors(DependencyRule) }
func (s *TypeStore) DependencyQueue() sd.Adaptor { return s.Adaptors(DependencyQueue) }
diff --git a/datasource/etcd/kv/types.go b/datasource/etcd/kv/types.go
index 752c464..e6f0829 100644
--- a/datasource/etcd/kv/types.go
+++ b/datasource/etcd/kv/types.go
@@ -40,8 +40,6 @@ var (
ServiceIndex sd.Type
ServiceAlias sd.Type
ServiceTag sd.Type
- RULE sd.Type
- RuleIndex sd.Type
DependencyRule sd.Type
DependencyQueue sd.Type
SCHEMA sd.Type
@@ -67,9 +65,6 @@ func registerInnerTypes() {
SchemaSummary = Store().MustInstall(NewAddOn("SCHEMA_SUMMARY",
sd.Configure().WithPrefix(path.GetServiceSchemaSummaryRootKey("")).
WithInitSize(100).WithParser(value.StringParser)))
- RULE = Store().MustInstall(NewAddOn("RULE",
- sd.Configure().WithPrefix(path.GetServiceRuleRootKey("")).
- WithInitSize(100).WithParser(value.RuleParser)))
LEASE = Store().MustInstall(NewAddOn("LEASE",
sd.Configure().WithPrefix(path.GetInstanceLeaseRootKey("")).
WithInitSize(1000).WithParser(value.StringParser)))
@@ -82,9 +77,6 @@ func registerInnerTypes() {
ServiceTag = Store().MustInstall(NewAddOn("SERVICE_TAG",
sd.Configure().WithPrefix(path.GetServiceTagRootKey("")).
WithInitSize(100).WithParser(value.MapParser)))
- RuleIndex = Store().MustInstall(NewAddOn("RULE_INDEX",
- sd.Configure().WithPrefix(path.GetServiceRuleIndexRootKey("")).
- WithInitSize(100).WithParser(value.StringParser)))
DependencyRule = Store().MustInstall(NewAddOn("DEPENDENCY_RULE",
sd.Configure().WithPrefix(path.GetServiceDependencyRuleRootKey("")).
WithInitSize(100).WithParser(value.DependencyRuleParser)))
diff --git a/datasource/etcd/ms.go b/datasource/etcd/ms.go
index e2b4d52..40f112f 100644
--- a/datasource/etcd/ms.go
+++ b/datasource/etcd/ms.go
@@ -243,7 +243,7 @@ func (ds *MetadataManager) GetServiceDetail(ctx context.Context, request *pb.Get
}, err
}
- options := []string{"tags", "rules", "instances", "schemas", "dependencies"}
+ options := []string{"tags", "instances", "schemas", "dependencies"}
serviceInfo, err := getServiceDetailUtil(ctx, ServiceDetailOpt{
domainProject: domainProject,
service: service,
@@ -275,7 +275,7 @@ func (ds *MetadataManager) GetServicesInfo(ctx context.Context, request *pb.GetS
options := make([]string, 0, len(optionMap))
if _, ok := optionMap["all"]; ok {
optionMap["statistics"] = struct{}{}
- options = []string{"tags", "rules", "instances", "schemas", "dependencies"}
+ options = []string{"tags", "instances", "schemas", "dependencies"}
} else {
for opt := range optionMap {
options = append(options, opt)
@@ -1824,332 +1824,6 @@ func (ds *MetadataManager) DeleteTags(ctx context.Context, request *pb.DeleteSer
}, nil
}
-func (ds *MetadataManager) AddRule(ctx context.Context, request *pb.AddServiceRulesRequest) (
- *pb.AddServiceRulesResponse, error) {
- remoteIP := util.GetIPFromContext(ctx)
- domainProject := util.ParseDomainProject(ctx)
-
- // service id存在性校验
- if !serviceUtil.ServiceExist(ctx, domainProject, request.ServiceId) {
- log.Errorf(nil, "add service[%s] rule failed, service does not exist, operator: %s",
- request.ServiceId, remoteIP)
- return &pb.AddServiceRulesResponse{
- Response: pb.CreateResponse(pb.ErrInvalidParams, "Service does not exist."),
- }, nil
- }
- res := quota.NewApplyQuotaResource(quota.TypeRule, domainProject, request.ServiceId, int64(len(request.Rules)))
- errQuota := quota.Apply(ctx, res)
- if errQuota != nil {
- log.Errorf(errQuota, "add service[%s] rule failed, operator: %s", request.ServiceId, remoteIP)
- response := &pb.AddServiceRulesResponse{
- Response: pb.CreateResponseWithSCErr(errQuota),
- }
- if errQuota.InternalError() {
- return response, errQuota
- }
- return response, nil
- }
-
- ruleType, _, err := serviceUtil.GetServiceRuleType(ctx, domainProject, request.ServiceId)
- if err != nil {
- return &pb.AddServiceRulesResponse{
- Response: pb.CreateResponse(pb.ErrInternal, err.Error()),
- }, err
- }
- ruleIDs := make([]string, 0, len(request.Rules))
- opts := make([]client.PluginOp, 0, 2*len(request.Rules))
- for _, rule := range request.Rules {
- //黑白名单只能存在一种，黑名单 or 白名单
- if len(ruleType) == 0 {
- ruleType = rule.RuleType
- } else if ruleType != rule.RuleType {
- log.Errorf(nil,
- "add service[%s] rule failed, can not add different RuleType at the same time, operator: %s",
- request.ServiceId, remoteIP)
- return &pb.AddServiceRulesResponse{
- Response: pb.CreateResponse(pb.ErrBlackAndWhiteRule,
- "Service can only contain one rule type, BLACK or WHITE."),
- }, nil
-
- }
-
- //同一服务，attribute和pattern确定一个rule
- if serviceUtil.RuleExist(ctx, domainProject, request.ServiceId, rule.Attribute, rule.Pattern) {
- log.Infof("service[%s] rule[%s/%s] already exists, operator: %s",
- request.ServiceId, rule.Attribute, rule.Pattern, remoteIP)
- continue
- }
-
- // 产生全局rule id
- timestamp := strconv.FormatInt(time.Now().Unix(), 10)
- ruleAdd := &pb.ServiceRule{
- RuleId: util.GenerateUUID(),
- RuleType: rule.RuleType,
- Attribute: rule.Attribute,
- Pattern: rule.Pattern,
- Description: rule.Description,
- Timestamp: timestamp,
- ModTimestamp: timestamp,
- }
-
- key := path.GenerateServiceRuleKey(domainProject, request.ServiceId, ruleAdd.RuleId)
- indexKey := path.GenerateRuleIndexKey(domainProject, request.ServiceId, ruleAdd.Attribute, ruleAdd.Pattern)
- ruleIDs = append(ruleIDs, ruleAdd.RuleId)
-
- data, err := json.Marshal(ruleAdd)
- if err != nil {
- log.Errorf(err, "add service[%s] rule failed, marshal rule[%s/%s] failed, operator: %s",
- request.ServiceId, ruleAdd.Attribute, ruleAdd.Pattern, remoteIP)
- return &pb.AddServiceRulesResponse{
- Response: pb.CreateResponse(pb.ErrInternal, err.Error()),
- }, err
- }
-
- opts = append(opts, client.OpPut(client.WithStrKey(key), client.WithValue(data)))
- opts = append(opts, client.OpPut(client.WithStrKey(indexKey), client.WithStrValue(ruleAdd.RuleId)))
- }
- if len(opts) <= 0 {
- log.Infof("add service[%s] rule successfully, no rules to add, operator: %s",
- request.ServiceId, remoteIP)
- return &pb.AddServiceRulesResponse{
- Response: pb.CreateResponse(pb.ResponseSuccess, "Service rules has been added."),
- }, nil
- }
-
- resp, err := client.BatchCommitWithCmp(ctx, opts,
- []client.CompareOp{client.OpCmp(
- client.CmpVer(util.StringToBytesWithNoCopy(path.GenerateServiceKey(domainProject, request.ServiceId))),
- client.CmpNotEqual, 0)},
- nil)
- if err != nil {
- log.Errorf(err, "add service[%s] rule failed, operator: %s", request.ServiceId, remoteIP)
- return &pb.AddServiceRulesResponse{
- Response: pb.CreateResponse(pb.ErrUnavailableBackend, err.Error()),
- }, err
- }
- if !resp.Succeeded {
- log.Errorf(nil, "add service[%s] rule failed, service does not exist, operator: %s",
- request.ServiceId, remoteIP)
- return &pb.AddServiceRulesResponse{
- Response: pb.CreateResponse(pb.ErrServiceNotExists, "Service does not exist."),
- }, nil
- }
-
- log.Infof("add service[%s] rule %v successfully, operator: %s", request.ServiceId, ruleIDs, remoteIP)
- return &pb.AddServiceRulesResponse{
- Response: pb.CreateResponse(pb.ResponseSuccess, "Add service rules successfully."),
- RuleIds: ruleIDs,
- }, nil
-}
-
-func (ds *MetadataManager) GetRules(ctx context.Context, request *pb.GetServiceRulesRequest) (
- *pb.GetServiceRulesResponse, error) {
- domainProject := util.ParseDomainProject(ctx)
-
- // service id存在性校验
- if !serviceUtil.ServiceExist(ctx, domainProject, request.ServiceId) {
- log.Errorf(nil, "get service[%s] rule failed, service does not exist", request.ServiceId)
- return &pb.GetServiceRulesResponse{
- Response: pb.CreateResponse(pb.ErrServiceNotExists, "Service does not exist."),
- }, nil
- }
-
- rules, err := serviceUtil.GetRulesUtil(ctx, domainProject, request.ServiceId)
- if err != nil {
- log.Errorf(err, "get service[%s] rule failed", request.ServiceId)
- return &pb.GetServiceRulesResponse{
- Response: pb.CreateResponse(pb.ErrInternal, err.Error()),
- }, err
- }
-
- return &pb.GetServiceRulesResponse{
- Response: pb.CreateResponse(pb.ResponseSuccess, "Get service rules successfully."),
- Rules: rules,
- }, nil
-}
-
-func (ds *MetadataManager) UpdateRule(ctx context.Context, request *pb.UpdateServiceRuleRequest) (
- *pb.UpdateServiceRuleResponse, error) {
- remoteIP := util.GetIPFromContext(ctx)
- domainProject := util.ParseDomainProject(ctx)
-
- // service id存在性校验
- if !serviceUtil.ServiceExist(ctx, domainProject, request.ServiceId) {
- log.Errorf(nil, "update service rule[%s/%s] failed, service does not exist, operator: %s",
- request.ServiceId, request.RuleId, remoteIP)
- return &pb.UpdateServiceRuleResponse{
- Response: pb.CreateResponse(pb.ErrServiceNotExists, "Service does not exist."),
- }, nil
- }
-
- //是否能改变ruleType
- ruleType, ruleNum, err := serviceUtil.GetServiceRuleType(ctx, domainProject, request.ServiceId)
- if err != nil {
- log.Errorf(err, "update service rule[%s/%s] failed, get rule type failed, operator: %s",
- request.ServiceId, request.RuleId, remoteIP)
- return &pb.UpdateServiceRuleResponse{
- Response: pb.CreateResponse(pb.ErrInternal, err.Error()),
- }, err
- }
- if ruleNum >= 1 && ruleType != request.Rule.RuleType {
- log.Errorf(err, "update service rule[%s/%s] failed, can only exist one type, current type is %s, operator: %s",
- request.ServiceId, request.RuleId, ruleType, remoteIP)
- return &pb.UpdateServiceRuleResponse{
- Response: pb.CreateResponse(pb.ErrModifyRuleNotAllow, "Exist multiple rules,can not change rule type. Rule type is "+ruleType),
- }, nil
- }
-
- rule, err := serviceUtil.GetOneRule(ctx, domainProject, request.ServiceId, request.RuleId)
- if err != nil {
- log.Errorf(err, "update service rule[%s/%s] failed, query service rule failed, operator: %s",
- request.ServiceId, request.RuleId, remoteIP)
- return &pb.UpdateServiceRuleResponse{
- Response: pb.CreateResponse(pb.ErrInternal, err.Error()),
- }, err
- }
- if rule == nil {
- log.Errorf(err, "update service rule[%s/%s] failed, service rule does not exist, operator: %s",
- request.ServiceId, request.RuleId, remoteIP)
- return &pb.UpdateServiceRuleResponse{
- Response: pb.CreateResponse(pb.ErrRuleNotExists, "This rule does not exist."),
- }, nil
- }
-
- copyRuleRef := *rule
- oldRulePatten := copyRuleRef.Pattern
- oldRuleAttr := copyRuleRef.Attribute
- isChangeIndex := false
- if copyRuleRef.Attribute != request.Rule.Attribute {
- isChangeIndex = true
- copyRuleRef.Attribute = request.Rule.Attribute
- }
- if copyRuleRef.Pattern != request.Rule.Pattern {
- isChangeIndex = true
- copyRuleRef.Pattern = request.Rule.Pattern
- }
- copyRuleRef.RuleType = request.Rule.RuleType
- copyRuleRef.Description = request.Rule.Description
- copyRuleRef.ModTimestamp = strconv.FormatInt(time.Now().Unix(), 10)
-
- key := path.GenerateServiceRuleKey(domainProject, request.ServiceId, request.RuleId)
- data, err := json.Marshal(copyRuleRef)
- if err != nil {
- log.Errorf(err, "update service rule[%s/%s] failed, marshal service rule failed, operator: %s",
- request.ServiceId, request.RuleId, remoteIP)
- return &pb.UpdateServiceRuleResponse{
- Response: pb.CreateResponse(pb.ErrInternal, err.Error()),
- }, err
- }
- var opts []client.PluginOp
- if isChangeIndex {
- //加入新的rule index
- indexKey := path.GenerateRuleIndexKey(domainProject, request.ServiceId, copyRuleRef.Attribute, copyRuleRef.Pattern)
- opts = append(opts, client.OpPut(client.WithStrKey(indexKey), client.WithStrValue(copyRuleRef.RuleId)))
-
- //删除旧的rule index
- oldIndexKey := path.GenerateRuleIndexKey(domainProject, request.ServiceId, oldRuleAttr, oldRulePatten)
- opts = append(opts, client.OpDel(client.WithStrKey(oldIndexKey)))
- }
- opts = append(opts, client.OpPut(client.WithStrKey(key), client.WithValue(data)))
-
- resp, err := client.Instance().TxnWithCmp(ctx, opts,
- []client.CompareOp{client.OpCmp(
- client.CmpVer(util.StringToBytesWithNoCopy(path.GenerateServiceKey(domainProject, request.ServiceId))),
- client.CmpNotEqual, 0)},
- nil)
- if err != nil {
- log.Errorf(err, "update service rule[%s/%s] failed, operator: %s", request.ServiceId, request.RuleId, remoteIP)
- return &pb.UpdateServiceRuleResponse{
- Response: pb.CreateResponse(pb.ErrUnavailableBackend, err.Error()),
- }, err
- }
- if !resp.Succeeded {
- log.Errorf(err, "update service rule[%s/%s] failed, service does not exist, operator: %s",
- request.ServiceId, request.RuleId, remoteIP)
- return &pb.UpdateServiceRuleResponse{
- Response: pb.CreateResponse(pb.ErrServiceNotExists, "Service does not exist."),
- }, nil
- }
-
- log.Infof("update service rule[%s/%s] successfully, operator: %s", request.ServiceId, request.RuleId, remoteIP)
- return &pb.UpdateServiceRuleResponse{
- Response: pb.CreateResponse(pb.ResponseSuccess, "Get service rules successfully."),
- }, nil
-}
-
-func (ds *MetadataManager) DeleteRule(ctx context.Context, request *pb.DeleteServiceRulesRequest) (
- *pb.DeleteServiceRulesResponse, error) {
- remoteIP := util.GetIPFromContext(ctx)
- domainProject := util.ParseDomainProject(ctx)
-
- // service id存在性校验
- if !serviceUtil.ServiceExist(ctx, domainProject, request.ServiceId) {
- log.Errorf(nil, "delete service[%s] rules %v failed, service does not exist, operator: %s",
- request.ServiceId, request.RuleIds, remoteIP)
- return &pb.DeleteServiceRulesResponse{
- Response: pb.CreateResponse(pb.ErrServiceNotExists, "Service does not exist."),
- }, nil
- }
-
- opts := []client.PluginOp{}
- key := ""
- indexKey := ""
- for _, ruleID := range request.RuleIds {
- key = path.GenerateServiceRuleKey(domainProject, request.ServiceId, ruleID)
- log.Debugf("start delete service rule file: %s", key)
- data, err := serviceUtil.GetOneRule(ctx, domainProject, request.ServiceId, ruleID)
- if err != nil {
- log.Errorf(err, "delete service[%s] rules %v failed, get rule[%s] failed, operator: %s",
- request.ServiceId, request.RuleIds, ruleID, remoteIP)
- return &pb.DeleteServiceRulesResponse{
- Response: pb.CreateResponse(pb.ErrInternal, err.Error()),
- }, err
- }
- if data == nil {
- log.Errorf(nil, "delete service[%s] rules %v failed, rule[%s] does not exist, operator: %s",
- request.ServiceId, request.RuleIds, ruleID, remoteIP)
- return &pb.DeleteServiceRulesResponse{
- Response: pb.CreateResponse(pb.ErrRuleNotExists, "This rule does not exist."),
- }, nil
- }
- indexKey = path.GenerateRuleIndexKey(domainProject, request.ServiceId, data.Attribute, data.Pattern)
- opts = append(opts,
- client.OpDel(client.WithStrKey(key)),
- client.OpDel(client.WithStrKey(indexKey)))
- }
- if len(opts) <= 0 {
- log.Errorf(nil, "delete service[%s] rules %v failed, no rule has been deleted, operator: %s",
- request.ServiceId, request.RuleIds, remoteIP)
- return &pb.DeleteServiceRulesResponse{
- Response: pb.CreateResponse(pb.ErrRuleNotExists, "No service rule has been deleted."),
- }, nil
- }
-
- resp, err := client.BatchCommitWithCmp(ctx, opts,
- []client.CompareOp{client.OpCmp(
- client.CmpVer(util.StringToBytesWithNoCopy(path.GenerateServiceKey(domainProject, request.ServiceId))),
- client.CmpNotEqual, 0)},
- nil)
- if err != nil {
- log.Errorf(err, "delete service[%s] rules %v failed, operator: %s", request.ServiceId, request.RuleIds, remoteIP)
- return &pb.DeleteServiceRulesResponse{
- Response: pb.CreateResponse(pb.ErrUnavailableBackend, err.Error()),
- }, err
- }
- if !resp.Succeeded {
- log.Errorf(err, "delete service[%s] rules %v failed, service does not exist, operator: %s",
- request.ServiceId, request.RuleIds, remoteIP)
- return &pb.DeleteServiceRulesResponse{
- Response: pb.CreateResponse(pb.ErrServiceNotExists, "Service does not exist."),
- }, nil
- }
-
- log.Infof("delete service[%s] rules %v successfully, operator: %s", request.ServiceId, request.RuleIds, remoteIP)
- return &pb.DeleteServiceRulesResponse{
- Response: pb.CreateResponse(pb.ResponseSuccess, "Delete service rules successfully."),
- }, nil
-}
-
func (ds *MetadataManager) modifySchemas(ctx context.Context, domainProject string, service *pb.MicroService,
schemas []*pb.Schema) *errsvc.Error {
remoteIP := util.GetIPFromContext(ctx)
diff --git a/datasource/etcd/sd/servicecenter/aggregate.go b/datasource/etcd/sd/servicecenter/aggregate.go
index c6d580f..164d100 100644
--- a/datasource/etcd/sd/servicecenter/aggregate.go
+++ b/datasource/etcd/sd/servicecenter/aggregate.go
@@ -68,8 +68,6 @@ func (c *SCClientAggregate) GetScCache(ctx context.Context) (*dump.Cache, map[st
c.cacheAppend(client.Cfg.Name, &caches.Indexes, &cache.Indexes)
c.cacheAppend(client.Cfg.Name, &caches.Aliases, &cache.Aliases)
c.cacheAppend(client.Cfg.Name, &caches.Tags, &cache.Tags)
- c.cacheAppend(client.Cfg.Name, &caches.Rules, &cache.Rules)
- c.cacheAppend(client.Cfg.Name, &caches.RuleIndexes, &cache.RuleIndexes)
c.cacheAppend(client.Cfg.Name, &caches.DependencyRules, &cache.DependencyRules)
c.cacheAppend(client.Cfg.Name, &caches.Summaries, &cache.Summaries)
c.cacheAppend(client.Cfg.Name, &caches.Instances, &cache.Instances)
diff --git a/datasource/etcd/sd/servicecenter/syncer.go b/datasource/etcd/sd/servicecenter/syncer.go
index 19a4099..ca6f413 100644
--- a/datasource/etcd/sd/servicecenter/syncer.go
+++ b/datasource/etcd/sd/servicecenter/syncer.go
@@ -86,14 +86,6 @@ func (c *Syncer) Sync(ctx context.Context) {
if ok {
c.check(tagCacher, &cache.Tags, errs)
}
- ruleCacher, ok := c.cachers[kv.RULE]
- if ok {
- c.check(ruleCacher, &cache.Rules, errs)
- }
- ruleIndexCacher, ok := c.cachers[kv.RuleIndex]
- if ok {
- c.check(ruleIndexCacher, &cache.RuleIndexes, errs)
- }
depRuleCacher, ok := c.cachers[kv.DependencyRule]
if ok {
c.check(depRuleCacher, &cache.DependencyRules, errs)
diff --git a/datasource/etcd/system.go b/datasource/etcd/system.go
index 8cebe98..5b18aef 100644
--- a/datasource/etcd/system.go
+++ b/datasource/etcd/system.go
@@ -45,8 +45,6 @@ func (sm *SysManager) DumpCache(ctx context.Context) *dump.Cache {
Do(func(_ context.Context) { setValue(kv.Store().ServiceIndex(), &cache.Indexes) }).
Do(func(_ context.Context) { setValue(kv.Store().ServiceAlias(), &cache.Aliases) }).
Do(func(_ context.Context) { setValue(kv.Store().ServiceTag(), &cache.Tags) }).
- Do(func(_ context.Context) { setValue(kv.Store().RuleIndex(), &cache.RuleIndexes) }).
- Do(func(_ context.Context) { setValue(kv.Store().Rule(), &cache.Rules) }).
Do(func(_ context.Context) { setValue(kv.Store().DependencyRule(), &cache.DependencyRules) }).
Do(func(_ context.Context) { setValue(kv.Store().SchemaSummary(), &cache.Summaries) }).
Do(func(_ context.Context) { setValue(kv.Store().Instance(), &cache.Instances) }).
diff --git a/datasource/etcd/util.go b/datasource/etcd/util.go
index a8393d9..88d7e9a 100644
--- a/datasource/etcd/util.go
+++ b/datasource/etcd/util.go
@@ -279,16 +279,6 @@ func getServiceDetailUtil(ctx context.Context, serviceDetailOpt ServiceDetailOpt
return nil, err
}
serviceDetail.Tags = tags
- case "rules":
- rules, err := serviceUtil.GetRulesUtil(ctx, domainProject, serviceID)
- if err != nil {
- log.Errorf(err, "get service[%s]'s all rules failed", serviceID)
- return nil, err
- }
- for _, rule := range rules {
- rule.Timestamp = rule.ModTimestamp
- }
- serviceDetail.Rules = rules
case "instances":
if serviceDetailOpt.countOnly {
instanceCount, err := serviceUtil.GetInstanceCountOfOneService(ctx, domainProject, serviceID)
diff --git a/datasource/etcd/util/dependency_test.go b/datasource/etcd/util/dependency_test.go
index 1ce2b06..6e03a4a 100644
--- a/datasource/etcd/util/dependency_test.go
+++ b/datasource/etcd/util/dependency_test.go
@@ -279,10 +279,3 @@ func TestDependencyRelationFilterOpt(t *testing.T) {
t.Fatalf(`ToDependencyRelationFilterOpt failed`)
}
}
-
-func TestGetConsumerIdsWithFilter(t *testing.T) {
- _, _, err := GetConsumerIdsWithFilter(context.Background(), "", &discovery.MicroService{}, nil)
- if err != nil {
- t.Fatalf(`TestGetConsumerIdsWithFilter failed`)
- }
-}
diff --git a/datasource/etcd/util/dependency_util.go b/datasource/etcd/util/dependency_util.go
index 3813e9c..dd00d02 100644
--- a/datasource/etcd/util/dependency_util.go
+++ b/datasource/etcd/util/dependency_util.go
@@ -54,76 +54,6 @@ func GetProviderIds(ctx context.Context, domainProject string, consumer *pb.Micr
return providerIDs, nil
}
-// GetAllConsumerIds is the function get from dependency rule and filter with service rules
-func GetAllConsumerIds(ctx context.Context, domainProject string, provider *pb.MicroService) (allow []string, deny []string, _ error) {
- if provider == nil || len(provider.ServiceId) == 0 {
- return nil, nil, fmt.Errorf("invalid provider")
- }
-
- //todo 删除服务，最后实例推送有误差
- providerRules, err := GetRulesUtil(ctx, domainProject, provider.ServiceId)
- if err != nil {
- return nil, nil, err
- }
-
- rf := &RuleFilter{
- DomainProject: domainProject,
- ProviderRules: providerRules,
- }
-
- allow, deny, err = GetConsumerIdsWithFilter(ctx, domainProject, provider, rf)
- if err != nil {
- return nil, nil, err
- }
- return allow, deny, nil
-}
-
-func GetConsumerIdsWithFilter(ctx context.Context, domainProject string, provider *pb.MicroService, rf *RuleFilter) (allow []string, deny []string, err error) {
- consumerIds, err := GetConsumerIds(ctx, domainProject, provider)
- if err != nil {
- return nil, nil, err
- }
- return rf.FilterAll(ctx, consumerIds)
-}
-
-func GetAllProviderIds(ctx context.Context, domainProject string, service *pb.MicroService) (allow []string, deny []string, _ error) {
- providerIDsInCache, err := GetProviderIds(ctx, domainProject, service)
- if err != nil {
- return nil, nil, err
- }
- l := len(providerIDsInCache)
- rf := RuleFilter{
- DomainProject: domainProject,
- }
- allowIdx, denyIdx := 0, l
- providerIDs := make([]string, l)
- copyCtx := util.WithCacheOnly(util.CloneContext(ctx))
- for _, providerID := range providerIDsInCache {
- providerRules, err := GetRulesUtil(copyCtx, domainProject, providerID)
- if err != nil {
- return nil, nil, err
- }
- if len(providerRules) == 0 {
- providerIDs[allowIdx] = providerID
- allowIdx++
- continue
- }
- rf.ProviderRules = providerRules
- ok, err := rf.Filter(ctx, service.ServiceId)
- if err != nil {
- return nil, nil, err
- }
- if ok {
- providerIDs[allowIdx] = providerID
- allowIdx++
- } else {
- denyIdx--
- providerIDs[denyIdx] = providerID
- }
- }
- return providerIDs[:allowIdx], providerIDs[denyIdx:], nil
-}
-
func DependencyRuleExist(ctx context.Context, provider *pb.MicroServiceKey, consumer *pb.MicroServiceKey) (bool, error) {
targetDomainProject := provider.Tenant
if len(targetDomainProject) == 0 {
diff --git a/datasource/etcd/util/rule_util.go b/datasource/etcd/util/rule_util.go
index 8ebff79..6f59fcc 100644
--- a/datasource/etcd/util/rule_util.go
+++ b/datasource/etcd/util/rule_util.go
@@ -21,137 +21,15 @@ import (
"context"
"errors"
"fmt"
- "reflect"
- "regexp"
"strings"
"github.com/go-chassis/cari/discovery"
"github.com/go-chassis/cari/pkg/errsvc"
"github.com/apache/servicecomb-service-center/datasource"
- "github.com/apache/servicecomb-service-center/datasource/etcd/client"
- "github.com/apache/servicecomb-service-center/datasource/etcd/kv"
- "github.com/apache/servicecomb-service-center/datasource/etcd/path"
- "github.com/apache/servicecomb-service-center/pkg/log"
"github.com/apache/servicecomb-service-center/pkg/util"
)
-type RuleFilter struct {
- DomainProject string
- ProviderRules []*discovery.ServiceRule
-}
-
-func (rf *RuleFilter) Filter(ctx context.Context, consumerID string) (bool, error) {
- copyCtx := util.WithCacheOnly(util.CloneContext(ctx))
- consumer, err := GetService(copyCtx, rf.DomainProject, consumerID)
- if err != nil {
- return false, err
- }
-
- if len(rf.ProviderRules) == 0 {
- return true, nil
- }
-
- tags, err := GetTagsUtils(copyCtx, rf.DomainProject, consumerID)
- if err != nil {
- return false, err
- }
- matchErr := MatchRules(rf.ProviderRules, consumer, tags)
- if matchErr != nil {
- if matchErr.Code == discovery.ErrPermissionDeny {
- return false, nil
- }
- return false, matchErr
- }
- return true, nil
-}
-
-func (rf *RuleFilter) FilterAll(ctx context.Context, consumerIDs []string) (allow []string, deny []string, err error) {
- l := len(consumerIDs)
- if l == 0 || len(rf.ProviderRules) == 0 {
- return consumerIDs, nil, nil
- }
-
- allowIdx, denyIdx := 0, l
- consumers := make([]string, l)
- for _, consumerID := range consumerIDs {
- ok, err := rf.Filter(ctx, consumerID)
- if err != nil {
- return nil, nil, err
- }
- if ok {
- consumers[allowIdx] = consumerID
- allowIdx++
- } else {
- denyIdx--
- consumers[denyIdx] = consumerID
- }
- }
- return consumers[:allowIdx], consumers[denyIdx:], nil
-}
-
-func GetRulesUtil(ctx context.Context, domainProject string, serviceID string) ([]*discovery.ServiceRule, error) {
- key := util.StringJoin([]string{
- path.GetServiceRuleRootKey(domainProject),
- serviceID,
- "",
- }, "/")
-
- opts := append(FromContext(ctx), client.WithStrKey(key), client.WithPrefix())
- resp, err := kv.Store().Rule().Search(ctx, opts...)
- if err != nil {
- return nil, err
- }
-
- rules := []*discovery.ServiceRule{}
- for _, kv := range resp.Kvs {
- rules = append(rules, kv.Value.(*discovery.ServiceRule))
- }
- return rules, nil
-}
-
-func RuleExist(ctx context.Context, domainProject string, serviceID string, attr string, pattern string) bool {
- opts := append(FromContext(ctx),
- client.WithStrKey(path.GenerateRuleIndexKey(domainProject, serviceID, attr, pattern)),
- client.WithCountOnly())
- resp, err := kv.Store().RuleIndex().Search(ctx, opts...)
- if err != nil || resp.Count == 0 {
- return false
- }
- return true
-}
-
-func GetServiceRuleType(ctx context.Context, domainProject string, serviceID string) (string, int, error) {
- key := path.GenerateServiceRuleKey(domainProject, serviceID, "")
- opts := append(FromContext(ctx),
- client.WithStrKey(key),
- client.WithPrefix())
- resp, err := kv.Store().Rule().Search(ctx, opts...)
- if err != nil {
- log.Errorf(err, "get service[%s] rule failed", serviceID)
- return "", 0, err
- }
- if len(resp.Kvs) == 0 {
- return "", 0, nil
- }
- return resp.Kvs[0].Value.(*discovery.ServiceRule).RuleType, len(resp.Kvs), nil
-}
-
-func GetOneRule(ctx context.Context, domainProject, serviceID, ruleID string) (*discovery.ServiceRule, error) {
- opts := append(FromContext(ctx),
- client.WithStrKey(path.GenerateServiceRuleKey(domainProject, serviceID, ruleID)))
- resp, err := kv.Store().Rule().Search(ctx, opts...)
- if err != nil {
- log.Errorf(err, "get service rule[%s/%s]", serviceID, ruleID)
- return nil, err
- }
- if len(resp.Kvs) == 0 {
- log.Errorf(nil, "get service rule[%s/%s] failed", serviceID, ruleID)
- return nil, nil
- }
- return resp.Kvs[0].Value.(*discovery.ServiceRule), nil
-}
-
func AllowAcrossDimension(ctx context.Context, providerService *discovery.MicroService, consumerService *discovery.MicroService) error {
if providerService.AppId != consumerService.AppId {
if len(providerService.Properties) == 0 {
@@ -171,86 +49,6 @@ func AllowAcrossDimension(ctx context.Context, providerService *discovery.MicroS
return nil
}
-func MatchRules(rulesOfProvider []*discovery.ServiceRule, consumer *discovery.MicroService, tagsOfConsumer map[string]string) *errsvc.Error {
- if consumer == nil {
- return discovery.NewError(discovery.ErrInvalidParams, "consumer is nil")
- }
-
- if len(rulesOfProvider) <= 0 {
- return nil
- }
- if rulesOfProvider[0].RuleType == "WHITE" {
- return patternWhiteList(rulesOfProvider, tagsOfConsumer, consumer)
- }
- return patternBlackList(rulesOfProvider, tagsOfConsumer, consumer)
-}
-
-func patternWhiteList(rulesOfProvider []*discovery.ServiceRule, tagsOfConsumer map[string]string, consumer *discovery.MicroService) *errsvc.Error {
- v := reflect.Indirect(reflect.ValueOf(consumer))
- consumerID := consumer.ServiceId
- for _, rule := range rulesOfProvider {
- value, err := parsePattern(v, rule, tagsOfConsumer, consumerID)
- if err != nil {
- return err
- }
- if len(value) == 0 {
- continue
- }
-
- match, _ := regexp.MatchString(rule.Pattern, value)
- if match {
- log.Infof("consumer[%s][%s/%s/%s/%s] match white list, rule.Pattern is %s, value is %s",
- consumerID, consumer.Environment, consumer.AppId, consumer.ServiceName, consumer.Version,
- rule.Pattern, value)
- return nil
- }
- }
- return discovery.NewError(discovery.ErrPermissionDeny, "Not found in white list")
-}
-
-func parsePattern(v reflect.Value, rule *discovery.ServiceRule, tagsOfConsumer map[string]string, consumerID string) (string, *errsvc.Error) {
- if strings.HasPrefix(rule.Attribute, "tag_") {
- key := rule.Attribute[4:]
- value := tagsOfConsumer[key]
- if len(value) == 0 {
- log.Infof("can not find service[%s] tag[%s]", consumerID, key)
- }
- return value, nil
- }
- key := v.FieldByName(rule.Attribute)
- if !key.IsValid() {
- log.Errorf(nil, "can not find service[%] field[%s], ruleID is %s",
- consumerID, rule.Attribute, rule.RuleId)
- return "", discovery.NewError(discovery.ErrInternal, fmt.Sprintf("Can not find field '%s'", rule.Attribute))
- }
- return key.String(), nil
-
-}
-
-func patternBlackList(rulesOfProvider []*discovery.ServiceRule, tagsOfConsumer map[string]string, consumer *discovery.MicroService) *errsvc.Error {
- v := reflect.Indirect(reflect.ValueOf(consumer))
- consumerID := consumer.ServiceId
- for _, rule := range rulesOfProvider {
- var value string
- value, err := parsePattern(v, rule, tagsOfConsumer, consumerID)
- if err != nil {
- return err
- }
- if len(value) == 0 {
- continue
- }
-
- match, _ := regexp.MatchString(rule.Pattern, value)
- if match {
- log.Warnf("no permission to access, consumer[%s][%s/%s/%s/%s] match black list, rule.Pattern is %s, value is %s",
- consumerID, consumer.Environment, consumer.AppId, consumer.ServiceName, consumer.Version,
- rule.Pattern, value)
- return discovery.NewError(discovery.ErrPermissionDeny, "Found in black list")
- }
- }
- return nil
-}
-
func Accessible(ctx context.Context, consumerID string, providerID string) *errsvc.Error {
if len(consumerID) == 0 {
return nil
@@ -280,23 +78,5 @@ func Accessible(ctx context.Context, consumerID string, providerID string) *errs
if err != nil {
return discovery.NewError(discovery.ErrPermissionDeny, err.Error())
}
-
- ctx = util.WithCacheOnly(util.CloneContext(ctx))
-
- // 黑白名单
- rules, err := GetRulesUtil(ctx, targetDomainProject, providerID)
- if err != nil {
- return discovery.NewError(discovery.ErrInternal, fmt.Sprintf("An error occurred in query provider rules(%s)", err.Error()))
- }
-
- if len(rules) == 0 {
- return nil
- }
-
- validateTags, err := GetTagsUtils(ctx, domainProject, consumerService.ServiceId)
- if err != nil {
- return discovery.NewError(discovery.ErrInternal, fmt.Sprintf("An error occurred in query consumer tags(%s)", err.Error()))
- }
-
- return MatchRules(rules, consumerService, validateTags)
+ return nil
}
diff --git a/datasource/etcd/util/rule_util_test.go b/datasource/etcd/util/rule_util_test.go
index 39529cc..d0a550e 100644
--- a/datasource/etcd/util/rule_util_test.go
+++ b/datasource/etcd/util/rule_util_test.go
@@ -19,79 +19,13 @@ package util_test
import (
"context"
- "errors"
"net/http"
"testing"
- "github.com/stretchr/testify/assert"
-
- "github.com/apache/servicecomb-service-center/datasource"
. "github.com/apache/servicecomb-service-center/datasource/etcd/util"
- "github.com/apache/servicecomb-service-center/pkg/util"
"github.com/go-chassis/cari/discovery"
)
-func TestRuleFilter_Filter(t *testing.T) {
- rf := RuleFilter{
- DomainProject: "",
- ProviderRules: []*discovery.ServiceRule{},
- }
- var err error
- t.Run("when there is no such a customer in db", func(t *testing.T) {
- _, err = rf.Filter(context.Background(), "")
- 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 = rf.FilterAll(context.Background(), []string{""})
- if err != nil && !errors.Is(err, datasource.ErrNoData) {
- t.Fatalf("RuleFilter FilterAll failed")
- }
- assert.Equal(t, nil, err, "no customer found err is nil")
- })
- rf.ProviderRules = []*discovery.ServiceRule{
- {},
- }
- t.Run("FilterAll when ProviderRules not nil and service not exist", func(t *testing.T) {
- _, _, err = rf.FilterAll(context.Background(), []string{""})
- if err != nil && !errors.Is(err, datasource.ErrNoData) {
- t.Fatalf("RuleFilter FilterAll failed")
- }
- assert.Equal(t, datasource.ErrNoData, err, "no customer found when FilterAll")
- })
-}
-
-func TestGetRulesUtil(t *testing.T) {
- _, err := GetRulesUtil(context.Background(), "", "")
- if err != nil {
- t.Fatalf("GetRulesUtil failed")
- }
-
- _, err = GetOneRule(context.Background(), "", "", "")
- if err != nil {
- t.Fatalf("GetOneRule failed")
- }
-}
-
-func TestRuleExist(t *testing.T) {
- defer func() {
- if r := recover(); r != nil {
- t.Fatalf("TestRuleExist panic")
- }
- }()
- RuleExist(util.WithCacheOnly(context.Background()), "", "", "", "")
- RuleExist(context.Background(), "", "", "", "")
-}
-
-func TestGetServiceRuleType(t *testing.T) {
- _, _, err := GetServiceRuleType(context.Background(), "", "")
- if err != nil {
- t.Fatalf("GetServiceRuleType failed")
- }
-}
-
func TestAllowAcrossApp(t *testing.T) {
err := AllowAcrossDimension(context.Background(), &discovery.MicroService{
AppId: "a",
@@ -160,135 +94,8 @@ func TestAllowAcrossApp(t *testing.T) {
}
}
-func TestMatchRules(t *testing.T) {
- err := MatchRules([]*discovery.ServiceRule{
- {
- RuleType: "WHITE",
- Attribute: "",
- Pattern: "",
- },
- }, nil, nil)
- if err == nil {
- t.Fatalf("MatchRules nil failed")
- }
-
- err = MatchRules([]*discovery.ServiceRule{
- {
- RuleType: "WHITE",
- Attribute: "",
- Pattern: "",
- },
- }, &discovery.MicroService{}, nil)
- if err == nil {
- t.Fatalf("MatchRules invalid WHITE failed")
- }
-
- err = MatchRules([]*discovery.ServiceRule{
- {
- RuleType: "WHITE",
- Attribute: "ServiceName",
- Pattern: "^a.*",
- },
- }, &discovery.MicroService{
- ServiceName: "a",
- }, nil)
- if err != nil {
- t.Fatalf("MatchRules WHITE with field ServiceName failed")
- }
-
- err = MatchRules([]*discovery.ServiceRule{
- {
- RuleType: "WHITE",
- Attribute: "tag_a",
- Pattern: "^b.*",
- },
- }, &discovery.MicroService{}, map[string]string{
- "a": "b",
- })
- if err != nil {
- t.Fatalf("MatchRules WHITE with tag b failed")
- }
-
- err = MatchRules([]*discovery.ServiceRule{
- {
- RuleType: "WHITE",
- Attribute: "tag_a",
- Pattern: "^b.*",
- },
- }, &discovery.MicroService{}, map[string]string{
- "a": "c",
- })
- if err == nil {
- t.Fatalf("MatchRules WHITE with tag c failed")
- }
-
- err = MatchRules([]*discovery.ServiceRule{
- {
- RuleType: "BLACK",
- Attribute: "tag_a",
- Pattern: "^b.*",
- },
- }, &discovery.MicroService{}, map[string]string{
- "a": "b",
- })
- if err == nil {
- t.Fatalf("MatchRules BLACK with tag b failed")
- }
-
- err = MatchRules([]*discovery.ServiceRule{
- {
- RuleType: "BLACK",
- Attribute: "ServiceName",
- Pattern: "^a.*",
- },
- }, &discovery.MicroService{
- ServiceName: "a",
- }, nil)
- if err == nil {
- t.Fatalf("MatchRules BLACK with field ServiceName failed")
- }
-
- err = MatchRules([]*discovery.ServiceRule{
- {
- RuleType: "BLACK",
- Attribute: "tag_a",
- Pattern: "^b.*",
- },
- }, &discovery.MicroService{}, map[string]string{
- "a": "c",
- })
- if err != nil {
- t.Fatalf("MatchRules BLACK with tag c failed")
- }
-
- err = MatchRules([]*discovery.ServiceRule{
- {
- RuleType: "BLACK",
- Attribute: "tag_a",
- Pattern: "^b.*",
- },
- }, &discovery.MicroService{}, map[string]string{
- "b": "b",
- })
- if err != nil {
- t.Fatalf("MatchRules with not exist tag failed")
- }
-}
-
func TestGetConsumer(t *testing.T) {
- _, _, err := GetAllProviderIds(context.Background(), "", &discovery.MicroService{})
- if err != nil {
- t.Fatalf("GetConsumerIdsByProvider invalid failed")
- }
-
- _, _, err = GetAllConsumerIds(context.Background(), "", &discovery.MicroService{
- ServiceId: "a",
- })
- if err != nil {
- t.Fatalf("GetConsumerIdsByProvider WithCacheOnly not exist service failed")
- }
-
- _, err = GetConsumerIds(context.Background(), "",
+ _, err := GetConsumerIds(context.Background(), "",
&discovery.MicroService{
ServiceId: "a",
})
@@ -305,11 +112,6 @@ func TestGetProvider(t *testing.T) {
if err != nil {
t.Fatalf("GetProviderIds WithCacheOnly failed")
}
-
- _, _, err = GetAllProviderIds(context.Background(), "", &discovery.MicroService{})
- if err != nil {
- t.Fatalf("GetAllProviderIds WithCacheOnly failed")
- }
}
func TestAccessible(t *testing.T) {
diff --git a/datasource/mongo/client/dao/rule.go b/datasource/mongo/client/dao/rule.go
deleted file mode 100644
index 4179ae6..0000000
--- a/datasource/mongo/client/dao/rule.go
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package dao
-
-import (
- "context"
-
- mutil "github.com/apache/servicecomb-service-center/datasource/mongo/util"
- "github.com/apache/servicecomb-service-center/pkg/util"
-
- "github.com/go-chassis/cari/discovery"
- "go.mongodb.org/mongo-driver/bson"
- "go.mongodb.org/mongo-driver/mongo/options"
-
- "github.com/apache/servicecomb-service-center/datasource/mongo/client"
- "github.com/apache/servicecomb-service-center/datasource/mongo/client/model"
- "github.com/apache/servicecomb-service-center/pkg/log"
-)
-
-func GetRulesByServiceID(ctx context.Context, serviceID string) ([]*model.Rule, error) {
- filter := mutil.NewDomainProjectFilter(util.ParseDomain(ctx), util.ParseDomain(ctx), mutil.ServiceID(serviceID))
- return GetRules(ctx, filter)
-}
-
-func GetRules(ctx context.Context, filter interface{}) ([]*model.Rule, error) {
- cursor, err := client.GetMongoClient().Find(ctx, model.CollectionRule, filter)
- if err != nil {
- return nil, err
- }
- if cursor.Err() != nil {
- return nil, cursor.Err()
- }
- var rules []*model.Rule
- defer cursor.Close(ctx)
- for cursor.Next(ctx) {
- var rule model.Rule
- err := cursor.Decode(&rule)
- if err != nil {
- log.Error("type conversion error", err)
- return nil, err
- }
- rules = append(rules, &rule)
- }
- return rules, nil
-}
-
-func GetServiceRules(ctx context.Context, filter interface{}, opts ...*options.FindOptions) ([]*discovery.ServiceRule, error) {
- ruleRes, err := client.GetMongoClient().Find(ctx, model.CollectionRule, filter, opts...)
- if err != nil {
- return nil, err
- }
- var rules []*discovery.ServiceRule
- for ruleRes.Next(ctx) {
- var tempRule *model.Rule
- err := ruleRes.Decode(&tempRule)
- if err != nil {
- return nil, err
- }
- rules = append(rules, tempRule.Rule)
- }
- return rules, nil
-}
-
-func RuleExist(ctx context.Context, filter interface{}) (bool, error) {
- return client.GetMongoClient().DocExist(ctx, model.CollectionRule, filter)
-}
-
-func UpdateRule(ctx context.Context, filter interface{}, m bson.M) error {
- return client.GetMongoClient().DocUpdate(ctx, model.CollectionRule, filter, m)
-}
-
-func UpdateSchema(ctx context.Context, filter interface{}, update interface{}, opts ...*options.FindOneAndUpdateOptions) error {
- _, err := client.GetMongoClient().FindOneAndUpdate(ctx, model.CollectionSchema, filter, update, opts...)
- if err != nil {
- return err
- }
- return nil
-}
diff --git a/datasource/mongo/client/dao/schema.go b/datasource/mongo/client/dao/schema.go
index 6cf10ea..0aa61bf 100644
--- a/datasource/mongo/client/dao/schema.go
+++ b/datasource/mongo/client/dao/schema.go
@@ -20,6 +20,8 @@ package dao
import (
"context"
+ "go.mongodb.org/mongo-driver/mongo/options"
+
"github.com/apache/servicecomb-service-center/datasource/mongo/client"
"github.com/apache/servicecomb-service-center/datasource/mongo/client/model"
mutil "github.com/apache/servicecomb-service-center/datasource/mongo/util"
@@ -85,3 +87,11 @@ func CountSchema(ctx context.Context, serviceID string) (int64, error) {
filter := mutil.NewBasicFilter(ctx, mutil.ServiceID(serviceID))
return client.Count(ctx, model.CollectionSchema, filter)
}
+
+func UpdateSchema(ctx context.Context, filter interface{}, update interface{}, opts ...*options.FindOneAndUpdateOptions) error {
+ _, err := client.GetMongoClient().FindOneAndUpdate(ctx, model.CollectionSchema, filter, update, opts...)
+ if err != nil {
+ return err
+ }
+ return nil
+}
diff --git a/datasource/mongo/client/model/types.go b/datasource/mongo/client/model/types.go
index f92f3b2..fd9e5ea 100644
--- a/datasource/mongo/client/model/types.go
+++ b/datasource/mongo/client/model/types.go
@@ -28,7 +28,6 @@ const (
CollectionAccountLock = "account_lock"
CollectionService = "service"
CollectionSchema = "schema"
- CollectionRule = "rule"
CollectionInstance = "instance"
CollectionDep = "dependency"
CollectionRole = "role"
@@ -42,7 +41,6 @@ const (
ColumnTag = "tags"
ColumnSchemaID = "schema_id"
ColumnServiceID = "service_id"
- ColumnRuleID = "rule_id"
ColumnService = "service"
ColumnProperty = "properties"
ColumnModTime = "mod_timestamp"
@@ -52,15 +50,10 @@ const (
ColumnAlias = "alias"
ColumnVersion = "version"
ColumnSchemas = "schemas"
- ColumnAttribute = "attribute"
- ColumnPattern = "pattern"
- ColumnDescription = "description"
- ColumnRuleType = "rule_type"
ColumnSchema = "schema"
ColumnSchemaSummary = "schema_summary"
ColumnDep = "dep"
ColumnDependency = "dependency"
- ColumnRule = "rule"
ColumnInstance = "instance"
ColumnInstanceID = "instance_id"
ColumnTenant = "tenant"
@@ -99,13 +92,6 @@ type Schema struct {
SchemaSummary string `json:"schemaSummary,omitempty" bson:"schema_summary"`
}
-type Rule struct {
- Domain string `json:"domain,omitempty"`
- Project string `json:"project,omitempty"`
- ServiceID string `json:"serviceID,omitempty" bson:"service_id"`
- Rule *pb.ServiceRule `json:"rule,omitempty"`
-}
-
type Instance struct {
Domain string `json:"domain,omitempty"`
Project string `json:"project,omitempty"`
diff --git a/datasource/mongo/db.go b/datasource/mongo/db.go
index 0d0fdb6..dbc7f08 100644
--- a/datasource/mongo/db.go
+++ b/datasource/mongo/db.go
@@ -33,7 +33,6 @@ import (
func EnsureDB() {
EnsureService()
EnsureInstance()
- EnsureRule()
EnsureSchema()
EnsureDep()
EnsureAccountLock()
@@ -80,13 +79,6 @@ func EnsureSchema() {
model.ColumnServiceID)})
}
-func EnsureRule() {
- EnsureCollection(model.CollectionRule, []mongo.IndexModel{mutil.BuildIndexDoc(
- model.ColumnDomain,
- model.ColumnProject,
- model.ColumnServiceID)})
-}
-
func EnsureDep() {
EnsureCollection(model.CollectionDep, []mongo.IndexModel{mutil.BuildIndexDoc(
model.ColumnDomain,
diff --git a/datasource/mongo/dep_util.go b/datasource/mongo/dep_util.go
index 52c766a..3d3e1ce 100644
--- a/datasource/mongo/dep_util.go
+++ b/datasource/mongo/dep_util.go
@@ -19,56 +19,37 @@ package mongo
import (
"context"
- "errors"
"fmt"
pb "github.com/go-chassis/cari/discovery"
- "github.com/apache/servicecomb-service-center/datasource"
"github.com/apache/servicecomb-service-center/datasource/cache"
"github.com/apache/servicecomb-service-center/datasource/mongo/client/dao"
- "github.com/apache/servicecomb-service-center/datasource/mongo/client/model"
)
-func GetAllConsumerIds(ctx context.Context, provider *pb.MicroService) (allow []string, deny []string, err error) {
+func GetConsumerIDs(ctx context.Context, provider *pb.MicroService) ([]string, error) {
if provider == nil || len(provider.ServiceId) == 0 {
- return nil, nil, fmt.Errorf("invalid provider")
+ return nil, fmt.Errorf("invalid provider")
}
- //todo 删除服务，最后实例推送有误差
- providerRules, ok := cache.GetRulesByServiceID(provider.ServiceId)
- if !ok {
- providerRules, err = dao.GetRulesByServiceID(ctx, provider.ServiceId)
- if err != nil {
- return nil, nil, err
- }
- }
-
- allow, deny, err = GetConsumerIDsWithFilter(ctx, provider, providerRules)
- if err != nil && !errors.Is(err, datasource.ErrNoData) {
- return nil, nil, err
- }
- return allow, deny, nil
-}
-
-func GetConsumerIDsWithFilter(ctx context.Context, provider *pb.MicroService, rules []*model.Rule) (allow []string, deny []string, err error) {
+ var err error
serviceDeps, ok := cache.GetProviderServiceOfDeps(provider)
if !ok {
serviceDeps, err = dao.GetProviderDeps(ctx, provider)
if err != nil {
- return nil, nil, err
+ return nil, err
}
}
- consumerIDs := make([]string, len(serviceDeps.Dependency))
+ consumerIDs := make([]string, 0, len(serviceDeps.Dependency))
for _, serviceKeys := range serviceDeps.Dependency {
id, ok := cache.GetServiceID(ctx, serviceKeys)
if !ok {
id, err = dao.GetServiceID(ctx, serviceKeys)
if err != nil {
- return nil, nil, err
+ return nil, err
}
}
consumerIDs = append(consumerIDs, id)
}
- return FilterAll(ctx, consumerIDs, rules)
+ return consumerIDs, nil
}
diff --git a/datasource/mongo/event/instance_event_handler.go b/datasource/mongo/event/instance_event_handler.go
index 6e2ceb1..fe80ba7 100644
--- a/datasource/mongo/event/instance_event_handler.go
+++ b/datasource/mongo/event/instance_event_handler.go
@@ -77,7 +77,7 @@ func (h InstanceEventHandler) OnEvent(evt sd.MongoEvent) {
if !syncernotify.GetSyncerNotifyCenter().Closed() {
NotifySyncerInstanceEvent(evt, microService)
}
- consumerIDS, _, err := mongo.GetAllConsumerIds(ctx, microService)
+ consumerIDS, err := mongo.GetConsumerIDs(ctx, microService)
if err != nil {
log.Error(fmt.Sprintf("get service[%s][%s/%s/%s/%s]'s consumerIDs failed",
providerID, microService.Environment, microService.AppId, microService.ServiceName, microService.Version), err)
diff --git a/datasource/mongo/ms.go b/datasource/mongo/ms.go
index 7420779..69ed850 100644
--- a/datasource/mongo/ms.go
+++ b/datasource/mongo/ms.go
@@ -23,8 +23,6 @@ import (
"encoding/json"
"errors"
"fmt"
- "reflect"
- "regexp"
"sort"
"strconv"
"strings"
@@ -343,11 +341,10 @@ func (ds *MetadataManager) DelServicePri(ctx context.Context, serviceID string,
}
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{mutil.ConnectWithDot([]string{model.ColumnInstance, model.ColumnServiceID}): serviceID})}}
serviceOps := client.MongoOperation{Table: model.CollectionService, Models: []mongo.WriteModel{mongo.NewDeleteOneModel().SetFilter(bson.M{mutil.ConnectWithDot([]string{model.ColumnService, model.ColumnServiceID}): serviceID})}}
- err = client.GetMongoClient().MultiTableBatchUpdate(ctx, []client.MongoOperation{schemaOps, rulesOps, instanceOps, serviceOps})
+ err = client.GetMongoClient().MultiTableBatchUpdate(ctx, []client.MongoOperation{schemaOps, instanceOps, serviceOps})
if err != nil {
log.Error(fmt.Sprintf("micro-service[%s] failed, operator: %s", serviceID, remoteIP), err)
return discovery.CreateResponse(discovery.ErrUnavailableBackend, err.Error()), err
@@ -441,7 +438,7 @@ func (ds *MetadataManager) GetServiceDetail(ctx context.Context, request *discov
Response: discovery.CreateResponse(discovery.ErrInternal, err.Error()),
}, err
}
- options := []string{"tags", "rules", "instances", "schemas", "dependencies"}
+ options := []string{"tags", "instances", "schemas", "dependencies"}
serviceInfo, err := getServiceDetailUtil(ctx, mgSvc, false, options)
if err != nil {
return &discovery.GetServiceDetailResponse{
@@ -466,7 +463,7 @@ func (ds *MetadataManager) GetServicesInfo(ctx context.Context, request *discove
options := make([]string, 0, len(optionMap))
if _, ok := optionMap["all"]; ok {
optionMap["statistics"] = struct{}{}
- options = []string{"tags", "rules", "instances", "schemas", "dependencies"}
+ options = []string{"tags", "instances", "schemas", "dependencies"}
} else {
for opt := range optionMap {
options = append(options, opt)
@@ -1113,222 +1110,6 @@ func (ds *MetadataManager) modifySchema(ctx context.Context, serviceID string, s
return nil
}
-func (ds *MetadataManager) AddRule(ctx context.Context, request *discovery.AddServiceRulesRequest) (*discovery.AddServiceRulesResponse, error) {
- remoteIP := util.GetIPFromContext(ctx)
- domain := util.ParseDomain(ctx)
- project := util.ParseProject(ctx)
- exist, err := ServiceExistID(ctx, request.ServiceId)
- if err != nil {
- log.Error(fmt.Sprintf("failed to add rules for service %s for get service failed", request.ServiceId), err)
- return &discovery.AddServiceRulesResponse{
- Response: discovery.CreateResponse(discovery.ErrInternal, "Failed to check service exist"),
- }, nil
- }
- if !exist {
- return &discovery.AddServiceRulesResponse{Response: discovery.CreateResponse(discovery.ErrServiceNotExists, "Service does not exist")}, nil
- }
- res := quota.NewApplyQuotaResource(quota.TypeRule, util.ParseDomainProject(ctx), request.ServiceId, int64(len(request.Rules)))
- errQuota := quota.Apply(ctx, res)
- if errQuota != nil {
- log.Error(fmt.Sprintf("add service[%s] rule failed, operator: %s", request.ServiceId, remoteIP), errQuota)
- response := &discovery.AddServiceRulesResponse{
- Response: discovery.CreateResponseWithSCErr(errQuota),
- }
- if errQuota.InternalError() {
- return response, errQuota
- }
- return response, nil
- }
- filter := mutil.NewDomainProjectFilter(domain, project, mutil.ServiceID(request.ServiceId))
- rules, err := dao.GetServiceRules(ctx, filter)
- if err != nil {
- return &discovery.AddServiceRulesResponse{
- Response: discovery.CreateResponse(discovery.ErrInternal, err.Error()),
- }, err
- }
- var ruleType string
- if len(rules) != 0 {
- ruleType = rules[0].RuleType
- }
- ruleIDs := make([]string, 0, len(request.Rules))
- for _, rule := range request.Rules {
- if len(ruleType) == 0 {
- ruleType = rule.RuleType
- } else if ruleType != rule.RuleType {
- return &discovery.AddServiceRulesResponse{
- Response: discovery.CreateResponse(discovery.ErrBlackAndWhiteRule, "Service can only contain one rule type,Black or white."),
- }, nil
- }
- //the rule unique index is (serviceid,attribute,pattern)
- filter = mutil.NewFilter(
- mutil.ServiceID(request.ServiceId),
- mutil.RuleAttribute(rule.Attribute),
- mutil.RulePattern(rule.Pattern),
- )
- exist, err := dao.RuleExist(ctx, filter)
- if err != nil {
- return &discovery.AddServiceRulesResponse{
- Response: discovery.CreateResponse(discovery.ErrUnavailableBackend, "Can not check rule if exist."),
- }, nil
- }
- if exist {
- continue
- }
- timestamp := strconv.FormatInt(time.Now().Unix(), 10)
- ruleAdd := &model.Rule{
- Domain: util.ParseDomain(ctx),
- Project: util.ParseProject(ctx),
- ServiceID: request.ServiceId,
- Rule: &discovery.ServiceRule{
- RuleId: util.GenerateUUID(),
- RuleType: rule.RuleType,
- Attribute: rule.Attribute,
- Pattern: rule.Pattern,
- Description: rule.Description,
- Timestamp: timestamp,
- ModTimestamp: timestamp,
- },
- }
- ruleIDs = append(ruleIDs, ruleAdd.Rule.RuleId)
- _, err = client.GetMongoClient().Insert(ctx, model.CollectionRule, ruleAdd)
- if err != nil {
- return &discovery.AddServiceRulesResponse{
- Response: discovery.CreateResponse(discovery.ErrInternal, err.Error()),
- }, err
- }
- }
- return &discovery.AddServiceRulesResponse{
- Response: discovery.CreateResponse(discovery.ResponseSuccess, "Add service rules successfully."),
- RuleIds: ruleIDs,
- }, nil
-}
-
-func (ds *MetadataManager) GetRules(ctx context.Context, request *discovery.GetServiceRulesRequest) (*discovery.GetServiceRulesResponse, error) {
- exist, err := ServiceExistID(ctx, request.ServiceId)
- if err != nil {
- return &discovery.GetServiceRulesResponse{
- Response: discovery.CreateResponse(discovery.ErrServiceNotExists, "GetRules failed for get service failed."),
- }, nil
- }
- if !exist {
- return &discovery.GetServiceRulesResponse{
- Response: discovery.CreateResponse(discovery.ErrServiceNotExists, "GetRules failed for service not exist."),
- }, nil
- }
- filter := mutil.NewBasicFilter(ctx, mutil.ServiceID(request.ServiceId))
- rules, err := dao.GetServiceRules(ctx, filter)
- if err != nil {
- return &discovery.GetServiceRulesResponse{
- Response: discovery.CreateResponse(discovery.ErrInternal, err.Error()),
- }, nil
- }
- return &discovery.GetServiceRulesResponse{
- Response: discovery.CreateResponse(discovery.ResponseSuccess, "Get service rules successfully."),
- Rules: rules,
- }, nil
-}
-
-func (ds *MetadataManager) DeleteRule(ctx context.Context, request *discovery.DeleteServiceRulesRequest) (*discovery.DeleteServiceRulesResponse, error) {
- exist, err := ServiceExistID(ctx, request.ServiceId)
- domain := util.ParseDomain(ctx)
- project := util.ParseProject(ctx)
- if err != nil {
- log.Error(fmt.Sprintf("failed to add tags for service %s for get service failed", request.ServiceId), err)
- return &discovery.DeleteServiceRulesResponse{
- Response: discovery.CreateResponse(discovery.ErrInternal, "Failed to check service exist"),
- }, err
- }
- if !exist {
- return &discovery.DeleteServiceRulesResponse{Response: discovery.CreateResponse(discovery.ErrServiceNotExists, "Service not exist")}, nil
- }
- var delRules []mongo.WriteModel
- for _, ruleID := range request.RuleIds {
- filter := mutil.NewDomainProjectFilter(domain, project, mutil.ServiceID(request.ServiceId), mutil.RuleRuleID(ruleID))
- exist, err := dao.RuleExist(ctx, filter)
- if err != nil {
- return &discovery.DeleteServiceRulesResponse{
- Response: discovery.CreateResponse(discovery.ErrInternal, err.Error()),
- }, err
- }
- if !exist {
- return &discovery.DeleteServiceRulesResponse{
- Response: discovery.CreateResponse(discovery.ErrRuleNotExists, "This rule does not exist."),
- }, nil
- }
- filter = mutil.NewDomainProjectFilter(domain, project, mutil.ServiceID(request.ServiceId), mutil.RuleRuleID(ruleID))
- delRules = append(delRules, mongo.NewDeleteOneModel().SetFilter(filter))
- }
- if len(delRules) > 0 {
- _, err := client.GetMongoClient().BatchDelete(ctx, model.CollectionRule, delRules)
- if err != nil {
- return &discovery.DeleteServiceRulesResponse{
- Response: discovery.CreateResponse(discovery.ErrInternal, err.Error()),
- }, err
- }
- }
- return &discovery.DeleteServiceRulesResponse{
- Response: discovery.CreateResponse(discovery.ResponseSuccess, "Delete service rules successfully."),
- }, nil
-}
-
-func (ds *MetadataManager) UpdateRule(ctx context.Context, request *discovery.UpdateServiceRuleRequest) (*discovery.UpdateServiceRuleResponse, error) {
- domain := util.ParseDomain(ctx)
- project := util.ParseProject(ctx)
- exist, err := ServiceExistID(ctx, request.ServiceId)
- if err != nil {
- return &discovery.UpdateServiceRuleResponse{
- Response: discovery.CreateResponse(discovery.ErrServiceNotExists, "UpdateRule failed for get service failed."),
- }, nil
- }
- if !exist {
- return &discovery.UpdateServiceRuleResponse{
- Response: discovery.CreateResponse(discovery.ErrServiceNotExists, "UpdateRule failed for service not exist."),
- }, nil
- }
- filter := mutil.NewDomainProjectFilter(domain, project, mutil.ServiceID(request.ServiceId))
- rules, err := dao.GetServiceRules(ctx, filter)
- if err != nil {
- return &discovery.UpdateServiceRuleResponse{
- Response: discovery.CreateResponse(discovery.ErrUnavailableBackend, "UpdateRule failed for get rule."),
- }, nil
- }
- if len(rules) >= 1 && rules[0].RuleType != request.Rule.RuleType {
- return &discovery.UpdateServiceRuleResponse{
- Response: discovery.CreateResponse(discovery.ErrModifyRuleNotAllow, "Exist multiple rules, can not change rule type. Rule type is ."+rules[0].RuleType),
- }, nil
- }
- filter = mutil.NewDomainProjectFilter(domain, project, mutil.ServiceID(request.ServiceId), mutil.RuleRuleID(request.RuleId))
- exist, err = dao.RuleExist(ctx, filter)
- if err != nil {
- return &discovery.UpdateServiceRuleResponse{
- Response: discovery.CreateResponse(discovery.ErrInternal, err.Error()),
- }, nil
- }
- if !exist {
- return &discovery.UpdateServiceRuleResponse{
- Response: discovery.CreateResponse(discovery.ErrRuleNotExists, "This rule does not exist."),
- }, nil
- }
- filter = mutil.NewDomainProjectFilter(domain, project, mutil.ServiceID(request.ServiceId), mutil.RuleRuleID(request.RuleId))
- setFilter := mutil.NewFilter(
- mutil.RuleRuleType(request.Rule.RuleType),
- mutil.RulePattern(request.Rule.Pattern),
- mutil.RuleAttribute(request.Rule.Attribute),
- mutil.RuleDescription(request.Rule.Description),
- mutil.RuleModTime(strconv.FormatInt(time.Now().Unix(), baseTen)),
- )
- updateFilter := mutil.NewFilter(mutil.Set(setFilter))
- err = dao.UpdateRule(ctx, filter, updateFilter)
- if err != nil {
- return &discovery.UpdateServiceRuleResponse{
- Response: discovery.CreateResponse(discovery.ErrInternal, err.Error()),
- }, err
- }
- return &discovery.UpdateServiceRuleResponse{
- Response: discovery.CreateResponse(discovery.ResponseSuccess, "Update service rules succesfully."),
- }, nil
-}
-
func (ds *MetadataManager) isSchemaEditable() bool {
return !ds.SchemaNotEditable
}
@@ -1352,17 +1133,6 @@ func getServiceDetailUtil(ctx context.Context, mgs *model.Service, countOnly boo
switch expr {
case "tags":
serviceDetail.Tags = mgs.Tags
- case "rules":
- filter := mutil.NewDomainProjectFilter(domain, project, mutil.ServiceID(mgs.Service.ServiceId))
- rules, err := dao.GetServiceRules(ctx, filter)
- if err != nil {
- log.Error(fmt.Sprintf("get service %s's all rules failed", mgs.Service.ServiceId), err)
- return nil, err
- }
- for _, rule := range rules {
- rule.Timestamp = rule.ModTimestamp
- }
- serviceDetail.Rules = rules
case "instances":
if countOnly {
filter := mutil.NewDomainProjectFilter(domain, project, mutil.InstanceServiceID(serviceID))
@@ -2638,99 +2408,9 @@ func accessible(ctx context.Context, consumerID string, providerID string) *errs
if err != nil {
return discovery.NewError(discovery.ErrPermissionDeny, err.Error())
}
-
- // 黑白名单
- filter = mutil.NewDomainProjectFilter(providerDomain, providerProject, mutil.ServiceID(providerID))
- rules, err := dao.GetRules(ctx, filter)
- if err != nil {
- return discovery.NewError(discovery.ErrInternal, fmt.Sprintf("an error occurred in query provider rules(%s)", err.Error()))
- }
-
- if len(rules) == 0 {
- return nil
- }
- return MatchRules(rules, consumerService.Service, consumerService.Tags)
-}
-
-func MatchRules(rulesOfProvider []*model.Rule, consumer *discovery.MicroService, tagsOfConsumer map[string]string) *errsvc.Error {
- if consumer == nil {
- return discovery.NewError(discovery.ErrInvalidParams, "consumer is nil")
- }
-
- if len(rulesOfProvider) <= 0 {
- return nil
- }
- if rulesOfProvider[0].Rule.RuleType == "WHITE" {
- return patternWhiteList(rulesOfProvider, tagsOfConsumer, consumer)
- }
- return patternBlackList(rulesOfProvider, tagsOfConsumer, consumer)
-}
-
-func parsePattern(v reflect.Value, rule *discovery.ServiceRule, tagsOfConsumer map[string]string, consumerID string) (string, *errsvc.Error) {
- if strings.HasPrefix(rule.Attribute, "tag_") {
- key := rule.Attribute[4:]
- value := tagsOfConsumer[key]
- if len(value) == 0 {
- log.Info(fmt.Sprintf("can not find service[%s] tag[%s]", consumerID, key))
- }
- return value, nil
- }
- key := v.FieldByName(rule.Attribute)
- if !key.IsValid() {
- log.Error(fmt.Sprintf("can not find service[%s] field[%s], ruleID is %s",
- consumerID, rule.Attribute, rule.RuleId), nil)
- return "", discovery.NewError(discovery.ErrInternal, fmt.Sprintf("can not find field '%s'", rule.Attribute))
- }
- return key.String(), nil
-
-}
-
-func patternWhiteList(rulesOfProvider []*model.Rule, tagsOfConsumer map[string]string, consumer *discovery.MicroService) *errsvc.Error {
- v := reflect.Indirect(reflect.ValueOf(consumer))
- consumerID := consumer.ServiceId
- for _, rule := range rulesOfProvider {
- value, err := parsePattern(v, rule.Rule, tagsOfConsumer, consumerID)
- if err != nil {
- return err
- }
- if len(value) == 0 {
- continue
- }
-
- match, _ := regexp.MatchString(rule.Rule.Pattern, value)
- if match {
- log.Info(fmt.Sprintf("consumer[%s][%s/%s/%s/%s] match white list, rule.Pattern is %s, value is %s",
- consumerID, consumer.Environment, consumer.AppId, consumer.ServiceName, consumer.Version,
- rule.Rule.Pattern, value))
- return nil
- }
- }
- return discovery.NewError(discovery.ErrPermissionDeny, "not found in white list")
-}
-
-func patternBlackList(rulesOfProvider []*model.Rule, tagsOfConsumer map[string]string, consumer *discovery.MicroService) *errsvc.Error {
- v := reflect.Indirect(reflect.ValueOf(consumer))
- consumerID := consumer.ServiceId
- for _, rule := range rulesOfProvider {
- var value string
- value, err := parsePattern(v, rule.Rule, tagsOfConsumer, consumerID)
- if err != nil {
- return err
- }
- if len(value) == 0 {
- continue
- }
-
- match, _ := regexp.MatchString(rule.Rule.Pattern, value)
- if match {
- log.Warn(fmt.Sprintf("no permission to access, consumer[%s][%s/%s/%s/%s] match black list, rule.Pattern is %s, value is %s",
- consumerID, consumer.Environment, consumer.AppId, consumer.ServiceName, consumer.Version,
- rule.Rule.Pattern, value))
- return discovery.NewError(discovery.ErrPermissionDeny, "found in black list")
- }
- }
return nil
}
+
func allowAcrossDimension(ctx context.Context, providerService *model.Service, consumerService *model.Service) error {
if providerService.Service.AppId != consumerService.Service.AppId {
if len(providerService.Service.Properties) == 0 {
diff --git a/datasource/mongo/rule_util.go b/datasource/mongo/rule_util.go
deleted file mode 100644
index 5a9bc97..0000000
--- a/datasource/mongo/rule_util.go
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- * 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 mongo
-
-import (
- "context"
-
- "github.com/apache/servicecomb-service-center/datasource/cache"
- "github.com/go-chassis/cari/discovery"
-
- "github.com/apache/servicecomb-service-center/datasource/mongo/client/dao"
- "github.com/apache/servicecomb-service-center/datasource/mongo/client/model"
- mutil "github.com/apache/servicecomb-service-center/datasource/mongo/util"
- "github.com/apache/servicecomb-service-center/pkg/util"
-)
-
-func Filter(ctx context.Context, rules []*model.Rule, consumerID string) (bool, error) {
- consumer, ok := cache.GetServiceByID(ctx, consumerID)
- if !ok {
- var err error
- consumer, err = dao.GetServiceByID(ctx, consumerID)
- if err != nil {
- return false, err
- }
- }
-
- if len(rules) == 0 {
- return true, nil
- }
- domain := util.ParseDomainProject(ctx)
- project := util.ParseProject(ctx)
- filter := mutil.NewDomainProjectFilter(domain, project, mutil.ServiceServiceID(consumerID))
- tags, err := dao.GetTags(ctx, filter)
- if err != nil {
- return false, err
- }
- matchErr := MatchRules(rules, consumer.Service, tags)
- if matchErr != nil {
- if matchErr.Code == discovery.ErrPermissionDeny {
- return false, nil
- }
- return false, matchErr
- }
- return true, nil
-}
-
-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
- }
-
- allowIdx, denyIdx := 0, l
- consumers := make([]string, l)
- for _, consumerID := range consumerIDs {
- ok, err := Filter(ctx, rules, consumerID)
- if err != nil {
- return nil, nil, err
- }
- if ok {
- consumers[allowIdx] = consumerID
- allowIdx++
- } else {
- denyIdx--
- consumers[denyIdx] = consumerID
- }
- }
- return consumers[:allowIdx], consumers[denyIdx:], nil
-}
diff --git a/datasource/mongo/rule_util_test.go b/datasource/mongo/rule_util_test.go
deleted file mode 100644
index f0e5bd4..0000000
--- a/datasource/mongo/rule_util_test.go
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * 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 mongo_test
-
-import (
- "context"
- "errors"
- "testing"
-
- "github.com/stretchr/testify/assert"
-
- "github.com/apache/servicecomb-service-center/datasource"
- "github.com/apache/servicecomb-service-center/datasource/mongo"
- "github.com/apache/servicecomb-service-center/datasource/mongo/client/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(), []*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{""}, []*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{""}, []*model.Rule{{}})
- if err != nil && !errors.Is(err, datasource.ErrNoData) {
- t.Fatalf("RuleFilter FilterAll failed")
- }
- assert.Equal(t, datasource.ErrNoData, err, "no customer found when FilterAll")
- })
-}
diff --git a/datasource/mongo/sd/rule_cache.go b/datasource/mongo/sd/rule_cache.go
deleted file mode 100644
index 8e669c6..0000000
--- a/datasource/mongo/sd/rule_cache.go
+++ /dev/null
@@ -1,163 +0,0 @@
-/*
-* 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 sd
-
-import (
- "reflect"
-
- cmap "github.com/orcaman/concurrent-map"
-
- "github.com/apache/servicecomb-service-center/datasource/mongo/client/model"
- "github.com/apache/servicecomb-service-center/datasource/sdcommon"
- "go.mongodb.org/mongo-driver/bson"
-)
-
-type ruleStore struct {
- dirty bool
- // the key is documentID, is value is mongo document.
- concurrentMap cmap.ConcurrentMap
- // the key is generated by indexFuncs,the value is a set of documentID.
- indexSets IndexCache
-}
-
-func init() {
- RegisterCacher(rule, newRuleStore)
- RuleIndexCols = NewIndexCols()
- RuleIndexCols.AddIndexFunc(RuleServiceIDIndex)
-}
-
-func newRuleStore() *MongoCacher {
- options := DefaultOptions().SetTable(rule)
- cache := &ruleStore{
- dirty: false,
- concurrentMap: cmap.New(),
- indexSets: NewIndexCache(),
- }
- ruleUnmarshal := func(doc bson.Raw) (resource sdcommon.Resource) {
- docID := MongoDocument{}
- err := bson.Unmarshal(doc, &docID)
- if err != nil {
- return
- }
- rule := model.Rule{}
- err = bson.Unmarshal(doc, &rule)
- if err != nil {
- return
- }
- resource.Value = rule
- resource.Key = docID.ID.Hex()
- return
- }
- return NewMongoCacher(options, cache, ruleUnmarshal)
-}
-
-func (s *ruleStore) Name() string {
- return rule
-}
-
-func (s *ruleStore) Size() int {
- return s.concurrentMap.Count()
-}
-
-func (s *ruleStore) Get(key string) interface{} {
- if v, exist := s.concurrentMap.Get(key); exist {
- return v
- }
- return nil
-}
-
-func (s *ruleStore) ForEach(iter func(k string, v interface{}) (next bool)) {
- for k, v := range s.concurrentMap.Items() {
- if !iter(k, v) {
- break
- }
- }
-}
-
-func (s *ruleStore) GetValue(index string) []interface{} {
- docs := s.indexSets.Get(index)
- res := make([]interface{}, 0, len(docs))
- for _, id := range docs {
- if doc, exist := s.concurrentMap.Get(id); exist {
- res = append(res, doc)
- }
- }
- return res
-}
-
-func (s *ruleStore) Dirty() bool {
- return s.dirty
-}
-
-func (s *ruleStore) MarkDirty() {
- s.dirty = true
-}
-
-func (s *ruleStore) Clear() {
- s.dirty = false
- s.concurrentMap.Clear()
- s.indexSets.Clear()
-}
-
-func (s *ruleStore) ProcessUpdate(event MongoEvent) {
- ruleData, ok := event.Value.(model.Rule)
- if !ok {
- return
- }
- if ruleData.Rule == nil {
- return
- }
- // set the document data.
- s.concurrentMap.Set(event.DocumentID, event.Value)
- for _, index := range RuleIndexCols.GetIndexes(ruleData) {
- // set the index sets.
- s.indexSets.Put(index, event.DocumentID)
- }
-}
-
-func (s *ruleStore) ProcessDelete(event MongoEvent) {
- ruleData, ok := s.concurrentMap.Get(event.DocumentID)
- if !ok {
- return
- }
- ruleMongo := ruleData.(model.Rule)
- if ruleMongo.Rule == nil {
- return
- }
- s.concurrentMap.Remove(event.DocumentID)
- for _, index := range RuleIndexCols.GetIndexes(ruleData) {
- s.indexSets.Delete(index, event.DocumentID)
- }
-}
-
-func (s *ruleStore) isValueNotUpdated(value interface{}, newValue interface{}) bool {
- newRule, ok := newValue.(model.Rule)
- if !ok {
- return true
- }
- oldRule, ok := value.(model.Rule)
- if !ok {
- return true
- }
- return reflect.DeepEqual(newRule, oldRule)
-}
-
-func RuleServiceIDIndex(data interface{}) string {
- rule := data.(model.Rule)
- return rule.ServiceID
-}
diff --git a/datasource/mongo/sd/types.go b/datasource/mongo/sd/types.go
index d596cb3..1f53ccd 100644
--- a/datasource/mongo/sd/types.go
+++ b/datasource/mongo/sd/types.go
@@ -30,7 +30,6 @@ import (
const (
service = "service"
instance = "instance"
- rule = "rule"
dep = "dependency"
)
diff --git a/datasource/mongo/sd/typestore.go b/datasource/mongo/sd/typestore.go
index cc55619..d7b3a52 100644
--- a/datasource/mongo/sd/typestore.go
+++ b/datasource/mongo/sd/typestore.go
@@ -123,7 +123,6 @@ func (s *TypeStore) Ready() <-chan struct{} {
func (s *TypeStore) TypeCacher(id string) *MongoCacher { return s.getOrCreateCache(id) }
func (s *TypeStore) Service() *MongoCacher { return s.TypeCacher(service) }
func (s *TypeStore) Instance() *MongoCacher { return s.TypeCacher(instance) }
-func (s *TypeStore) Rule() *MongoCacher { return s.TypeCacher(rule) }
func (s *TypeStore) Dep() *MongoCacher { return s.TypeCacher(dep) }
func Store() *TypeStore {
diff --git a/datasource/mongo/util/db.go b/datasource/mongo/util/db.go
index 8d02367..f87f4fa 100644
--- a/datasource/mongo/util/db.go
+++ b/datasource/mongo/util/db.go
@@ -316,42 +316,6 @@ func SchemaID(schemaID string) Option {
}
}
-func RuleAttribute(attribute string) Option {
- return func(filter bson.M) {
- filter[ConnectWithDot([]string{model.ColumnRule, model.ColumnAttribute})] = attribute
- }
-}
-
-func RuleRuleID(ruleID string) Option {
- return func(filter bson.M) {
- filter[ConnectWithDot([]string{model.ColumnRule, model.ColumnRuleID})] = ruleID
- }
-}
-
-func RuleRuleType(ruleType string) Option {
- return func(filter bson.M) {
- filter[ConnectWithDot([]string{model.ColumnRule, model.ColumnRuleType})] = ruleType
- }
-}
-
-func RulePattern(pattern string) Option {
- return func(filter bson.M) {
- filter[ConnectWithDot([]string{model.ColumnRule, model.ColumnPattern})] = pattern
- }
-}
-
-func RuleDescription(description string) Option {
- return func(filter bson.M) {
- filter[ConnectWithDot([]string{model.ColumnRule, model.ColumnDescription})] = description
- }
-}
-
-func RuleModTime(modTime string) Option {
- return func(filter bson.M) {
- filter[ConnectWithDot([]string{model.ColumnRule, model.ColumnModTime})] = modTime
- }
-}
-
func SchemaSummary(schemaSummary string) Option {
return func(filter bson.M) {
filter[model.ColumnSchemaSummary] = schemaSummary
diff --git a/datasource/ms.go b/datasource/ms.go
index 309ce88..a2751a9 100644
--- a/datasource/ms.go
+++ b/datasource/ms.go
@@ -98,10 +98,4 @@ type MetadataManager interface {
GetTags(ctx context.Context, request *pb.GetServiceTagsRequest) (*pb.GetServiceTagsResponse, error)
UpdateTag(ctx context.Context, request *pb.UpdateServiceTagRequest) (*pb.UpdateServiceTagResponse, error)
DeleteTags(ctx context.Context, request *pb.DeleteServiceTagsRequest) (*pb.DeleteServiceTagsResponse, error)
-
- // White/black list management
- AddRule(ctx context.Context, request *pb.AddServiceRulesRequest) (*pb.AddServiceRulesResponse, error)
- GetRules(ctx context.Context, request *pb.GetServiceRulesRequest) (*pb.GetServiceRulesResponse, error)
- UpdateRule(ctx context.Context, request *pb.UpdateServiceRuleRequest) (*pb.UpdateServiceRuleResponse, error)
- DeleteRule(ctx context.Context, request *pb.DeleteServiceRulesRequest) (*pb.DeleteServiceRulesResponse, error)
}
diff --git a/datasource/rule_test.go b/datasource/rule_test.go
deleted file mode 100644
index 9388c5c..0000000
--- a/datasource/rule_test.go
+++ /dev/null
@@ -1,554 +0,0 @@
-/*
- * 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 datasource_test
-
-import (
- "strconv"
- "testing"
-
- "github.com/apache/servicecomb-service-center/datasource"
- "github.com/apache/servicecomb-service-center/pkg/log"
- "github.com/apache/servicecomb-service-center/server/plugin/quota"
- pb "github.com/go-chassis/cari/discovery"
- "github.com/stretchr/testify/assert"
-)
-
-func TestRule_Add(t *testing.T) {
- var (
- serviceId1 string
- serviceId2 string
- )
-
- t.Run("register service and instance", func(t *testing.T) {
- respCreateService, err := datasource.GetMetadataManager().RegisterService(getContext(), &pb.CreateServiceRequest{
- Service: &pb.MicroService{
- AppId: "create_rule_group_ms",
- ServiceName: "create_rule_service_ms",
- Version: "1.0.0",
- Level: "FRONT",
- Status: pb.MS_UP,
- },
- })
- assert.NoError(t, err)
- assert.Equal(t, pb.ResponseSuccess, respCreateService.Response.GetCode())
- serviceId1 = respCreateService.ServiceId
-
- respCreateService, err = datasource.GetMetadataManager().RegisterService(getContext(), &pb.CreateServiceRequest{
- Service: &pb.MicroService{
- AppId: "create_rule_group_ms",
- ServiceName: "create_rule_service_ms",
- Version: "1.0.1",
- Level: "FRONT",
- Status: pb.MS_UP,
- },
- })
- assert.NoError(t, err)
- assert.Equal(t, pb.ResponseSuccess, respCreateService.Response.GetCode())
- serviceId2 = respCreateService.ServiceId
- })
-
- t.Run("invalid request", func(t *testing.T) {
- log.Info("service does not exist")
- respAddRule, err := datasource.GetMetadataManager().AddRule(getContext(), &pb.AddServiceRulesRequest{
- ServiceId: "not_exist_service_ms",
- Rules: []*pb.AddOrUpdateServiceRule{
- {
- RuleType: "BLACK",
- Attribute: "ServiceName",
- Pattern: "Test*",
- Description: "test white",
- },
- },
- })
- assert.NoError(t, err)
- assert.NotEqual(t, pb.ResponseSuccess, respAddRule)
- })
-
- t.Run("request is valid", func(t *testing.T) {
- log.Info("create a new black list")
- respAddRule, err := datasource.GetMetadataManager().AddRule(getContext(), &pb.AddServiceRulesRequest{
- ServiceId: serviceId1,
- Rules: []*pb.AddOrUpdateServiceRule{
- {
- RuleType: "BLACK",
- Attribute: "ServiceName",
- Pattern: "Test*",
- Description: "test black",
- },
- },
- })
- assert.NoError(t, err)
- assert.Equal(t, pb.ResponseSuccess, respAddRule.Response.GetCode())
- ruleId := respAddRule.RuleIds[0]
- assert.NotEqual(t, "", ruleId)
-
- log.Info("create the black list again")
- respAddRule, err = datasource.GetMetadataManager().AddRule(getContext(), &pb.AddServiceRulesRequest{
- ServiceId: serviceId1,
- Rules: []*pb.AddOrUpdateServiceRule{
- {
- RuleType: "BLACK",
- Attribute: "ServiceName",
- Pattern: "Test*",
- Description: "test change black",
- },
- },
- })
- assert.NoError(t, err)
- assert.Equal(t, pb.ResponseSuccess, respAddRule.Response.GetCode())
- assert.Equal(t, 0, len(respAddRule.RuleIds))
-
- log.Info("create a new white list when black list already exists")
- respAddRule, err = datasource.GetMetadataManager().AddRule(getContext(), &pb.AddServiceRulesRequest{
- ServiceId: serviceId1,
- Rules: []*pb.AddOrUpdateServiceRule{
- {
- RuleType: "WHITE",
- Attribute: "ServiceName",
- Pattern: "Test*",
- Description: "test white",
- },
- },
- })
- assert.NoError(t, err)
- assert.NotEqual(t, pb.ResponseSuccess, respAddRule.Response.GetCode())
- })
-
- t.Run("create rule out of gaugue", func(t *testing.T) {
- size := quota.DefaultRuleQuota + 1
- rules := make([]*pb.AddOrUpdateServiceRule, 0, size)
- for i := 0; i < size; i++ {
- rules = append(rules, &pb.AddOrUpdateServiceRule{
- RuleType: "BLACK",
- Attribute: "ServiceName",
- Pattern: strconv.Itoa(i),
- Description: "test white",
- })
- }
-
- resp, err := datasource.GetMetadataManager().AddRule(getContext(), &pb.AddServiceRulesRequest{
- ServiceId: serviceId2,
- Rules: rules[:size-1],
- })
- assert.NoError(t, err)
- assert.Equal(t, pb.ResponseSuccess, resp.Response.GetCode())
-
- resp, err = datasource.GetMetadataManager().AddRule(getContext(), &pb.AddServiceRulesRequest{
- ServiceId: serviceId2,
- Rules: rules[size-1:],
- })
- assert.NoError(t, err)
- assert.Equal(t, pb.ErrNotEnoughQuota, resp.Response.GetCode())
- })
-}
-
-func TestRule_Get(t *testing.T) {
- var (
- serviceId string
- ruleId string
- )
-
- t.Run("register service and rules", func(t *testing.T) {
- respCreateService, err := datasource.GetMetadataManager().RegisterService(getContext(), &pb.CreateServiceRequest{
- Service: &pb.MicroService{
- AppId: "get_rule_group_ms",
- ServiceName: "get_rule_service_ms",
- Version: "1.0.0",
- Level: "FRONT",
- Status: pb.MS_UP,
- },
- })
- assert.NoError(t, err)
- assert.Equal(t, pb.ResponseSuccess, respCreateService.Response.GetCode())
- serviceId = respCreateService.ServiceId
-
- respAddRule, err := datasource.GetMetadataManager().AddRule(getContext(), &pb.AddServiceRulesRequest{
- ServiceId: serviceId,
- Rules: []*pb.AddOrUpdateServiceRule{
- {
- RuleType: "BLACK",
- Attribute: "ServiceName",
- Pattern: "Test*",
- Description: "test BLACK",
- },
- },
- })
- assert.NoError(t, err)
- assert.Equal(t, pb.ResponseSuccess, respAddRule.Response.GetCode())
- ruleId = respAddRule.RuleIds[0]
- assert.NotEqual(t, "", ruleId)
- })
-
- t.Run("get when request is invalid", func(t *testing.T) {
- log.Info("service not exists")
- respGetRule, err := datasource.GetMetadataManager().GetRules(getContext(), &pb.GetServiceRulesRequest{
- ServiceId: "not_exist_service_ms",
- })
- assert.NoError(t, err)
- assert.Equal(t, pb.ErrServiceNotExists, respGetRule.Response.GetCode())
- })
-
- t.Run("get when request is valid", func(t *testing.T) {
- respGetRule, err := datasource.GetMetadataManager().GetRules(getContext(), &pb.GetServiceRulesRequest{
- ServiceId: serviceId,
- })
- assert.NoError(t, err)
- assert.Equal(t, pb.ResponseSuccess, respGetRule.Response.GetCode())
- assert.Equal(t, ruleId, respGetRule.Rules[0].RuleId)
- })
-}
-
-func TestRule_Update(t *testing.T) {
- var (
- serviceId string
- ruleId string
- )
-
- t.Run("create service and rules", func(t *testing.T) {
- respCreateService, err := datasource.GetMetadataManager().RegisterService(getContext(), &pb.CreateServiceRequest{
- Service: &pb.MicroService{
- AppId: "update_rule_group_ms",
- ServiceName: "update_rule_service_ms",
- Version: "1.0.0",
- Level: "FRONT",
- Status: pb.MS_UP,
- },
- })
- assert.NoError(t, err)
- assert.Equal(t, pb.ResponseSuccess, respCreateService.Response.GetCode())
- serviceId = respCreateService.ServiceId
-
- respAddRule, err := datasource.GetMetadataManager().AddRule(getContext(), &pb.AddServiceRulesRequest{
- ServiceId: serviceId,
- Rules: []*pb.AddOrUpdateServiceRule{
- {
- RuleType: "BLACK",
- Attribute: "ServiceName",
- Pattern: "Test*",
- Description: "test BLACK",
- },
- },
- })
- assert.NoError(t, err)
- assert.Equal(t, pb.ResponseSuccess, respAddRule.Response.GetCode())
- ruleId = respAddRule.RuleIds[0]
- assert.NotEqual(t, "", ruleId)
- })
-
- t.Run("update when request is invalid", func(t *testing.T) {
- rule := &pb.AddOrUpdateServiceRule{
- RuleType: "BLACK",
- Attribute: "ServiceName",
- Pattern: "Test*",
- Description: "test BLACK update",
- }
- log.Info("service does not exist")
- resp, err := datasource.GetMetadataManager().UpdateRule(getContext(), &pb.UpdateServiceRuleRequest{
- ServiceId: "not_exist_service_ms",
- RuleId: ruleId,
- Rule: rule,
- })
- assert.NoError(t, err)
- assert.NotEqual(t, pb.ResponseSuccess, resp.Response.GetCode())
-
- log.Info("rule not exists")
- resp, err = datasource.GetMetadataManager().UpdateRule(getContext(), &pb.UpdateServiceRuleRequest{
- ServiceId: serviceId,
- RuleId: "not_exist_rule_ms",
- Rule: rule,
- })
- assert.NoError(t, err)
- assert.NotEqual(t, pb.ResponseSuccess, resp.Response.GetCode())
-
- log.Info("change rule type")
- resp, err = datasource.GetMetadataManager().UpdateRule(getContext(), &pb.UpdateServiceRuleRequest{
- ServiceId: serviceId,
- RuleId: ruleId,
- Rule: &pb.AddOrUpdateServiceRule{
- RuleType: "WHITE",
- Attribute: "ServiceName",
- Pattern: "Test*",
- Description: "test white update",
- },
- })
- assert.NoError(t, err)
- assert.NotEqual(t, pb.ResponseSuccess, resp.Response.GetCode())
- })
-
- t.Run("update when request is valid", func(t *testing.T) {
- resp, err := datasource.GetMetadataManager().UpdateRule(getContext(), &pb.UpdateServiceRuleRequest{
- ServiceId: serviceId,
- RuleId: ruleId,
- Rule: &pb.AddOrUpdateServiceRule{
- RuleType: "BLACK",
- Attribute: "AppId",
- Pattern: "Test*",
- Description: "test white update",
- },
- })
- assert.NoError(t, err)
- assert.Equal(t, pb.ResponseSuccess, resp.Response.GetCode())
- })
-}
-
-func TestRule_Delete(t *testing.T) {
- var (
- serviceId string
- ruleId string
- )
- t.Run("register service and rules", func(t *testing.T) {
- respCreateService, err := datasource.GetMetadataManager().RegisterService(getContext(), &pb.CreateServiceRequest{
- Service: &pb.MicroService{
- AppId: "delete_rule_group_ms",
- ServiceName: "delete_rule_service_ms",
- Version: "1.0.0",
- Level: "FRONT",
- Status: pb.MS_UP,
- },
- })
- assert.NoError(t, err)
- assert.Equal(t, pb.ResponseSuccess, respCreateService.Response.GetCode())
- serviceId = respCreateService.ServiceId
-
- respAddRule, err := datasource.GetMetadataManager().AddRule(getContext(), &pb.AddServiceRulesRequest{
- ServiceId: serviceId,
- Rules: []*pb.AddOrUpdateServiceRule{
- {
- RuleType: "BLACK",
- Attribute: "ServiceName",
- Pattern: "Test*",
- Description: "test BLACK",
- },
- },
- })
- assert.NoError(t, err)
- assert.Equal(t, pb.ResponseSuccess, respAddRule.Response.GetCode())
- ruleId = respAddRule.RuleIds[0]
- assert.NotEqual(t, "", ruleId)
- })
-
- t.Run("delete when request is invalid", func(t *testing.T) {
- log.Info("service not exist")
- resp, err := datasource.GetMetadataManager().DeleteRule(getContext(), &pb.DeleteServiceRulesRequest{
- ServiceId: "not_exist_service_ms",
- RuleIds: []string{"1000000"},
- })
- assert.NoError(t, err)
- assert.Equal(t, pb.ErrServiceNotExists, resp.Response.GetCode())
-
- log.Info("rule not exist")
- resp, err = datasource.GetMetadataManager().DeleteRule(getContext(), &pb.DeleteServiceRulesRequest{
- ServiceId: serviceId,
- RuleIds: []string{"not_exist_rule"},
- })
- assert.NoError(t, err)
- assert.Equal(t, pb.ErrRuleNotExists, resp.Response.GetCode())
- })
-
- t.Run("delete when request is valid", func(t *testing.T) {
- resp, err := datasource.GetMetadataManager().DeleteRule(getContext(), &pb.DeleteServiceRulesRequest{
- ServiceId: serviceId,
- RuleIds: []string{ruleId},
- })
- assert.NoError(t, err)
- assert.Equal(t, pb.ResponseSuccess, resp.Response.GetCode())
-
- respGetRule, err := datasource.GetMetadataManager().GetRules(getContext(), &pb.GetServiceRulesRequest{
- ServiceId: serviceId,
- })
- assert.NoError(t, err)
- assert.Equal(t, pb.ResponseSuccess, resp.Response.GetCode())
- assert.Equal(t, 0, len(respGetRule.Rules))
- })
-}
-
-func TestRule_Permission(t *testing.T) {
- var (
- consumerVersion string
- consumerTag string
- providerBlack string
- providerWhite string
- )
- t.Run("register service and rules", func(t *testing.T) {
- respCreateService, err := datasource.GetMetadataManager().RegisterService(getContext(), &pb.CreateServiceRequest{
- Service: &pb.MicroService{
- AppId: "query_instance_tag_ms",
- ServiceName: "query_instance_version_consumer_ms",
- Version: "1.0.0",
- Level: "FRONT",
- Status: pb.MS_UP,
- },
- })
- assert.NoError(t, err)
- assert.Equal(t, pb.ResponseSuccess, respCreateService.Response.GetCode())
- consumerVersion = respCreateService.ServiceId
-
- respCreateService, err = datasource.GetMetadataManager().RegisterService(getContext(), &pb.CreateServiceRequest{
- Service: &pb.MicroService{
- AppId: "query_instance_tag_ms",
- ServiceName: "query_instance_tag_service_ms",
- Version: "1.0.2",
- Level: "FRONT",
- Status: pb.MS_UP,
- },
- })
- assert.NoError(t, err)
- assert.Equal(t, pb.ResponseSuccess, respCreateService.Response.GetCode())
- providerBlack = respCreateService.ServiceId
-
- respAddRule, err := datasource.GetMetadataManager().AddRule(getContext(), &pb.AddServiceRulesRequest{
- ServiceId: providerBlack,
- Rules: []*pb.AddOrUpdateServiceRule{
- {
- RuleType: "BLACK",
- Attribute: "Version",
- Pattern: "1.0.0",
- },
- {
- RuleType: "BLACK",
- Attribute: "tag_a",
- Pattern: "b",
- },
- },
- })
- assert.NoError(t, err)
- assert.Equal(t, pb.ResponseSuccess, respAddRule.Response.GetCode())
-
- respCreateService, err = datasource.GetMetadataManager().RegisterService(getContext(), &pb.CreateServiceRequest{
- Service: &pb.MicroService{
- AppId: "query_instance_tag_ms",
- ServiceName: "query_instance_tag_service_ms",
- Version: "1.0.3",
- Level: "FRONT",
- Status: pb.MS_UP,
- },
- })
- assert.NoError(t, err)
- assert.Equal(t, pb.ResponseSuccess, respCreateService.Response.GetCode())
- providerWhite = respCreateService.ServiceId
-
- respAddRule, err = datasource.GetMetadataManager().AddRule(getContext(), &pb.AddServiceRulesRequest{
- ServiceId: providerWhite,
- Rules: []*pb.AddOrUpdateServiceRule{
- {
- RuleType: "WHITE",
- Attribute: "Version",
- Pattern: "1.0.0",
- },
- {
- RuleType: "WHITE",
- Attribute: "tag_a",
- Pattern: "b",
- },
- },
- })
- assert.NoError(t, err)
- assert.Equal(t, pb.ResponseSuccess, respAddRule.Response.GetCode())
-
- respCreateService, err = datasource.GetMetadataManager().RegisterService(getContext(), &pb.CreateServiceRequest{
- Service: &pb.MicroService{
- AppId: "query_instance_tag_ms",
- ServiceName: "query_instance_tag_consumer_ms",
- Version: "1.0.4",
- Level: "FRONT",
- Status: pb.MS_UP,
- },
- })
- assert.NoError(t, err)
- assert.Equal(t, pb.ResponseSuccess, respCreateService.Response.GetCode())
- consumerTag = respCreateService.ServiceId
-
- respAddTag, err := datasource.GetMetadataManager().AddTags(getContext(), &pb.AddServiceTagsRequest{
- ServiceId: consumerTag,
- Tags: map[string]string{"a": "b"},
- })
- assert.NoError(t, err)
- assert.Equal(t, pb.ResponseSuccess, respAddTag.Response.GetCode())
- })
-
- t.Run("when query instances", func(t *testing.T) {
- log.Info("consumer version in black list")
- resp, err := datasource.GetMetadataManager().GetInstances(getContext(), &pb.GetInstancesRequest{
- ConsumerServiceId: consumerVersion,
- ProviderServiceId: providerBlack,
- })
- assert.NoError(t, err)
- assert.Equal(t, pb.ErrServiceNotExists, resp.Response.GetCode())
-
- log.Info("consumer tag in black list")
- resp, err = datasource.GetMetadataManager().GetInstances(getContext(), &pb.GetInstancesRequest{
- ConsumerServiceId: consumerTag,
- ProviderServiceId: providerBlack,
- })
- assert.NoError(t, err)
- assert.Equal(t, pb.ErrServiceNotExists, resp.Response.GetCode())
-
- log.Info("find should return 200 even if consumer permission deny")
- respFind, err := datasource.GetMetadataManager().FindInstances(getContext(), &pb.FindInstancesRequest{
- ConsumerServiceId: consumerVersion,
- AppId: "query_instance_tag_ms",
- ServiceName: "query_instance_tag_service_ms",
- VersionRule: "0+",
- })
- assert.NoError(t, err)
- assert.Equal(t, pb.ResponseSuccess, respFind.Response.GetCode())
- assert.Equal(t, 0, len(respFind.Instances))
-
- respFind, err = datasource.GetMetadataManager().FindInstances(getContext(), &pb.FindInstancesRequest{
- ConsumerServiceId: consumerTag,
- AppId: "query_instance_tag_ms",
- ServiceName: "query_instance_tag_service_ms",
- VersionRule: "0+",
- })
- assert.NoError(t, err)
- assert.Equal(t, pb.ResponseSuccess, respFind.Response.GetCode())
- assert.Equal(t, 0, len(respFind.Instances))
-
- log.Info("consumer not in black list")
- resp, err = datasource.GetMetadataManager().GetInstances(getContext(), &pb.GetInstancesRequest{
- ConsumerServiceId: providerWhite,
- ProviderServiceId: providerBlack,
- })
- assert.NoError(t, err)
- assert.Equal(t, pb.ResponseSuccess, resp.Response.GetCode())
-
- log.Info("consumer not in white list")
- resp, err = datasource.GetMetadataManager().GetInstances(getContext(), &pb.GetInstancesRequest{
- ConsumerServiceId: providerBlack,
- ProviderServiceId: providerWhite,
- })
- assert.NoError(t, err)
- assert.Equal(t, pb.ErrServiceNotExists, resp.Response.GetCode())
-
- log.Info("consumer version in white list")
- resp, err = datasource.GetMetadataManager().GetInstances(getContext(), &pb.GetInstancesRequest{
- ConsumerServiceId: consumerVersion,
- ProviderServiceId: providerWhite,
- })
- assert.NoError(t, err)
- assert.Equal(t, pb.ResponseSuccess, resp.Response.GetCode())
-
- log.Info("consumer tag in white list")
- resp, err = datasource.GetMetadataManager().GetInstances(getContext(), &pb.GetInstancesRequest{
- ConsumerServiceId: consumerTag,
- ProviderServiceId: providerWhite,
- })
- assert.NoError(t, err)
- assert.Equal(t, pb.ResponseSuccess, resp.Response.GetCode())
- })
-}
diff --git a/docs/openapi/v4.yaml b/docs/openapi/v4.yaml
index a84242c..beb610a 100644
--- a/docs/openapi/v4.yaml
+++ b/docs/openapi/v4.yaml
@@ -440,168 +440,6 @@ paths:
description: 内部错误
schema:
$ref: '#/definitions/Error'
- /v4/{project}/registry/microservices/{serviceId}/rules:
- post:
- description: |
- 为serviceId的服务新增黑白名单，同一服务，attribute和pattern唯一标识一份黑白名单。
- operationId: addRule
- parameters:
- - name: x-domain-name
- in: header
- type: string
- default: default
- - name: project
- in: path
- required: true
- type: string
- - name: serviceId
- in: path
- description: 微服务唯一标识。
- required: true
- type: string
- - name: rules
- in: body
- description: 新增黑白名单。
- required: true
- schema:
- $ref: '#/definitions/AddRules'
- tags:
- - microservices
- - rules
- responses:
- 200:
- description: 创建成功
- schema:
- $ref: '#/definitions/AddRuleResponse'
- 400:
- description: 错误的请求
- schema:
- $ref: '#/definitions/Error'
- 500:
- description: 内部错误
- schema:
- $ref: '#/definitions/Error'
- get:
- description: |
- 获取serviceId的服务的黑白名单信息。
- operationId: getRule
- parameters:
- - name: x-domain-name
- in: header
- required: true
- type: string
- default: default
- - name: project
- in: path
- required: true
- type: string
- - name: serviceId
- in: path
- description: 微服务唯一标识。
- required: true
- type: string
- tags:
- - microservices
- - rules
- responses:
- 200:
- description: 查询成功
- schema:
- $ref: '#/definitions/Rules'
- 400:
- description: 错误的请求
- schema:
- $ref: '#/definitions/Error'
- 500:
- description: 内部错误
- schema:
- $ref: '#/definitions/Error'
- /v4/{project}/registry/microservices/{serviceId}/rules/{ruleId}:
- put:
- description: |
- 为serviceId的服务更新黑白名单。
- operationId: updateRule
- parameters:
- - name: x-domain-name
- in: header
- type: string
- default: default
- - name: project
- in: path
- required: true
- type: string
- - name: serviceId
- in: path
- description: 微服务唯一标识。
- required: true
- type: string
- - name: ruleId
- in: path
- description: ruleId。
- required: true
- type: string
- - name: rule
- in: body
- description: 要更新的rule
- required: true
- schema:
- $ref: "#/definitions/AddOrUpdateRule"
- tags:
- - microservices
- - rules
- responses:
- 200:
- description: 修改成功
- schema:
- type: string
- 400:
- description: 错误的请求
- schema:
- $ref: '#/definitions/Error'
- 500:
- description: 内部错误
- schema:
- $ref: '#/definitions/Error'
- delete:
- description: |
- 为serviceId的服务删除黑白名单。
- operationId: deleteRule
- parameters:
- - name: x-domain-name
- in: header
- required: true
- type: string
- default: default
- - name: project
- in: path
- required: true
- type: string
- - name: serviceId
- in: path
- description: 微服务唯一标识。
- required: true
- type: string
- - name: ruleId
- in: path
- description: ruleId。
- required: true
- type: string
- tags:
- - microservices
- - rules
- responses:
- 200:
- description: 删除成功
- schema:
- type: string
- 400:
- description: 错误的请求
- schema:
- $ref: '#/definitions/Error'
- 500:
- description: 内部错误
- schema:
- $ref: '#/definitions/Error'
/v4/{project}/registry/microservices/{serviceId}/schemas/{schemaId}:
get:
description: |
diff --git a/etc/conf/app.yaml b/etc/conf/app.yaml
index 995eafc..5964b41 100644
--- a/etc/conf/app.yaml
+++ b/etc/conf/app.yaml
@@ -180,8 +180,6 @@ quota:
limit: 150000
schema:
limit: 100
- rule:
- limit: 100
tag:
limit: 100
account:
diff --git a/integration/rules_test.go b/integration/rules_test.go
deleted file mode 100644
index a031950..0000000
--- a/integration/rules_test.go
+++ /dev/null
@@ -1,527 +0,0 @@
-/*
- * 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 integrationtest_test
-
-import (
- "bytes"
- "encoding/json"
- "io/ioutil"
- "math/rand"
- "net/http"
- "strconv"
- "strings"
- "time"
-
- . "github.com/apache/servicecomb-service-center/integration"
- . "github.com/onsi/ginkgo"
- . "github.com/onsi/gomega"
- "github.com/widuu/gojson"
-)
-
-var _ = Describe("MicroService Api Test", func() {
- var serviceName = "integrationtestInstances"
- var serviceId = ""
- var serviceAppId = "integrationtestAppIdInstance"
- var serviceVersion = "0.0.2"
- var ruleID = ""
- Context("Tesing MicroService Rules API's", func() {
- BeforeEach(func() {
- schema := []string{"testSchema"}
- properties := map[string]string{"attr1": "aa"}
- servicemap := map[string]interface{}{
- "serviceName": serviceName + strconv.Itoa(rand.Int()),
- "appId": serviceAppId,
- "version": serviceVersion,
- "description": "examples",
- "level": "FRONT",
- "schemas": schema,
- "status": "UP",
- "properties": properties,
- }
- bodyParams := map[string]interface{}{
- "service": servicemap,
- }
- body, _ := json.Marshal(bodyParams)
- bodyBuf := bytes.NewReader(body)
- req, _ := http.NewRequest(POST, SCURL+REGISTERMICROSERVICE, bodyBuf)
- req.Header.Set("X-Domain-Name", "default")
- resp, err := scclient.Do(req)
- Expect(err).To(BeNil())
- defer resp.Body.Close()
-
- // Validate the service creation
- Expect(resp.StatusCode).To(Equal(http.StatusOK))
- respbody, _ := ioutil.ReadAll(resp.Body)
- serviceId = gojson.Json(string(respbody)).Get("serviceId").Tostring()
- Expect(len(serviceId)).Should(BeNumerically("==", LengthUUID))
- })
-
- AfterEach(func() {
- if serviceId != "" {
- url := strings.Replace(UNREGISTERMICROSERVICE, ":serviceId", serviceId, 1)
- req, _ := http.NewRequest(DELETE, SCURL+url, nil)
- req.Header.Set("X-Domain-Name", "default")
- resp, _ := scclient.Do(req)
- Expect(resp.StatusCode).To(Equal(http.StatusOK))
- }
-
- })
-
- By("Create Micro-Service Rules API", func() {
- It("Create MicroService Rules", func() {
- rules := map[string]interface{}{
- "ruleType": "WHITE",
- "attribute": "tag_a",
- "pattern": "a+",
- "description": "test ",
- }
- rulesArray := []interface{}{rules}
- bodyParams := map[string][]interface{}{
- "rules": rulesArray,
- }
- url := strings.Replace(ADDRULE, ":serviceId", serviceId, 1)
- body, _ := json.Marshal(bodyParams)
- bodyBuf := bytes.NewReader(body)
- req, _ := http.NewRequest(POST, SCURL+url, bodyBuf)
- req.Header.Set("X-Domain-Name", "default")
- resp, err := scclient.Do(req)
- Expect(err).To(BeNil())
- defer resp.Body.Close()
-
- Expect(resp.StatusCode).To(Equal(http.StatusOK))
- })
-
- It("Create MicroService Rules with empty rules", func() {
- rules := map[string]interface{}{}
- rulesArray := []interface{}{rules}
- bodyParams := map[string][]interface{}{
- "rules": rulesArray,
- }
- url := strings.Replace(ADDRULE, ":serviceId", serviceId, 1)
- body, _ := json.Marshal(bodyParams)
- bodyBuf := bytes.NewReader(body)
- req, _ := http.NewRequest(POST, SCURL+url, bodyBuf)
- req.Header.Set("X-Domain-Name", "default")
- resp, err := scclient.Do(req)
- Expect(err).To(BeNil())
- defer resp.Body.Close()
-
- Expect(resp.StatusCode).To(Equal(http.StatusBadRequest))
- })
-
- It("Create MicroService Rules with wrong Rule Type", func() {
- rules := map[string]interface{}{
- "ruleType": "UKNOWN",
- "attribute": "tag_a",
- "pattern": "a+",
- "description": "test ",
- }
- rulesArray := []interface{}{rules}
- bodyParams := map[string][]interface{}{
- "rules": rulesArray,
- }
- url := strings.Replace(ADDRULE, ":serviceId", serviceId, 1)
- body, _ := json.Marshal(bodyParams)
- bodyBuf := bytes.NewReader(body)
- req, _ := http.NewRequest(POST, SCURL+url, bodyBuf)
- req.Header.Set("X-Domain-Name", "default")
- resp, err := scclient.Do(req)
- Expect(err).To(BeNil())
- defer resp.Body.Close()
-
- Expect(resp.StatusCode).To(Equal(http.StatusBadRequest))
- })
-
- It("Create MicroService Rules with worng service ID", func() {
- rules := map[string]interface{}{}
- rulesArray := []interface{}{rules}
- bodyParams := map[string][]interface{}{
- "rules": rulesArray,
- }
- url := strings.Replace(ADDRULE, ":serviceId", "XXXXXX", 1)
- body, _ := json.Marshal(bodyParams)
- bodyBuf := bytes.NewReader(body)
- req, _ := http.NewRequest(POST, SCURL+url, bodyBuf)
- req.Header.Set("X-Domain-Name", "default")
- resp, err := scclient.Do(req)
- Expect(err).To(BeNil())
- defer resp.Body.Close()
-
- Expect(resp.StatusCode).To(Equal(http.StatusBadRequest))
- })
-
- It("Create MicroService Rules with duplicate rules", func() {
- rules := map[string]interface{}{
- "ruleType": "WHITE",
- "attribute": "tag_a",
- "pattern": "a+",
- "description": "test ",
- }
- rulesArray := []interface{}{rules}
- bodyParams := map[string][]interface{}{
- "rules": rulesArray,
- }
- url := strings.Replace(ADDRULE, ":serviceId", serviceId, 1)
- body, _ := json.Marshal(bodyParams)
- bodyBuf := bytes.NewReader(body)
- req, _ := http.NewRequest(POST, SCURL+url, bodyBuf)
- req.Header.Set("X-Domain-Name", "default")
- resp, err := scclient.Do(req)
- Expect(err).To(BeNil())
- defer resp.Body.Close()
-
- Expect(resp.StatusCode).To(Equal(http.StatusOK))
-
- //Duplicate Request
- <-time.After(time.Second)
- bodyBuf = bytes.NewReader(body)
- req, _ = http.NewRequest(POST, SCURL+url, bodyBuf)
- req.Header.Set("X-Domain-Name", "default")
- resp, err = scclient.Do(req)
- Expect(err).To(BeNil())
- defer resp.Body.Close()
-
- Expect(resp.StatusCode).To(Equal(http.StatusOK))
-
- respbody, _ := ioutil.ReadAll(resp.Body)
- Expect(strings.TrimSpace(string(respbody))).To(Equal("{}"))
- })
- })
-
- By("Get Micro-Service Rules API", func() {
- It("Get Rules for MicroService", func() {
- //Add Rules
- rules := map[string]interface{}{
- "ruleType": "WHITE",
- "attribute": "tag_a",
- "pattern": "a+",
- "description": "test ",
- }
- rulesArray := []interface{}{rules}
- bodyParams := map[string][]interface{}{
- "rules": rulesArray,
- }
- url := strings.Replace(ADDRULE, ":serviceId", serviceId, 1)
- body, _ := json.Marshal(bodyParams)
- bodyBuf := bytes.NewReader(body)
- req, _ := http.NewRequest(POST, SCURL+url, bodyBuf)
- req.Header.Set("X-Domain-Name", "default")
- resp, err := scclient.Do(req)
- Expect(err).To(BeNil())
- defer resp.Body.Close()
-
- Expect(resp.StatusCode).To(Equal(http.StatusOK))
-
- //Get Rules
- <-time.After(time.Second)
- url = strings.Replace(GETRULES, ":serviceId", serviceId, 1)
- req, _ = http.NewRequest(GET, SCURL+url, nil)
- req.Header.Set("X-Domain-Name", "default")
- req.Header.Set("X-ConsumerId", serviceId)
- resp, _ = scclient.Do(req)
- respbody, _ := ioutil.ReadAll(resp.Body)
- Expect(resp.StatusCode).To(Equal(http.StatusOK))
- rulesStruct := map[string][]map[string]interface{}{}
- json.Unmarshal(respbody, &rulesStruct)
- for _, rule := range rulesStruct["rules"] {
- Expect(rule["ruleType"]).To(Equal("WHITE"))
- Expect(rule["attribute"]).To(Equal("tag_a"))
- Expect(rule["pattern"]).To(Equal("a+"))
- }
- })
-
- It("Get Empty Rules for MicroService", func() {
- //Get Rules
- url := strings.Replace(GETRULES, ":serviceId", serviceId, 1)
- req, _ := http.NewRequest(GET, SCURL+url, nil)
- req.Header.Set("X-Domain-Name", "default")
- req.Header.Set("X-ConsumerId", serviceId)
- resp, _ := scclient.Do(req)
- respbody, _ := ioutil.ReadAll(resp.Body)
- Expect(resp.StatusCode).To(Equal(http.StatusOK))
- Expect(strings.TrimSpace(string(respbody))).To(Equal("{}"))
- })
-
- It("Get Rules for Invalid MicroService", func() {
- //Get Rules
- url := strings.Replace(GETRULES, ":serviceId", "XXXX", 1)
- req, _ := http.NewRequest(GET, SCURL+url, nil)
- req.Header.Set("X-Domain-Name", "default")
- resp, _ := scclient.Do(req)
- Expect(resp.StatusCode).To(Equal(http.StatusBadRequest))
- })
-
- })
- By("Update Micro-Service Rules API", func() {
- It("Update MicroService rules with proper value", func() {
- //Add Rules
- rules := map[string]interface{}{
- "ruleType": "WHITE",
- "attribute": "tag_a",
- "pattern": "a+",
- "description": "test ",
- }
- rulesArray := []interface{}{rules}
- bodyParams := map[string][]interface{}{
- "rules": rulesArray,
- }
- url := strings.Replace(ADDRULE, ":serviceId", serviceId, 1)
- body, _ := json.Marshal(bodyParams)
- bodyBuf := bytes.NewReader(body)
- req, _ := http.NewRequest(POST, SCURL+url, bodyBuf)
- req.Header.Set("X-Domain-Name", "default")
- resp, err := scclient.Do(req)
- Expect(err).To(BeNil())
- defer resp.Body.Close()
-
- //Get the rule ID
- respbody, _ := ioutil.ReadAll(resp.Body)
- Expect(resp.StatusCode).To(Equal(http.StatusOK))
- rulesCreateRespStruct := map[string][]string{}
- json.Unmarshal(respbody, &rulesCreateRespStruct)
- for _, rule := range rulesCreateRespStruct["RuleIds"] {
- ruleID = rule
- break
- }
-
- //Update Rules
- <-time.After(time.Second)
- updateParams := map[string]interface{}{
- "ruleType": "WHITE",
- "attribute": "tag_b",
- "pattern": "a+",
- "description": "test ",
- }
- url = strings.Replace(UPDATERULES, ":serviceId", serviceId, 1)
- url = strings.Replace(url, ":rule_id", ruleID, 1)
- body, _ = json.Marshal(updateParams)
- bodyBuf = bytes.NewReader(body)
- req, _ = http.NewRequest(UPDATE, SCURL+url, bodyBuf)
- req.Header.Set("X-Domain-Name", "default")
- resp, err = scclient.Do(req)
- Expect(err).To(BeNil())
- defer resp.Body.Close()
- respbody, _ = ioutil.ReadAll(resp.Body)
- Expect(resp.StatusCode).To(Equal(http.StatusOK))
-
- //Get Rules
- <-time.After(time.Second)
- url = strings.Replace(GETRULES, ":serviceId", serviceId, 1)
- req, _ = http.NewRequest(GET, SCURL+url, nil)
- req.Header.Set("X-Domain-Name", "default")
- req.Header.Set("X-ConsumerId", serviceId)
- resp, _ = scclient.Do(req)
- respbody, _ = ioutil.ReadAll(resp.Body)
- Expect(resp.StatusCode).To(Equal(http.StatusOK))
- rulesStruct := map[string][]map[string]interface{}{}
- json.Unmarshal(respbody, &rulesStruct)
- for _, rule := range rulesStruct["rules"] {
- Expect(rule["ruleType"]).To(Equal("WHITE"))
- Expect(rule["attribute"]).To(Equal("tag_b"))
- Expect(rule["pattern"]).To(Equal("a+"))
- }
- })
-
- It("Update MicroService tag with invalid Rules", func() {
- //Add Rules
- rules := map[string]interface{}{
- "ruleType": "WHITE",
- "attribute": "tag_a",
- "pattern": "a+",
- "description": "test ",
- }
- rulesArray := []interface{}{rules}
- bodyParams := map[string][]interface{}{
- "rules": rulesArray,
- }
- url := strings.Replace(ADDRULE, ":serviceId", serviceId, 1)
- body, _ := json.Marshal(bodyParams)
- bodyBuf := bytes.NewReader(body)
- req, _ := http.NewRequest(POST, SCURL+url, bodyBuf)
- req.Header.Set("X-Domain-Name", "default")
- resp, err := scclient.Do(req)
- Expect(err).To(BeNil())
- defer resp.Body.Close()
-
- //Get the rule ID
- respbody, _ := ioutil.ReadAll(resp.Body)
- Expect(resp.StatusCode).To(Equal(http.StatusOK))
- rulesCreateRespStruct := map[string][]string{}
- json.Unmarshal(respbody, &rulesCreateRespStruct)
- for _, rule := range rulesCreateRespStruct["RuleIds"] {
- ruleID = rule
- break
- }
-
- //Update Rules with invalid RuleType
- <-time.After(time.Second)
- updateParams := map[string]interface{}{
- "ruleType": "UNKNOWN",
- "attribute": "tag_b",
- "pattern": "a+",
- "description": "test ",
- }
- url = strings.Replace(UPDATERULES, ":serviceId", serviceId, 1)
- url = strings.Replace(url, ":rule_id", ruleID, 1)
- body, _ = json.Marshal(updateParams)
- bodyBuf = bytes.NewReader(body)
- req, _ = http.NewRequest(UPDATE, SCURL+url, bodyBuf)
- req.Header.Set("X-Domain-Name", "default")
- resp, err = scclient.Do(req)
- Expect(err).To(BeNil())
- defer resp.Body.Close()
- Expect(resp.StatusCode).To(Equal(http.StatusBadRequest))
-
- //Update Rules with invalid pattern
- <-time.After(time.Second)
- updateParams = map[string]interface{}{
- "ruleType": "WHITE",
- "attribute": "tag_b",
- "pattern": "",
- "description": "test ",
- }
- url = strings.Replace(UPDATERULES, ":serviceId", serviceId, 1)
- url = strings.Replace(url, ":rule_id", ruleID, 1)
- body, _ = json.Marshal(updateParams)
- bodyBuf = bytes.NewReader(body)
- req, _ = http.NewRequest(UPDATE, SCURL+url, bodyBuf)
- req.Header.Set("X-Domain-Name", "default")
- resp, err = scclient.Do(req)
- Expect(err).To(BeNil())
- defer resp.Body.Close()
- Expect(resp.StatusCode).To(Equal(http.StatusBadRequest))
-
- //Update Rules with invalid different ruleType
- <-time.After(time.Second)
- updateParams = map[string]interface{}{
- "ruleType": "BLACK",
- "attribute": "tag_b",
- "pattern": "a+",
- "description": "test ",
- }
- url = strings.Replace(UPDATERULES, ":serviceId", serviceId, 1)
- url = strings.Replace(url, ":rule_id", ruleID, 1)
- body, _ = json.Marshal(updateParams)
- bodyBuf = bytes.NewReader(body)
- req, _ = http.NewRequest(UPDATE, SCURL+url, bodyBuf)
- req.Header.Set("X-Domain-Name", "default")
- resp, err = scclient.Do(req)
- Expect(err).To(BeNil())
- defer resp.Body.Close()
- Expect(resp.StatusCode).To(Equal(http.StatusBadRequest))
-
- })
-
- It("Update MicroService Rule with non-exsisting RuleID", func() {
- updateParams := map[string]interface{}{
- "ruleType": "WHITE",
- "attribute": "tag_b",
- "pattern": "a+",
- "description": "test ",
- }
- url := strings.Replace(UPDATERULES, ":serviceId", serviceId, 1)
- url = strings.Replace(url, ":rule_id", "XXXX", 1)
- body, _ := json.Marshal(updateParams)
- bodyBuf := bytes.NewReader(body)
- req, _ := http.NewRequest(UPDATE, SCURL+url, bodyBuf)
- req.Header.Set("X-Domain-Name", "default")
- resp, err := scclient.Do(req)
- Expect(err).To(BeNil())
- defer resp.Body.Close()
- Expect(resp.StatusCode).To(Equal(http.StatusBadRequest))
- })
-
- })
- By("Delete Micro-Service Rules API", func() {
- It("Delete MicroService Rules with proper value", func() {
- //Add Rules
- rules := map[string]interface{}{
- "ruleType": "WHITE",
- "attribute": "tag_a",
- "pattern": "a+",
- "description": "test ",
- }
- rulesArray := []interface{}{rules}
- bodyParams := map[string][]interface{}{
- "rules": rulesArray,
- }
- url := strings.Replace(ADDRULE, ":serviceId", serviceId, 1)
- body, _ := json.Marshal(bodyParams)
- bodyBuf := bytes.NewReader(body)
- req, _ := http.NewRequest(POST, SCURL+url, bodyBuf)
- req.Header.Set("X-Domain-Name", "default")
- resp, err := scclient.Do(req)
- Expect(err).To(BeNil())
- defer resp.Body.Close()
-
- //Get the rule ID
- respbody, _ := ioutil.ReadAll(resp.Body)
- Expect(resp.StatusCode).To(Equal(http.StatusOK))
- rulesCreateRespStruct := map[string][]string{}
- json.Unmarshal(respbody, &rulesCreateRespStruct)
- for _, rule := range rulesCreateRespStruct["RuleIds"] {
- ruleID = rule
- break
- }
-
- //Delete the Rules
- <-time.After(time.Second)
- url = strings.Replace(DELETERULES, ":serviceId", serviceId, 1)
- url = strings.Replace(url, ":rule_id", ruleID, 1)
- req, _ = http.NewRequest(DELETE, SCURL+url, nil)
- req.Header.Set("X-Domain-Name", "default")
- resp, err = scclient.Do(req)
- Expect(err).To(BeNil())
- defer resp.Body.Close()
- Expect(resp.StatusCode).To(Equal(http.StatusOK))
-
- //verify Delete
- <-time.After(time.Second)
- url = strings.Replace(GETTAGS, ":serviceId", serviceId, 1)
- req, _ = http.NewRequest(GET, SCURL+url, nil)
- req.Header.Set("X-Domain-Name", "default")
- req.Header.Set("X-ConsumerId", serviceId)
- resp, _ = scclient.Do(req)
- respbody, _ = ioutil.ReadAll(resp.Body)
- Expect(resp.StatusCode).To(Equal(http.StatusOK))
- Expect(strings.TrimSpace(string(respbody))).To(Equal("{}"))
- })
-
- It("Delete MicroService rules with non-exsisting ruleID", func() {
- url := strings.Replace(DELETERULES, ":serviceId", serviceId, 1)
- url = strings.Replace(url, ":rule_id", "XX", 1)
- req, _ := http.NewRequest(DELETE, SCURL+url, nil)
- req.Header.Set("X-Domain-Name", "default")
- resp, err := scclient.Do(req)
- Expect(err).To(BeNil())
- defer resp.Body.Close()
- Expect(resp.StatusCode).To(Equal(http.StatusBadRequest))
- })
-
- It("Delete MicroService rules with non-exsiting service id", func() {
- url := strings.Replace(DELETERULES, ":serviceId", "XX", 1)
- url = strings.Replace(url, ":rule_id", ruleID, 1)
- req, _ := http.NewRequest(DELETE, SCURL+url, nil)
- req.Header.Set("X-Domain-Name", "default")
- resp, err := scclient.Do(req)
- Expect(err).To(BeNil())
- defer resp.Body.Close()
- Expect(resp.StatusCode).To(Equal(http.StatusBadRequest))
- })
- })
- })
-})
diff --git a/pkg/dump/dump.go b/pkg/dump/dump.go
index 5acf129..f85988b 100644
--- a/pkg/dump/dump.go
+++ b/pkg/dump/dump.go
@@ -34,8 +34,6 @@ type MicroserviceSlice []*Microservice
type MicroserviceIndexSlice []*MicroserviceIndex
type MicroserviceAliasSlice []*MicroserviceAlias
type TagSlice []*Tag
-type MicroServiceRuleSlice []*MicroServiceRule
-type MicroServiceRuleIndexSlice []*MicroServiceRuleIndex
type MicroServiceDependencyRuleSlice []*MicroServiceDependencyRule
type SummarySlice []*Summary
type InstanceSlice []*Instance
@@ -72,22 +70,6 @@ func (s *TagSlice) ForEach(f func(i int, v *KV) bool) {
}
}
}
-func (s *MicroServiceRuleIndexSlice) ForEach(f func(i int, v *KV) bool) {
- for i, v := range *s {
- v.KV.Value = v.Value
- if !f(i, v.KV) {
- break
- }
- }
-}
-func (s *MicroServiceRuleSlice) ForEach(f func(i int, v *KV) bool) {
- for i, v := range *s {
- v.KV.Value = v.Value
- if !f(i, v.KV) {
- break
- }
- }
-}
func (s *MicroServiceDependencyRuleSlice) ForEach(f func(i int, v *KV) bool) {
for i, v := range *s {
v.KV.Value = v.Value
@@ -113,12 +95,10 @@ func (s *InstanceSlice) ForEach(f func(i int, v *KV) bool) {
}
}
-func (s *MicroserviceSlice) SetValue(v *KV) { *s = append(*s, NewMicroservice(v)) }
-func (s *MicroserviceIndexSlice) SetValue(v *KV) { *s = append(*s, NewMicroserviceIndex(v)) }
-func (s *MicroserviceAliasSlice) SetValue(v *KV) { *s = append(*s, NewMicroserviceAlias(v)) }
-func (s *TagSlice) SetValue(v *KV) { *s = append(*s, NewTag(v)) }
-func (s *MicroServiceRuleIndexSlice) SetValue(v *KV) { *s = append(*s, NewMicroServiceRuleIndex(v)) }
-func (s *MicroServiceRuleSlice) SetValue(v *KV) { *s = append(*s, NewMicroServiceRule(v)) }
+func (s *MicroserviceSlice) SetValue(v *KV) { *s = append(*s, NewMicroservice(v)) }
+func (s *MicroserviceIndexSlice) SetValue(v *KV) { *s = append(*s, NewMicroserviceIndex(v)) }
+func (s *MicroserviceAliasSlice) SetValue(v *KV) { *s = append(*s, NewMicroserviceAlias(v)) }
+func (s *TagSlice) SetValue(v *KV) { *s = append(*s, NewTag(v)) }
func (s *MicroServiceDependencyRuleSlice) SetValue(v *KV) {
*s = append(*s, NewMicroServiceDependencyRule(v))
}
@@ -135,12 +115,6 @@ func NewMicroserviceAlias(kv *KV) *MicroserviceAlias {
return &MicroserviceAlias{kv, kv.Value.(string)}
}
func NewTag(kv *KV) *Tag { return &Tag{kv, kv.Value.(map[string]string)} }
-func NewMicroServiceRuleIndex(kv *KV) *MicroServiceRuleIndex {
- return &MicroServiceRuleIndex{kv, kv.Value.(string)}
-}
-func NewMicroServiceRule(kv *KV) *MicroServiceRule {
- return &MicroServiceRule{kv, kv.Value.(*discovery.ServiceRule)}
-}
func NewMicroServiceDependencyRule(kv *KV) *MicroServiceDependencyRule {
return &MicroServiceDependencyRule{kv, kv.Value.(*discovery.MicroServiceDependency)}
}
@@ -154,8 +128,6 @@ type Cache struct {
Indexes MicroserviceIndexSlice `json:"serviceIndexes,omitempty"`
Aliases MicroserviceAliasSlice `json:"serviceAliases,omitempty"`
Tags TagSlice `json:"serviceTags,omitempty"`
- Rules MicroServiceRuleSlice `json:"serviceRules,omitempty"`
- RuleIndexes MicroServiceRuleIndexSlice `json:"serviceRuleIndexes,omitempty"`
DependencyRules MicroServiceDependencyRuleSlice `json:"dependencyRules,omitempty"`
Summaries SummarySlice `json:"summaries,omitempty"`
Instances InstanceSlice `json:"instances,omitempty"`
@@ -188,15 +160,6 @@ type MicroServiceDependencyRule struct {
Value *discovery.MicroServiceDependency `json:"value,omitempty"`
}
-type MicroServiceRuleIndex struct {
- *KV
- Value string `json:"value,omitempty"`
-}
-
-type MicroServiceRule struct {
- *KV
- Value *discovery.ServiceRule `json:"value,omitempty"`
-}
type Summary struct {
*KV
Value string `json:"value,omitempty"`
diff --git a/pkg/proto/service.go b/pkg/proto/service.go
index a38e005..1cf5faf 100644
--- a/pkg/proto/service.go
+++ b/pkg/proto/service.go
@@ -33,10 +33,6 @@ type ServiceCtrlServer interface {
GetOne(context.Context, *discovery.GetServiceRequest) (*discovery.GetServiceResponse, error)
GetServices(context.Context, *discovery.GetServicesRequest) (*discovery.GetServicesResponse, error)
UpdateProperties(context.Context, *discovery.UpdateServicePropsRequest) (*discovery.UpdateServicePropsResponse, error)
- AddRule(context.Context, *discovery.AddServiceRulesRequest) (*discovery.AddServiceRulesResponse, error)
- GetRule(context.Context, *discovery.GetServiceRulesRequest) (*discovery.GetServiceRulesResponse, error)
- UpdateRule(context.Context, *discovery.UpdateServiceRuleRequest) (*discovery.UpdateServiceRuleResponse, error)
- DeleteRule(context.Context, *discovery.DeleteServiceRulesRequest) (*discovery.DeleteServiceRulesResponse, error)
AddTags(context.Context, *discovery.AddServiceTagsRequest) (*discovery.AddServiceTagsResponse, error)
GetTags(context.Context, *discovery.GetServiceTagsRequest) (*discovery.GetServiceTagsResponse, error)
UpdateTag(context.Context, *discovery.UpdateServiceTagRequest) (*discovery.UpdateServiceTagResponse, error)
diff --git a/server/plugin/quota/buildin/buildin.go b/server/plugin/quota/buildin/buildin.go
index 5bc8e01..e448c8f 100644
--- a/server/plugin/quota/buildin/buildin.go
+++ b/server/plugin/quota/buildin/buildin.go
@@ -31,10 +31,10 @@ func init() {
func New() plugin.Instance {
quota.Init()
- log.Infof("quota init, service: %d, instance: %d, schema: %d/service, tag: %d/service, rule: %d/service"+
+ log.Infof("quota init, service: %d, instance: %d, schema: %d/service, tag: %d/service"+
", account: %d, role: %d",
quota.DefaultServiceQuota, quota.DefaultInstanceQuota,
- quota.DefaultSchemaQuota, quota.DefaultTagQuota, quota.DefaultRuleQuota,
+ quota.DefaultSchemaQuota, quota.DefaultTagQuota,
quota.DefaultAccountQuota, quota.DefaultRoleQuota)
return &Quota{}
}
@@ -48,8 +48,6 @@ func (q *Quota) GetQuota(ctx context.Context, t quota.ResourceType) int64 {
return int64(quota.DefaultInstanceQuota)
case quota.TypeService:
return int64(quota.DefaultServiceQuota)
- case quota.TypeRule:
- return int64(quota.DefaultRuleQuota)
case quota.TypeSchema:
return int64(quota.DefaultSchemaQuota)
case quota.TypeTag:
diff --git a/server/plugin/quota/quota.go b/server/plugin/quota/quota.go
index 1e114ef..d088149 100644
--- a/server/plugin/quota/quota.go
+++ b/server/plugin/quota/quota.go
@@ -38,15 +38,13 @@ const (
defaultServiceLimit = 50000
defaultInstanceLimit = 150000
defaultSchemaLimit = 100
- defaultRuleLimit = 100
defaultTagLimit = 100
defaultAccountLimit = 1000
defaultRoleLimit = 100
)
const (
- TypeRule ResourceType = iota
- TypeSchema
+ TypeSchema ResourceType = iota
TypeTag
TypeService
TypeInstance
@@ -59,7 +57,6 @@ var (
DefaultInstanceQuota = defaultInstanceLimit
DefaultSchemaQuota = defaultSchemaLimit
DefaultTagQuota = defaultTagLimit
- DefaultRuleQuota = defaultRuleLimit
DefaultAccountQuota = defaultAccountLimit
DefaultRoleQuota = defaultRoleLimit
)
@@ -69,7 +66,6 @@ func Init() {
DefaultInstanceQuota = config.GetInt("quota.cap.instance.limit", defaultInstanceLimit, config.WithENV("QUOTA_INSTANCE"))
DefaultSchemaQuota = config.GetInt("quota.cap.schema.limit", defaultSchemaLimit, config.WithENV("QUOTA_SCHEMA"))
DefaultTagQuota = config.GetInt("quota.cap.tag.limit", defaultTagLimit, config.WithENV("QUOTA_TAG"))
- DefaultRuleQuota = config.GetInt("quota.cap.rule.limit", defaultRuleLimit, config.WithENV("QUOTA_RULE"))
DefaultAccountQuota = config.GetInt("quota.cap.account.limit", defaultAccountLimit, config.WithENV("QUOTA_ACCOUNT"))
DefaultRoleQuota = config.GetInt("quota.cap.role.limit", defaultRoleLimit, config.WithENV("QUOTA_ROLE"))
}
@@ -99,8 +95,6 @@ type ResourceType int
func (r ResourceType) String() string {
switch r {
- case TypeRule:
- return "RULE"
case TypeSchema:
return "SCHEMA"
case TypeTag:
@@ -157,8 +151,6 @@ func GetResourceUsage(ctx context.Context, res *ApplyQuotaResource) (int64, erro
Domain: util.ParseDomain(ctx),
Project: util.ParseProject(ctx),
})
- case TypeRule:
- return quota.RuleUsage(ctx, serviceID)
case TypeSchema:
return quota.SchemaUsage(ctx, serviceID)
case TypeTag:
diff --git a/server/rest/controller/v3/query_rule_controller.go b/server/rest/controller/v3/query_rule_controller.go
deleted file mode 100644
index aa53eeb..0000000
--- a/server/rest/controller/v3/query_rule_controller.go
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * 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 v3
-
-import (
- "net/http"
-
- "github.com/apache/servicecomb-service-center/pkg/rest"
- v4 "github.com/apache/servicecomb-service-center/server/rest/controller/v4"
-)
-
-type RuleService struct {
- v4.RuleService
-}
-
-func (this *RuleService) URLPatterns() []rest.Route {
- return []rest.Route{
- {http.MethodPost, "/registry/v3/microservices/:serviceId/rules", this.AddRule},
- {http.MethodGet, "/registry/v3/microservices/:serviceId/rules", this.GetRules},
- {http.MethodPut, "/registry/v3/microservices/:serviceId/rules/:rule_id", this.UpdateRule},
- {http.MethodDelete, "/registry/v3/microservices/:serviceId/rules/:rule_id", this.DeleteRule},
- }
-}
diff --git a/server/rest/controller/v3/v3.go b/server/rest/controller/v3/v3.go
index ec2fdc8..62e8691 100644
--- a/server/rest/controller/v3/v3.go
+++ b/server/rest/controller/v3/v3.go
@@ -30,7 +30,6 @@ func initRouter() {
roa.RegisterServant(&SchemaService{})
roa.RegisterServant(&DependencyService{})
roa.RegisterServant(&TagService{})
- roa.RegisterServant(&RuleService{})
roa.RegisterServant(&MicroServiceInstanceService{})
roa.RegisterServant(&WatchService{})
}
diff --git a/server/rest/controller/v4/query_rule_controller.go b/server/rest/controller/v4/query_rule_controller.go
deleted file mode 100644
index 1dc3b9c..0000000
--- a/server/rest/controller/v4/query_rule_controller.go
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
- * 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 v4
-
-import (
- "encoding/json"
- "io/ioutil"
- "net/http"
- "strings"
-
- "github.com/apache/servicecomb-service-center/pkg/log"
- "github.com/apache/servicecomb-service-center/pkg/rest"
- "github.com/apache/servicecomb-service-center/pkg/util"
- "github.com/apache/servicecomb-service-center/server/core"
- pb "github.com/go-chassis/cari/discovery"
-)
-
-type RuleService struct {
- //
-}
-
-func (s *RuleService) URLPatterns() []rest.Route {
- return []rest.Route{
- {Method: http.MethodPost, Path: "/v4/:project/registry/microservices/:serviceId/rules", Func: s.AddRule},
- {Method: http.MethodGet, Path: "/v4/:project/registry/microservices/:serviceId/rules", Func: s.GetRules},
- {Method: http.MethodPut, Path: "/v4/:project/registry/microservices/:serviceId/rules/:rule_id", Func: s.UpdateRule},
- {Method: http.MethodDelete, Path: "/v4/:project/registry/microservices/:serviceId/rules/:rule_id", Func: s.DeleteRule},
- }
-}
-func (s *RuleService) AddRule(w http.ResponseWriter, r *http.Request) {
- message, err := ioutil.ReadAll(r.Body)
- if err != nil {
- log.Error("read body failed", err)
- rest.WriteError(w, pb.ErrInvalidParams, err.Error())
- return
- }
- rule := map[string][]*pb.AddOrUpdateServiceRule{}
- err = json.Unmarshal(message, &rule)
- if err != nil {
- log.Errorf(err, "invalid json: %s", util.BytesToStringWithNoCopy(message))
- rest.WriteError(w, pb.ErrInvalidParams, err.Error())
- return
- }
-
- resp, err := core.ServiceAPI.AddRule(r.Context(), &pb.AddServiceRulesRequest{
- ServiceId: r.URL.Query().Get(":serviceId"),
- Rules: rule["rules"],
- })
- if err != nil {
- log.Errorf(err, "add rule failed")
- rest.WriteError(w, pb.ErrInternal, "add rule failed")
- return
- }
- rest.WriteResponse(w, r, resp.Response, resp)
-}
-
-func (s *RuleService) DeleteRule(w http.ResponseWriter, r *http.Request) {
- query := r.URL.Query()
- id := query.Get(":rule_id")
- ids := strings.Split(id, ",")
-
- resp, _ := core.ServiceAPI.DeleteRule(r.Context(), &pb.DeleteServiceRulesRequest{
- ServiceId: query.Get(":serviceId"),
- RuleIds: ids,
- })
- rest.WriteResponse(w, r, resp.Response, nil)
-}
-
-func (s *RuleService) UpdateRule(w http.ResponseWriter, r *http.Request) {
- message, err := ioutil.ReadAll(r.Body)
- if err != nil {
- log.Error("read body failed", err)
- rest.WriteError(w, pb.ErrInvalidParams, err.Error())
- return
- }
-
- rule := pb.AddOrUpdateServiceRule{}
- err = json.Unmarshal(message, &rule)
- if err != nil {
- log.Errorf(err, "invalid json: %s", util.BytesToStringWithNoCopy(message))
- rest.WriteError(w, pb.ErrInvalidParams, err.Error())
- return
- }
- query := r.URL.Query()
- resp, err := core.ServiceAPI.UpdateRule(r.Context(), &pb.UpdateServiceRuleRequest{
- ServiceId: query.Get(":serviceId"),
- RuleId: query.Get(":rule_id"),
- Rule: &rule,
- })
- if err != nil {
- log.Errorf(err, "update rule failed")
- rest.WriteError(w, pb.ErrInternal, "update rule failed")
- return
- }
- rest.WriteResponse(w, r, resp.Response, nil)
-}
-
-func (s *RuleService) GetRules(w http.ResponseWriter, r *http.Request) {
- resp, _ := core.ServiceAPI.GetRule(r.Context(), &pb.GetServiceRulesRequest{
- ServiceId: r.URL.Query().Get(":serviceId"),
- })
- rest.WriteResponse(w, r, resp.Response, resp)
-}
diff --git a/server/rest/controller/v4/v4.go b/server/rest/controller/v4/v4.go
index 4944ff8..2c3e022 100644
--- a/server/rest/controller/v4/v4.go
+++ b/server/rest/controller/v4/v4.go
@@ -31,7 +31,6 @@ func initRouter() {
roa.RegisterServant(&SchemaService{})
roa.RegisterServant(&DependencyService{})
roa.RegisterServant(&TagService{})
- roa.RegisterServant(&RuleService{})
roa.RegisterServant(&MicroServiceInstanceService{})
roa.RegisterServant(&WatchService{})
}
diff --git a/server/service/disco/microservice.go b/server/service/disco/microservice.go
index 0145453..f014681 100644
--- a/server/service/disco/microservice.go
+++ b/server/service/disco/microservice.go
@@ -261,28 +261,8 @@ func (s *MicroServiceService) CreateServiceEx(ctx context.Context, in *pb.Create
ServiceId: serviceID,
Response: &pb.Response{},
}
- var chanLen int = 0
+ var chanLen = 0
createRespChan := make(chan *pb.Response, 10)
- //create rules
- if in.Rules != nil && len(in.Rules) != 0 {
- chanLen++
- gopool.Go(func(_ context.Context) {
- req := &pb.AddServiceRulesRequest{
- ServiceId: serviceID,
- Rules: in.Rules,
- }
- chanRsp := &pb.Response{}
- rsp, err := s.AddRule(ctx, req)
- if err != nil {
- chanRsp.Message = err.Error()
- }
-
- if rsp.Response.GetCode() != pb.ResponseSuccess {
- chanRsp.Message = rsp.Response.GetMessage()
- }
- createRespChan <- chanRsp
- })
- }
//create tags
if in.Tags != nil && len(in.Tags) != 0 {
chanLen++
diff --git a/server/service/disco/microservice_test.go b/server/service/disco/microservice_test.go
index 85142c3..8badaad 100644
--- a/server/service/disco/microservice_test.go
+++ b/server/service/disco/microservice_test.go
@@ -148,7 +148,7 @@ var _ = Describe("'Micro-service' service", func() {
Expect(err).To(BeNil())
Expect(resp.Response.GetCode()).To(Equal(pb.ResponseSuccess))
- By("check the tags/rules/instances")
+ By("check the tags/instances")
respGetTags, err := serviceResource.GetTags(getContext(), &pb.GetServiceTagsRequest{
ServiceId: resp.ServiceId,
})
@@ -156,13 +156,6 @@ var _ = Describe("'Micro-service' service", func() {
Expect(respGetTags.Response.GetCode()).To(Equal(pb.ResponseSuccess))
Expect(respGetTags.Tags["second"]).To(Equal("second"))
- respGetRules, err := serviceResource.GetRule(getContext(), &pb.GetServiceRulesRequest{
- ServiceId: resp.ServiceId,
- })
- Expect(err).To(BeNil())
- Expect(respGetRules.Response.GetCode()).To(Equal(pb.ResponseSuccess))
- Expect(respGetRules.Rules[0].Attribute).To(Equal("ServiceName"))
-
respGetInsts, err := disco.GetInstances(getContext(), &pb.GetInstancesRequest{
ConsumerServiceId: resp.ServiceId,
ProviderServiceId: resp.ServiceId,
diff --git a/server/service/disco/rule.go b/server/service/disco/rule.go
deleted file mode 100644
index 13a4f68..0000000
--- a/server/service/disco/rule.go
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- * 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 disco
-
-import (
- "context"
-
- pb "github.com/go-chassis/cari/discovery"
-
- "github.com/apache/servicecomb-service-center/datasource"
- "github.com/apache/servicecomb-service-center/pkg/log"
- "github.com/apache/servicecomb-service-center/pkg/util"
- "github.com/apache/servicecomb-service-center/server/service/validator"
-)
-
-func (s *MicroServiceService) AddRule(ctx context.Context, in *pb.AddServiceRulesRequest) (*pb.AddServiceRulesResponse, error) {
- err := validator.Validate(in)
- if err != nil {
- remoteIP := util.GetIPFromContext(ctx)
- log.Errorf(err, "add service[%s] rule failed, operator: %s", in.ServiceId, remoteIP)
- return &pb.AddServiceRulesResponse{
- Response: pb.CreateResponse(pb.ErrInvalidParams, err.Error()),
- }, nil
- }
-
- return datasource.GetMetadataManager().AddRule(ctx, in)
-}
-
-func (s *MicroServiceService) UpdateRule(ctx context.Context, in *pb.UpdateServiceRuleRequest) (*pb.UpdateServiceRuleResponse, error) {
- err := validator.Validate(in)
- if err != nil {
- remoteIP := util.GetIPFromContext(ctx)
- log.Errorf(err, "update service rule[%s/%s] failed, operator: %s", in.ServiceId, in.RuleId, remoteIP)
- return &pb.UpdateServiceRuleResponse{
- Response: pb.CreateResponse(pb.ErrInvalidParams, err.Error()),
- }, nil
- }
-
- return datasource.GetMetadataManager().UpdateRule(ctx, in)
-}
-
-func (s *MicroServiceService) GetRule(ctx context.Context, in *pb.GetServiceRulesRequest) (*pb.GetServiceRulesResponse, error) {
- err := validator.Validate(in)
- if err != nil {
- log.Errorf(err, "get service[%s] rule failed", in.ServiceId)
- return &pb.GetServiceRulesResponse{
- Response: pb.CreateResponse(pb.ErrInvalidParams, err.Error()),
- }, nil
- }
-
- return datasource.GetMetadataManager().GetRules(ctx, in)
-}
-
-func (s *MicroServiceService) DeleteRule(ctx context.Context, in *pb.DeleteServiceRulesRequest) (*pb.DeleteServiceRulesResponse, error) {
- err := validator.Validate(in)
- if err != nil {
- remoteIP := util.GetIPFromContext(ctx)
- log.Errorf(err, "delete service[%s] rules %v failed, operator: %s", in.ServiceId, in.RuleIds, remoteIP)
- return &pb.DeleteServiceRulesResponse{
- Response: pb.CreateResponse(pb.ErrInvalidParams, err.Error()),
- }, nil
- }
-
- return datasource.GetMetadataManager().DeleteRule(ctx, in)
-}
diff --git a/server/service/disco/rule_test.go b/server/service/disco/rule_test.go
deleted file mode 100644
index 6348a27..0000000
--- a/server/service/disco/rule_test.go
+++ /dev/null
@@ -1,750 +0,0 @@
-/*
- * 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 disco_test
-
-import (
- "strconv"
-
- discosvc "github.com/apache/servicecomb-service-center/server/service/disco"
-
- "github.com/apache/servicecomb-service-center/server/plugin/quota"
- pb "github.com/go-chassis/cari/discovery"
- . "github.com/onsi/ginkgo"
- . "github.com/onsi/gomega"
-)
-
-var _ = Describe("'Rule' service", func() {
- Describe("execute 'create' operartion", func() {
- var (
- serviceId1 string
- serviceId2 string
- )
-
- It("should be passed", func() {
- respCreateService, err := serviceResource.Create(getContext(), &pb.CreateServiceRequest{
- Service: &pb.MicroService{
- AppId: "create_rule_group",
- ServiceName: "create_rule_service",
- Version: "1.0.0",
- Level: "FRONT",
- Status: pb.MS_UP,
- },
- })
- Expect(err).To(BeNil())
- Expect(respCreateService.Response.GetCode()).To(Equal(pb.ResponseSuccess))
- serviceId1 = respCreateService.ServiceId
-
- respCreateService, err = serviceResource.Create(getContext(), &pb.CreateServiceRequest{
- Service: &pb.MicroService{
- AppId: "create_rule_group",
- ServiceName: "create_rule_service",
- Version: "1.0.1",
- Level: "FRONT",
- Status: pb.MS_UP,
- },
- })
- Expect(err).To(BeNil())
- Expect(respCreateService.Response.GetCode()).To(Equal(pb.ResponseSuccess))
- serviceId2 = respCreateService.ServiceId
- })
-
- Context("when request is invalid", func() {
- It("should be failed", func() {
- By("attribute is empty")
- respAddRule, err := serviceResource.AddRule(getContext(), &pb.AddServiceRulesRequest{
- ServiceId: serviceId1,
- Rules: []*pb.AddOrUpdateServiceRule{
- {
- RuleType: "BLACK",
- Attribute: "",
- Pattern: "Test*",
- Description: "test BLACK",
- },
- },
- })
- Expect(err).To(BeNil())
- Expect(respAddRule.Response.GetCode()).ToNot(Equal(pb.ResponseSuccess))
-
- By("attribute is tag but name is invalid")
- respAddRule, err = serviceResource.AddRule(getContext(), &pb.AddServiceRulesRequest{
- ServiceId: serviceId1,
- Rules: []*pb.AddOrUpdateServiceRule{
- {
- RuleType: "BLACK",
- Attribute: "tag_@34",
- Pattern: "Test*",
- Description: "test BLACK",
- },
- },
- })
- Expect(err).To(BeNil())
- Expect(respAddRule.Response.GetCode()).ToNot(Equal(pb.ResponseSuccess))
-
- By("attribute is a invalid field name")
- respAddRule, err = serviceResource.AddRule(getContext(), &pb.AddServiceRulesRequest{
- ServiceId: serviceId1,
- Rules: []*pb.AddOrUpdateServiceRule{
- {
- RuleType: "BLACK",
- Attribute: "xxx",
- Pattern: "Test*",
- Description: "test BLACK",
- },
- },
- })
- Expect(err).To(BeNil())
- Expect(respAddRule.Response.GetCode()).ToNot(Equal(pb.ResponseSuccess))
-
- By("service does not exist")
- respAddRule, err = serviceResource.AddRule(getContext(), &pb.AddServiceRulesRequest{
- ServiceId: "notexistservice",
- Rules: []*pb.AddOrUpdateServiceRule{
- {
- RuleType: "BLACK",
- Attribute: "ServiceName",
- Pattern: "Test*",
- Description: "test white",
- },
- },
- })
- Expect(err).To(BeNil())
- Expect(respAddRule.Response.GetCode()).ToNot(Equal(pb.ResponseSuccess))
-
- By("service id is empty")
- respAddRule, err = serviceResource.AddRule(getContext(), &pb.AddServiceRulesRequest{
- ServiceId: "",
- Rules: []*pb.AddOrUpdateServiceRule{
- {
- RuleType: "BLACK",
- Attribute: "",
- Pattern: "Test*",
- Description: "test white",
- },
- },
- })
- Expect(err).To(BeNil())
- Expect(respAddRule.Response.GetCode()).ToNot(Equal(pb.ResponseSuccess))
-
- By("rules is nil")
- respAddRule, err = serviceResource.AddRule(getContext(), &pb.AddServiceRulesRequest{
- ServiceId: serviceId1,
- })
- Expect(err).To(BeNil())
- Expect(respAddRule.Response.GetCode()).To(Equal(pb.ErrInvalidParams))
- })
- })
-
- Context("when request is valid", func() {
- It("should be passed", func() {
- By("create a new black list")
- respAddRule, err := serviceResource.AddRule(getContext(), &pb.AddServiceRulesRequest{
- ServiceId: serviceId1,
- Rules: []*pb.AddOrUpdateServiceRule{
- {
- RuleType: "BLACK",
- Attribute: "ServiceName",
- Pattern: "Test*",
- Description: "test black",
- },
- },
- })
- Expect(err).To(BeNil())
- Expect(respAddRule.Response.GetCode()).To(Equal(pb.ResponseSuccess))
- ruleId := respAddRule.RuleIds[0]
- Expect(ruleId).ToNot(Equal(""))
-
- By("create the black list again")
- respAddRule, err = serviceResource.AddRule(getContext(), &pb.AddServiceRulesRequest{
- ServiceId: serviceId1,
- Rules: []*pb.AddOrUpdateServiceRule{
- {
- RuleType: "BLACK",
- Attribute: "ServiceName",
- Pattern: "Test*",
- Description: "test change black",
- },
- },
- })
- Expect(err).To(BeNil())
- Expect(respAddRule.Response.GetCode()).To(Equal(pb.ResponseSuccess))
- Expect(len(respAddRule.RuleIds)).To(Equal(0)) // no changed
-
- By("create a new white list when black list already exists")
- respAddRule, err = serviceResource.AddRule(getContext(), &pb.AddServiceRulesRequest{
- ServiceId: serviceId1,
- Rules: []*pb.AddOrUpdateServiceRule{
- {
- RuleType: "WHITE",
- Attribute: "ServiceName",
- Pattern: "Test*",
- Description: "test white",
- },
- },
- })
- Expect(err).To(BeNil())
- Expect(respAddRule.Response.GetCode()).ToNot(Equal(pb.ResponseSuccess))
- })
- })
-
- Context("when create rule out of gauge", func() {
- It("should be failed", func() {
- size := quota.DefaultRuleQuota + 1
- rules := make([]*pb.AddOrUpdateServiceRule, 0, size)
- for i := 0; i < size; i++ {
- rules = append(rules, &pb.AddOrUpdateServiceRule{
- RuleType: "BLACK",
- Attribute: "ServiceName",
- Pattern: strconv.Itoa(i),
- Description: "test white",
- })
- }
- resp, err := serviceResource.AddRule(getContext(), &pb.AddServiceRulesRequest{
- ServiceId: serviceId2,
- Rules: rules,
- })
- Expect(err).To(BeNil())
- Expect(resp.Response.GetCode()).To(Equal(pb.ErrInvalidParams))
-
- resp, err = serviceResource.AddRule(getContext(), &pb.AddServiceRulesRequest{
- ServiceId: serviceId2,
- Rules: rules[:size-1],
- })
- Expect(err).To(BeNil())
- Expect(resp.Response.GetCode()).To(Equal(pb.ResponseSuccess))
-
- resp, err = serviceResource.AddRule(getContext(), &pb.AddServiceRulesRequest{
- ServiceId: serviceId2,
- Rules: rules[size-1:],
- })
- Expect(err).To(BeNil())
- Expect(resp.Response.GetCode()).To(Equal(pb.ErrNotEnoughQuota))
- })
- })
- })
-
- Describe("execute 'get' operartion", func() {
- var (
- serviceId string
- ruleId string
- )
-
- It("should be passed", func() {
- respCreateService, err := serviceResource.Create(getContext(), &pb.CreateServiceRequest{
- Service: &pb.MicroService{
- AppId: "get_rule_group",
- ServiceName: "get_rule_service",
- Version: "1.0.0",
- Level: "FRONT",
- Status: pb.MS_UP,
- },
- })
- Expect(err).To(BeNil())
- Expect(respCreateService.Response.GetCode()).To(Equal(pb.ResponseSuccess))
- serviceId = respCreateService.ServiceId
-
- respAddRule, err := serviceResource.AddRule(getContext(), &pb.AddServiceRulesRequest{
- ServiceId: serviceId,
- Rules: []*pb.AddOrUpdateServiceRule{
- {
- RuleType: "BLACK",
- Attribute: "ServiceName",
- Pattern: "Test*",
- Description: "test BLACK",
- },
- },
- })
- Expect(err).To(BeNil())
- Expect(respAddRule.Response.GetCode()).To(Equal(pb.ResponseSuccess))
- ruleId = respAddRule.RuleIds[0]
- Expect(ruleId).ToNot(Equal(""))
- })
-
- Context("when request is invalid", func() {
- It("should be failed", func() {
- By("service id is invalid")
- respGetRule, err := serviceResource.GetRule(getContext(), &pb.GetServiceRulesRequest{
- ServiceId: "",
- })
- Expect(err).To(BeNil())
- Expect(respGetRule.Response.GetCode()).To(Equal(pb.ErrInvalidParams))
-
- respGetRule, err = serviceResource.GetRule(getContext(), &pb.GetServiceRulesRequest{
- ServiceId: TOO_LONG_SERVICEID,
- })
- Expect(err).To(BeNil())
- Expect(respGetRule.Response.GetCode()).To(Equal(pb.ErrInvalidParams))
-
- By("service does not exist")
- respGetRule, err = serviceResource.GetRule(getContext(), &pb.GetServiceRulesRequest{
- ServiceId: "notexist",
- })
- Expect(err).To(BeNil())
- Expect(respGetRule.Response.GetCode()).To(Equal(pb.ErrServiceNotExists))
- })
- })
-
- Context("when request is valid", func() {
- It("should be passed", func() {
- respGetRule, err := serviceResource.GetRule(getContext(), &pb.GetServiceRulesRequest{
- ServiceId: serviceId,
- })
- Expect(err).To(BeNil())
- Expect(respGetRule.Response.GetCode()).To(Equal(pb.ResponseSuccess))
- Expect(respGetRule.Rules[0].RuleId).To(Equal(ruleId))
- })
- })
- })
-
- Describe("execute 'update' operartion", func() {
- var (
- serviceId string
- ruleId string
- )
-
- It("should be passed", func() {
- respCreateService, err := serviceResource.Create(getContext(), &pb.CreateServiceRequest{
- Service: &pb.MicroService{
- AppId: "update_rule_group",
- ServiceName: "update_rule_service",
- Version: "1.0.0",
- Level: "FRONT",
- Status: pb.MS_UP,
- },
- })
- Expect(err).To(BeNil())
- Expect(respCreateService.Response.GetCode()).To(Equal(pb.ResponseSuccess))
- serviceId = respCreateService.ServiceId
-
- respAddRule, err := serviceResource.AddRule(getContext(), &pb.AddServiceRulesRequest{
- ServiceId: serviceId,
- Rules: []*pb.AddOrUpdateServiceRule{
- {
- RuleType: "BLACK",
- Attribute: "ServiceName",
- Pattern: "Test*",
- Description: "test BLACK",
- },
- },
- })
- Expect(err).To(BeNil())
- Expect(respAddRule.Response.GetCode()).To(Equal(pb.ResponseSuccess))
- ruleId = respAddRule.RuleIds[0]
- Expect(ruleId).ToNot(Equal(""))
- })
-
- Context("when request is invalid", func() {
- It("should be failed", func() {
- rule := &pb.AddOrUpdateServiceRule{
- RuleType: "BLACK",
- Attribute: "ServiceName",
- Pattern: "Test*",
- Description: "test BLACK update",
- }
- By("service id is empty")
- respAddRule, err := serviceResource.UpdateRule(getContext(), &pb.UpdateServiceRuleRequest{
- ServiceId: "",
- RuleId: ruleId,
- Rule: rule,
- })
- Expect(err).To(BeNil())
- Expect(respAddRule.Response.GetCode()).ToNot(Equal(pb.ResponseSuccess))
-
- By("service does not exist")
- respAddRule, err = serviceResource.UpdateRule(getContext(), &pb.UpdateServiceRuleRequest{
- ServiceId: "notexistservice",
- RuleId: ruleId,
- Rule: rule,
- })
- Expect(err).To(BeNil())
- Expect(respAddRule.Response.GetCode()).ToNot(Equal(pb.ResponseSuccess))
-
- By("rule id is empty")
- respAddRule, err = serviceResource.UpdateRule(getContext(), &pb.UpdateServiceRuleRequest{
- ServiceId: serviceId,
- RuleId: "",
- Rule: rule,
- })
- Expect(err).To(BeNil())
- Expect(respAddRule.Response.GetCode()).ToNot(Equal(pb.ResponseSuccess))
-
- By("rule does not exist")
- respAddRule, err = serviceResource.UpdateRule(getContext(), &pb.UpdateServiceRuleRequest{
- ServiceId: serviceId,
- RuleId: "notexistrule",
- Rule: rule,
- })
- Expect(err).To(BeNil())
- Expect(respAddRule.Response.GetCode()).ToNot(Equal(pb.ResponseSuccess))
-
- By("rule type is invalid")
- respAddRule, err = serviceResource.UpdateRule(getContext(), &pb.UpdateServiceRuleRequest{
- ServiceId: serviceId,
- RuleId: ruleId,
- Rule: &pb.AddOrUpdateServiceRule{
- RuleType: "notType",
- Attribute: "ServiceName",
- Pattern: "Test*",
- Description: "test BLACK update",
- },
- })
- Expect(err).To(BeNil())
- Expect(respAddRule.Response.GetCode()).ToNot(Equal(pb.ResponseSuccess))
-
- By("attribute is a invalid field name")
- respAddRule, err = serviceResource.UpdateRule(getContext(), &pb.UpdateServiceRuleRequest{
- ServiceId: serviceId,
- RuleId: ruleId,
- Rule: &pb.AddOrUpdateServiceRule{
- RuleType: "BLACK",
- Attribute: "noattribute",
- Pattern: "Test*",
- Description: "test BLACK update",
- },
- })
- Expect(err).To(BeNil())
- Expect(respAddRule.Response.GetCode()).ToNot(Equal(pb.ResponseSuccess))
-
- By("attribute is tag but name is invalid")
- respAddRule, err = serviceResource.UpdateRule(getContext(), &pb.UpdateServiceRuleRequest{
- ServiceId: serviceId,
- RuleId: ruleId,
- Rule: &pb.AddOrUpdateServiceRule{
- RuleType: "BLACK",
- Attribute: "tag_@34",
- Pattern: "Test*",
- Description: "test BLACK update",
- },
- })
- Expect(err).To(BeNil())
- Expect(respAddRule.Response.GetCode()).ToNot(Equal(pb.ResponseSuccess))
-
- By("change rule type")
- respAddRule, err = serviceResource.UpdateRule(getContext(), &pb.UpdateServiceRuleRequest{
- ServiceId: serviceId,
- RuleId: ruleId,
- Rule: &pb.AddOrUpdateServiceRule{
- RuleType: "WHITE",
- Attribute: "ServiceName",
- Pattern: "Test*",
- Description: "test white update",
- },
- })
- Expect(err).To(BeNil())
- Expect(respAddRule.Response.GetCode()).ToNot(Equal(pb.ResponseSuccess))
- })
- })
-
- Context("when request is valid", func() {
- It("should be passed", func() {
- respAddRule, err := serviceResource.UpdateRule(getContext(), &pb.UpdateServiceRuleRequest{
- ServiceId: serviceId,
- RuleId: ruleId,
- Rule: &pb.AddOrUpdateServiceRule{
- RuleType: "BLACK",
- Attribute: "AppId",
- Pattern: "Test*",
- Description: "test white update",
- },
- })
- Expect(err).To(BeNil())
- Expect(respAddRule.Response.GetCode()).To(Equal(pb.ResponseSuccess))
- })
- })
- })
-
- Describe("execute 'delete' operartion", func() {
- var (
- serviceId string
- ruleId string
- )
-
- It("should be passed", func() {
- respCreateService, err := serviceResource.Create(getContext(), &pb.CreateServiceRequest{
- Service: &pb.MicroService{
- AppId: "delete_rule_group",
- ServiceName: "delete_rule_service",
- Version: "1.0.0",
- Level: "FRONT",
- Status: pb.MS_UP,
- },
- })
- Expect(err).To(BeNil())
- Expect(respCreateService.Response.GetCode()).To(Equal(pb.ResponseSuccess))
- serviceId = respCreateService.ServiceId
-
- respAddRule, err := serviceResource.AddRule(getContext(), &pb.AddServiceRulesRequest{
- ServiceId: serviceId,
- Rules: []*pb.AddOrUpdateServiceRule{
- {
- RuleType: "BLACK",
- Attribute: "ServiceName",
- Pattern: "Test*",
- Description: "test BLACK",
- },
- },
- })
- Expect(err).To(BeNil())
- Expect(respAddRule.Response.GetCode()).To(Equal(pb.ResponseSuccess))
- ruleId = respAddRule.RuleIds[0]
- Expect(ruleId).ToNot(Equal(""))
- })
-
- Context("when request is invalid", func() {
- It("should be failed", func() {
- By("service id is empty")
- respAddRule, err := serviceResource.DeleteRule(getContext(), &pb.DeleteServiceRulesRequest{
- ServiceId: "",
- RuleIds: []string{"1000000"},
- })
- Expect(err).To(BeNil())
- Expect(respAddRule.Response.GetCode()).To(Equal(pb.ErrInvalidParams))
-
- By("service does not exist")
- respAddRule, err = serviceResource.DeleteRule(getContext(), &pb.DeleteServiceRulesRequest{
- ServiceId: "notexistservice",
- RuleIds: []string{"1000000"},
- })
- Expect(err).To(BeNil())
- Expect(respAddRule.Response.GetCode()).To(Equal(pb.ErrServiceNotExists))
-
- By("rule does not exist")
- respAddRule, err = serviceResource.DeleteRule(getContext(), &pb.DeleteServiceRulesRequest{
- ServiceId: serviceId,
- RuleIds: []string{"notexistrule"},
- })
- Expect(err).To(BeNil())
- Expect(respAddRule.Response.GetCode()).To(Equal(pb.ErrRuleNotExists))
-
- By("rules is empty")
- respAddRule, err = serviceResource.DeleteRule(getContext(), &pb.DeleteServiceRulesRequest{
- ServiceId: serviceId,
- })
- Expect(err).To(BeNil())
- Expect(respAddRule.Response.GetCode()).To(Equal(pb.ErrInvalidParams))
-
- By("rules is invalid")
- var arr []string
- for i := 0; i < quota.DefaultRuleQuota+1; i++ {
- arr = append(arr, strconv.Itoa(i))
- }
- respAddRule, err = serviceResource.DeleteRule(getContext(), &pb.DeleteServiceRulesRequest{
- ServiceId: serviceId,
- RuleIds: arr,
- })
- Expect(err).To(BeNil())
- Expect(respAddRule.Response.GetCode()).To(Equal(pb.ErrInvalidParams))
-
- })
- })
-
- Context("when request is valid", func() {
- It("should be passed", func() {
- respAddRule, err := serviceResource.DeleteRule(getContext(), &pb.DeleteServiceRulesRequest{
- ServiceId: serviceId,
- RuleIds: []string{ruleId},
- })
- Expect(err).To(BeNil())
- Expect(respAddRule.Response.GetCode()).To(Equal(pb.ResponseSuccess))
-
- respGetRule, err := serviceResource.GetRule(getContext(), &pb.GetServiceRulesRequest{
- ServiceId: serviceId,
- })
- Expect(err).To(BeNil())
- Expect(respGetRule.Response.GetCode()).To(Equal(pb.ResponseSuccess))
- Expect(len(respGetRule.Rules)).To(Equal(0))
- })
- })
- })
-
- Describe("execute 'permission' operartion", func() {
- var (
- consumerVersion string
- consumerTag string
- providerBlack string
- providerWhite string
- )
-
- It("should be passed", func() {
- respCreate, err := serviceResource.Create(getContext(), &pb.CreateServiceRequest{
- Service: &pb.MicroService{
- AppId: "query_instance_tag",
- ServiceName: "query_instance_version_consumer",
- Version: "1.0.0",
- Level: "FRONT",
- Status: pb.MS_UP,
- },
- })
- Expect(err).To(BeNil())
- Expect(respCreate.Response.GetCode()).To(Equal(pb.ResponseSuccess))
- consumerVersion = respCreate.ServiceId
-
- respCreate, err = serviceResource.Create(getContext(), &pb.CreateServiceRequest{
- Service: &pb.MicroService{
- AppId: "query_instance_tag",
- ServiceName: "query_instance_tag_service",
- Version: "1.0.2",
- Level: "FRONT",
- Status: pb.MS_UP,
- },
- })
- Expect(err).To(BeNil())
- Expect(respCreate.Response.GetCode()).To(Equal(pb.ResponseSuccess))
- providerBlack = respCreate.ServiceId
-
- resp, err := serviceResource.AddRule(getContext(), &pb.AddServiceRulesRequest{
- ServiceId: providerBlack,
- Rules: []*pb.AddOrUpdateServiceRule{
- {
- RuleType: "BLACK",
- Attribute: "Version",
- Pattern: "1.0.0",
- },
- {
- RuleType: "BLACK",
- Attribute: "tag_a",
- Pattern: "b",
- },
- },
- })
- Expect(err).To(BeNil())
- Expect(resp.Response.GetCode()).To(Equal(pb.ResponseSuccess))
-
- respCreate, err = serviceResource.Create(getContext(), &pb.CreateServiceRequest{
- Service: &pb.MicroService{
- AppId: "query_instance_tag",
- ServiceName: "query_instance_tag_service",
- Version: "1.0.3",
- Level: "FRONT",
- Status: pb.MS_UP,
- },
- })
- Expect(err).To(BeNil())
- Expect(respCreate.Response.GetCode()).To(Equal(pb.ResponseSuccess))
- providerWhite = respCreate.ServiceId
-
- resp, err = serviceResource.AddRule(getContext(), &pb.AddServiceRulesRequest{
- ServiceId: providerWhite,
- Rules: []*pb.AddOrUpdateServiceRule{
- {
- RuleType: "WHITE",
- Attribute: "Version",
- Pattern: "1.0.0",
- },
- {
- RuleType: "WHITE",
- Attribute: "tag_a",
- Pattern: "b",
- },
- },
- })
- Expect(err).To(BeNil())
- Expect(resp.Response.GetCode()).To(Equal(pb.ResponseSuccess))
-
- respCreate, err = serviceResource.Create(getContext(), &pb.CreateServiceRequest{
- Service: &pb.MicroService{
- AppId: "query_instance_tag",
- ServiceName: "query_instance_tag_consumer",
- Version: "1.0.4",
- Level: "FRONT",
- Status: pb.MS_UP,
- },
- })
- Expect(err).To(BeNil())
- Expect(respCreate.Response.GetCode()).To(Equal(pb.ResponseSuccess))
- consumerTag = respCreate.ServiceId
-
- resp1, err := serviceResource.AddTags(getContext(), &pb.AddServiceTagsRequest{
- ServiceId: consumerTag,
- Tags: map[string]string{"a": "b"},
- })
- Expect(err).To(BeNil())
- Expect(resp1.Response.GetCode()).To(Equal(pb.ResponseSuccess))
- })
-
- Context("when query instances", func() {
- It("should be failed", func() {
- By("consumer version in black list")
- resp, err := discosvc.GetInstances(getContext(), &pb.GetInstancesRequest{
- ConsumerServiceId: consumerVersion,
- ProviderServiceId: providerBlack,
- })
- Expect(err).To(BeNil())
- Expect(resp.Response.GetCode()).To(Equal(pb.ErrServiceNotExists))
-
- By("consumer tag in black list")
- resp, err = discosvc.GetInstances(getContext(), &pb.GetInstancesRequest{
- ConsumerServiceId: consumerTag,
- ProviderServiceId: providerBlack,
- })
- Expect(err).To(BeNil())
- Expect(resp.Response.GetCode()).To(Equal(pb.ErrServiceNotExists))
-
- By("find should return 200 even if consumer permission deny")
- respFind, err := discosvc.FindInstances(getContext(), &pb.FindInstancesRequest{
- ConsumerServiceId: consumerVersion,
- AppId: "query_instance_tag",
- ServiceName: "query_instance_tag_service",
- VersionRule: "0+",
- })
- Expect(err).To(BeNil())
- Expect(respFind.Response.GetCode()).To(Equal(pb.ResponseSuccess))
- Expect(len(respFind.Instances)).To(Equal(0))
- respFind, err = discosvc.FindInstances(getContext(), &pb.FindInstancesRequest{
- ConsumerServiceId: consumerTag,
- AppId: "query_instance_tag",
- ServiceName: "query_instance_tag_service",
- VersionRule: "0+",
- })
- Expect(err).To(BeNil())
- Expect(respFind.Response.GetCode()).To(Equal(pb.ResponseSuccess))
- Expect(len(respFind.Instances)).To(Equal(0))
-
- By("consumer not in black list")
- resp, err = discosvc.GetInstances(getContext(), &pb.GetInstancesRequest{
- ConsumerServiceId: providerWhite,
- ProviderServiceId: providerBlack,
- })
- Expect(err).To(BeNil())
- Expect(resp.Response.GetCode()).To(Equal(pb.ResponseSuccess))
-
- By("consumer not in white list")
- resp, err = discosvc.GetInstances(getContext(), &pb.GetInstancesRequest{
- ConsumerServiceId: providerBlack,
- ProviderServiceId: providerWhite,
- })
- Expect(err).To(BeNil())
- Expect(resp.Response.GetCode()).To(Equal(pb.ErrServiceNotExists))
-
- By("consumer version in white list")
- resp, err = discosvc.GetInstances(getContext(), &pb.GetInstancesRequest{
- ConsumerServiceId: consumerVersion,
- ProviderServiceId: providerWhite,
- })
- Expect(err).To(BeNil())
- Expect(resp.Response.GetCode()).To(Equal(pb.ResponseSuccess))
-
- By("consumer tag in white list")
- resp, err = discosvc.GetInstances(getContext(), &pb.GetInstancesRequest{
- ConsumerServiceId: consumerTag,
- ProviderServiceId: providerWhite,
- })
- Expect(err).To(BeNil())
- Expect(resp.Response.GetCode()).To(Equal(pb.ResponseSuccess))
- })
- })
- })
-})
diff --git a/server/service/disco/tag_test.go b/server/service/disco/tag_test.go
index 92b63df..7483d50 100644
--- a/server/service/disco/tag_test.go
+++ b/server/service/disco/tag_test.go
@@ -102,7 +102,7 @@ var _ = Describe("'Tag' service", func() {
Context("when request is valid", func() {
It("should be passed", func() {
By("all max")
- size := quota.DefaultRuleQuota
+ size := quota.DefaultTagQuota
tags := make(map[string]string, size)
for i := 0; i < size; i++ {
s := "tag" + strconv.Itoa(i)
@@ -128,7 +128,7 @@ var _ = Describe("'Tag' service", func() {
Context("when create tag out of gauge", func() {
It("should be failed", func() {
- size := quota.DefaultRuleQuota + 1
+ size := quota.DefaultTagQuota + 1
tags := make(map[string]string, size)
for i := 0; i < size; i++ {
s := "tag" + strconv.Itoa(i)
@@ -141,7 +141,7 @@ var _ = Describe("'Tag' service", func() {
Expect(err).To(BeNil())
Expect(respAddTags.Response.GetCode()).To(Equal(pb.ErrInvalidParams))
- size = quota.DefaultRuleQuota
+ size = quota.DefaultTagQuota
tags = make(map[string]string, size)
for i := 0; i < size; i++ {
s := "tag" + strconv.Itoa(i)
@@ -385,48 +385,6 @@ var _ = Describe("'Tag' service", func() {
Expect(err).To(BeNil())
Expect(findResp.Response.GetCode()).To(Equal(pb.ResponseSuccess))
Expect(findResp.Instances[0].InstanceId).To(Equal(instanceResp.InstanceId))
-
- respAddRule, err := serviceResource.AddRule(getContext(), &pb.AddServiceRulesRequest{
- ServiceId: providerId,
- Rules: []*pb.AddOrUpdateServiceRule{
- {
- RuleType: "WHITE",
- Attribute: "tag_consumer_tag",
- Pattern: "f*",
- Description: "test white",
- },
- },
- })
- Expect(err).To(BeNil())
- Expect(respAddRule.Response.GetCode()).To(Equal(pb.ResponseSuccess))
-
- findResp, err = disco.FindInstances(getContext(), &pb.FindInstancesRequest{
- ConsumerServiceId: consumerId,
- AppId: "find_inst_tag_group",
- ServiceName: "find_inst_tag_provider",
- VersionRule: "1.0.0+",
- Tags: []string{"filter_tag"},
- })
- Expect(err).To(BeNil())
- Expect(findResp.Response.GetCode()).To(Equal(pb.ResponseSuccess))
- Expect(len(findResp.Instances)).To(Equal(0))
-
- addTagResp, err = serviceResource.AddTags(getContext(), &pb.AddServiceTagsRequest{
- ServiceId: consumerId,
- Tags: map[string]string{"consumer_tag": "filter"},
- })
- Expect(err).To(BeNil())
- Expect(addTagResp.Response.GetCode()).To(Equal(pb.ResponseSuccess))
-
- findResp, err = disco.FindInstances(getContext(), &pb.FindInstancesRequest{
- ConsumerServiceId: consumerId,
- AppId: "find_inst_tag_group",
- ServiceName: "find_inst_tag_provider",
- VersionRule: "1.0.0+",
- Tags: []string{"filter_tag"},
- })
- Expect(findResp.Response.GetCode()).To(Equal(pb.ResponseSuccess))
- Expect(findResp.Instances[0].InstanceId).To(Equal(instanceResp.InstanceId))
})
})
@@ -512,7 +470,7 @@ var _ = Describe("'Tag' service", func() {
Expect(respAddTags.Response.GetCode()).To(Equal(pb.ErrInvalidParams))
var arr []string
- for i := 0; i < quota.DefaultRuleQuota+1; i++ {
+ for i := 0; i < quota.DefaultTagQuota+1; i++ {
arr = append(arr, strconv.Itoa(i))
}
respAddTags, err = serviceResource.DeleteTags(getContext(), &pb.DeleteServiceTagsRequest{
diff --git a/server/service/quota/quota.go b/server/service/quota/quota.go
index 9074e74..036b0ff 100644
--- a/server/service/quota/quota.go
+++ b/server/service/quota/quota.go
@@ -40,16 +40,6 @@ func InstanceUsage(ctx context.Context, request *discovery.GetServiceCountReques
return resp.Count, nil
}
-func RuleUsage(ctx context.Context, serviceID string) (int64, error) {
- resp, err := datasource.GetMetadataManager().GetRules(ctx, &discovery.GetServiceRulesRequest{
- ServiceId: serviceID,
- })
- if err != nil {
- return 0, err
- }
- return int64(len(resp.Rules)), nil
-}
-
func SchemaUsage(ctx context.Context, serviceID string) (int64, error) {
resp, err := datasource.GetMetadataManager().GetAllSchemas(ctx, &discovery.GetAllSchemaRequest{
ServiceId: serviceID,
diff --git a/server/service/validator/rule_validator.go b/server/service/validator/rule_validator.go
deleted file mode 100644
index 6f7c7d4..0000000
--- a/server/service/validator/rule_validator.go
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * 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 validator
-
-import (
- "regexp"
-
- "github.com/apache/servicecomb-service-center/pkg/validate"
- "github.com/apache/servicecomb-service-center/server/plugin/quota"
-)
-
-var (
- getRulesReqValidator validate.Validator
- updateRuleReqValidator validate.Validator
- addRulesReqValidator validate.Validator
- deleteRulesReqValidator validate.Validator
-)
-
-var (
- ruleRegex, _ = regexp.Compile(`^(WHITE|BLACK)$`)
- ruleAttrRegex, _ = regexp.Compile(`((^tag_[a-zA-Z][a-zA-Z0-9_\-.]{0,63}$)|(^ServiceId$)|(^AppId$)|(^ServiceName$)|(^Version$)|(^Description$)|(^Level$)|(^Status$))`)
-)
-
-func GetRulesReqValidator() *validate.Validator {
- return getRulesReqValidator.Init(func(v *validate.Validator) {
- v.AddRule("ServiceId", GetServiceReqValidator().GetRule("ServiceId"))
- })
-}
-
-func UpdateRuleReqValidator() *validate.Validator {
- return updateRuleReqValidator.Init(func(v *validate.Validator) {
- var ruleValidator validate.Validator
- ruleValidator.AddRule("RuleType", &validate.Rule{Regexp: ruleRegex})
- ruleValidator.AddRule("Attribute", &validate.Rule{Regexp: ruleAttrRegex})
- ruleValidator.AddRule("Pattern", &validate.Rule{Min: 1, Max: 64})
- ruleValidator.AddRule("Description", CreateServiceReqValidator().GetSub("Service").GetRule("Description"))
-
- v.AddRule("ServiceId", GetServiceReqValidator().GetRule("ServiceId"))
- v.AddRule("RuleId", GetServiceReqValidator().GetRule("ServiceId"))
- v.AddSub("Rule", &ruleValidator)
- })
-}
-
-func AddRulesReqValidator() *validate.Validator {
- return addRulesReqValidator.Init(func(v *validate.Validator) {
- v.AddRule("ServiceId", GetServiceReqValidator().GetRule("ServiceId"))
- v.AddRule("Rules", &validate.Rule{Min: 1, Max: quota.DefaultRuleQuota})
- v.AddSub("Rules", UpdateRuleReqValidator().GetSub("Rule"))
- })
-}
-
-func DeleteRulesReqValidator() *validate.Validator {
- return deleteRulesReqValidator.Init(func(v *validate.Validator) {
- v.AddRule("ServiceId", GetServiceReqValidator().GetRule("ServiceId"))
- v.AddRule("RuleIds", &validate.Rule{Min: 1, Max: quota.DefaultRuleQuota})
- })
-}
diff --git a/server/service/validator/validator.go b/server/service/validator/validator.go
index b00ea98..02cf2c3 100644
--- a/server/service/validator/validator.go
+++ b/server/service/validator/validator.go
@@ -101,14 +101,6 @@ func Validate(v interface{}) error {
return HeartbeatReqValidator().Validate(v)
case *pb.UpdateInstancePropsRequest:
return UpdateInstancePropsReqValidator().Validate(v)
- case *pb.GetServiceRulesRequest:
- return GetRulesReqValidator().Validate(v)
- case *pb.AddServiceRulesRequest:
- return AddRulesReqValidator().Validate(v)
- case *pb.UpdateServiceRuleRequest:
- return UpdateRuleReqValidator().Validate(v)
- case *pb.DeleteServiceRulesRequest:
- return DeleteRulesReqValidator().Validate(v)
case *pb.GetAppsRequest:
return MicroServiceKeyValidator().Validate(v)
default: