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

Reply via email to