Golang NewTask示例

示例#1

文件： task_test.go 项目： JosephSalisbury/chrootly

func TestTaskZombie(t *testing.T) {
	image, err := chrootly.NewImageFromLocal("test_image.tar")
	if err != nil {
		t.Fatal("Could not create image: ", err)
	}
	task := chrootly.NewTask("sleep", []string{"100"}, image)

	task.SetStdout(ioutil.Discard)

	if err := task.Start(); err != nil {
		t.Fatal("Could not start task: ", err)
	}
	assert.True(t, task.Alive())
	assert.False(t, task.Zombie())

	if err := task.Kill(); err != nil {
		t.Fatal("Could not kill task: ", err)
	}

	// Give the system a beat to kill the process
	time.Sleep(200 * time.Millisecond)

	assert.True(t, task.Alive())
	assert.True(t, task.Zombie())

	if err := task.Wait(); err != nil {
		t.Fatal("Could not wait task: ", err)
	}
	assert.False(t, task.Alive())
	assert.False(t, task.Zombie())
}

示例#2

文件： task_test.go 项目： JosephSalisbury/chrootly

func TestKillTask(t *testing.T) {
	// https://code.google.com/p/go/issues/detail?id=7938

	image, err := chrootly.NewImageFromLocal("test_image.tar")
	if err != nil {
		t.Fatal("Could not create image: ", err)
	}
	task := chrootly.NewTask("sleep", []string{"100"}, image)

	task.SetStdout(ioutil.Discard)

	if err := task.Start(); err != nil {
		t.Fatal("Could not start task: ", err)
	}
	if err := task.Kill(); err != nil {
		t.Fatal("Could not kill task: ", err)
	}
	if err := task.Wait(); err != nil {
		t.Fatal("Could not wait task: ", err)
	}

	signaled, err := task.Signaled()
	if err != nil {
		t.Fatal("Could not get signaled: ", err)
	}

	assert.True(t, signaled)
}

示例#3

文件： task_test.go 项目： JosephSalisbury/chrootly

func TestSignalWithSigterm(t *testing.T) {
	image, err := chrootly.NewImageFromLocal("test_image.tar")
	if err != nil {
		t.Fatal("Could not create image: ", err)
	}
	task := chrootly.NewTask("sleep", []string{"10"}, image)

	task.SetStdout(ioutil.Discard)

	if err := task.Start(); err != nil {
		t.Fatal("Could not start task: ", err)
	}

	if err := task.Command.Process.Signal(syscall.SIGTERM); err != nil {
		t.Fatal("Could not signal process: ", err)
	}

	if err := task.Wait(); err != nil {
		t.Fatal("Could not wait task: ", err)
	}

	signaled, err := task.Signaled()
	if err != nil {
		t.Fatal("Could not get signaled of task: ", err)
	}
	assert.True(t, signaled)

	signal, err := task.Signal()
	if err != nil {
		t.Fatal("Could not get signal of task: ", err)
	}
	assert.Equal(t, syscall.SIGTERM, signal)
}

示例#4

文件： task_test.go 项目： JosephSalisbury/chrootly

func TestTaskWaitStatusNoWait(t *testing.T) {
	image, err := chrootly.NewImageFromLocal("test_image.tar")
	if err != nil {
		t.Fatal("Could not create image: ", err)
	}
	task := chrootly.NewTask("uname", []string{}, image)

	waitstatus, err := task.WaitStatus()
	assert.Nil(t, waitstatus)
	assert.NotNil(t, err)
}

示例#5

文件： task_test.go 项目： JosephSalisbury/chrootly

func TestErrorProcessStateNoWait(t *testing.T) {
	image, err := chrootly.NewImageFromLocal("test_image.tar")
	if err != nil {
		t.Fatal("Could not create image: ", err)
	}
	task := chrootly.NewTask("uname", []string{}, image)

	task.SetStdout(ioutil.Discard)

	processstate, err := task.ProcessState()
	assert.Nil(t, processstate)
	assert.NotNil(t, err)
}

示例#6

文件： main.go 项目： JosephSalisbury/chrootly-client

func start() {
	name := getName()
	imageDescriptor := getImageDescriptor()
	command, args := getCommand()

	image, err := chrootly.NewImage(imageDescriptor)
	if err != nil {
		fmt.Println(err)
		return
	}
	task := chrootly.NewTask(command, args, image)

	task.SetStdout(ioutil.Discard)
	task.SetStderr(ioutil.Discard)

	tasks[name] = task

	task.Start()
}

示例#7

文件： task_test.go 项目： JosephSalisbury/chrootly

func TestTaskWaitStatusSignaled(t *testing.T) {
	image, err := chrootly.NewImageFromLocal("test_image.tar")
	if err != nil {
		t.Fatal("Could not create image: ", err)
	}
	task := chrootly.NewTask("uname", []string{}, image)

	task.SetStdout(ioutil.Discard)

	if err := task.Start(); err != nil {
		t.Fatal("Could not start task: ", err)
	}
	if err := task.Wait(); err != nil {
		t.Fatal("Could not wait task: ", err)
	}

	waitStatus, _ := task.WaitStatus()
	assert.False(t, waitStatus.Signaled())
}

示例#8

文件： task_test.go 项目： JosephSalisbury/chrootly

func TestTaskProcessStateNoSuccess(t *testing.T) {
	image, err := chrootly.NewImageFromLocal("test_image.tar")
	if err != nil {
		t.Fatal("Could not create image: ", err)
	}
	task := chrootly.NewTask("ls", []string{"/notarealdir"}, image)

	task.SetStderr(ioutil.Discard)

	if err := task.Start(); err != nil {
		t.Fatal("Could not start task: ", err)
	}
	if err := task.Wait(); err == nil {
		t.Fatal("Task waited successfully: ", err)
	}

	processState, _ := task.ProcessState()
	assert.False(t, processState.Success())
}

示例#9

文件： task_test.go 项目： JosephSalisbury/chrootly

func TestTaskProcessState(t *testing.T) {
	image, err := chrootly.NewImageFromLocal("test_image.tar")
	if err != nil {
		t.Fatal("Could not create image: ", err)
	}
	task := chrootly.NewTask("uname", []string{}, image)

	task.SetStdout(ioutil.Discard)

	if err := task.Start(); err != nil {
		t.Fatal("Could not start task: ", err)
	}
	if err := task.Wait(); err != nil {
		t.Fatal("Could not wait task: ", err)
	}

	processState, _ := task.ProcessState()
	assert.True(t, processState.Success())
}

示例#10

文件： task_test.go 项目： JosephSalisbury/chrootly

func TestTaskAliveWithWait(t *testing.T) {
	image, err := chrootly.NewImageFromLocal("test_image.tar")
	if err != nil {
		t.Fatal("Could not create image: ", err)
	}
	task := chrootly.NewTask("sleep", []string{"3"}, image)

	task.SetStdout(ioutil.Discard)

	if err := task.Start(); err != nil {
		t.Fatal("Could not start task: ", err)
	}
	assert.True(t, task.Alive())

	if err := task.Wait(); err != nil {
		t.Fatal("Could not wait task: ", err)
	}
	assert.False(t, task.Alive())
}

示例#11

文件： main.go 项目： JosephSalisbury/chrootly-client

func run() {
	imageDescriptor := getImageDescriptor()
	command, args := getCommand()

	image, err := chrootly.NewImage(imageDescriptor)
	if err != nil {
		fmt.Println(err)
		return
	}
	task := chrootly.NewTask(command, args, image)

	err = task.Start()
	if err != nil {
		fmt.Println(err)
		return
	}

	err = task.Wait()
	if err != nil {
		fmt.Println(err)
		return
	}
}

示例#12

文件： task_test.go 项目： JosephSalisbury/chrootly

func TestTask(t *testing.T) {
	image, err := chrootly.NewImageFromLocal("test_image.tar")
	if err != nil {
		t.Fatal("Could not create image: ", err)
	}
	task := chrootly.NewTask("ls", []string{"-a", ".dockerenv"}, image)

	output := bytes.NewBuffer(nil)
	task.SetStdout(output)

	if err := task.Start(); err != nil {
		t.Fatal("Could not start task: ", err)
	}
	if err := task.Wait(); err != nil {
		t.Fatal("Could not wait task: ", err)
	}

	stdoutLine, err := output.ReadString('\n')
	if err != nil {
		t.Fatal("Could not read output: ", err)
	}

	assert.Equal(t, ".dockerenv\n", stdoutLine)
}