daemon/info_unix.go

   1 // +build !windows
   2
   3 package daemon
   4
   5 import (
   6         "context"
   7         "os/exec"
   8         "strings"
   9
  10         "github.com/Sirupsen/logrus"
  11         "github.com/docker/docker/api/types"
  12         "github.com/docker/docker/dockerversion"
  13         "github.com/docker/docker/pkg/sysinfo"
  14         "github.com/pkg/errors"
  15 )
  16
  17 // FillPlatformInfo fills the platform related info.
  18 func (daemon *Daemon) FillPlatformInfo(v *types.Info, sysInfo *sysinfo.SysInfo) {
  19         v.MemoryLimit = sysInfo.MemoryLimit
  20         v.SwapLimit = sysInfo.SwapLimit
  21         v.KernelMemory = sysInfo.KernelMemory
  22         v.OomKillDisable = sysInfo.OomKillDisable
  23         v.CPUCfsPeriod = sysInfo.CPUCfsPeriod
  24         v.CPUCfsQuota = sysInfo.CPUCfsQuota
  25         v.CPUShares = sysInfo.CPUShares
  26         v.CPUSet = sysInfo.Cpuset
  27         v.Runtimes = daemon.configStore.GetAllRuntimes()
  28         v.DefaultRuntime = daemon.configStore.GetDefaultRuntimeName()
  29         v.InitBinary = daemon.configStore.GetInitPath()
  30
  31         v.ContainerdCommit.Expected = dockerversion.ContainerdCommitID
  32         if sv, err := daemon.containerd.GetServerVersion(context.Background()); err == nil {
  33                 v.ContainerdCommit.ID = sv.Revision
  34         } else {
  35                 logrus.Warnf("failed to retrieve containerd version: %v", err)
  36                 v.ContainerdCommit.ID = "N/A"
  37         }
  38
  39         v.RuncCommit.Expected = dockerversion.RuncCommitID
  40         defaultRuntimeBinary := daemon.configStore.GetRuntime(daemon.configStore.GetDefaultRuntimeName()).Path
  41         if rv, err := exec.Command(defaultRuntimeBinary, "--version").Output(); err == nil {
  42                 parts := strings.Split(strings.TrimSpace(string(rv)), "\n")
  43                 if len(parts) == 3 {
  44                         parts = strings.Split(parts[1], ": ")
  45                         if len(parts) == 2 {
  46                                 v.RuncCommit.ID = strings.TrimSpace(parts[1])
  47                         }
  48                 }
  49
  50                 if v.RuncCommit.ID == "" {
  51                         logrus.Warnf("failed to retrieve %s version: unknown output format: %s", defaultRuntimeBinary, string(rv))
  52                         v.RuncCommit.ID = "N/A"
  53                 }
  54         } else {
  55                 logrus.Warnf("failed to retrieve %s version: %v", defaultRuntimeBinary, err)
  56                 v.RuncCommit.ID = "N/A"
  57         }
  58
  59         defaultInitBinary := daemon.configStore.GetInitPath()
  60         if rv, err := exec.Command(defaultInitBinary, "--version").Output(); err == nil {
  61                 ver, err := parseInitVersion(string(rv))
  62
  63                 if err != nil {
  64                         logrus.Warnf("failed to retrieve %s version: %s", defaultInitBinary, err)
  65                 }
  66                 v.InitCommit = ver
  67         } else {
  68                 //logrus.Warnf("failed to retrieve %s version: %s", defaultInitBinary, err)
  69                 v.InitCommit.ID = "N/A"
  70         }
  71 }
  72
  73 // parseInitVersion parses a Tini version string, and extracts the version.
  74 func parseInitVersion(v string) (types.Commit, error) {
  75         version := types.Commit{ID: "", Expected: dockerversion.InitCommitID}
  76         parts := strings.Split(strings.TrimSpace(v), " - ")
  77
  78         if len(parts) >= 2 {
  79                 gitParts := strings.Split(parts[1], ".")
  80                 if len(gitParts) == 2 && gitParts[0] == "git" {
  81                         version.ID = gitParts[1]
  82                         version.Expected = dockerversion.InitCommitID[0:len(version.ID)]
  83                 }
  84         }
  85         if version.ID == "" && strings.HasPrefix(parts[0], "tini version ") {
  86                 version.ID = "v" + strings.TrimPrefix(parts[0], "tini version ")
  87         }
  88         if version.ID == "" {
  89                 version.ID = "N/A"
  90                 return version, errors.Errorf("unknown output format: %s", v)
  91         }
  92         return version, nil
  93 }