github.com/xiekeyang/containerd@v0.2.5/integration-test/exec_test.go (about)

     1  package main
     2  
     3  import (
     4  	"path/filepath"
     5  	"syscall"
     6  	"time"
     7  
     8  	"github.com/docker/containerd/api/grpc/types"
     9  	"github.com/docker/docker/pkg/integration/checker"
    10  	"github.com/go-check/check"
    11  )
    12  
    13  func (cs *ContainerdSuite) TestBusyboxTopExecEcho(t *check.C) {
    14  	bundleName := "busybox-top"
    15  	if err := CreateBusyboxBundle(bundleName, []string{"top"}); err != nil {
    16  		t.Fatal(err)
    17  	}
    18  
    19  	var (
    20  		err   error
    21  		initp *ContainerProcess
    22  		echop *ContainerProcess
    23  	)
    24  
    25  	containerID := "top"
    26  	initp, err = cs.StartContainer(containerID, bundleName)
    27  	t.Assert(err, checker.Equals, nil)
    28  
    29  	echop, err = cs.AddProcessToContainer(initp, "echo", "/", []string{"PATH=/bin"}, []string{"sh", "-c", "echo -n Ay Caramba! ; exit 1"}, 0, 0)
    30  	t.Assert(err, checker.Equals, nil)
    31  
    32  	for _, evt := range []types.Event{
    33  		{
    34  			Type:   "start-container",
    35  			Id:     containerID,
    36  			Status: 0,
    37  			Pid:    "",
    38  		},
    39  		{
    40  			Type:   "start-process",
    41  			Id:     containerID,
    42  			Status: 0,
    43  			Pid:    "echo",
    44  		},
    45  		{
    46  			Type:   "exit",
    47  			Id:     containerID,
    48  			Status: 1,
    49  			Pid:    "echo",
    50  		},
    51  	} {
    52  		ch := initp.GetEventsChannel()
    53  		e := <-ch
    54  		evt.Timestamp = e.Timestamp
    55  
    56  		t.Assert(*e, checker.Equals, evt)
    57  	}
    58  
    59  	t.Assert(echop.io.stdoutBuffer.String(), checker.Equals, "Ay Caramba!")
    60  }
    61  
    62  func (cs *ContainerdSuite) TestBusyboxTopExecTop(t *check.C) {
    63  	bundleName := "busybox-top"
    64  	if err := CreateBusyboxBundle(bundleName, []string{"top"}); err != nil {
    65  		t.Fatal(err)
    66  	}
    67  
    68  	var (
    69  		err   error
    70  		initp *ContainerProcess
    71  	)
    72  
    73  	containerID := "top"
    74  	initp, err = cs.StartContainer(containerID, bundleName)
    75  	t.Assert(err, checker.Equals, nil)
    76  
    77  	execID := "top1"
    78  	_, err = cs.AddProcessToContainer(initp, execID, "/", []string{"PATH=/usr/bin"}, []string{"top"}, 0, 0)
    79  	t.Assert(err, checker.Equals, nil)
    80  
    81  	for idx, evt := range []types.Event{
    82  		{
    83  			Type:   "start-container",
    84  			Id:     containerID,
    85  			Status: 0,
    86  			Pid:    "",
    87  		},
    88  		{
    89  			Type:   "start-process",
    90  			Id:     containerID,
    91  			Status: 0,
    92  			Pid:    execID,
    93  		},
    94  		{
    95  			Type:   "exit",
    96  			Id:     containerID,
    97  			Status: 137,
    98  			Pid:    execID,
    99  		},
   100  	} {
   101  		ch := initp.GetEventsChannel()
   102  		e := <-ch
   103  		evt.Timestamp = e.Timestamp
   104  		t.Assert(*e, checker.Equals, evt)
   105  		if idx == 1 {
   106  			// Process Started, kill it
   107  			cs.SignalContainerProcess(containerID, "top1", uint32(syscall.SIGKILL))
   108  		}
   109  	}
   110  
   111  	// Container should still be running
   112  	containers, err := cs.ListRunningContainers()
   113  	if err != nil {
   114  		t.Fatal(err)
   115  	}
   116  	t.Assert(len(containers), checker.Equals, 1)
   117  	t.Assert(containers[0].Id, checker.Equals, "top")
   118  	t.Assert(containers[0].Status, checker.Equals, "running")
   119  	t.Assert(containers[0].BundlePath, check.Equals, filepath.Join(cs.cwd, GetBundle(bundleName).Path))
   120  }
   121  
   122  func (cs *ContainerdSuite) TestBusyboxTopExecTopKillInit(t *check.C) {
   123  	bundleName := "busybox-top"
   124  	if err := CreateBusyboxBundle(bundleName, []string{"top"}); err != nil {
   125  		t.Fatal(err)
   126  	}
   127  
   128  	var (
   129  		err   error
   130  		initp *ContainerProcess
   131  	)
   132  
   133  	containerID := "top"
   134  	initp, err = cs.StartContainer(containerID, bundleName)
   135  	t.Assert(err, checker.Equals, nil)
   136  
   137  	execID := "top1"
   138  	_, err = cs.AddProcessToContainer(initp, execID, "/", []string{"PATH=/usr/bin"}, []string{"top"}, 0, 0)
   139  	t.Assert(err, checker.Equals, nil)
   140  
   141  	ch := initp.GetEventsChannel()
   142  	for _, evt := range []types.Event{
   143  		{
   144  			Type:   "start-container",
   145  			Id:     containerID,
   146  			Status: 0,
   147  			Pid:    "",
   148  		},
   149  		{
   150  			Type:   "start-process",
   151  			Id:     containerID,
   152  			Status: 0,
   153  			Pid:    execID,
   154  		},
   155  	} {
   156  		e := <-ch
   157  		evt.Timestamp = e.Timestamp
   158  		t.Assert(*e, checker.Equals, evt)
   159  	}
   160  
   161  	cs.SignalContainerProcess(containerID, "init", uint32(syscall.SIGTERM))
   162  	for i := 0; i < 2; i++ {
   163  		e := <-ch
   164  		switch e.Pid {
   165  		case "init":
   166  			evt := types.Event{
   167  				Type:      "exit",
   168  				Id:        containerID,
   169  				Status:    143,
   170  				Pid:       "init",
   171  				Timestamp: e.Timestamp,
   172  			}
   173  			t.Assert(*e, checker.Equals, evt)
   174  		case execID:
   175  			evt := types.Event{
   176  				Type:      "exit",
   177  				Id:        containerID,
   178  				Status:    137,
   179  				Pid:       execID,
   180  				Timestamp: e.Timestamp,
   181  			}
   182  			t.Assert(*e, checker.Equals, evt)
   183  		default:
   184  			t.Fatalf("Unexpected event %v", e)
   185  		}
   186  	}
   187  
   188  }
   189  
   190  func (cs *ContainerdSuite) TestBusyboxExecCreateDetachedChild(t *check.C) {
   191  	bundleName := "busybox-top"
   192  	if err := CreateBusyboxBundle(bundleName, []string{"top"}); err != nil {
   193  		t.Fatal(err)
   194  	}
   195  
   196  	var (
   197  		err   error
   198  		initp *ContainerProcess
   199  	)
   200  
   201  	containerID := "top"
   202  	initp, err = cs.StartContainer(containerID, bundleName)
   203  	t.Assert(err, checker.Equals, nil)
   204  
   205  	ch := initp.GetEventsChannel()
   206  	for _, evt := range []types.Event{
   207  		{
   208  			Type:   "start-container",
   209  			Id:     containerID,
   210  			Status: 0,
   211  			Pid:    "",
   212  		},
   213  	} {
   214  		e := <-ch
   215  		evt.Timestamp = e.Timestamp
   216  		t.Assert(*e, checker.Equals, evt)
   217  	}
   218  
   219  	execID := "sh-sleep"
   220  	_, err = cs.AddProcessToContainer(initp, execID, "/", []string{"PATH=/bin"}, []string{"sh", "-c", "sleep 1000 2>&- 1>&- 0<&- &"}, 0, 0)
   221  	t.Assert(err, checker.Equals, nil)
   222  	for _, evt := range []types.Event{
   223  		{
   224  			Type:   "start-process",
   225  			Id:     containerID,
   226  			Status: 0,
   227  			Pid:    execID,
   228  		},
   229  		{
   230  			Type:   "exit",
   231  			Id:     containerID,
   232  			Status: 0,
   233  			Pid:    execID,
   234  		},
   235  	} {
   236  		e := <-ch
   237  		evt.Timestamp = e.Timestamp
   238  		t.Assert(*e, checker.Equals, evt)
   239  	}
   240  
   241  	// Check that sleep is still running
   242  	execOutput, err := cs.AddProcessToContainer(initp, "ps", "/", []string{"PATH=/bin"}, []string{"ps", "aux"}, 0, 0)
   243  	t.Assert(err, checker.Equals, nil)
   244  	t.Assert(execOutput.io.stdoutBuffer.String(), checker.Contains, "sleep 1000")
   245  }
   246  
   247  func (cs *ContainerdSuite) TestBusyboxExecCreateAttachedChild(t *check.C) {
   248  	bundleName := "busybox-top"
   249  	if err := CreateBusyboxBundle(bundleName, []string{"top"}); err != nil {
   250  		t.Fatal(err)
   251  	}
   252  
   253  	var (
   254  		err   error
   255  		initp *ContainerProcess
   256  	)
   257  
   258  	containerID := "top"
   259  	initp, err = cs.StartContainer(containerID, bundleName)
   260  	t.Assert(err, checker.Equals, nil)
   261  
   262  	ch := initp.GetEventsChannel()
   263  	for _, evt := range []types.Event{
   264  		{
   265  			Type:   "start-container",
   266  			Id:     containerID,
   267  			Status: 0,
   268  			Pid:    "",
   269  		},
   270  	} {
   271  		e := <-ch
   272  		evt.Timestamp = e.Timestamp
   273  		t.Assert(*e, checker.Equals, evt)
   274  	}
   275  
   276  	doneCh := make(chan struct{})
   277  	go func() {
   278  		execID := "sh-sleep"
   279  		_, err = cs.AddProcessToContainer(initp, execID, "/", []string{"PATH=/bin"}, []string{"sh", "-c", "sleep 5 &"}, 0, 0)
   280  		t.Assert(err, checker.Equals, nil)
   281  		for _, evt := range []types.Event{
   282  			{
   283  				Type:   "start-process",
   284  				Id:     containerID,
   285  				Status: 0,
   286  				Pid:    execID,
   287  			},
   288  			{
   289  				Type:   "exit",
   290  				Id:     containerID,
   291  				Status: 0,
   292  				Pid:    execID,
   293  			},
   294  		} {
   295  			e := <-ch
   296  			evt.Timestamp = e.Timestamp
   297  			t.Assert(*e, checker.Equals, evt)
   298  		}
   299  		close(doneCh)
   300  	}()
   301  
   302  	select {
   303  	case <-doneCh:
   304  		break
   305  	case <-time.After(8 * time.Second):
   306  		t.Fatal("exec did not exit within 5 seconds")
   307  	}
   308  }