Make Wait() async

In all of the examples, its recommended to call `Wait()` before starting
a process/task.
Since `Wait()` is a blocking call, this means it must be called from a
goroutine like so:

```go
statusC := make(chan uint32)
go func() {
  status, err := task.Wait(ctx)
  if err != nil {
    // handle async err
  }

  statusC <- status
}()

task.Start(ctx)
<-statusC
```

This means there is a race here where there is no guarentee when the
goroutine is going to be scheduled, and even a bit more since this
requires an RPC call to be made.
In addition, this code is very messy and a common pattern for any caller
using Wait+Start.

Instead, this changes `Wait()` to use an async model having `Wait()`
return a channel instead of the code itself.
This ensures that when `Wait()` returns that the client has a handle on
the event stream (already made the RPC request) before returning and
reduces any sort of race to how the stream is handled by grpc since we
can't guarentee that we have a goroutine running and blocked on
`Recv()`.

Making `Wait()` async also cleans up the code in the caller drastically:

```go
statusC, err := task.Wait(ctx)
if err != nil {
  return err
}

task.Start(ctx)

status := <-statusC
if status.Err != nil {
  return err
}
```

No more spinning up goroutines and more natural error
handling for the caller.

Signed-off-by: Brian Goff <cpuguy83@gmail.com>

cmd/ctr/attach.go

@@ -44,6 +44,12 @@ var taskAttachCommand = cli.Command{
 			return err
 		}
 		defer task.Delete(ctx)
+
+		statusC, err := task.Wait(ctx)
+		if err != nil {
+			return err
+		}
+
 		if tty {
 			if err := handleConsoleResize(ctx, task, con); err != nil {
 				logrus.WithError(err).Error("console resize")
@@ -52,12 +58,13 @@ var taskAttachCommand = cli.Command{
 			sigc := forwardAllSignals(ctx, task)
 			defer stopCatch(sigc)
 		}
-		status, err := task.Wait(ctx)
-		if err != nil {
+
+		ec := <-statusC
+		if ec.Err != nil {
 			return err
 		}
-		if status != 0 {
-			return cli.NewExitError("", int(status))
+		if ec.Code != 0 {
+			return cli.NewExitError("", int(ec.Code))
 		}
 		return nil
 	},

cmd/ctr/exec.go

@@ -70,14 +70,11 @@ var taskExecCommand = cli.Command{
 		}
 		defer process.Delete(ctx)
 
-		statusC := make(chan uint32, 1)
-		go func() {
-			status, err := process.Wait(ctx)
-			if err != nil {
-				logrus.WithError(err).Error("wait process")
-			}
-			statusC <- status
-		}()
+		statusC, err := task.Wait(ctx)
+		if err != nil {
+			return err
+		}
+
 		var con console.Console
 		if tty {
 			con = console.Current()
@@ -98,8 +95,11 @@ var taskExecCommand = cli.Command{
 			defer stopCatch(sigc)
 		}
 		status := <-statusC
-		if status != 0 {
-			return cli.NewExitError("", int(status))
+		if status.Err != nil {
+			return status.Err
+		}
+		if status.Code != 0 {
+			return cli.NewExitError("", int(status.Code))
 		}
 		return nil
 	},

cmd/ctr/run.go

@@ -129,14 +129,11 @@ var runCommand = cli.Command{
 		}
 		defer task.Delete(ctx)
 
-		statusC := make(chan uint32, 1)
-		go func() {
-			status, err := task.Wait(ctx)
-			if err != nil {
-				logrus.WithError(err).Error("wait process")
-			}
-			statusC <- status
-		}()
+		statusC, err := task.Wait(ctx)
+		if err != nil {
+			return err
+		}
+
 		var con console.Console
 		if tty {
 			con = console.Current()
@@ -158,11 +155,15 @@ var runCommand = cli.Command{
 		}
 
 		status := <-statusC
+		if status.Err != nil {
+			return status.Err
+		}
+
 		if _, err := task.Delete(ctx); err != nil {
 			return err
 		}
-		if status != 0 {
-			return cli.NewExitError("", int(status))
+		if status.Code != 0 {
+			return cli.NewExitError("", int(status.Code))
 		}
 		return nil
 	},

cmd/ctr/start.go

@@ -47,14 +47,11 @@ var taskStartCommand = cli.Command{
 		}
 		defer task.Delete(ctx)
 
-		statusC := make(chan uint32, 1)
-		go func() {
-			status, err := task.Wait(ctx)
-			if err != nil {
-				logrus.WithError(err).Error("wait process")
-			}
-			statusC <- status
-		}()
+		statusC, err := task.Wait(ctx)
+		if err != nil {
+			return err
+		}
+
 		var con console.Console
 		if tty {
 			con = console.Current()
@@ -76,11 +73,14 @@ var taskStartCommand = cli.Command{
 		}
 
 		status := <-statusC
+		if status.Err != nil {
+			return err
+		}
 		if _, err := task.Delete(ctx); err != nil {
 			return err
 		}
-		if status != 0 {
-			return cli.NewExitError("", int(status))
+		if status.Code != 0 {
+			return cli.NewExitError("", int(status.Code))
 		}
 		return nil
 	},