mirror of
https://github.com/genuinetools/reg.git
synced 2024-08-21 14:20:23 -04:00
188 lines
4.5 KiB
Go
188 lines
4.5 KiB
Go
package daemon // import "github.com/docker/docker/daemon"
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"io"
|
|
|
|
"github.com/docker/docker/api/types/backend"
|
|
"github.com/docker/docker/container"
|
|
"github.com/docker/docker/container/stream"
|
|
"github.com/docker/docker/daemon/logger"
|
|
"github.com/docker/docker/errdefs"
|
|
"github.com/docker/docker/pkg/stdcopy"
|
|
"github.com/docker/docker/pkg/term"
|
|
"github.com/pkg/errors"
|
|
"github.com/sirupsen/logrus"
|
|
)
|
|
|
|
// ContainerAttach attaches to logs according to the config passed in. See ContainerAttachConfig.
|
|
func (daemon *Daemon) ContainerAttach(prefixOrName string, c *backend.ContainerAttachConfig) error {
|
|
keys := []byte{}
|
|
var err error
|
|
if c.DetachKeys != "" {
|
|
keys, err = term.ToBytes(c.DetachKeys)
|
|
if err != nil {
|
|
return errdefs.InvalidParameter(errors.Errorf("Invalid detach keys (%s) provided", c.DetachKeys))
|
|
}
|
|
}
|
|
|
|
container, err := daemon.GetContainer(prefixOrName)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if container.IsPaused() {
|
|
err := fmt.Errorf("container %s is paused, unpause the container before attach", prefixOrName)
|
|
return errdefs.Conflict(err)
|
|
}
|
|
if container.IsRestarting() {
|
|
err := fmt.Errorf("container %s is restarting, wait until the container is running", prefixOrName)
|
|
return errdefs.Conflict(err)
|
|
}
|
|
|
|
cfg := stream.AttachConfig{
|
|
UseStdin: c.UseStdin,
|
|
UseStdout: c.UseStdout,
|
|
UseStderr: c.UseStderr,
|
|
TTY: container.Config.Tty,
|
|
CloseStdin: container.Config.StdinOnce,
|
|
DetachKeys: keys,
|
|
}
|
|
container.StreamConfig.AttachStreams(&cfg)
|
|
|
|
inStream, outStream, errStream, err := c.GetStreams()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer inStream.Close()
|
|
|
|
if !container.Config.Tty && c.MuxStreams {
|
|
errStream = stdcopy.NewStdWriter(errStream, stdcopy.Stderr)
|
|
outStream = stdcopy.NewStdWriter(outStream, stdcopy.Stdout)
|
|
}
|
|
|
|
if cfg.UseStdin {
|
|
cfg.Stdin = inStream
|
|
}
|
|
if cfg.UseStdout {
|
|
cfg.Stdout = outStream
|
|
}
|
|
if cfg.UseStderr {
|
|
cfg.Stderr = errStream
|
|
}
|
|
|
|
if err := daemon.containerAttach(container, &cfg, c.Logs, c.Stream); err != nil {
|
|
fmt.Fprintf(outStream, "Error attaching: %s\n", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// ContainerAttachRaw attaches the provided streams to the container's stdio
|
|
func (daemon *Daemon) ContainerAttachRaw(prefixOrName string, stdin io.ReadCloser, stdout, stderr io.Writer, doStream bool, attached chan struct{}) error {
|
|
container, err := daemon.GetContainer(prefixOrName)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
cfg := stream.AttachConfig{
|
|
UseStdin: stdin != nil,
|
|
UseStdout: stdout != nil,
|
|
UseStderr: stderr != nil,
|
|
TTY: container.Config.Tty,
|
|
CloseStdin: container.Config.StdinOnce,
|
|
}
|
|
container.StreamConfig.AttachStreams(&cfg)
|
|
close(attached)
|
|
if cfg.UseStdin {
|
|
cfg.Stdin = stdin
|
|
}
|
|
if cfg.UseStdout {
|
|
cfg.Stdout = stdout
|
|
}
|
|
if cfg.UseStderr {
|
|
cfg.Stderr = stderr
|
|
}
|
|
|
|
return daemon.containerAttach(container, &cfg, false, doStream)
|
|
}
|
|
|
|
func (daemon *Daemon) containerAttach(c *container.Container, cfg *stream.AttachConfig, logs, doStream bool) error {
|
|
if logs {
|
|
logDriver, logCreated, err := daemon.getLogger(c)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if logCreated {
|
|
defer func() {
|
|
if err = logDriver.Close(); err != nil {
|
|
logrus.Errorf("Error closing logger: %v", err)
|
|
}
|
|
}()
|
|
}
|
|
cLog, ok := logDriver.(logger.LogReader)
|
|
if !ok {
|
|
return logger.ErrReadLogsNotSupported{}
|
|
}
|
|
logs := cLog.ReadLogs(logger.ReadConfig{Tail: -1})
|
|
defer logs.Close()
|
|
|
|
LogLoop:
|
|
for {
|
|
select {
|
|
case msg, ok := <-logs.Msg:
|
|
if !ok {
|
|
break LogLoop
|
|
}
|
|
if msg.Source == "stdout" && cfg.Stdout != nil {
|
|
cfg.Stdout.Write(msg.Line)
|
|
}
|
|
if msg.Source == "stderr" && cfg.Stderr != nil {
|
|
cfg.Stderr.Write(msg.Line)
|
|
}
|
|
case err := <-logs.Err:
|
|
logrus.Errorf("Error streaming logs: %v", err)
|
|
break LogLoop
|
|
}
|
|
}
|
|
}
|
|
|
|
daemon.LogContainerEvent(c, "attach")
|
|
|
|
if !doStream {
|
|
return nil
|
|
}
|
|
|
|
if cfg.Stdin != nil {
|
|
r, w := io.Pipe()
|
|
go func(stdin io.ReadCloser) {
|
|
defer w.Close()
|
|
defer logrus.Debug("Closing buffered stdin pipe")
|
|
io.Copy(w, stdin)
|
|
}(cfg.Stdin)
|
|
cfg.Stdin = r
|
|
}
|
|
|
|
if !c.Config.OpenStdin {
|
|
cfg.Stdin = nil
|
|
}
|
|
|
|
if c.Config.StdinOnce && !c.Config.Tty {
|
|
// Wait for the container to stop before returning.
|
|
waitChan := c.Wait(context.Background(), container.WaitConditionNotRunning)
|
|
defer func() {
|
|
<-waitChan // Ignore returned exit code.
|
|
}()
|
|
}
|
|
|
|
ctx := c.InitAttachContext()
|
|
err := <-c.StreamConfig.CopyStreams(ctx, cfg)
|
|
if err != nil {
|
|
if _, ok := err.(term.EscapeError); ok {
|
|
daemon.LogContainerEvent(c, "detach")
|
|
} else {
|
|
logrus.Errorf("attach failed with error: %v", err)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|