1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
//go:build !windows
package main
import (
"context"
"net"
"os"
"os/signal"
"path/filepath"
"strconv"
"time"
"github.com/docker/docker/daemon"
"github.com/docker/docker/daemon/config"
"github.com/docker/docker/libnetwork/portallocator"
"github.com/docker/docker/pkg/homedir"
"github.com/pkg/errors"
"golang.org/x/sys/unix"
)
func getDefaultDaemonConfigDir() string {
if !honorXDG {
return "/etc/docker"
}
// NOTE: CLI uses ~/.docker while the daemon uses ~/.config/docker, because
// ~/.docker was not designed to store daemon configurations.
// In future, the daemon directory may be renamed to ~/.config/moby-engine (?).
configHome, err := homedir.GetConfigHome()
if err != nil {
return ""
}
return filepath.Join(configHome, "docker")
}
func getDefaultDaemonConfigFile() string {
dir := getDefaultDaemonConfigDir()
if dir == "" {
return ""
}
return filepath.Join(dir, "daemon.json")
}
// setDefaultUmask sets the umask to 0022 to avoid problems
// caused by custom umask
func setDefaultUmask() error {
desiredUmask := 0o022
unix.Umask(desiredUmask)
if umask := unix.Umask(desiredUmask); umask != desiredUmask {
return errors.Errorf("failed to set umask: expected %#o, got %#o", desiredUmask, umask)
}
return nil
}
// setupConfigReloadTrap configures the SIGHUP signal to reload the configuration.
func (cli *daemonCLI) setupConfigReloadTrap() {
c := make(chan os.Signal, 1)
signal.Notify(c, unix.SIGHUP)
go func() {
for range c {
cli.reloadConfig()
}
}()
}
// getSwarmRunRoot gets the root directory for swarm to store runtime state
// For example, the control socket
func getSwarmRunRoot(cfg *config.Config) string {
return filepath.Join(cfg.ExecRoot, "swarm")
}
// allocateDaemonPort ensures that there are no containers
// that try to use any port allocated for the docker server.
func allocateDaemonPort(addr string) error {
host, port, err := net.SplitHostPort(addr)
if err != nil {
return errors.Wrap(err, "error parsing tcp address")
}
intPort, err := strconv.Atoi(port)
if err != nil {
return errors.Wrap(err, "error parsing tcp address")
}
var hostIPs []net.IP
if parsedIP := net.ParseIP(host); parsedIP != nil {
hostIPs = append(hostIPs, parsedIP)
} else if hostIPs, err = net.LookupIP(host); err != nil {
return errors.Errorf("failed to lookup %s address in host specification", host)
}
pa := portallocator.Get()
for _, hostIP := range hostIPs {
if _, err := pa.RequestPort(hostIP, "tcp", intPort); err != nil {
return errors.Errorf("failed to allocate daemon listening port %d (err: %v)", intPort, err)
}
}
return nil
}
func newCgroupParent(cfg *config.Config) string {
cgroupParent := "docker"
useSystemd := daemon.UsingSystemd(cfg)
if useSystemd {
cgroupParent = "system.slice"
}
if cfg.CgroupParent != "" {
cgroupParent = cfg.CgroupParent
}
if useSystemd {
cgroupParent = cgroupParent + ":" + "docker" + ":"
}
return cgroupParent
}
func (cli *daemonCLI) initContainerd(ctx context.Context) (func(time.Duration) error, error) {
if cli.Config.ContainerdAddr != "" {
// use system containerd at the given address.
return nil, nil
}
return cli.initializeContainerd(ctx)
}
|
