diff --git a/controllers/gateway_controller.go b/controllers/gateway_controller.go index a7eabf96..69909554 100644 --- a/controllers/gateway_controller.go +++ b/controllers/gateway_controller.go @@ -75,7 +75,7 @@ func RegisterGatewayController( evtRec := mgr.GetEventRecorderFor("gateway") modelBuilder := gateway.NewServiceNetworkModelBuilder(mgrClient) - stackDeployer := deploy.NewServiceNetworkStackDeployer(cloud, mgrClient) + stackDeployer := deploy.NewServiceNetworkStackDeployer(log, cloud, mgrClient) stackMarshaller := deploy.NewDefaultStackMarshaller() r := &GatewayReconciler{ diff --git a/pkg/aws/cloud.go b/pkg/aws/cloud.go index 5e624b76..7322b847 100644 --- a/pkg/aws/cloud.go +++ b/pkg/aws/cloud.go @@ -2,11 +2,13 @@ package aws import ( "fmt" - "github.com/aws/aws-application-networking-k8s/pkg/aws/services" - "github.com/aws/aws-application-networking-k8s/pkg/utils/gwlog" + "github.com/aws/aws-sdk-go/aws/request" "github.com/aws/aws-sdk-go/aws/session" "github.com/aws/aws-sdk-go/service/vpclattice" + + "github.com/aws/aws-application-networking-k8s/pkg/aws/services" + "github.com/aws/aws-application-networking-k8s/pkg/utils/gwlog" ) const ( diff --git a/pkg/aws/gomock_reflect_3295326204/prog.go b/pkg/aws/gomock_reflect_3295326204/prog.go new file mode 100644 index 00000000..ef549501 --- /dev/null +++ b/pkg/aws/gomock_reflect_3295326204/prog.go @@ -0,0 +1,64 @@ +package main + +import ( + "encoding/gob" + "flag" + "fmt" + "os" + "path" + "reflect" + + "github.com/golang/mock/mockgen/model" + + pkg_ "github.com/aws/aws-application-networking-k8s/pkg/aws" +) + +var output = flag.String("output", "", "The output file name, or empty to use stdout.") + +func main() { + flag.Parse() + + its := []struct { + sym string + typ reflect.Type + }{ + + {"Cloud", reflect.TypeOf((*pkg_.Cloud)(nil)).Elem()}, + } + pkg := &model.Package{ + // NOTE: This behaves contrary to documented behaviour if the + // package name is not the final component of the import path. + // The reflect package doesn't expose the package name, though. + Name: path.Base("github.com/aws/aws-application-networking-k8s/pkg/aws"), + } + + for _, it := range its { + intf, err := model.InterfaceFromInterfaceType(it.typ) + if err != nil { + fmt.Fprintf(os.Stderr, "Reflection: %v\n", err) + os.Exit(1) + } + intf.Name = it.sym + pkg.Interfaces = append(pkg.Interfaces, intf) + } + + outfile := os.Stdout + if len(*output) != 0 { + var err error + outfile, err = os.Create(*output) + if err != nil { + fmt.Fprintf(os.Stderr, "failed to open output file %q", *output) + } + defer func() { + if err := outfile.Close(); err != nil { + fmt.Fprintf(os.Stderr, "failed to close output file %q", *output) + os.Exit(1) + } + }() + } + + if err := gob.NewEncoder(outfile).Encode(pkg); err != nil { + fmt.Fprintf(os.Stderr, "gob encode: %v\n", err) + os.Exit(1) + } +} diff --git a/pkg/aws/gomock_reflect_3994833575/prog.go b/pkg/aws/gomock_reflect_3994833575/prog.go new file mode 100644 index 00000000..ef549501 --- /dev/null +++ b/pkg/aws/gomock_reflect_3994833575/prog.go @@ -0,0 +1,64 @@ +package main + +import ( + "encoding/gob" + "flag" + "fmt" + "os" + "path" + "reflect" + + "github.com/golang/mock/mockgen/model" + + pkg_ "github.com/aws/aws-application-networking-k8s/pkg/aws" +) + +var output = flag.String("output", "", "The output file name, or empty to use stdout.") + +func main() { + flag.Parse() + + its := []struct { + sym string + typ reflect.Type + }{ + + {"Cloud", reflect.TypeOf((*pkg_.Cloud)(nil)).Elem()}, + } + pkg := &model.Package{ + // NOTE: This behaves contrary to documented behaviour if the + // package name is not the final component of the import path. + // The reflect package doesn't expose the package name, though. + Name: path.Base("github.com/aws/aws-application-networking-k8s/pkg/aws"), + } + + for _, it := range its { + intf, err := model.InterfaceFromInterfaceType(it.typ) + if err != nil { + fmt.Fprintf(os.Stderr, "Reflection: %v\n", err) + os.Exit(1) + } + intf.Name = it.sym + pkg.Interfaces = append(pkg.Interfaces, intf) + } + + outfile := os.Stdout + if len(*output) != 0 { + var err error + outfile, err = os.Create(*output) + if err != nil { + fmt.Fprintf(os.Stderr, "failed to open output file %q", *output) + } + defer func() { + if err := outfile.Close(); err != nil { + fmt.Fprintf(os.Stderr, "failed to close output file %q", *output) + os.Exit(1) + } + }() + } + + if err := gob.NewEncoder(outfile).Encode(pkg); err != nil { + fmt.Fprintf(os.Stderr, "gob encode: %v\n", err) + os.Exit(1) + } +} diff --git a/pkg/deploy/externaldns/dnsendpoint_manager.go b/pkg/deploy/externaldns/dnsendpoint_manager.go index 816fe720..1ecbf741 100644 --- a/pkg/deploy/externaldns/dnsendpoint_manager.go +++ b/pkg/deploy/externaldns/dnsendpoint_manager.go @@ -4,9 +4,6 @@ import ( "context" "reflect" - "github.com/aws/aws-application-networking-k8s/pkg/model/core" - latticemodel "github.com/aws/aws-application-networking-k8s/pkg/model/lattice" - "github.com/golang/glog" apierrors "k8s.io/apimachinery/pkg/api/errors" "k8s.io/apimachinery/pkg/api/meta" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -14,6 +11,10 @@ import ( "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil" "sigs.k8s.io/external-dns/endpoint" + + "github.com/aws/aws-application-networking-k8s/pkg/model/core" + latticemodel "github.com/aws/aws-application-networking-k8s/pkg/model/lattice" + "github.com/aws/aws-application-networking-k8s/pkg/utils/gwlog" ) type DnsEndpointManager interface { @@ -21,11 +22,13 @@ type DnsEndpointManager interface { } type defaultDnsEndpointManager struct { + log gwlog.Logger k8sClient client.Client } -func NewDnsEndpointManager(k8sClient client.Client) *defaultDnsEndpointManager { +func NewDnsEndpointManager(log gwlog.Logger, k8sClient client.Client) *defaultDnsEndpointManager { return &defaultDnsEndpointManager{ + log: log, k8sClient: k8sClient, } } @@ -36,11 +39,11 @@ func (s *defaultDnsEndpointManager) Create(ctx context.Context, service *lattice Name: service.Spec.Name + "-dns", } if service.Spec.CustomerDomainName == "" { - glog.V(2).Infof("Skipping creation of %s: detected no custom domain", namespacedName.String()) + s.log.Debugf("Skipping creation of %s: detected no custom domain", namespacedName.String()) return nil } if service.Status == nil || service.Status.Dns == "" { - glog.V(2).Infof("Skipping creation of %s: DNS target not ready in svc status", namespacedName.String()) + s.log.Debugf("Skipping creation of %s: DNS target not ready in svc status", namespacedName.String()) return nil } @@ -58,14 +61,14 @@ func (s *defaultDnsEndpointManager) Create(ctx context.Context, service *lattice route, err = core.GetHTTPRoute(ctx, s.k8sClient, routeNamespacedName) } if err != nil { - glog.V(2).Infof("Skipping creation of %s: Could not find corresponding route", namespacedName.String()) + s.log.Debugf("Skipping creation of %s: Could not find corresponding route", namespacedName.String()) return nil } ep := &endpoint.DNSEndpoint{} if err := s.k8sClient.Get(ctx, namespacedName, ep); err != nil { if apierrors.IsNotFound(err) { - glog.V(2).Infof("Attempting creation of DNSEndpoint for %s - %s -> %s", + s.log.Debugf("Attempting creation of DNSEndpoint for %s - %s -> %s", namespacedName.String(), service.Spec.CustomerDomainName, service.Status.Dns) ep = &endpoint.DNSEndpoint{ ObjectMeta: metav1.ObjectMeta{ @@ -87,18 +90,16 @@ func (s *defaultDnsEndpointManager) Create(ctx context.Context, service *lattice } controllerutil.SetControllerReference(route.K8sObject(), ep, s.k8sClient.Scheme()) if err = s.k8sClient.Create(ctx, ep); err != nil { - glog.V(2).Infof("Failed creating DNSEndpoint: %s", err.Error()) return err } } else if meta.IsNoMatchError(err) { - glog.V(2).Infof("DNSEndpoint CRD not supported, skipping") + s.log.Debugf("DNSEndpoint CRD not supported, skipping") return nil } else { - glog.V(2).Infof("Failed lookup of DNSEndpoint: %s", err.Error()) return err } } else { - glog.V(2).Infof("Attempting update of DNSEndpoint for %s - %s -> %s", + s.log.Debugf("Attempting update of DNSEndpoint for %s - %s -> %s", namespacedName.String(), service.Spec.CustomerDomainName, service.Status.Dns) old := ep.DeepCopy() ep.Spec.Endpoints = []*endpoint.Endpoint{ @@ -113,7 +114,6 @@ func (s *defaultDnsEndpointManager) Create(ctx context.Context, service *lattice } if !reflect.DeepEqual(ep.Spec.Endpoints, old.Spec.Endpoints) { if err = s.k8sClient.Patch(ctx, ep, client.MergeFrom(old)); err != nil { - glog.V(2).Infof("Failed updating DNSEndpoint: %s", err.Error()) return err } } diff --git a/pkg/deploy/externaldns/dnsendpoint_manager_test.go b/pkg/deploy/externaldns/dnsendpoint_manager_test.go index 7b6552bd..e6980243 100644 --- a/pkg/deploy/externaldns/dnsendpoint_manager_test.go +++ b/pkg/deploy/externaldns/dnsendpoint_manager_test.go @@ -8,6 +8,8 @@ import ( mock_client "github.com/aws/aws-application-networking-k8s/mocks/controller-runtime/client" latticemodel "github.com/aws/aws-application-networking-k8s/pkg/model/lattice" + "github.com/aws/aws-application-networking-k8s/pkg/utils/gwlog" + "github.com/golang/mock/gomock" "github.com/stretchr/testify/assert" apierrors "k8s.io/apimachinery/pkg/api/errors" @@ -230,7 +232,7 @@ func TestCreateDnsEndpoint(t *testing.T) { for _, tt := range tests { fmt.Printf("Testing >>>>> %v\n", tt.name) client := mock_client.NewMockClient(c) - mgr := NewDnsEndpointManager(client) + mgr := NewDnsEndpointManager(gwlog.FallbackLogger, client) client.EXPECT().Scheme().Return(runtime.NewScheme()).AnyTimes() diff --git a/pkg/deploy/lattice/listener_manager.go b/pkg/deploy/lattice/listener_manager.go index 9871beac..afa19b47 100644 --- a/pkg/deploy/lattice/listener_manager.go +++ b/pkg/deploy/lattice/listener_manager.go @@ -2,7 +2,6 @@ package lattice import ( "context" - "errors" "fmt" "github.com/aws/aws-application-networking-k8s/pkg/aws/services" @@ -110,7 +109,7 @@ func (d *defaultListenerManager) Create( resp, err := d.cloud.Lattice().CreateListener(&listenerInput) if err != nil { - d.log.Errorf("Error during creation of Listener %s-%s", listenerSpec.Name, listenerSpec.Namespace) + return latticemodel.ListenerStatus{}, err } return latticemodel.ListenerStatus{ @@ -183,7 +182,7 @@ func (d *defaultListenerManager) findListenerByNamePort( } } - return nil, errors.New("listener does not exist") + return nil, fmt.Errorf("listener for service %s and port %d does not exist", serviceId, port) } func (d *defaultListenerManager) Delete(ctx context.Context, listenerId string, serviceId string) error { diff --git a/pkg/deploy/lattice/listener_synthesizer.go b/pkg/deploy/lattice/listener_synthesizer.go index a26e81fa..3792438d 100644 --- a/pkg/deploy/lattice/listener_synthesizer.go +++ b/pkg/deploy/lattice/listener_synthesizer.go @@ -102,7 +102,9 @@ func (l *listenerSynthesizer) getSDKListeners(ctx context.Context) ([]*latticemo var resService []*latticemodel.Service err := l.stack.ListResources(&resService) - l.log.Debugf("Ignoring error when listing services %s", err) + if err != nil { + l.log.Debugf("Ignoring error when listing services %s", err) + } for _, service := range resService { latticeService, err := l.listenerMgr.Cloud().Lattice().FindService(ctx, service) diff --git a/pkg/deploy/lattice/rule_synthesizer.go b/pkg/deploy/lattice/rule_synthesizer.go index 5ab62052..e6864920 100644 --- a/pkg/deploy/lattice/rule_synthesizer.go +++ b/pkg/deploy/lattice/rule_synthesizer.go @@ -3,9 +3,9 @@ package lattice import ( "context" "errors" + "fmt" "github.com/aws/aws-sdk-go/aws" - "github.com/golang/glog" "github.com/aws/aws-application-networking-k8s/pkg/latticestore" "github.com/aws/aws-application-networking-k8s/pkg/model/core" @@ -38,15 +38,15 @@ func (r *ruleSynthesizer) Synthesize(ctx context.Context) error { var resRule []*latticemodel.Rule err := r.stack.ListResources(&resRule) + if err != nil { + r.log.Debugf("Error while synthesizing rules %v, %s", resRule, err) + } - glog.V(6).Infof("Synthesize rule = %v, err :%v \n", resRule, err) updatePriority := false for _, rule := range resRule { ruleResp, err := r.rule.Create(ctx, rule) - if err != nil { - glog.V(6).Infof("Failed to create rule %v, err :%v \n", rule, err) return err } @@ -54,65 +54,65 @@ func (r *ruleSynthesizer) Synthesize(ctx context.Context) error { updatePriority = true } - glog.V(6).Infof("Synthesise rule %v, ruleResp:%v \n", rule, ruleResp) + r.log.Debugf("Synthesise rule %s, ruleResp: %+v", rule.Spec.RuleID, ruleResp) rule.Status = &ruleResp } // handle delete sdkRules, err := r.getSDKRules(ctx) - glog.V(6).Infof("rule>>> synthesize, sdkRules :%v err: %v \n", sdkRules, err) - - for _, sdkrule := range sdkRules { - _, err := r.findMatchedRule(ctx, sdkrule.RuleID, sdkrule.ListenerID, sdkrule.ServiceID, resRule) + if err != nil { + r.log.Debugf("Error while getting rules %v, %s", sdkRules, err) + } - if err == nil { - continue + for _, sdkRule := range sdkRules { + _, err := r.findMatchedRule(ctx, sdkRule.RuleID, sdkRule.ListenerID, sdkRule.ServiceID, resRule) + if err != nil { + r.log.Debugf("Error while finding matching rule for service %s, listener %s, rule %s. %s", + sdkRule.ServiceID, sdkRule.ListenerID, sdkRule.RuleID, err) + err := r.rule.Delete(ctx, sdkRule.RuleID, sdkRule.ListenerID, sdkRule.ServiceID) + if err != nil { + r.log.Debugf("Error while deleting rule for service %s, listener %s, rule %s. %s", + sdkRule.ServiceID, sdkRule.ListenerID, sdkRule.RuleID, err) + } } - - glog.V(2).Infof("rule-synthersize >>> deleting rule %v\n", *sdkrule) - r.rule.Delete(ctx, sdkrule.RuleID, sdkrule.ListenerID, sdkrule.ServiceID) } if updatePriority { - //r.rule. err := r.rule.Update(ctx, resRule) - glog.V(6).Infof("rule --synthesie update rule priority err: %v\n", err) + if err != nil { + r.log.Debugf("Error while updating rule priority for rules %+v. %s", resRule, err) + } } return nil } -func (r *ruleSynthesizer) findMatchedRule(ctx context.Context, sdkRuleID string, listern string, service string, - resRule []*latticemodel.Rule) (*latticemodel.Rule, error) { +func (r *ruleSynthesizer) findMatchedRule( + ctx context.Context, + sdkRuleId string, + listener string, + service string, + resRule []*latticemodel.Rule, +) (*latticemodel.Rule, error) { var modelRule *latticemodel.Rule = nil - - glog.V(6).Infof("findMatchedRule: skdRuleID %v, listener %v, service %v \n", sdkRuleID, listern, service) - sdkRuleDetail, err := r.rule.Get(ctx, service, listern, sdkRuleID) - + sdkRuleDetail, err := r.rule.Get(ctx, service, listener, sdkRuleId) if err != nil { - glog.V(6).Infof("findMatchRule, rule not found err:%v\n", err) - return modelRule, errors.New("rule not found") + return modelRule, err } if sdkRuleDetail.Match == nil || sdkRuleDetail.Match.HttpMatch == nil { - glog.V(6).Infof("no HTTPMatch ") - return modelRule, errors.New("rule not found") + return modelRule, errors.New("rule not found, no HTTPMatch") } for _, modelRule := range resRule { sameRule := isRulesSame(r.log, modelRule, sdkRuleDetail) - - if !sameRule { - continue + if sameRule { + return modelRule, nil } - - glog.V(6).Infof("findMatchedRule: found matched modelRule %v \n", modelRule) - return modelRule, nil } - glog.V(6).Infof("findMatchedRule, sdk rule %v not found in model rules %v \n", sdkRuleID, resRule) - return modelRule, errors.New("failed to find matching rule in model") + return modelRule, fmt.Errorf("failed to find matching rule in model for rule %s", sdkRuleId) } func (r *ruleSynthesizer) getSDKRules(ctx context.Context) ([]*latticemodel.RuleStatus, error) { @@ -122,41 +122,43 @@ func (r *ruleSynthesizer) getSDKRules(ctx context.Context) ([]*latticemodel.Rule var resRule []*latticemodel.Rule err := r.stack.ListResources(&resService) - - glog.V(6).Infof("getSDKRules service: %v err: %v \n", resService, err) + if err != nil { + r.log.Errorf("Error listing services: %s", err) + } err = r.stack.ListResources(&resListener) - - glog.V(6).Infof("getSDKRules, listener: %v err: %v \n ", resListener, err) + if err != nil { + r.log.Errorf("Error listing listeners: %s", err) + } err = r.stack.ListResources(&resRule) - glog.V(6).Infof("getSDKRules, rule %v err %v \n", resRule, err) + if err != nil { + r.log.Errorf("Error listing rules: %s", err) + } for _, service := range resService { latticeService, err := r.rule.Cloud().Lattice().FindService(ctx, service) if err != nil { - glog.V(6).Infof("getSDKRules: failed to find service %v, err %v \n", service, err) - return sdkRules, errors.New("getSDKRules: failed to find service") + return sdkRules, fmt.Errorf("failed to find service %s-%s, %s", + service.Spec.Name, service.Spec.Namespace, err) } listeners, err := r.latticestore.GetAllListeners(service.Spec.Name, service.Spec.Namespace) + if err != nil { + return sdkRules, err + } if len(listeners) == 0 { - glog.V(6).Infof("getSDKRules, no listeners in store service %v \n", service) return sdkRules, errors.New("failed to find listener in store") - } for _, listener := range listeners { rules, _ := r.rule.List(ctx, aws.StringValue(latticeService.Id), listener.ID) - sdkRules = append(sdkRules, rules...) - } } return sdkRules, nil - } func (r *ruleSynthesizer) PostSynthesize(ctx context.Context) error { diff --git a/pkg/deploy/lattice/service_network_manager.go b/pkg/deploy/lattice/service_network_manager.go index 46bb2541..a35ecdda 100644 --- a/pkg/deploy/lattice/service_network_manager.go +++ b/pkg/deploy/lattice/service_network_manager.go @@ -7,6 +7,7 @@ import ( "github.com/golang/glog" "github.com/aws/aws-application-networking-k8s/pkg/aws/services" + "github.com/aws/aws-application-networking-k8s/pkg/utils/gwlog" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/service/vpclattice" @@ -17,9 +18,9 @@ import ( ) type ServiceNetworkManager interface { - Create(ctx context.Context, service_network *latticemodel.ServiceNetwork) (latticemodel.ServiceNetworkStatus, error) + Create(ctx context.Context, serviceNetwork *latticemodel.ServiceNetwork) (latticemodel.ServiceNetworkStatus, error) List(ctx context.Context) ([]string, error) - Delete(ctx context.Context, service_network string) error + Delete(ctx context.Context, serviceNetwork string) error } type serviceNetworkOutput struct { @@ -27,22 +28,22 @@ type serviceNetworkOutput struct { snTags *vpclattice.ListTagsForResourceOutput } -func NewDefaultServiceNetworkManager(cloud lattice_aws.Cloud) *defaultServiceNetworkManager { +func NewDefaultServiceNetworkManager(log gwlog.Logger, cloud lattice_aws.Cloud) *defaultServiceNetworkManager { return &defaultServiceNetworkManager{ + log: log, cloud: cloud, } } -var _service_networkManager = &defaultServiceNetworkManager{} - type defaultServiceNetworkManager struct { + log gwlog.Logger cloud lattice_aws.Cloud } // Create will try to create a service_network and associate the service_network with vpc // return error when: // -// ListServiceNetworkesWithContext returns error +// ListServiceNetworksWithContext returns error // CreateServiceNetworkWithContext returns error // CreateServiceNetworkVpcAssociationInput returns error // @@ -53,131 +54,125 @@ type defaultServiceNetworkManager struct { // return errors.New(LATTICE_RETRY) when: // // CreateServiceNetworkVpcAssociationInput returns ServiceNetworkVpcAssociationStatusFailed/ServiceNetworkVpcAssociationStatusCreateInProgress/MeshVpcAssociationStatusDeleteInProgress -func (m *defaultServiceNetworkManager) Create(ctx context.Context, service_network *latticemodel.ServiceNetwork) (latticemodel.ServiceNetworkStatus, error) { +func (m *defaultServiceNetworkManager) Create( + ctx context.Context, + serviceNetwork *latticemodel.ServiceNetwork, +) (latticemodel.ServiceNetworkStatus, error) { // check if exists - service_networkSummary, err := m.cloud.Lattice().FindServiceNetwork(ctx, service_network.Spec.Name, "") + serviceNetworkSummary, err := m.cloud.Lattice().FindServiceNetwork(ctx, serviceNetwork.Spec.Name, "") if err != nil && !services.IsNotFoundError(err) { return latticemodel.ServiceNetworkStatus{ServiceNetworkARN: "", ServiceNetworkID: ""}, err } // pre declaration - var service_networkID string - var service_networkArn string - var isServiceNetworkAssociatedWithVPC bool - var service_networkAssociatedWithCurrentVPCId *string + var serviceNetworkId string + var serviceNetworkArn string + var isServiceNetworkAssociatedWithVpc bool + var serviceNetworkAssociatedWithCurrentVpcId *string vpcLatticeSess := m.cloud.Lattice() - if service_networkSummary == nil { - glog.V(2).Infof("Create ServiceNetwork, service_network[%v] and tag it with vpciID[%s]\n", service_network, config.VpcID) - // Add tag to show this is the VPC create this servicenetwork - // This means, the servicenetwork can only be deleted by the controller running in this VPC - service_networkInput := vpclattice.CreateServiceNetworkInput{ - Name: &service_network.Spec.Name, + if serviceNetworkSummary == nil { + m.log.Debugf("Creating ServiceNetwork %s and tagging it with vpcId %s", + serviceNetwork.Spec.Name, config.VpcID) + + // Add tag to show this is the VPC create this service network + // This means, the service network can only be deleted by the controller running in this VPC + serviceNetworkInput := vpclattice.CreateServiceNetworkInput{ + Name: &serviceNetwork.Spec.Name, Tags: make(map[string]*string), } - service_networkInput.Tags[latticemodel.K8SServiceNetworkOwnedByVPC] = &config.VpcID + serviceNetworkInput.Tags[latticemodel.K8SServiceNetworkOwnedByVPC] = &config.VpcID - glog.V(2).Infof("Create service_network >>>> req[%v]", service_networkInput) - resp, err := vpcLatticeSess.CreateServiceNetworkWithContext(ctx, &service_networkInput) - glog.V(2).Infof("Create service_network >>>> resp[%v], err : %v", resp, err) + m.log.Debugf("Creating serviceNetwork %+v", serviceNetworkInput) + resp, err := vpcLatticeSess.CreateServiceNetworkWithContext(ctx, &serviceNetworkInput) if err != nil { - glog.V(2).Infof("Failed to create service_network[%v], err: %v", service_network, err) return latticemodel.ServiceNetworkStatus{ServiceNetworkARN: "", ServiceNetworkID: ""}, err } - service_networkID = aws.StringValue(resp.Id) - service_networkArn = aws.StringValue(resp.Arn) - isServiceNetworkAssociatedWithVPC = false - glog.V(6).Infof(" ServiceNetwork Create API resp [%v]\n", resp) + serviceNetworkId = aws.StringValue(resp.Id) + serviceNetworkArn = aws.StringValue(resp.Arn) + isServiceNetworkAssociatedWithVpc = false } else { - glog.V(6).Infof("service_network[%v] exists, further check association", service_network) - service_networkID = aws.StringValue(service_networkSummary.SvcNetwork.Id) - service_networkArn = aws.StringValue(service_networkSummary.SvcNetwork.Arn) - isServiceNetworkAssociatedWithVPC, service_networkAssociatedWithCurrentVPCId, _, err = m.isServiceNetworkAssociatedWithVPC(ctx, service_networkID) + glog.V(6).Infof("serviceNetwork %s exists, checking its VPC association", serviceNetwork.Spec.Name) + serviceNetworkId = aws.StringValue(serviceNetworkSummary.SvcNetwork.Id) + serviceNetworkArn = aws.StringValue(serviceNetworkSummary.SvcNetwork.Arn) + isServiceNetworkAssociatedWithVpc, serviceNetworkAssociatedWithCurrentVpcId, _, err = m.isServiceNetworkAssociatedWithVPC(ctx, serviceNetworkId) if err != nil { return latticemodel.ServiceNetworkStatus{ServiceNetworkARN: "", ServiceNetworkID: ""}, err } } - if service_network.Spec.AssociateToVPC == true { - if isServiceNetworkAssociatedWithVPC == false { + if serviceNetwork.Spec.AssociateToVPC == true { + if isServiceNetworkAssociatedWithVpc == false { // current state: service network is associated to VPC // desired state: associate this service network to VPC createServiceNetworkVpcAssociationInput := vpclattice.CreateServiceNetworkVpcAssociationInput{ - ServiceNetworkIdentifier: &service_networkID, + ServiceNetworkIdentifier: &serviceNetworkId, VpcIdentifier: &config.VpcID, } - glog.V(2).Infof("Create service_network/vpc association >>>> req[%v]", createServiceNetworkVpcAssociationInput) + m.log.Debugf("Creating association between ServiceNetwork %s and VPC %s", serviceNetworkId, config.VpcID) resp, err := vpcLatticeSess.CreateServiceNetworkVpcAssociationWithContext(ctx, &createServiceNetworkVpcAssociationInput) - glog.V(2).Infof("Create service_network and vpc association here >>>> resp[%v] err [%v]\n", resp, err) - // Associate service_network with vpc if err != nil { - glog.V(2).Infof("Failed to associate service_network[%v] and vpc, err: %v", service_network, err) return latticemodel.ServiceNetworkStatus{ServiceNetworkARN: "", ServiceNetworkID: ""}, err - } else { - service_networkVPCAssociationStatus := aws.StringValue(resp.Status) - switch service_networkVPCAssociationStatus { - case vpclattice.ServiceNetworkVpcAssociationStatusCreateInProgress: - return latticemodel.ServiceNetworkStatus{ServiceNetworkARN: "", ServiceNetworkID: ""}, errors.New(LATTICE_RETRY) - case vpclattice.ServiceNetworkVpcAssociationStatusActive: - return latticemodel.ServiceNetworkStatus{ServiceNetworkARN: service_networkArn, ServiceNetworkID: service_networkID}, nil - case vpclattice.ServiceNetworkVpcAssociationStatusCreateFailed: - return latticemodel.ServiceNetworkStatus{ServiceNetworkARN: "", ServiceNetworkID: ""}, errors.New(LATTICE_RETRY) - case vpclattice.ServiceNetworkVpcAssociationStatusDeleteFailed: - return latticemodel.ServiceNetworkStatus{ServiceNetworkARN: "", ServiceNetworkID: ""}, errors.New(LATTICE_RETRY) - case vpclattice.ServiceNetworkVpcAssociationStatusDeleteInProgress: - return latticemodel.ServiceNetworkStatus{ServiceNetworkARN: "", ServiceNetworkID: ""}, errors.New(LATTICE_RETRY) - } + } + + serviceNetworkVpcAssociationStatus := aws.StringValue(resp.Status) + switch serviceNetworkVpcAssociationStatus { + case vpclattice.ServiceNetworkVpcAssociationStatusCreateInProgress: + return latticemodel.ServiceNetworkStatus{ServiceNetworkARN: "", ServiceNetworkID: ""}, errors.New(LATTICE_RETRY) + case vpclattice.ServiceNetworkVpcAssociationStatusActive: + return latticemodel.ServiceNetworkStatus{ServiceNetworkARN: serviceNetworkArn, ServiceNetworkID: serviceNetworkId}, nil + case vpclattice.ServiceNetworkVpcAssociationStatusCreateFailed: + return latticemodel.ServiceNetworkStatus{ServiceNetworkARN: "", ServiceNetworkID: ""}, errors.New(LATTICE_RETRY) + case vpclattice.ServiceNetworkVpcAssociationStatusDeleteFailed: + return latticemodel.ServiceNetworkStatus{ServiceNetworkARN: "", ServiceNetworkID: ""}, errors.New(LATTICE_RETRY) + case vpclattice.ServiceNetworkVpcAssociationStatusDeleteInProgress: + return latticemodel.ServiceNetworkStatus{ServiceNetworkARN: "", ServiceNetworkID: ""}, errors.New(LATTICE_RETRY) } } } else { - if isServiceNetworkAssociatedWithVPC == true { + if isServiceNetworkAssociatedWithVpc == true { // current state: service network is associated to VPC // desired state: not to associate this service network to VPC - glog.V(6).Infof("Disassociate service_network(%v) from vpc association", service_network.Spec.Name) - + m.log.Debugf("Disassociating ServiceNetwork %s from VPC", serviceNetwork.Spec.Name) deleteServiceNetworkVpcAssociationInput := vpclattice.DeleteServiceNetworkVpcAssociationInput{ - ServiceNetworkVpcAssociationIdentifier: service_networkAssociatedWithCurrentVPCId, + ServiceNetworkVpcAssociationIdentifier: serviceNetworkAssociatedWithCurrentVpcId, } - - glog.V(2).Infof("Delete service_network association >>>> req[%v]", deleteServiceNetworkVpcAssociationInput) resp, err := vpcLatticeSess.DeleteServiceNetworkVpcAssociationWithContext(ctx, &deleteServiceNetworkVpcAssociationInput) - glog.V(2).Infof("Delete service_network association >>>> resp[%v],err [%v]", resp, err) if err != nil { - glog.V(2).Infof("Failed to delete association for %v err=%v , resp = %v\n", service_network.Spec.Name, err, resp) + m.log.Errorf("Failed to delete association for %s, with response %s and err %s", + serviceNetwork.Spec.Name, resp, err) } // return retry and check later if disassociation workflow finishes return latticemodel.ServiceNetworkStatus{ServiceNetworkARN: "", ServiceNetworkID: ""}, errors.New(LATTICE_RETRY) - } - glog.V(2).Infof("Created service_network(%v) without vpc association", service_network.Spec.Name) + m.log.Debugf("Created serviceNetwork %s without VPC association", serviceNetwork.Spec.Name) } - return latticemodel.ServiceNetworkStatus{ServiceNetworkARN: service_networkArn, ServiceNetworkID: service_networkID}, nil + return latticemodel.ServiceNetworkStatus{ServiceNetworkARN: serviceNetworkArn, ServiceNetworkID: serviceNetworkId}, nil } // return all service_networkes associated with VPC func (m *defaultServiceNetworkManager) List(ctx context.Context) ([]string, error) { vpcLatticeSess := m.cloud.Lattice() - service_networkListInput := vpclattice.ListServiceNetworksInput{MaxResults: nil} - resp, err := vpcLatticeSess.ListServiceNetworksAsList(ctx, &service_networkListInput) + serviceNetworkListInput := vpclattice.ListServiceNetworksInput{MaxResults: nil} + resp, err := vpcLatticeSess.ListServiceNetworksAsList(ctx, &serviceNetworkListInput) - var service_networkList = make([]string, 0) + var serviceNetworkList = make([]string, 0) if err == nil { for _, r := range resp { - service_networkList = append(service_networkList, aws.StringValue(r.Name)) + serviceNetworkList = append(serviceNetworkList, aws.StringValue(r.Name)) } } - glog.V(6).Infof("defaultServiceNetworkManager: List return %v \n", service_networkList) - return service_networkList, nil + return serviceNetworkList, nil } func (m *defaultServiceNetworkManager) Delete(ctx context.Context, snName string) error { - service_networkSummary, err := m.cloud.Lattice().FindServiceNetwork(ctx, snName, "") + serviceNetworkSummary, err := m.cloud.Lattice().FindServiceNetwork(ctx, snName, "") if err != nil { if services.IsNotFoundError(err) { - glog.V(2).Infoln("Service network not found, assume already deleted", snName) + m.log.Debugf("ServiceNetwork %s not found, assuming it's already deleted", snName) return nil } else { return err @@ -185,77 +180,75 @@ func (m *defaultServiceNetworkManager) Delete(ctx context.Context, snName string } vpcLatticeSess := m.cloud.Lattice() - service_networkID := aws.StringValue(service_networkSummary.SvcNetwork.Id) + serviceNetworkId := aws.StringValue(serviceNetworkSummary.SvcNetwork.Id) - _, service_networkAssociatedWithCurrentVPCId, assocResp, err := m.isServiceNetworkAssociatedWithVPC(ctx, service_networkID) + _, serviceNetworkAssociatedWithCurrentVpcId, assocResp, err := m.isServiceNetworkAssociatedWithVPC(ctx, serviceNetworkId) if err != nil { return err } - if service_networkAssociatedWithCurrentVPCId != nil { - // current VPC is associated with this service network + if serviceNetworkAssociatedWithCurrentVpcId != nil { + // Current VPC is associated with this service network // Happy case, disassociate the VPC from service network deleteServiceNetworkVpcAssociationInput := vpclattice.DeleteServiceNetworkVpcAssociationInput{ - ServiceNetworkVpcAssociationIdentifier: service_networkAssociatedWithCurrentVPCId, + ServiceNetworkVpcAssociationIdentifier: serviceNetworkAssociatedWithCurrentVpcId, } - glog.V(2).Infof("DeleteServiceNetworkVpcAssociationInput >>>> %v\n", deleteServiceNetworkVpcAssociationInput) - resp, err := vpcLatticeSess.DeleteServiceNetworkVpcAssociationWithContext(ctx, &deleteServiceNetworkVpcAssociationInput) - glog.V(2).Infof("DeleteServiceNetworkVPCAssociationResp: service_network %v , resp %v, err %v \n", snName, resp, err) + m.log.Debugf("Deleting ServiceNetworkVpcAssociation %s", *serviceNetworkAssociatedWithCurrentVpcId) + _, err := vpcLatticeSess.DeleteServiceNetworkVpcAssociationWithContext(ctx, &deleteServiceNetworkVpcAssociationInput) if err != nil { - glog.V(2).Infof("Failed to delete association for %v, err: %v \n", snName, err) + m.log.Debugf("Failed to delete association for %s, err: %s", snName, err) } // retry later to check if VPC disassociation workflow finishes return errors.New(LATTICE_RETRY) - } // check if this VPC is the one created the service network needToDelete := false - if service_networkSummary.Tags != nil { - vpcOwner, ok := service_networkSummary.Tags[latticemodel.K8SServiceNetworkOwnedByVPC] + if serviceNetworkSummary.Tags != nil { + vpcOwner, ok := serviceNetworkSummary.Tags[latticemodel.K8SServiceNetworkOwnedByVPC] if ok && *vpcOwner == config.VpcID { needToDelete = true } else { if ok { - glog.V(2).Infof("Skip deleting, the service network[%v] is created by VPC %v", snName, *vpcOwner) + m.log.Debugf("Skip deleting, service network %s is created by VPC %s", snName, *vpcOwner) } else { - glog.V(2).Infof("Skip deleting, the service network[%v] is not created by K8S, since there is no tag", snName) + m.log.Debugf("Skip deleting, service network %s is not created by K8S, since there is no tag", snName) } } } if needToDelete { - if len(assocResp) != 0 { - glog.V(2).Infof("Retry deleting %v later, due to service network still has VPCs associated", snName) + m.log.Debugf("Retry deleting service network %s later since it still has VPCs associated", snName) return errors.New(LATTICE_RETRY) } + m.log.Debugf("Deleting service network %s", snName) deleteInput := vpclattice.DeleteServiceNetworkInput{ - ServiceNetworkIdentifier: &service_networkID, + ServiceNetworkIdentifier: &serviceNetworkId, } - glog.V(2).Infof("DeleteServiceNetworkWithContext: service_network %v", snName) resp, err := vpcLatticeSess.DeleteServiceNetworkWithContext(ctx, &deleteInput) - glog.V(2).Infof("DeleteServiceNetworkWithContext: service_network %v , resp %v, err %v \n", snName, resp, err) if err != nil { + m.log.Debugf("Failed to delete service network %s due to %s", snName, resp) return errors.New(LATTICE_RETRY) } - glog.V(2).Infof("Successfully delete service_network %v\n", snName) return err - } else { - glog.V(2).Infof("Deleting service_network (%v) Skipped, since it is owned by different VPC ", snName) + m.log.Debugf("Skipped deleting service network %s since it is owned by different VPC", snName) return nil } } // If service_network exists, check if service_network has already associated with VPC -func (m *defaultServiceNetworkManager) isServiceNetworkAssociatedWithVPC(ctx context.Context, service_networkID string) (bool, *string, []*vpclattice.ServiceNetworkVpcAssociationSummary, error) { +func (m *defaultServiceNetworkManager) isServiceNetworkAssociatedWithVPC( + ctx context.Context, + serviceNetworkId string, +) (bool, *string, []*vpclattice.ServiceNetworkVpcAssociationSummary, error) { vpcLatticeSess := m.cloud.Lattice() // TODO: can pass vpc id to ListServiceNetworkVpcAssociationsInput, could return err if no associations associationStatusInput := vpclattice.ListServiceNetworkVpcAssociationsInput{ - ServiceNetworkIdentifier: &service_networkID, + ServiceNetworkIdentifier: &serviceNetworkId, } resp, err := vpcLatticeSess.ListServiceNetworkVpcAssociationsAsList(ctx, &associationStatusInput) @@ -273,19 +266,19 @@ func (m *defaultServiceNetworkManager) isServiceNetworkAssociatedWithVPC(ctx con if err == nil { switch associationStatus { case vpclattice.ServiceNetworkVpcAssociationStatusActive: - glog.V(6).Infoln("Mesh and Vpc association is active.") + m.log.Debugf("Mesh and Vpc association is active.") return true, r.Id, resp, nil case vpclattice.ServiceNetworkVpcAssociationStatusCreateFailed: - glog.V(6).Infoln("Mesh and Vpc association does not exists, start creating service_network and vpc association") + m.log.Debugf("Mesh and Vpc association does not exists, start creating service_network and vpc association") return false, r.Id, resp, nil case vpclattice.ServiceNetworkVpcAssociationStatusDeleteFailed: - glog.V(6).Infoln("Mesh and Vpc association failed to delete") + m.log.Debugf("Mesh and Vpc association failed to delete") return true, r.Id, resp, nil case vpclattice.ServiceNetworkVpcAssociationStatusDeleteInProgress: - glog.V(6).Infoln("ServiceNetwork and Vpc association is being deleted, please retry later") + m.log.Debugf("ServiceNetwork and Vpc association is being deleted, retry later") return true, r.Id, resp, errors.New(LATTICE_RETRY) case vpclattice.ServiceNetworkVpcAssociationStatusCreateInProgress: - glog.V(6).Infoln("ServiceNetwork and Vpc association is being created, please retry later") + m.log.Debugf("ServiceNetwork and Vpc association is being created, retry later") return true, r.Id, resp, errors.New(LATTICE_RETRY) } } diff --git a/pkg/deploy/lattice/service_network_manager_mock.go b/pkg/deploy/lattice/service_network_manager_mock.go index c30f578a..a11f8f18 100644 --- a/pkg/deploy/lattice/service_network_manager_mock.go +++ b/pkg/deploy/lattice/service_network_manager_mock.go @@ -36,32 +36,32 @@ func (m *MockServiceNetworkManager) EXPECT() *MockServiceNetworkManagerMockRecor } // Create mocks base method. -func (m *MockServiceNetworkManager) Create(ctx context.Context, service_network *lattice.ServiceNetwork) (lattice.ServiceNetworkStatus, error) { +func (m *MockServiceNetworkManager) Create(ctx context.Context, serviceNetwork *lattice.ServiceNetwork) (lattice.ServiceNetworkStatus, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Create", ctx, service_network) + ret := m.ctrl.Call(m, "Create", ctx, serviceNetwork) ret0, _ := ret[0].(lattice.ServiceNetworkStatus) ret1, _ := ret[1].(error) return ret0, ret1 } // Create indicates an expected call of Create. -func (mr *MockServiceNetworkManagerMockRecorder) Create(ctx, service_network interface{}) *gomock.Call { +func (mr *MockServiceNetworkManagerMockRecorder) Create(ctx, serviceNetwork interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockServiceNetworkManager)(nil).Create), ctx, service_network) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockServiceNetworkManager)(nil).Create), ctx, serviceNetwork) } // Delete mocks base method. -func (m *MockServiceNetworkManager) Delete(ctx context.Context, service_network string) error { +func (m *MockServiceNetworkManager) Delete(ctx context.Context, serviceNetwork string) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Delete", ctx, service_network) + ret := m.ctrl.Call(m, "Delete", ctx, serviceNetwork) ret0, _ := ret[0].(error) return ret0 } // Delete indicates an expected call of Delete. -func (mr *MockServiceNetworkManagerMockRecorder) Delete(ctx, service_network interface{}) *gomock.Call { +func (mr *MockServiceNetworkManagerMockRecorder) Delete(ctx, serviceNetwork interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockServiceNetworkManager)(nil).Delete), ctx, service_network) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockServiceNetworkManager)(nil).Delete), ctx, serviceNetwork) } // List mocks base method. diff --git a/pkg/deploy/lattice/service_network_manager_test.go b/pkg/deploy/lattice/service_network_manager_test.go index b343b1b7..fee20ccf 100644 --- a/pkg/deploy/lattice/service_network_manager_test.go +++ b/pkg/deploy/lattice/service_network_manager_test.go @@ -3,15 +3,20 @@ package lattice import ( "context" "errors" + mocks_aws "github.com/aws/aws-application-networking-k8s/pkg/aws" mocks "github.com/aws/aws-application-networking-k8s/pkg/aws/services" "github.com/aws/aws-application-networking-k8s/pkg/config" - "github.com/aws/aws-sdk-go/service/vpclattice" + "github.com/aws/aws-application-networking-k8s/pkg/utils/gwlog" + "testing" - latticemodel "github.com/aws/aws-application-networking-k8s/pkg/model/lattice" + "github.com/aws/aws-sdk-go/service/vpclattice" + "github.com/golang/mock/gomock" "github.com/stretchr/testify/assert" + + latticemodel "github.com/aws/aws-application-networking-k8s/pkg/model/lattice" ) // ServiceNetwork does not exist before,happy case. @@ -48,7 +53,7 @@ func Test_CreateServiceNetwork_MeshNotExist_NoNeedToAssociate(t *testing.T) { mockLattice.EXPECT().FindServiceNetwork(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, &mocks.NotFoundError{}).Times(1) - meshManager := NewDefaultServiceNetworkManager(mockCloud) + meshManager := NewDefaultServiceNetworkManager(gwlog.FallbackLogger, mockCloud) resp, err := meshManager.Create(ctx, &meshCreateInput) assert.Nil(t, err) @@ -105,7 +110,7 @@ func Test_CreateServiceNetwork_MeshNotExist_NeedToAssociate(t *testing.T) { mockCloud.EXPECT().Lattice().Return(mockLattice).AnyTimes() - meshManager := NewDefaultServiceNetworkManager(mockCloud) + meshManager := NewDefaultServiceNetworkManager(gwlog.FallbackLogger, mockCloud) resp, err := meshManager.Create(ctx, &meshCreateInput) assert.Nil(t, err) @@ -132,7 +137,7 @@ func Test_CreateServiceNetwork_ListFailed(t *testing.T) { mockLattice.EXPECT().FindServiceNetwork(ctx, gomock.Any(), gomock.Any()).Return(nil, errors.New("ERROR")) mockCloud.EXPECT().Lattice().Return(mockLattice).AnyTimes() - meshManager := NewDefaultServiceNetworkManager(mockCloud) + meshManager := NewDefaultServiceNetworkManager(gwlog.FallbackLogger, mockCloud) resp, err := meshManager.Create(ctx, &meshCreateInput) assert.NotNil(t, err) @@ -184,7 +189,7 @@ func Test_CreateServiceNetwork_MeshAlreadyExist_ServiceNetworkVpcAssociationStat }, nil) mockCloud.EXPECT().Lattice().Return(mockLattice).AnyTimes() - meshManager := NewDefaultServiceNetworkManager(mockCloud) + meshManager := NewDefaultServiceNetworkManager(gwlog.FallbackLogger, mockCloud) resp, err := meshManager.Create(ctx, &meshCreateInput) assert.NotNil(t, err) @@ -236,7 +241,7 @@ func Test_CreateServiceNetwork_MeshAlreadyExist_ServiceNetworkVpcAssociationStat }, nil) mockCloud.EXPECT().Lattice().Return(mockLattice).AnyTimes() - meshManager := NewDefaultServiceNetworkManager(mockCloud) + meshManager := NewDefaultServiceNetworkManager(gwlog.FallbackLogger, mockCloud) resp, err := meshManager.Create(ctx, &meshCreateInput) assert.NotNil(t, err) @@ -287,7 +292,7 @@ func Test_CreateServiceNetwork_MeshAlreadyExist_ServiceNetworkVpcAssociationStat mockLattice.EXPECT().ListServiceNetworkVpcAssociationsAsList(ctx, gomock.Any()).Return(statusServiceNetworkVPCOutput, nil) mockCloud.EXPECT().Lattice().Return(mockLattice).AnyTimes() - meshManager := NewDefaultServiceNetworkManager(mockCloud) + meshManager := NewDefaultServiceNetworkManager(gwlog.FallbackLogger, mockCloud) resp, err := meshManager.Create(ctx, &meshCreateInput) assert.Nil(t, err) @@ -341,7 +346,7 @@ func Test_CreateServiceNetwork_MeshAlreadyExist_AssociateToNotAssociate(t *testi mockCloud.EXPECT().Lattice().Return(mockLattice).AnyTimes() - meshManager := NewDefaultServiceNetworkManager(mockCloud) + meshManager := NewDefaultServiceNetworkManager(gwlog.FallbackLogger, mockCloud) _, err := meshManager.Create(ctx, &meshCreateInput) assert.Equal(t, err, errors.New(LATTICE_RETRY)) @@ -405,7 +410,7 @@ func Test_CreateServiceNetwork_MeshAlreadyExist_ServiceNetworkVpcAssociationStat mockLattice.EXPECT().CreateServiceNetworkVpcAssociationWithContext(ctx, createServiceNetworkVpcAssociationInput).Return(createServiceNetworkVPCAssociationOutput, nil) mockCloud.EXPECT().Lattice().Return(mockLattice).AnyTimes() - meshManager := NewDefaultServiceNetworkManager(mockCloud) + meshManager := NewDefaultServiceNetworkManager(gwlog.FallbackLogger, mockCloud) resp, err := meshManager.Create(ctx, &meshCreateInput) assert.Nil(t, err) @@ -471,7 +476,7 @@ func Test_CreateServiceNetwork_MeshAlreadyExist_MeshAssociatedWithOtherVPC(t *te mockLattice.EXPECT().CreateServiceNetworkVpcAssociationWithContext(ctx, createServiceNetworkVpcAssociationInput).Return(createServiceNetworkVPCAssociationOutput, nil) mockCloud.EXPECT().Lattice().Return(mockLattice).AnyTimes() - meshManager := NewDefaultServiceNetworkManager(mockCloud) + meshManager := NewDefaultServiceNetworkManager(gwlog.FallbackLogger, mockCloud) resp, err := meshManager.Create(ctx, &meshCreateInput) assert.Nil(t, err) @@ -523,7 +528,7 @@ func Test_CreateServiceNetwork_MeshNotExist_ServiceNetworkVpcAssociationStatusFa mockLattice.EXPECT().CreateServiceNetworkVpcAssociationWithContext(ctx, createServiceNetworkVpcAssociationInput).Return(createServiceNetworkVPCAssociationOutput, nil) mockCloud.EXPECT().Lattice().Return(mockLattice).AnyTimes() - meshManager := NewDefaultServiceNetworkManager(mockCloud) + meshManager := NewDefaultServiceNetworkManager(gwlog.FallbackLogger, mockCloud) resp, err := meshManager.Create(ctx, &CreateInput) assert.NotNil(t, err) @@ -574,7 +579,7 @@ func Test_CreateServiceNetwork_MeshNOTExist_ServiceNetworkVpcAssociationStatusCr mockLattice.EXPECT().CreateServiceNetworkVpcAssociationWithContext(ctx, createServiceNetworkVpcAssociationInput).Return(createServiceNetworkVPCAssociationOutput, nil) mockCloud.EXPECT().Lattice().Return(mockLattice).AnyTimes() - meshManager := NewDefaultServiceNetworkManager(mockCloud) + meshManager := NewDefaultServiceNetworkManager(gwlog.FallbackLogger, mockCloud) resp, err := meshManager.Create(ctx, &CreateInput) assert.NotNil(t, err) @@ -625,7 +630,7 @@ func Test_CreateServiceNetwork_MeshNotExist_ServiceNetworkVpcAssociationStatusDe mockLattice.EXPECT().CreateServiceNetworkVpcAssociationWithContext(ctx, createServiceNetworkVpcAssociationInput).Return(createServiceNetworkVPCAssociationOutput, nil) mockCloud.EXPECT().Lattice().Return(mockLattice).AnyTimes() - meshManager := NewDefaultServiceNetworkManager(mockCloud) + meshManager := NewDefaultServiceNetworkManager(gwlog.FallbackLogger, mockCloud) resp, err := meshManager.Create(ctx, &CreateInput) assert.NotNil(t, err) @@ -673,7 +678,7 @@ func Test_CreateServiceNetwork_MeshNotExist_ServiceNetworkVpcAssociationReturnsE mockLattice.EXPECT().CreateServiceNetworkVpcAssociationWithContext(ctx, createServiceNetworkVpcAssociationInput).Return(createServiceNetworkVPCAssociationOutput, errors.New("ERROR")) mockCloud.EXPECT().Lattice().Return(mockLattice).AnyTimes() - meshManager := NewDefaultServiceNetworkManager(mockCloud) + meshManager := NewDefaultServiceNetworkManager(gwlog.FallbackLogger, mockCloud) resp, err := meshManager.Create(ctx, &CreateInput) assert.NotNil(t, err) @@ -715,7 +720,7 @@ func Test_CreateMesh_MeshNotExist_MeshCreateFailed(t *testing.T) { mockLattice.EXPECT().CreateServiceNetworkWithContext(ctx, meshCreateInput).Return(meshCreateOutput, errors.New("ERROR")) mockCloud.EXPECT().Lattice().Return(mockLattice).AnyTimes() - meshManager := NewDefaultServiceNetworkManager(mockCloud) + meshManager := NewDefaultServiceNetworkManager(gwlog.FallbackLogger, mockCloud) resp, err := meshManager.Create(ctx, &CreateInput) assert.NotNil(t, err) @@ -734,7 +739,7 @@ func Test_DeleteMesh_MeshNotExist(t *testing.T) { mockLattice.EXPECT().FindServiceNetwork(ctx, gomock.Any(), gomock.Any()).Return(nil, &mocks.NotFoundError{}) mockCloud.EXPECT().Lattice().Return(mockLattice).AnyTimes() - meshManager := NewDefaultServiceNetworkManager(mockCloud) + meshManager := NewDefaultServiceNetworkManager(gwlog.FallbackLogger, mockCloud) err := meshManager.Delete(ctx, "test") assert.Nil(t, err) @@ -775,7 +780,7 @@ func Test_DeleteMesh_MeshExistsNoAssociation(t *testing.T) { mockLattice.EXPECT().DeleteServiceNetworkWithContext(ctx, deleteMeshInout).Return(deleteMeshOutput, nil) mockCloud.EXPECT().Lattice().Return(mockLattice).AnyTimes() - meshManager := NewDefaultServiceNetworkManager(mockCloud) + meshManager := NewDefaultServiceNetworkManager(gwlog.FallbackLogger, mockCloud) err := meshManager.Delete(ctx, "test") assert.Nil(t, err) @@ -832,7 +837,7 @@ func Test_DeleteMesh_MeshExistsAssociatedWithVPC_Deleting(t *testing.T) { mockLattice.EXPECT().DeleteServiceNetworkVpcAssociationWithContext(ctx, deleteServiceNetworkVpcAssociationInput).Return(deleteServiceNetworkVpcAssociationOutput, nil) mockCloud.EXPECT().Lattice().Return(mockLattice).AnyTimes() - meshManager := NewDefaultServiceNetworkManager(mockCloud) + meshManager := NewDefaultServiceNetworkManager(gwlog.FallbackLogger, mockCloud) err := meshManager.Delete(ctx, "test") assert.NotNil(t, err) @@ -882,7 +887,7 @@ func Test_DeleteMesh_MeshExistsAssociatedWithOtherVPC(t *testing.T) { }, nil) mockCloud.EXPECT().Lattice().Return(mockLattice).AnyTimes() - meshManager := NewDefaultServiceNetworkManager(mockCloud) + meshManager := NewDefaultServiceNetworkManager(gwlog.FallbackLogger, mockCloud) err := meshManager.Delete(ctx, "test") assert.NotNil(t, err) @@ -927,7 +932,7 @@ func Test_DeleteMesh_MeshExistsAssociatedWithOtherVPC_NotCreatedByVPC(t *testing mockLattice.EXPECT().ListServiceNetworkVpcAssociationsAsList(ctx, gomock.Any()).Return(statusServiceNetworkVPCOutput, nil) mockCloud.EXPECT().Lattice().Return(mockLattice).AnyTimes() - meshManager := NewDefaultServiceNetworkManager(mockCloud) + meshManager := NewDefaultServiceNetworkManager(gwlog.FallbackLogger, mockCloud) err := meshManager.Delete(ctx, "test") assert.Nil(t, err) @@ -975,7 +980,7 @@ func Test_DeleteMesh_MeshExistsAssociatedWithOtherVPC_CreatedByVPC(t *testing.T) }, nil) mockCloud.EXPECT().Lattice().Return(mockLattice).AnyTimes() - meshManager := NewDefaultServiceNetworkManager(mockCloud) + meshManager := NewDefaultServiceNetworkManager(gwlog.FallbackLogger, mockCloud) err := meshManager.Delete(ctx, "test") assert.NotNil(t, err) @@ -1007,7 +1012,7 @@ func Test_ListMesh_MeshExists(t *testing.T) { mockLattice.EXPECT().ListServiceNetworksAsList(ctx, gomock.Any()).Return(listServiceNetworkOutput, nil) mockCloud.EXPECT().Lattice().Return(mockLattice) - meshManager := NewDefaultServiceNetworkManager(mockCloud) + meshManager := NewDefaultServiceNetworkManager(gwlog.FallbackLogger, mockCloud) meshList, err := meshManager.List(ctx) assert.Nil(t, err) @@ -1025,7 +1030,7 @@ func Test_ListMesh_NoMesh(t *testing.T) { mockLattice.EXPECT().ListServiceNetworksAsList(ctx, gomock.Any()).Return(listServiceNetworkOutput, nil) mockCloud.EXPECT().Lattice().Return(mockLattice) - meshManager := NewDefaultServiceNetworkManager(mockCloud) + meshManager := NewDefaultServiceNetworkManager(gwlog.FallbackLogger, mockCloud) meshList, err := meshManager.List(ctx) assert.Nil(t, err) diff --git a/pkg/deploy/stack_deployer.go b/pkg/deploy/stack_deployer.go index 7f30bec2..6102e395 100644 --- a/pkg/deploy/stack_deployer.go +++ b/pkg/deploy/stack_deployer.go @@ -37,11 +37,11 @@ type ResourceSynthesizer interface { PostSynthesize(ctx context.Context) error } -func NewServiceNetworkStackDeployer(cloud aws.Cloud, k8sClient client.Client) *serviceNetworkStackDeployer { +func NewServiceNetworkStackDeployer(log gwlog.Logger, cloud aws.Cloud, k8sClient client.Client) *serviceNetworkStackDeployer { return &serviceNetworkStackDeployer{ cloud: cloud, k8sclient: k8sClient, - latticeServiceNetworkManager: lattice.NewDefaultServiceNetworkManager(cloud), + latticeServiceNetworkManager: lattice.NewDefaultServiceNetworkManager(log, cloud), } } @@ -98,7 +98,7 @@ func NewLatticeServiceStackDeploy( targetsManager: lattice.NewTargetsManager(cloud, latticeDataStore), listenerManager: lattice.NewListenerManager(log, cloud, latticeDataStore), ruleManager: lattice.NewRuleManager(log, cloud, latticeDataStore), - dnsEndpointManager: externaldns.NewDnsEndpointManager(k8sClient), + dnsEndpointManager: externaldns.NewDnsEndpointManager(log, k8sClient), latticeDataStore: latticeDataStore, } }