diff --git a/internal/address/gcp.go b/internal/address/gcp.go index a92b577..bff7fde 100644 --- a/internal/address/gcp.go +++ b/internal/address/gcp.go @@ -36,7 +36,7 @@ var ( type internalAssigner interface { CheckAddressAssigned(region, addressName string) (bool, error) - AddInstanceAddress(ctx context.Context, instance *compute.Instance, zone string, address *compute.Address) error + AddInstanceAddress(ctx context.Context, instance *compute.Instance, zone string, address *compute.Address, accessConfigName string) error DeleteInstanceAddress(ctx context.Context, instance *compute.Instance, zone string) error } @@ -185,14 +185,14 @@ func (a *gcpAssigner) DeleteInstanceAddress(ctx context.Context, instance *compu return nil } -func (a *gcpAssigner) AddInstanceAddress(ctx context.Context, instance *compute.Instance, zone string, address *compute.Address) error { +func (a *gcpAssigner) AddInstanceAddress(ctx context.Context, instance *compute.Instance, zone string, address *compute.Address, accessConfigName string) error { // get instance network interface networkInterface, err := getNetworkInterface(instance) if err != nil { return errors.Wrap(err, "failed to get instance network interface") } // create access config for the address - accessConfig := createAccessConfig(address, a.ipv6) + accessConfig := createAccessConfig(address, a.ipv6, accessConfigName) // add instance network interface access config a.logger.WithField("accessConfig", accessConfig).Info("adding public IP address to instance") op, err := a.addressManager.AddAccessConfig(a.project, zone, instance.Name, networkInterface.Name, networkInterface.Fingerprint, accessConfig) @@ -239,6 +239,8 @@ func (a *gcpAssigner) Assign(ctx context.Context, instanceID, zone string, filte } a.logger.WithField("addresses", ips).Debugf("found %d available addresses", len(addresses)) + accessConfigName := getAccessConfigName(instance, a.ipv6) + // delete current ephemeral public IP address if err = a.DeleteInstanceAddress(ctx, instance, zone); err != nil && !errors.Is(err, ErrNoPublicIPAssigned) { return "", errors.Wrap(err, "failed to delete current public IP address") @@ -258,7 +260,7 @@ func (a *gcpAssigner) Assign(ctx context.Context, instanceID, zone string, filte if ctx.Err() != nil { return "", errors.Wrap(ctx.Err(), "context cancelled while assigning addresses") } - if err = tryAssignAddress(ctx, a, instance, a.region, zone, address); err != nil { + if err = tryAssignAddress(ctx, a, instance, a.region, zone, address, accessConfigName); err != nil { a.logger.WithError(err).WithField("address", address.Address).Error("failed to assign static public IP address") continue } @@ -372,6 +374,7 @@ func (a *gcpAssigner) Unassign(ctx context.Context, instanceID, zone string) err // check if the instance's self link is in the list of users if _, ok := users[instance.SelfLink]; ok { + accessConfigName := getAccessConfigName(instance, a.ipv6) // release/remove current static public IP address if err = a.DeleteInstanceAddress(ctx, instance, zone); err != nil { return errors.Wrap(err, "failed to delete current public IP address") @@ -382,7 +385,7 @@ func (a *gcpAssigner) Unassign(ctx context.Context, instanceID, zone string) err return errors.Wrapf(err, "failed refresh network interface fingerprint for instance %s", instanceID) } // assign ephemeral public IP address to the instance (pass nil address) - if err = retryAddEphemeralAddress(ctx, a.logger, a, instance, zone); err != nil { + if err = retryAddEphemeralAddress(ctx, a.logger, a, instance, zone, accessConfigName); err != nil { return errors.Wrap(err, "failed to assign ephemeral public IP address") } } @@ -402,6 +405,25 @@ func getAccessConfig(networkInterface *compute.NetworkInterface, ipv6 bool) (*co return networkInterface.AccessConfigs[0], nil } +// getAccessConfigName returns the name of the instance's current access config, falling back to the default name. +// Replacement access configs reuse this name because access config names are immutable: if an instance's name no longer +// matches its instance template, the managed instance group can't update it in place (e.g. GKE in-place node upgrades). +func getAccessConfigName(instance *compute.Instance, ipv6 bool) string { + defaultName := defaultNetworkName + if ipv6 { + defaultName = defaultNetworkNameIPv6 + } + networkInterface, err := getNetworkInterface(instance) + if err != nil { + return defaultName + } + accessConfig, err := getAccessConfig(networkInterface, ipv6) + if err != nil || accessConfig.Name == "" { + return defaultName + } + return accessConfig.Name +} + func getNetworkInterface(instance *compute.Instance) (*compute.NetworkInterface, error) { if len(instance.NetworkInterfaces) == 0 { return nil, errors.New("instance has no network interfaces") @@ -409,7 +431,7 @@ func getNetworkInterface(instance *compute.Instance) (*compute.NetworkInterface, return instance.NetworkInterfaces[0], nil } -func tryAssignAddress(ctx context.Context, as internalAssigner, instance *compute.Instance, region, zone string, address *compute.Address) error { +func tryAssignAddress(ctx context.Context, as internalAssigner, instance *compute.Instance, region, zone string, address *compute.Address, accessConfigName string) error { // Force check if address is already assigned addressAssigned, err := as.CheckAddressAssigned(region, address.Name) if err != nil { @@ -419,7 +441,7 @@ func tryAssignAddress(ctx context.Context, as internalAssigner, instance *comput return errors.New("address is already assigned") } // Assign address to the instance - if err = as.AddInstanceAddress(ctx, instance, zone, address); err != nil { + if err = as.AddInstanceAddress(ctx, instance, zone, address, accessConfigName); err != nil { return errors.Wrap(err, "failed to assign static public IP address") } return nil @@ -435,13 +457,13 @@ func (a *gcpAssigner) createUserMap(assigned []*compute.Address) map[string]stri return users } -func retryAddEphemeralAddress(ctx context.Context, logger *logrus.Entry, as internalAssigner, instance *compute.Instance, zone string) error { +func retryAddEphemeralAddress(ctx context.Context, logger *logrus.Entry, as internalAssigner, instance *compute.Instance, zone, accessConfigName string) error { for i := 0; i < maxRetries; i++ { // check if context is done before trying to assign an address if ctx.Err() != nil { return errors.Wrap(ctx.Err(), "context cancelled while assigning ephemeral addresses") } - if err := as.AddInstanceAddress(ctx, instance, zone, nil); err != nil { + if err := as.AddInstanceAddress(ctx, instance, zone, nil, accessConfigName); err != nil { logger.WithError(err).Error("failed to assign ephemeral public IP address, retrying") continue } @@ -450,15 +472,14 @@ func retryAddEphemeralAddress(ctx context.Context, logger *logrus.Entry, as inte return errors.New("reached max retries") } -func createAccessConfig(address *compute.Address, ipv6 bool) *compute.AccessConfig { +func createAccessConfig(address *compute.Address, ipv6 bool, name string) *compute.AccessConfig { accessConfig := &compute.AccessConfig{ - Name: defaultNetworkName, + Name: name, Type: defaultAccessConfigType, Kind: accessConfigKind, } if ipv6 { - accessConfig.Name = defaultNetworkNameIPv6 accessConfig.Type = defaultAccessConfigIPv6Type accessConfig.ExternalIpv6 = addressAddressOrEmpty(address) accessConfig.NetworkTier = addressNetworkTierOrDefault(address) diff --git a/internal/address/gcp_test.go b/internal/address/gcp_test.go index f2eca54..89bc1e4 100644 --- a/internal/address/gcp_test.go +++ b/internal/address/gcp_test.go @@ -392,7 +392,7 @@ func Test_gcpAssigner_Assign(t *testing.T) { mock := mocks.NewAddressManager(t) mock.EXPECT().DeleteAccessConfig("test-project", "test-zone", "test-instance-0", "test-access-config", "test-network-interface", "test-fingerprint").Return(&compute.Operation{Name: "test-operation", Status: "DONE"}, nil) mock.EXPECT().AddAccessConfig("test-project", "test-zone", "test-instance-0", "test-network-interface", "test-fingerprint", &compute.AccessConfig{ - Name: defaultNetworkName, + Name: "test-access-config", Type: defaultAccessConfigType, Kind: accessConfigKind, NatIP: "100.0.0.3", @@ -481,6 +481,54 @@ func Test_gcpAssigner_Assign(t *testing.T) { } } +func Test_getAccessConfigName(t *testing.T) { + tests := []struct { + name string + instance *compute.Instance + ipv6 bool + want string + }{ + { + name: "preserves existing IPv4 access config name", + instance: &compute.Instance{NetworkInterfaces: []*compute.NetworkInterface{ + {AccessConfigs: []*compute.AccessConfig{{Name: "external-nat"}}}, + }}, + want: "external-nat", + }, + { + name: "preserves existing IPv6 access config name", + instance: &compute.Instance{NetworkInterfaces: []*compute.NetworkInterface{ + {Ipv6AccessConfigs: []*compute.AccessConfig{{Name: "external-ipv6"}}}, + }}, + ipv6: true, + want: "external-ipv6", + }, + { + name: "defaults IPv4 without access config", + instance: &compute.Instance{NetworkInterfaces: []*compute.NetworkInterface{{}}}, + want: defaultNetworkName, + }, + { + name: "defaults IPv6 without access config", + instance: &compute.Instance{NetworkInterfaces: []*compute.NetworkInterface{{}}}, + ipv6: true, + want: defaultNetworkNameIPv6, + }, + { + name: "defaults without network interface", + instance: &compute.Instance{}, + want: defaultNetworkName, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := getAccessConfigName(tt.instance, tt.ipv6); got != tt.want { + t.Errorf("getAccessConfigName() = %v, want %v", got, tt.want) + } + }) + } +} + func Test_createAccessConfig(t *testing.T) { type args struct { address *compute.Address @@ -557,7 +605,11 @@ func Test_createAccessConfig(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - if got := createAccessConfig(tt.args.address, tt.args.ipv6); !reflect.DeepEqual(got, tt.want) { + name := defaultNetworkName + if tt.args.ipv6 { + name = defaultNetworkNameIPv6 + } + if got := createAccessConfig(tt.args.address, tt.args.ipv6, name); !reflect.DeepEqual(got, tt.want) { t.Errorf("createAccessConfig() = %v, want %v", got, tt.want) } }) @@ -717,7 +769,7 @@ func Test_retryAddEphemeralAddress(t *testing.T) { zone: "test-zone", asFn: func(t *testing.T) internalAssigner { mock := amock.NewInternalAssigner(t) - mock.EXPECT().AddInstanceAddress(context.TODO(), tmock.Anything, "test-zone", tmock.Anything).Return(nil) + mock.EXPECT().AddInstanceAddress(context.TODO(), tmock.Anything, "test-zone", tmock.Anything, defaultNetworkName).Return(nil) return mock }, }, @@ -728,8 +780,8 @@ func Test_retryAddEphemeralAddress(t *testing.T) { zone: "test-zone", asFn: func(t *testing.T) internalAssigner { mock := amock.NewInternalAssigner(t) - mock.EXPECT().AddInstanceAddress(context.TODO(), tmock.Anything, "test-zone", tmock.Anything).Return(errors.New("test-error")).Times(3) - mock.EXPECT().AddInstanceAddress(context.TODO(), tmock.Anything, "test-zone", tmock.Anything).Return(nil) + mock.EXPECT().AddInstanceAddress(context.TODO(), tmock.Anything, "test-zone", tmock.Anything, defaultNetworkName).Return(errors.New("test-error")).Times(3) + mock.EXPECT().AddInstanceAddress(context.TODO(), tmock.Anything, "test-zone", tmock.Anything, defaultNetworkName).Return(nil) return mock }, }, @@ -740,7 +792,7 @@ func Test_retryAddEphemeralAddress(t *testing.T) { zone: "test-zone", asFn: func(t *testing.T) internalAssigner { mock := amock.NewInternalAssigner(t) - mock.EXPECT().AddInstanceAddress(context.TODO(), tmock.Anything, "test-zone", tmock.Anything).Return(errors.New("test-error")).Times(maxRetries) + mock.EXPECT().AddInstanceAddress(context.TODO(), tmock.Anything, "test-zone", tmock.Anything, defaultNetworkName).Return(errors.New("test-error")).Times(maxRetries) return mock }, }, @@ -749,7 +801,7 @@ func Test_retryAddEphemeralAddress(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - if err := retryAddEphemeralAddress(context.TODO(), logrus.NewEntry(logrus.New()), tt.args.asFn(t), tt.args.instance, tt.args.zone); (err != nil) != tt.wantErr { + if err := retryAddEphemeralAddress(context.TODO(), logrus.NewEntry(logrus.New()), tt.args.asFn(t), tt.args.instance, tt.args.zone, defaultNetworkName); (err != nil) != tt.wantErr { t.Errorf("retryAddEphemeralAddress() error = %v, wantErr %v", err, tt.wantErr) } }) @@ -777,7 +829,7 @@ func Test_tryAssignAddress(t *testing.T) { asFn: func(t *testing.T) internalAssigner { mock := amock.NewInternalAssigner(t) mock.EXPECT().CheckAddressAssigned("test-region", "test-address").Return(false, nil) - mock.EXPECT().AddInstanceAddress(context.TODO(), tmock.Anything, "test-zone", tmock.Anything).Return(nil) + mock.EXPECT().AddInstanceAddress(context.TODO(), tmock.Anything, "test-zone", tmock.Anything, defaultNetworkName).Return(nil) return mock }, address: &compute.Address{ @@ -825,7 +877,7 @@ func Test_tryAssignAddress(t *testing.T) { asFn: func(t *testing.T) internalAssigner { mock := amock.NewInternalAssigner(t) mock.EXPECT().CheckAddressAssigned("test-region", "test-address").Return(false, nil) - mock.EXPECT().AddInstanceAddress(context.TODO(), tmock.Anything, "test-zone", tmock.Anything).Return(errors.New("test-error")) + mock.EXPECT().AddInstanceAddress(context.TODO(), tmock.Anything, "test-zone", tmock.Anything, defaultNetworkName).Return(errors.New("test-error")) return mock }, address: &compute.Address{ @@ -837,7 +889,7 @@ func Test_tryAssignAddress(t *testing.T) { } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - if err := tryAssignAddress(context.TODO(), tt.args.asFn(t), tt.args.instance, tt.args.region, tt.args.zone, tt.args.address); (err != nil) != tt.wantErr { + if err := tryAssignAddress(context.TODO(), tt.args.asFn(t), tt.args.instance, tt.args.region, tt.args.zone, tt.args.address, defaultNetworkName); (err != nil) != tt.wantErr { t.Errorf("tryAssignAddress() error = %v, wantErr %v", err, tt.wantErr) } }) @@ -907,7 +959,7 @@ func Test_AddInstanceAddressRequiresCompletedOperation(t *testing.T) { } a := &gcpAssigner{project: "project", addressManager: manager, waiter: waiter, logger: logrus.NewEntry(logrus.New())} instance := &compute.Instance{Name: "instance", NetworkInterfaces: []*compute.NetworkInterface{{Name: "nic0", Fingerprint: "fingerprint"}}} - err := a.AddInstanceAddress(context.Background(), instance, "zone", &compute.Address{Address: "1.1.1.1", NetworkTier: "STANDARD"}) + err := a.AddInstanceAddress(context.Background(), instance, "zone", &compute.Address{Address: "1.1.1.1", NetworkTier: "STANDARD"}, defaultNetworkName) if (err != nil) != tt.wantErr { t.Fatalf("error = %v, wantErr %v", err, tt.wantErr) } diff --git a/internal/address/reconcile.go b/internal/address/reconcile.go index d17589c..f6d1e3a 100644 --- a/internal/address/reconcile.go +++ b/internal/address/reconcile.go @@ -86,6 +86,7 @@ func (a *gcpAssigner) RestoreAddress(ctx context.Context, instance, zone, expect if err != nil { return errors.Wrap(err, "reading instance before repair") } + accessConfigName := getAccessConfigName(vm, a.ipv6) if err := a.DeleteInstanceAddress(ctx, vm, zone); err != nil && !errors.Is(err, ErrNoPublicIPAssigned) { return err } @@ -93,5 +94,5 @@ func (a *gcpAssigner) RestoreAddress(ctx context.Context, instance, zone, expect if err != nil { return errors.Wrap(err, "refreshing instance before repair") } - return tryAssignAddress(ctx, a, vm, a.region, zone, addresses[0]) + return tryAssignAddress(ctx, a, vm, a.region, zone, addresses[0], accessConfigName) } diff --git a/mocks/address/internalAssigner.go b/mocks/address/internalAssigner.go index fda352f..065627a 100644 --- a/mocks/address/internalAssigner.go +++ b/mocks/address/internalAssigner.go @@ -23,13 +23,13 @@ func (_m *InternalAssigner) EXPECT() *InternalAssigner_Expecter { return &InternalAssigner_Expecter{mock: &_m.Mock} } -// AddInstanceAddress provides a mock function with given fields: ctx, instance, zone, _a3 -func (_m *InternalAssigner) AddInstanceAddress(ctx context.Context, instance *compute.Instance, zone string, _a3 *compute.Address) error { - ret := _m.Called(ctx, instance, zone, _a3) +// AddInstanceAddress provides a mock function with given fields: ctx, instance, zone, _a3, accessConfigName +func (_m *InternalAssigner) AddInstanceAddress(ctx context.Context, instance *compute.Instance, zone string, _a3 *compute.Address, accessConfigName string) error { + ret := _m.Called(ctx, instance, zone, _a3, accessConfigName) var r0 error - if rf, ok := ret.Get(0).(func(context.Context, *compute.Instance, string, *compute.Address) error); ok { - r0 = rf(ctx, instance, zone, _a3) + if rf, ok := ret.Get(0).(func(context.Context, *compute.Instance, string, *compute.Address, string) error); ok { + r0 = rf(ctx, instance, zone, _a3, accessConfigName) } else { r0 = ret.Error(0) } @@ -47,13 +47,14 @@ type InternalAssigner_AddInstanceAddress_Call struct { // - instance *compute.Instance // - zone string // - _a3 *compute.Address -func (_e *InternalAssigner_Expecter) AddInstanceAddress(ctx interface{}, instance interface{}, zone interface{}, _a3 interface{}) *InternalAssigner_AddInstanceAddress_Call { - return &InternalAssigner_AddInstanceAddress_Call{Call: _e.mock.On("AddInstanceAddress", ctx, instance, zone, _a3)} +// - accessConfigName string +func (_e *InternalAssigner_Expecter) AddInstanceAddress(ctx interface{}, instance interface{}, zone interface{}, _a3 interface{}, accessConfigName interface{}) *InternalAssigner_AddInstanceAddress_Call { + return &InternalAssigner_AddInstanceAddress_Call{Call: _e.mock.On("AddInstanceAddress", ctx, instance, zone, _a3, accessConfigName)} } -func (_c *InternalAssigner_AddInstanceAddress_Call) Run(run func(ctx context.Context, instance *compute.Instance, zone string, _a3 *compute.Address)) *InternalAssigner_AddInstanceAddress_Call { +func (_c *InternalAssigner_AddInstanceAddress_Call) Run(run func(ctx context.Context, instance *compute.Instance, zone string, _a3 *compute.Address, accessConfigName string)) *InternalAssigner_AddInstanceAddress_Call { _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(*compute.Instance), args[2].(string), args[3].(*compute.Address)) + run(args[0].(context.Context), args[1].(*compute.Instance), args[2].(string), args[3].(*compute.Address), args[4].(string)) }) return _c } @@ -63,7 +64,7 @@ func (_c *InternalAssigner_AddInstanceAddress_Call) Return(_a0 error) *InternalA return _c } -func (_c *InternalAssigner_AddInstanceAddress_Call) RunAndReturn(run func(context.Context, *compute.Instance, string, *compute.Address) error) *InternalAssigner_AddInstanceAddress_Call { +func (_c *InternalAssigner_AddInstanceAddress_Call) RunAndReturn(run func(context.Context, *compute.Instance, string, *compute.Address, string) error) *InternalAssigner_AddInstanceAddress_Call { _c.Call.Return(run) return _c }