| package daemon |
| |
| import ( |
| "fmt" |
| "io" |
| "net/http" |
| "time" |
| |
| "github.com/Sirupsen/logrus" |
| "github.com/docker/docker/container" |
| "github.com/docker/docker/daemon/logger" |
| derr "github.com/docker/docker/errors" |
| "github.com/docker/docker/pkg/stdcopy" |
| ) |
| |
| // ContainerAttachWithLogsConfig holds the streams to use when connecting to a container to view logs. |
| type ContainerAttachWithLogsConfig struct { |
| Hijacker http.Hijacker |
| Upgrade bool |
| UseStdin bool |
| UseStdout bool |
| UseStderr bool |
| Logs bool |
| Stream bool |
| DetachKeys []byte |
| } |
| |
| // ContainerAttachWithLogs attaches to logs according to the config passed in. See ContainerAttachWithLogsConfig. |
| func (daemon *Daemon) ContainerAttachWithLogs(prefixOrName string, c *ContainerAttachWithLogsConfig) error { |
| if c.Hijacker == nil { |
| return derr.ErrorCodeNoHijackConnection.WithArgs(prefixOrName) |
| } |
| container, err := daemon.GetContainer(prefixOrName) |
| if err != nil { |
| return derr.ErrorCodeNoSuchContainer.WithArgs(prefixOrName) |
| } |
| if container.IsPaused() { |
| return derr.ErrorCodePausedContainer.WithArgs(prefixOrName) |
| } |
| |
| conn, _, err := c.Hijacker.Hijack() |
| if err != nil { |
| return err |
| } |
| defer conn.Close() |
| // Flush the options to make sure the client sets the raw mode |
| conn.Write([]byte{}) |
| inStream := conn.(io.ReadCloser) |
| outStream := conn.(io.Writer) |
| |
| if c.Upgrade { |
| fmt.Fprintf(outStream, "HTTP/1.1 101 UPGRADED\r\nContent-Type: application/vnd.docker.raw-stream\r\nConnection: Upgrade\r\nUpgrade: tcp\r\n\r\n") |
| } else { |
| fmt.Fprintf(outStream, "HTTP/1.1 200 OK\r\nContent-Type: application/vnd.docker.raw-stream\r\n\r\n") |
| } |
| |
| var errStream io.Writer |
| |
| if !container.Config.Tty { |
| errStream = stdcopy.NewStdWriter(outStream, stdcopy.Stderr) |
| outStream = stdcopy.NewStdWriter(outStream, stdcopy.Stdout) |
| } else { |
| errStream = outStream |
| } |
| |
| var stdin io.ReadCloser |
| var stdout, stderr io.Writer |
| |
| if c.UseStdin { |
| stdin = inStream |
| } |
| if c.UseStdout { |
| stdout = outStream |
| } |
| if c.UseStderr { |
| stderr = errStream |
| } |
| |
| if err := daemon.attachWithLogs(container, stdin, stdout, stderr, c.Logs, c.Stream, c.DetachKeys); err != nil { |
| fmt.Fprintf(outStream, "Error attaching: %s\n", err) |
| } |
| return nil |
| } |
| |
| // ContainerWsAttachWithLogsConfig attach with websockets, since all |
| // stream data is delegated to the websocket to handle there. |
| type ContainerWsAttachWithLogsConfig struct { |
| InStream io.ReadCloser |
| OutStream, ErrStream io.Writer |
| Logs, Stream bool |
| DetachKeys []byte |
| } |
| |
| // ContainerWsAttachWithLogs websocket connection |
| func (daemon *Daemon) ContainerWsAttachWithLogs(prefixOrName string, c *ContainerWsAttachWithLogsConfig) error { |
| container, err := daemon.GetContainer(prefixOrName) |
| if err != nil { |
| return err |
| } |
| return daemon.attachWithLogs(container, c.InStream, c.OutStream, c.ErrStream, c.Logs, c.Stream, c.DetachKeys) |
| } |
| |
| func (daemon *Daemon) attachWithLogs(container *container.Container, stdin io.ReadCloser, stdout, stderr io.Writer, logs, stream bool, keys []byte) error { |
| if logs { |
| logDriver, err := daemon.getLogger(container) |
| if err != nil { |
| return err |
| } |
| cLog, ok := logDriver.(logger.LogReader) |
| if !ok { |
| return logger.ErrReadLogsNotSupported |
| } |
| logs := cLog.ReadLogs(logger.ReadConfig{Tail: -1}) |
| |
| LogLoop: |
| for { |
| select { |
| case msg, ok := <-logs.Msg: |
| if !ok { |
| break LogLoop |
| } |
| if msg.Source == "stdout" && stdout != nil { |
| stdout.Write(msg.Line) |
| } |
| if msg.Source == "stderr" && stderr != nil { |
| stderr.Write(msg.Line) |
| } |
| case err := <-logs.Err: |
| logrus.Errorf("Error streaming logs: %v", err) |
| break LogLoop |
| } |
| } |
| } |
| |
| daemon.LogContainerEvent(container, "attach") |
| |
| //stream |
| if stream { |
| var stdinPipe io.ReadCloser |
| if stdin != nil { |
| r, w := io.Pipe() |
| go func() { |
| defer w.Close() |
| defer logrus.Debugf("Closing buffered stdin pipe") |
| io.Copy(w, stdin) |
| }() |
| stdinPipe = r |
| } |
| <-container.Attach(stdinPipe, stdout, stderr, keys) |
| // If we are in stdinonce mode, wait for the process to end |
| // otherwise, simply return |
| if container.Config.StdinOnce && !container.Config.Tty { |
| container.WaitStop(-1 * time.Second) |
| } |
| } |
| return nil |
| } |