From 4979b7f492ace0ebe3ee3da607f434f41af2aef1 Mon Sep 17 00:00:00 2001 From: Abhinandan Prativadi Date: Fri, 7 Jul 2017 11:47:21 -0700 Subject: [PATCH] Code cleanup using context The debugs using the caller of method has been extremely useful in faster debugging and understanding of flow. This commit uses context to pass in the caller information instead of explicit method names. The ideal way would have been to use the runtime package Caller function to get the callers from the function stack instead of passing the method explicitly. However since the caller tree need not be symmetric it would make it ugly to retrieve the interested caller. Hencing moving the method name passing to context which would make it cleaner and more readable. Signed-off-by: Abhinandan Prativadi --- agent.go | 38 +++++++++++++------ endpoint.go | 10 +++-- libnetwork_internal_test.go | 12 +++--- network.go | 24 +++++++----- service_common.go | 74 +++++++++++++++++++------------------ 5 files changed, 94 insertions(+), 64 deletions(-) diff --git a/agent.go b/agent.go index a45a569500..c617c56f16 100644 --- a/agent.go +++ b/agent.go @@ -3,6 +3,7 @@ package libnetwork //go:generate protoc -I.:Godeps/_workspace/src/github.com/gogo/protobuf --gogo_out=import_path=github.com/docker/libnetwork,Mgogoproto/gogo.proto=github.com/gogo/protobuf/gogoproto:. agent.proto import ( + "context" "encoding/json" "fmt" "net" @@ -26,8 +27,11 @@ const ( subsysGossip = "networking:gossip" subsysIPSec = "networking:ipsec" keyringSize = 3 + callerCtxKey = callerCtx("caller") ) +type callerCtx string + // ByTime implements sort.Interface for []*types.EncryptionKey based on // the LamportTime field. type ByTime []*types.EncryptionKey @@ -597,6 +601,8 @@ func (ep *endpoint) addServiceInfoToCluster(sb *sandbox) error { defer sb.Service.Unlock() logrus.Debugf("addServiceInfoToCluster START for %s %s", ep.svcName, ep.ID()) + ctx := context.WithValue(context.Background(), callerCtxKey, "addServiceInfoToCluster") + // Check that the endpoint is still present on the sandbox before adding it to the service discovery. // This is to handle a race between the EnableService and the sbLeave // It is possible that the EnableService starts, fetches the list of the endpoints and @@ -628,12 +634,12 @@ func (ep *endpoint) addServiceInfoToCluster(sb *sandbox) error { if n.ingress { ingressPorts = ep.ingressPorts } - if err := c.addServiceBinding(ep.svcName, ep.svcID, n.ID(), ep.ID(), name, ep.virtualIP, ingressPorts, ep.svcAliases, ep.myAliases, ep.Iface().Address().IP, "addServiceInfoToCluster"); err != nil { + if err := c.addServiceBinding(ctx, ep.svcName, ep.svcID, n.ID(), ep.ID(), name, ep.virtualIP, ingressPorts, ep.svcAliases, ep.myAliases, ep.Iface().Address().IP); err != nil { return err } } else { // This is a container simply attached to an attachable network - if err := c.addContainerNameResolution(n.ID(), ep.ID(), name, ep.myAliases, ep.Iface().Address().IP, "addServiceInfoToCluster"); err != nil { + if err := c.addContainerNameResolution(ctx, n.ID(), ep.ID(), name, ep.myAliases, ep.Iface().Address().IP); err != nil { return err } } @@ -664,7 +670,7 @@ func (ep *endpoint) addServiceInfoToCluster(sb *sandbox) error { return nil } -func (ep *endpoint) deleteServiceInfoFromCluster(sb *sandbox, method string) error { +func (ep *endpoint) deleteServiceInfoFromCluster(ctx context.Context, sb *sandbox) error { if ep.isAnonymous() && len(ep.myAliases) == 0 { return nil } @@ -676,7 +682,7 @@ func (ep *endpoint) deleteServiceInfoFromCluster(sb *sandbox, method string) err sb.Service.Lock() defer sb.Service.Unlock() - logrus.Debugf("deleteServiceInfoFromCluster from %s START for %s %s", method, ep.svcName, ep.ID()) + logrus.Debugf("deleteServiceInfoFromCluster from %s START for %s %s", getCaller(ctx), ep.svcName, ep.ID()) c := n.getController() agent := c.getAgent() @@ -685,6 +691,7 @@ func (ep *endpoint) deleteServiceInfoFromCluster(sb *sandbox, method string) err if ep.isAnonymous() { name = ep.MyAliases()[0] } + newCtx := context.WithValue(ctx, callerCtxKey, "deleteServiceInfoFromCluster") if agent != nil { // First delete from networkDB then locally @@ -700,18 +707,18 @@ func (ep *endpoint) deleteServiceInfoFromCluster(sb *sandbox, method string) err if n.ingress { ingressPorts = ep.ingressPorts } - if err := c.rmServiceBinding(ep.svcName, ep.svcID, n.ID(), ep.ID(), name, ep.virtualIP, ingressPorts, ep.svcAliases, ep.myAliases, ep.Iface().Address().IP, "deleteServiceInfoFromCluster", true); err != nil { + if err := c.rmServiceBinding(newCtx, ep.svcName, ep.svcID, n.ID(), ep.ID(), name, ep.virtualIP, ingressPorts, ep.svcAliases, ep.myAliases, ep.Iface().Address().IP, true); err != nil { return err } } else { // This is a container simply attached to an attachable network - if err := c.delContainerNameResolution(n.ID(), ep.ID(), name, ep.myAliases, ep.Iface().Address().IP, "deleteServiceInfoFromCluster"); err != nil { + if err := c.delContainerNameResolution(newCtx, n.ID(), ep.ID(), name, ep.myAliases, ep.Iface().Address().IP); err != nil { return err } } } - logrus.Debugf("deleteServiceInfoFromCluster from %s END for %s %s", method, ep.svcName, ep.ID()) + logrus.Debugf("deleteServiceInfoFromCluster from %s END for %s %s", getCaller(ctx), ep.svcName, ep.ID()) return nil } @@ -883,17 +890,19 @@ func (c *controller) handleEpTableEvent(ev events.Event) { return } + ctx := context.WithValue(context.Background(), callerCtxKey, "handleEpTableEvent") + if isAdd { logrus.Debugf("handleEpTableEvent ADD %s R:%v", eid, epRec) if svcID != "" { // This is a remote task part of a service - if err := c.addServiceBinding(svcName, svcID, nid, eid, containerName, vip, ingressPorts, serviceAliases, taskAliases, ip, "handleEpTableEvent"); err != nil { + if err := c.addServiceBinding(ctx, svcName, svcID, nid, eid, containerName, vip, ingressPorts, serviceAliases, taskAliases, ip); err != nil { logrus.Errorf("failed adding service binding for %s epRec:%v err:%s", eid, epRec, err) return } } else { // This is a remote container simply attached to an attachable network - if err := c.addContainerNameResolution(nid, eid, containerName, taskAliases, ip, "handleEpTableEvent"); err != nil { + if err := c.addContainerNameResolution(ctx, nid, eid, containerName, taskAliases, ip); err != nil { logrus.Errorf("failed adding service binding for %s epRec:%v err:%s", eid, epRec, err) } } @@ -901,15 +910,22 @@ func (c *controller) handleEpTableEvent(ev events.Event) { logrus.Debugf("handleEpTableEvent DEL %s R:%v", eid, epRec) if svcID != "" { // This is a remote task part of a service - if err := c.rmServiceBinding(svcName, svcID, nid, eid, containerName, vip, ingressPorts, serviceAliases, taskAliases, ip, "handleEpTableEvent", true); err != nil { + if err := c.rmServiceBinding(ctx, svcName, svcID, nid, eid, containerName, vip, ingressPorts, serviceAliases, taskAliases, ip, true); err != nil { logrus.Errorf("failed removing service binding for %s epRec:%v err:%s", eid, epRec, err) return } } else { // This is a remote container simply attached to an attachable network - if err := c.delContainerNameResolution(nid, eid, containerName, taskAliases, ip, "handleEpTableEvent"); err != nil { + if err := c.delContainerNameResolution(ctx, nid, eid, containerName, taskAliases, ip); err != nil { logrus.Errorf("failed adding service binding for %s epRec:%v err:%s", eid, epRec, err) } } } } + +func getCaller(ctx context.Context) string { + if value := ctx.Value(callerCtxKey); value != nil { + return value.(string) + } + return "unknown" +} diff --git a/endpoint.go b/endpoint.go index 111b747352..7cddb21c81 100644 --- a/endpoint.go +++ b/endpoint.go @@ -2,6 +2,7 @@ package libnetwork import ( "container/heap" + "context" "encoding/json" "fmt" "net" @@ -603,8 +604,10 @@ func (ep *endpoint) rename(name string) error { return nil } + ctx := context.WithValue(context.Background(), callerCtxKey, "rename") + if c.isAgent() { - if err = ep.deleteServiceInfoFromCluster(sb, "rename"); err != nil { + if err = ep.deleteServiceInfoFromCluster(ctx, sb); err != nil { return types.InternalErrorf("Could not delete service state for endpoint %s from cluster on rename: %v", ep.Name(), err) } } else { @@ -628,7 +631,7 @@ func (ep *endpoint) rename(name string) error { } defer func() { if err != nil { - ep.deleteServiceInfoFromCluster(sb, "rename") + ep.deleteServiceInfoFromCluster(ctx, sb) ep.name = oldName ep.anonymous = oldAnonymous ep.addServiceInfoToCluster(sb) @@ -751,8 +754,9 @@ func (ep *endpoint) sbLeave(sb *sandbox, force bool, options ...EndpointOption) if err := n.getController().updateToStore(ep); err != nil { return err } + ctx := context.WithValue(context.Background(), callerCtxKey, "sbleave") - if e := ep.deleteServiceInfoFromCluster(sb, "sbLeave"); e != nil { + if e := ep.deleteServiceInfoFromCluster(ctx, sb); e != nil { logrus.Errorf("Could not delete service state for endpoint %s from cluster: %v", ep.Name(), e) } diff --git a/libnetwork_internal_test.go b/libnetwork_internal_test.go index 58742cf5e1..a1f614395e 100644 --- a/libnetwork_internal_test.go +++ b/libnetwork_internal_test.go @@ -1,6 +1,7 @@ package libnetwork import ( + "context" "encoding/json" "fmt" "net" @@ -479,8 +480,9 @@ func TestServiceVIPReuse(t *testing.T) { } // Add 2 services with same name but different service ID to share the same VIP - n.(*network).addSvcRecords("ep1", "service_test", "serviceID1", net.ParseIP("192.168.0.1"), net.IP{}, true, "test") - n.(*network).addSvcRecords("ep2", "service_test", "serviceID2", net.ParseIP("192.168.0.1"), net.IP{}, true, "test") + ctx := context.WithValue(context.Background(), callerCtxKey, "test") + n.(*network).addSvcRecords(ctx, "ep1", "service_test", "serviceID1", net.ParseIP("192.168.0.1"), net.IP{}, true) + n.(*network).addSvcRecords(ctx, "ep2", "service_test", "serviceID2", net.ParseIP("192.168.0.1"), net.IP{}, true) ipToResolve := netutils.ReverseIP("192.168.0.1") @@ -503,7 +505,7 @@ func TestServiceVIPReuse(t *testing.T) { } // Delete service record for one of the services, the IP should remain because one service is still associated with it - n.(*network).deleteSvcRecords("ep1", "service_test", "serviceID1", net.ParseIP("192.168.0.1"), net.IP{}, true, "test") + n.(*network).deleteSvcRecords(ctx, "ep1", "service_test", "serviceID1", net.ParseIP("192.168.0.1"), net.IP{}, true) ipList, _ = n.(*network).ResolveName("service_test", types.IPv4) if len(ipList) == 0 { t.Fatal("There must be the VIP") @@ -523,7 +525,7 @@ func TestServiceVIPReuse(t *testing.T) { } // Delete again the service using the previous service ID, nothing should happen - n.(*network).deleteSvcRecords("ep2", "service_test", "serviceID1", net.ParseIP("192.168.0.1"), net.IP{}, true, "test") + n.(*network).deleteSvcRecords(ctx, "ep2", "service_test", "serviceID1", net.ParseIP("192.168.0.1"), net.IP{}, true) ipList, _ = n.(*network).ResolveName("service_test", types.IPv4) if len(ipList) == 0 { t.Fatal("There must be the VIP") @@ -543,7 +545,7 @@ func TestServiceVIPReuse(t *testing.T) { } // Delete now using the second service ID, now all the entries should be gone - n.(*network).deleteSvcRecords("ep2", "service_test", "serviceID2", net.ParseIP("192.168.0.1"), net.IP{}, true, "test") + n.(*network).deleteSvcRecords(ctx, "ep2", "service_test", "serviceID2", net.ParseIP("192.168.0.1"), net.IP{}, true) ipList, _ = n.(*network).ResolveName("service_test", types.IPv4) if len(ipList) != 0 { t.Fatal("All the VIPs should be gone now") diff --git a/network.go b/network.go index 9f99064e11..2b5fcba764 100644 --- a/network.go +++ b/network.go @@ -1,6 +1,7 @@ package libnetwork import ( + "context" "encoding/json" "fmt" "net" @@ -1240,30 +1241,33 @@ func (n *network) updateSvcRecord(ep *endpoint, localEps []*endpoint, isAdd bool if serviceID == "" { serviceID = ep.ID() } + + ctx := context.WithValue(context.Background(), callerCtxKey, "updateSvcRecord") + if isAdd { // If anonymous endpoint has an alias use the first alias // for ip->name mapping. Not having the reverse mapping // breaks some apps if ep.isAnonymous() { if len(myAliases) > 0 { - n.addSvcRecords(ep.ID(), myAliases[0], serviceID, iface.Address().IP, ipv6, true, "updateSvcRecord") + n.addSvcRecords(ctx, ep.ID(), myAliases[0], serviceID, iface.Address().IP, ipv6, true) } } else { - n.addSvcRecords(ep.ID(), epName, serviceID, iface.Address().IP, ipv6, true, "updateSvcRecord") + n.addSvcRecords(ctx, ep.ID(), epName, serviceID, iface.Address().IP, ipv6, true) } for _, alias := range myAliases { - n.addSvcRecords(ep.ID(), alias, serviceID, iface.Address().IP, ipv6, false, "updateSvcRecord") + n.addSvcRecords(ctx, ep.ID(), alias, serviceID, iface.Address().IP, ipv6, false) } } else { if ep.isAnonymous() { if len(myAliases) > 0 { - n.deleteSvcRecords(ep.ID(), myAliases[0], serviceID, iface.Address().IP, ipv6, true, "updateSvcRecord") + n.deleteSvcRecords(ctx, ep.ID(), myAliases[0], serviceID, iface.Address().IP, ipv6, true) } } else { - n.deleteSvcRecords(ep.ID(), epName, serviceID, iface.Address().IP, ipv6, true, "updateSvcRecord") + n.deleteSvcRecords(ctx, ep.ID(), epName, serviceID, iface.Address().IP, ipv6, true) } for _, alias := range myAliases { - n.deleteSvcRecords(ep.ID(), alias, serviceID, iface.Address().IP, ipv6, false, "updateSvcRecord") + n.deleteSvcRecords(ctx, ep.ID(), alias, serviceID, iface.Address().IP, ipv6, false) } } } @@ -1299,14 +1303,14 @@ func delNameToIP(svcMap common.SetMatrix, name, serviceID string, epIP net.IP) { }) } -func (n *network) addSvcRecords(eID, name, serviceID string, epIP, epIPv6 net.IP, ipMapUpdate bool, method string) { +func (n *network) addSvcRecords(ctx context.Context, eID, name, serviceID string, epIP, epIPv6 net.IP, ipMapUpdate bool) { // Do not add service names for ingress network as this is a // routing only network if n.ingress { return } - logrus.Debugf("%s (%s).addSvcRecords(%s, %s, %s, %t) %s sid:%s", eID, n.ID()[0:7], name, epIP, epIPv6, ipMapUpdate, method, serviceID) + logrus.Debugf("%s (%s).addSvcRecords(%s, %s, %s, %t) %s sid:%s", eID, n.ID()[0:7], name, epIP, epIPv6, ipMapUpdate, getCaller(ctx), serviceID) c := n.getController() c.Lock() @@ -1335,14 +1339,14 @@ func (n *network) addSvcRecords(eID, name, serviceID string, epIP, epIPv6 net.IP } } -func (n *network) deleteSvcRecords(eID, name, serviceID string, epIP net.IP, epIPv6 net.IP, ipMapUpdate bool, method string) { +func (n *network) deleteSvcRecords(ctx context.Context, eID, name, serviceID string, epIP net.IP, epIPv6 net.IP, ipMapUpdate bool) { // Do not delete service names from ingress network as this is a // routing only network if n.ingress { return } - logrus.Debugf("%s (%s).deleteSvcRecords(%s, %s, %s, %t) %s sid:%s ", eID, n.ID()[0:7], name, epIP, epIPv6, ipMapUpdate, method, serviceID) + logrus.Debugf("%s (%s).deleteSvcRecords(%s, %s, %s, %t) %s sid:%s ", eID, n.ID()[0:7], name, epIP, epIPv6, ipMapUpdate, getCaller(ctx), serviceID) c := n.getController() c.Lock() diff --git a/service_common.go b/service_common.go index 7e3367c71c..bc4a27f502 100644 --- a/service_common.go +++ b/service_common.go @@ -3,13 +3,14 @@ package libnetwork import ( + "context" "net" "github.com/Sirupsen/logrus" "github.com/docker/libnetwork/common" ) -func (c *controller) addEndpointNameResolution(svcName, svcID, nID, eID, containerName string, vip net.IP, serviceAliases, taskAliases []string, ip net.IP, addService bool, method string) error { +func (c *controller) addEndpointNameResolution(ctx context.Context, svcName, svcID, nID, eID, containerName string, vip net.IP, serviceAliases, taskAliases []string, ip net.IP, addService bool) error { n, err := c.NetworkByID(nID) if err != nil { return err @@ -18,7 +19,7 @@ func (c *controller) addEndpointNameResolution(svcName, svcID, nID, eID, contain logrus.Debugf("addEndpointNameResolution %s %s add_service:%t sAliases:%v tAliases:%v", eID, svcName, addService, serviceAliases, taskAliases) // Add container resolution mappings - c.addContainerNameResolution(nID, eID, containerName, taskAliases, ip, method) + c.addContainerNameResolution(ctx, nID, eID, containerName, taskAliases, ip) serviceID := svcID if serviceID == "" { @@ -27,30 +28,30 @@ func (c *controller) addEndpointNameResolution(svcName, svcID, nID, eID, contain } // Add endpoint IP to special "tasks.svc_name" so that the applications have access to DNS RR. - n.(*network).addSvcRecords(eID, "tasks."+svcName, serviceID, ip, nil, false, method) + n.(*network).addSvcRecords(ctx, eID, "tasks."+svcName, serviceID, ip, nil, false) for _, alias := range serviceAliases { - n.(*network).addSvcRecords(eID, "tasks."+alias, serviceID, ip, nil, false, method) + n.(*network).addSvcRecords(ctx, eID, "tasks."+alias, serviceID, ip, nil, false) } // Add service name to vip in DNS, if vip is valid. Otherwise resort to DNS RR if len(vip) == 0 { - n.(*network).addSvcRecords(eID, svcName, serviceID, ip, nil, false, method) + n.(*network).addSvcRecords(ctx, eID, svcName, serviceID, ip, nil, false) for _, alias := range serviceAliases { - n.(*network).addSvcRecords(eID, alias, serviceID, ip, nil, false, method) + n.(*network).addSvcRecords(ctx, eID, alias, serviceID, ip, nil, false) } } if addService && len(vip) != 0 { - n.(*network).addSvcRecords(eID, svcName, serviceID, vip, nil, false, method) + n.(*network).addSvcRecords(ctx, eID, svcName, serviceID, vip, nil, false) for _, alias := range serviceAliases { - n.(*network).addSvcRecords(eID, alias, serviceID, vip, nil, false, method) + n.(*network).addSvcRecords(ctx, eID, alias, serviceID, vip, nil, false) } } return nil } -func (c *controller) addContainerNameResolution(nID, eID, containerName string, taskAliases []string, ip net.IP, method string) error { +func (c *controller) addContainerNameResolution(ctx context.Context, nID, eID, containerName string, taskAliases []string, ip net.IP) error { n, err := c.NetworkByID(nID) if err != nil { return err @@ -58,17 +59,17 @@ func (c *controller) addContainerNameResolution(nID, eID, containerName string, logrus.Debugf("addContainerNameResolution %s %s", eID, containerName) // Add resolution for container name - n.(*network).addSvcRecords(eID, containerName, eID, ip, nil, true, method) + n.(*network).addSvcRecords(ctx, eID, containerName, eID, ip, nil, true) // Add resolution for taskaliases for _, alias := range taskAliases { - n.(*network).addSvcRecords(eID, alias, eID, ip, nil, true, method) + n.(*network).addSvcRecords(ctx, eID, alias, eID, ip, nil, true) } return nil } -func (c *controller) deleteEndpointNameResolution(svcName, svcID, nID, eID, containerName string, vip net.IP, serviceAliases, taskAliases []string, ip net.IP, rmService, multipleEntries bool, method string) error { +func (c *controller) deleteEndpointNameResolution(ctx context.Context, svcName, svcID, nID, eID, containerName string, vip net.IP, serviceAliases, taskAliases []string, ip net.IP, rmService, multipleEntries bool) error { n, err := c.NetworkByID(nID) if err != nil { return err @@ -77,7 +78,7 @@ func (c *controller) deleteEndpointNameResolution(svcName, svcID, nID, eID, cont logrus.Debugf("deleteEndpointNameResolution %s %s rm_service:%t suppress:%t sAliases:%v tAliases:%v", eID, svcName, rmService, multipleEntries, serviceAliases, taskAliases) // Delete container resolution mappings - c.delContainerNameResolution(nID, eID, containerName, taskAliases, ip, method) + c.delContainerNameResolution(ctx, nID, eID, containerName, taskAliases, ip) serviceID := svcID if serviceID == "" { @@ -87,32 +88,32 @@ func (c *controller) deleteEndpointNameResolution(svcName, svcID, nID, eID, cont // Delete the special "tasks.svc_name" backend record. if !multipleEntries { - n.(*network).deleteSvcRecords(eID, "tasks."+svcName, serviceID, ip, nil, false, method) + n.(*network).deleteSvcRecords(ctx, eID, "tasks."+svcName, serviceID, ip, nil, false) for _, alias := range serviceAliases { - n.(*network).deleteSvcRecords(eID, "tasks."+alias, serviceID, ip, nil, false, method) + n.(*network).deleteSvcRecords(ctx, eID, "tasks."+alias, serviceID, ip, nil, false) } } // If we are doing DNS RR delete the endpoint IP from DNS record right away. if !multipleEntries && len(vip) == 0 { - n.(*network).deleteSvcRecords(eID, svcName, serviceID, ip, nil, false, method) + n.(*network).deleteSvcRecords(ctx, eID, svcName, serviceID, ip, nil, false) for _, alias := range serviceAliases { - n.(*network).deleteSvcRecords(eID, alias, serviceID, ip, nil, false, method) + n.(*network).deleteSvcRecords(ctx, eID, alias, serviceID, ip, nil, false) } } // Remove the DNS record for VIP only if we are removing the service if rmService && len(vip) != 0 && !multipleEntries { - n.(*network).deleteSvcRecords(eID, svcName, serviceID, vip, nil, false, method) + n.(*network).deleteSvcRecords(ctx, eID, svcName, serviceID, vip, nil, false) for _, alias := range serviceAliases { - n.(*network).deleteSvcRecords(eID, alias, serviceID, vip, nil, false, method) + n.(*network).deleteSvcRecords(ctx, eID, alias, serviceID, vip, nil, false) } } return nil } -func (c *controller) delContainerNameResolution(nID, eID, containerName string, taskAliases []string, ip net.IP, method string) error { +func (c *controller) delContainerNameResolution(ctx context.Context, nID, eID, containerName string, taskAliases []string, ip net.IP) error { n, err := c.NetworkByID(nID) if err != nil { return err @@ -120,11 +121,11 @@ func (c *controller) delContainerNameResolution(nID, eID, containerName string, logrus.Debugf("delContainerNameResolution %s %s", eID, containerName) // Delete resolution for container name - n.(*network).deleteSvcRecords(eID, containerName, eID, ip, nil, true, method) + n.(*network).deleteSvcRecords(ctx, eID, containerName, eID, ip, nil, true) // Delete resolution for taskaliases for _, alias := range taskAliases { - n.(*network).deleteSvcRecords(eID, alias, eID, ip, nil, true, method) + n.(*network).deleteSvcRecords(ctx, eID, alias, eID, ip, nil, true) } return nil @@ -179,6 +180,7 @@ func (c *controller) cleanupServiceBindings(cleanupNID string) { s.Unlock() continue } + ctx := context.WithValue(context.Background(), callerCtxKey, "cleanupServiceBindings") for nid, lb := range s.loadBalancers { if cleanupNID != "" && nid != cleanupNID { continue @@ -203,8 +205,8 @@ func (c *controller) cleanupServiceBindings(cleanupNID string) { // ContainerName and taskAliases are not available here, this is still fine because the Service discovery // cleanup already happened before. The only thing that rmServiceBinding is still doing here a part from the Load // Balancer bookeeping, is to keep consistent the mapping of endpoint to IP. - if err := c.rmServiceBinding(service.name, service.id, networkID, epID, "", loadBalancer.vip, - service.ingressPorts, service.aliases, []string{}, epIP, "cleanupServiceBindings", false); err != nil { + if err := c.rmServiceBinding(ctx, service.name, service.id, networkID, epID, "", loadBalancer.vip, + service.ingressPorts, service.aliases, []string{}, epIP, false); err != nil { logrus.Errorf("Failed to remove service bindings for service %s network %s endpoint %s while cleanup: %v", service.id, networkID, epID, err) } @@ -220,7 +222,7 @@ func (c *controller) cleanupServiceBindings(cleanupNID string) { } -func (c *controller) addServiceBinding(svcName, svcID, nID, eID, containerName string, vip net.IP, ingressPorts []*PortConfig, serviceAliases, taskAliases []string, ip net.IP, method string) error { +func (c *controller) addServiceBinding(ctx context.Context, svcName, svcID, nID, eID, containerName string, vip net.IP, ingressPorts []*PortConfig, serviceAliases, taskAliases []string, ip net.IP) error { var addService bool n, err := c.NetworkByID(nID) @@ -252,7 +254,7 @@ func (c *controller) addServiceBinding(svcName, svcID, nID, eID, containerName s } s.Unlock() } - logrus.Debugf("addServiceBinding from %s START for %s %s p:%p nid:%s skey:%v", method, svcName, eID, s, nID, skey) + logrus.Debugf("addServiceBinding from %s START for %s %s p:%p nid:%s skey:%v", getCaller(ctx), svcName, eID, s, nID, skey) defer s.Unlock() lb, ok := s.loadBalancers[nID] @@ -290,15 +292,16 @@ func (c *controller) addServiceBinding(svcName, svcID, nID, eID, containerName s n.(*network).addLBBackend(ip, vip, lb.fwMark, ingressPorts) } + newCtx := context.WithValue(ctx, callerCtxKey, "addServiceBinding") // Add the appropriate name resolutions - c.addEndpointNameResolution(svcName, svcID, nID, eID, containerName, vip, serviceAliases, taskAliases, ip, addService, "addServiceBinding") + c.addEndpointNameResolution(newCtx, svcName, svcID, nID, eID, containerName, vip, serviceAliases, taskAliases, ip, addService) - logrus.Debugf("addServiceBinding from %s END for %s %s", method, svcName, eID) + logrus.Debugf("addServiceBinding from %s END for %s %s", getCaller(ctx), svcName, eID) return nil } -func (c *controller) rmServiceBinding(svcName, svcID, nID, eID, containerName string, vip net.IP, ingressPorts []*PortConfig, serviceAliases []string, taskAliases []string, ip net.IP, method string, deleteSvcRecords bool) error { +func (c *controller) rmServiceBinding(ctx context.Context, svcName, svcID, nID, eID, containerName string, vip net.IP, ingressPorts []*PortConfig, serviceAliases []string, taskAliases []string, ip net.IP, deleteSvcRecords bool) error { var rmService bool @@ -316,22 +319,22 @@ func (c *controller) rmServiceBinding(svcName, svcID, nID, eID, containerName st s, ok := c.serviceBindings[skey] c.Unlock() if !ok { - logrus.Warnf("rmServiceBinding %s %s %s aborted c.serviceBindings[skey] !ok", method, svcName, eID) + logrus.Warnf("rmServiceBinding %s %s %s aborted c.serviceBindings[skey] !ok", getCaller(ctx), svcName, eID) return nil } s.Lock() defer s.Unlock() - logrus.Debugf("rmServiceBinding from %s START for %s %s p:%p nid:%s sKey:%v deleteSvc:%t", method, svcName, eID, s, nID, skey, deleteSvcRecords) + logrus.Debugf("rmServiceBinding from %s START for %s %s p:%p nid:%s sKey:%v deleteSvc:%t", getCaller(ctx), svcName, eID, s, nID, skey, deleteSvcRecords) lb, ok := s.loadBalancers[nID] if !ok { - logrus.Warnf("rmServiceBinding %s %s %s aborted s.loadBalancers[nid] !ok", method, svcName, eID) + logrus.Warnf("rmServiceBinding %s %s %s aborted s.loadBalancers[nid] !ok", getCaller(ctx), svcName, eID) return nil } _, ok = lb.backEnds[eID] if !ok { - logrus.Warnf("rmServiceBinding %s %s %s aborted lb.backEnds[eid] !ok", method, svcName, eID) + logrus.Warnf("rmServiceBinding %s %s %s aborted lb.backEnds[eid] !ok", getCaller(ctx), svcName, eID) return nil } @@ -360,7 +363,8 @@ func (c *controller) rmServiceBinding(svcName, svcID, nID, eID, containerName st // Delete the name resolutions if deleteSvcRecords { - c.deleteEndpointNameResolution(svcName, svcID, nID, eID, containerName, vip, serviceAliases, taskAliases, ip, rmService, entries > 0, "rmServiceBinding") + ctx := context.WithValue(ctx, callerCtxKey, "rmServiceBinding") + c.deleteEndpointNameResolution(ctx, svcName, svcID, nID, eID, containerName, vip, serviceAliases, taskAliases, ip, rmService, entries > 0) } if len(s.loadBalancers) == 0 { @@ -376,6 +380,6 @@ func (c *controller) rmServiceBinding(svcName, svcID, nID, eID, containerName st c.Unlock() } - logrus.Debugf("rmServiceBinding from %s END for %s %s", method, svcName, eID) + logrus.Debugf("rmServiceBinding from %s END for %s %s", getCaller(ctx), svcName, eID) return nil }