This is an automated email from the ASF dual-hosted git repository.
tianxiaoliang pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/servicecomb-service-center.git
The following commit(s) were added to refs/heads/master by this push:
new fe8b622 GetService optimize (#824)
fe8b622 is described below
commit fe8b622a4740780b90edc05ba5797fbc153fad34
Author: yeyiwei <[email protected]>
AuthorDate: Wed Jan 13 10:41:36 2021 +0800
GetService optimize (#824)
---
datasource/{mongo/client => }/errortypes.go | 32 +--
datasource/etcd/dep.go | 38 +--
datasource/etcd/event/instance_event_handler.go | 11 +-
datasource/etcd/event/rule_event_handler.go | 12 +-
datasource/etcd/event/tag_event_handler.go | 18 +-
datasource/etcd/ms.go | 299 +++++++++++------------
datasource/etcd/util.go | 3 +-
datasource/etcd/util/dependency_query.go | 38 +--
datasource/etcd/util/dependency_test.go | 14 +-
datasource/etcd/util/microservice_util.go | 17 +-
datasource/etcd/util/rule_util.go | 19 +-
datasource/etcd/util/rule_util_test.go | 37 ++-
datasource/etcd/util/util_suite_test.go | 26 +-
datasource/mongo/client/errortypes.go | 2 +-
datasource/mongo/dep.go | 33 +--
datasource/mongo/dependency_query.go | 16 +-
datasource/mongo/event/instance_event_handler.go | 11 +-
datasource/mongo/ms.go | 186 +++++++-------
server/broker/service.go | 103 ++++----
server/broker/util.go | 31 +--
20 files changed, 484 insertions(+), 462 deletions(-)
diff --git a/datasource/mongo/client/errortypes.go b/datasource/errortypes.go
similarity index 64%
copy from datasource/mongo/client/errortypes.go
copy to datasource/errortypes.go
index 9d7311a..ffc6866 100644
--- a/datasource/mongo/client/errortypes.go
+++ b/datasource/errortypes.go
@@ -13,36 +13,10 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package client
+package datasource
-import (
- "errors"
-
- "go.mongodb.org/mongo-driver/mongo"
-)
+import "errors"
var (
- ErrNoDocuments = errors.New("no doc found")
-)
-
-const (
- DuplicateKey = 11000
+ ErrNoData = errors.New("no data found")
)
-
-func IsDuplicateKey(err error) bool {
- if err != nil {
- we, ok := err.(mongo.WriteException)
- if ok {
- for _, wr := range we.WriteErrors {
- if wr.Code == DuplicateKey {
- return true
- }
- }
- }
- }
- return false
-}
-
-func IsNoneDoc(err error) bool {
- return err == ErrNoDocuments
-}
diff --git a/datasource/etcd/dep.go b/datasource/etcd/dep.go
index db51e6e..cc0c887 100644
--- a/datasource/etcd/dep.go
+++ b/datasource/etcd/dep.go
@@ -20,8 +20,10 @@ package etcd
import (
"context"
"encoding/json"
+ "errors"
"fmt"
+ "github.com/apache/servicecomb-service-center/datasource"
"github.com/apache/servicecomb-service-center/datasource/etcd/client"
"github.com/apache/servicecomb-service-center/datasource/etcd/path"
serviceUtil
"github.com/apache/servicecomb-service-center/datasource/etcd/util"
@@ -36,22 +38,22 @@ func (ds *DataSource) SearchProviderDependency(ctx
context.Context, request *pb.
provider, err := serviceUtil.GetService(ctx, domainProject,
providerServiceID)
if err != nil {
- log.Errorf(err, "GetProviderDependencies failed, provider is
%s", providerServiceID)
+ if errors.Is(err, datasource.ErrNoData) {
+ log.Debug(fmt.Sprintf("provider[%s] does not exist in
db", providerServiceID))
+ return &pb.GetProDependenciesResponse{
+ Response:
pb.CreateResponse(pb.ErrServiceNotExists, "Provider does not exist"),
+ }, nil
+ }
+ log.Error(fmt.Sprintf("query provider service from db failed,
provider is %s", providerServiceID), err)
return nil, err
}
- if provider == nil {
- log.Errorf(err, "GetProviderDependencies failed for
provider[%s] does not exist", providerServiceID)
- return &pb.GetProDependenciesResponse{
- Response: pb.CreateResponse(pb.ErrServiceNotExists,
"Provider does not exist"),
- }, nil
- }
dr := serviceUtil.NewProviderDependencyRelation(ctx, domainProject,
provider)
services, err :=
dr.GetDependencyConsumers(toDependencyFilterOptions(request)...)
if err != nil {
- log.Errorf(err, "GetProviderDependencies failed, provider is
%s/%s/%s/%s",
- provider.Environment, provider.AppId,
provider.ServiceName, provider.Version)
+ log.Error(fmt.Sprintf("query provider failed, provider is
%s/%s/%s/%s",
+ provider.Environment, provider.AppId,
provider.ServiceName, provider.Version), err)
return &pb.GetProDependenciesResponse{
Response: pb.CreateResponse(pb.ErrInternal,
err.Error()),
}, err
@@ -69,21 +71,21 @@ func (ds *DataSource) SearchConsumerDependency(ctx
context.Context, request *pb.
consumer, err := serviceUtil.GetService(ctx, domainProject, consumerID)
if err != nil {
- log.Errorf(err, "GetConsumerDependencies failed, consumer is
%s", consumerID)
+ if errors.Is(err, datasource.ErrNoData) {
+ log.Debug(fmt.Sprintf("consumer[%s] does not exist",
consumerID))
+ return &pb.GetConDependenciesResponse{
+ Response:
pb.CreateResponse(pb.ErrServiceNotExists, "Consumer does not exist"),
+ }, nil
+ }
+ log.Error(fmt.Sprintf("query consumer failed, consumer is %s",
consumerID), err)
return nil, err
}
- if consumer == nil {
- log.Errorf(err, "GetConsumerDependencies failed for
consumer[%s] does not exist", consumerID)
- return &pb.GetConDependenciesResponse{
- Response: pb.CreateResponse(pb.ErrServiceNotExists,
"Consumer does not exist"),
- }, nil
- }
dr := serviceUtil.NewConsumerDependencyRelation(ctx, domainProject,
consumer)
services, err :=
dr.GetDependencyProviders(toDependencyFilterOptions(request)...)
if err != nil {
- log.Errorf(err, "GetConsumerDependencies failed, consumer is
%s/%s/%s/%s",
- consumer.Environment, consumer.AppId,
consumer.ServiceName, consumer.Version)
+ log.Error(fmt.Sprintf("query consumer failed, consumer is
%s/%s/%s/%s",
+ consumer.Environment, consumer.AppId,
consumer.ServiceName, consumer.Version), err)
return &pb.GetConDependenciesResponse{
Response: pb.CreateResponse(pb.ErrInternal,
err.Error()),
}, err
diff --git a/datasource/etcd/event/instance_event_handler.go
b/datasource/etcd/event/instance_event_handler.go
index ae5919a..54b78be 100644
--- a/datasource/etcd/event/instance_event_handler.go
+++ b/datasource/etcd/event/instance_event_handler.go
@@ -19,6 +19,7 @@ package event
import (
"context"
+ "fmt"
"strings"
"github.com/apache/servicecomb-service-center/datasource/etcd/cache"
@@ -92,9 +93,9 @@ func (h *InstanceEventHandler) OnEvent(evt sd.KvEvent) {
ctx := util.WithGlobal(util.WithCacheOnly(context.Background()))
ms, err := serviceUtil.GetService(ctx, domainProject, providerID)
- if ms == nil {
- log.Errorf(err, "caught [%s] instance[%s/%s] event, endpoints
%v, get cached provider's file failed",
- action, providerID, providerInstanceID,
instance.Endpoints)
+ if err != nil {
+ log.Error(fmt.Sprintf("caught [%s] instance[%s/%s] event,
endpoints %v, get cached provider's file failed",
+ action, providerID, providerInstanceID,
instance.Endpoints), err)
return
}
@@ -103,8 +104,8 @@ func (h *InstanceEventHandler) OnEvent(evt sd.KvEvent) {
}
if notify.Center().Closed() {
- log.Warnf("caught [%s] instance[%s/%s] event, endpoints %v, but
notify service is closed",
- action, providerID, providerInstanceID,
instance.Endpoints)
+ log.Warn(fmt.Sprintf("caught [%s] instance[%s/%s] event,
endpoints %v, but notify service is closed",
+ action, providerID, providerInstanceID,
instance.Endpoints))
return
}
diff --git a/datasource/etcd/event/rule_event_handler.go
b/datasource/etcd/event/rule_event_handler.go
index 88b5ff5..8b8a866 100644
--- a/datasource/etcd/event/rule_event_handler.go
+++ b/datasource/etcd/event/rule_event_handler.go
@@ -19,8 +19,10 @@ package event
import (
"context"
+ "errors"
"fmt"
+ "github.com/apache/servicecomb-service-center/datasource"
"github.com/apache/servicecomb-service-center/datasource/etcd/kv"
"github.com/apache/servicecomb-service-center/datasource/etcd/path"
"github.com/apache/servicecomb-service-center/datasource/etcd/sd"
@@ -60,13 +62,13 @@ func (apt *RulesChangedTask) publish(ctx context.Context,
domainProject, provide
provider, err := serviceUtil.GetService(ctx, domainProject, providerID)
if err != nil {
- log.Errorf(err, "get provider[%s] service file failed",
providerID)
+ if errors.Is(err, datasource.ErrNoData) {
+ log.Debug(fmt.Sprintf("provider[%s] does not exist",
providerID))
+ } else {
+ log.Error(fmt.Sprintf("get provider[%s] service file
failed", providerID), err)
+ }
return err
}
- if provider == nil {
- log.Errorf(nil, "provider[%s] does not exist", providerID)
- return fmt.Errorf("provider %s does not exist", providerID)
- }
consumerIds, err := serviceUtil.GetConsumerIds(ctx, domainProject,
provider)
if err != nil {
diff --git a/datasource/etcd/event/tag_event_handler.go
b/datasource/etcd/event/tag_event_handler.go
index 585b173..f0c5822 100644
--- a/datasource/etcd/event/tag_event_handler.go
+++ b/datasource/etcd/event/tag_event_handler.go
@@ -19,8 +19,10 @@ package event
import (
"context"
+ "errors"
"fmt"
+ "github.com/apache/servicecomb-service-center/datasource"
"github.com/apache/servicecomb-service-center/datasource/etcd/cache"
"github.com/apache/servicecomb-service-center/datasource/etcd/kv"
"github.com/apache/servicecomb-service-center/datasource/etcd/path"
@@ -61,13 +63,13 @@ func (apt *TagsChangedTask) publish(ctx context.Context,
domainProject, consumer
consumer, err := serviceUtil.GetService(ctx, domainProject, consumerID)
if err != nil {
- log.Errorf(err, "get consumer[%s] for publish event failed",
consumerID)
+ if errors.Is(err, datasource.ErrNoData) {
+ log.Debug(fmt.Sprintf("consumer[%s] does not exist in
db", consumerID))
+ } else {
+ log.Error(fmt.Sprintf("get consumer[%s] for publish
event failed", consumerID), err)
+ }
return err
}
- if consumer == nil {
- log.Errorf(nil, "consumer[%s] does not exist", consumerID)
- return fmt.Errorf("consumer[%s] does not exist", consumerID)
- }
serviceKey := pb.MicroServiceToKey(domainProject, consumer)
cache.FindInstances.Remove(serviceKey)
@@ -81,9 +83,9 @@ func (apt *TagsChangedTask) publish(ctx context.Context,
domainProject, consumer
for _, providerID := range providerIDs {
provider, err := serviceUtil.GetService(ctx, domainProject,
providerID)
- if provider == nil {
- log.Errorf(err, "get service[%s][%s/%s/%s/%s]'s
provider[%s] file failed",
- consumerID, consumer.Environment,
consumer.AppId, consumer.ServiceName, consumer.Version, providerID)
+ if err != nil {
+ log.Error(fmt.Sprintf("get service[%s][%s/%s/%s/%s]'s
provider[%s] file failed",
+ consumerID, consumer.Environment,
consumer.AppId, consumer.ServiceName, consumer.Version, providerID), err)
continue
}
diff --git a/datasource/etcd/ms.go b/datasource/etcd/ms.go
index 1527490..3e650c7 100644
--- a/datasource/etcd/ms.go
+++ b/datasource/etcd/ms.go
@@ -66,8 +66,8 @@ func (ds *DataSource) RegisterService(ctx context.Context,
request *pb.CreateSer
reporter := checkQuota(ctx, domainProject)
defer reporter.Close(ctx)
if reporter != nil && reporter.Err != nil {
- log.Errorf(reporter.Err, "create micro-service[%s] failed,
operator: %s",
- serviceFlag, remoteIP)
+ log.Error(fmt.Sprintf("create micro-service[%s] failed,
operator: %s",
+ serviceFlag, remoteIP), reporter.Err)
resp := &pb.CreateServiceResponse{
Response: pb.CreateResponseWithSCErr(reporter.Err),
}
@@ -90,8 +90,8 @@ func (ds *DataSource) RegisterService(ctx context.Context,
request *pb.CreateSer
data, err := json.Marshal(service)
if err != nil {
- log.Errorf(err, "create micro-service[%s] failed, json marshal
service failed, operator: %s",
- serviceFlag, remoteIP)
+ log.Error(fmt.Sprintf("create micro-service[%s] failed, json
marshal service failed, operator: %s",
+ serviceFlag, remoteIP), err)
return &pb.CreateServiceResponse{
Response: pb.CreateResponse(pb.ErrInternal,
err.Error()),
}, err
@@ -123,8 +123,8 @@ func (ds *DataSource) RegisterService(ctx context.Context,
request *pb.CreateSer
resp, err := client.Instance().TxnWithCmp(ctx, opts, uniqueCmpOpts,
failOpts)
if err != nil {
- log.Errorf(err, "create micro-service[%s] failed, operator: %s",
- serviceFlag, remoteIP)
+ log.Error(fmt.Sprintf("create micro-service[%s] failed,
operator: %s",
+ serviceFlag, remoteIP), err)
return &pb.CreateServiceResponse{
Response: pb.CreateResponse(pb.ErrUnavailableBackend,
err.Error()),
}, err
@@ -133,8 +133,8 @@ func (ds *DataSource) RegisterService(ctx context.Context,
request *pb.CreateSer
if len(requestServiceID) != 0 {
if len(resp.Kvs) == 0 ||
requestServiceID !=
util.BytesToStringWithNoCopy(resp.Kvs[0].Value) {
- log.Warnf("create micro-service[%s] failed,
service already exists, operator: %s",
- serviceFlag, remoteIP)
+ log.Warn(fmt.Sprintf("create micro-service[%s]
failed, service already exists, operator: %s",
+ serviceFlag, remoteIP))
return &pb.CreateServiceResponse{
Response:
pb.CreateResponse(pb.ErrServiceAlreadyExists,
"ServiceID conflict or found
the same service with different id."),
@@ -144,16 +144,16 @@ func (ds *DataSource) RegisterService(ctx
context.Context, request *pb.CreateSer
if len(resp.Kvs) == 0 {
// internal error?
- log.Errorf(nil, "create micro-service[%s] failed,
unexpected txn response, operator: %s",
- serviceFlag, remoteIP)
+ log.Error(fmt.Sprintf("create micro-service[%s] failed,
unexpected txn response, operator: %s",
+ serviceFlag, remoteIP), nil)
return &pb.CreateServiceResponse{
Response: pb.CreateResponse(pb.ErrInternal,
"Unexpected txn response."),
}, nil
}
serviceIDInner :=
util.BytesToStringWithNoCopy(resp.Kvs[0].Value)
- log.Warnf("create micro-service[%s][%s] failed, service already
exists, operator: %s",
- serviceIDInner, serviceFlag, remoteIP)
+ log.Warn(fmt.Sprintf("create micro-service[%s][%s] failed,
service already exists, operator: %s",
+ serviceIDInner, serviceFlag, remoteIP))
return &pb.CreateServiceResponse{
Response: pb.CreateResponse(pb.ResponseSuccess,
"register service successfully"),
ServiceId: serviceIDInner,
@@ -161,11 +161,11 @@ func (ds *DataSource) RegisterService(ctx
context.Context, request *pb.CreateSer
}
if err := reporter.ReportUsedQuota(ctx); err != nil {
- log.Errorf(err, "report the used quota failed")
+ log.Error("report the used quota failed", err)
}
- log.Infof("create micro-service[%s][%s] successfully, operator: %s",
- service.ServiceId, serviceFlag, remoteIP)
+ log.Info(fmt.Sprintf("create micro-service[%s][%s] successfully,
operator: %s",
+ service.ServiceId, serviceFlag, remoteIP))
return &pb.CreateServiceResponse{
Response: pb.CreateResponse(pb.ResponseSuccess, "Register
service successfully."),
ServiceId: service.ServiceId,
@@ -177,7 +177,7 @@ func (ds *DataSource) GetServices(ctx context.Context,
request *pb.GetServicesRe
*pb.GetServicesResponse, error) {
services, err := serviceUtil.GetAllServiceUtil(ctx)
if err != nil {
- log.Errorf(err, "get all services by domain failed")
+ log.Error("get all services by domain failed", err)
return &pb.GetServicesResponse{
Response: pb.CreateResponse(pb.ErrInternal,
err.Error()),
}, err
@@ -195,17 +195,17 @@ func (ds *DataSource) GetService(ctx context.Context,
request *pb.GetServiceRequ
singleService, err := serviceUtil.GetService(ctx, domainProject,
request.ServiceId)
if err != nil {
- log.Errorf(err, "get micro-service[%s] failed, get service file
failed", request.ServiceId)
+ if errors.Is(err, datasource.ErrNoData) {
+ log.Debug(fmt.Sprintf("get micro-service[%s] failed,
service does not exist in db", request.ServiceId))
+ return &pb.GetServiceResponse{
+ Response:
pb.CreateResponse(pb.ErrServiceNotExists, "Service does not exist."),
+ }, nil
+ }
+ log.Error(fmt.Sprintf("get micro-service[%s] failed, get
service file failed", request.ServiceId), err)
return &pb.GetServiceResponse{
Response: pb.CreateResponse(pb.ErrInternal,
err.Error()),
}, err
}
- if singleService == nil {
- log.Errorf(nil, "get micro-service[%s] failed, service does not
exist", request.ServiceId)
- return &pb.GetServiceResponse{
- Response: pb.CreateResponse(pb.ErrServiceNotExists,
"Service does not exist."),
- }, nil
- }
return &pb.GetServiceResponse{
Response: pb.CreateResponse(pb.ResponseSuccess, "Get service
successfully."),
Service: singleService,
@@ -217,12 +217,12 @@ func (ds *DataSource) GetServiceDetail(ctx
context.Context, request *pb.GetServi
domainProject := util.ParseDomainProject(ctx)
service, err := serviceUtil.GetService(ctx, domainProject,
request.ServiceId)
- if service == nil {
- return &pb.GetServiceDetailResponse{
- Response: pb.CreateResponse(pb.ErrServiceNotExists,
"Service does not exist."),
- }, nil
- }
if err != nil {
+ if errors.Is(err, datasource.ErrNoData) {
+ return &pb.GetServiceDetailResponse{
+ Response:
pb.CreateResponse(pb.ErrServiceNotExists, "Service does not exist."),
+ }, nil
+ }
return &pb.GetServiceDetailResponse{
Response: pb.CreateResponse(pb.ErrInternal,
err.Error()),
}, err
@@ -237,8 +237,8 @@ func (ds *DataSource) GetServiceDetail(ctx context.Context,
request *pb.GetServi
}
versions, err := getServiceAllVersions(ctx, key)
if err != nil {
- log.Errorf(err, "get service[%s/%s/%s] all versions failed",
- service.Environment, service.AppId, service.ServiceName)
+ log.Error(fmt.Sprintf("get service[%s/%s/%s] all versions
failed",
+ service.Environment, service.AppId,
service.ServiceName), err)
return &pb.GetServiceDetailResponse{
Response: pb.CreateResponse(pb.ErrInternal,
err.Error()),
}, err
@@ -303,7 +303,7 @@ func (ds *DataSource) GetServicesInfo(ctx context.Context,
request *pb.GetServic
//获取所有服务
services, err := serviceUtil.GetAllServiceUtil(ctx)
if err != nil {
- log.Errorf(err, "get all services by domain failed")
+ log.Error("get all services by domain failed", err)
return &pb.GetServicesInfoResponse{
Response: pb.CreateResponse(pb.ErrInternal,
err.Error()),
}, err
@@ -409,19 +409,19 @@ func (ds *DataSource) ExistService(ctx context.Context,
request *pb.GetExistence
Tenant: domainProject,
})
if err != nil {
- log.Errorf(err, "micro-service[%s] exist failed, find
serviceIDs failed", serviceFlag)
+ log.Error(fmt.Sprintf("micro-service[%s] exist failed, find
serviceIDs failed", serviceFlag), err)
return &pb.GetExistenceResponse{
Response: pb.CreateResponse(pb.ErrInternal,
err.Error()),
}, err
}
if !exist {
- log.Infof("micro-service[%s] exist failed, service does not
exist", serviceFlag)
+ log.Info(fmt.Sprintf("micro-service[%s] exist failed, service
does not exist", serviceFlag))
return &pb.GetExistenceResponse{
Response: pb.CreateResponse(pb.ErrServiceNotExists,
serviceFlag+" does not exist."),
}, nil
}
if len(ids) == 0 {
- log.Infof("micro-service[%s] exist failed, version mismatch",
serviceFlag)
+ log.Info(fmt.Sprintf("micro-service[%s] exist failed, version
mismatch", serviceFlag))
return &pb.GetExistenceResponse{
Response:
pb.CreateResponse(pb.ErrServiceVersionNotExists, serviceFlag+" version
mismatch."),
}, nil
@@ -440,19 +440,19 @@ func (ds *DataSource) UpdateService(ctx context.Context,
request *pb.UpdateServi
key := path.GenerateServiceKey(domainProject, request.ServiceId)
microservice, err := serviceUtil.GetService(ctx, domainProject,
request.ServiceId)
if err != nil {
- log.Errorf(err, "update service[%s] properties failed, get
service file failed, operator: %s",
- request.ServiceId, remoteIP)
+ if errors.Is(err, datasource.ErrNoData) {
+ log.Debug(fmt.Sprintf("service does not exist, update
service[%s] properties failed, operator: %s",
+ request.ServiceId, remoteIP))
+ return &pb.UpdateServicePropsResponse{
+ Response:
pb.CreateResponse(pb.ErrServiceNotExists, "Service does not exist."),
+ }, nil
+ }
+ log.Error(fmt.Sprintf("update service[%s] properties failed,
get service file failed, operator: %s",
+ request.ServiceId, remoteIP), err)
return &pb.UpdateServicePropsResponse{
Response: pb.CreateResponse(pb.ErrInternal,
err.Error()),
}, err
}
- if microservice == nil {
- log.Errorf(nil, "update service[%s] properties failed, service
does not exist, operator: %s",
- request.ServiceId, remoteIP)
- return &pb.UpdateServicePropsResponse{
- Response: pb.CreateResponse(pb.ErrServiceNotExists,
"Service does not exist."),
- }, nil
- }
copyServiceRef := *microservice
copyServiceRef.Properties = request.Properties
@@ -541,8 +541,8 @@ func (ds *DataSource) RegisterInstance(ctx context.Context,
request *pb.Register
}
switch resp.Response.GetCode() {
case pb.ResponseSuccess:
- log.Infof("register instance successful, reuse
instance[%s/%s], operator %s",
- instance.ServiceId, instance.InstanceId,
remoteIP)
+ log.Info(fmt.Sprintf("register instance successful,
reuse instance[%s/%s], operator %s",
+ instance.ServiceId, instance.InstanceId,
remoteIP))
return &pb.RegisterInstanceResponse{
Response: resp.Response,
InstanceId: instance.InstanceId,
@@ -550,8 +550,8 @@ func (ds *DataSource) RegisterInstance(ctx context.Context,
request *pb.Register
case pb.ErrInstanceNotExists:
// register a new one
default:
- log.Errorf(err, "register instance failed, reuse
instance[%s/%s], operator %s",
- instance.ServiceId, instance.InstanceId,
remoteIP)
+ log.Error(fmt.Sprintf("register instance failed, reuse
instance[%s/%s], operator %s",
+ instance.ServiceId, instance.InstanceId,
remoteIP), err)
return &pb.RegisterInstanceResponse{
Response: resp.Response,
}, err
@@ -559,8 +559,8 @@ func (ds *DataSource) RegisterInstance(ctx context.Context,
request *pb.Register
}
if err := preProcessRegisterInstance(ctx, instance); err != nil {
- log.Errorf(err, "register service[%s]'s instance failed,
endpoints %v, host '%s', operator %s",
- instance.ServiceId, instance.Endpoints,
instance.HostName, remoteIP)
+ log.Error(fmt.Sprintf("register service[%s]'s instance failed,
endpoints %v, host '%s', operator %s",
+ instance.ServiceId, instance.Endpoints,
instance.HostName, remoteIP), err)
return &pb.RegisterInstanceResponse{
Response: pb.CreateResponseWithSCErr(err),
}, nil
@@ -584,8 +584,8 @@ func (ds *DataSource) RegisterInstance(ctx context.Context,
request *pb.Register
defer reporter.Close(ctx)
if reporter.Err != nil {
- log.Errorf(reporter.Err, "register instance failed, %s,
operator %s",
- instanceFlag, remoteIP)
+ log.Error(fmt.Sprintf("register instance failed, %s,
operator %s",
+ instanceFlag, remoteIP), reporter.Err)
response := &pb.RegisterInstanceResponse{
Response:
pb.CreateResponseWithSCErr(reporter.Err),
}
@@ -599,9 +599,8 @@ func (ds *DataSource) RegisterInstance(ctx context.Context,
request *pb.Register
instanceID := instance.InstanceId
data, err := json.Marshal(instance)
if err != nil {
- log.Errorf(err,
- "register instance failed, %s, instanceID %s, operator
%s",
- instanceFlag, instanceID, remoteIP)
+ log.Error(fmt.Sprintf("register instance failed, %s, instanceID
%s, operator %s",
+ instanceFlag, instanceID, remoteIP), err)
return &pb.RegisterInstanceResponse{
Response: pb.CreateResponse(pb.ErrInternal,
err.Error()),
}, err
@@ -609,7 +608,7 @@ func (ds *DataSource) RegisterInstance(ctx context.Context,
request *pb.Register
leaseID, err := client.Instance().LeaseGrant(ctx, ttl)
if err != nil {
- log.Errorf(err, "grant lease failed, %s, operator: %s",
instanceFlag, remoteIP)
+ log.Error(fmt.Sprintf("grant lease failed, %s, operator: %s",
instanceFlag, remoteIP), err)
return &pb.RegisterInstanceResponse{
Response: pb.CreateResponse(pb.ErrUnavailableBackend,
err.Error()),
}, err
@@ -632,30 +631,27 @@ func (ds *DataSource) RegisterInstance(ctx
context.Context, request *pb.Register
client.CmpNotEqual, 0)},
nil)
if err != nil {
- log.Errorf(err,
- "register instance failed, %s, instanceID %s, operator
%s",
- instanceFlag, instanceID, remoteIP)
+ log.Error(fmt.Sprintf("register instance failed, %s, instanceID
%s, operator %s",
+ instanceFlag, instanceID, remoteIP), err)
return &pb.RegisterInstanceResponse{
Response: pb.CreateResponse(pb.ErrUnavailableBackend,
err.Error()),
}, err
}
if !resp.Succeeded {
- log.Errorf(nil,
- "register instance failed, %s, instanceID %s, operator
%s: service does not exist",
- instanceFlag, instanceID, remoteIP)
+ log.Error(fmt.Sprintf("register instance failed, %s, instanceID
%s, operator %s: service does not exist",
+ instanceFlag, instanceID, remoteIP), nil)
return &pb.RegisterInstanceResponse{
Response: pb.CreateResponse(pb.ErrServiceNotExists,
"Service does not exist."),
}, nil
}
if err := reporter.ReportUsedQuota(ctx); err != nil {
- log.Errorf(err,
- "register instance failed, %s, instanceID %s, operator
%s",
- instanceFlag, instanceID, remoteIP)
+ log.Error(fmt.Sprintf("register instance failed, %s, instanceID
%s, operator %s",
+ instanceFlag, instanceID, remoteIP), err)
}
- log.Infof("register instance %s, instanceID %s, operator %s",
- instanceFlag, instanceID, remoteIP)
+ log.Info(fmt.Sprintf("register instance %s, instanceID %s, operator %s",
+ instanceFlag, instanceID, remoteIP))
return &pb.RegisterInstanceResponse{
Response: pb.CreateResponse(pb.ResponseSuccess, "Register
service instance successfully."),
InstanceId: instanceID,
@@ -671,38 +667,38 @@ func (ds *DataSource) GetInstance(ctx context.Context,
request *pb.GetOneInstanc
if len(request.ConsumerServiceId) > 0 {
service, err = serviceUtil.GetService(ctx, domainProject,
request.ConsumerServiceId)
if err != nil {
- log.Errorf(err, "get consumer failed, consumer[%s] find
provider instance[%s/%s]",
- request.ConsumerServiceId,
request.ProviderServiceId, request.ProviderInstanceId)
+ if errors.Is(err, datasource.ErrNoData) {
+ log.Debug(fmt.Sprintf("consumer does not exist
in db, consumer[%s] find provider instance[%s/%s]",
+ request.ConsumerServiceId,
request.ProviderServiceId, request.ProviderInstanceId))
+ return &pb.GetOneInstanceResponse{
+ Response:
pb.CreateResponse(pb.ErrServiceNotExists,
+ fmt.Sprintf("Consumer[%s] does
not exist.", request.ConsumerServiceId)),
+ }, nil
+ }
+ log.Error(fmt.Sprintf("get consumer failed,
consumer[%s] find provider instance[%s/%s]",
+ request.ConsumerServiceId,
request.ProviderServiceId, request.ProviderInstanceId), err)
return &pb.GetOneInstanceResponse{
Response: pb.CreateResponse(pb.ErrInternal,
err.Error()),
}, err
}
- if service == nil {
- log.Errorf(nil, "consumer does not exist, consumer[%s]
find provider instance[%s/%s]",
- request.ConsumerServiceId,
request.ProviderServiceId, request.ProviderInstanceId)
- return &pb.GetOneInstanceResponse{
- Response:
pb.CreateResponse(pb.ErrServiceNotExists,
- fmt.Sprintf("Consumer[%s] does not
exist.", request.ConsumerServiceId)),
- }, nil
- }
}
provider, err := serviceUtil.GetService(ctx, domainProject,
request.ProviderServiceId)
if err != nil {
- log.Errorf(err, "get provider failed, consumer[%s] find
provider instance[%s/%s]",
- request.ConsumerServiceId, request.ProviderServiceId,
request.ProviderInstanceId)
+ if errors.Is(err, datasource.ErrNoData) {
+ log.Debug(fmt.Sprintf("provider does not exist in db,
consumer[%s] find provider instance[%s/%s]",
+ request.ConsumerServiceId,
request.ProviderServiceId, request.ProviderInstanceId))
+ return &pb.GetOneInstanceResponse{
+ Response:
pb.CreateResponse(pb.ErrServiceNotExists,
+ fmt.Sprintf("Provider[%s] does not
exist.", request.ProviderServiceId)),
+ }, nil
+ }
+ log.Error(fmt.Sprintf("get provider failed, consumer[%s] find
provider instance[%s/%s]",
+ request.ConsumerServiceId, request.ProviderServiceId,
request.ProviderInstanceId), err)
return &pb.GetOneInstanceResponse{
Response: pb.CreateResponse(pb.ErrInternal,
err.Error()),
}, err
}
- if provider == nil {
- log.Errorf(nil, "provider does not exist, consumer[%s] find
provider instance[%s/%s]",
- request.ConsumerServiceId, request.ProviderServiceId,
request.ProviderInstanceId)
- return &pb.GetOneInstanceResponse{
- Response: pb.CreateResponse(pb.ErrServiceNotExists,
- fmt.Sprintf("Provider[%s] does not exist.",
request.ProviderServiceId)),
- }, nil
- }
findFlag := func() string {
return fmt.Sprintf("Consumer[%s][%s/%s/%s/%s] find
provider[%s][%s/%s/%s/%s] instance[%s]",
@@ -718,14 +714,14 @@ func (ds *DataSource) GetInstance(ctx context.Context,
request *pb.GetOneInstanc
ServiceId: request.ProviderServiceId, InstanceId:
request.ProviderInstanceId,
}, request.Tags, rev)
if err != nil {
- log.Errorf(err, "FindInstances.GetWithProviderID failed, %s
failed", findFlag())
+ log.Error(fmt.Sprintf("find Instances by providerID failed, %s
failed", findFlag()), err)
return &pb.GetOneInstanceResponse{
Response: pb.CreateResponse(pb.ErrInternal,
err.Error()),
}, err
}
if item == nil || len(item.Instances) == 0 {
mes := fmt.Errorf("%s failed, provider instance does not
exist", findFlag())
- log.Errorf(mes, "FindInstances.GetWithProviderID failed")
+ log.Error("find Instances by ProviderID failed", mes)
return &pb.GetOneInstanceResponse{
Response: pb.CreateResponse(pb.ErrInstanceNotExists,
mes.Error()),
}, nil
@@ -752,38 +748,38 @@ func (ds *DataSource) GetInstances(ctx context.Context,
request *pb.GetInstances
if len(request.ConsumerServiceId) > 0 {
service, err = serviceUtil.GetService(ctx, domainProject,
request.ConsumerServiceId)
if err != nil {
- log.Errorf(err, "get consumer failed, consumer[%s] find
provider instances",
- request.ConsumerServiceId,
request.ProviderServiceId)
+ if errors.Is(err, datasource.ErrNoData) {
+ log.Debug(fmt.Sprintf("consumer does not exist
in db, consumer[%s] find provider[%s] instances",
+ request.ConsumerServiceId,
request.ProviderServiceId))
+ return &pb.GetInstancesResponse{
+ Response:
pb.CreateResponse(pb.ErrServiceNotExists,
+ fmt.Sprintf("Consumer[%s] does
not exist.", request.ConsumerServiceId)),
+ }, nil
+ }
+ log.Error(fmt.Sprintf("get consumer failed,
consumer[%s] find provider[%s] instances",
+ request.ConsumerServiceId,
request.ProviderServiceId), err)
return &pb.GetInstancesResponse{
Response: pb.CreateResponse(pb.ErrInternal,
err.Error()),
}, err
}
- if service == nil {
- log.Errorf(nil, "consumer does not exist, consumer[%s]
find provider instances",
- request.ConsumerServiceId,
request.ProviderServiceId)
- return &pb.GetInstancesResponse{
- Response:
pb.CreateResponse(pb.ErrServiceNotExists,
- fmt.Sprintf("Consumer[%s] does not
exist.", request.ConsumerServiceId)),
- }, nil
- }
}
provider, err := serviceUtil.GetService(ctx, domainProject,
request.ProviderServiceId)
if err != nil {
- log.Errorf(err, "get provider failed, consumer[%s] find
provider instances",
- request.ConsumerServiceId, request.ProviderServiceId)
+ if errors.Is(err, datasource.ErrNoData) {
+ log.Debug(fmt.Sprintf("provider does not exist,
consumer[%s] find provider[%s] instances",
+ request.ConsumerServiceId,
request.ProviderServiceId))
+ return &pb.GetInstancesResponse{
+ Response:
pb.CreateResponse(pb.ErrServiceNotExists,
+ fmt.Sprintf("Provider[%s] does not
exist.", request.ProviderServiceId)),
+ }, nil
+ }
+ log.Error(fmt.Sprintf("get provider failed, consumer[%s] find
provider[%s] instances",
+ request.ConsumerServiceId, request.ProviderServiceId),
err)
return &pb.GetInstancesResponse{
Response: pb.CreateResponse(pb.ErrInternal,
err.Error()),
}, err
}
- if provider == nil {
- log.Errorf(nil, "provider does not exist, consumer[%s] find
provider instances",
- request.ConsumerServiceId, request.ProviderServiceId)
- return &pb.GetInstancesResponse{
- Response: pb.CreateResponse(pb.ErrServiceNotExists,
- fmt.Sprintf("Provider[%s] does not exist.",
request.ProviderServiceId)),
- }, nil
- }
findFlag := func() string {
return fmt.Sprintf("Consumer[%s][%s/%s/%s/%s] find
provider[%s][%s/%s/%s/%s] instances",
@@ -914,20 +910,20 @@ func (ds *DataSource) findInstance(ctx context.Context,
request *pb.FindInstance
if len(request.ConsumerServiceId) > 0 {
service, err = serviceUtil.GetService(ctx, domainProject,
request.ConsumerServiceId)
if err != nil {
- log.Errorf(err, "get consumer failed, consumer[%s] find
provider[%s/%s/%s/%s]",
- request.ConsumerServiceId, request.Environment,
request.AppId, request.ServiceName, request.VersionRule)
+ if errors.Is(err, datasource.ErrNoData) {
+ log.Debug(fmt.Sprintf("consumer does not exist,
consumer[%s] find provider[%s/%s/%s/%s]",
+ request.ConsumerServiceId,
request.Environment, request.AppId, request.ServiceName, request.VersionRule))
+ return &pb.FindInstancesResponse{
+ Response:
pb.CreateResponse(pb.ErrServiceNotExists,
+ fmt.Sprintf("Consumer[%s] does
not exist.", request.ConsumerServiceId)),
+ }, nil
+ }
+ log.Error(fmt.Sprintf("get consumer failed,
consumer[%s] find provider[%s/%s/%s/%s]",
+ request.ConsumerServiceId, request.Environment,
request.AppId, request.ServiceName, request.VersionRule), err)
return &pb.FindInstancesResponse{
Response: pb.CreateResponse(pb.ErrInternal,
err.Error()),
}, err
}
- if service == nil {
- log.Errorf(nil, "consumer does not exist, consumer[%s]
find provider[%s/%s/%s/%s]",
- request.ConsumerServiceId, request.Environment,
request.AppId, request.ServiceName, request.VersionRule)
- return &pb.FindInstancesResponse{
- Response:
pb.CreateResponse(pb.ErrServiceNotExists,
- fmt.Sprintf("Consumer[%s] does not
exist.", request.ConsumerServiceId)),
- }, nil
- }
provider.Environment = service.Environment
}
@@ -1031,7 +1027,7 @@ func (ds *DataSource) reshapeProviderKey(ctx
context.Context, provider *pb.Micro
*pb.MicroServiceKey, error) {
//维护version的规则,service name 可能是别名，所以重新获取
providerService, err := serviceUtil.GetService(ctx, provider.Tenant,
providerID)
- if providerService == nil {
+ if err != nil {
return nil, err
}
@@ -1348,23 +1344,23 @@ func (ds *DataSource) ModifySchemas(ctx
context.Context, request *pb.ModifySchem
serviceInfo, err := serviceUtil.GetService(ctx, domainProject,
serviceID)
if err != nil {
- log.Errorf(err, "modify service[%s] schemas failed, get service
failed, operator: %s",
- serviceID, remoteIP)
+ if errors.Is(err, datasource.ErrNoData) {
+ log.Debug(fmt.Sprintf("modify service[%s] schemas
failed, service does not exist in db, operator: %s",
+ serviceID, remoteIP))
+ return &pb.ModifySchemasResponse{
+ Response:
pb.CreateResponse(pb.ErrServiceNotExists, "Service does not exist."),
+ }, nil
+ }
+ log.Error(fmt.Sprintf("modify service[%s] schemas failed, get
service failed, operator: %s",
+ serviceID, remoteIP), err)
return &pb.ModifySchemasResponse{
Response: pb.CreateResponse(pb.ErrInternal,
err.Error()),
}, err
}
- if serviceInfo == nil {
- log.Errorf(nil, "modify service[%s] schemas failed, service
does not exist, operator: %s",
- serviceID, remoteIP)
- return &pb.ModifySchemasResponse{
- Response: pb.CreateResponse(pb.ErrServiceNotExists,
"Service does not exist."),
- }, nil
- }
respErr := ds.modifySchemas(ctx, domainProject, serviceInfo,
request.Schemas)
if respErr != nil {
- log.Errorf(nil, "modify service[%s] schemas failed, operator:
%s", serviceID, remoteIP)
+ log.Error(fmt.Sprintf("modify service[%s] schemas failed,
operator: %s", serviceID, remoteIP), nil)
resp := &pb.ModifySchemasResponse{
Response: pb.CreateResponseWithSCErr(respErr),
}
@@ -1498,17 +1494,17 @@ func (ds *DataSource) GetAllSchemas(ctx
context.Context, request *pb.GetAllSchem
service, err := serviceUtil.GetService(ctx, domainProject,
request.ServiceId)
if err != nil {
- log.Errorf(err, "get service[%s] all schemas failed, get
service failed", request.ServiceId)
+ if errors.Is(err, datasource.ErrNoData) {
+ log.Debug(fmt.Sprintf("get service[%s] all schemas
failed, service does not exist in db", request.ServiceId))
+ return &pb.GetAllSchemaResponse{
+ Response:
pb.CreateResponse(pb.ErrServiceNotExists, "Service does not exist."),
+ }, nil
+ }
+ log.Error(fmt.Sprintf("get service[%s] all schemas failed, get
service failed", request.ServiceId), err)
return &pb.GetAllSchemaResponse{
Response: pb.CreateResponse(pb.ErrInternal,
err.Error()),
}, err
}
- if service == nil {
- log.Errorf(nil, "get service[%s] all schemas failed, service
does not exist", request.ServiceId)
- return &pb.GetAllSchemaResponse{
- Response: pb.CreateResponse(pb.ErrServiceNotExists,
"Service does not exist."),
- }, nil
- }
schemasList := service.Schemas
if len(schemasList) == 0 {
@@ -2301,15 +2297,15 @@ func (ds *DataSource) modifySchema(ctx context.Context,
serviceID string, schema
microService, err := serviceUtil.GetService(ctx, domainProject,
serviceID)
if err != nil {
- log.Errorf(err, "modify schema[%s/%s] failed, get `microService
failed, operator: %s",
- serviceID, schemaID, remoteIP)
+ if errors.Is(err, datasource.ErrNoData) {
+ log.Debug(fmt.Sprintf("microService does not exist,
modify schema[%s/%s] failed, operator: %s",
+ serviceID, schemaID, remoteIP))
+ return pb.NewError(pb.ErrServiceNotExists, "Service
does not exist")
+ }
+ log.Error(fmt.Sprintf("modify schema[%s/%s] failed, get
`microService failed, operator: %s",
+ serviceID, schemaID, remoteIP), err)
return pb.NewError(pb.ErrInternal, err.Error())
}
- if microService == nil {
- log.Errorf(nil, "modify schema[%s/%s] failed, microService does
not exist, operator: %s",
- serviceID, schemaID, remoteIP)
- return pb.NewError(pb.ErrServiceNotExists, "Service does not
exist")
- }
var pluginOps []client.PluginOp
isExist := isExistSchemaID(microService, []*pb.Schema{schema})
@@ -2399,23 +2395,22 @@ func (ds *DataSource) DeleteServicePri(ctx
context.Context, serviceID string, fo
if serviceID == core.Service.ServiceId {
err := errors.New("not allow to delete service center")
- log.Errorf(err, "%s micro-service[%s] failed, operator: %s",
title, serviceID, remoteIP)
+ log.Error(fmt.Sprintf("%s micro-service[%s] failed, operator:
%s", title, serviceID, remoteIP), err)
return pb.CreateResponse(pb.ErrInvalidParams, err.Error()), nil
}
microservice, err := serviceUtil.GetService(ctx, domainProject,
serviceID)
if err != nil {
- log.Errorf(err, "%s micro-service[%s] failed, get service file
failed, operator: %s",
- title, serviceID, remoteIP)
+ if errors.Is(err, datasource.ErrNoData) {
+ log.Debug(fmt.Sprintf("service does not exist, %s
micro-service[%s] failed, operator: %s",
+ title, serviceID, remoteIP))
+ return pb.CreateResponse(pb.ErrServiceNotExists,
"Service does not exist."), nil
+ }
+ log.Error(fmt.Sprintf("%s micro-service[%s] failed, get service
file failed, operator: %s",
+ title, serviceID, remoteIP), err)
return pb.CreateResponse(pb.ErrInternal, err.Error()), err
}
- if microservice == nil {
- log.Errorf(err, "%s micro-service[%s] failed, service does not
exist, operator: %s",
- title, serviceID, remoteIP)
- return pb.CreateResponse(pb.ErrServiceNotExists, "Service does
not exist."), nil
- }
-
// 强制删除，则与该服务相关的信息删除，非强制删除：
如果作为该被依赖（作为provider，提供服务,且不是只存在自依赖）或者存在实例，则不能删除
if !force {
dr := serviceUtil.NewProviderDependencyRelation(ctx,
domainProject, microservice)
diff --git a/datasource/etcd/util.go b/datasource/etcd/util.go
index 4b21e9d..cfb549d 100644
--- a/datasource/etcd/util.go
+++ b/datasource/etcd/util.go
@@ -24,7 +24,6 @@ import (
"time"
"github.com/apache/servicecomb-service-center/datasource"
-
"github.com/apache/servicecomb-service-center/datasource/etcd/client"
"github.com/apache/servicecomb-service-center/datasource/etcd/kv"
"github.com/apache/servicecomb-service-center/datasource/etcd/path"
@@ -192,7 +191,7 @@ func preProcessRegisterInstance(ctx context.Context,
instance *pb.MicroServiceIn
domainProject := util.ParseDomainProject(ctx)
microservice, err := serviceUtil.GetService(ctx, domainProject,
instance.ServiceId)
- if microservice == nil || err != nil {
+ if err != nil {
return pb.NewError(pb.ErrServiceNotExists, "Invalid 'serviceID'
in request body.")
}
instance.Version = microservice.Version
diff --git a/datasource/etcd/util/dependency_query.go
b/datasource/etcd/util/dependency_query.go
index 4092f97..5e30ede 100644
--- a/datasource/etcd/util/dependency_query.go
+++ b/datasource/etcd/util/dependency_query.go
@@ -19,13 +19,14 @@ package util
import (
"context"
+ "errors"
"fmt"
"strings"
- "github.com/apache/servicecomb-service-center/datasource/etcd/path"
-
+ "github.com/apache/servicecomb-service-center/datasource"
"github.com/apache/servicecomb-service-center/datasource/etcd/client"
"github.com/apache/servicecomb-service-center/datasource/etcd/kv"
+ "github.com/apache/servicecomb-service-center/datasource/etcd/path"
"github.com/apache/servicecomb-service-center/pkg/log"
"github.com/apache/servicecomb-service-center/pkg/util"
pb "github.com/go-chassis/cari/discovery"
@@ -90,13 +91,13 @@ func (dr *DependencyRelation) GetDependencyProviders(opts
...DependencyRelationF
for _, providerID := range providerIDs {
provider, err := GetService(dr.ctx, key.Tenant,
providerID)
if err != nil {
- log.Warnf("get provider[%s/%s/%s/%s] failed",
- key.Environment, key.AppId,
key.ServiceName, key.Version)
- continue
- }
- if provider == nil {
- log.Warnf("provider[%s/%s/%s/%s] does not
exist",
- key.Environment, key.AppId,
key.ServiceName, key.Version)
+ if errors.Is(err, datasource.ErrNoData) {
+
log.Warn(fmt.Sprintf("provider[%s/%s/%s/%s] does not exist",
+ key.Environment, key.AppId,
key.ServiceName, key.Version))
+ } else {
+ log.Warn(fmt.Sprintf("get
provider[%s/%s/%s/%s] failed",
+ key.Environment, key.AppId,
key.ServiceName, key.Version))
+ }
continue
}
if op.NonSelf && providerID == dr.consumer.ServiceId {
@@ -202,12 +203,13 @@ func (dr *DependencyRelation) GetDependencyConsumers(opts
...DependencyRelationF
service, err := dr.GetServiceByMicroServiceKey(consumer)
if err != nil {
- return nil, err
- }
- if service == nil {
- log.Warnf("consumer[%s/%s/%s/%s] does not exist",
- consumer.Environment, consumer.AppId,
consumer.ServiceName, consumer.Version)
- continue
+ if errors.Is(err, datasource.ErrNoData) {
+ log.Warn(fmt.Sprintf("consumer[%s/%s/%s/%s]
does not exist",
+ consumer.Environment, consumer.AppId,
consumer.ServiceName, consumer.Version))
+ continue
+ } else {
+ return nil, err
+ }
}
if op.NonSelf && service.ServiceId == dr.provider.ServiceId {
@@ -225,9 +227,9 @@ func (dr *DependencyRelation)
GetServiceByMicroServiceKey(service *pb.MicroServi
return nil, err
}
if len(serviceID) == 0 {
- log.Warnf("service[%s/%s/%s/%s] not exist",
- service.Environment, service.AppId,
service.ServiceName, service.Version)
- return nil, nil
+ log.Warn(fmt.Sprintf("service[%s/%s/%s/%s] not exist",
+ service.Environment, service.AppId,
service.ServiceName, service.Version))
+ return nil, datasource.ErrNoData
}
return GetService(dr.ctx, service.Tenant, serviceID)
}
diff --git a/datasource/etcd/util/dependency_test.go
b/datasource/etcd/util/dependency_test.go
index f152b40..1e22306 100644
--- a/datasource/etcd/util/dependency_test.go
+++ b/datasource/etcd/util/dependency_test.go
@@ -19,8 +19,11 @@ package util_test
import (
"context"
+ "errors"
+ "github.com/stretchr/testify/assert"
"testing"
+ "github.com/apache/servicecomb-service-center/datasource"
. "github.com/apache/servicecomb-service-center/datasource/etcd/util"
"github.com/go-chassis/cari/discovery"
)
@@ -227,10 +230,13 @@ func TestDependency(t *testing.T) {
t.Fatalf(`DependencyRelation_GetDependencyConsumers failed`)
}
- _, err = dr.GetServiceByMicroServiceKey(&discovery.MicroServiceKey{})
- if err != nil {
- t.Fatalf(`DependencyRelation_getServiceByMicroServiceKey
failed`)
- }
+ t.Run("GetServiceByMicroServiceKey when service not exist", func(t
*testing.T) {
+ _, err =
dr.GetServiceByMicroServiceKey(&discovery.MicroServiceKey{})
+ if err != nil && !errors.Is(err, datasource.ErrNoData) {
+
t.Fatalf(`DependencyRelation_getServiceByMicroServiceKey failed`)
+ }
+ assert.Equal(t, datasource.ErrNoData, err, "service not exist")
+ })
_, err =
dr.GetConsumerOfSameServiceNameAndAppID(&discovery.MicroServiceKey{})
if err != nil {
diff --git a/datasource/etcd/util/microservice_util.go
b/datasource/etcd/util/microservice_util.go
index 5e71c6b..2d76525 100644
--- a/datasource/etcd/util/microservice_util.go
+++ b/datasource/etcd/util/microservice_util.go
@@ -20,12 +20,13 @@ package util
import (
"context"
"encoding/json"
+ "fmt"
"strings"
- "github.com/apache/servicecomb-service-center/datasource/etcd/path"
-
+ "github.com/apache/servicecomb-service-center/datasource"
"github.com/apache/servicecomb-service-center/datasource/etcd/client"
"github.com/apache/servicecomb-service-center/datasource/etcd/kv"
+ "github.com/apache/servicecomb-service-center/datasource/etcd/path"
"github.com/apache/servicecomb-service-center/datasource/etcd/sd"
"github.com/apache/servicecomb-service-center/pkg/log"
"github.com/apache/servicecomb-service-center/pkg/util"
@@ -45,7 +46,7 @@ func GetServiceWithRev(ctx context.Context, domain string, id
string, rev int64)
return nil, err
}
if len(serviceResp.Kvs) == 0 {
- return nil, nil
+ return nil, datasource.ErrNoData
}
return serviceResp.Kvs[0].Value.(*pb.MicroService), nil
}
@@ -58,7 +59,7 @@ func GetService(ctx context.Context, domainProject string,
serviceID string) (*p
return nil, err
}
if len(serviceResp.Kvs) == 0 {
- return nil, nil
+ return nil, datasource.ErrNoData
}
return serviceResp.Kvs[0].Value.(*pb.MicroService), nil
}
@@ -108,7 +109,7 @@ func GetAllServicesAcrossDomainProject(ctx context.Context)
(map[string][]*pb.Mi
domainProject := parts[4] + path.SPLIT + parts[5]
microService, ok := value.Value.(*pb.MicroService)
if !ok {
- log.Errorf(nil, "backend key[%s]'s value is not type
*pb.MicroService", prefix)
+ log.Error(fmt.Sprintf("backend key[%s]'s value is not
type *pb.MicroService", prefix), nil)
continue
}
services[domainProject] = append(services[domainProject],
microService)
@@ -135,8 +136,8 @@ func GetServiceID(ctx context.Context, key
*pb.MicroServiceKey) (serviceID strin
}
if len(serviceID) == 0 {
// 别名查询
- log.Debugf("could not search microservice[%s/%s/%s/%s] id by
'serviceName', now try 'alias'",
- key.Environment, key.AppId, key.ServiceName,
key.Version)
+ log.Debug(fmt.Sprintf("could not search
microservice[%s/%s/%s/%s] id by 'serviceName', now try 'alias'",
+ key.Environment, key.AppId, key.ServiceName,
key.Version))
return searchServiceIDFromAlias(ctx, key)
}
return
@@ -256,7 +257,7 @@ func UpdateService(domainProject string, serviceID string,
service *pb.MicroServ
key := path.GenerateServiceKey(domainProject, serviceID)
data, err := json.Marshal(service)
if err != nil {
- log.Errorf(err, "marshal service file failed")
+ log.Error("marshal service file failed", err)
return
}
opt = client.OpPut(client.WithStrKey(key), client.WithValue(data))
diff --git a/datasource/etcd/util/rule_util.go
b/datasource/etcd/util/rule_util.go
index 8666f4c..f8fb9e2 100644
--- a/datasource/etcd/util/rule_util.go
+++ b/datasource/etcd/util/rule_util.go
@@ -19,15 +19,16 @@ package util
import (
"context"
+ "errors"
"fmt"
"reflect"
"regexp"
"strings"
- "github.com/apache/servicecomb-service-center/datasource/etcd/path"
-
+ "github.com/apache/servicecomb-service-center/datasource"
"github.com/apache/servicecomb-service-center/datasource/etcd/client"
"github.com/apache/servicecomb-service-center/datasource/etcd/kv"
+ "github.com/apache/servicecomb-service-center/datasource/etcd/path"
"github.com/apache/servicecomb-service-center/pkg/log"
"github.com/apache/servicecomb-service-center/pkg/util"
apt "github.com/apache/servicecomb-service-center/server/core"
@@ -42,7 +43,7 @@ type RuleFilter struct {
func (rf *RuleFilter) Filter(ctx context.Context, consumerID string) (bool,
error) {
copyCtx := util.WithCacheOnly(util.CloneContext(ctx))
consumer, err := GetService(copyCtx, rf.DomainProject, consumerID)
- if consumer == nil {
+ if err != nil {
return false, err
}
@@ -259,20 +260,20 @@ func Accessible(ctx context.Context, consumerID string,
providerID string) *disc
consumerService, err := GetService(ctx, domainProject, consumerID)
if err != nil {
+ if errors.Is(err, datasource.ErrNoData) {
+ return
discovery.NewError(discovery.ErrServiceNotExists, "consumer serviceID is
invalid")
+ }
return discovery.NewErrorf(discovery.ErrInternal, "An error
occurred in query consumer(%s)", err.Error())
}
- if consumerService == nil {
- return discovery.NewError(discovery.ErrServiceNotExists,
"consumer serviceID is invalid")
- }
// 跨应用权限
providerService, err := GetService(ctx, targetDomainProject, providerID)
if err != nil {
+ if errors.Is(err, datasource.ErrNoData) {
+ return
discovery.NewError(discovery.ErrServiceNotExists, "provider serviceID is
invalid")
+ }
return discovery.NewErrorf(discovery.ErrInternal, "An error
occurred in query provider(%s)", err.Error())
}
- if providerService == nil {
- return discovery.NewError(discovery.ErrServiceNotExists,
"provider serviceID is invalid")
- }
err = AllowAcrossDimension(ctx, providerService, consumerService)
if err != nil {
diff --git a/datasource/etcd/util/rule_util_test.go
b/datasource/etcd/util/rule_util_test.go
index ba72871..0312eff 100644
--- a/datasource/etcd/util/rule_util_test.go
+++ b/datasource/etcd/util/rule_util_test.go
@@ -19,9 +19,12 @@ package util_test
import (
"context"
+ "errors"
+ "github.com/stretchr/testify/assert"
"net/http"
"testing"
+ "github.com/apache/servicecomb-service-center/datasource"
. "github.com/apache/servicecomb-service-center/datasource/etcd/util"
"github.com/apache/servicecomb-service-center/pkg/util"
"github.com/go-chassis/cari/discovery"
@@ -32,21 +35,31 @@ func TestRuleFilter_Filter(t *testing.T) {
DomainProject: "",
ProviderRules: []*discovery.ServiceRule{},
}
- _, err := rf.Filter(context.Background(), "")
- if err != nil {
- t.Fatalf("RuleFilter Filter failed")
- }
- _, _, err = rf.FilterAll(context.Background(), []string{""})
- if err != nil {
- t.Fatalf("RuleFilter FilterAll failed")
- }
+ var err error
+ t.Run("when there is no such a customer in db", func(t *testing.T) {
+ _, err = rf.Filter(context.Background(), "")
+ if err != nil && !errors.Is(err, datasource.ErrNoData) {
+ t.Fatalf("RuleFilter Filter failed")
+ }
+ assert.Equal(t, datasource.ErrNoData, err, "no data found")
+ })
+ t.Run("FilterAll when customer not exist", func(t *testing.T) {
+ _, _, err = rf.FilterAll(context.Background(), []string{""})
+ if err != nil && !errors.Is(err, datasource.ErrNoData) {
+ t.Fatalf("RuleFilter FilterAll failed")
+ }
+ assert.Equal(t, nil, err, "no customer found err is nil")
+ })
rf.ProviderRules = []*discovery.ServiceRule{
{},
}
- _, _, err = rf.FilterAll(context.Background(), []string{""})
- if err != nil {
- t.Fatalf("RuleFilter FilterAll failed")
- }
+ t.Run("FilterAll when ProviderRules not nil and service not exist",
func(t *testing.T) {
+ _, _, err = rf.FilterAll(context.Background(), []string{""})
+ if err != nil && !errors.Is(err, datasource.ErrNoData) {
+ t.Fatalf("RuleFilter FilterAll failed")
+ }
+ assert.Equal(t, datasource.ErrNoData, err, "no customer found
when FilterAll")
+ })
}
func TestGetRulesUtil(t *testing.T) {
diff --git a/datasource/etcd/util/util_suite_test.go
b/datasource/etcd/util/util_suite_test.go
index 4cb7774..ac69588 100644
--- a/datasource/etcd/util/util_suite_test.go
+++ b/datasource/etcd/util/util_suite_test.go
@@ -20,8 +20,11 @@ package util_test
// initialize
import (
"context"
+ "errors"
+ "github.com/stretchr/testify/assert"
"testing"
+ "github.com/apache/servicecomb-service-center/datasource"
"github.com/apache/servicecomb-service-center/datasource/etcd/client"
_ "github.com/apache/servicecomb-service-center/test"
@@ -66,10 +69,14 @@ func TestFindServiceIds(t *testing.T) {
}
func TestGetService(t *testing.T) {
- _, err := serviceUtil.GetService(context.Background(), "", "")
- if err != nil {
- t.Fatalf("TestGetService failed")
- }
+ var err error
+ t.Run("when there is no such a service in db", func(t *testing.T) {
+ _, err = serviceUtil.GetService(context.Background(), "", "")
+ if err != nil && !errors.Is(err, datasource.ErrNoData) {
+ t.Fatalf("TestGetService failed")
+ }
+ assert.Equal(t, datasource.ErrNoData, err)
+ })
_, err = serviceUtil.GetServicesByDomainProject(context.Background(),
"")
if err != nil {
@@ -81,10 +88,13 @@ func TestGetService(t *testing.T) {
t.Fatalf("TestGetService failed")
}
- _, err = serviceUtil.GetServiceWithRev(context.Background(), "", "", 0)
- if err != nil {
- t.Fatalf("TestGetService failed")
- }
+ t.Run("when there is no such a service in db", func(t *testing.T) {
+ _, err = serviceUtil.GetServiceWithRev(context.Background(),
"", "", 0)
+ if err != nil && !errors.Is(err, datasource.ErrNoData) {
+ t.Fatalf("TestGetService failed")
+ }
+ assert.Equal(t, datasource.ErrNoData, err)
+ })
//_, err = serviceUtil.GetServiceWithRev(context.Background(), "", "",
1)
//if err != nil {
diff --git a/datasource/mongo/client/errortypes.go
b/datasource/mongo/client/errortypes.go
index 9d7311a..3c86420 100644
--- a/datasource/mongo/client/errortypes.go
+++ b/datasource/mongo/client/errortypes.go
@@ -43,6 +43,6 @@ func IsDuplicateKey(err error) bool {
return false
}
-func IsNoneDoc(err error) bool {
+func IsNoneDocErr(err error) bool {
return err == ErrNoDocuments
}
diff --git a/datasource/mongo/dep.go b/datasource/mongo/dep.go
index 0566c5b..fe0467d 100644
--- a/datasource/mongo/dep.go
+++ b/datasource/mongo/dep.go
@@ -19,6 +19,7 @@ package mongo
import (
"context"
+ "errors"
"fmt"
pb "github.com/go-chassis/cari/discovery"
@@ -36,15 +37,15 @@ func (ds *DataSource) SearchProviderDependency(ctx
context.Context, request *pb.
filter := GeneratorServiceFilter(ctx, providerServiceID)
provider, err := GetService(ctx, filter)
if err != nil {
- log.Error("GetProviderDependencies failed, provider is
"+providerServiceID, err)
+ if errors.Is(err, datasource.ErrNoData) {
+ log.Debug(fmt.Sprintf("query provider service failed,
there is no provider %s in db", providerServiceID))
+ return &pb.GetProDependenciesResponse{
+ Response:
pb.CreateResponse(pb.ErrServiceNotExists, "Provider does not exist"),
+ }, nil
+ }
+ log.Error(fmt.Sprintf("query provider from db error, provider
is %s", providerServiceID), err)
return nil, err
}
- if provider == nil {
- log.Error(fmt.Sprintf("GetProviderDependencies failed for
provider %s", providerServiceID), err)
- return &pb.GetProDependenciesResponse{
- Response: pb.CreateResponse(pb.ErrServiceNotExists,
"Provider does not exist"),
- }, nil
- }
dr := NewProviderDependencyRelation(ctx, domainProject,
provider.ServiceInfo)
services, err :=
dr.GetDependencyConsumers(ToDependencyFilterOptions(request)...)
@@ -69,20 +70,20 @@ func (ds *DataSource) SearchConsumerDependency(ctx
context.Context, request *pb.
filter := GeneratorServiceFilter(ctx, consumerID)
consumer, err := GetService(ctx, filter)
if err != nil {
- log.Error(fmt.Sprintf("GetConsumerDependencies failed, consumer
is %s", consumerID), err)
+ if errors.Is(err, datasource.ErrNoData) {
+ log.Debug(fmt.Sprintf("query consumer service failed,
there is no consumer %s in db", consumerID))
+ return &pb.GetConDependenciesResponse{
+ Response:
pb.CreateResponse(pb.ErrServiceNotExists, "Consumer does not exist"),
+ }, nil
+ }
+ log.Error(fmt.Sprintf("query consumer from db error, consumer
is %s", consumerID), err)
return nil, err
}
- if consumer == nil {
- log.Error(fmt.Sprintf("GetConsumerDependencies failed for
consumer %s does not exist", consumerID), err)
- return &pb.GetConDependenciesResponse{
- Response: pb.CreateResponse(pb.ErrServiceNotExists,
"Consumer does not exist"),
- }, nil
- }
dr := NewConsumerDependencyRelation(ctx, domainProject,
consumer.ServiceInfo)
services, err :=
dr.GetDependencyProviders(ToDependencyFilterOptions(request)...)
if err != nil {
- log.Error(fmt.Sprintf("GetConsumerDependencies failed, consumer
is %s/%s/%s/%s",
+ log.Error(fmt.Sprintf("query consumer failed, consumer is
%s/%s/%s/%s",
consumer.ServiceInfo.Environment,
consumer.ServiceInfo.AppId, consumer.ServiceInfo.ServiceName,
consumer.ServiceInfo.Version), err)
return &pb.GetConDependenciesResponse{
Response: pb.CreateResponse(pb.ErrInternal,
err.Error()),
@@ -90,7 +91,7 @@ func (ds *DataSource) SearchConsumerDependency(ctx
context.Context, request *pb.
}
return &pb.GetConDependenciesResponse{
- Response: pb.CreateResponse(pb.ResponseSuccess, "Get all
providers successfully."),
+ Response: pb.CreateResponse(pb.ResponseSuccess, "get all
providers successfully."),
Providers: services,
}, nil
}
diff --git a/datasource/mongo/dependency_query.go
b/datasource/mongo/dependency_query.go
index 8025aba..db91d47 100644
--- a/datasource/mongo/dependency_query.go
+++ b/datasource/mongo/dependency_query.go
@@ -19,9 +19,11 @@ package mongo
import (
"context"
+ "errors"
"fmt"
"strings"
+ "github.com/apache/servicecomb-service-center/datasource"
"github.com/apache/servicecomb-service-center/datasource/mongo/client"
"github.com/apache/servicecomb-service-center/pkg/log"
pb "github.com/go-chassis/cari/discovery"
@@ -86,13 +88,13 @@ func (dr *DependencyRelation) GetDependencyProviders(opts
...DependencyRelationF
filter := GeneratorServiceFilter(dr.ctx, providerID)
provider, err := GetService(dr.ctx, filter)
if err != nil {
- log.Warn(fmt.Sprintf("get provider[%s/%s/%s/%s]
failed",
- key.Environment, key.AppId,
key.ServiceName, key.Version))
- continue
- }
- if provider == nil {
- log.Warn(fmt.Sprintf("provider[%s/%s/%s/%s]
does not exist",
- key.Environment, key.AppId,
key.ServiceName, key.Version))
+ if errors.Is(err, datasource.ErrNoData) {
+
log.Warn(fmt.Sprintf("provider[%s/%s/%s/%s] does not exist",
+ key.Environment, key.AppId,
key.ServiceName, key.Version))
+ } else {
+ log.Warn(fmt.Sprintf("get
provider[%s/%s/%s/%s] failed",
+ key.Environment, key.AppId,
key.ServiceName, key.Version))
+ }
continue
}
if op.NonSelf && providerID == dr.consumer.ServiceId {
diff --git a/datasource/mongo/event/instance_event_handler.go
b/datasource/mongo/event/instance_event_handler.go
index e9ecf12..c870b8a 100644
--- a/datasource/mongo/event/instance_event_handler.go
+++ b/datasource/mongo/event/instance_event_handler.go
@@ -19,6 +19,7 @@ package event
import (
"context"
+ "errors"
"fmt"
"github.com/apache/servicecomb-service-center/datasource"
@@ -56,11 +57,11 @@ func (h InstanceEventHandler) OnEvent(evt sd.MongoEvent) {
log.Info("get cached service failed, then get from database")
service, err := mongo.GetService(context.Background(),
bson.M{"serviceinfo.serviceid": providerID})
if err != nil {
- log.Error("query database error", err)
- return
- }
- if service == nil {
- log.Warn(fmt.Sprintf("there is no service with id [%s]
in the database", providerID))
+ if errors.Is(err, datasource.ErrNoData) {
+ log.Warn(fmt.Sprintf("there is no service with
id [%s] in the database", providerID))
+ } else {
+ log.Error("query database error", err)
+ }
return
}
microService = service.ServiceInfo // service in the cache may
not ready, query from db once
diff --git a/datasource/mongo/ms.go b/datasource/mongo/ms.go
index 6911e66..d60a9d8 100644
--- a/datasource/mongo/ms.go
+++ b/datasource/mongo/ms.go
@@ -173,19 +173,20 @@ func (ds *DataSource) GetService(ctx context.Context,
request *discovery.GetServ
*discovery.GetServiceResponse, error) {
svc, err := GetServiceByID(ctx, request.ServiceId)
if err != nil {
+ if errors.Is(err, datasource.ErrNoData) {
+ log.Debug(fmt.Sprintf("service %s not exist in db",
request.ServiceId))
+ return &discovery.GetServiceResponse{
+ Response:
discovery.CreateResponse(discovery.ErrServiceNotExists, "Service not exist."),
+ }, nil
+ }
log.Error(fmt.Sprintf("failed to get single service %s from
mongo", request.ServiceId), err)
return &discovery.GetServiceResponse{
Response:
discovery.CreateResponse(discovery.ErrInternal, "get service data from mongodb
failed."),
}, err
}
- if svc != nil {
- return &discovery.GetServiceResponse{
- Response:
discovery.CreateResponse(discovery.ResponseSuccess, "Get service
successfully."),
- Service: svc.ServiceInfo,
- }, nil
- }
return &discovery.GetServiceResponse{
- Response:
discovery.CreateResponse(discovery.ErrServiceNotExists, "Service not exist."),
+ Response: discovery.CreateResponse(discovery.ResponseSuccess,
"Get service successfully."),
+ Service: svc.ServiceInfo,
}, nil
}
@@ -266,17 +267,17 @@ func (ds *DataSource) DelServicePri(ctx context.Context,
serviceID string, force
log.Error(fmt.Sprintf("%s micro-service %s failed, operator:
%s", title, serviceID, remoteIP), ErrNotAllowDeleteSC)
return discovery.CreateResponse(discovery.ErrInvalidParams,
ErrNotAllowDeleteSC.Error()), nil
}
- microservice, err := GetService(ctx, GeneratorServiceFilter(ctx,
serviceID))
+ _, err := GetService(ctx, GeneratorServiceFilter(ctx, serviceID))
if err != nil {
+ if errors.Is(err, datasource.ErrNoData) {
+ log.Debug(fmt.Sprintf("%s micro-service %s failed,
service does not exist, operator: %s",
+ title, serviceID, remoteIP))
+ return
discovery.CreateResponse(discovery.ErrServiceNotExists, "Service does not
exist."), nil
+ }
log.Error(fmt.Sprintf("%s micro-service %s failed, get service
file failed, operator: %s",
title, serviceID, remoteIP), err)
return discovery.CreateResponse(discovery.ErrInternal,
err.Error()), err
}
- if microservice == nil {
- log.Error(fmt.Sprintf("%s micro-service %s failed, service does
not exist, operator: %s",
- title, serviceID, remoteIP), err)
- return discovery.CreateResponse(discovery.ErrServiceNotExists,
"Service does not exist."), nil
- }
// 强制删除，则与该服务相关的信息删除，非强制删除：
如果作为该被依赖（作为provider，提供服务,且不是只存在自依赖）或者存在实例，则不能删除
if !force {
//todo wait for dep interface
@@ -347,15 +348,15 @@ func (ds *DataSource) GetServiceDetail(ctx
context.Context, request *discovery.G
*discovery.GetServiceDetailResponse, error) {
mgSvc, err := GetService(ctx, GeneratorServiceFilter(ctx,
request.ServiceId))
if err != nil {
+ if errors.Is(err, datasource.ErrNoData) {
+ return &discovery.GetServiceDetailResponse{
+ Response:
discovery.CreateResponse(discovery.ErrServiceNotExists, "Service does not
exist."),
+ }, nil
+ }
return &discovery.GetServiceDetailResponse{
Response:
discovery.CreateResponse(discovery.ErrInternal, err.Error()),
}, err
}
- if mgSvc == nil {
- return &discovery.GetServiceDetailResponse{
- Response:
discovery.CreateResponse(discovery.ErrServiceNotExists, "Service does not
exist."),
- }, nil
- }
svc := mgSvc.ServiceInfo
key := &discovery.MicroServiceKey{
Environment: svc.Environment,
@@ -460,14 +461,15 @@ func (ds *DataSource) AddTags(ctx context.Context,
request *discovery.AddService
remoteIP := util.GetIPFromContext(ctx)
service, err := GetService(ctx, GeneratorServiceFilter(ctx,
request.ServiceId))
if err != nil {
+ if errors.Is(err, datasource.ErrNoData) {
+ log.Debug(fmt.Sprintf("service %s not exist in db",
request.ServiceId))
+ return &discovery.AddServiceTagsResponse{Response:
discovery.CreateResponse(discovery.ErrServiceNotExists, "Service not exist")},
nil
+ }
log.Error(fmt.Sprintf("failed to add tags for service %s for
get service failed", request.ServiceId), err)
return &discovery.AddServiceTagsResponse{
Response:
discovery.CreateResponse(discovery.ErrInternal, "Failed to check service
exist"),
}, nil
}
- if service == nil {
- return &discovery.AddServiceTagsResponse{Response:
discovery.CreateResponse(discovery.ErrServiceNotExists, "Service not exist")},
nil
- }
tags := request.Tags
res := quota.NewApplyQuotaResource(quota.TagQuotaType,
util.ParseDomainProject(ctx), request.ServiceId, int64(len(tags)))
rst := quota.Apply(ctx, res)
@@ -504,16 +506,17 @@ func (ds *DataSource) AddTags(ctx context.Context,
request *discovery.AddService
func (ds *DataSource) GetTags(ctx context.Context, request
*discovery.GetServiceTagsRequest) (*discovery.GetServiceTagsResponse, error) {
svc, err := GetService(ctx, GeneratorServiceFilter(ctx,
request.ServiceId))
if err != nil {
+ if errors.Is(err, datasource.ErrNoData) {
+ log.Debug(fmt.Sprintf("service %s not exist in db",
request.ServiceId))
+ return &discovery.GetServiceTagsResponse{
+ Response:
discovery.CreateResponse(discovery.ErrServiceNotExists, "Service does not
exist"),
+ }, nil
+ }
log.Error(fmt.Sprintf("failed to get service %s tags",
request.ServiceId), err)
return &discovery.GetServiceTagsResponse{
Response:
discovery.CreateResponse(discovery.ErrInternal, err.Error()),
}, nil
}
- if svc == nil {
- return &discovery.GetServiceTagsResponse{
- Response:
discovery.CreateResponse(discovery.ErrServiceNotExists, "Service does not
exist"),
- }, nil
- }
return &discovery.GetServiceTagsResponse{
Response: discovery.CreateResponse(discovery.ResponseSuccess,
"Get service tags successfully."),
Tags: svc.Tags,
@@ -523,16 +526,17 @@ func (ds *DataSource) GetTags(ctx context.Context,
request *discovery.GetService
func (ds *DataSource) UpdateTag(ctx context.Context, request
*discovery.UpdateServiceTagRequest) (*discovery.UpdateServiceTagResponse,
error) {
svc, err := GetService(ctx, GeneratorServiceFilter(ctx,
request.ServiceId))
if err != nil {
+ if errors.Is(err, datasource.ErrNoData) {
+ log.Debug(fmt.Sprintf("service %s not exist in db",
request.ServiceId))
+ return &discovery.UpdateServiceTagResponse{
+ Response:
discovery.CreateResponse(discovery.ErrServiceNotExists, "Service does not
exist"),
+ }, nil
+ }
log.Error(fmt.Sprintf("failed to get %s tags",
request.ServiceId), err)
return &discovery.UpdateServiceTagResponse{
Response:
discovery.CreateResponse(discovery.ErrInternal, err.Error()),
}, nil
}
- if svc == nil {
- return &discovery.UpdateServiceTagResponse{
- Response:
discovery.CreateResponse(discovery.ErrServiceNotExists, "Service does not
exist"),
- }, nil
- }
dataTags := svc.Tags
if len(dataTags) > 0 {
if _, ok := dataTags[request.Key]; !ok {
@@ -562,16 +566,17 @@ func (ds *DataSource) UpdateTag(ctx context.Context,
request *discovery.UpdateSe
func (ds *DataSource) DeleteTags(ctx context.Context, request
*discovery.DeleteServiceTagsRequest) (*discovery.DeleteServiceTagsResponse,
error) {
svc, err := GetService(ctx, GeneratorServiceFilter(ctx,
request.ServiceId))
if err != nil {
+ if errors.Is(err, datasource.ErrNoData) {
+ log.Debug(fmt.Sprintf("service %s not exist in db",
request.ServiceId))
+ return &discovery.DeleteServiceTagsResponse{
+ Response:
discovery.CreateResponse(discovery.ErrServiceNotExists, "Service does not
exist"),
+ }, nil
+ }
log.Error(fmt.Sprintf("failed to get service %s tags",
request.ServiceId), err)
return &discovery.DeleteServiceTagsResponse{
Response:
discovery.CreateResponse(discovery.ErrInternal, err.Error()),
}, nil
}
- if svc == nil {
- return &discovery.DeleteServiceTagsResponse{
- Response:
discovery.CreateResponse(discovery.ErrServiceNotExists, "Service does not
exist"),
- }, nil
- }
dataTags := svc.Tags
newTags := make(map[string]string, len(dataTags))
for k, v := range dataTags {
@@ -632,16 +637,17 @@ func (ds *DataSource) GetSchema(ctx context.Context,
request *discovery.GetSchem
func (ds *DataSource) GetAllSchemas(ctx context.Context, request
*discovery.GetAllSchemaRequest) (*discovery.GetAllSchemaResponse, error) {
svc, err := GetService(ctx, GeneratorServiceFilter(ctx,
request.ServiceId))
if err != nil {
+ if errors.Is(err, datasource.ErrNoData) {
+ log.Debug(fmt.Sprintf("service %s not exist in db",
request.ServiceId))
+ return &discovery.GetAllSchemaResponse{
+ Response:
discovery.CreateResponse(discovery.ErrServiceNotExists, "GetAllSchemas failed
for service not exist"),
+ }, nil
+ }
log.Error(fmt.Sprintf("get service[%s] all schemas failed, get
service failed", request.ServiceId), err)
return &discovery.GetAllSchemaResponse{
Response:
discovery.CreateResponse(discovery.ErrInternal, err.Error()),
}, err
}
- if svc == nil {
- return &discovery.GetAllSchemaResponse{
- Response:
discovery.CreateResponse(discovery.ErrServiceNotExists, "GetAllSchemas failed
for service not exist"),
- }, nil
- }
schemasList := svc.ServiceInfo.Schemas
if len(schemasList) == 0 {
return &discovery.GetAllSchemaResponse{
@@ -764,11 +770,11 @@ func (ds *DataSource) ModifySchema(ctx context.Context,
request *discovery.Modif
func (ds *DataSource) ModifySchemas(ctx context.Context, request
*discovery.ModifySchemasRequest) (*discovery.ModifySchemasResponse, error) {
svc, err := GetService(ctx, GeneratorServiceFilter(ctx,
request.ServiceId))
if err != nil {
+ if errors.Is(err, datasource.ErrNoData) {
+ return &discovery.ModifySchemasResponse{Response:
discovery.CreateResponse(discovery.ErrServiceNotExists, "Service not exist")},
nil
+ }
return &discovery.ModifySchemasResponse{Response:
discovery.CreateResponse(discovery.ErrInternal, err.Error())}, err
}
- if svc == nil {
- return &discovery.ModifySchemasResponse{Response:
discovery.CreateResponse(discovery.ErrServiceNotExists, "Service not exist")},
nil
- }
respErr := ds.modifySchemas(ctx, svc.ServiceInfo, request.Schemas)
if respErr != nil {
resp := &discovery.ModifySchemasResponse{
@@ -905,11 +911,11 @@ func (ds *DataSource) modifySchema(ctx context.Context,
serviceID string, schema
remoteIP := util.GetIPFromContext(ctx)
svc, err := GetService(ctx, GeneratorServiceFilter(ctx, serviceID))
if err != nil {
+ if errors.Is(err, datasource.ErrNoData) {
+ return
discovery.NewError(discovery.ErrServiceNotExists, "Service does not exist.")
+ }
return discovery.NewError(discovery.ErrInternal, err.Error())
}
- if svc == nil {
- return discovery.NewError(discovery.ErrServiceNotExists,
"Service does not exist.")
- }
microservice := svc.ServiceInfo
var isExist bool
for _, sid := range microservice.Schemas {
@@ -1188,7 +1194,7 @@ func GetService(ctx context.Context, filter bson.M)
(*Service, error) {
var svc *Service
if findRes.Err() != nil {
//not get any service,not db err
- return nil, nil
+ return nil, datasource.ErrNoData
}
err = findRes.Decode(&svc)
if err != nil {
@@ -1529,39 +1535,39 @@ func (ds *DataSource) GetInstance(ctx context.Context,
request *discovery.GetOne
filter := GeneratorServiceFilter(ctx, request.ConsumerServiceId)
service, err = GetService(ctx, filter)
if err != nil {
+ if errors.Is(err, datasource.ErrNoData) {
+ log.Debug(fmt.Sprintf("consumer does not exist,
consumer %s find provider instance %s %s",
+ request.ConsumerServiceId,
request.ProviderServiceId, request.ProviderInstanceId))
+ return &discovery.GetOneInstanceResponse{
+ Response:
discovery.CreateResponse(discovery.ErrServiceNotExists,
+ fmt.Sprintf("Consumer[%s] does
not exist.", request.ConsumerServiceId)),
+ }, nil
+ }
log.Error(fmt.Sprintf(" get consumer failed, consumer
%s find provider instance %s",
request.ConsumerServiceId,
request.ProviderInstanceId), err)
return &discovery.GetOneInstanceResponse{
Response:
discovery.CreateResponse(discovery.ErrInternal, err.Error()),
}, err
}
- if service == nil {
- log.Error(fmt.Sprintf("consumer does not exist,
consumer %s find provider instance %s %s",
- request.ConsumerServiceId,
request.ProviderServiceId, request.ProviderInstanceId), err)
- return &discovery.GetOneInstanceResponse{
- Response:
discovery.CreateResponse(discovery.ErrServiceNotExists,
- fmt.Sprintf("Consumer[%s] does not
exist.", request.ConsumerServiceId)),
- }, nil
- }
}
filter := GeneratorServiceFilter(ctx, request.ProviderServiceId)
provider, err := GetService(ctx, filter)
if err != nil {
+ if errors.Is(err, datasource.ErrNoData) {
+ log.Debug(fmt.Sprintf("provider does not exist,
consumer %s find provider instance %s %s",
+ request.ConsumerServiceId,
request.ProviderServiceId, request.ProviderInstanceId))
+ return &discovery.GetOneInstanceResponse{
+ Response:
discovery.CreateResponse(discovery.ErrServiceNotExists,
+ fmt.Sprintf("Provider[%s] does not
exist.", request.ProviderServiceId)),
+ }, nil
+ }
log.Error(fmt.Sprintf("get provider failed, consumer %s find
provider instance %s %s",
request.ConsumerServiceId, request.ProviderServiceId,
request.ProviderInstanceId), err)
return &discovery.GetOneInstanceResponse{
Response:
discovery.CreateResponse(discovery.ErrInternal, err.Error()),
}, err
}
- if provider == nil {
- log.Error(fmt.Sprintf("provider does not exist, consumer %s
find provider instance %s %s",
- request.ConsumerServiceId, request.ProviderServiceId,
request.ProviderInstanceId), err)
- return &discovery.GetOneInstanceResponse{
- Response:
discovery.CreateResponse(discovery.ErrServiceNotExists,
- fmt.Sprintf("Provider[%s] does not exist.",
request.ProviderServiceId)),
- }, nil
- }
findFlag := func() string {
return fmt.Sprintf("consumer[%s][%s/%s/%s/%s] find
provider[%s][%s/%s/%s/%s] instance[%s]",
request.ConsumerServiceId,
service.ServiceInfo.Environment, service.ServiceInfo.AppId,
service.ServiceInfo.ServiceName, service.ServiceInfo.Version,
@@ -1608,38 +1614,38 @@ func (ds *DataSource) GetInstances(ctx context.Context,
request *discovery.GetIn
if len(request.ConsumerServiceId) > 0 {
service, err = GetServiceByID(ctx, request.ConsumerServiceId)
if err != nil {
+ if errors.Is(err, datasource.ErrNoData) {
+ log.Debug(fmt.Sprintf("consumer does not exist,
consumer %s find provider %s instances",
+ request.ConsumerServiceId,
request.ProviderServiceId))
+ return &discovery.GetInstancesResponse{
+ Response:
discovery.CreateResponse(discovery.ErrServiceNotExists,
+ fmt.Sprintf("Consumer[%s] does
not exist.", request.ConsumerServiceId)),
+ }, nil
+ }
log.Error(fmt.Sprintf("get consumer failed, consumer %s
find provider %s instances",
request.ConsumerServiceId,
request.ProviderServiceId), err)
return &discovery.GetInstancesResponse{
Response:
discovery.CreateResponse(discovery.ErrInternal, err.Error()),
}, err
}
- if service == nil {
- log.Error(fmt.Sprintf("consumer does not exist,
consumer %s find provider %s instances",
- request.ConsumerServiceId,
request.ProviderServiceId), err)
- return &discovery.GetInstancesResponse{
- Response:
discovery.CreateResponse(discovery.ErrServiceNotExists,
- fmt.Sprintf("Consumer[%s] does not
exist.", request.ConsumerServiceId)),
- }, nil
- }
}
provider, err := GetServiceByID(ctx, request.ProviderServiceId)
if err != nil {
+ if errors.Is(err, datasource.ErrNoData) {
+ log.Debug(fmt.Sprintf("provider does not exist,
consumer %s find provider %s instances",
+ request.ConsumerServiceId,
request.ProviderServiceId))
+ return &discovery.GetInstancesResponse{
+ Response:
discovery.CreateResponse(discovery.ErrServiceNotExists,
+ fmt.Sprintf("provider[%s] does not
exist.", request.ProviderServiceId)),
+ }, nil
+ }
log.Error(fmt.Sprintf("get provider failed, consumer %s find
provider instances %s",
request.ConsumerServiceId, request.ProviderServiceId),
err)
return &discovery.GetInstancesResponse{
Response:
discovery.CreateResponse(discovery.ErrInternal, err.Error()),
}, err
}
- if provider == nil {
- log.Error(fmt.Sprintf("provider does not exist, consumer %s
find provider %s instances",
- request.ConsumerServiceId, request.ProviderServiceId),
err)
- return &discovery.GetInstancesResponse{
- Response:
discovery.CreateResponse(discovery.ErrServiceNotExists,
- fmt.Sprintf("provider[%s] does not exist.",
request.ProviderServiceId)),
- }, nil
- }
findFlag := func() string {
return fmt.Sprintf("consumer[%s][%s/%s/%s/%s] find
provider[%s][%s/%s/%s/%s] instances",
@@ -2052,20 +2058,20 @@ func (ds *DataSource) findInstance(ctx context.Context,
request *discovery.FindI
filter := GeneratorServiceFilter(ctx, request.ConsumerServiceId)
service, err = GetService(ctx, filter)
if err != nil {
+ if errors.Is(err, datasource.ErrNoData) {
+ log.Debug(fmt.Sprintf("consumer does not exist,
consumer %s find provider %s/%s/%s/%s",
+ request.ConsumerServiceId,
request.Environment, request.AppId, request.ServiceName, request.VersionRule))
+ return &discovery.FindInstancesResponse{
+ Response:
discovery.CreateResponse(discovery.ErrServiceNotExists,
+ fmt.Sprintf("Consumer[%s] does
not exist.", request.ConsumerServiceId)),
+ }, nil
+ }
log.Error(fmt.Sprintf("get consumer failed, consumer %s
find provider %s/%s/%s/%s",
request.ConsumerServiceId, request.Environment,
request.AppId, request.ServiceName, request.VersionRule), err)
return &discovery.FindInstancesResponse{
Response:
discovery.CreateResponse(discovery.ErrInternal, err.Error()),
}, err
}
- if service == nil {
- log.Error(fmt.Sprintf("consumer does not exist,
consumer %s find provider %s/%s/%s/%s",
- request.ConsumerServiceId, request.Environment,
request.AppId, request.ServiceName, request.VersionRule), err)
- return &discovery.FindInstancesResponse{
- Response:
discovery.CreateResponse(discovery.ErrServiceNotExists,
- fmt.Sprintf("Consumer[%s] does not
exist.", request.ConsumerServiceId)),
- }, nil
- }
provider.Environment = service.ServiceInfo.Environment
}
@@ -2142,7 +2148,7 @@ func (ds *DataSource) reshapeProviderKey(ctx
context.Context, provider *discover
//维护version的规则,service name 可能是别名，所以重新获取
filter := GeneratorServiceFilter(ctx, providerID)
providerService, err := GetService(ctx, filter)
- if providerService == nil {
+ if err != nil {
return nil, err
}
@@ -2369,7 +2375,7 @@ func preProcessRegisterInstance(ctx context.Context,
instance *discovery.MicroSe
filter := GeneratorServiceFilter(ctx, instance.ServiceId)
microservice, err := GetService(ctx, filter)
- if microservice == nil || err != nil {
+ if err != nil {
return discovery.NewError(discovery.ErrServiceNotExists,
"invalid 'serviceID' in request body.")
}
instance.Version = microservice.ServiceInfo.Version
diff --git a/server/broker/service.go b/server/broker/service.go
index d7055a8..58eec98 100644
--- a/server/broker/service.go
+++ b/server/broker/service.go
@@ -18,15 +18,17 @@
package broker
import (
+ "context"
"crypto/sha1"
"encoding/json"
+ "errors"
+ "fmt"
"math"
"strconv"
"strings"
"time"
- "context"
-
+ "github.com/apache/servicecomb-service-center/datasource"
"github.com/apache/servicecomb-service-center/datasource/etcd/client"
serviceUtil
"github.com/apache/servicecomb-service-center/datasource/etcd/util"
"github.com/apache/servicecomb-service-center/pkg/log"
@@ -117,17 +119,17 @@ func (*Service) RetrieveProviderPacts(ctx context.Context,
provider, err := serviceUtil.GetService(ctx, tenant, in.ProviderId)
if err != nil {
- PactLogger.Errorf(err, "all provider pact retrieve failed,
providerId is %s: query provider failed.", in.ProviderId)
+ if errors.Is(err, datasource.ErrNoData) {
+ PactLogger.Debug(fmt.Sprintf("all provider pact
retrieve failed, providerId is %s: provider not exist.", in.ProviderId))
+ return &brokerpb.GetAllProviderPactsResponse{
+ Response:
pb.CreateResponse(pb.ErrInvalidParams, "Provider does not exist."),
+ }, nil
+ }
+ PactLogger.Error(fmt.Sprintf("all provider pact retrieve
failed, providerId is %s: query provider failed.", in.ProviderId), err)
return &brokerpb.GetAllProviderPactsResponse{
Response: pb.CreateResponse(pb.ErrInvalidParams, "Query
provider failed."),
}, err
}
- if provider == nil {
- PactLogger.Errorf(nil, "all provider pact retrieve failed,
providerId is %s: provider not exist.", in.ProviderId)
- return &brokerpb.GetAllProviderPactsResponse{
- Response: pb.CreateResponse(pb.ErrInvalidParams,
"Provider does not exist."),
- }, nil
- }
// Get the provider participant
//providerParticipantKey := apt.GenerateBrokerParticipantKey(tenant,
provider.AppId, provider.ServiceName)
providerParticipant, err := GetParticipant(ctx, tenant, provider.AppId,
provider.ServiceName)
@@ -270,17 +272,17 @@ func (*Service) GetAllProviderPacts(ctx context.Context,
provider, err := serviceUtil.GetService(ctx, tenant, in.ProviderId)
if err != nil {
- PactLogger.Errorf(err, "all provider pact retrieve failed,
providerId is %s: query provider failed.", in.ProviderId)
+ if errors.Is(err, datasource.ErrNoData) {
+ PactLogger.Debug(fmt.Sprintf("all provider pact
retrieve failed, providerId is %s: provider not exist.", in.ProviderId))
+ return &brokerpb.GetAllProviderPactsResponse{
+ Response:
pb.CreateResponse(pb.ErrInvalidParams, "Provider does not exist."),
+ }, nil
+ }
+ PactLogger.Error(fmt.Sprintf("all provider pact retrieve
failed, providerId is %s: query provider failed.", in.ProviderId), err)
return &brokerpb.GetAllProviderPactsResponse{
Response: pb.CreateResponse(pb.ErrInvalidParams, "Query
provider failed."),
}, err
}
- if provider == nil {
- PactLogger.Errorf(nil, "all provider pact retrieve failed,
providerId is %s: provider not exist.", in.ProviderId)
- return &brokerpb.GetAllProviderPactsResponse{
- Response: pb.CreateResponse(pb.ErrInvalidParams,
"Provider does not exist."),
- }, nil
- }
// Get the provider participant
//providerParticipantKey := apt.GenerateBrokerParticipantKey(tenant,
provider.AppId, provider.ServiceName)
providerParticipant, err := GetParticipant(ctx, tenant, provider.AppId,
provider.ServiceName)
@@ -420,17 +422,17 @@ func (*Service) RetrieveVerificationResults(ctx
context.Context, in *brokerpb.Re
tenant := GetDefaultTenantProject()
consumer, err := serviceUtil.GetService(ctx, tenant, in.ConsumerId)
if err != nil {
- PactLogger.Errorf(err, "verification result retrieve request
failed, consumerID is %s: query consumer failed.", in.ConsumerId)
+ if errors.Is(err, datasource.ErrNoData) {
+ PactLogger.Debug(fmt.Sprintf("verification result
retrieve request failed, consumerID is %s: consumer not exist.", in.ConsumerId))
+ return &brokerpb.RetrieveVerificationResponse{
+ Response:
pb.CreateResponse(pb.ErrInvalidParams, "Consumer does not exist."),
+ }, nil
+ }
+ PactLogger.Error(fmt.Sprintf("verification result retrieve
request failed, consumerID is %s: query consumer failed.", in.ConsumerId), err)
return &brokerpb.RetrieveVerificationResponse{
Response: pb.CreateResponse(pb.ErrInvalidParams, "Query
consumer failed."),
}, err
}
- if consumer == nil {
- PactLogger.Errorf(nil, "verification result retrieve request
failed, consumerID is %s: consumer not exist.", in.ConsumerId)
- return &brokerpb.RetrieveVerificationResponse{
- Response: pb.CreateResponse(pb.ErrInvalidParams,
"Consumer does not exist."),
- }, nil
- }
PactLogger.Infof("Consumer service found: (%s, %s, %s, %s)",
consumer.ServiceId, consumer.AppId, consumer.ServiceName, consumer.Version)
// Get consumer participant
consumerParticipant, err := GetParticipant(ctx, tenant, consumer.AppId,
consumer.ServiceName)
@@ -595,18 +597,18 @@ func (*Service) PublishVerificationResults(ctx
context.Context, in *brokerpb.Pub
tenant := GetDefaultTenantProject()
consumer, err := serviceUtil.GetService(ctx, tenant, in.ConsumerId)
if err != nil {
- PactLogger.Errorf(err, "verification result publish request
failed, consumerID is %s: query consumer failed.", in.ConsumerId)
+ if errors.Is(err, datasource.ErrNoData) {
+ PactLogger.Debug(fmt.Sprintf("verification result
publish request failed, consumerID is %s: consumer not exist.", in.ConsumerId))
+ return &brokerpb.PublishVerificationResponse{
+ Response:
pb.CreateResponse(pb.ErrInvalidParams, "Consumer does not exist."),
+ }, nil
+ }
+ PactLogger.Error(fmt.Sprintf("verification result publish
request failed, consumerID is %s: query consumer failed.", in.ConsumerId), err)
return &brokerpb.PublishVerificationResponse{
Response: pb.CreateResponse(pb.ErrInvalidParams, "Query
consumer failed."),
}, err
}
- if consumer == nil {
- PactLogger.Errorf(nil, "verification result publish request
failed, consumerID is %s: consumer not exist.", in.ConsumerId)
- return &brokerpb.PublishVerificationResponse{
- Response: pb.CreateResponse(pb.ErrInvalidParams,
"Consumer does not exist."),
- }, nil
- }
- PactLogger.Infof("Consumer service found: (%s, %s, %s, %s)",
consumer.ServiceId, consumer.AppId, consumer.ServiceName, consumer.Version)
+ PactLogger.Info(fmt.Sprintf("consumer service found: (%s, %s, %s, %s)",
consumer.ServiceId, consumer.AppId, consumer.ServiceName, consumer.Version))
// Get consumer participant
consumerParticipant, err := GetParticipant(ctx, tenant, consumer.AppId,
consumer.ServiceName)
if err != nil || consumerParticipant == nil {
@@ -615,7 +617,7 @@ func (*Service) PublishVerificationResults(ctx
context.Context, in *brokerpb.Pub
Response: pb.CreateResponse(pb.ErrInvalidParams,
"consumer participant cannot be searched."),
}, err
}
- PactLogger.Infof("Consumer participant found: (%d, %s, %s)",
consumerParticipant.Id, consumerParticipant.AppId,
consumerParticipant.ServiceName)
+ PactLogger.Info(fmt.Sprintf("Consumer participant found: (%d, %s, %s)",
consumerParticipant.Id, consumerParticipant.AppId,
consumerParticipant.ServiceName))
// Get version
version, err := GetVersion(ctx, tenant, consumer.Version,
consumerParticipant.Id)
if err != nil || version == nil {
@@ -744,47 +746,46 @@ func (*Service) PublishPact(ctx context.Context, in
*brokerpb.PublishPactRequest
provider, err := serviceUtil.GetService(ctx, tenant, in.ProviderId)
if err != nil {
- PactLogger.Errorf(err, "pact publish failed, providerId is %s:
query provider failed.", in.ProviderId)
+ if errors.Is(err, datasource.ErrNoData) {
+ PactLogger.Debug(fmt.Sprintf("pact publish failed,
providerId is %s: provider not exist.", in.ProviderId))
+ return &brokerpb.PublishPactResponse{
+ Response:
pb.CreateResponse(pb.ErrInvalidParams, "Provider does not exist."),
+ }, nil
+ }
+ PactLogger.Error(fmt.Sprintf("pact publish failed, providerId
is %s: query provider failed.", in.ProviderId), err)
return &brokerpb.PublishPactResponse{
Response: pb.CreateResponse(pb.ErrInvalidParams, "Query
provider failed."),
}, err
}
- if provider == nil {
- PactLogger.Errorf(nil, "pact publish failed, providerId is %s:
provider not exist.", in.ProviderId)
- return &brokerpb.PublishPactResponse{
- Response: pb.CreateResponse(pb.ErrInvalidParams,
"Provider does not exist."),
- }, nil
- }
- PactLogger.Infof("Provider service found: (%s, %s, %s, %s)",
provider.ServiceId, provider.AppId, provider.ServiceName, provider.Version)
+ PactLogger.Info(fmt.Sprintf("provider service found: (%s, %s, %s, %s)",
provider.ServiceId, provider.AppId, provider.ServiceName, provider.Version))
consumer, err := serviceUtil.GetService(ctx, tenant, in.ConsumerId)
if err != nil {
- PactLogger.Errorf(err, "pact publish failed, consumerID is %s:
query consumer failed.", in.ConsumerId)
+ if errors.Is(err, datasource.ErrNoData) {
+ PactLogger.Debug(fmt.Sprintf("pact publish failed,
consumerID is %s: consumer not exist.", in.ConsumerId))
+ return &brokerpb.PublishPactResponse{
+ Response:
pb.CreateResponse(pb.ErrInvalidParams, "Consumer does not exist."),
+ }, nil
+ }
+ PactLogger.Error(fmt.Sprintf("pact publish failed, consumerID
is %s: query consumer failed.", in.ConsumerId), err)
return &brokerpb.PublishPactResponse{
Response: pb.CreateResponse(pb.ErrInvalidParams, "Query
consumer failed."),
}, err
}
- if consumer == nil {
- PactLogger.Errorf(nil, "pact publish failed, consumerID is %s:
consumer not exist.", in.ConsumerId)
- return &brokerpb.PublishPactResponse{
- Response: pb.CreateResponse(pb.ErrInvalidParams,
"Consumer does not exist."),
- }, nil
- }
// check that the consumer has that vesion in the url
if strings.Compare(consumer.Version, in.Version) != 0 {
- log.Errorf(nil,
- "pact publish failed, version (%s) does not exist for
consmer", in.Version)
+ log.Error(fmt.Sprintf("pact publish failed, version (%s) does
not exist for consmer", in.Version), nil)
return &brokerpb.PublishPactResponse{
Response: pb.CreateResponse(pb.ErrInvalidParams,
"Consumer Version does not exist."),
}, nil
}
- PactLogger.Infof("Consumer service found: (%s, %s, %s, %s)",
consumer.ServiceId, consumer.AppId, consumer.ServiceName, consumer.Version)
+ PactLogger.Info(fmt.Sprintf("consumer service found: (%s, %s, %s, %s)",
consumer.ServiceId, consumer.AppId, consumer.ServiceName, consumer.Version))
// Get or create provider participant
providerParticipantKey := GenerateBrokerParticipantKey(tenant,
provider.AppId, provider.ServiceName)
providerParticipant, err := GetParticipant(ctx, tenant, provider.AppId,
provider.ServiceName)
if err != nil {
- PactLogger.Errorf(nil, "pact publish failed, provider
participant cannot be searched.", in.ProviderId)
+ PactLogger.Error(fmt.Sprintf("pact publish failed, provider[%s]
participant cannot be searched.", in.ProviderId), nil)
return &brokerpb.PublishPactResponse{
Response: pb.CreateResponse(pb.ErrInvalidParams,
"Provider participant cannot be searched."),
}, err
diff --git a/server/broker/util.go b/server/broker/util.go
index f97a94b..66bec20 100644
--- a/server/broker/util.go
+++ b/server/broker/util.go
@@ -20,11 +20,14 @@ package broker
import (
"context"
"encoding/json"
+ "errors"
+ "fmt"
"math"
"net/url"
"strconv"
"strings"
+ "github.com/apache/servicecomb-service-center/datasource"
"github.com/apache/servicecomb-service-center/datasource/etcd/client"
serviceUtil
"github.com/apache/servicecomb-service-center/datasource/etcd/util"
"github.com/apache/servicecomb-service-center/pkg/log"
@@ -438,31 +441,31 @@ func RetrieveProviderConsumerPact(ctx context.Context,
// Get provider microservice
provider, err := serviceUtil.GetService(ctx, tenant, in.ProviderId)
if err != nil {
- PactLogger.Errorf(err, "pact retrieve failed, providerId is %s:
query provider failed.", in.ProviderId)
+ if errors.Is(err, datasource.ErrNoData) {
+ PactLogger.Debug(fmt.Sprintf("pact retrieve failed,
providerId is %s: provider not exist.", in.ProviderId))
+ return &brokerpb.GetProviderConsumerVersionPactResponse{
+ Response: pb.CreateResponse(pb.ErrInternal,
"Provider does not exist."),
+ }, -1, nil
+ }
+ PactLogger.Error(fmt.Sprintf("pact retrieve failed, providerId
is %s: query provider failed.", in.ProviderId), err)
return &brokerpb.GetProviderConsumerVersionPactResponse{
Response: pb.CreateResponse(pb.ErrInternal, "Query
provider failed."),
}, -1, err
}
- if provider == nil {
- PactLogger.Errorf(nil, "pact retrieve failed, providerId is %s:
provider not exist.", in.ProviderId)
- return &brokerpb.GetProviderConsumerVersionPactResponse{
- Response: pb.CreateResponse(pb.ErrInternal, "Provider
does not exist."),
- }, -1, nil
- }
// Get consumer microservice
consumer, err := serviceUtil.GetService(ctx, tenant, in.ConsumerId)
if err != nil {
- PactLogger.Errorf(err, "pact retrieve failed, consumerId is %s:
query consumer failed.", in.ConsumerId)
+ if errors.Is(err, datasource.ErrNoData) {
+ PactLogger.Debug(fmt.Sprintf("pact retrieve failed,
consumerId is %s: consumer not exist.", in.ConsumerId))
+ return &brokerpb.GetProviderConsumerVersionPactResponse{
+ Response: pb.CreateResponse(pb.ErrInternal,
"Consumer does not exist."),
+ }, -1, nil
+ }
+ PactLogger.Error(fmt.Sprintf("pact retrieve failed, consumerId
is %s: query consumer failed.", in.ConsumerId), err)
return &brokerpb.GetProviderConsumerVersionPactResponse{
Response: pb.CreateResponse(pb.ErrInternal, "Query
consumer failed."),
}, -1, err
}
- if consumer == nil {
- PactLogger.Errorf(nil, "pact retrieve failed, consumerId is %s:
consumer not exist.", in.ConsumerId)
- return &brokerpb.GetProviderConsumerVersionPactResponse{
- Response: pb.CreateResponse(pb.ErrInternal, "Consumer
does not exist."),
- }, -1, nil
- }
// Get provider participant
//providerParticipantKey := apt.GenerateBrokerParticipantKey(tenant,
provider.AppId, provider.ServiceName)
providerParticipant, err := GetParticipant(ctx, tenant, provider.AppId,
provider.ServiceName)
