little-cui closed pull request #248: SCB-235 Optimize quota check log
URL: https://github.com/apache/incubator-servicecomb-service-center/pull/248
 
 
   

This is a PR merged from a forked repository.
As GitHub hides the original diff on merge, it is displayed below for
the sake of provenance:

As this is a foreign pull request (from a fork), the diff is supplied
below (as it won't show otherwise due to GitHub magic):

diff --git a/etc/conf/app.conf b/etc/conf/app.conf
index 1799c304..9d54f2d6 100644
--- a/etc/conf/app.conf
+++ b/etc/conf/app.conf
@@ -43,7 +43,7 @@ compact_interval = 12h
 
 cipher_plugin = ""
 
-#suppot buildin, fusionstage, unlimit
+#suppot buildin, unlimit
 quota_plugin = ""
 
 # access control plugin
diff --git a/server/core/proto/services.go b/server/core/proto/services.go
index cf6ea39c..27f2e2e4 100644
--- a/server/core/proto/services.go
+++ b/server/core/proto/services.go
@@ -23,6 +23,7 @@ import (
        "github.com/gorilla/websocket"
        "golang.org/x/net/context"
        "strings"
+       scerr 
"github.com/apache/incubator-servicecomb-service-center/server/error"
 )
 
 type EventType string
@@ -131,6 +132,13 @@ func CreateResponse(code int32, message string) *Response {
        return resp
 }
 
+func CreateResponseWithSCErr(err *scerr.Error) *Response {
+       return &Response{
+               Code:    err.Code,
+               Message: err.Detail,
+       }
+}
+
 func KvToResponse(kv *mvccpb.KeyValue) (keys []string, data []byte) {
        keys = strings.Split(util.BytesToStringWithNoCopy(kv.Key), "/")
        data = kv.Value
diff --git a/server/error/error.go b/server/error/error.go
index cdad863b..5ee5bf12 100644
--- a/server/error/error.go
+++ b/server/error/error.go
@@ -116,6 +116,13 @@ func (e Error) StatusCode() int {
        return http.StatusBadRequest
 }
 
+func (e Error) InternalError() bool {
+       if e.Code >= 500000 {
+               return true
+       }
+       return false
+}
+
 func (e Error) HttpWrite(w http.ResponseWriter) {
        status := e.StatusCode()
        w.Header().Add("X-Response-Status", fmt.Sprint(status))
diff --git a/server/infra/quota/quota.go b/server/infra/quota/quota.go
index ba7ecb49..84dc579c 100644
--- a/server/infra/quota/quota.go
+++ b/server/infra/quota/quota.go
@@ -19,10 +19,39 @@ package quota
 import (
        "fmt"
        "golang.org/x/net/context"
+       scerr 
"github.com/apache/incubator-servicecomb-service-center/server/error"
 )
 
+type ApplyQuotaResult struct {
+       Reporter QuotaReporter
+       Err      *scerr.Error
+}
+
+func NewApplyQuotaResult(reporter QuotaReporter, err *scerr.Error) 
*ApplyQuotaResult {
+       return &ApplyQuotaResult{
+               reporter,
+               err,
+       }
+}
+
+type ApplyQuotaResource struct {
+       QuotaType     ResourceType
+       DomainProject string
+       ServiceId     string
+       QuotaSize     int64
+}
+
+func NewApplyQuotaResource(quotaType ResourceType, domainProject, serviceId 
string, quotaSize int64) *ApplyQuotaResource {
+       return &ApplyQuotaResource{
+               quotaType,
+               domainProject,
+               serviceId,
+               quotaSize,
+       }
+}
+
 type QuotaManager interface {
-       Apply4Quotas(ctx context.Context, quotaType ResourceType, domainProject 
string, serviceId string, quotaSize int16) (QuotaReporter, bool, error)
+       Apply4Quotas(ctx context.Context, res *ApplyQuotaResource) 
*ApplyQuotaResult
        RemandQuotas(ctx context.Context, quotaType ResourceType)
 }
 
diff --git a/server/plugin/infra/quota/buildin/buildin.go 
b/server/plugin/infra/quota/buildin/buildin.go
index a8b7b11f..018a845b 100644
--- a/server/plugin/infra/quota/buildin/buildin.go
+++ b/server/plugin/infra/quota/buildin/buildin.go
@@ -27,6 +27,7 @@ import (
        serviceUtil 
"github.com/apache/incubator-servicecomb-service-center/server/service/util"
        "golang.org/x/net/context"
        "strings"
+       scerr 
"github.com/apache/incubator-servicecomb-service-center/server/error"
 )
 
 const (
@@ -52,20 +53,18 @@ type BuildInQuota struct {
 }
 
 //????sourceType serviceinstance servicetype
-func (q *BuildInQuota) Apply4Quotas(ctx context.Context, quotaType 
quota.ResourceType, domainProject string, serviceId string, quotaSize int16) 
(quota.QuotaReporter, bool, error) {
+func (q *BuildInQuota) Apply4Quotas(ctx context.Context, res 
*quota.ApplyQuotaResource) *quota.ApplyQuotaResult {
        data := &QuotaApplyData{
-               domain:    strings.Split(domainProject, "/")[0],
-               quotaSize: int64(quotaSize),
+               domain:    strings.Split(res.DomainProject, "/")[0],
+               quotaSize: res.QuotaSize,
        }
-       switch quotaType {
+       switch res.QuotaType {
        case quota.MicroServiceInstanceQuotaType:
-               isOk, err := instanceQuotaCheck(ctx, data)
-               return nil, isOk, err
+               return instanceQuotaCheck(ctx, data)
        case quota.MicroServiceQuotaType:
-               isOk, err := serviceQuotaCheck(ctx, data)
-               return nil, isOk, err
+               return serviceQuotaCheck(ctx, data)
        default:
-               return ResourceLimitHandler(ctx, quotaType, domainProject, 
serviceId, quotaSize)
+               return ResourceLimitHandler(ctx, res)
        }
 }
 
@@ -73,12 +72,14 @@ func (q *BuildInQuota) Apply4Quotas(ctx context.Context, 
quotaType quota.Resourc
 func (q *BuildInQuota) RemandQuotas(ctx context.Context, quotaType 
quota.ResourceType) {
 }
 
-func ResourceLimitHandler(ctx context.Context, quotaType quota.ResourceType, 
domainProject string, serviceId string, quotaSize int16) (quota.QuotaReporter, 
bool, error) {
+func ResourceLimitHandler(ctx context.Context, res *quota.ApplyQuotaResource) 
*quota.ApplyQuotaResult {
        var key string
        var max int64 = 0
        var indexer *store.Indexer
 
-       switch quotaType {
+       domainProject := res.DomainProject
+       serviceId := res.ServiceId
+       switch res.QuotaType {
        case quota.RuleQuotaType:
                key = core.GenerateServiceRuleKey(domainProject, serviceId, "")
                max = RULE_NUM_MAX_LIMIT_PER_SERVICE
@@ -88,19 +89,23 @@ func ResourceLimitHandler(ctx context.Context, quotaType 
quota.ResourceType, dom
                max = SCHEMA_NUM_MAX_LIMIT_PER_SERVICE
                indexer = store.Store().Schema()
        case quota.TagQuotaType:
-               num := quotaSize
+               applyNum := res.QuotaSize
                max = TAG_NUM_MAX_LIMIT_PER_SERVICE
                tags, err := serviceUtil.GetTagsUtils(ctx, domainProject, 
serviceId)
                if err != nil {
-                       return nil, false, err
+                       return quota.NewApplyQuotaResult(nil, 
scerr.NewError(scerr.ErrInternal, err.Error()))
                }
-               if int64(len(tags))+int64(num) > max {
-                       util.Logger().Errorf(nil, "no quota(%d) to apply 
resource '%s', %s", max, quotaType, serviceId)
-                       return nil, false, nil
+               curNum := int64(len(tags))
+               if curNum+applyNum > max {
+                       mes := fmt.Sprintf("no quota to apply %s , max quota is 
%d, current used quota is %d, apply quota num is %d",
+                               res.QuotaType, max, curNum, applyNum)
+                       util.Logger().Errorf(nil, "%s, serviceId is %s", mes, 
serviceId)
+                       return quota.NewApplyQuotaResult(nil, 
scerr.NewError(scerr.ErrNotEnoughQuota, mes))
                }
-               return nil, true, nil
+               return quota.NewApplyQuotaResult(nil, nil)
        default:
-               return nil, false, fmt.Errorf("Unsurported resource '%s'", 
quotaType)
+               mes := fmt.Sprintf("not define quota type %s", res.QuotaType)
+               return quota.NewApplyQuotaResult(nil, 
scerr.NewError(scerr.ErrInternal, mes))
        }
 
        resp, err := indexer.Search(ctx,
@@ -108,15 +113,17 @@ func ResourceLimitHandler(ctx context.Context, quotaType 
quota.ResourceType, dom
                registry.WithPrefix(),
                registry.WithCountOnly())
        if err != nil {
-               return nil, false, err
+               return quota.NewApplyQuotaResult(nil, 
scerr.NewError(scerr.ErrInternal, err.Error()))
        }
-       num := resp.Count + int64(quotaSize)
+       num := resp.Count + int64(res.QuotaSize)
        util.Logger().Debugf("resource num is %d", num)
        if num > max {
-               util.Logger().Errorf(nil, "no quota(%d) to apply resource '%s', 
%s", max, quotaType, serviceId)
-               return nil, false, nil
+               mes := fmt.Sprintf("no quota to apply %s, max quota is %d, 
current used quota is %d, apply quota num is %d",
+                       res.QuotaType, max, resp.Count, res.QuotaSize)
+               util.Logger().Errorf(nil, "%s,  serviceId %s", mes, serviceId)
+               return quota.NewApplyQuotaResult(nil, 
scerr.NewError(scerr.ErrNotEnoughQuota, mes))
        }
-       return nil, true, nil
+       return quota.NewApplyQuotaResult(nil, nil)
 }
 
 type QuotaApplyData struct {
@@ -129,29 +136,46 @@ type QuotaApplyData struct {
 type GetCurUsedNum func(context.Context, *QuotaApplyData) (int64, error)
 type GetLimitQuota func() int64
 
-func quotaCheck(ctx context.Context, data *QuotaApplyData, getLimitQuota 
GetLimitQuota, getCurUsedNum GetCurUsedNum) (bool, error) {
+type QuotaCheckResult struct {
+       IsOk   bool
+       CurNum int64
+       Err    error
+}
+
+func NewQuotaCheckResult(isOk bool, curNum int64, err error) QuotaCheckResult {
+       return QuotaCheckResult{
+               isOk,
+               curNum,
+               err,
+       }
+}
+
+func quotaCheck(ctx context.Context, data *QuotaApplyData, getLimitQuota 
GetLimitQuota, getCurUsedNum GetCurUsedNum) QuotaCheckResult {
        limitQuota := getLimitQuota()
        curNum, err := getCurUsedNum(ctx, data)
        if err != nil {
-               return false, err
+               return NewQuotaCheckResult(false, 0, err)
        }
        if curNum+data.quotaSize > limitQuota {
-               return false, nil
+               return NewQuotaCheckResult(false, curNum, nil)
        }
-       return true, nil
+       return NewQuotaCheckResult(true, curNum, nil)
 }
 
-func instanceQuotaCheck(ctx context.Context, data *QuotaApplyData) (isOk bool, 
err error) {
-       isOk, err = quotaCheck(ctx, data, getInstanceMaxLimit, 
getAllInstancesNum)
-       if err != nil {
-               util.Logger().Errorf(err, "instance quota check failed")
-               return
+func instanceQuotaCheck(ctx context.Context, data *QuotaApplyData) 
*quota.ApplyQuotaResult {
+       rst := quotaCheck(ctx, data, getInstanceMaxLimit, getAllInstancesNum)
+       err := rst.Err
+       if rst.Err != nil {
+               util.Logger().Errorf(rst.Err, "instance quota check failed")
+               return quota.NewApplyQuotaResult(nil, 
scerr.NewError(scerr.ErrInternal, err.Error()))
        }
-       if !isOk {
-               util.Logger().Errorf(err, "no quota to create instance")
-               return
+       if !rst.IsOk {
+               mes := fmt.Sprintf("no quota to create instance, max num is %d, 
curNum is %d, apply num is %d",
+                       getInstanceMaxLimit(), rst.CurNum, data.quotaSize)
+               util.Logger().Errorf(nil, mes)
+               return quota.NewApplyQuotaResult(nil, 
scerr.NewError(scerr.ErrNotEnoughQuota, mes))
        }
-       return
+       return quota.NewApplyQuotaResult(nil, nil)
 }
 
 func getInstanceMaxLimit() int64 {
@@ -174,17 +198,20 @@ func getAllInstancesNum(ctx context.Context, data 
*QuotaApplyData) (int64, error
        return getInstancesNum(ctx, key)
 }
 
-func serviceQuotaCheck(ctx context.Context, data *QuotaApplyData) (isOk bool, 
err error) {
-       isOk, err = quotaCheck(ctx, data, getServiceMaxLimit, getAllServicesNum)
+func serviceQuotaCheck(ctx context.Context, data *QuotaApplyData) 
*quota.ApplyQuotaResult {
+       rst := quotaCheck(ctx, data, getServiceMaxLimit, getAllServicesNum)
+       err := rst.Err
        if err != nil {
                util.Logger().Errorf(err, "service quota check failed")
-               return
+               return quota.NewApplyQuotaResult(nil, 
scerr.NewError(scerr.ErrInternal, err.Error()))
        }
-       if !isOk {
-               util.Logger().Errorf(err, "no quota to create service")
-               return
+       if !rst.IsOk {
+               mes := fmt.Sprintf("no quota to create service, max quota is 
%d, current used quota is %d, apply quota num is %d",
+                       getServiceMaxLimit(), rst.CurNum, data.quotaSize)
+               util.Logger().Errorf(err, mes)
+               return quota.NewApplyQuotaResult(nil, 
scerr.NewError(scerr.ErrNotEnoughQuota, mes))
        }
-       return
+       return quota.NewApplyQuotaResult(nil,nil)
 }
 
 func getServiceMaxLimit() int64 {
diff --git a/server/plugin/infra/quota/unlimit/unlimit.go 
b/server/plugin/infra/quota/unlimit/unlimit.go
index 422f0eee..319d8cf3 100644
--- a/server/plugin/infra/quota/unlimit/unlimit.go
+++ b/server/plugin/infra/quota/unlimit/unlimit.go
@@ -41,8 +41,8 @@ func New() mgr.PluginInstance {
        return &Unlimit{}
 }
 
-func (q *Unlimit) Apply4Quotas(ctx context.Context, quotaType 
quota.ResourceType, domainProject string, serviceId string, quotaSize int16) 
(quota.QuotaReporter, bool, error) {
-       return nil, true, nil
+func (q *Unlimit) Apply4Quotas(ctx context.Context, res 
*quota.ApplyQuotaResource) *quota.ApplyQuotaResult {
+       return quota.NewApplyQuotaResult(nil, nil)
 }
 
 func (q *Unlimit) RemandQuotas(ctx context.Context, quotaType 
quota.ResourceType) {
diff --git a/server/service/instances.go b/server/service/instances.go
index 8fdbd6a2..0f29b6fe 100644
--- a/server/service/instances.go
+++ b/server/service/instances.go
@@ -33,7 +33,6 @@ import (
        "github.com/gorilla/websocket"
        "golang.org/x/net/context"
        "math"
-       "net/http"
        "strconv"
        "time"
 )
@@ -108,23 +107,22 @@ func (s *InstanceService) Register(ctx context.Context, 
in *pb.RegisterInstanceR
        var reporter quota.QuotaReporter
        if len(oldInstanceId) == 0 {
                if !apt.IsSCInstance(ctx) {
-                       var err error
-                       var ok bool
-                       reporter, ok, err = 
plugin.Plugins().Quota().Apply4Quotas(ctx, quota.MicroServiceInstanceQuotaType, 
domainProject, in.Instance.ServiceId, 1)
+                       res := 
quota.NewApplyQuotaResource(quota.MicroServiceInstanceQuotaType, domainProject, 
in.Instance.ServiceId, 1)
+                       rst := plugin.Plugins().Quota().Apply4Quotas(ctx, res)
+                       reporter = rst.Reporter
+                       err := rst.Err
                        if reporter != nil {
                                defer reporter.Close()
                        }
                        if err != nil {
-                               util.Logger().Errorf(err, "register instance 
failed, service %s, operator %s: check apply quota failed.", instanceFlag, 
remoteIP)
-                               return &pb.RegisterInstanceResponse{
-                                       Response: 
pb.CreateResponse(scerr.ErrUnavailableQuota, err.Error()),
-                               }, err
-                       }
-                       if !ok {
-                               util.Logger().Errorf(nil, "register instance 
failed, service %s, operator %s: no quota apply.", instanceFlag, remoteIP)
-                               return &pb.RegisterInstanceResponse{
-                                       Response: 
pb.CreateResponse(scerr.ErrNotEnoughQuota, "No quota to create instance."),
-                               }, nil
+                               util.Logger().Errorf(err, "register instance 
failed, service %s, operator %s: no quota apply.", instanceFlag, remoteIP)
+                               response := &pb.RegisterInstanceResponse{
+                                       Response: 
pb.CreateResponseWithSCErr(err),
+                               }
+                               if err.InternalError() {
+                                       return response, err
+                               }
+                               return response, nil
                        }
                }
        }
@@ -422,9 +420,9 @@ func (s *InstanceService) GetOneInstance(ctx 
context.Context, in *pb.GetOneInsta
        if checkErr != nil {
                util.Logger().Errorf(checkErr, "get instance failed: pre check 
failed.")
                resp := &pb.GetOneInstanceResponse{
-                       Response: pb.CreateResponse(checkErr.Code, 
checkErr.Detail),
+                       Response: pb.CreateResponseWithSCErr(checkErr),
                }
-               if checkErr.StatusCode() == http.StatusInternalServerError {
+               if checkErr.InternalError() {
                        return resp, checkErr
                }
                return resp, nil
@@ -508,9 +506,9 @@ func (s *InstanceService) GetInstances(ctx context.Context, 
in *pb.GetInstancesR
        if checkErr != nil {
                util.Logger().Errorf(checkErr, "get instances failed: pre check 
failed.")
                resp := &pb.GetInstancesResponse{
-                       Response: pb.CreateResponse(checkErr.Code, 
checkErr.Detail),
+                       Response: pb.CreateResponseWithSCErr(checkErr),
                }
-               if checkErr.StatusCode() == http.StatusInternalServerError {
+               if checkErr.InternalError() {
                        return resp, checkErr
                }
                return resp, nil
@@ -540,7 +538,7 @@ func (s *InstanceService) Find(ctx context.Context, in 
*pb.FindInstancesRequest)
        }
 
        domainProject := util.ParseDomainProject(ctx)
-       findFlag := fmt.Sprintf("consumer %s --> provider %s/%s/%s", 
in.ConsumerServiceId, in.AppId, in.ServiceName, in.VersionRule)
+       findFlag := fmt.Sprintf("consumer %s find provider %s/%s/%s", 
in.ConsumerServiceId, in.AppId, in.ServiceName, in.VersionRule)
 
        service, err := serviceUtil.GetService(ctx, domainProject, 
in.ConsumerServiceId)
        if err != nil {
@@ -584,9 +582,10 @@ func (s *InstanceService) Find(ctx context.Context, in 
*pb.FindInstancesRequest)
                }, err
        }
        if len(ids) == 0 {
-               util.Logger().Errorf(nil, "find instance failed, %s: no 
provider matched.", findFlag)
+               mes := fmt.Sprintf("no provider matched, %s", findFlag)
+               util.Logger().Errorf(nil, "find instance failed, %s", mes)
                return &pb.FindInstancesResponse{
-                       Response: pb.CreateResponse(scerr.ErrServiceNotExists, 
"No provider matched."),
+                       Response: pb.CreateResponse(scerr.ErrServiceNotExists, 
mes),
                }, nil
        }
 
@@ -608,7 +607,7 @@ func (s *InstanceService) Find(ctx context.Context, in 
*pb.FindInstancesRequest)
                }
        }
 
-       //??version???,servicename ????????????
+       //??version???,service name ????????????
        providerService, err := serviceUtil.GetService(ctx, provider.Tenant, 
ids[0])
        if providerService == nil {
                util.Logger().Errorf(err, "find instance failed, %s: no 
provider matched.", findFlag)
diff --git a/server/service/microservices.go b/server/service/microservices.go
index aadbcea5..578c408d 100644
--- a/server/service/microservices.go
+++ b/server/service/microservices.go
@@ -32,9 +32,9 @@ import (
        "github.com/apache/incubator-servicecomb-service-center/server/plugin"
        serviceUtil 
"github.com/apache/incubator-servicecomb-service-center/server/service/util"
        "golang.org/x/net/context"
-       "net/http"
        "strconv"
        "time"
+       "errors"
 )
 
 type MicroServiceService struct {
@@ -48,7 +48,7 @@ const (
 
 func (s *MicroServiceService) Create(ctx context.Context, in 
*pb.CreateServiceRequest) (*pb.CreateServiceResponse, error) {
        if in == nil || in.Service == nil {
-               util.Logger().Errorf(nil, "create microservice failed : param 
empty.")
+               util.Logger().Errorf(nil, "create micro-service failed : param 
empty.")
                return &pb.CreateServiceResponse{
                        Response: pb.CreateResponse(scerr.ErrInvalidParams, 
"request format invalid"),
                }, nil
@@ -77,7 +77,7 @@ func (s *MicroServiceService) CreateServicePri(ctx 
context.Context, in *pb.Creat
 
        err := apt.Validate(service)
        if err != nil {
-               util.Logger().Errorf(err, "create microservice failed, %s: 
invalid parameters. operator: %s",
+               util.Logger().Errorf(err, "create micro-service failed, %s: 
invalid parameters. operator: %s",
                        serviceFlag, remoteIP)
                return &pb.CreateServiceResponse{
                        Response: pb.CreateResponse(scerr.ErrInvalidParams, 
err.Error()),
@@ -99,12 +99,12 @@ func (s *MicroServiceService) CreateServicePri(ctx 
context.Context, in *pb.Creat
                defer reporter.Close()
        }
        if quotaErr != nil {
-               util.Logger().Errorf(err, "create microservice failed, %s: 
check service failed before create. operator: %s",
+               util.Logger().Errorf(quotaErr, "create micro-service failed, 
%s: check service failed before create. operator: %s",
                        serviceFlag, remoteIP)
                resp := &pb.CreateServiceResponse{
-                       Response: pb.CreateResponse(quotaErr.Code, 
quotaErr.Detail),
+                       Response: pb.CreateResponseWithSCErr(quotaErr),
                }
-               if quotaErr.StatusCode() == http.StatusInternalServerError {
+               if quotaErr.InternalError() {
                        return resp, quotaErr
                }
                return resp, nil
@@ -121,7 +121,7 @@ func (s *MicroServiceService) CreateServicePri(ctx 
context.Context, in *pb.Creat
 
        data, err := json.Marshal(service)
        if err != nil {
-               util.Logger().Errorf(err, "create microservice failed, %s: json 
marshal service failed. operator: %s",
+               util.Logger().Errorf(err, "create micro-service failed, %s: 
json marshal service failed. operator: %s",
                        serviceFlag, remoteIP)
                return &pb.CreateServiceResponse{
                        Response: pb.CreateResponse(scerr.ErrInternal, "Body 
error "+err.Error()),
@@ -147,16 +147,16 @@ func (s *MicroServiceService) CreateServicePri(ctx 
context.Context, in *pb.Creat
 
        resp, err := backend.Registry().TxnWithCmp(ctx, opts, uniqueCmpOpts, 
nil)
        if err != nil {
-               util.Logger().Errorf(err, "create microservice failed, %s: 
commit data into etcd failed. operator: %s",
+               util.Logger().Errorf(err, "create micro-service failed, %s: 
commit data into etcd failed. operator: %s",
                        serviceFlag, remoteIP)
                return &pb.CreateServiceResponse{
-                       Response: 
pb.CreateResponse(scerr.ErrUnavailableBackend, "Commit operations failed."),
+                       Response: 
pb.CreateResponse(scerr.ErrUnavailableBackend, "commit operations failed."),
                }, err
        }
        if !resp.Succeeded {
                if s.isCreateServiceEx(in) == true {
                        serviceIdInner, _ := serviceUtil.GetServiceId(ctx, 
serviceKey)
-                       util.Logger().Warnf(nil, "create microservice failed, 
serviceid = %s , flag = %s: service already exists. operator: %s",
+                       util.Logger().Warnf(nil, "create micro-service failed, 
serviceId = %s , flag = %s: service already exists. operator: %s",
                                serviceIdInner, serviceFlag, remoteIP)
 
                        return &pb.CreateServiceResponse{
@@ -165,7 +165,7 @@ func (s *MicroServiceService) CreateServicePri(ctx 
context.Context, in *pb.Creat
                        }, nil
                }
 
-               util.Logger().Warnf(nil, "create microservice failed, %s: 
service already exists. operator: %s",
+               util.Logger().Warnf(nil, "create micro-service failed, %s: 
service already exists. operator: %s",
                        serviceFlag, remoteIP)
 
                return &pb.CreateServiceResponse{
@@ -178,7 +178,7 @@ func (s *MicroServiceService) CreateServicePri(ctx 
context.Context, in *pb.Creat
                        util.Logger().Errorf(err, "report used quota failed.")
                }
        }
-       util.Logger().Infof("create microservice successful, %s, serviceId: %s. 
operator: %s",
+       util.Logger().Infof("create micro-service successful, %s, serviceId: 
%s. operator: %s",
                serviceFlag, service.ServiceId, remoteIP)
        return &pb.CreateServiceResponse{
                Response:  pb.CreateResponse(pb.Response_SUCCESS, "Register 
service successfully."),
@@ -191,15 +191,9 @@ func checkQuota(ctx context.Context, domainProject string) 
(quota.QuotaReporter,
                util.Logger().Infof("it is service-center")
                return nil, nil
        }
-       reporter, ok, err := plugin.Plugins().Quota().Apply4Quotas(ctx, 
quota.MicroServiceQuotaType, domainProject, "", 1)
-       if err != nil {
-               return reporter, scerr.NewError(scerr.ErrUnavailableQuota,
-                       fmt.Sprintf("An error occurred in apply for 
quotas(%s)", err.Error()))
-       }
-       if !ok {
-               return reporter, scerr.NewError(scerr.ErrNotEnoughQuota, "No 
quota to create service")
-       }
-       return reporter, nil
+       res := quota.NewApplyQuotaResource(quota.MicroServiceQuotaType, 
domainProject, "", 1)
+       rst := plugin.Plugins().Quota().Apply4Quotas(ctx, res)
+       return rst.Reporter, rst.Err
 }
 
 func (s *MicroServiceService) DeleteServicePri(ctx context.Context, ServiceId 
string, force bool) (*pb.Response, error) {
@@ -211,19 +205,19 @@ func (s *MicroServiceService) DeleteServicePri(ctx 
context.Context, ServiceId st
        }
 
        if ServiceId == apt.Service.ServiceId {
-               err := fmt.Errorf("Not allow to delete service center")
-               util.Logger().Errorf(err, "%s microservice failed, serviceId is 
%s", title, ServiceId)
+               err := errors.New("not allow to delete service center")
+               util.Logger().Errorf(err, "%s micro-service failed, serviceId 
is %s", title, ServiceId)
                return pb.CreateResponse(scerr.ErrInvalidParams, err.Error()), 
nil
        }
 
        service, err := serviceUtil.GetService(ctx, domainProject, ServiceId)
        if err != nil {
-               util.Logger().Errorf(err, "%s microservice failed, serviceId is 
%s: get service failed.", title, ServiceId)
+               util.Logger().Errorf(err, "%s micro-service failed, serviceId 
is %s: get service failed.", title, ServiceId)
                return pb.CreateResponse(scerr.ErrInternal, err.Error()), err
        }
 
        if service == nil {
-               util.Logger().Errorf(err, "%s microservice failed, serviceId is 
%s: service not exist.", title, ServiceId)
+               util.Logger().Errorf(err, "%s micro-service failed, serviceId 
is %s: service not exist.", title, ServiceId)
                return pb.CreateResponse(scerr.ErrServiceNotExists, "Service 
does not exist."), nil
        }
 
@@ -232,11 +226,11 @@ func (s *MicroServiceService) DeleteServicePri(ctx 
context.Context, ServiceId st
                dr := serviceUtil.NewProviderDependencyRelation(ctx, 
domainProject, service)
                services, err := dr.GetDependencyConsumerIds()
                if err != nil {
-                       util.Logger().Errorf(err, "delete microservice failed, 
serviceId is %s: inner err, get service dependency failed.", ServiceId)
+                       util.Logger().Errorf(err, "delete micro-service failed, 
serviceId is %s: inner err, get service dependency failed.", ServiceId)
                        return pb.CreateResponse(scerr.ErrInternal, "Get 
dependency info failed."), err
                }
                if len(services) > 1 || (len(services) == 1 && services[0] != 
ServiceId) {
-                       util.Logger().Errorf(nil, "delete microservice failed, 
serviceId is %s: can't delete, other services rely it.", ServiceId)
+                       util.Logger().Errorf(nil, "delete micro-service failed, 
serviceId is %s: can't delete, other services rely it.", ServiceId)
                        return pb.CreateResponse(scerr.ErrDependedOnConsumer, 
"Can not delete this service, other service rely it."), err
                }
 
@@ -246,12 +240,12 @@ func (s *MicroServiceService) DeleteServicePri(ctx 
context.Context, ServiceId st
                        registry.WithPrefix(),
                        registry.WithCountOnly())
                if err != nil {
-                       util.Logger().Errorf(err, "delete microservice failed, 
serviceId is %s: inner err,get instances failed.", ServiceId)
+                       util.Logger().Errorf(err, "delete micro-service failed, 
serviceId is %s: inner err,get instances failed.", ServiceId)
                        return pb.CreateResponse(scerr.ErrInternal, "Get 
instance failed."), err
                }
 
                if rsp.Count > 0 {
-                       util.Logger().Errorf(nil, "delete microservice failed, 
serviceId is %s: can't delete, exist instance.", ServiceId)
+                       util.Logger().Errorf(nil, "delete micro-service failed, 
serviceId is %s: can't delete, exist instance.", ServiceId)
                        return pb.CreateResponse(scerr.ErrDeployedInstance, 
"Can not delete this service, exist instance."), err
                }
        }
@@ -268,7 +262,7 @@ func (s *MicroServiceService) DeleteServicePri(ctx 
context.Context, ServiceId st
        //refresh msCache consumerCache, ensure that watch can notify consumers 
when no cache.
        err = serviceUtil.RefreshDependencyCache(ctx, domainProject, service)
        if err != nil {
-               util.Logger().Errorf(err, "%s microservice failed, serviceId is 
%s: inner err, refresh service dependency cache failed.", title, ServiceId)
+               util.Logger().Errorf(err, "%s micro-service failed, serviceId 
is %s: inner err, refresh service dependency cache failed.", title, ServiceId)
                return pb.CreateResponse(scerr.ErrInternal, "Refresh dependency 
cache failed."), err
        }
 
@@ -283,13 +277,13 @@ func (s *MicroServiceService) DeleteServicePri(ctx 
context.Context, ServiceId st
        //??????
        lock, err := mux.Lock(mux.DEP_QUEUE_LOCK)
        if err != nil {
-               util.Logger().Errorf(err, "%s microservice failed, serviceId is 
%s: inner err, create lock failed.", title, ServiceId)
+               util.Logger().Errorf(err, "%s micro-service failed, serviceId 
is %s: inner err, create lock failed.", title, ServiceId)
                return pb.CreateResponse(scerr.ErrUnavailableBackend, 
err.Error()), err
        }
        optsTmp, err := serviceUtil.DeleteDependencyForService(ctx, consumer, 
ServiceId)
        lock.Unlock()
        if err != nil {
-               util.Logger().Errorf(err, "%s microservice failed, serviceId is 
%s: inner err, delete dependency failed.", title, ServiceId)
+               util.Logger().Errorf(err, "%s micro-service failed, serviceId 
is %s: inner err, delete dependency failed.", title, ServiceId)
                return pb.CreateResponse(scerr.ErrInternal, err.Error()), err
        }
        opts = append(opts, optsTmp...)
@@ -301,7 +295,7 @@ func (s *MicroServiceService) DeleteServicePri(ctx 
context.Context, ServiceId st
        opts = append(opts, registry.OpDel(
                registry.WithStrKey(apt.GenerateRuleIndexKey(domainProject, 
ServiceId, "", ""))))
 
-       //??shemas
+       //??schemas
        opts = append(opts, registry.OpDel(
                registry.WithStrKey(apt.GenerateServiceSchemaKey(domainProject, 
ServiceId, "")),
                registry.WithPrefix()))
@@ -316,32 +310,32 @@ func (s *MicroServiceService) DeleteServicePri(ctx 
context.Context, ServiceId st
        //????
        err = serviceUtil.DeleteServiceAllInstances(ctx, ServiceId)
        if err != nil {
-               util.Logger().Errorf(err, "%s microservice failed, serviceId is 
%s: delete all instances failed.", title, ServiceId)
+               util.Logger().Errorf(err, "%s micro-service failed, serviceId 
is %s: delete all instances failed.", title, ServiceId)
                return pb.CreateResponse(scerr.ErrInternal, "Delete all 
instances failed for service."), err
        }
 
        err = backend.BatchCommit(ctx, opts)
        if err != nil {
-               util.Logger().Errorf(err, "%s microservice failed, serviceId is 
%s: commit data into etcd failed.", title, ServiceId)
+               util.Logger().Errorf(err, "%s micro-service failed, serviceId 
is %s: commit data into etcd failed.", title, ServiceId)
                return pb.CreateResponse(scerr.ErrUnavailableBackend, "Commit 
operations failed."), nil
        }
 
        serviceUtil.RemandServiceQuota(ctx)
 
-       util.Logger().Infof("%s microservice successful: serviceid is %s, 
operator is %s.", title, ServiceId, util.GetIPFromContext(ctx))
+       util.Logger().Infof("%s micro-service successful: serviceId is %s, 
operator is %s.", title, ServiceId, util.GetIPFromContext(ctx))
        return pb.CreateResponse(pb.Response_SUCCESS, "Unregister service 
successfully."), nil
 }
 
 func (s *MicroServiceService) Delete(ctx context.Context, in 
*pb.DeleteServiceRequest) (*pb.DeleteServiceResponse, error) {
        if in == nil || len(in.ServiceId) == 0 {
-               util.Logger().Errorf(nil, "delete microservice failed: service 
empty.")
+               util.Logger().Errorf(nil, "delete micro-service failed: service 
empty.")
                return &pb.DeleteServiceResponse{
                        Response: pb.CreateResponse(scerr.ErrInvalidParams, 
"Request format invalid."),
                }, nil
        }
        err := apt.Validate(in)
        if err != nil {
-               util.Logger().Errorf(err, "delete microservice failed, 
serviceId is %s: invalid parameters.", in.ServiceId)
+               util.Logger().Errorf(err, "delete micro-service failed, 
serviceId is %s: invalid parameters.", in.ServiceId)
                return &pb.DeleteServiceResponse{
                        Response: pb.CreateResponse(scerr.ErrInvalidParams, 
err.Error()),
                }, nil
@@ -370,7 +364,7 @@ func (s *MicroServiceService) DeleteServices(ctx 
context.Context, request *pb.De
        for _, serviceId := range request.ServiceIds {
                //ServiceId?????
                if _, ok := existFlag[serviceId]; ok {
-                       util.Logger().Warnf(nil, "delete microservice %s , 
multiple.", serviceId)
+                       util.Logger().Warnf(nil, "delete micro-service %s , 
multiple.", serviceId)
                        continue
                } else {
                        existFlag[serviceId] = true
@@ -389,7 +383,7 @@ func (s *MicroServiceService) DeleteServices(ctx 
context.Context, request *pb.De
                }
                err := apt.Validate(in)
                if err != nil {
-                       util.Logger().Errorf(err, "delete microservice failed, 
serviceId is %s: invalid parameters.", in.ServiceId)
+                       util.Logger().Errorf(err, "delete micro-service failed, 
serviceId is %s: invalid parameters.", in.ServiceId)
                        serviceRst.ErrMessage = err.Error()
                        serviceRespChan <- serviceRst
                        continue
@@ -411,7 +405,7 @@ func (s *MicroServiceService) DeleteServices(ctx 
context.Context, request *pb.De
        //???????????
        count := 0
        responseCode := pb.Response_SUCCESS
-       delServiceRspInfo := []*pb.DelServicesRspInfo{}
+       delServiceRspInfo := make([]*pb.DelServicesRspInfo, 0, 
len(serviceRespChan))
        for serviceRespItem := range serviceRespChan {
                count++
                if len(serviceRespItem.ErrMessage) != 0 {
@@ -439,7 +433,7 @@ func (s *MicroServiceService) GetOne(ctx context.Context, 
in *pb.GetServiceReque
        }
        err := apt.Validate(in)
        if err != nil {
-               util.Logger().Errorf(err, "get microservice failed, serviceId 
is %s: invalid parameters.",
+               util.Logger().Errorf(err, "get micro-service failed, serviceId 
is %s: invalid parameters.",
                        in.ServiceId)
                return &pb.GetServiceResponse{
                        Response: pb.CreateResponse(scerr.ErrInvalidParams, 
err.Error()),
@@ -449,19 +443,19 @@ func (s *MicroServiceService) GetOne(ctx context.Context, 
in *pb.GetServiceReque
        service, err := serviceUtil.GetService(ctx, domainProject, in.ServiceId)
 
        if err != nil {
-               util.Logger().Errorf(err, "get microservice failed, serviceId 
is %s: inner err,get service failed.", in.ServiceId)
+               util.Logger().Errorf(err, "get micro-service failed, serviceId 
is %s: inner err,get service failed.", in.ServiceId)
                return &pb.GetServiceResponse{
                        Response: pb.CreateResponse(scerr.ErrInternal, "Get 
service file failed."),
                }, err
        }
        if service == nil {
-               util.Logger().Errorf(nil, "get microservice failed, serviceId 
is %s: service not exist.", in.ServiceId)
+               util.Logger().Errorf(nil, "get micro-service failed, serviceId 
is %s: service not exist.", in.ServiceId)
                return &pb.GetServiceResponse{
-                       Response: pb.CreateResponse(scerr.ErrServiceNotExists, 
"Service does not exist."),
+                       Response: pb.CreateResponse(scerr.ErrServiceNotExists, 
"service does not exist."),
                }, nil
        }
        return &pb.GetServiceResponse{
-               Response: pb.CreateResponse(pb.Response_SUCCESS, "Get service 
successfully."),
+               Response: pb.CreateResponse(pb.Response_SUCCESS, "get service 
successfully."),
                Service:  service,
        }, nil
 }
@@ -470,7 +464,7 @@ func (s *MicroServiceService) GetServices(ctx 
context.Context, in *pb.GetService
        if in == nil {
                util.Logger().Errorf(nil, "get services failed: invalid 
params.")
                return &pb.GetServicesResponse{
-                       Response: pb.CreateResponse(scerr.ErrInvalidParams, 
"Request format invalid."),
+                       Response: pb.CreateResponse(scerr.ErrInvalidParams, 
"request format invalid."),
                }, nil
        }
        services, err := serviceUtil.GetAllServiceUtil(ctx)
@@ -482,7 +476,7 @@ func (s *MicroServiceService) GetServices(ctx 
context.Context, in *pb.GetService
        }
 
        return &pb.GetServicesResponse{
-               Response: pb.CreateResponse(pb.Response_SUCCESS, "Get services 
successfully."),
+               Response: pb.CreateResponse(pb.Response_SUCCESS, "get services 
successfully."),
                Services: services,
        }, nil
 }
@@ -491,7 +485,7 @@ func (s *MicroServiceService) UpdateProperties(ctx 
context.Context, in *pb.Updat
        if in == nil || len(in.ServiceId) == 0 || in.Properties == nil {
                util.Logger().Errorf(nil, "update service properties failed: 
invalid params.")
                return &pb.UpdateServicePropsResponse{
-                       Response: pb.CreateResponse(scerr.ErrInvalidParams, 
"Request format invalid."),
+                       Response: pb.CreateResponse(scerr.ErrInvalidParams, 
"request format invalid."),
                }, nil
        }
        err := apt.Validate(in)
@@ -515,7 +509,7 @@ func (s *MicroServiceService) UpdateProperties(ctx 
context.Context, in *pb.Updat
        if service == nil {
                util.Logger().Errorf(nil, "update service properties failed, 
serviceId is %s: service not exist.", in.ServiceId)
                return &pb.UpdateServicePropsResponse{
-                       Response: pb.CreateResponse(scerr.ErrServiceNotExists, 
"Service does not exist."),
+                       Response: pb.CreateResponse(scerr.ErrServiceNotExists, 
"service does not exist."),
                }, nil
        }
        service.Properties = make(map[string]string)
@@ -528,7 +522,7 @@ func (s *MicroServiceService) UpdateProperties(ctx 
context.Context, in *pb.Updat
        if err != nil {
                util.Logger().Errorf(err, "update service properties failed, 
serviceId is %s: json marshal service failed.", in.ServiceId)
                return &pb.UpdateServicePropsResponse{
-                       Response: pb.CreateResponse(scerr.ErrInternal, "Service 
file marshal error."),
+                       Response: pb.CreateResponse(scerr.ErrInternal, "service 
file marshal error."),
                }, err
        }
 
@@ -546,15 +540,15 @@ func (s *MicroServiceService) UpdateProperties(ctx 
context.Context, in *pb.Updat
 
        util.Logger().Infof("update service properties successful: serviceId is 
%s.", in.ServiceId)
        return &pb.UpdateServicePropsResponse{
-               Response: pb.CreateResponse(pb.Response_SUCCESS, "Update 
service successfully."),
+               Response: pb.CreateResponse(pb.Response_SUCCESS, "update 
service successfully."),
        }, nil
 }
 
 func (s *MicroServiceService) Exist(ctx context.Context, in 
*pb.GetExistenceRequest) (*pb.GetExistenceResponse, error) {
        if in == nil {
-               util.Logger().Errorf(nil, "exist failed: invalid params.")
+               util.Logger().Errorf(nil, "exist failed: invalid params")
                return &pb.GetExistenceResponse{
-                       Response: pb.CreateResponse(scerr.ErrInvalidParams, 
"Request format invalid."),
+                       Response: pb.CreateResponse(scerr.ErrInvalidParams, 
"request format invalid"),
                }, nil
        }
 
@@ -562,15 +556,15 @@ func (s *MicroServiceService) Exist(ctx context.Context, 
in *pb.GetExistenceRequ
        switch in.Type {
        case EXIST_TYPE_MICROSERVICE:
                if len(in.AppId) == 0 || len(in.ServiceName) == 0 || 
len(in.Version) == 0 {
-                       util.Logger().Errorf(nil, "microservice exist failed: 
invalid params.")
+                       util.Logger().Errorf(nil, "micro-service exist failed: 
invalid params.")
                        return &pb.GetExistenceResponse{
-                               Response: 
pb.CreateResponse(scerr.ErrInvalidParams, "Invalid request."),
+                               Response: 
pb.CreateResponse(scerr.ErrInvalidParams, "invalid request."),
                        }, nil
                }
                err := apt.GetMSExistsReqValidator.Validate(in)
                serviceFlag := util.StringJoin([]string{in.AppId, 
in.ServiceName, in.Version}, "/")
                if err != nil {
-                       util.Logger().Errorf(err, "microservice exist failed, 
service %s: invalid params.", serviceFlag)
+                       util.Logger().Errorf(err, "micro-service exist failed, 
service %s: invalid params.", serviceFlag)
                        return &pb.GetExistenceResponse{
                                Response: 
pb.CreateResponse(scerr.ErrInvalidParams, err.Error()),
                        }, nil
@@ -585,26 +579,26 @@ func (s *MicroServiceService) Exist(ctx context.Context, 
in *pb.GetExistenceRequ
                        Tenant:      domainProject,
                })
                if err != nil {
-                       util.Logger().Errorf(err, "microservice exist failed, 
service %s: find serviceIds failed.", serviceFlag)
+                       util.Logger().Errorf(err, "micro-service exist failed, 
service %s: find serviceIds failed.", serviceFlag)
                        return &pb.GetExistenceResponse{
-                               Response: pb.CreateResponse(scerr.ErrInternal, 
"Get service file failed."),
+                               Response: pb.CreateResponse(scerr.ErrInternal, 
"get service file failed."),
                        }, err
                }
                if len(ids) <= 0 {
-                       util.Logger().Infof("microservice exist failed, service 
%s: service not exist.", serviceFlag)
+                       util.Logger().Infof("micro-service exist failed, 
service %s: service not exist.", serviceFlag)
                        return &pb.GetExistenceResponse{
-                               Response: 
pb.CreateResponse(scerr.ErrServiceNotExists, "Service does not exist."),
+                               Response: 
pb.CreateResponse(scerr.ErrServiceNotExists, "service does not exist."),
                        }, nil
                }
                return &pb.GetExistenceResponse{
-                       Response:  pb.CreateResponse(pb.Response_SUCCESS, "Get 
service id successfully."),
+                       Response:  pb.CreateResponse(pb.Response_SUCCESS, "get 
service id successfully."),
                        ServiceId: ids[0], // ???????????
                }, nil
        case EXIST_TYPE_SCHEMA:
                if len(in.SchemaId) == 0 || len(in.ServiceId) == 0 {
                        util.Logger().Errorf(nil, "schema exist failed, 
serviceId %s, schemaId %s: invalid params.", in.ServiceId, in.SchemaId)
                        return &pb.GetExistenceResponse{
-                               Response: 
pb.CreateResponse(scerr.ErrInvalidParams, "Invalid request."),
+                               Response: 
pb.CreateResponse(scerr.ErrInvalidParams, "invalid request."),
                        }, nil
                }
 
@@ -619,7 +613,7 @@ func (s *MicroServiceService) Exist(ctx context.Context, in 
*pb.GetExistenceRequ
                if !serviceUtil.ServiceExist(ctx, domainProject, in.ServiceId) {
                        util.Logger().Warnf(nil, "schema exist failed, 
serviceId %s, schemaId %s: service not exist.", in.ServiceId, in.SchemaId)
                        return &pb.GetExistenceResponse{
-                               Response: 
pb.CreateResponse(scerr.ErrServiceNotExists, "Service does not exist."),
+                               Response: 
pb.CreateResponse(scerr.ErrServiceNotExists, "service does not exist."),
                        }, nil
                }
 
@@ -634,7 +628,7 @@ func (s *MicroServiceService) Exist(ctx context.Context, in 
*pb.GetExistenceRequ
                if !exist {
                        util.Logger().Infof("schema exist failed, serviceId %s, 
schemaId %s: schema not exist.", in.ServiceId, in.SchemaId)
                        return &pb.GetExistenceResponse{
-                               Response: 
pb.CreateResponse(scerr.ErrSchemaNotExists, "Schema does not exist."),
+                               Response: 
pb.CreateResponse(scerr.ErrSchemaNotExists, "schema does not exist."),
                        }, nil
                }
                schemaSummary, err := getSchemaSummary(ctx, domainProject, 
in.ServiceId, in.SchemaId)
@@ -652,7 +646,7 @@ func (s *MicroServiceService) Exist(ctx context.Context, in 
*pb.GetExistenceRequ
        default:
                util.Logger().Warnf(nil, "unexpected type '%s' for query.", 
in.Type)
                return &pb.GetExistenceResponse{
-                       Response: pb.CreateResponse(scerr.ErrInvalidParams, 
"Only microservice and schema can be used as type."),
+                       Response: pb.CreateResponse(scerr.ErrInvalidParams, 
"Only micro-service and schema can be used as type."),
                }, nil
        }
 }
@@ -747,12 +741,12 @@ func (s *MicroServiceService) CreateServiceEx(ctx 
context.Context, in *pb.Create
                        util.Logger().Error("marshal errMessages error", err)
                        return result, nil
                }
-               result.Response.Message = fmt.Sprintf("ErrMessage : %s", 
string(errMessage))
+               result.Response.Message = fmt.Sprintf("errMessage : %s", 
string(errMessage))
        } else {
                result.Response.Code = pb.Response_SUCCESS
        }
 
-       util.Logger().Infof("CreateServiceEx, serviceid = %s, result = %s ", 
result.ServiceId, result.Response.Message)
+       util.Logger().Infof("createServiceEx, serviceId = %s, result = %s ", 
result.ServiceId, result.Response.Message)
        return result, nil
 }
 
diff --git a/server/service/rule.go b/server/service/rule.go
index dfab65f3..287dbc2b 100644
--- a/server/service/rule.go
+++ b/server/service/rule.go
@@ -50,21 +50,21 @@ func (s *MicroServiceService) AddRule(ctx context.Context, 
in *pb.AddServiceRule
                        Response: pb.CreateResponse(scerr.ErrInvalidParams, 
"Service does not exist."),
                }, nil
        }
-       _, ok, err := plugin.Plugins().Quota().Apply4Quotas(ctx, 
quota.RuleQuotaType, domainProject, in.ServiceId, int16(len(in.Rules)))
-       if err != nil {
-               util.Logger().Errorf(err, "check can apply resource failed.%s", 
in.ServiceId)
-               return &pb.AddServiceRulesResponse{
-                       Response: pb.CreateResponse(scerr.ErrUnavailableQuota, 
err.Error()),
-               }, err
-       }
-       if !ok {
-               util.Logger().Errorf(err, "no size to add tag, max size is 100 
for one servivce.%s", in.ServiceId)
-               return &pb.AddServiceRulesResponse{
-                       Response: pb.CreateResponse(scerr.ErrNotEnoughQuota, 
"no size to add tag, max size is 100 for one servivce"),
-               }, nil
+       res := quota.NewApplyQuotaResource(quota.RuleQuotaType, domainProject, 
in.ServiceId, int64(len(in.Rules)))
+       rst := plugin.Plugins().Quota().Apply4Quotas(ctx, res)
+       errQuota := rst.Err
+       if errQuota != nil {
+               util.Logger().Errorf(errQuota, "")
+               response := &pb.AddServiceRulesResponse{
+                       Response: pb.CreateResponseWithSCErr(errQuota),
+               }
+               if errQuota.InternalError() {
+                       return response, errQuota
+               }
+               return response, nil
        }
 
-       opts := []registry.PluginOp{}
+
        ruleType, _, err := serviceUtil.GetServiceRuleType(ctx, domainProject, 
in.ServiceId)
        util.Logger().Debugf("ruleType is %s", ruleType)
        if err != nil {
@@ -72,7 +72,8 @@ func (s *MicroServiceService) AddRule(ctx context.Context, in 
*pb.AddServiceRule
                        Response: pb.CreateResponse(scerr.ErrInternal, 
err.Error()),
                }, err
        }
-       ruleIds := []string{}
+       ruleIds := make([]string, 0, len(in.Rules))
+       opts := make([]registry.PluginOp, 0, 2*len(in.Rules))
        for _, rule := range in.Rules {
                err := apt.Validate(rule)
                if err != nil {
diff --git a/server/service/schema.go b/server/service/schema.go
index fa279c6f..107575f4 100644
--- a/server/service/schema.go
+++ b/server/service/schema.go
@@ -29,7 +29,6 @@ import (
        "github.com/apache/incubator-servicecomb-service-center/server/plugin"
        serviceUtil 
"github.com/apache/incubator-servicecomb-service-center/server/service/util"
        "golang.org/x/net/context"
-       "net/http"
        "strings"
 )
 
@@ -264,9 +263,9 @@ func (s *MicroServiceService) ModifySchemas(ctx 
context.Context, request *pb.Mod
        respErr := modifySchemas(ctx, domainProject, service, request.Schemas)
        if respErr != nil {
                resp := &pb.ModifySchemasResponse{
-                       Response: pb.CreateResponse(respErr.Code, 
respErr.Detail),
+                       Response: pb.CreateResponseWithSCErr(respErr),
                }
-               if respErr.StatusCode() == http.StatusInternalServerError {
+               if respErr.InternalError() {
                        return resp, respErr
                }
                return resp, nil
@@ -323,14 +322,12 @@ func modifySchemas(ctx context.Context, domainProject 
string, service *pb.MicroS
        pluginOps := make([]registry.PluginOp, 0)
        if service.Environment == pb.ENV_PROD {
                if len(service.Schemas) == 0 {
-                       _, ok, err := 
plugin.Plugins().Quota().Apply4Quotas(ctx, quota.SchemaQuotaType, 
domainProject, serviceId, int16(len(schemas)))
-                       if err != nil {
-                               util.Logger().Errorf(err, "modify schemas info 
failed, check resource num failed, %s", serviceId)
-                               return 
scerr.NewError(scerr.ErrUnavailableQuota, err.Error())
-                       }
-                       if !ok {
-                               util.Logger().Errorf(err, "modify schemas info 
failed, reach the max size of schema, %s", serviceId)
-                               return scerr.NewError(scerr.ErrNotEnoughQuota, 
"reach the max size of schema")
+                       res := 
quota.NewApplyQuotaResource(quota.SchemaQuotaType, domainProject, serviceId, 
int64(len(schemas)))
+                       rst := plugin.Plugins().Quota().Apply4Quotas(ctx, res)
+                       errQuota := rst.Err
+                       if errQuota != nil {
+                               util.Logger().Errorf(errQuota, "modify schemas 
info failed, serviceId is %s", serviceId)
+                               return errQuota
                        }
 
                        service.Schemas = nonExistSchemaIds
@@ -376,14 +373,12 @@ func modifySchemas(ctx context.Context, domainProject 
string, service *pb.MicroS
 
                quotaSize := len(needAddSchemas) - len(needDeleteSchemas)
                if quotaSize > 0 {
-                       _, ok, err := 
plugin.Plugins().Quota().Apply4Quotas(ctx, quota.SchemaQuotaType, 
domainProject, serviceId, int16(quotaSize))
+                       res := 
quota.NewApplyQuotaResource(quota.SchemaQuotaType, domainProject, serviceId, 
int64(quotaSize))
+                       rst := plugin.Plugins().Quota().Apply4Quotas(ctx, res)
+                       err := rst.Err
                        if err != nil {
                                util.Logger().Errorf(err, "modify schemas info 
failed, check resource num failed, %s", serviceId)
-                               return 
scerr.NewError(scerr.ErrUnavailableQuota, err.Error())
-                       }
-                       if !ok {
-                               util.Logger().Errorf(err, "modify schemas info 
failed, reach the max size of schema, %s", serviceId)
-                               return scerr.NewError(scerr.ErrNotEnoughQuota, 
"reach the max size of schema")
+                               return err
                        }
                }
 
@@ -487,9 +482,9 @@ func (s *MicroServiceService) ModifySchema(ctx 
context.Context, request *pb.Modi
        respErr := s.canModifySchema(ctx, domainProject, request)
        if respErr != nil {
                resp := &pb.ModifySchemaResponse{
-                       Response: pb.CreateResponse(respErr.Code, 
respErr.Detail),
+                       Response: pb.CreateResponseWithSCErr(respErr),
                }
-               if respErr.StatusCode() == http.StatusInternalServerError {
+               if respErr.InternalError() {
                        return resp, respErr
                }
                return resp, nil
@@ -507,9 +502,9 @@ func (s *MicroServiceService) ModifySchema(ctx 
context.Context, request *pb.Modi
        if err != nil {
                util.Logger().Errorf(err, "modify schema failed, serviceId %s, 
schemaId %s", serviceId, schemaId)
                resp := &pb.ModifySchemaResponse{
-                       Response: pb.CreateResponse(err.Code, err.Detail),
+                       Response: pb.CreateResponseWithSCErr(err),
                }
-               if err.StatusCode() == http.StatusInternalServerError {
+               if err.InternalError() {
                        return resp, err
                }
                return resp, nil
@@ -534,14 +529,12 @@ func (s *MicroServiceService) canModifySchema(ctx 
context.Context, domainProject
                return scerr.NewError(scerr.ErrInvalidParams, err.Error())
        }
 
-       _, ok, err := plugin.Plugins().Quota().Apply4Quotas(ctx, 
quota.SchemaQuotaType, domainProject, serviceId, 1)
-       if err != nil {
-               util.Logger().Errorf(err, "modify schema info failed, check 
resource num failed, %s, %s", serviceId, schemaId)
-               return scerr.NewError(scerr.ErrUnavailableQuota, err.Error())
-       }
-       if !ok {
-               util.Logger().Errorf(err, "modify schema info failed, reach the 
max size of schema, %s, %s", serviceId, schemaId)
-               return scerr.NewError(scerr.ErrNotEnoughQuota, "add schema 
failed, reach max size of schema")
+       res := quota.NewApplyQuotaResource(quota.SchemaQuotaType, 
domainProject, serviceId, 1)
+       rst := plugin.Plugins().Quota().Apply4Quotas(ctx, res)
+       errQuota := rst.Err
+       if errQuota != nil {
+               util.Logger().Errorf(errQuota, "modify schema info failed, 
check resource num failed, %s, %s", serviceId, schemaId)
+               return errQuota
        }
        if len(request.Summary) == 0 {
                util.Logger().Warnf(nil, "service %s schema %s summary is 
empty.", request.ServiceId, schemaId)
diff --git a/server/service/tag.go b/server/service/tag.go
index 66854523..08f35279 100644
--- a/server/service/tag.go
+++ b/server/service/tag.go
@@ -56,18 +56,18 @@ func (s *MicroServiceService) AddTags(ctx context.Context, 
in *pb.AddServiceTags
        }
 
        addTags := in.GetTags()
-       _, ok, err := plugin.Plugins().Quota().Apply4Quotas(ctx, 
quota.TagQuotaType, domainProject, in.ServiceId, int16(len(addTags)))
-       if err != nil {
-               util.Logger().Errorf(err, "add tag info failed, check resource 
num failed, %s", in.ServiceId)
-               return &pb.AddServiceTagsResponse{
-                       Response: pb.CreateResponse(scerr.ErrUnavailableQuota, 
"Modify schema info failed, check resource num failed."),
-               }, err
-       }
-       if !ok {
-               util.Logger().Errorf(err, "add tag info failed, reach the max 
size of tag, %s", in.ServiceId)
-               return &pb.AddServiceTagsResponse{
-                       Response: pb.CreateResponse(scerr.ErrNotEnoughQuota, 
"reach the max size of tag."),
-               }, nil
+       res := quota.NewApplyQuotaResource(quota.TagQuotaType, domainProject, 
in.ServiceId, int64(len(addTags)))
+       rst := plugin.Plugins().Quota().Apply4Quotas(ctx, res)
+       errQuota := rst.Err
+       if errQuota != nil {
+               util.Logger().Errorf(errQuota, "add tag info failed, check 
resource num failed, %s", in.ServiceId)
+               response := &pb.AddServiceTagsResponse{
+                       Response: pb.CreateResponseWithSCErr(errQuota),
+               }
+               if errQuota.InternalError() {
+                       return response, errQuota
+               }
+               return response, nil
        }
 
        dataTags, err := serviceUtil.GetTagsUtils(ctx, domainProject, 
in.ServiceId)


 

----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on GitHub and use the
URL above to go to the specific comment.
 
For queries about this service, please contact Infrastructure at:
[email protected]


With regards,
Apache Git Services

Reply via email to