You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@servicecomb.apache.org by GitBox <gi...@apache.org> on 2018/01/15 08:42:02 UTC
[GitHub] little-cui closed pull request #248: SCB-235 Optimize quota check log
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:
users@infra.apache.org
With regards,
Apache Git Services