@@ -17,7 +17,6 @@ import (

 	"github.com/docker/docker/client"

 	"github.com/docker/docker/dockerversion"

 	dopts "github.com/docker/docker/opts"

-	"github.com/docker/docker/pkg/term"

 	"github.com/docker/go-connections/sockets"

 	"github.com/docker/go-connections/tlsconfig"

 )

@@ -25,33 +24,12 @@ import (

 // DockerCli represents the docker command line client.

 // Instances of the client can be returned from NewDockerCli.

 type DockerCli struct {

-	// initializing closure

-	init func() error

-

-	// configFile has the client configuration file

 	configFile *configfile.ConfigFile

-	// in holds the input stream and closer (io.ReadCloser) for the client.

-	in io.ReadCloser

-	// out holds the output stream (io.Writer) for the client.

-	out io.Writer

-	// err holds the error stream (io.Writer) for the client.

-	err io.Writer

-	// keyFile holds the key file as a string.

-	keyFile string

-	// inFd holds the file descriptor of the client's STDIN (if valid).

-	inFd uintptr

-	// outFd holds file descriptor of the client's STDOUT (if valid).

-	outFd uintptr

-	// isTerminalIn indicates whether the client's STDIN is a TTY

-	isTerminalIn bool

-	// isTerminalOut indicates whether the client's STDOUT is a TTY

-	isTerminalOut bool

-	// client is the http client that performs all API operations

-	client client.APIClient

-	// inState holds the terminal input state

-	inState *term.State

-	// outState holds the terminal output state

-	outState *term.State

+	in         *InStream

+	out        *OutStream

+	err        io.Writer

+	keyFile    string

+	client     client.APIClient

 }

 // Client returns the APIClient

@@ -60,7 +38,7 @@ func (cli *DockerCli) Client() client.APIClient {

 }

 // Out returns the writer used for stdout

-func (cli *DockerCli) Out() io.Writer {

+func (cli *DockerCli) Out() *OutStream {

 	return cli.out

 }

@@ -70,7 +48,7 @@ func (cli *DockerCli) Err() io.Writer {

 }

 // In returns the reader used for stdin

-func (cli *DockerCli) In() io.ReadCloser {

+func (cli *DockerCli) In() *InStream {

 	return cli.in

 }

@@ -79,93 +57,16 @@ func (cli *DockerCli) ConfigFile() *configfile.ConfigFile {

 	return cli.configFile

 }

-// IsTerminalIn returns true if the clients stdin is a TTY

-func (cli *DockerCli) IsTerminalIn() bool {

-	return cli.isTerminalIn

-}

-

-// IsTerminalOut returns true if the clients stdout is a TTY

-func (cli *DockerCli) IsTerminalOut() bool {

-	return cli.isTerminalOut

-}

-

-// OutFd returns the fd for the stdout stream

-func (cli *DockerCli) OutFd() uintptr {

-	return cli.outFd

-}

-

-// CheckTtyInput checks if we are trying to attach to a container tty

-// from a non-tty client input stream, and if so, returns an error.

-func (cli *DockerCli) CheckTtyInput(attachStdin, ttyMode bool) error {

-	// In order to attach to a container tty, input stream for the client must

-	// be a tty itself: redirecting or piping the client standard input is

-	// incompatible with `docker run -t`, `docker exec -t` or `docker attach`.

-	if ttyMode && attachStdin && !cli.isTerminalIn {

-		eText := "the input device is not a TTY"

-		if runtime.GOOS == "windows" {

-			return errors.New(eText + ".  If you are using mintty, try prefixing the command with 'winpty'")

-		}

-		return errors.New(eText)

-	}

-	return nil

-}

-

-func (cli *DockerCli) setRawTerminal() error {

-	if os.Getenv("NORAW") == "" {

-		if cli.isTerminalIn {

-			state, err := term.SetRawTerminal(cli.inFd)

-			if err != nil {

-				return err

-			}

-			cli.inState = state

-		}

-		if cli.isTerminalOut {

-			state, err := term.SetRawTerminalOutput(cli.outFd)

-			if err != nil {

-				return err

-			}

-			cli.outState = state

-		}

-	}

-	return nil

-}

-

-func (cli *DockerCli) restoreTerminal(in io.Closer) error {

-	if cli.inState != nil {

-		term.RestoreTerminal(cli.inFd, cli.inState)

-	}

-	if cli.outState != nil {

-		term.RestoreTerminal(cli.outFd, cli.outState)

-	}

-	// WARNING: DO NOT REMOVE THE OS CHECK !!!

-	// For some reason this Close call blocks on darwin..

-	// As the client exists right after, simply discard the close

-	// until we find a better solution.

-	if in != nil && runtime.GOOS != "darwin" {

-		return in.Close()

-	}

-	return nil

-}

-

 // Initialize the dockerCli runs initialization that must happen after command

 // line flags are parsed.

 func (cli *DockerCli) Initialize(opts *cliflags.ClientOptions) error {

 	cli.configFile = LoadDefaultConfigFile(cli.err)

-	client, err := NewAPIClientFromFlags(opts.Common, cli.configFile)

+	var err error

+	cli.client, err = NewAPIClientFromFlags(opts.Common, cli.configFile)

 	if err != nil {

 		return err

 	}

-

-	cli.client = client

-

-	if cli.in != nil {

-		cli.inFd, cli.isTerminalIn = term.GetFdInfo(cli.in)

-	}

-	if cli.out != nil {

-		cli.outFd, cli.isTerminalOut = term.GetFdInfo(cli.out)

-	}

-

 	if opts.Common.TrustKey == "" {

 		cli.keyFile = filepath.Join(cliconfig.ConfigDir(), cliflags.DefaultTrustKeyFile)

 	} else {

@@ -177,11 +78,7 @@ func (cli *DockerCli) Initialize(opts *cliflags.ClientOptions) error {

 // NewDockerCli returns a DockerCli instance with IO output and error streams set by in, out and err.

 func NewDockerCli(in io.ReadCloser, out, err io.Writer) *DockerCli {

-	return &DockerCli{

-		in:  in,

-		out: out,

-		err: err,

-	}

+	return &DockerCli{in: NewInStream(in), out: NewOutStream(out), err: err}

 }

 // LoadDefaultConfigFile attempts to load the default config file and returns

@@ -46,8 +46,9 @@ func NewAttachCommand(dockerCli *client.DockerCli) *cobra.Command {

 func runAttach(dockerCli *client.DockerCli, opts *attachOptions) error {

 	ctx := context.Background()

+	client := dockerCli.Client()

-	c, err := dockerCli.Client().ContainerInspect(ctx, opts.container)

+	c, err := client.ContainerInspect(ctx, opts.container)

 	if err != nil {

 		return err

 	}

@@ -60,7 +61,7 @@ func runAttach(dockerCli *client.DockerCli, opts *attachOptions) error {

 		return fmt.Errorf("You cannot attach to a paused container, unpause it first")

 	}

-	if err := dockerCli.CheckTtyInput(!opts.noStdin, c.Config.Tty); err != nil {

+	if err := dockerCli.In().CheckTty(!opts.noStdin, c.Config.Tty); err != nil {

 		return err

 	}

@@ -82,11 +83,11 @@ func runAttach(dockerCli *client.DockerCli, opts *attachOptions) error {

 	}

 	if opts.proxy && !c.Config.Tty {

-		sigc := dockerCli.ForwardAllSignals(ctx, opts.container)

+		sigc := ForwardAllSignals(ctx, dockerCli, opts.container)

 		defer signal.StopCatch(sigc)

 	}

-	resp, errAttach := dockerCli.Client().ContainerAttach(ctx, opts.container, options)

+	resp, errAttach := client.ContainerAttach(ctx, opts.container, options)

 	if errAttach != nil && errAttach != httputil.ErrPersistEOF {

 		// ContainerAttach returns an ErrPersistEOF (connection closed)

 		// means server met an error and put it in Hijacked connection

@@ -95,21 +96,21 @@ func runAttach(dockerCli *client.DockerCli, opts *attachOptions) error {

 	}

 	defer resp.Close()

-	if c.Config.Tty && dockerCli.IsTerminalOut() {

-		height, width := dockerCli.GetTtySize()

+	if c.Config.Tty && dockerCli.Out().IsTerminal() {

+		height, width := dockerCli.Out().GetTtySize()

 		// To handle the case where a user repeatedly attaches/detaches without resizing their

 		// terminal, the only way to get the shell prompt to display for attaches 2+ is to artificially

 		// resize it, then go back to normal. Without this, every attach after the first will

 		// require the user to manually resize or hit enter.

-		dockerCli.ResizeTtyTo(ctx, opts.container, height+1, width+1, false)

+		resizeTtyTo(ctx, client, opts.container, height+1, width+1, false)

 		// After the above resizing occurs, the call to MonitorTtySize below will handle resetting back

 		// to the actual size.

-		if err := dockerCli.MonitorTtySize(ctx, opts.container, false); err != nil {

+		if err := MonitorTtySize(ctx, dockerCli, opts.container, false); err != nil {

 			logrus.Debugf("Error monitoring TTY size: %s", err)

 		}

 	}

-	if err := dockerCli.HoldHijackedConnection(ctx, c.Config.Tty, in, dockerCli.Out(), dockerCli.Err(), resp); err != nil {

+	if err := holdHijackedConnection(ctx, dockerCli, c.Config.Tty, in, dockerCli.Out(), dockerCli.Err(), resp); err != nil {

 		return err

 	}

@@ -103,8 +103,8 @@ func pullImage(ctx context.Context, dockerCli *client.DockerCli, image string, o

 	return jsonmessage.DisplayJSONMessagesStream(

 		responseBody,

 		out,

-		dockerCli.OutFd(),

-		dockerCli.IsTerminalOut(),

+		dockerCli.Out().FD(),

+		dockerCli.Out().IsTerminal(),

 		nil)

 }

@@ -10,6 +10,7 @@ import (

 	"github.com/docker/docker/api/client"

 	"github.com/docker/docker/api/types"

 	"github.com/docker/docker/cli"

+	apiclient "github.com/docker/docker/client"

 	"github.com/docker/docker/pkg/promise"

 	"github.com/spf13/cobra"

 )

@@ -66,8 +67,9 @@ func runExec(dockerCli *client.DockerCli, opts *execOptions, container string, e

 	execConfig.DetachKeys = dockerCli.ConfigFile().DetachKeys

 	ctx := context.Background()

+	client := dockerCli.Client()

-	response, err := dockerCli.Client().ContainerExecCreate(ctx, container, *execConfig)

+	response, err := client.ContainerExecCreate(ctx, container, *execConfig)

 	if err != nil {

 		return err

 	}

@@ -80,7 +82,7 @@ func runExec(dockerCli *client.DockerCli, opts *execOptions, container string, e

 	//Temp struct for execStart so that we don't need to transfer all the execConfig

 	if !execConfig.Detach {

-		if err := dockerCli.CheckTtyInput(execConfig.AttachStdin, execConfig.Tty); err != nil {

+		if err := dockerCli.In().CheckTty(execConfig.AttachStdin, execConfig.Tty); err != nil {

 			return err

 		}

 	} else {

@@ -89,7 +91,7 @@ func runExec(dockerCli *client.DockerCli, opts *execOptions, container string, e

 			Tty:    execConfig.Tty,

 		}

-		if err := dockerCli.Client().ContainerExecStart(ctx, execID, execStartCheck); err != nil {

+		if err := client.ContainerExecStart(ctx, execID, execStartCheck); err != nil {

 			return err

 		}

 		// For now don't print this - wait for when we support exec wait()

@@ -118,17 +120,17 @@ func runExec(dockerCli *client.DockerCli, opts *execOptions, container string, e

 		}

 	}

-	resp, err := dockerCli.Client().ContainerExecAttach(ctx, execID, *execConfig)

+	resp, err := client.ContainerExecAttach(ctx, execID, *execConfig)

 	if err != nil {

 		return err

 	}

 	defer resp.Close()

 	errCh = promise.Go(func() error {

-		return dockerCli.HoldHijackedConnection(ctx, execConfig.Tty, in, out, stderr, resp)

+		return holdHijackedConnection(ctx, dockerCli, execConfig.Tty, in, out, stderr, resp)

 	})

-	if execConfig.Tty && dockerCli.IsTerminalIn() {

-		if err := dockerCli.MonitorTtySize(ctx, execID, true); err != nil {

+	if execConfig.Tty && dockerCli.In().IsTerminal() {

+		if err := MonitorTtySize(ctx, dockerCli, execID, true); err != nil {

 			fmt.Fprintf(dockerCli.Err(), "Error monitoring TTY size: %s\n", err)

 		}

 	}

@@ -139,7 +141,7 @@ func runExec(dockerCli *client.DockerCli, opts *execOptions, container string, e

 	}

 	var status int

-	if _, status, err = dockerCli.GetExecExitCode(ctx, execID); err != nil {

+	if _, status, err = getExecExitCode(ctx, client, execID); err != nil {

 		return err

 	}

@@ -150,6 +152,21 @@ func runExec(dockerCli *client.DockerCli, opts *execOptions, container string, e

 	return nil

 }

+// getExecExitCode perform an inspect on the exec command. It returns

+// the running state and the exit code.

+func getExecExitCode(ctx context.Context, client apiclient.ContainerAPIClient, execID string) (bool, int, error) {

+	resp, err := client.ContainerExecInspect(ctx, execID)

+	if err != nil {

+		// If we can't connect, then the daemon probably died.

+		if err != apiclient.ErrConnectionFailed {

+			return false, -1, err

+		}

+		return false, -1, nil

+	}

+

+	return resp.Running, resp.ExitCode, nil

+}

+

 // parseExec parses the specified args for the specified command and generates

 // an ExecConfig from it.

 func parseExec(opts *execOptions, container string, execCmd []string) (*types.ExecConfig, error) {

@@ -38,7 +38,7 @@ func NewExportCommand(dockerCli *client.DockerCli) *cobra.Command {

 }

 func runExport(dockerCli *client.DockerCli, opts exportOptions) error {

-	if opts.output == "" && dockerCli.IsTerminalOut() {

+	if opts.output == "" && dockerCli.Out().IsTerminal() {

 		return errors.New("Cowardly refusing to save to a terminal. Use the -o flag or redirect.")

 	}

new file mode 100644

@@ -0,0 +1,121 @@

+package container

+

+import (

+	"io"

+	"runtime"

+	"sync"

+

+	"github.com/Sirupsen/logrus"

+	"github.com/docker/docker/api/client"

+	"github.com/docker/docker/api/types"

+	"github.com/docker/docker/pkg/stdcopy"

+	"golang.org/x/net/context"

+)

+

+type streams interface {

+	In() *client.InStream

+	Out() *client.OutStream

+}

+

+// holdHijackedConnection handles copying input to and output from streams to the

+// connection

+func holdHijackedConnection(ctx context.Context, streams streams, tty bool, inputStream io.ReadCloser, outputStream, errorStream io.Writer, resp types.HijackedResponse) error {

+	var (

+		err         error

+		restoreOnce sync.Once

+	)

+	if inputStream != nil && tty {

+		if err := setRawTerminal(streams); err != nil {

+			return err

+		}

+		defer func() {

+			restoreOnce.Do(func() {

+				restoreTerminal(streams, inputStream)

+			})

+		}()

+	}

+

+	receiveStdout := make(chan error, 1)

+	if outputStream != nil || errorStream != nil {

+		go func() {

+			// When TTY is ON, use regular copy

+			if tty && outputStream != nil {

+				_, err = io.Copy(outputStream, resp.Reader)

+				// we should restore the terminal as soon as possible once connection end

+				// so any following print messages will be in normal type.

+				if inputStream != nil {

+					restoreOnce.Do(func() {

+						restoreTerminal(streams, inputStream)

+					})

+				}

+			} else {

+				_, err = stdcopy.StdCopy(outputStream, errorStream, resp.Reader)

+			}

+

+			logrus.Debug("[hijack] End of stdout")

+			receiveStdout <- err

+		}()

+	}

+

+	stdinDone := make(chan struct{})

+	go func() {

+		if inputStream != nil {

+			io.Copy(resp.Conn, inputStream)

+			// we should restore the terminal as soon as possible once connection end

+			// so any following print messages will be in normal type.

+			if tty {

+				restoreOnce.Do(func() {

+					restoreTerminal(streams, inputStream)

+				})

+			}

+			logrus.Debug("[hijack] End of stdin")

+		}

+

+		if err := resp.CloseWrite(); err != nil {

+			logrus.Debugf("Couldn't send EOF: %s", err)

+		}

+		close(stdinDone)

+	}()

+

+	select {

+	case err := <-receiveStdout:

+		if err != nil {

+			logrus.Debugf("Error receiveStdout: %s", err)

+			return err

+		}

+	case <-stdinDone:

+		if outputStream != nil || errorStream != nil {

+			select {

+			case err := <-receiveStdout:

+				if err != nil {

+					logrus.Debugf("Error receiveStdout: %s", err)

+					return err

+				}

+			case <-ctx.Done():

+			}

+		}

+	case <-ctx.Done():

+	}

+

+	return nil

+}

+

+func setRawTerminal(streams streams) error {

+	if err := streams.In().SetRawTerminal(); err != nil {

+		return err

+	}

+	return streams.Out().SetRawTerminal()

+}

+

+func restoreTerminal(streams streams, in io.Closer) error {

+	streams.In().RestoreTerminal()

+	streams.Out().RestoreTerminal()

+	// WARNING: DO NOT REMOVE THE OS CHECK !!!

+	// For some reason this Close call blocks on darwin..

+	// As the client exists right after, simply discard the close

+	// until we find a better solution.

+	if in != nil && runtime.GOOS != "darwin" {

+		return in.Close()

+	}

+	return nil

+}

@@ -109,7 +109,7 @@ func runRun(dockerCli *client.DockerCli, flags *pflag.FlagSet, opts *runOptions,

 	config.ArgsEscaped = false

 	if !opts.detach {

-		if err := dockerCli.CheckTtyInput(config.AttachStdin, config.Tty); err != nil {

+		if err := dockerCli.In().CheckTty(config.AttachStdin, config.Tty); err != nil {

 			return err

 		}

 	} else {

@@ -135,7 +135,7 @@ func runRun(dockerCli *client.DockerCli, flags *pflag.FlagSet, opts *runOptions,

 	// a far better user experience rather than relying on subsequent resizes

 	// to cause things to catch up.

 	if runtime.GOOS == "windows" {

-		hostConfig.ConsoleSize[0], hostConfig.ConsoleSize[1] = dockerCli.GetTtySize()

+		hostConfig.ConsoleSize[0], hostConfig.ConsoleSize[1] = dockerCli.Out().GetTtySize()

 	}

 	ctx, cancelFun := context.WithCancel(context.Background())

@@ -146,7 +146,7 @@ func runRun(dockerCli *client.DockerCli, flags *pflag.FlagSet, opts *runOptions,

 		return runStartContainerErr(err)

 	}

 	if opts.sigProxy {

-		sigc := dockerCli.ForwardAllSignals(ctx, createResponse.ID)

+		sigc := ForwardAllSignals(ctx, dockerCli, createResponse.ID)

 		defer signal.StopCatch(sigc)

 	}

 	var (

@@ -203,7 +203,7 @@ func runRun(dockerCli *client.DockerCli, flags *pflag.FlagSet, opts *runOptions,

 		defer resp.Close()

 		errCh = promise.Go(func() error {

-			errHijack := dockerCli.HoldHijackedConnection(ctx, config.Tty, in, out, cerr, resp)

+			errHijack := holdHijackedConnection(ctx, dockerCli, config.Tty, in, out, cerr, resp)

 			if errHijack == nil {

 				return errAttach

 			}

@@ -234,8 +234,8 @@ func runRun(dockerCli *client.DockerCli, flags *pflag.FlagSet, opts *runOptions,

 		return runStartContainerErr(err)

 	}

-	if (config.AttachStdin || config.AttachStdout || config.AttachStderr) && config.Tty && dockerCli.IsTerminalOut() {

-		if err := dockerCli.MonitorTtySize(ctx, createResponse.ID, false); err != nil {

+	if (config.AttachStdin || config.AttachStdout || config.AttachStderr) && config.Tty && dockerCli.Out().IsTerminal() {

+		if err := MonitorTtySize(ctx, dockerCli, createResponse.ID, false); err != nil {

 			fmt.Fprintf(stderr, "Error monitoring TTY size: %s\n", err)

 		}

 	}

@@ -64,7 +64,7 @@ func runStart(dockerCli *client.DockerCli, opts *startOptions) error {

 		// We always use c.ID instead of container to maintain consistency during `docker start`

 		if !c.Config.Tty {

-			sigc := dockerCli.ForwardAllSignals(ctx, c.ID)

+			sigc := ForwardAllSignals(ctx, dockerCli, c.ID)

 			defer signal.StopCatch(sigc)

 		}

@@ -95,7 +95,7 @@ func runStart(dockerCli *client.DockerCli, opts *startOptions) error {

 		}

 		defer resp.Close()

 		cErr := promise.Go(func() error {

-			errHijack := dockerCli.HoldHijackedConnection(ctx, c.Config.Tty, in, dockerCli.Out(), dockerCli.Err(), resp)

+			errHijack := holdHijackedConnection(ctx, dockerCli, c.Config.Tty, in, dockerCli.Out(), dockerCli.Err(), resp)

 			if errHijack == nil {

 				return errAttach

 			}

@@ -118,8 +118,8 @@ func runStart(dockerCli *client.DockerCli, opts *startOptions) error {

 		}

 		// 5. Wait for attachment to break.

-		if c.Config.Tty && dockerCli.IsTerminalOut() {

-			if err := dockerCli.MonitorTtySize(ctx, c.ID, false); err != nil {

+		if c.Config.Tty && dockerCli.Out().IsTerminal() {

+			if err := MonitorTtySize(ctx, dockerCli, c.ID, false); err != nil {

 				fmt.Fprintf(dockerCli.Err(), "Error monitoring TTY size: %s\n", err)

 			}

 		}

new file mode 100644

@@ -0,0 +1,103 @@

+package container

+

+import (

+	"fmt"

+	"os"

+	gosignal "os/signal"

+	"runtime"

+	"time"

+

+	"github.com/Sirupsen/logrus"

+	"github.com/docker/docker/api/client"

+	"github.com/docker/docker/api/types"

+	apiclient "github.com/docker/docker/client"

+	"github.com/docker/docker/pkg/signal"

+	"golang.org/x/net/context"

+)

+

+// resizeTtyTo resizes tty to specific height and width

+func resizeTtyTo(ctx context.Context, client apiclient.ContainerAPIClient, id string, height, width int, isExec bool) {

+	if height == 0 && width == 0 {

+		return

+	}

+

+	options := types.ResizeOptions{

+		Height: height,

+		Width:  width,

+	}

+

+	var err error

+	if isExec {

+		err = client.ContainerExecResize(ctx, id, options)

+	} else {

+		err = client.ContainerResize(ctx, id, options)

+	}

+

+	if err != nil {

+		logrus.Debugf("Error resize: %s", err)

+	}

+}

+

+// MonitorTtySize updates the container tty size when the terminal tty changes size

+func MonitorTtySize(ctx context.Context, cli *client.DockerCli, id string, isExec bool) error {

+	resizeTty := func() {

+		height, width := cli.Out().GetTtySize()

+		resizeTtyTo(ctx, cli.Client(), id, height, width, isExec)

+	}

+

+	resizeTty()

+

+	if runtime.GOOS == "windows" {

+		go func() {

+			prevH, prevW := cli.Out().GetTtySize()

+			for {

+				time.Sleep(time.Millisecond * 250)

+				h, w := cli.Out().GetTtySize()

+

+				if prevW != w || prevH != h {

+					resizeTty()

+				}

+				prevH = h

+				prevW = w

+			}

+		}()

+	} else {

+		sigchan := make(chan os.Signal, 1)

+		gosignal.Notify(sigchan, signal.SIGWINCH)

+		go func() {

+			for range sigchan {

+				resizeTty()

+			}

+		}()

+	}

+	return nil

+}

+

+// ForwardAllSignals forwards signals to the container

+func ForwardAllSignals(ctx context.Context, cli *client.DockerCli, cid string) chan os.Signal {

+	sigc := make(chan os.Signal, 128)

+	signal.CatchAll(sigc)

+	go func() {

+		for s := range sigc {

+			if s == signal.SIGCHLD || s == signal.SIGPIPE {

+				continue

+			}

+			var sig string

+			for sigStr, sigN := range signal.SignalMap {

+				if sigN == s {

+					sig = sigStr

+					break

+				}

+			}

+			if sig == "" {

+				fmt.Fprintf(cli.Err(), "Unsupported signal: %v. Discarding.\n", s)

+				continue

+			}

+

+			if err := cli.Client().ContainerKill(ctx, cid, sig); err != nil {

+				logrus.Debugf("Error sending signal: %s", err)

+			}

+		}

+	}()

+	return sigc

+}

deleted file mode 100644

@@ -1,95 +0,0 @@

-package client

-

-import (

-	"io"

-	"sync"

-

-	"golang.org/x/net/context"

-

-	"github.com/Sirupsen/logrus"

-	"github.com/docker/docker/api/types"

-	"github.com/docker/docker/pkg/stdcopy"

-)

-

-// HoldHijackedConnection handles copying input to and output from streams to the

-// connection

-func (cli *DockerCli) HoldHijackedConnection(ctx context.Context, tty bool, inputStream io.ReadCloser, outputStream, errorStream io.Writer, resp types.HijackedResponse) error {

-	var (

-		err         error

-		restoreOnce sync.Once

-	)

-	if inputStream != nil && tty {

-		if err := cli.setRawTerminal(); err != nil {

-			return err

-		}

-		defer func() {

-			restoreOnce.Do(func() {

-				cli.restoreTerminal(inputStream)

-			})

-		}()

-	}

-

-	receiveStdout := make(chan error, 1)

-	if outputStream != nil || errorStream != nil {

-		go func() {

-			// When TTY is ON, use regular copy

-			if tty && outputStream != nil {

-				_, err = io.Copy(outputStream, resp.Reader)

-				// we should restore the terminal as soon as possible once connection end

-				// so any following print messages will be in normal type.

-				if inputStream != nil {

-					restoreOnce.Do(func() {

-						cli.restoreTerminal(inputStream)

-					})

-				}

-			} else {

-				_, err = stdcopy.StdCopy(outputStream, errorStream, resp.Reader)

-			}

-

-			logrus.Debug("[hijack] End of stdout")

-			receiveStdout <- err

-		}()

-	}

-

-	stdinDone := make(chan struct{})

-	go func() {

-		if inputStream != nil {

-			io.Copy(resp.Conn, inputStream)

-			// we should restore the terminal as soon as possible once connection end

-			// so any following print messages will be in normal type.

-			if tty {

-				restoreOnce.Do(func() {

-					cli.restoreTerminal(inputStream)

-				})

-			}

-			logrus.Debug("[hijack] End of stdin")

-		}

-

-		if err := resp.CloseWrite(); err != nil {

-			logrus.Debugf("Couldn't send EOF: %s", err)

-		}

-		close(stdinDone)

-	}()

-

-	select {

-	case err := <-receiveStdout:

-		if err != nil {

-			logrus.Debugf("Error receiveStdout: %s", err)

-			return err

-		}

-	case <-stdinDone:

-		if outputStream != nil || errorStream != nil {

-			select {

-			case err := <-receiveStdout:

-				if err != nil {

-					logrus.Debugf("Error receiveStdout: %s", err)

-					return err

-				}

-			case <-ctx.Done():

-			}

-		}

-	case <-ctx.Done():

-	}

-

-	return nil

-}

@@ -227,7 +227,7 @@ func runBuild(dockerCli *client.DockerCli, options buildOptions) error {

 	// Setup an upload progress bar

 	progressOutput := streamformatter.NewStreamFormatter().NewProgressOutput(progBuff, true)

-	if !dockerCli.IsTerminalOut() {

+	if !dockerCli.Out().IsTerminal() {

 		progressOutput = &lastProgressOutput{output: progressOutput}

 	}

@@ -293,7 +293,7 @@ func runBuild(dockerCli *client.DockerCli, options buildOptions) error {

 	}

 	defer response.Body.Close()

-	err = jsonmessage.DisplayJSONMessagesStream(response.Body, buildBuff, dockerCli.OutFd(), dockerCli.IsTerminalOut(), nil)

+	err = jsonmessage.DisplayJSONMessagesStream(response.Body, buildBuff, dockerCli.Out().FD(), dockerCli.Out().IsTerminal(), nil)

 	if err != nil {

 		if jerr, ok := err.(*jsonmessage.JSONError); ok {

 			// If no error code is set, default to 1

@@ -84,5 +84,5 @@ func runImport(dockerCli *client.DockerCli, opts importOptions) error {

 	}

 	defer responseBody.Close()

-	return jsonmessage.DisplayJSONMessagesStream(responseBody, dockerCli.Out(), dockerCli.OutFd(), dockerCli.IsTerminalOut(), nil)

+	return jsonmessage.DisplayJSONMessagesToStream(responseBody, dockerCli.Out(), nil)

 }

@@ -49,7 +49,7 @@ func runLoad(dockerCli *client.DockerCli, opts loadOptions) error {

 		defer file.Close()

 		input = file

 	}

-	if !dockerCli.IsTerminalOut() {

+	if !dockerCli.Out().IsTerminal() {

 		opts.quiet = true

 	}

 	response, err := dockerCli.Client().ImageLoad(context.Background(), input, opts.quiet)

@@ -59,7 +59,7 @@ func runLoad(dockerCli *client.DockerCli, opts loadOptions) error {

 	defer response.Body.Close()

 	if response.Body != nil && response.JSON {

-		return jsonmessage.DisplayJSONMessagesStream(response.Body, dockerCli.Out(), dockerCli.OutFd(), dockerCli.IsTerminalOut(), nil)

+		return jsonmessage.DisplayJSONMessagesToStream(response.Body, dockerCli.Out(), nil)

 	}

 	_, err = io.Copy(dockerCli.Out(), response.Body)

@@ -57,6 +57,5 @@ func runPush(dockerCli *client.DockerCli, remote string) error {

 	}

 	defer responseBody.Close()

-

-	return jsonmessage.DisplayJSONMessagesStream(responseBody, dockerCli.Out(), dockerCli.OutFd(), dockerCli.IsTerminalOut(), nil)

+	return jsonmessage.DisplayJSONMessagesToStream(responseBody, dockerCli.Out(), nil)

 }

@@ -38,7 +38,7 @@ func NewSaveCommand(dockerCli *client.DockerCli) *cobra.Command {

 }

 func runSave(dockerCli *client.DockerCli, opts saveOptions) error {

-	if opts.output == "" && dockerCli.IsTerminalOut() {

+	if opts.output == "" && dockerCli.Out().IsTerminal() {

 		return errors.New("Cowardly refusing to save to a terminal. Use the -o flag or redirect.")

 	}

new file mode 100644

@@ -0,0 +1,75 @@

+package client

+

+import (

+	"errors"

+	"io"

+	"os"

+	"runtime"

+

+	"github.com/docker/docker/pkg/term"

+)

+

+// InStream is an input stream used by the DockerCli to read user input

+type InStream struct {

+	in         io.ReadCloser

+	fd         uintptr

+	isTerminal bool

+	state      *term.State

+}

+

+func (i *InStream) Read(p []byte) (int, error) {

+	return i.in.Read(p)

+}

+

+// Close implements the Closer interface

+func (i *InStream) Close() error {

+	return i.in.Close()

+}

+

+// FD returns the file descriptor number for this stream

+func (i *InStream) FD() uintptr {

+	return i.fd

+}

+

+// IsTerminal returns true if this stream is connected to a terminal

+func (i *InStream) IsTerminal() bool {

+	return i.isTerminal

+}

+

+// SetRawTerminal sets raw mode on the input terminal

+func (i *InStream) SetRawTerminal() (err error) {

+	if os.Getenv("NORAW") != "" || !i.isTerminal {

+		return nil

+	}

+	i.state, err = term.SetRawTerminal(i.fd)

+	return err

+}

+

+// RestoreTerminal restores normal mode to the terminal

+func (i *InStream) RestoreTerminal() {

+	if i.state != nil {

+		term.RestoreTerminal(i.fd, i.state)

+	}

+}

+

+// CheckTty checks if we are trying to attach to a container tty

+// from a non-tty client input stream, and if so, returns an error.

+func (i *InStream) CheckTty(attachStdin, ttyMode bool) error {

+	// In order to attach to a container tty, input stream for the client must

+	// be a tty itself: redirecting or piping the client standard input is

+	// incompatible with `docker run -t`, `docker exec -t` or `docker attach`.