From 502b8a5887380f35efa7d4fc015f4cf4e84cb07e Mon Sep 17 00:00:00 2001 From: hc-github-team-nomad-core <82989552+hc-github-team-nomad-core@users.noreply.github.com> Date: Tue, 5 Sep 2023 04:37:47 -0500 Subject: [PATCH] backport of commit 6ba600cbf1c8b7ad915c4c95995bda4b97b4d58b (#18387) Co-authored-by: Dao Thanh Tung --- api/deployments.go | 2 +- api/deployments_test.go | 394 ++++++++++++++++++++++++++++++++++++++++ api/util_test.go | 8 + 3 files changed, 403 insertions(+), 1 deletion(-) create mode 100644 api/deployments_test.go diff --git a/api/deployments.go b/api/deployments.go index 665d38834..6785b8f6d 100644 --- a/api/deployments.go +++ b/api/deployments.go @@ -18,7 +18,7 @@ func (c *Client) Deployments() *Deployments { return &Deployments{client: c} } -// List is used to dump all of the deployments. +// List is used to dump all the deployments. func (d *Deployments) List(q *QueryOptions) ([]*Deployment, *QueryMeta, error) { var resp []*Deployment qm, err := d.client.query("/v1/deployments", &resp, q) diff --git a/api/deployments_test.go b/api/deployments_test.go new file mode 100644 index 000000000..c3bf046e1 --- /dev/null +++ b/api/deployments_test.go @@ -0,0 +1,394 @@ +package api + +import ( + "fmt" + "testing" + "time" + + "github.com/hashicorp/nomad/api/internal/testutil" + "github.com/shoenig/test/must" + "github.com/shoenig/test/wait" +) + +func TestDeployments_List(t *testing.T) { + testutil.Parallel(t) + + c, s := makeClient(t, nil, nil) + defer s.Stop() + deployments := c.Deployments() + jobs := c.Jobs() + + // Create a job of type service + job := testServiceJob() + + // Initially there should be no deployment + resp0, _, err := deployments.List(nil) + must.NoError(t, err) + must.Len(t, 0, resp0) + + // Register + resp1, wm, err := jobs.Register(job, nil) + must.NoError(t, err) + must.NotNil(t, resp1) + must.UUIDv4(t, resp1.EvalID) + assertWriteMeta(t, wm) + + // Query the jobs back out again + resp2, qm, err := jobs.List(nil) + assertQueryMeta(t, qm) + must.NoError(t, err) + must.Len(t, 1, resp2) + + f := func() error { + // List the deployment + resp3, _, err := deployments.List(nil) + if err != nil { + return err + } + if len(resp3) != 1 { + return fmt.Errorf(fmt.Sprintf("expected 1 deployment, found %v", len(resp3))) + } + return nil + } + must.Wait(t, wait.InitialSuccess( + wait.ErrorFunc(f), + wait.Timeout(3*time.Second), + wait.Gap(100*time.Millisecond), + )) +} + +func TestDeployments_PrefixList(t *testing.T) { + testutil.Parallel(t) + + c, s := makeClient(t, nil, nil) + defer s.Stop() + deployments := c.Deployments() + jobs := c.Jobs() + + // Initially there should be no deployment + resp, _, err := deployments.PrefixList("b1") + must.NoError(t, err) + must.Len(t, 0, resp) + + // Create a job of type service + job := testServiceJob() + + // Register the job + resp2, wm, err := jobs.Register(job, nil) + must.NoError(t, err) + must.NotNil(t, resp2) + must.UUIDv4(t, resp2.EvalID) + assertWriteMeta(t, wm) + + // Query the jobs back out again + resp3, qm, err := jobs.List(nil) + assertQueryMeta(t, qm) + must.NoError(t, err) + must.Len(t, 1, resp3) + + f := func() error { + // List the deployment + resp4, _, err := jobs.Deployments(resp3[0].ID, true, nil) + if len(resp4) != 1 { + return fmt.Errorf("expected 1 deployment, found %v", len(resp4)) + } + + // Prefix List + resp5, _, err := deployments.PrefixList(resp4[0].ID) + if err != nil { + return err + } + if len(resp5) != 1 { + return fmt.Errorf(fmt.Sprintf("expected 1 deployment, found %v", len(resp5))) + } + return nil + } + must.Wait(t, wait.InitialSuccess( + wait.ErrorFunc(f), + wait.Timeout(3*time.Second), + wait.Gap(100*time.Millisecond), + )) +} + +func TestDeployments_Info(t *testing.T) { + testutil.Parallel(t) + + c, s := makeClient(t, nil, nil) + defer s.Stop() + deployments := c.Deployments() + jobs := c.Jobs() + + // Create a job of type service + job := testServiceJob() + + // Register + resp, wm, err := jobs.Register(job, nil) + must.NoError(t, err) + must.NotNil(t, resp) + must.UUIDv4(t, resp.EvalID) + assertWriteMeta(t, wm) + + // Query the jobs + resp2, qm, err := jobs.List(nil) + assertQueryMeta(t, qm) + must.NoError(t, err) + must.Len(t, 1, resp2) + + f := func() error { + // Get the deploymentID for Info + resp3, _, err := jobs.Deployments(resp2[0].ID, true, nil) + if len(resp3) != 1 { + return fmt.Errorf("expected 1 deployment, found %v", len(resp3)) + } + + // Get Info using deployment ID + resp4, _, err := deployments.Info(resp3[0].ID, nil) + if err != nil { + return err + } + if resp4.JobID != resp2[0].ID { + return fmt.Errorf(fmt.Sprintf("expected job id: %v, found %v", resp4.JobID, resp2[0].ID)) + } + if resp4.Namespace != resp2[0].Namespace { + return fmt.Errorf(fmt.Sprintf("expected deployment namespace: %v, found %v", resp4.Namespace, resp2[0].Namespace)) + } + return nil + } + must.Wait(t, wait.InitialSuccess( + wait.ErrorFunc(f), + wait.Timeout(3*time.Second), + wait.Gap(100*time.Millisecond), + )) +} + +func TestDeployments_Allocations(t *testing.T) { + testutil.Parallel(t) + + c, s := makeClient(t, nil, nil) + defer s.Stop() + deployments := c.Deployments() + jobs := c.Jobs() + + // Create a job of type service + job := testServiceJob() + + // Register + resp, wm, err := jobs.Register(job, nil) + must.NoError(t, err) + must.NotNil(t, resp) + must.UUIDv4(t, resp.EvalID) + assertWriteMeta(t, wm) + + // Query the jobs + resp2, qm, err := jobs.List(nil) + assertQueryMeta(t, qm) + must.NoError(t, err) + must.Len(t, 1, resp2) + + f := func() error { + // Get the deploymentID for Allocations + resp3, _, err := jobs.Deployments(resp2[0].ID, true, nil) + if len(resp3) != 1 { + return fmt.Errorf("expected 1 deployment, found %v", len(resp3)) + } + + // Query deployment list + resp4, _, err := deployments.List(nil) + if err != nil { + return err + } + if len(resp4) != 1 { + return fmt.Errorf("expected 1 deployment, found %v", len(resp4)) + } + + // Get Allocations + resp5, _, err := deployments.Allocations(resp3[0].ID, nil) + if err != nil { + return err + } + if len(resp5) != 0 { + return fmt.Errorf("expected 0 Allocations, found %v", len(resp5)) + } + return nil + } + must.Wait(t, wait.InitialSuccess( + wait.ErrorFunc(f), + wait.Timeout(3*time.Second), + wait.Gap(100*time.Millisecond), + )) +} + +func TestDeployments_Fail(t *testing.T) { + testutil.Parallel(t) + + c, s := makeClient(t, nil, nil) + defer s.Stop() + deployments := c.Deployments() + jobs := c.Jobs() + + // Create a job of type service + job := testServiceJob() + + // Register + resp, wm, err := jobs.Register(job, nil) + must.NoError(t, err) + must.NotNil(t, resp) + must.UUIDv4(t, resp.EvalID) + assertWriteMeta(t, wm) + + // Query the jobs + resp2, qm, err := jobs.List(nil) + assertQueryMeta(t, qm) + must.NoError(t, err) + must.Len(t, 1, resp2) + + f := func() error { + // Get the deploymentID for Failing + resp3, _, err := jobs.Deployments(resp2[0].ID, true, nil) + if len(resp3) != 1 { + return fmt.Errorf("expected 1 deployment, found %v", len(resp3)) + } + + // Fail Deployment + _, _, err = deployments.Fail(resp3[0].ID, nil) + if err != nil { + return err + } + + // Query Info to check the status + resp4, _, err := deployments.Info(resp3[0].ID, nil) + if err != nil { + return err + } + if resp4.Status != "failed" { + return fmt.Errorf("expected failed status, got %v", resp4.Status) + } + return nil + } + must.Wait(t, wait.InitialSuccess( + wait.ErrorFunc(f), + wait.Timeout(3*time.Second), + wait.Gap(100*time.Millisecond), + )) +} + +func TestDeployments_Pause(t *testing.T) { + testutil.Parallel(t) + + c, s := makeClient(t, nil, nil) + defer s.Stop() + deployments := c.Deployments() + jobs := c.Jobs() + + // Create a job of type service + job := testServiceJob() + + // Register + resp, wm, err := jobs.Register(job, nil) + must.NoError(t, err) + must.NotNil(t, resp) + must.UUIDv4(t, resp.EvalID) + assertWriteMeta(t, wm) + + // Query the jobs + resp2, qm, err := jobs.List(nil) + assertQueryMeta(t, qm) + must.NoError(t, err) + must.Len(t, 1, resp2) + + f := func() error { + // Get the deploymentID for pausing + resp3, _, err := jobs.Deployments(resp2[0].ID, true, nil) + if len(resp3) != 1 { + return fmt.Errorf("expected 1 deployment, found %v", len(resp3)) + } + + // Pause Deployment + _, _, err = deployments.Pause(resp3[0].ID, true, nil) + if err != nil { + return err + } + + // Query Info to check the status + resp4, _, err := deployments.Info(resp3[0].ID, nil) + if err != nil { + return err + } + if resp4.Status != "paused" { + return fmt.Errorf("expected paused status, got %v", resp4.Status) + } + return nil + } + must.Wait(t, wait.InitialSuccess( + wait.ErrorFunc(f), + wait.Timeout(3*time.Second), + wait.Gap(100*time.Millisecond), + )) +} + +func TestDeployments_Unpause(t *testing.T) { + testutil.Parallel(t) + + c, s := makeClient(t, nil, nil) + defer s.Stop() + deployments := c.Deployments() + jobs := c.Jobs() + + // Create a job of type service + job := testServiceJob() + + // Register + resp, wm, err := jobs.Register(job, nil) + must.NoError(t, err) + must.NotNil(t, resp) + must.UUIDv4(t, resp.EvalID) + assertWriteMeta(t, wm) + + // Query the jobs + resp2, qm, err := jobs.List(nil) + assertQueryMeta(t, qm) + must.NoError(t, err) + must.Len(t, 1, resp2) + + f := func() error { + // Get the deploymentID for un-pausing + resp3, _, err := jobs.Deployments(resp2[0].ID, true, nil) + if len(resp3) != 1 { + return fmt.Errorf("expected 1 deployment, found %v", len(resp3)) + } + + // Pause Deployment + _, _, err = deployments.Pause(resp3[0].ID, true, nil) + if err != nil { + return err + } + + // Query Info to check the status + resp4, _, err := deployments.Info(resp3[0].ID, nil) + if err != nil { + return err + } + if resp4.Status != "paused" { + return fmt.Errorf("expected paused status, got %v", resp4.Status) + } + + // UnPause the deployment + _, _, err = deployments.Pause(resp3[0].ID, false, nil) + must.NoError(t, err) + + // Query Info again to check the status + resp5, _, err := deployments.Info(resp3[0].ID, nil) + if err != nil { + return err + } + if resp5.Status != "running" { + return fmt.Errorf("expected running status, got %v", resp5.Status) + } + return nil + } + must.Wait(t, wait.InitialSuccess( + wait.ErrorFunc(f), + wait.Timeout(3*time.Second), + wait.Gap(100*time.Millisecond), + )) +} diff --git a/api/util_test.go b/api/util_test.go index 5af2625b2..c5932d4c0 100644 --- a/api/util_test.go +++ b/api/util_test.go @@ -48,6 +48,14 @@ func testJob() *Job { return job } +func testServiceJob() *Job { + // Create a job of type service + task := NewTask("dummy-task", "exec").SetConfig("command", "/bin/sleep") + group1 := NewTaskGroup("dummy-group", 1).AddTask(task) + job := NewServiceJob("dummy-service", "dummy-service", "global", 5).AddTaskGroup(group1) + return job +} + func testJobWithScalingPolicy() *Job { job := testJob() job.TaskGroups[0].Scaling = &ScalingPolicy{