docker execコマンドの実行時に起きていること

> Usage:	docker exec [OPTIONS] CONTAINER COMMAND [ARG...]

## 記事を書く背景
私は普段職場でLinuxでWebアプリケーションの開発をしていて､実行環境に**Docker**のコンテナを使っていました｡
元々使っていたネットワークマネージャの**network-manager**が再接続をしてくれないという問題があったので**wicd**に変えたところ､コンテナに設定されていたDNSサーバが応答しなくなり､コンテナを再度作成しました｡

(後で調べたところ､**wicd**のインストール時の自動検知によって有線LANのインターフェースが`docker0`に設定されていたため､外部に送出したパケットがコンテナにそのまま戻っているという状態でした｡)

![alt](http://i.imgur.com/Rdp2fTV.png)

そのコンテナ内の`bash`を開く際､`docker exec`コマンドのオプションに`-i`を付けるのを忘れていたため､コマンドラインからの入力を受け付けませんでした｡

## 私が試したこと
そこで私が思いついたのは､正常なコンテナの作成に失敗しているか､コンテナ内の`bash`を開く時のコマンドが間違っているという可能性でした｡私は以下の2つを試しましたが､**1**の結果`docker run`は正常に動作していることが分かったので､結局は`docker exec`コマンドの挙動から答えにたどり着きました｡

1. 正常に動作している他のコンテナと同じイメージを使ってコンテナを作成し､コマンドラインからの入力を試す
2. `docker run`と`docker exec`コマンドの挙動について調べる

## **`docker exec`**コマンドの挙動
``` go:docker/docker/cli/command/container/exec.go
type execOptions struct {
	detachKeys  string
	interactive bool
	tty         bool
	detach      bool
	user        string
	privileged  bool
	env         *options.ListOpts
}

func newExecOptions() *execOptions {
	var values []string
	return &execOptions{
		env: options.NewListOptsRef(&values, runconfigopts.ValidateEnv),
	}
}

func NewExecCommand(dockerCli *command.DockerCli) *cobra.Command {
	opts := newExecOptions()

	cmd := &cobra.Command{
		Use:   "exec [OPTIONS] CONTAINER COMMAND [ARG...]",
		Short: "Run a command in a running container",
		Args:  cli.RequiresMinArgs(2),
		RunE: func(cmd *cobra.Command, args []string) error {
			container := args[0]
			execCmd := args[1:]
			return runExec(dockerCli, opts, container, execCmd)
		},
	}

	flags := cmd.Flags()
	flags.SetInterspersed(false)

	flags.StringVarP(&opts.detachKeys, "detach-keys", "", "", "Override the key sequence for detaching a container")
	flags.BoolVarP(&opts.interactive, "interactive", "i", false, "Keep STDIN open even if not attached")
	flags.BoolVarP(&opts.tty, "tty", "t", false, "Allocate a pseudo-TTY")
	flags.BoolVarP(&opts.detach, "detach", "d", false, "Detached mode: run command in the background")
	flags.StringVarP(&opts.user, "user", "u", "", "Username or UID (format: <name|uid>[:<group|gid>])")
	flags.BoolVarP(&opts.privileged, "privileged", "", false, "Give extended privileges to the command")
	flags.VarP(opts.env, "env", "e", "Set environment variables")
	flags.SetAnnotation("env", "version", []string{"1.25"})

	return cmd
}

func runExec(dockerCli *command.DockerCli, opts *execOptions, container string, execCmd []string) error {
	execConfig, err := parseExec(opts, execCmd)
	// just in case the ParseExec does not exit
	if container == "" || err != nil {
		return cli.StatusError{StatusCode: 1}
	}

	if opts.detachKeys != "" {
		dockerCli.ConfigFile().DetachKeys = opts.detachKeys
	}

	// Send client escape keys
	execConfig.DetachKeys = dockerCli.ConfigFile().DetachKeys

	ctx := context.Background()
	client := dockerCli.Client()

	response, err := client.ContainerExecCreate(ctx, container, *execConfig)
	if err != nil {
		return err
	}

	execID := response.ID
	if execID == "" {
		fmt.Fprintf(dockerCli.Out(), "exec ID empty")
		return nil
	}

	//Temp struct for execStart so that we don't need to transfer all the execConfig
	if !execConfig.Detach {
		if err := dockerCli.In().CheckTty(execConfig.AttachStdin, execConfig.Tty); err != nil {
			return err
		}
	} else {
		execStartCheck := types.ExecStartCheck{
			Detach: execConfig.Detach,
			Tty:    execConfig.Tty,
		}

		if err := client.ContainerExecStart(ctx, execID, execStartCheck); err != nil {
			return err
		}
		// For now don't print this - wait for when we support exec wait()
		// fmt.Fprintf(dockerCli.Out(), "%s\n", execID)
		return nil
	}

	// Interactive exec requested.
	var (
		out, stderr io.Writer
		in          io.ReadCloser
		errCh       chan error
	)

	if execConfig.AttachStdin {
		in = dockerCli.In()
	}
	if execConfig.AttachStdout {
		out = dockerCli.Out()
	}
	if execConfig.AttachStderr {
		if execConfig.Tty {
			stderr = dockerCli.Out()
		} else {
			stderr = dockerCli.Err()
		}
	}

	resp, err := client.ContainerExecAttach(ctx, execID, *execConfig)
	if err != nil {
		return err
	}
	defer resp.Close()
	errCh = promise.Go(func() error {
		return holdHijackedConnection(ctx, dockerCli, execConfig.Tty, in, out, stderr, resp)
	})

	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)
		}
	}

	if err := <-errCh; err != nil {
		logrus.Debugf("Error hijack: %s", err)
		return err
	}

	var status int
	if _, status, err = getExecExitCode(ctx, client, execID); err != nil {
		return err
	}

	if status != 0 {
		return cli.StatusError{StatusCode: status}
	}

	return nil
}

func parseExec(opts *execOptions, execCmd []string) (*types.ExecConfig, error) {
	execConfig := &types.ExecConfig{
		User:       opts.user,
		Privileged: opts.privileged,
		Tty:        opts.tty,
		Cmd:        execCmd,
		Detach:     opts.detach,
	}

	// If -d is not set, attach to everything by default
	if !opts.detach {
		execConfig.AttachStdout = true
		execConfig.AttachStderr = true
		if opts.interactive {
			execConfig.AttachStdin = true
		}
	}

	if opts.env != nil {
		execConfig.Env = opts.env.GetAll()
	}

	return execConfig, nil
}
```
```go:docker/docker/opts/opts.go
func NewListOptsRef(values *[]string, validator ValidatorFctType) *ListOpts {
	return &ListOpts{
		values:    values,
		validator: validator,
	}
}
```
`docker/docker/client/container_exec.go`はこちらを参照 [docker/docker](https://github.com/docker/docker/blob/master/client/container_exec.go)
`spf13/cobra/command.go`はこちらを参照 [spf13/cobra](https://github.com/spf13/cobra/blob/master/command.go)

### **各関数の挙動**
`func newExecOptions()`: `opts.go`内の`func NewListOptsRef()`の返り値を返します

`func NewExecCommand()`:
    1. `func newExecOptions()`をコールし､オプションリストを取得します
    2. `spf13/cobra`の`command.go`内の`Command`構造体を取得します
    3. `spf13/pflag`の`flag.go`内でオプションに関して定義を行います
    4. `cobra.Command`構造体を返します

`func runExec()`:
    1. コマンド情報をパースして取得します
    2. デタッチキーの指定があれば上書きします
    3. 環境変数を取得します
    4. `dockerCli.Client()`からexecIDを取得します
    5. デタッチキーとttyを渡して`client.ContainerExecStart()`をコールします ([**ttyとは** - teratail](https://teratail.com/questions/1947))
    6. `dockerCli`から`stdin` `stdout` `stderr`を取得します
    7. `client.ContainerExecAttach()`をコールします

`func parseExec()`: コマンド情報をパースして返します

## 原因
```go:docker/docker/cli/command/container/exec.go
if opts.interactive {
	execConfig.AttachStdin = true
}
```
オプションに`-i`が無い場合はコマンドラインから入力できないという仕様にここで気づきました｡

## 参考
[**docker/docker** - Github](https://github.com/docker/docker/)
[**spf13/cobra** - Github](https://github.com/spf13/cobra/blob/master/command.go)
[**spf13/pflag** - Github](https://github.com/spf13/pflag)
[**ttyとは** - teratail](https://teratail.com/questions/1947)