@@ -28,7 +28,6 @@ import (
2828
2929 "github.com/GoogleCloudPlatform/k8s-cloud-provider/pkg/cloud"
3030 "github.com/GoogleCloudPlatform/k8s-cloud-provider/pkg/cloud/meta"
31- computebeta "google.golang.org/api/compute/v0.beta"
3231 compute "google.golang.org/api/compute/v1"
3332 "k8s.io/api/core/v1"
3433 "k8s.io/apimachinery/pkg/types"
@@ -169,24 +168,28 @@ func (g *Cloud) ensureInternalLoadBalancer(clusterName, clusterID string, svc *v
169168 return nil , err
170169 }
171170
172- newFRC := & forwardingRuleComposite {
173- name : loadBalancerName ,
174- description : & forwardingRuleDescription {ServiceName : nm .String ()},
175- ipAddress : ipToUse ,
176- backendService : backendServiceLink ,
177- ports : ports ,
178- ipProtocol : string (protocol ),
179- lbScheme : string (scheme ),
171+ fwdRuleDescription := & forwardingRuleDescription {ServiceName : nm .String ()}
172+ fwdRuleDescriptionString , err := fwdRuleDescription .marshal ()
173+ if err != nil {
174+ return nil , err
175+ }
176+ newFwdRule := & compute.ForwardingRule {
177+ Name : loadBalancerName ,
178+ Description : fwdRuleDescriptionString ,
179+ IPAddress : ipToUse ,
180+ BackendService : backendServiceLink ,
181+ Ports : ports ,
182+ IPProtocol : string (protocol ),
183+ LoadBalancingScheme : string (scheme ),
180184 // Given that CreateGCECloud will attempt to determine the subnet based off the network,
181185 // the subnetwork should rarely be unknown.
182- subnetwork : subnetworkURL ,
183- network : g .networkURL ,
186+ Subnetwork : subnetworkURL ,
187+ Network : g .networkURL ,
184188 }
185189 if options .AllowGlobalAccess {
186- newFRC .allowGlobalAccess = options .AllowGlobalAccess
187- newFRC .description .APIVersion = meta .VersionBeta
190+ newFwdRule .AllowGlobalAccess = options .AllowGlobalAccess
188191 }
189- if err := g .ensureInternalForwardingRule (existingFwdRule , newFRC ); err != nil {
192+ if err := g .ensureInternalForwardingRule (existingFwdRule , newFwdRule ); err != nil {
190193 return nil , err
191194 }
192195
@@ -878,116 +881,6 @@ func getILBOptions(svc *v1.Service) ILBOptions {
878881 }
879882}
880883
881- // forwardingRuleComposite is a composite type encapsulating both the GA and Beta ForwardingRules.
882- // It exposes methods to compute the ForwardingRule object based on the given parameters and to compare 2 composite types
883- // based on the version string.
884- type forwardingRuleComposite struct {
885- allowGlobalAccess bool
886- name string
887- description * forwardingRuleDescription
888- ipAddress string
889- backendService string
890- ports []string
891- ipProtocol string
892- lbScheme string
893- subnetwork string
894- network string
895- }
896-
897- func (f * forwardingRuleComposite ) Version () meta.Version {
898- return f .description .APIVersion
899- }
900-
901- func (f * forwardingRuleComposite ) Equal (other * forwardingRuleComposite ) bool {
902- return (f .ipAddress == "" || other .ipAddress == "" || f .ipAddress == other .ipAddress ) &&
903- f .ipProtocol == other .ipProtocol &&
904- f .lbScheme == other .lbScheme &&
905- equalStringSets (f .ports , other .ports ) &&
906- f .backendService == other .backendService &&
907- f .allowGlobalAccess == other .allowGlobalAccess &&
908- f .subnetwork == other .subnetwork
909- }
910-
911- // toForwardingRuleComposite converts a compute beta or GA ForwardingRule into the composite type
912- func toForwardingRuleComposite (rule interface {}) (frc * forwardingRuleComposite , err error ) {
913- switch fr := rule .(type ) {
914- case * compute.ForwardingRule :
915- frc = & forwardingRuleComposite {
916- name : fr .Name ,
917- ipAddress : fr .IPAddress ,
918- description : & forwardingRuleDescription {APIVersion : meta .VersionGA },
919- backendService : fr .BackendService ,
920- ports : fr .Ports ,
921- ipProtocol : fr .IPProtocol ,
922- lbScheme : fr .LoadBalancingScheme ,
923- subnetwork : fr .Subnetwork ,
924- network : fr .Network ,
925- }
926- if fr .Description != "" {
927- err = frc .description .unmarshal (fr .Description )
928- }
929- return frc , err
930- case * computebeta.ForwardingRule :
931- frc = & forwardingRuleComposite {
932- name : fr .Name ,
933- ipAddress : fr .IPAddress ,
934- description : & forwardingRuleDescription {APIVersion : meta .VersionBeta },
935- backendService : fr .BackendService ,
936- ports : fr .Ports ,
937- ipProtocol : fr .IPProtocol ,
938- lbScheme : fr .LoadBalancingScheme ,
939- subnetwork : fr .Subnetwork ,
940- network : fr .Network ,
941- allowGlobalAccess : fr .AllowGlobalAccess ,
942- }
943- if fr .Description != "" {
944- err = frc .description .unmarshal (fr .Description )
945- }
946- return frc , err
947- default :
948- return nil , fmt .Errorf ("Invalid object type %T to compute ForwardingRuleComposite from" , fr )
949- }
950- }
951-
952- // ToBeta returns a Beta ForwardingRule from the composite type.
953- func (f * forwardingRuleComposite ) ToBeta () (* computebeta.ForwardingRule , error ) {
954- descStr , err := f .description .marshal ()
955- if err != nil {
956- return nil , fmt .Errorf ("Failed to compute description for beta forwarding rule %s, err: %v" , f .name , err )
957- }
958- return & computebeta.ForwardingRule {
959- Name : f .name ,
960- Description : descStr ,
961- IPAddress : f .ipAddress ,
962- BackendService : f .backendService ,
963- Ports : f .ports ,
964- IPProtocol : f .ipProtocol ,
965- LoadBalancingScheme : f .lbScheme ,
966- Subnetwork : f .subnetwork ,
967- Network : f .network ,
968- AllowGlobalAccess : f .allowGlobalAccess ,
969- }, nil
970- }
971-
972- // ToGA returns a GA ForwardingRule from the composite type.
973- func (f * forwardingRuleComposite ) ToGA () (* compute.ForwardingRule , error ) {
974- descStr , err := f .description .marshal ()
975- if err != nil {
976- return nil , fmt .Errorf ("Failed to compute description for GA forwarding rule %s, err: %v" , f .name , err )
977- }
978- return & compute.ForwardingRule {
979- Name : f .name ,
980- Description : descStr ,
981- IPAddress : f .ipAddress ,
982- BackendService : f .backendService ,
983- Ports : f .ports ,
984- IPProtocol : f .ipProtocol ,
985- LoadBalancingScheme : f .lbScheme ,
986- Subnetwork : f .subnetwork ,
987- Network : f .network ,
988- }, nil
989- }
990-
991884type forwardingRuleDescription struct {
992885 ServiceName string `json:"kubernetes.io/service-name"`
993886 APIVersion meta.Version `json:"kubernetes.io/api-version,omitempty"`
@@ -1021,32 +914,10 @@ func getFwdRuleAPIVersion(rule *compute.ForwardingRule) (meta.Version, error) {
1021914 return d .APIVersion , nil
1022915}
1023916
1024- func (g * Cloud ) ensureInternalForwardingRule (existingFwdRule * compute.ForwardingRule , newFRC * forwardingRuleComposite ) (err error ) {
917+ func (g * Cloud ) ensureInternalForwardingRule (existingFwdRule , newFwdRule * compute.ForwardingRule ) (err error ) {
1025918 if existingFwdRule != nil {
1026- version , err := getFwdRuleAPIVersion (existingFwdRule )
1027- if err != nil {
1028- return err
1029- }
1030- var oldFRC * forwardingRuleComposite
1031- switch version {
1032- case meta .VersionBeta :
1033- var betaRule * computebeta.ForwardingRule
1034- betaRule , err = g .GetBetaRegionForwardingRule (existingFwdRule .Name , g .region )
1035- if err != nil {
1036- return err
1037- }
1038- oldFRC , err = toForwardingRuleComposite (betaRule )
1039- case meta .VersionGA :
1040- oldFRC , err = toForwardingRuleComposite (existingFwdRule )
1041- default :
1042- klog .Errorf ("invalid version string for %s, assuming GA" , existingFwdRule .Name )
1043- oldFRC , err = toForwardingRuleComposite (existingFwdRule )
1044- }
1045- if err != nil {
1046- return err
1047- }
1048- if oldFRC .Equal (newFRC ) {
1049- klog .V (4 ).Infof ("oldFRC == newFRC, no updates needed (oldFRC == %+v)" , oldFRC )
919+ if forwardingRulesEqual (existingFwdRule , newFwdRule ) {
920+ klog .V (4 ).Infof ("existingFwdRule == newFwdRule, no updates needed (existingFwdRule == %+v)" , existingFwdRule )
1050921 return nil
1051922 }
1052923 klog .V (2 ).Infof ("ensureInternalLoadBalancer(%v): deleting existing forwarding rule with IP address %v" , existingFwdRule .Name , existingFwdRule .IPAddress )
@@ -1056,23 +927,20 @@ func (g *Cloud) ensureInternalForwardingRule(existingFwdRule *compute.Forwarding
1056927 }
1057928 // At this point, the existing rule has been deleted if required.
1058929 // Create the rule based on the api version determined
1059- if newFRC .Version () == meta .VersionBeta {
1060- klog .V (2 ).Infof ("ensureInternalLoadBalancer(%v): creating beta forwarding rule" , newFRC .name )
1061- var betaRule * computebeta.ForwardingRule
1062- betaRule , err = newFRC .ToBeta ()
1063- if err != nil {
1064- return err
1065- }
1066- err = g .CreateBetaRegionForwardingRule (betaRule , g .region )
1067- } else {
1068- var gaRule * compute.ForwardingRule
1069- klog .V (2 ).Infof ("ensureInternalLoadBalancer(%v): creating ga forwarding rule" , newFRC .name )
1070- gaRule , err = newFRC .ToGA ()
1071- if err != nil {
1072- return err
1073- }
1074- err = g .CreateRegionForwardingRule (gaRule , g .region )
930+ klog .V (2 ).Infof ("ensureInternalLoadBalancer(%v): creating forwarding rule" , newFwdRule .Name )
931+ if err = g .CreateRegionForwardingRule (newFwdRule , g .region ); err != nil {
932+ return err
1075933 }
1076- klog .V (2 ).Infof ("ensureInternalLoadBalancer(%v): created forwarding rule, err : %s" , newFRC .name , err )
1077- return err
934+ klog .V (2 ).Infof ("ensureInternalLoadBalancer(%v): created forwarding rule" , newFwdRule .Name )
935+ return nil
936+ }
937+
938+ func forwardingRulesEqual (old , new * compute.ForwardingRule ) bool {
939+ return (old .IPAddress == "" || new .IPAddress == "" || old .IPAddress == new .IPAddress ) &&
940+ old .IPProtocol == new .IPProtocol &&
941+ old .LoadBalancingScheme == new .LoadBalancingScheme &&
942+ equalStringSets (old .Ports , new .Ports ) &&
943+ old .BackendService == new .BackendService &&
944+ old .AllowGlobalAccess == new .AllowGlobalAccess &&
945+ old .Subnetwork == new .Subnetwork
1078946}
0 commit comments