little-cui closed pull request #253: SCB-269 dependency use domain-project-env
level lock
URL: https://github.com/apache/incubator-servicecomb-service-center/pull/253
This is a PR merged from a forked repository.
As GitHub hides the original diff on merge, it is displayed below for
the sake of provenance:
As this is a foreign pull request (from a fork), the diff is supplied
below (as it won't show otherwise due to GitHub magic):
diff --git a/server/service/event/dependency_event_handler.go
b/server/service/event/dependency_event_handler.go
index 6789a143..c91cb35b 100644
--- a/server/service/event/dependency_event_handler.go
+++ b/server/service/event/dependency_event_handler.go
@@ -102,6 +102,20 @@ func (h *DependencyEventHandler) loop() {
})
}
+type DependencyEventHandlerResource struct {
+ dep *pb.ConsumerDependency
+ kv *mvccpb.KeyValue
+ domainProject string
+}
+
+func NewDependencyEventHandlerResource(dep *pb.ConsumerDependency, kv
*mvccpb.KeyValue, domainProject string) *DependencyEventHandlerResource {
+ return &DependencyEventHandlerResource{
+ dep,
+ kv,
+ domainProject,
+ }
+}
+
func (h *DependencyEventHandler) Handle() error {
key := core.GetServiceDependencyQueueRootKey("")
resp, err :=
store.Store().DependencyQueue().Search(context.Background(),
@@ -117,6 +131,9 @@ func (h *DependencyEventHandler) Handle() error {
return nil
}
+ lenKvs := len(resp.Kvs)
+ resourcesMap := make(map[string][]*DependencyEventHandlerResource,
lenKvs)
+
ctx := context.Background()
for _, kv := range resp.Kvs {
r := &pb.ConsumerDependency{}
@@ -133,19 +150,63 @@ func (h *DependencyEventHandler) Handle() error {
continue
}
+ lockKey := serviceUtil.NewDependencyLockKey(domainProject,
r.Consumer.Environment)
+ res := NewDependencyEventHandlerResource(r, kv, domainProject)
+ resources := resourcesMap[lockKey]
+ if resources == nil {
+ resources = make([]*DependencyEventHandlerResource, 0,
lenKvs)
+ }
+ resources = append(resources, res)
+ resourcesMap[lockKey] = resources
+ }
+
+ dependencyRuleHandleResults := make(chan error, len(resourcesMap))
+ for lockKey, resources := range resourcesMap {
+ go func(lockKey string, resources
[]*DependencyEventHandlerResource){
+ err := h.dependencyRuleHandle(ctx, lockKey, resources)
+ dependencyRuleHandleResults <- err
+ }(lockKey, resources)
+ }
+ var lastErr error
+ finishedCount := 0
+ for err := range dependencyRuleHandleResults {
+ finishedCount++
+ if err != nil {
+ lastErr = err
+ }
+ if finishedCount == len(resourcesMap) {
+ close(dependencyRuleHandleResults)
+ }
+ }
+ return lastErr
+}
+
+func (h *DependencyEventHandler)dependencyRuleHandle(ctx context.Context,
lockKey string, resources []*DependencyEventHandlerResource) error{
+ lock, err := serviceUtil.DependencyLock(lockKey)
+ if err != nil {
+ util.Logger().Errorf(err, "create dependency rule locker
failed")
+ return err
+ }
+ defer lock.Unlock()
+ for _, res := range resources {
+ r := res.dep
consumerFlag := util.StringJoin([]string{r.Consumer.AppId,
r.Consumer.ServiceName, r.Consumer.Version}, "/")
+
+ domainProject := res.domainProject
consumerInfo :=
pb.DependenciesToKeys([]*pb.MicroServiceKey{r.Consumer}, domainProject)[0]
providersInfo := pb.DependenciesToKeys(r.Providers,
domainProject)
- consumerId, err = serviceUtil.GetServiceId(ctx, consumerInfo)
+ consumerId, err := serviceUtil.GetServiceId(ctx, consumerInfo)
if err != nil {
+ util.Logger().Errorf(err, "modify dependency rule
failed, override: %t, consumer %s", r.Override, consumerFlag)
return fmt.Errorf("get consumer %s id failed, override:
%t, %s", consumerFlag, r.Override, err.Error())
}
if len(consumerId) == 0 {
util.Logger().Errorf(nil, "maintain dependency failed,
override: %t, consumer %s does not exist",
r.Override, consumerFlag)
- if err = h.removeKV(ctx, kv); err != nil {
+ if err = h.removeKV(ctx, res.kv); err != nil {
+ util.Logger().Errorf(err, "remove dependency
rule failed, override: %t, consumer %s", r.Override, consumerFlag)
return err
}
continue
@@ -163,10 +224,12 @@ func (h *DependencyEventHandler) Handle() error {
}
if err != nil {
+ util.Logger().Errorf(err, "modify dependency rule
failed, override: %t, consumer %s", r.Override, consumerFlag)
return fmt.Errorf("override: %t, consumer is %s, %s",
r.Override, consumerFlag, err.Error())
}
- if err = h.removeKV(ctx, kv); err != nil {
+ if err = h.removeKV(ctx, res.kv); err != nil {
+ util.Logger().Errorf(err, "remove dependency rule
failed, override: %t, consumer %s", r.Override, consumerFlag)
return err
}
diff --git a/server/service/microservices.go b/server/service/microservices.go
index 578c408d..319c1088 100644
--- a/server/service/microservices.go
+++ b/server/service/microservices.go
@@ -28,7 +28,6 @@ import (
scerr
"github.com/apache/incubator-servicecomb-service-center/server/error"
"github.com/apache/incubator-servicecomb-service-center/server/infra/quota"
"github.com/apache/incubator-servicecomb-service-center/server/infra/registry"
- "github.com/apache/incubator-servicecomb-service-center/server/mux"
"github.com/apache/incubator-servicecomb-service-center/server/plugin"
serviceUtil
"github.com/apache/incubator-servicecomb-service-center/server/service/util"
"golang.org/x/net/context"
@@ -196,7 +195,7 @@ func checkQuota(ctx context.Context, domainProject string)
(quota.QuotaReporter,
return rst.Reporter, rst.Err
}
-func (s *MicroServiceService) DeleteServicePri(ctx context.Context, ServiceId
string, force bool) (*pb.Response, error) {
+func (s *MicroServiceService) DeleteServicePri(ctx context.Context, serviceId
string, force bool) (*pb.Response, error) {
domainProject := util.ParseDomainProject(ctx)
title := "delete"
@@ -204,20 +203,24 @@ func (s *MicroServiceService) DeleteServicePri(ctx
context.Context, ServiceId st
title = "force delete"
}
- if ServiceId == apt.Service.ServiceId {
+ isServiceCenter := func(serviceId string) bool {
+ return serviceId == apt.Service.ServiceId
+ }
+
+ if isServiceCenter(serviceId) {
err := errors.New("not allow to delete service center")
- util.Logger().Errorf(err, "%s micro-service failed, serviceId
is %s", title, ServiceId)
+ util.Logger().Errorf(err, "%s micro-service failed, serviceId
is %s", title, serviceId)
return pb.CreateResponse(scerr.ErrInvalidParams, err.Error()),
nil
}
- service, err := serviceUtil.GetService(ctx, domainProject, ServiceId)
+ service, err := serviceUtil.GetService(ctx, domainProject, serviceId)
if err != nil {
- util.Logger().Errorf(err, "%s micro-service failed, serviceId
is %s: get service failed.", title, ServiceId)
+ util.Logger().Errorf(err, "%s micro-service failed, serviceId
is %s: get service failed.", title, serviceId)
return pb.CreateResponse(scerr.ErrInternal, err.Error()), err
}
if service == nil {
- util.Logger().Errorf(err, "%s micro-service failed, serviceId
is %s: service not exist.", title, ServiceId)
+ util.Logger().Errorf(err, "%s micro-service failed, serviceId
is %s: service not exist.", title, serviceId)
return pb.CreateResponse(scerr.ErrServiceNotExists, "Service
does not exist."), nil
}
@@ -226,31 +229,38 @@ func (s *MicroServiceService) DeleteServicePri(ctx
context.Context, ServiceId st
dr := serviceUtil.NewProviderDependencyRelation(ctx,
domainProject, service)
services, err := dr.GetDependencyConsumerIds()
if err != nil {
- util.Logger().Errorf(err, "delete micro-service failed,
serviceId is %s: inner err, get service dependency failed.", ServiceId)
+ util.Logger().Errorf(err, "delete micro-service failed,
serviceId is %s: inner err, get service dependency failed.", serviceId)
return pb.CreateResponse(scerr.ErrInternal, "Get
dependency info failed."), err
}
- if len(services) > 1 || (len(services) == 1 && services[0] !=
ServiceId) {
- util.Logger().Errorf(nil, "delete micro-service failed,
serviceId is %s: can't delete, other services rely it.", ServiceId)
+ if len(services) > 1 || (len(services) == 1 && services[0] !=
serviceId) {
+ util.Logger().Errorf(nil, "delete micro-service failed,
serviceId is %s: can't delete, other services rely it.", serviceId)
return pb.CreateResponse(scerr.ErrDependedOnConsumer,
"Can not delete this service, other service rely it."), err
}
- instancesKey := apt.GenerateInstanceKey(domainProject,
ServiceId, "")
+ instancesKey := apt.GenerateInstanceKey(domainProject,
serviceId, "")
rsp, err := store.Store().Instance().Search(ctx,
registry.WithStrKey(instancesKey),
registry.WithPrefix(),
registry.WithCountOnly())
if err != nil {
- util.Logger().Errorf(err, "delete micro-service failed,
serviceId is %s: inner err,get instances failed.", ServiceId)
+ util.Logger().Errorf(err, "delete micro-service failed,
serviceId is %s: inner err,get instances failed.", serviceId)
return pb.CreateResponse(scerr.ErrInternal, "Get
instance failed."), err
}
if rsp.Count > 0 {
- util.Logger().Errorf(nil, "delete micro-service failed,
serviceId is %s: can't delete, exist instance.", ServiceId)
+ util.Logger().Errorf(nil, "delete micro-service failed,
serviceId is %s: can't delete, exist instance.", serviceId)
return pb.CreateResponse(scerr.ErrDeployedInstance,
"Can not delete this service, exist instance."), err
}
}
- consumer := &pb.MicroServiceKey{
+ //refresh msCache consumerCache, ensure that watch can notify consumers
when no cache.
+ err = serviceUtil.RefreshDependencyCache(ctx, domainProject, service)
+ if err != nil {
+ util.Logger().Errorf(err, "%s micro-service failed, serviceId
is %s: inner err, refresh service dependency cache failed.", title, serviceId)
+ return pb.CreateResponse(scerr.ErrInternal, "Refresh dependency
cache failed."), err
+ }
+
+ serviceKey := &pb.MicroServiceKey{
Tenant: domainProject,
Environment: service.Environment,
AppId: service.AppId,
@@ -258,71 +268,64 @@ func (s *MicroServiceService) DeleteServicePri(ctx
context.Context, ServiceId st
Version: service.Version,
Alias: service.Alias,
}
-
- //refresh msCache consumerCache, ensure that watch can notify consumers
when no cache.
- err = serviceUtil.RefreshDependencyCache(ctx, domainProject, service)
- if err != nil {
- util.Logger().Errorf(err, "%s micro-service failed, serviceId
is %s: inner err, refresh service dependency cache failed.", title, ServiceId)
- return pb.CreateResponse(scerr.ErrInternal, "Refresh dependency
cache failed."), err
- }
-
opts := []registry.PluginOp{
-
registry.OpDel(registry.WithStrKey(apt.GenerateServiceIndexKey(consumer))),
-
registry.OpDel(registry.WithStrKey(apt.GenerateServiceAliasKey(consumer))),
-
registry.OpDel(registry.WithStrKey(apt.GenerateServiceKey(domainProject,
ServiceId))),
+
registry.OpDel(registry.WithStrKey(apt.GenerateServiceIndexKey(serviceKey))),
+
registry.OpDel(registry.WithStrKey(apt.GenerateServiceAliasKey(serviceKey))),
+
registry.OpDel(registry.WithStrKey(apt.GenerateServiceKey(domainProject,
serviceId))),
registry.OpDel(registry.WithStrKey(
-
util.StringJoin([]string{apt.GetServiceRuleRootKey(domainProject), ServiceId,
""}, "/"))),
+
util.StringJoin([]string{apt.GetServiceRuleRootKey(domainProject), serviceId,
""}, "/"))),
}
//??????
- lock, err := mux.Lock(mux.DEP_QUEUE_LOCK)
+ lock, err :=
serviceUtil.DependencyLock(serviceUtil.NewDependencyLockKey(domainProject,
service.Environment))
if err != nil {
- util.Logger().Errorf(err, "%s micro-service failed, serviceId
is %s: inner err, create lock failed.", title, ServiceId)
+ util.Logger().Errorf(err, "%s micro-service failed, serviceId
is %s: inner err, create lock failed.", title, serviceId)
return pb.CreateResponse(scerr.ErrUnavailableBackend,
err.Error()), err
}
- optsTmp, err := serviceUtil.DeleteDependencyForService(ctx, consumer,
ServiceId)
- lock.Unlock()
+
+ defer lock.Unlock()
+ optsTmp, err := serviceUtil.DeleteDependencyForService(ctx, serviceKey)
if err != nil {
- util.Logger().Errorf(err, "%s micro-service failed, serviceId
is %s: inner err, delete dependency failed.", title, ServiceId)
+ util.Logger().Errorf(err, "%s micro-service failed, serviceId
is %s: inner err, delete dependency failed.", title, serviceId)
return pb.CreateResponse(scerr.ErrInternal, err.Error()), err
}
opts = append(opts, optsTmp...)
//??????
opts = append(opts, registry.OpDel(
- registry.WithStrKey(apt.GenerateServiceRuleKey(domainProject,
ServiceId, "")),
+ registry.WithStrKey(apt.GenerateServiceRuleKey(domainProject,
serviceId, "")),
registry.WithPrefix()))
opts = append(opts, registry.OpDel(
- registry.WithStrKey(apt.GenerateRuleIndexKey(domainProject,
ServiceId, "", ""))))
+ registry.WithStrKey(apt.GenerateRuleIndexKey(domainProject,
serviceId, "", ""))))
//??schemas
opts = append(opts, registry.OpDel(
- registry.WithStrKey(apt.GenerateServiceSchemaKey(domainProject,
ServiceId, "")),
+ registry.WithStrKey(apt.GenerateServiceSchemaKey(domainProject,
serviceId, "")),
registry.WithPrefix()))
opts = append(opts, registry.OpDel(
-
registry.WithStrKey(apt.GenerateServiceSchemaSummaryKey(domainProject,
ServiceId, "")),
+
registry.WithStrKey(apt.GenerateServiceSchemaSummaryKey(domainProject,
serviceId, "")),
registry.WithPrefix()))
//??tags
opts = append(opts, registry.OpDel(
- registry.WithStrKey(apt.GenerateServiceTagKey(domainProject,
ServiceId))))
+ registry.WithStrKey(apt.GenerateServiceTagKey(domainProject,
serviceId))))
//????
- err = serviceUtil.DeleteServiceAllInstances(ctx, ServiceId)
+ err = serviceUtil.DeleteServiceAllInstances(ctx, serviceId)
if err != nil {
- util.Logger().Errorf(err, "%s micro-service failed, serviceId
is %s: delete all instances failed.", title, ServiceId)
+ util.Logger().Errorf(err, "%s micro-service failed, serviceId
is %s: delete all instances failed.", title, serviceId)
return pb.CreateResponse(scerr.ErrInternal, "Delete all
instances failed for service."), err
}
err = backend.BatchCommit(ctx, opts)
if err != nil {
- util.Logger().Errorf(err, "%s micro-service failed, serviceId
is %s: commit data into etcd failed.", title, ServiceId)
+ util.Logger().Errorf(err, "%s micro-service failed, serviceId
is %s: commit data into etcd failed.", title, serviceId)
return pb.CreateResponse(scerr.ErrUnavailableBackend, "Commit
operations failed."), nil
}
serviceUtil.RemandServiceQuota(ctx)
- util.Logger().Infof("%s micro-service successful: serviceId is %s,
operator is %s.", title, ServiceId, util.GetIPFromContext(ctx))
+ util.Logger().Infof("%s micro-service successful: serviceId is %s,
operator is %s.", title, serviceId, util.GetIPFromContext(ctx))
return pb.CreateResponse(pb.Response_SUCCESS, "Unregister service
successfully."), nil
}
diff --git a/server/service/util/dependency.go
b/server/service/util/dependency.go
index bd4a3ac0..5bfb9789 100644
--- a/server/service/util/dependency.go
+++ b/server/service/util/dependency.go
@@ -31,6 +31,8 @@ import (
"golang.org/x/net/context"
"strings"
"time"
+ "github.com/apache/incubator-servicecomb-service-center/pkg/etcdsync"
+ "github.com/apache/incubator-servicecomb-service-center/server/mux"
)
var consumerCache *cache.Cache
@@ -277,54 +279,40 @@ func AddServiceVersionRule(ctx context.Context,
domainProject string, consumer *
return nil
}
-func DeleteDependencyForService(ctx context.Context, consumer
*pb.MicroServiceKey, serviceId string) ([]registry.PluginOp, error) {
- ops := []registry.PluginOp{}
- opsTmps := []registry.PluginOp{}
- domainProject := consumer.Tenant
- flag := map[string]bool{}
+func DeleteDependencyForService(ctx context.Context, service
*pb.MicroServiceKey) ([]registry.PluginOp, error) {
+ domainProject := service.Tenant
//??????
- conKey := apt.GenerateConsumerDependencyRuleKey(domainProject, consumer)
+ conKey := apt.GenerateConsumerDependencyRuleKey(domainProject, service)
providerValue, err := TransferToMicroServiceDependency(ctx, conKey)
if err != nil {
return nil, err
}
+ opts := make([]registry.PluginOp, 0)
if providerValue != nil && len(providerValue.Dependency) != 0 {
- proProkey := ""
+ providerRuleKey := ""
for _, providerRule := range providerValue.Dependency {
- proProkey =
apt.GenerateProviderDependencyRuleKey(domainProject, providerRule)
- consumers, err := TransferToMicroServiceDependency(ctx,
proProkey)
+ providerRuleKey =
apt.GenerateProviderDependencyRuleKey(domainProject, providerRule)
+ consumers, err := TransferToMicroServiceDependency(ctx,
providerRuleKey)
if err != nil {
return nil, err
}
- err = deleteDependencyRuleUtil(ctx, consumers,
consumer, proProkey)
+ opt, err := updateProviderDependencyRuleUtil(consumers,
service, providerRuleKey)
if err != nil {
return nil, err
}
+ opts = append(opts, opt)
}
-
- util.Logger().Debugf("conKey is %s.", conKey)
- ops = append(ops, registry.OpDel(registry.WithStrKey(conKey)))
}
+ util.Logger().Infof("delete dependency rule, consumer Key is %s.",
conKey)
+ opts = append(opts, registry.OpDel(registry.WithStrKey(conKey)))
+
//??provider?????
- providerKey := apt.GenerateProviderDependencyRuleKey(domainProject,
consumer)
+ providerKey := apt.GenerateProviderDependencyRuleKey(domainProject,
service)
- util.Logger().Debugf("providerKey is %s", providerKey)
- ops = append(ops, registry.OpDel(registry.WithStrKey(providerKey)))
+ util.Logger().Infof("delete dependency rule, providerKey is %s",
providerKey)
+ opts = append(opts, registry.OpDel(registry.WithStrKey(providerKey)))
- //??????
- opsTmps, err = deleteDependencyUtil(ctx, "c", domainProject, serviceId,
flag)
- if err != nil {
- return nil, err
- }
- ops = append(ops, opsTmps...)
- util.Logger().Debugf("flag is %s", flag)
- opsTmps, err = deleteDependencyUtil(ctx, "p", domainProject, serviceId,
flag)
- if err != nil {
- return nil, err
- }
- util.Logger().Debugf("flag is %s", flag)
- ops = append(ops, opsTmps...)
- return ops, nil
+ return opts, nil
}
func TransferToMicroServiceDependency(ctx context.Context, key string)
(*pb.MicroServiceDependency, error) {
@@ -348,35 +336,25 @@ func TransferToMicroServiceDependency(ctx
context.Context, key string) (*pb.Micr
return microServiceDependency, nil
}
-func deleteDependencyRuleUtil(ctx context.Context, microServiceDependency
*pb.MicroServiceDependency, service *pb.MicroServiceKey, serviceKey string)
error {
- for key, serviceTmp := range microServiceDependency.Dependency {
- if ok := equalServiceDependency(serviceTmp, service); ok {
- microServiceDependency.Dependency =
append(microServiceDependency.Dependency[:key],
microServiceDependency.Dependency[key+1:]...)
- util.Logger().Debugf("delete versionRule from %s",
serviceTmp.ServiceName)
+func updateProviderDependencyRuleUtil(consumersOfProvideRules
*pb.MicroServiceDependency, consumer *pb.MicroServiceKey, providerRuleKey
string) (registry.PluginOp, error) {
+ for key, consumerInner := range consumersOfProvideRules.Dependency {
+ if ok := equalServiceDependency(consumerInner, consumer); ok {
+ consumersOfProvideRules.Dependency =
append(consumersOfProvideRules.Dependency[:key],
consumersOfProvideRules.Dependency[key+1:]...)
break
}
}
- opts := []registry.PluginOpOption{}
- if len(microServiceDependency.Dependency) == 0 {
- opts = append(opts, registry.DEL,
registry.WithStrKey(serviceKey))
- util.Logger().Debugf("serviceKey is .", serviceKey)
- util.Logger().Debugf("After deleting versionRule from
%s,provider's consumer is empty.", serviceKey)
-
+ if len(consumersOfProvideRules.Dependency) == 0 {
+ util.Logger().Infof("delete dependency rule key is %s",
providerRuleKey)
+ return registry.OpDel(registry.WithStrKey(providerRuleKey)), nil
} else {
- data, err := json.Marshal(microServiceDependency)
+ data, err := json.Marshal(consumersOfProvideRules)
if err != nil {
- util.Logger().Errorf(nil, "Marshal tmpValue failed.")
- return err
+ util.Logger().Errorf(nil, "update dependency key
Marshal tmpValue failed.")
+ return registry.PluginOp{}, err
}
- opts = append(opts, registry.PUT,
registry.WithStrKey(serviceKey), registry.WithValue(data))
- util.Logger().Debugf("serviceKey is %s.", serviceKey)
+ util.Logger().Infof("put provider's dependency rule, key is
%s, value is %v.", providerRuleKey, consumersOfProvideRules)
+ return registry.OpPut(registry.WithStrKey(providerRuleKey),
registry.WithValue(data)), nil
}
- _, err := backend.Registry().Do(ctx, opts...)
- if err != nil {
- util.Logger().Errorf(err, "Submit update dependency failed.")
- return err
- }
- return nil
}
func equalServiceDependency(serviceA *pb.MicroServiceKey, serviceB
*pb.MicroServiceKey) bool {
@@ -402,43 +380,6 @@ func toString(in *pb.MicroServiceKey) string {
return apt.GenerateProviderDependencyRuleKey(in.Tenant, in)
}
-func deleteDependencyUtil(ctx context.Context, serviceType string,
domainProject string, serviceId string, flag map[string]bool)
([]registry.PluginOp, error) {
- serviceKey := apt.GenerateServiceDependencyKey(serviceType,
domainProject, serviceId, "")
- rsp, err := store.Store().Dependency().Search(ctx,
- registry.WithStrKey(serviceKey),
- registry.WithPrefix())
- if err != nil {
- return nil, err
- }
- ops := []registry.PluginOp{}
- if rsp != nil {
- serviceTmpId := ""
- serviceTmpKey := ""
- deleteKey := ""
- for _, kv := range rsp.Kvs {
- tmpKeyArr :=
strings.Split(util.BytesToStringWithNoCopy(kv.Key), "/")
- serviceTmpId = tmpKeyArr[len(tmpKeyArr)-1]
- if serviceType == "p" {
- serviceTmpKey =
apt.GenerateConsumerDependencyKey(domainProject, serviceTmpId, serviceId)
- deleteKey = util.StringJoin([]string{"c",
serviceTmpId, serviceId}, "/")
- } else {
- serviceTmpKey =
apt.GenerateProviderDependencyKey(domainProject, serviceTmpId, serviceId)
- deleteKey = util.StringJoin([]string{"p",
serviceTmpId, serviceId}, "/")
- }
- if _, ok := flag[serviceTmpKey]; ok {
- util.Logger().Debugf("serviceTmpKey is more
exist.%s", serviceTmpKey)
- continue
- }
- flag[serviceTmpKey] = true
- util.Logger().Infof("delete dependency %s", deleteKey)
- ops = append(ops,
registry.OpDel(registry.WithStrKey(serviceTmpKey)))
- }
- util.Logger().Infof("delete dependency serviceKey is %s",
serviceType+"/"+serviceId)
- ops = append(ops,
registry.OpDel(registry.WithStrKey(serviceKey), registry.WithPrefix()))
- }
- return ops, nil
-}
-
func parseAddOrUpdateRules(ctx context.Context, dep *Dependency)
(newDependencyRuleList, existDependencyRuleList, deleteDependencyRuleList
[]*pb.MicroServiceKey) {
conKey := apt.GenerateConsumerDependencyRuleKey(dep.DomainProject,
dep.Consumer)
@@ -1112,3 +1053,11 @@ func (dr *DependencyRelation)
getConsumerOfSameServiceNameAndAppId(provider *pb.
}
return allConsumers, nil
}
+
+func DependencyLock(lockKey string) (*etcdsync.DLock, error) {
+ return mux.Lock(mux.MuxType(lockKey))
+}
+
+func NewDependencyLockKey(domainProject, env string) string {
+ return util.StringJoin([]string{"","env-lock", domainProject, env}, "/")
+}
\ No newline at end of file
diff --git a/server/service/util/dependency_test.go
b/server/service/util/dependency_test.go
index 6695945d..c1326e9f 100644
--- a/server/service/util/dependency_test.go
+++ b/server/service/util/dependency_test.go
@@ -33,13 +33,13 @@ func TestRefreshDependencyCache(t *testing.T) {
}
func TestDeleteDependencyForService(t *testing.T) {
- _, err := DeleteDependencyForService(context.Background(),
&proto.MicroServiceKey{}, "")
+ _, err := DeleteDependencyForService(context.Background(),
&proto.MicroServiceKey{})
if err == nil {
fmt.Printf(`DeleteDependencyForService failed`)
t.FailNow()
}
- err = deleteDependencyRuleUtil(context.Background(),
+ _, err = updateProviderDependencyRuleUtil(
&proto.MicroServiceDependency{
Dependency: []*proto.MicroServiceKey{
{AppId: "a"},
@@ -48,12 +48,12 @@ func TestDeleteDependencyForService(t *testing.T) {
&proto.MicroServiceKey{
AppId: "a",
}, "")
- if err == nil {
+ if err != nil {
fmt.Printf(`deleteDependencyRuleUtil with the same deps failed`)
t.FailNow()
}
- err = deleteDependencyRuleUtil(context.Background(),
+ _, err = updateProviderDependencyRuleUtil(
&proto.MicroServiceDependency{
Dependency: []*proto.MicroServiceKey{
{AppId: "b"},
@@ -62,17 +62,11 @@ func TestDeleteDependencyForService(t *testing.T) {
&proto.MicroServiceKey{
AppId: "a",
}, "")
- if err == nil {
+ if err != nil {
fmt.Printf(`deleteDependencyRuleUtil failed`)
t.FailNow()
}
- _, err = deleteDependencyUtil(context.Background(), "", "", "",
map[string]bool{})
- if err == nil {
- fmt.Printf(`deleteDependencyUtil failed`)
- t.FailNow()
- }
-
_, err = deleteConsumerDepOfProviderRule(context.Background(), "",
&proto.MicroServiceKey{}, &proto.MicroServiceKey{})
if err == nil {
fmt.Printf(`deleteConsumerDepOfProviderRule failed`)
----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
[email protected]
With regards,
Apache Git Services