github.com/Ilhicas/nomad@v1.0.4-0.20210304152020-e86851182bc3/drivers/exec/driver_unix_test.go (about)

     1  // +build darwin dragonfly freebsd linux netbsd openbsd solaris
     2  
     3  package exec
     4  
     5  import (
     6  	"context"
     7  	"fmt"
     8  	"testing"
     9  	"time"
    10  
    11  	"github.com/stretchr/testify/require"
    12  	"golang.org/x/sys/unix"
    13  
    14  	ctestutils "github.com/hashicorp/nomad/client/testutil"
    15  	"github.com/hashicorp/nomad/helper/testlog"
    16  	"github.com/hashicorp/nomad/helper/uuid"
    17  	"github.com/hashicorp/nomad/plugins/drivers"
    18  	dtestutil "github.com/hashicorp/nomad/plugins/drivers/testutils"
    19  	"github.com/hashicorp/nomad/testutil"
    20  )
    21  
    22  func TestExecDriver_StartWaitStop(t *testing.T) {
    23  	t.Parallel()
    24  	require := require.New(t)
    25  	ctestutils.ExecCompatible(t)
    26  
    27  	ctx, cancel := context.WithCancel(context.Background())
    28  	defer cancel()
    29  
    30  	d := NewExecDriver(ctx, testlog.HCLogger(t))
    31  	harness := dtestutil.NewDriverHarness(t, d)
    32  	task := &drivers.TaskConfig{
    33  		ID:        uuid.Generate(),
    34  		Name:      "test",
    35  		Resources: testResources,
    36  	}
    37  
    38  	taskConfig := map[string]interface{}{
    39  		"command": "/bin/sleep",
    40  		"args":    []string{"600"},
    41  	}
    42  	require.NoError(task.EncodeConcreteDriverConfig(&taskConfig))
    43  
    44  	cleanup := harness.MkAllocDir(task, false)
    45  	defer cleanup()
    46  
    47  	handle, _, err := harness.StartTask(task)
    48  	defer harness.DestroyTask(task.ID, true)
    49  	require.NoError(err)
    50  
    51  	ch, err := harness.WaitTask(context.Background(), handle.Config.ID)
    52  	require.NoError(err)
    53  
    54  	require.NoError(harness.WaitUntilStarted(task.ID, 1*time.Second))
    55  
    56  	go func() {
    57  		harness.StopTask(task.ID, 2*time.Second, "SIGKILL")
    58  	}()
    59  
    60  	select {
    61  	case result := <-ch:
    62  		require.Equal(int(unix.SIGKILL), result.Signal)
    63  	case <-time.After(10 * time.Second):
    64  		require.Fail("timeout waiting for task to shutdown")
    65  	}
    66  
    67  	// Ensure that the task is marked as dead, but account
    68  	// for WaitTask() closing channel before internal state is updated
    69  	testutil.WaitForResult(func() (bool, error) {
    70  		status, err := harness.InspectTask(task.ID)
    71  		if err != nil {
    72  			return false, fmt.Errorf("inspecting task failed: %v", err)
    73  		}
    74  		if status.State != drivers.TaskStateExited {
    75  			return false, fmt.Errorf("task hasn't exited yet; status: %v", status.State)
    76  		}
    77  
    78  		return true, nil
    79  	}, func(err error) {
    80  		require.NoError(err)
    81  	})
    82  }
    83  
    84  func TestExec_ExecTaskStreaming(t *testing.T) {
    85  	t.Parallel()
    86  	require := require.New(t)
    87  
    88  	ctx, cancel := context.WithCancel(context.Background())
    89  	defer cancel()
    90  
    91  	d := NewExecDriver(ctx, testlog.HCLogger(t))
    92  	harness := dtestutil.NewDriverHarness(t, d)
    93  	defer harness.Kill()
    94  
    95  	task := &drivers.TaskConfig{
    96  		ID:   uuid.Generate(),
    97  		Name: "sleep",
    98  	}
    99  
   100  	cleanup := harness.MkAllocDir(task, false)
   101  	defer cleanup()
   102  
   103  	tc := &TaskConfig{
   104  		Command: "/bin/sleep",
   105  		Args:    []string{"9000"},
   106  	}
   107  	require.NoError(task.EncodeConcreteDriverConfig(&tc))
   108  
   109  	_, _, err := harness.StartTask(task)
   110  	require.NoError(err)
   111  	defer d.DestroyTask(task.ID, true)
   112  
   113  	dtestutil.ExecTaskStreamingConformanceTests(t, harness, task.ID)
   114  
   115  }
   116  
   117  // Tests that a given DNSConfig properly configures dns
   118  func TestExec_dnsConfig(t *testing.T) {
   119  	t.Parallel()
   120  	ctestutils.RequireRoot(t)
   121  	ctestutils.ExecCompatible(t)
   122  	require := require.New(t)
   123  
   124  	ctx, cancel := context.WithCancel(context.Background())
   125  	defer cancel()
   126  
   127  	d := NewExecDriver(ctx, testlog.HCLogger(t))
   128  	harness := dtestutil.NewDriverHarness(t, d)
   129  	defer harness.Kill()
   130  
   131  	cases := []struct {
   132  		name string
   133  		cfg  *drivers.DNSConfig
   134  	}{
   135  		{
   136  			name: "nil DNSConfig",
   137  		},
   138  		{
   139  			name: "basic",
   140  			cfg: &drivers.DNSConfig{
   141  				Servers: []string{"1.1.1.1", "1.0.0.1"},
   142  			},
   143  		},
   144  		{
   145  			name: "full",
   146  			cfg: &drivers.DNSConfig{
   147  				Servers:  []string{"1.1.1.1", "1.0.0.1"},
   148  				Searches: []string{"local.test", "node.consul"},
   149  				Options:  []string{"ndots:2", "edns0"},
   150  			},
   151  		},
   152  	}
   153  
   154  	for _, c := range cases {
   155  		task := &drivers.TaskConfig{
   156  			ID:   uuid.Generate(),
   157  			Name: "sleep",
   158  			DNS:  c.cfg,
   159  		}
   160  
   161  		cleanup := harness.MkAllocDir(task, false)
   162  		defer cleanup()
   163  
   164  		tc := &TaskConfig{
   165  			Command: "/bin/sleep",
   166  			Args:    []string{"9000"},
   167  		}
   168  		require.NoError(task.EncodeConcreteDriverConfig(&tc))
   169  
   170  		_, _, err := harness.StartTask(task)
   171  		require.NoError(err)
   172  		defer d.DestroyTask(task.ID, true)
   173  
   174  		dtestutil.TestTaskDNSConfig(t, harness, task.ID, c.cfg)
   175  	}
   176  
   177  }