func TestRawExecDriverUser(t *testing.T) { task := &structs.Task{ Name: "sleep", User: "******", Config: map[string]interface{}{ "command": testtask.Path(), "args": []string{"sleep", "45s"}, }, LogConfig: &structs.LogConfig{ MaxFiles: 10, MaxFileSizeMB: 10, }, Resources: basicResources, } testtask.SetTaskEnv(task) driverCtx, execCtx := testDriverContexts(task) defer execCtx.AllocDir.Destroy() d := NewRawExecDriver(driverCtx) handle, err := d.Start(execCtx, task) if err == nil { handle.Kill() t.Fatalf("Should've failed") } msg := "unknown user alice" if !strings.Contains(err.Error(), msg) { t.Fatalf("Expecting '%v' in '%v'", msg, err) } }
func TestRawExecDriver_Start_Wait_AllocDir(t *testing.T) { t.Parallel() exp := []byte{'w', 'i', 'n'} file := "output.txt" outPath := fmt.Sprintf(`${%s}/%s`, env.AllocDir, file) task := &structs.Task{ Name: "sleep", Config: map[string]interface{}{ "command": testtask.Path(), "args": []string{ "sleep", "1s", "write", string(exp), outPath, }, }, LogConfig: &structs.LogConfig{ MaxFiles: 10, MaxFileSizeMB: 10, }, Resources: basicResources, } testtask.SetTaskEnv(task) driverCtx, execCtx := testDriverContexts(task) defer execCtx.AllocDir.Destroy() d := NewRawExecDriver(driverCtx) handle, err := d.Start(execCtx, task) if err != nil { t.Fatalf("err: %v", err) } if handle == nil { t.Fatalf("missing handle") } // Task should terminate quickly select { case res := <-handle.WaitCh(): if !res.Successful() { t.Fatalf("err: %v", res) } case <-time.After(time.Duration(testutil.TestMultiplier()*5) * time.Second): t.Fatalf("timeout") } // Check that data was written to the shared alloc directory. outputFile := filepath.Join(execCtx.AllocDir.SharedDir, file) act, err := ioutil.ReadFile(outputFile) if err != nil { t.Fatalf("Couldn't read expected output: %v", err) } if !reflect.DeepEqual(act, exp) { t.Fatalf("Command outputted %v; want %v", act, exp) } }
func TestRawExecDriver_Start_Artifact_basic(t *testing.T) { t.Parallel() path := testtask.Path() ts := httptest.NewServer(http.FileServer(http.Dir(filepath.Dir(path)))) defer ts.Close() file := filepath.Base(path) task := &structs.Task{ Name: "sleep", Config: map[string]interface{}{ "artifact_source": fmt.Sprintf("%s/%s", ts.URL, file), "command": file, "args": []string{"sleep", "1s"}, }, LogConfig: &structs.LogConfig{ MaxFiles: 10, MaxFileSizeMB: 10, }, Resources: basicResources, } testtask.SetTaskEnv(task) driverCtx, execCtx := testDriverContexts(task) defer execCtx.AllocDir.Destroy() d := NewRawExecDriver(driverCtx) handle, err := d.Start(execCtx, task) if err != nil { t.Fatalf("err: %v", err) } if handle == nil { t.Fatalf("missing handle") } // Attempt to open handle2, err := d.Open(execCtx, handle.ID()) if err != nil { t.Fatalf("err: %v", err) } if handle2 == nil { t.Fatalf("missing handle") } // Task should terminate quickly select { case <-handle2.WaitCh(): case <-time.After(time.Duration(testutil.TestMultiplier()*5) * time.Second): t.Fatalf("timeout") } }
func TestRawExecDriver_Start_Kill_Wait(t *testing.T) { t.Parallel() task := &structs.Task{ Name: "sleep", Config: map[string]interface{}{ "command": testtask.Path(), "args": []string{"sleep", "45s"}, }, LogConfig: &structs.LogConfig{ MaxFiles: 10, MaxFileSizeMB: 10, }, Resources: basicResources, } testtask.SetTaskEnv(task) driverCtx, execCtx := testDriverContexts(task) defer execCtx.AllocDir.Destroy() d := NewRawExecDriver(driverCtx) handle, err := d.Start(execCtx, task) if err != nil { t.Fatalf("err: %v", err) } if handle == nil { t.Fatalf("missing handle") } go func() { time.Sleep(1 * time.Second) err := handle.Kill() // Can't rely on the ordering between wait and kill on travis... if !testutil.IsTravis() && err != nil { t.Fatalf("err: %v", err) } }() // Task should terminate quickly select { case res := <-handle.WaitCh(): if res.Successful() { t.Fatal("should err") } case <-time.After(time.Duration(testutil.TestMultiplier()*5) * time.Second): t.Fatalf("timeout") } }
func TestRawExecDriver_Start_Artifact_expanded(t *testing.T) { t.Parallel() path := testtask.Path() ts := httptest.NewServer(http.FileServer(http.Dir(filepath.Dir(path)))) defer ts.Close() file := filepath.Base(path) task := &structs.Task{ Name: "sleep", Config: map[string]interface{}{ "artifact_source": fmt.Sprintf("%s/%s", ts.URL, file), "command": filepath.Join("$NOMAD_TASK_DIR", file), "args": []string{"sleep", "1s"}, }, Resources: basicResources, } testtask.SetTaskEnv(task) driverCtx := testDriverContext(task.Name) ctx := testDriverExecContext(task, driverCtx) defer ctx.AllocDir.Destroy() d := NewRawExecDriver(driverCtx) handle, err := d.Start(ctx, task) if err != nil { t.Fatalf("err: %v", err) } if handle == nil { t.Fatalf("missing handle") } // Attempt to open handle2, err := d.Open(ctx, handle.ID()) if err != nil { t.Fatalf("err: %v", err) } if handle2 == nil { t.Fatalf("missing handle") } // Task should terminate quickly select { case <-handle2.WaitCh(): case <-time.After(5 * time.Second): t.Fatalf("timeout") } }
func TestRawExecDriver_StartOpen_Wait(t *testing.T) { t.Parallel() task := &structs.Task{ Name: "sleep", Config: map[string]interface{}{ "command": testtask.Path(), "args": []string{"sleep", "1s"}, }, LogConfig: &structs.LogConfig{ MaxFiles: 10, MaxFileSizeMB: 10, }, Resources: basicResources, } testtask.SetTaskEnv(task) driverCtx, execCtx := testDriverContexts(task) defer execCtx.AllocDir.Destroy() d := NewRawExecDriver(driverCtx) handle, err := d.Start(execCtx, task) if err != nil { t.Fatalf("err: %v", err) } if handle == nil { t.Fatalf("missing handle") } // Attempt to open handle2, err := d.Open(execCtx, handle.ID()) if err != nil { t.Fatalf("err: %v", err) } if handle2 == nil { t.Fatalf("missing handle") } // Task should terminate quickly select { case <-handle2.WaitCh(): case <-time.After(time.Duration(testutil.TestMultiplier()*5) * time.Second): t.Fatalf("timeout") } handle.Kill() handle2.Kill() }
func TestRawExecDriver_Start_Kill_Wait(t *testing.T) { t.Parallel() task := &structs.Task{ Name: "sleep", Config: map[string]interface{}{ "command": testtask.Path(), "args": []string{"sleep", "1s"}, }, Resources: basicResources, } testtask.SetTaskEnv(task) driverCtx := testDriverContext(task.Name) ctx := testDriverExecContext(task, driverCtx) defer ctx.AllocDir.Destroy() d := NewRawExecDriver(driverCtx) handle, err := d.Start(ctx, task) if err != nil { t.Fatalf("err: %v", err) } if handle == nil { t.Fatalf("missing handle") } go func() { time.Sleep(100 * time.Millisecond) err := handle.Kill() if err != nil { t.Fatalf("err: %v", err) } }() // Task should terminate quickly select { case res := <-handle.WaitCh(): if res.Successful() { t.Fatal("should err") } case <-time.After(2 * time.Second): t.Fatalf("timeout") } }
func TestRawExecDriver_Start_Wait(t *testing.T) { task := &structs.Task{ Name: "sleep", Config: map[string]interface{}{ "command": testtask.Path(), "args": []string{"sleep", "1s"}, }, LogConfig: &structs.LogConfig{ MaxFiles: 10, MaxFileSizeMB: 10, }, Resources: basicResources, } testtask.SetTaskEnv(task) driverCtx, execCtx := testDriverContexts(task) defer execCtx.AllocDir.Destroy() d := NewRawExecDriver(driverCtx) handle, err := d.Start(execCtx, task) if err != nil { t.Fatalf("err: %v", err) } if handle == nil { t.Fatalf("missing handle") } // Update should be a no-op err = handle.Update(task) if err != nil { t.Fatalf("err: %v", err) } // Task should terminate quickly select { case res := <-handle.WaitCh(): if !res.Successful() { t.Fatalf("err: %v", res) } case <-time.After(time.Duration(testutil.TestMultiplier()*5) * time.Second): t.Fatalf("timeout") } }
func TestRawExecDriver_StartOpen_Wait(t *testing.T) { t.Parallel() task := &structs.Task{ Name: "sleep", Config: map[string]interface{}{ "command": testtask.Path(), "args": []string{"sleep", "1s"}, }, Resources: basicResources, } testtask.SetTaskEnv(task) driverCtx := testDriverContext(task.Name) ctx := testDriverExecContext(task, driverCtx) defer ctx.AllocDir.Destroy() d := NewRawExecDriver(driverCtx) handle, err := d.Start(ctx, task) if err != nil { t.Fatalf("err: %v", err) } if handle == nil { t.Fatalf("missing handle") } // Attempt to open handle2, err := d.Open(ctx, handle.ID()) if err != nil { t.Fatalf("err: %v", err) } if handle2 == nil { t.Fatalf("missing handle") } // Task should terminate quickly select { case <-handle2.WaitCh(): case <-time.After(2 * time.Second): t.Fatalf("timeout") } }