Support new fields for LKE-E node pool

lke_node_pools.go

@@ -14,6 +14,16 @@ const (
 	LKELinodeNotReady LKELinodeStatus = "not_ready"
 )
 
+// LKENodePoolUpdateStrategy constants start with LKENodePool and include
+// LKE Node Pool upgrade strategy values
+type LKENodePoolUpdateStrategy string
+
+// LKENodePoolUpdateStrategy constants describe the available upgrade strategies for LKE Enterprise only
+const (
+	LKENodePoolRollingUpdate LKENodePoolUpdateStrategy = "rolling_update"
+	LKENodePoolOnRecycle     LKENodePoolUpdateStrategy = "on_recycle"
+)
+
 // LKENodePoolDisk represents a Node disk in an LKENodePool object
 type LKENodePoolDisk struct {
 	Size int    `json:"size"`
@@ -67,6 +77,11 @@ type LKENodePool struct {
 
 	// NOTE: Disk encryption may not currently be available to all users.
 	DiskEncryption InstanceDiskEncryption `json:"disk_encryption,omitempty"`
+
+	// K8sVersion and UpdateStrategy are only for LKE Enterprise to support node pool upgrades.
+	// It may not currently be available to all users and is under v4beta.
+	K8sVersion     *string                    `json:"k8s_version,omitempty"`
+	UpdateStrategy *LKENodePoolUpdateStrategy `json:"update_strategy,omitempty"`
 }
 
 // LKENodePoolCreateOptions fields are those accepted by CreateLKENodePool
@@ -79,6 +94,11 @@ type LKENodePoolCreateOptions struct {
 	Taints []LKENodePoolTaint `json:"taints"`
 
 	Autoscaler *LKENodePoolAutoscaler `json:"autoscaler,omitempty"`
+
+	// K8sVersion and UpdateStrategy only works for LKE Enterprise to support node pool upgrades.
+	// It may not currently be available to all users and is under v4beta.
+	K8sVersion     *string                    `json:"k8s_version,omitempty"`
+	UpdateStrategy *LKENodePoolUpdateStrategy `json:"update_strategy,omitempty"`
 }
 
 // LKENodePoolUpdateOptions fields are those accepted by UpdateLKENodePoolUpdate
@@ -89,6 +109,11 @@ type LKENodePoolUpdateOptions struct {
 	Taints *[]LKENodePoolTaint `json:"taints,omitempty"`
 
 	Autoscaler *LKENodePoolAutoscaler `json:"autoscaler,omitempty"`
+
+	// K8sVersion and UpdateStrategy only works for LKE Enterprise to support node pool upgrades.
+	// It may not currently be available to all users and is under v4beta.
+	K8sVersion     *string                    `json:"k8s_version,omitempty"`
+	UpdateStrategy *LKENodePoolUpdateStrategy `json:"update_strategy,omitempty"`
 }
 
 // GetCreateOptions converts a LKENodePool to LKENodePoolCreateOptions for
@@ -100,6 +125,8 @@ func (l LKENodePool) GetCreateOptions() (o LKENodePoolCreateOptions) {
 	o.Labels = l.Labels
 	o.Taints = l.Taints
 	o.Autoscaler = &l.Autoscaler
+	o.K8sVersion = l.K8sVersion
+	o.UpdateStrategy = l.UpdateStrategy
 	return
 }
 
@@ -110,6 +137,8 @@ func (l LKENodePool) GetUpdateOptions() (o LKENodePoolUpdateOptions) {
 	o.Labels = &l.Labels
 	o.Taints = &l.Taints
 	o.Autoscaler = &l.Autoscaler
+	o.K8sVersion = l.K8sVersion
+	o.UpdateStrategy = l.UpdateStrategy
 	return
 }
 

test/integration/lke_node_pools_test.go

@@ -312,3 +312,76 @@ func setupLKENodePool(t *testing.T, fixturesYaml string, nodePoolCreateOpts *lin
 	}
 	return client, lkeCluster, pool, teardown, err
 }
+
+func TestLKEEnterpriseNodePoolK8sUpgrade_Get(t *testing.T) {
+	testLKENodePoolCreateOpts.K8sVersion = linodego.Pointer("v1.31.1+lke1")
+	testLKENodePoolCreateOpts.UpdateStrategy = linodego.Pointer(linodego.LKENodePoolRollingUpdate)
+
+	_, _, nodePool, teardown, err := setupLKEEnterpriseNodePool(t, "fixtures/TestLKENodeEnterprisePoolNode_Get", &testLKENodePoolCreateOpts)
+	if err != nil {
+		t.Error(err)
+	}
+	defer teardown()
+
+	if diff := cmp.Diff(testLKENodePoolCreateOpts.K8sVersion, nodePool.K8sVersion); diff != "" {
+		t.Errorf("unexpected k8s version:\n%s", diff)
+	}
+
+	if diff := cmp.Diff(testLKENodePoolCreateOpts.UpdateStrategy, nodePool.UpdateStrategy); diff != "" {
+		t.Errorf("unexpected update strategy:\n%s", diff)
+	}
+}
+
+func TestLKEEnterpriseNodePoolK8sUpgrade_Update(t *testing.T) {
+	testLKENodePoolCreateOpts.K8sVersion = linodego.Pointer("v1.31.1+lke1")
+	testLKENodePoolCreateOpts.UpdateStrategy = linodego.Pointer(linodego.LKENodePoolRollingUpdate)
+
+	client, lkeCluster, nodePool, teardown, err := setupLKEEnterpriseNodePool(t, "fixtures/TestLKENodeEnterprisePoolNode_Update", &testLKENodePoolCreateOpts)
+	if err != nil {
+		t.Error(err)
+	}
+	defer teardown()
+
+	updated, err := client.UpdateLKENodePool(context.TODO(), lkeCluster.ID, nodePool.ID, linodego.LKENodePoolUpdateOptions{
+		UpdateStrategy: linodego.Pointer(linodego.LKENodePoolOnRecycle),
+	})
+	if err != nil {
+		t.Errorf("Failed to update LKE node pool update strategy: %v", err.Error())
+	}
+
+	updatedNodePool, err := client.GetLKENodePool(context.TODO(), lkeCluster.ID, nodePool.ID)
+	if err != nil {
+		t.Errorf("Failed to get updated LKE node pool update strategy: %v", err.Error())
+	}
+
+	if diff := cmp.Diff(updated.UpdateStrategy, updatedNodePool.UpdateStrategy); diff != "" {
+		t.Errorf("unexpected update strategy:\n%s", diff)
+	}
+}
+
+func setupLKEEnterpriseNodePool(t *testing.T, fixturesYaml string, nodePoolCreateOpts *linodego.LKENodePoolCreateOptions) (*linodego.Client, *linodego.LKECluster, *linodego.LKENodePool, func(), error) {
+	t.Helper()
+	var fixtureTeardown func()
+	client, lkeCluster, fixtureTeardown, err := setupLKECluster(t, []clusterModifier{func(createOpts *linodego.LKEClusterCreateOptions) {
+		createOpts.Tier = "enterprise"
+		createOpts.Region = "us-lax"
+		createOpts.K8sVersion = "v1.31.1+lke1"
+	}}, fixturesYaml)
+	if err != nil {
+		t.Errorf("Error creating LKE enterprise cluster, got error %v", err)
+	}
+
+	pool, err := client.CreateLKENodePool(context.Background(), lkeCluster.ID, *nodePoolCreateOpts)
+	if err != nil {
+		t.Errorf("Error creating Node Pool under LKE-E, got error %v", err)
+	}
+
+	teardown := func() {
+		// delete the LKENodePool to exercise the code
+		if err := client.DeleteLKENodePool(context.Background(), lkeCluster.ID, pool.ID); err != nil {
+			t.Errorf("Expected to delete a LKE Node Pool, but got %v", err)
+		}
+		fixtureTeardown()
+	}
+	return client, lkeCluster, pool, teardown, err
+}

test/unit/fixtures/lke_e_node_pool_create.json

@@ -0,0 +1,16 @@
+{
+  "id": 12345,
+  "type": "g6-standard-2",
+  "count": 2,
+  "disks": [
+    {
+      "size": 1000,
+      "type": "ext4"
+    }],
+  "labels": {},
+  "taints": [],
+  "tags": ["testing"],
+  "disk_encryption": "enabled",
+  "k8s_version": "v1.31.1+lke1",
+  "update_strategy": "on_recycle"
+}

test/unit/fixtures/lke_e_node_pool_update.json

@@ -0,0 +1,16 @@
+{
+  "id": 12345,
+  "type": "g6-standard-2",
+  "count": 2,
+  "disks": [
+    {
+      "size": 1000,
+      "type": "ext4"
+    }],
+  "labels": {},
+  "taints": [],
+  "tags": ["testing"],
+  "disk_encryption": "enabled",
+  "k8s_version": "v1.31.1+lke1",
+  "update_strategy": "rolling_update"
+}

test/unit/lke_node_pools_test.go

@@ -178,3 +178,50 @@ func TestLKENodePoolNode_Delete(t *testing.T) {
 	err := base.Client.DeleteLKENodePoolNode(context.Background(), 123, "abc123")
 	assert.NoError(t, err)
 }
+
+func TestLKEEnterpriseNodePool_Create(t *testing.T) {
+	fixtureData, err := fixtures.GetFixture("lke_e_node_pool_create")
+	assert.NoError(t, err)
+
+	var base ClientBaseCase
+	base.SetUp(t)
+	defer base.TearDown(t)
+
+	createOptions := linodego.LKENodePoolCreateOptions{
+		Count:          2,
+		Type:           "g6-standard-2",
+		Tags:           []string{"testing"},
+		K8sVersion:     linodego.Pointer("v1.31.1+lke1"),
+		UpdateStrategy: linodego.Pointer(linodego.LKENodePoolOnRecycle),
+	}
+
+	base.MockPost("lke/clusters/123/pools", fixtureData)
+
+	nodePool, err := base.Client.CreateLKENodePool(context.Background(), 123, createOptions)
+	assert.NoError(t, err)
+	assert.Equal(t, "g6-standard-2", nodePool.Type)
+	assert.Equal(t, 2, nodePool.Count)
+	assert.Equal(t, "v1.31.1+lke1", *nodePool.K8sVersion)
+	assert.Equal(t, "on_recycle", string(*nodePool.UpdateStrategy))
+}
+
+func TestLKEEnterpriseNodePool_Update(t *testing.T) {
+	fixtureData, err := fixtures.GetFixture("lke_e_node_pool_update")
+	assert.NoError(t, err)
+
+	var base ClientBaseCase
+	base.SetUp(t)
+	defer base.TearDown(t)
+
+	updateOptions := linodego.LKENodePoolUpdateOptions{
+		K8sVersion:     linodego.Pointer("v1.31.1+lke1"),
+		UpdateStrategy: linodego.Pointer(linodego.LKENodePoolRollingUpdate),
+	}
+
+	base.MockPut("lke/clusters/123/pools/12345", fixtureData)
+
+	nodePool, err := base.Client.UpdateLKENodePool(context.Background(), 123, 12345, updateOptions)
+	assert.NoError(t, err)
+	assert.Equal(t, "v1.31.1+lke1", *nodePool.K8sVersion)
+	assert.Equal(t, "rolling_update", string(*nodePool.UpdateStrategy))
+}