feat: cp docker cli code

Author: zeromake

internal/command/cli.go

@@ -383,12 +383,13 @@ func (cli *DebugCli) ContainerClean(ctx context.Context, id string) error {
 }
 
 // ExecCreate exec create
-func (cli *DebugCli) ExecCreate(options execOptions, container string) (types.IDResponse, error) {
+func (cli *DebugCli) ExecCreate(options execOptions, containerStr string) (types.IDResponse, error) {
 	var workDir = options.workDir
 	if workDir == "" && cli.config.MountDir != "" {
 		workDir = path.Join(cli.config.MountDir, options.targetDir)
 	}
-	opt := types.ExecConfig{
+	h, w := cli.out.GetTtySize()
+	opt := container.ExecOptions{
 		User:         options.user,
 		Privileged:   options.privileged,
 		DetachKeys:   options.detachKeys,
@@ -398,34 +399,67 @@ func (cli *DebugCli) ExecCreate(options execOptions, container string) (types.ID
 		AttachStdout: true,
 		WorkingDir:   workDir,
 		Cmd:          options.command,
+		ConsoleSize:  &[2]uint{h, w},
 	}
 	ctx, cancel := cli.withContent(cli.config.Timeout)
 	defer cancel()
-	resp, err := cli.client.ContainerExecCreate(ctx, container, opt)
+	resp, err := cli.client.ContainerExecCreate(ctx, containerStr, opt)
 	return resp, errors.WithStack(err)
 }
 
 // ExecStart exec start
-func (cli *DebugCli) ExecStart(_ execOptions, execID string) error {
-	execConfig := types.ExecStartCheck{
-		Tty: true,
+func (cli *DebugCli) ExecStart(options execOptions, execID string) error {
+	h, w := cli.out.GetTtySize()
+	execConfig := container.ExecStartOptions{
+		Tty:         true,
+		ConsoleSize: &[2]uint{h, w},
 	}
 
 	ctx, cancel := cli.withContent(cli.config.Timeout)
-	response, err := cli.client.ContainerExecAttach(ctx, execID, execConfig)
 	defer cancel()
+	response, err := cli.client.ContainerExecAttach(ctx, execID, execConfig)
 	if err != nil {
 		return errors.WithStack(err)
 	}
-	streamer := tty.HijackedIOStreamer{
-		Streams:      cli,
-		InputStream:  cli.in,
-		OutputStream: cli.out,
-		ErrorStream:  cli.err,
-		Resp:         response,
-		TTY:          true,
+	defer response.Close()
+	errCh := make(chan error, 1)
+	go func() {
+		defer close(errCh)
+		streamer := tty.HijackedIOStreamer{
+			Streams:      cli,
+			InputStream:  cli.in,
+			OutputStream: cli.out,
+			ErrorStream:  cli.err,
+			Resp:         response,
+			TTY:          true,
+			DetachKeys:   options.detachKeys,
+		}
+		errCh <- streamer.Stream(cli.ctx)
+	}()
+	if err := tty.MonitorTtySize(cli.ctx, cli.client, cli.out, execID, true); err != nil {
+		_, _ = fmt.Fprintln(cli.err, "Error monitoring TTY size:", err)
 	}
-	return streamer.Stream(cli.ctx, cli.config.ReadTimeout)
+	if err := <-errCh; err != nil {
+		logrus.Debugf("Error hijack: %s", err)
+		return err
+	}
+	return getExecExitStatus(cli.ctx, cli.client, execID)
+}
+
+func getExecExitStatus(ctx context.Context, apiClient client.ContainerAPIClient, execID string) error {
+	resp, err := apiClient.ContainerExecInspect(ctx, execID)
+	if err != nil {
+		// If we can't connect, then the daemon probably died.
+		if !client.IsErrConnectionFailed(err) {
+			return err
+		}
+		return errors.Errorf("ExitStatus %d", -1)
+	}
+	status := resp.ExitCode
+	if status != 0 {
+		return errors.Errorf("ExitStatus %d", status)
+	}
+	return nil
 }
 
 // FindContainer find container

pkg/tty/hijack.go

@@ -2,19 +2,16 @@ package tty
 
 import (
 	"context"
-	"io"
-	"net"
-	"runtime"
-	"sync"
-	"time"
-
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/pkg/ioutils"
 	"github.com/docker/docker/pkg/stdcopy"
 	"github.com/moby/term"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 	"github.com/zeromake/docker-debug/pkg/stream"
+	"io"
+	"runtime"
+	"sync"
 )
 
 // The default escape key sequence: ctrl-p, ctrl-q
@@ -39,7 +36,7 @@ type HijackedIOStreamer struct {
 // to/from the hijacked connection, blocking until it is either done reading
 // output, the user inputs the detach key sequence when in TTY mode, or when
 // the given context is cancelled.
-func (h *HijackedIOStreamer) Stream(ctx context.Context, readTimeout time.Duration) error {
+func (h *HijackedIOStreamer) Stream(ctx context.Context) error {
 	restoreInput, err := h.setupInput()
 	if err != nil {
 		return errors.Errorf("unable to setup input stream: %s", err)
@@ -48,7 +45,7 @@ func (h *HijackedIOStreamer) Stream(ctx context.Context, readTimeout time.Durati
 	defer restoreInput()
 	defer h.Resp.Close()
 	outputDone := h.beginOutputStream(restoreInput)
-	inputDone, detached := h.beginInputStream(ctx, restoreInput, readTimeout)
+	inputDone, detached := h.beginInputStream(restoreInput)
 
 	select {
 	case err = <-outputDone:
@@ -143,61 +140,13 @@ func (h *HijackedIOStreamer) beginOutputStream(restoreInput func()) <-chan error
 	return outputDone
 }
 
-var errInvalidWrite = errors.New("invalid write result")
-
-func Copy(ctx context.Context, dst net.Conn, src io.Reader, writeTimeout time.Duration) (written int64, err error) {
-	size := 32 * 1024
-	buf := make([]byte, size)
-	for {
-		select {
-		case <-ctx.Done():
-			err = ctx.Err()
-			return
-		default:
-		}
-		nr, er := src.Read(buf)
-		if nr > 0 {
-			// docker container is stop check
-			if writeTimeout > 0 {
-				err = dst.SetWriteDeadline(time.Now().Add(writeTimeout))
-				if err != nil {
-					break
-				}
-			}
-			nw, ew := dst.Write(buf[0:nr])
-			if nw < 0 || nr < nw {
-				nw = 0
-				if ew == nil {
-					ew = errInvalidWrite
-				}
-			}
-			written += int64(nw)
-			if ew != nil {
-				err = ew
-				break
-			}
-			if nr != nw {
-				err = io.ErrShortWrite
-				break
-			}
-		}
-		if er != nil {
-			if er != io.EOF {
-				err = er
-			}
-			break
-		}
-	}
-	return
-}
-
-func (h *HijackedIOStreamer) beginInputStream(ctx context.Context, restoreInput func(), readTimeout time.Duration) (doneC <-chan struct{}, detachedC <-chan error) {
+func (h *HijackedIOStreamer) beginInputStream(restoreInput func()) (doneC <-chan struct{}, detachedC <-chan error) {
 	inputDone := make(chan struct{})
 	detached := make(chan error)
 
 	go func() {
 		if h.InputStream != nil {
-			_, err := Copy(ctx, h.Resp.Conn, h.InputStream, readTimeout)
+			_, err := io.Copy(h.Resp.Conn, h.InputStream)
 			restoreInput()
 
 			logrus.Debug("[hijack] End of stdin")