This is an automated email from the ASF dual-hosted git repository.

tianxiaoliang pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/servicecomb-kie.git


The following commit(s) were added to refs/heads/master by this push:
     new a0e298a  fix go const (#111)
a0e298a is described below

commit a0e298aaf936a02c318ae82d86183a7dff0e0a73
Author: zhulijian <[email protected]>
AuthorDate: Mon Mar 2 14:06:19 2020 +0800

    fix go const (#111)
---
 client/client.go                         | 26 +++++++++++--------
 cmd/kieserver/main.go                    |  9 ++++---
 server/handler/noop_auth_handler.go      | 13 +++++++---
 server/resource/v1/common.go             | 26 ++++++++++++-------
 server/resource/v1/kv_resource.go        | 43 ++++++++++++++++----------------
 server/service/mongo/counter/revision.go |  6 +++--
 server/service/mongo/kv/kv_dao.go        | 13 +++++-----
 server/service/mongo/kv/kv_service.go    | 10 +++++++-
 server/service/mongo/kv/tool.go          |  4 +--
 server/service/mongo/label/label_dao.go  |  7 ++++--
 10 files changed, 96 insertions(+), 61 deletions(-)

diff --git a/client/client.go b/client/client.go
index 8d0c66e..b70d465 100644
--- a/client/client.go
+++ b/client/client.go
@@ -39,6 +39,10 @@ import (
 const (
        version   = "v1"
        APIPathKV = "kie/kv"
+
+       HeaderContentType = "Content-Type"
+       MsgGetFailed      = "get failed"
+       FmtGetFailed      = "get %s failed,http status [%s], body [%s]"
 )
 
 //client errors
@@ -97,20 +101,20 @@ func (c *Client) Put(ctx context.Context, kv 
model.KVRequest, opts ...OpOption)
        }
        url := fmt.Sprintf("%s/%s/%s/%s/%s", c.opts.Endpoint, version, 
options.Project, APIPathKV, kv.Key)
        h := http.Header{}
-       h.Set("Content-Type", "application/json")
+       h.Set(HeaderContentType, common.ContentTypeJSON)
        body, _ := json.Marshal(kv)
-       resp, err := c.c.Do(ctx, "PUT", url, h, body)
+       resp, err := c.c.Do(ctx, http.MethodPut, url, h, body)
        if err != nil {
                return nil, err
        }
        b := httputil.ReadBody(resp)
        if resp.StatusCode != http.StatusOK {
-               openlogging.Error("get failed", 
openlogging.WithTags(openlogging.Tags{
+               openlogging.Error(MsgGetFailed, 
openlogging.WithTags(openlogging.Tags{
                        "k":      kv.Key,
                        "status": resp.Status,
                        "body":   b,
                }))
-               return nil, fmt.Errorf("get %s failed,http status [%s], body 
[%s]", kv.Key, resp.Status, b)
+               return nil, fmt.Errorf(FmtGetFailed, kv.Key, resp.Status, b)
        }
 
        kvs := &model.KVDoc{}
@@ -152,7 +156,7 @@ func (c *Client) Get(ctx context.Context, opts 
...GetOption) (*model.KVResponse,
                url = url + labels
        }
        h := http.Header{}
-       resp, err := c.c.Do(ctx, "GET", url, h, nil)
+       resp, err := c.c.Do(ctx, http.MethodGet, url, h, nil)
        if err != nil {
                return nil, err
        }
@@ -164,12 +168,12 @@ func (c *Client) Get(ctx context.Context, opts 
...GetOption) (*model.KVResponse,
                if resp.StatusCode == http.StatusNotModified {
                        return nil, ErrNoChanges
                }
-               openlogging.Error("get failed", 
openlogging.WithTags(openlogging.Tags{
+               openlogging.Error(MsgGetFailed, 
openlogging.WithTags(openlogging.Tags{
                        "k":      options.Key,
                        "status": resp.Status,
                        "body":   b,
                }))
-               return nil, fmt.Errorf("get %s failed,http status [%s], body 
[%s]", options.Key, resp.Status, b)
+               return nil, fmt.Errorf(FmtGetFailed, options.Key, resp.Status, 
b)
        }
        var kvs *model.KVResponse
        err = json.Unmarshal(b, &kvs)
@@ -206,7 +210,7 @@ func (c *Client) Summary(ctx context.Context, opts 
...GetOption) ([]*model.KVRes
        }
        url := fmt.Sprintf("%s/%s/%s/%s?%s", c.opts.Endpoint, version, 
options.Project, "kie/summary", labelParams)
        h := http.Header{}
-       resp, err := c.c.Do(ctx, "GET", url, h, nil)
+       resp, err := c.c.Do(ctx, http.MethodGet, url, h, nil)
        if err != nil {
                return nil, err
        }
@@ -215,7 +219,7 @@ func (c *Client) Summary(ctx context.Context, opts 
...GetOption) ([]*model.KVRes
                if resp.StatusCode == http.StatusNotFound {
                        return nil, ErrKeyNotExist
                }
-               openlogging.Error("get failed", 
openlogging.WithTags(openlogging.Tags{
+               openlogging.Error(MsgGetFailed, 
openlogging.WithTags(openlogging.Tags{
                        "p":      options.Project,
                        "status": resp.Status,
                        "body":   b,
@@ -246,8 +250,8 @@ func (c *Client) Delete(ctx context.Context, kvID, labelID 
string, opts ...OpOpt
                url = fmt.Sprintf("%s?labelID=%s", url, labelID)
        }
        h := http.Header{}
-       h.Set("Content-Type", "application/json")
-       resp, err := c.c.Do(ctx, "DELETE", url, h, nil)
+       h.Set(HeaderContentType, common.ContentTypeJSON)
+       resp, err := c.c.Do(ctx, http.MethodDelete, url, h, nil)
        if err != nil {
                return err
        }
diff --git a/cmd/kieserver/main.go b/cmd/kieserver/main.go
index 4bba02f..28862b3 100644
--- a/cmd/kieserver/main.go
+++ b/cmd/kieserver/main.go
@@ -18,15 +18,16 @@
 package main
 
 import (
-       "github.com/apache/servicecomb-kie/server/pubsub"
-       "github.com/apache/servicecomb-kie/server/service"
        "os"
 
        "github.com/apache/servicecomb-kie/server/config"
        _ "github.com/apache/servicecomb-kie/server/handler"
+       "github.com/apache/servicecomb-kie/server/pubsub"
        v1 "github.com/apache/servicecomb-kie/server/resource/v1"
+       "github.com/apache/servicecomb-kie/server/service"
        _ "github.com/apache/servicecomb-kie/server/service/mongo"
        "github.com/go-chassis/go-chassis"
+       "github.com/go-chassis/go-chassis/core/common"
        "github.com/go-mesh/openlogging"
        "github.com/urfave/cli"
 )
@@ -77,8 +78,8 @@ func main() {
        if err := parseConfigFromCmd(os.Args); err != nil {
                openlogging.Fatal(err.Error())
        }
-       chassis.RegisterSchema("rest", &v1.KVResource{})
-       chassis.RegisterSchema("rest", &v1.HistoryResource{})
+       chassis.RegisterSchema(common.ProtocolRest, &v1.KVResource{})
+       chassis.RegisterSchema(common.ProtocolRest, &v1.HistoryResource{})
        if err := chassis.Init(); err != nil {
                openlogging.Fatal(err.Error())
        }
diff --git a/server/handler/noop_auth_handler.go 
b/server/handler/noop_auth_handler.go
index 7ad3fda..e35abab 100644
--- a/server/handler/noop_auth_handler.go
+++ b/server/handler/noop_auth_handler.go
@@ -18,18 +18,25 @@
 package handler
 
 import (
+       "github.com/apache/servicecomb-kie/server/resource/v1"
        "github.com/go-chassis/go-chassis/core/handler"
        "github.com/go-chassis/go-chassis/core/invocation"
        "github.com/go-mesh/openlogging"
 )
 
+//const of noop auth handler
+const (
+       NoopAuthHandlerName = "auth-handler"
+       DefaultDomain       = "default"
+)
+
 //NoopAuthHandler not need implement any logic
 //developer can extend authenticate and authorization by set new handler in 
chassis.yaml
 type NoopAuthHandler struct{}
 
 //Handle set local attribute to http request
 func (bk *NoopAuthHandler) Handle(chain *handler.Chain, inv 
*invocation.Invocation, cb invocation.ResponseCallBack) {
-       inv.SetMetadata("domain", "default")
+       inv.SetMetadata(v1.AttributeDomainKey, DefaultDomain)
        chain.Next(inv, cb)
 }
 
@@ -39,10 +46,10 @@ func newDomainResolver() handler.Handler {
 
 //Name is handler name
 func (bk *NoopAuthHandler) Name() string {
-       return "auth-handler"
+       return NoopAuthHandlerName
 }
 func init() {
-       if err := handler.RegisterHandler("auth-handler", newDomainResolver); 
err != nil {
+       if err := handler.RegisterHandler(NoopAuthHandlerName, 
newDomainResolver); err != nil {
                openlogging.Fatal("register auth-handler failed: " + 
err.Error())
        }
 }
diff --git a/server/resource/v1/common.go b/server/resource/v1/common.go
index ee14240..9787cc7 100644
--- a/server/resource/v1/common.go
+++ b/server/resource/v1/common.go
@@ -21,22 +21,33 @@ import (
        "context"
        "encoding/json"
        "errors"
-       "github.com/apache/servicecomb-kie/server/pubsub"
-       "github.com/apache/servicecomb-kie/server/service"
-       uuid "github.com/satori/go.uuid"
        "net/http"
        "strconv"
        "strings"
        "time"
 
        "github.com/apache/servicecomb-kie/pkg/common"
+       "github.com/apache/servicecomb-kie/server/pubsub"
+       "github.com/apache/servicecomb-kie/server/service"
        goRestful "github.com/emicklei/go-restful"
        "github.com/go-chassis/go-chassis/server/restful"
        "github.com/go-mesh/openlogging"
+       uuid "github.com/satori/go.uuid"
        "gopkg.in/yaml.v2"
 )
 
 //const of server
+const (
+       HeaderUserAgent        = "User-Agent"
+       HeaderSessionID        = "sessionID"
+       QueryParameterStatus   = "status"
+       QueryParameterPageNum  = "pageNum"
+       QueryParameterPageSize = "pageSize"
+       PathParameterProject   = "project"
+       PathParameterKey       = "key"
+       AttributeDomainKey     = "domain"
+       MsgLabelsNotFound      = "can not find by labels"
+)
 
 //err
 var (
@@ -45,7 +56,7 @@ var (
 
 //ReadDomain get domain info from attribute
 func ReadDomain(context *restful.Context) interface{} {
-       return context.ReadRestfulRequest().Attribute("domain")
+       return context.ReadRestfulRequest().Attribute(AttributeDomainKey)
 }
 
 //ReadFindDepth get find depth
@@ -165,7 +176,7 @@ func eventHappened(rctx *restful.Context, waitStr string, 
topic *pubsub.Topic) (
        o := &pubsub.Observer{
                UUID:      uuid.NewV4().String(),
                RemoteIP:  rctx.ReadRequest().RemoteAddr, //TODO x forward ip
-               UserAgent: rctx.ReadHeader("User-Agent"),
+               UserAgent: rctx.ReadHeader(HeaderUserAgent),
                Event:     make(chan *pubsub.KVChangeEvent, 1),
        }
        err = pubsub.ObserveOnce(o, topic)
@@ -196,10 +207,7 @@ func checkPagination(pageNum, pageSize string) (int64, 
int64, error) {
 
        if pageSize != "" {
                size, err = strconv.ParseInt(pageSize, 10, 64)
-               if err != nil {
-                       return 0, 0, errors.New("invalid pageSize number")
-               }
-               if size < 1 || size > 100 {
+               if err != nil || (size < 1 || size > 100) {
                        return 0, 0, errors.New("invalid pageSize number")
                }
        }
diff --git a/server/resource/v1/kv_resource.go 
b/server/resource/v1/kv_resource.go
index 765ca7e..463dfb7 100644
--- a/server/resource/v1/kv_resource.go
+++ b/server/resource/v1/kv_resource.go
@@ -20,6 +20,8 @@ package v1
 
 import (
        "fmt"
+       "net/http"
+
        "github.com/apache/servicecomb-kie/pkg/common"
        "github.com/apache/servicecomb-kie/pkg/iputil"
        "github.com/apache/servicecomb-kie/pkg/model"
@@ -30,7 +32,6 @@ import (
        "github.com/go-chassis/go-chassis/server/restful"
        "github.com/go-mesh/openlogging"
        uuid "github.com/satori/go.uuid"
-       "net/http"
 )
 
 //KVResource has API about kv operations
@@ -40,8 +41,8 @@ type KVResource struct {
 //Put create or update kv
 func (r *KVResource) Put(context *restful.Context) {
        var err error
-       key := context.ReadPathParameter("key")
-       project := context.ReadPathParameter("project")
+       key := context.ReadPathParameter(PathParameterKey)
+       project := context.ReadPathParameter(PathParameterProject)
        kv := new(model.KVDoc)
        if err = readRequest(context, kv); err != nil {
                WriteErrResponse(context, http.StatusBadRequest, err.Error(), 
common.ContentTypeText)
@@ -88,12 +89,12 @@ func (r *KVResource) Put(context *restful.Context) {
 //GetByKey search key by label and key
 func (r *KVResource) GetByKey(rctx *restful.Context) {
        var err error
-       key := rctx.ReadPathParameter("key")
+       key := rctx.ReadPathParameter(PathParameterKey)
        if key == "" {
                WriteErrResponse(rctx, http.StatusBadRequest, "key must not be 
empty", common.ContentTypeText)
                return
        }
-       project := rctx.ReadPathParameter("project")
+       project := rctx.ReadPathParameter(PathParameterProject)
        labels, err := getLabels(rctx)
        if err != nil {
                WriteErrResponse(rctx, http.StatusBadRequest, 
common.MsgIllegalLabels, common.ContentTypeText)
@@ -104,15 +105,15 @@ func (r *KVResource) GetByKey(rctx *restful.Context) {
                WriteErrResponse(rctx, http.StatusInternalServerError, 
common.MsgDomainMustNotBeEmpty, common.ContentTypeText)
                return
        }
-       pageNumStr := rctx.ReadQueryParameter("pageNum")
-       pageSizeStr := rctx.ReadQueryParameter("pageSize")
+       pageNumStr := rctx.ReadQueryParameter(QueryParameterPageNum)
+       pageSizeStr := rctx.ReadQueryParameter(QueryParameterPageSize)
        pageNum, pageSize, err := checkPagination(pageNumStr, pageSizeStr)
        if err != nil {
                WriteErrResponse(rctx, http.StatusBadRequest, err.Error(), 
common.ContentTypeText)
                return
        }
-       insID := rctx.ReadHeader("sessionID")
-       statusStr := rctx.ReadQueryParameter("status")
+       insID := rctx.ReadHeader(HeaderSessionID)
+       statusStr := rctx.ReadQueryParameter(QueryParameterStatus)
        status, err := checkStatus(statusStr)
        if err != nil {
                WriteErrResponse(rctx, http.StatusBadRequest, err.Error(), 
common.ContentTypeText)
@@ -124,7 +125,7 @@ func (r *KVResource) GetByKey(rctx *restful.Context) {
 //List response kv list
 func (r *KVResource) List(rctx *restful.Context) {
        var err error
-       project := rctx.ReadPathParameter("project")
+       project := rctx.ReadPathParameter(PathParameterProject)
        domain := ReadDomain(rctx)
        if domain == nil {
                WriteErrResponse(rctx, http.StatusInternalServerError, 
common.MsgDomainMustNotBeEmpty, common.ContentTypeText)
@@ -135,15 +136,15 @@ func (r *KVResource) List(rctx *restful.Context) {
                WriteErrResponse(rctx, http.StatusBadRequest, err.Error(), 
common.ContentTypeText)
                return
        }
-       pageNumStr := rctx.ReadQueryParameter("pageNum")
-       pageSizeStr := rctx.ReadQueryParameter("pageSize")
+       pageNumStr := rctx.ReadQueryParameter(QueryParameterPageNum)
+       pageSizeStr := rctx.ReadQueryParameter(QueryParameterPageSize)
        pageNum, pageSize, err := checkPagination(pageNumStr, pageSizeStr)
        if err != nil {
                WriteErrResponse(rctx, http.StatusBadRequest, err.Error(), 
common.ContentTypeText)
                return
        }
-       sessionID := rctx.ReadHeader("sessionID")
-       statusStr := rctx.ReadQueryParameter("status")
+       sessionID := rctx.ReadHeader(HeaderSessionID)
+       statusStr := rctx.ReadQueryParameter(QueryParameterStatus)
        status, err := checkStatus(statusStr)
        if err != nil {
                WriteErrResponse(rctx, http.StatusBadRequest, err.Error(), 
common.ContentTypeText)
@@ -231,7 +232,7 @@ func RecordPollingDetail(context *restful.Context, revStr, 
wait, domain, project
                "offset":  offset,
        }
        data.PollingData = dataMap
-       data.UserAgent = context.Req.HeaderParameter("User-Agent")
+       data.UserAgent = context.Req.HeaderParameter(HeaderUserAgent)
        data.URLPath = context.ReadRequest().Method + " " + 
context.ReadRequest().URL.Path
        data.ResponseHeader = context.Resp.Header()
        data.ResponseCode = context.Resp.StatusCode()
@@ -251,15 +252,15 @@ func (r *KVResource) Search(context *restful.Context) {
                WriteErrResponse(context, http.StatusBadRequest, err.Error(), 
common.ContentTypeText)
                return
        }
-       project := context.ReadPathParameter("project")
+       project := context.ReadPathParameter(PathParameterProject)
        domain := ReadDomain(context)
        if domain == nil {
                WriteErrResponse(context, http.StatusInternalServerError, 
common.MsgDomainMustNotBeEmpty, common.ContentTypeText)
                return
        }
        var kvs []*model.KVResponse
-       pageNumStr := context.ReadQueryParameter("pageNum")
-       pageSizeStr := context.ReadQueryParameter("pageSize")
+       pageNumStr := context.ReadQueryParameter(QueryParameterPageNum)
+       pageSizeStr := context.ReadQueryParameter(QueryParameterPageSize)
        pageNum, pageSize, err := checkPagination(pageNumStr, pageSizeStr)
        if err != nil {
                WriteErrResponse(context, http.StatusBadRequest, err.Error(), 
common.ContentTypeText)
@@ -270,7 +271,7 @@ func (r *KVResource) Search(context *restful.Context) {
                        service.WithPageNum(pageNum),
                        service.WithPageSize(pageSize))
                if err != nil {
-                       openlogging.Error("can not find by labels", 
openlogging.WithTags(openlogging.Tags{
+                       openlogging.Error(MsgLabelsNotFound, 
openlogging.WithTags(openlogging.Tags{
                                "err": err.Error(),
                        }))
                        WriteErrResponse(context, 
http.StatusInternalServerError, err.Error(), common.ContentTypeText)
@@ -290,7 +291,7 @@ func (r *KVResource) Search(context *restful.Context) {
                        if err == service.ErrKeyNotExists {
                                continue
                        } else {
-                               openlogging.Error("can not find by labels", 
openlogging.WithTags(openlogging.Tags{
+                               openlogging.Error(MsgLabelsNotFound, 
openlogging.WithTags(openlogging.Tags{
                                        "err": err.Error(),
                                }))
                                WriteErrResponse(context, 
http.StatusInternalServerError, err.Error(), common.ContentTypeText)
@@ -314,7 +315,7 @@ func (r *KVResource) Search(context *restful.Context) {
 
 //Delete deletes key by ids
 func (r *KVResource) Delete(context *restful.Context) {
-       project := context.ReadPathParameter("project")
+       project := context.ReadPathParameter(PathParameterProject)
        domain := ReadDomain(context)
        if domain == nil {
                WriteErrResponse(context, http.StatusInternalServerError, 
common.MsgDomainMustNotBeEmpty, common.ContentTypeText)
diff --git a/server/service/mongo/counter/revision.go 
b/server/service/mongo/counter/revision.go
index a90a8f1..5da19c0 100644
--- a/server/service/mongo/counter/revision.go
+++ b/server/service/mongo/counter/revision.go
@@ -20,6 +20,7 @@ package counter
 import (
        "context"
        "errors"
+
        "github.com/apache/servicecomb-kie/server/service/mongo/session"
        "github.com/go-mesh/openlogging"
        "go.mongodb.org/mongo-driver/bson"
@@ -39,8 +40,9 @@ func (s *Service) GetRevision(ctx context.Context, domain 
string) (int64, error)
        cur, err := collection.Find(ctx, filter)
        if err != nil {
                if err.Error() == context.DeadlineExceeded.Error() {
-                       openlogging.Error("operation timeout")
-                       return 0, errors.New("operation timeout")
+                       msg := "operation timeout"
+                       openlogging.Error(msg)
+                       return 0, errors.New(msg)
                }
                return 0, err
        }
diff --git a/server/service/mongo/kv/kv_dao.go 
b/server/service/mongo/kv/kv_dao.go
index 837a67b..f96114a 100644
--- a/server/service/mongo/kv/kv_dao.go
+++ b/server/service/mongo/kv/kv_dao.go
@@ -20,6 +20,8 @@ package kv
 import (
        "context"
        "fmt"
+       "time"
+
        "github.com/apache/servicecomb-kie/pkg/model"
        "github.com/apache/servicecomb-kie/server/service"
        "github.com/apache/servicecomb-kie/server/service/mongo/counter"
@@ -30,7 +32,6 @@ import (
        "go.mongodb.org/mongo-driver/bson"
        "go.mongodb.org/mongo-driver/mongo"
        "go.mongodb.org/mongo-driver/mongo/options"
-       "time"
 )
 
 //createKey get latest revision from history
@@ -124,10 +125,10 @@ func findKV(ctx context.Context, domain string, project 
string, opts service.Fin
        curTotal, err := collection.CountDocuments(ctx, filter)
        if err != nil {
                if err.Error() == context.DeadlineExceeded.Error() {
-                       openlogging.Error("find kv failed, deadline exceeded", 
openlogging.WithTags(openlogging.Tags{
+                       openlogging.Error(MsgFindKvFailed, 
openlogging.WithTags(openlogging.Tags{
                                "timeout": opts.Timeout,
                        }))
-                       return nil, 0, fmt.Errorf("can not find kv in %s", 
opts.Timeout)
+                       return nil, 0, fmt.Errorf(FmtErrFindKvFailed, 
opts.Timeout)
                }
                return nil, 0, err
        }
@@ -137,10 +138,10 @@ func findKV(ctx context.Context, domain string, project 
string, opts service.Fin
        cur, err := collection.Find(ctx, filter, opt)
        if err != nil {
                if err.Error() == context.DeadlineExceeded.Error() {
-                       openlogging.Error("find kv failed, deadline exceeded", 
openlogging.WithTags(openlogging.Tags{
+                       openlogging.Error(MsgFindKvFailed, 
openlogging.WithTags(openlogging.Tags{
                                "timeout": opts.Timeout,
                        }))
-                       return nil, 0, fmt.Errorf("can not find kv in %s", 
opts.Timeout)
+                       return nil, 0, fmt.Errorf(FmtErrFindKvFailed, 
opts.Timeout)
                }
                return nil, 0, err
        }
@@ -222,7 +223,7 @@ func findKVByLabelID(ctx context.Context, domain, labelID, 
key string, project s
        filter := bson.M{"label_id": labelID, "domain": domain, "project": 
project}
        if key != "" {
                filter["key"] = key
-               openlogging.Debug("find one key")
+               openlogging.Debug(MsgFindOneKey)
                return findOneKey(ctx, filter)
        }
        return findKeys(ctx, filter, true)
diff --git a/server/service/mongo/kv/kv_service.go 
b/server/service/mongo/kv/kv_service.go
index 9ecfb61..7e95ddd 100644
--- a/server/service/mongo/kv/kv_service.go
+++ b/server/service/mongo/kv/kv_service.go
@@ -31,6 +31,14 @@ import (
        "github.com/go-mesh/openlogging"
 )
 
+//const of kv service
+const (
+       MsgFindKvFailed    = "find kv failed, deadline exceeded"
+       MsgFindOneKey      = "find one key"
+       MsgHitExactLabels  = "hit exact labels"
+       FmtErrFindKvFailed = "can not find kv in %s"
+)
+
 //Service operate data in mongodb
 type Service struct {
        timeout time.Duration
@@ -211,7 +219,7 @@ func (s *Service) FindKV(ctx context.Context, domain 
string, project string, opt
 
        kvResp := make([]*model.KVResponse, 0)
        if opts.Depth == 0 && opts.Key != "" {
-               openlogging.Debug("find one key", openlogging.WithTags(
+               openlogging.Debug(MsgFindOneKey, openlogging.WithTags(
                        map[string]interface{}{
                                "key":    opts.Key,
                                "label":  opts.Labels,
diff --git a/server/service/mongo/kv/tool.go b/server/service/mongo/kv/tool.go
index 6852cfe..e3b1bdb 100644
--- a/server/service/mongo/kv/tool.go
+++ b/server/service/mongo/kv/tool.go
@@ -19,10 +19,10 @@ package kv
 
 import (
        "context"
-       "github.com/apache/servicecomb-kie/server/service"
        "reflect"
 
        "github.com/apache/servicecomb-kie/pkg/model"
+       "github.com/apache/servicecomb-kie/server/service"
        "github.com/go-mesh/openlogging"
        "go.mongodb.org/mongo-driver/mongo"
 )
@@ -51,7 +51,7 @@ func cursorToOneKV(ctx context.Context, cur *mongo.Cursor, 
labels map[string]str
                        return nil, err
                }
                if reflect.DeepEqual(curKV.Labels, labels) {
-                       openlogging.Debug("hit exact labels")
+                       openlogging.Debug(MsgHitExactLabels)
                        labelGroup := &model.KVResponse{
                                LabelDoc: &model.LabelDocResponse{
                                        Labels:  labels,
diff --git a/server/service/mongo/label/label_dao.go 
b/server/service/mongo/label/label_dao.go
index 5fb14aa..eff2821 100644
--- a/server/service/mongo/label/label_dao.go
+++ b/server/service/mongo/label/label_dao.go
@@ -20,6 +20,7 @@ package label
 import (
        "context"
        "fmt"
+
        "github.com/apache/servicecomb-kie/pkg/model"
        "github.com/apache/servicecomb-kie/pkg/stringutil"
        "github.com/apache/servicecomb-kie/server/service"
@@ -30,8 +31,10 @@ import (
        "go.mongodb.org/mongo-driver/bson/primitive"
 )
 
+//const of label dao
 const (
-       defaultLabels = "default"
+       defaultLabels     = "default"
+       MsgHitExactLabels = "hit exact labels"
 )
 
 //FindLabels find label doc by labels and project, check if the project has 
certain labels
@@ -59,7 +62,7 @@ func FindLabels(ctx context.Context, domain, project string, 
labels map[string]s
                        return nil, err
                }
                if len(curLabel.Labels) == len(labels) {
-                       openlogging.Debug("hit exact labels")
+                       openlogging.Debug(MsgHitExactLabels)
                        curLabel.Labels = nil //exact match don't need to 
return labels
                        return curLabel, nil
                }

Reply via email to