Add cwd argument for hooks exec Run func

Signed-off-by: Fang-Pen Lin <[email protected]>

Author: fangpenlin

pkg/hooks/exec/exec.go

@@ -18,11 +18,12 @@ const DefaultPostKillTimeout = time.Duration(10) * time.Second
 
 // Run executes the hook and waits for it to complete or for the
 // context or hook-specified timeout to expire.
-func Run(ctx context.Context, hook *rspec.Hook, state []byte, stdout io.Writer, stderr io.Writer, postKillTimeout time.Duration) (hookErr, err error) {
+func Run(ctx context.Context, hook *rspec.Hook, cwd string, state []byte, stdout io.Writer, stderr io.Writer, postKillTimeout time.Duration) (hookErr, err error) {
 	cmd := osexec.Cmd{
 		Path:   hook.Path,
 		Args:   hook.Args,
 		Env:    hook.Env,
+		Dir:    cwd,
 		Stdin:  bytes.NewReader(state),
 		Stdout: stdout,
 		Stderr: stderr,

pkg/hooks/exec/exec_test.go

@@ -29,7 +29,11 @@ func TestRun(t *testing.T) {
 		Args: []string{"sh", "-c", "cat"},
 	}
 	var stderr, stdout bytes.Buffer
-	hookErr, err := Run(ctx, hook, []byte("{}"), &stdout, &stderr, DefaultPostKillTimeout)
+	cwd, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
+	hookErr, err := Run(ctx, hook, cwd, []byte("{}"), &stdout, &stderr, DefaultPostKillTimeout)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -46,7 +50,11 @@ func TestRunIgnoreOutput(t *testing.T) {
 		Path: path,
 		Args: []string{"sh", "-c", "cat"},
 	}
-	hookErr, err := Run(ctx, hook, []byte("{}"), nil, nil, DefaultPostKillTimeout)
+	cwd, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
+	hookErr, err := Run(ctx, hook, cwd, []byte("{}"), nil, nil, DefaultPostKillTimeout)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -60,7 +68,11 @@ func TestRunFailedStart(t *testing.T) {
 	hook := &rspec.Hook{
 		Path: "/does/not/exist",
 	}
-	hookErr, err := Run(ctx, hook, []byte("{}"), nil, nil, DefaultPostKillTimeout)
+	cwd, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
+	hookErr, err := Run(ctx, hook, cwd, []byte("{}"), nil, nil, DefaultPostKillTimeout)
 	if err == nil {
 		t.Fatal("unexpected success")
 	}
@@ -91,6 +103,10 @@ func parseEnvironment(input string) (env map[string]string, err error) {
 
 func TestRunEnvironment(t *testing.T) {
 	ctx := context.Background()
+	cwd, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
 	hook := &rspec.Hook{
 		Path: path,
 		Args: []string{"sh", "-c", "env"},
@@ -125,7 +141,7 @@ func TestRunEnvironment(t *testing.T) {
 		t.Run(test.name, func(t *testing.T) {
 			var stderr, stdout bytes.Buffer
 			hook.Env = test.env
-			hookErr, err := Run(ctx, hook, []byte("{}"), &stdout, &stderr, DefaultPostKillTimeout)
+			hookErr, err := Run(ctx, hook, cwd, []byte("{}"), &stdout, &stderr, DefaultPostKillTimeout)
 			if err != nil {
 				t.Fatal(err)
 			}
@@ -143,11 +159,34 @@ func TestRunEnvironment(t *testing.T) {
 	}
 }
 
+func TestRunCwd(t *testing.T) {
+	ctx := context.Background()
+	hook := &rspec.Hook{
+		Path: path,
+		Args: []string{"sh", "-c", "pwd"},
+	}
+	cwd := "/path/to/container/userdata"
+	var stderr, stdout bytes.Buffer
+	hookErr, err := Run(ctx, hook, cwd, []byte("{}"), &stdout, &stderr, DefaultPostKillTimeout)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if hookErr != nil {
+		t.Fatal(hookErr)
+	}
+	assert.Equal(t, "", stderr.String())
+	assert.Equal(t, stdout.String(), cwd)
+}
+
 func TestRunCancel(t *testing.T) {
 	hook := &rspec.Hook{
 		Path: path,
 		Args: []string{"sh", "-c", "echo waiting; sleep 2; echo done"},
 	}
+	cwd, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
 	one := 1
 	for _, tt := range []struct {
 		name              string
@@ -186,7 +225,7 @@ func TestRunCancel(t *testing.T) {
 				defer cancel()
 			}
 			hook.Timeout = test.hookTimeout
-			hookErr, err := Run(ctx, hook, []byte("{}"), &stdout, &stderr, DefaultPostKillTimeout)
+			hookErr, err := Run(ctx, hook, cwd, []byte("{}"), &stdout, &stderr, DefaultPostKillTimeout)
 			assert.Equal(t, test.expectedRunError, err)
 			if test.expectedHookError == "" {
 				if hookErr != nil {
@@ -204,11 +243,15 @@ func TestRunCancel(t *testing.T) {
 func TestRunKillTimeout(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(500)*time.Millisecond)
 	defer cancel()
+	cwd, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
 	hook := &rspec.Hook{
 		Path: path,
 		Args: []string{"sh", "-c", "sleep 1"},
 	}
-	hookErr, err := Run(ctx, hook, []byte("{}"), nil, nil, time.Duration(0))
+	hookErr, err := Run(ctx, hook, cwd, []byte("{}"), nil, nil, time.Duration(0))
 	assert.Equal(t, context.DeadlineExceeded, err)
 	assert.Regexp(t, "^(failed to reap process within 0s of the kill signal|executing \\[sh -c sleep 1]: signal: killed)$", hookErr)
 }

pkg/hooks/exec/runtimeconfigfilter.go

@@ -25,15 +25,15 @@ var spewConfig = spew.ConfigState{
 // passing container state on their standard input,
 // RuntimeConfigFilter passes the proposed runtime configuration (and
 // reads back a possibly-altered form from their standard output).
-func RuntimeConfigFilter(ctx context.Context, hooks []spec.Hook, config *spec.Spec, postKillTimeout time.Duration) (hookErr, err error) {
+func RuntimeConfigFilter(ctx context.Context, hooks []spec.Hook, cwd string, config *spec.Spec, postKillTimeout time.Duration) (hookErr, err error) {
 	data, err := json.Marshal(config)
 	if err != nil {
 		return nil, err
 	}
 	for i, hook := range hooks {
 		hook := hook
 		var stdout bytes.Buffer
-		hookErr, err = Run(ctx, &hook, data, &stdout, nil, postKillTimeout)
+		hookErr, err = Run(ctx, &hook, cwd, data, &stdout, nil, postKillTimeout)
 		if err != nil {
 			return hookErr, err
 		}

pkg/hooks/exec/runtimeconfigfilter_test.go

@@ -17,6 +17,10 @@ func TestRuntimeConfigFilter(t *testing.T) {
 	fileMode := os.FileMode(0o600)
 	rootUint32 := uint32(0)
 	binUser := int(1)
+	cwd, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
 	for _, tt := range []struct {
 		name                   string
 		contextTimeout         time.Duration
@@ -243,7 +247,7 @@ func TestRuntimeConfigFilter(t *testing.T) {
 				ctx, cancel = context.WithTimeout(ctx, test.contextTimeout)
 				defer cancel()
 			}
-			hookErr, err := RuntimeConfigFilter(ctx, test.hooks, test.input, DefaultPostKillTimeout)
+			hookErr, err := RuntimeConfigFilter(ctx, test.hooks, cwd, test.input, DefaultPostKillTimeout)
 			if test.expectedRunErrorString != "" {
 				// We have to compare the error strings in that case because
 				// errors.Is works differently.