utils.go 4.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156
  1. package client
  2. import (
  3. "encoding/base64"
  4. "encoding/json"
  5. "fmt"
  6. "os"
  7. gosignal "os/signal"
  8. "runtime"
  9. "time"
  10. "github.com/Sirupsen/logrus"
  11. "github.com/docker/docker/pkg/signal"
  12. "github.com/docker/docker/pkg/term"
  13. "github.com/docker/docker/registry"
  14. "github.com/docker/engine-api/client"
  15. "github.com/docker/engine-api/types"
  16. registrytypes "github.com/docker/engine-api/types/registry"
  17. )
  18. func (cli *DockerCli) electAuthServer() string {
  19. // The daemon `/info` endpoint informs us of the default registry being
  20. // used. This is essential in cross-platforms environment, where for
  21. // example a Linux client might be interacting with a Windows daemon, hence
  22. // the default registry URL might be Windows specific.
  23. serverAddress := registry.IndexServer
  24. if info, err := cli.client.Info(); err != nil {
  25. fmt.Fprintf(cli.out, "Warning: failed to get default registry endpoint from daemon (%v). Using system default: %s\n", err, serverAddress)
  26. } else {
  27. serverAddress = info.IndexServerAddress
  28. }
  29. return serverAddress
  30. }
  31. // encodeAuthToBase64 serializes the auth configuration as JSON base64 payload
  32. func encodeAuthToBase64(authConfig types.AuthConfig) (string, error) {
  33. buf, err := json.Marshal(authConfig)
  34. if err != nil {
  35. return "", err
  36. }
  37. return base64.URLEncoding.EncodeToString(buf), nil
  38. }
  39. func (cli *DockerCli) encodeRegistryAuth(index *registrytypes.IndexInfo) (string, error) {
  40. authConfig := registry.ResolveAuthConfig(cli.configFile.AuthConfigs, index)
  41. return encodeAuthToBase64(authConfig)
  42. }
  43. func (cli *DockerCli) registryAuthenticationPrivilegedFunc(index *registrytypes.IndexInfo, cmdName string) client.RequestPrivilegeFunc {
  44. return func() (string, error) {
  45. fmt.Fprintf(cli.out, "\nPlease login prior to %s:\n", cmdName)
  46. indexServer := registry.GetAuthConfigKey(index)
  47. authConfig, err := cli.configureAuth("", "", "", indexServer)
  48. if err != nil {
  49. return "", err
  50. }
  51. return encodeAuthToBase64(authConfig)
  52. }
  53. }
  54. func (cli *DockerCli) resizeTty(id string, isExec bool) {
  55. height, width := cli.getTtySize()
  56. if height == 0 && width == 0 {
  57. return
  58. }
  59. options := types.ResizeOptions{
  60. ID: id,
  61. Height: height,
  62. Width: width,
  63. }
  64. var err error
  65. if isExec {
  66. err = cli.client.ContainerExecResize(options)
  67. } else {
  68. err = cli.client.ContainerResize(options)
  69. }
  70. if err != nil {
  71. logrus.Debugf("Error resize: %s", err)
  72. }
  73. }
  74. // getExitCode perform an inspect on the container. It returns
  75. // the running state and the exit code.
  76. func getExitCode(cli *DockerCli, containerID string) (bool, int, error) {
  77. c, err := cli.client.ContainerInspect(containerID)
  78. if err != nil {
  79. // If we can't connect, then the daemon probably died.
  80. if err != client.ErrConnectionFailed {
  81. return false, -1, err
  82. }
  83. return false, -1, nil
  84. }
  85. return c.State.Running, c.State.ExitCode, nil
  86. }
  87. // getExecExitCode perform an inspect on the exec command. It returns
  88. // the running state and the exit code.
  89. func getExecExitCode(cli *DockerCli, execID string) (bool, int, error) {
  90. resp, err := cli.client.ContainerExecInspect(execID)
  91. if err != nil {
  92. // If we can't connect, then the daemon probably died.
  93. if err != client.ErrConnectionFailed {
  94. return false, -1, err
  95. }
  96. return false, -1, nil
  97. }
  98. return resp.Running, resp.ExitCode, nil
  99. }
  100. func (cli *DockerCli) monitorTtySize(id string, isExec bool) error {
  101. cli.resizeTty(id, isExec)
  102. if runtime.GOOS == "windows" {
  103. go func() {
  104. prevH, prevW := cli.getTtySize()
  105. for {
  106. time.Sleep(time.Millisecond * 250)
  107. h, w := cli.getTtySize()
  108. if prevW != w || prevH != h {
  109. cli.resizeTty(id, isExec)
  110. }
  111. prevH = h
  112. prevW = w
  113. }
  114. }()
  115. } else {
  116. sigchan := make(chan os.Signal, 1)
  117. gosignal.Notify(sigchan, signal.SIGWINCH)
  118. go func() {
  119. for range sigchan {
  120. cli.resizeTty(id, isExec)
  121. }
  122. }()
  123. }
  124. return nil
  125. }
  126. func (cli *DockerCli) getTtySize() (int, int) {
  127. if !cli.isTerminalOut {
  128. return 0, 0
  129. }
  130. ws, err := term.GetWinsize(cli.outFd)
  131. if err != nil {
  132. logrus.Debugf("Error getting size: %s", err)
  133. if ws == nil {
  134. return 0, 0
  135. }
  136. }
  137. return int(ws.Height), int(ws.Width)
  138. }