docker
/
docs
mirror of https://github.com/docker/docs.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove systemd-related driver duplication 

Signed-off-by: Nathan LeClaire <nathan.leclaire@gmail.com>
This commit is contained in:
Nathan LeClaire 2015-11-17 19:47:10 -08:00
parent 8d19826c38
commit fda08f5e15
12 changed files with 160 additions and 289 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

61
libmachine/provision/arch.go
View File

@ -1,9 +1,7 @@
package provision
import (
"bytes"
"fmt"
"text/template"
"github.com/docker/machine/libmachine/auth"
"github.com/docker/machine/libmachine/drivers"
@ -23,39 +21,18 @@ func init() {
func NewArchProvisioner(d drivers.Driver) Provisioner {
return &ArchProvisioner{
GenericProvisioner{
DockerOptionsDir: "/etc/docker",
DaemonOptionsFile: "/etc/systemd/system/docker.service",
OsReleaseID: "arch",
Packages: []string{},
Driver: d,
},
NewSystemdProvisioner("arch", d),
}
}
type ArchProvisioner struct {
GenericProvisioner
SystemdProvisioner
}
func (provisioner *ArchProvisioner) CompatibleWithHost() bool {
return provisioner.OsReleaseInfo.ID == provisioner.OsReleaseID || provisioner.OsReleaseInfo.IDLike == provisioner.OsReleaseID
}
func (provisioner *ArchProvisioner) Service(name string, action serviceaction.ServiceAction) error {
// daemon-reload to catch config updates; systemd -- ugh
if _, err := provisioner.SSHCommand("sudo systemctl daemon-reload"); err != nil {
return err
}
command := fmt.Sprintf("sudo systemctl %s %s", action.String(), name)
if _, err := provisioner.SSHCommand(command); err != nil {
return err
}
return nil
}
func (provisioner *ArchProvisioner) Package(name string, action pkgaction.PackageAction) error {
var packageAction string
@ -167,37 +144,3 @@ func (provisioner *ArchProvisioner) Provision(swarmOptions swarm.Options, authOp
return nil
}
func (provisioner *ArchProvisioner) GenerateDockerOptions(dockerPort int) (*DockerOptions, error) {
var (
engineCfg bytes.Buffer
)
driverNameLabel := fmt.Sprintf("provider=%s", provisioner.Driver.DriverName())
provisioner.EngineOptions.Labels = append(provisioner.EngineOptions.Labels, driverNameLabel)
engineConfigTmpl := `[Service]
ExecStart=/usr/bin/docker -d -H tcp://0.0.0.0:{{.DockerPort}} -H unix:///var/run/docker.sock --storage-driver {{.EngineOptions.StorageDriver}} --tlsverify --tlscacert {{.AuthOptions.CaCertRemotePath}} --tlscert {{.AuthOptions.ServerCertRemotePath}} --tlskey {{.AuthOptions.ServerKeyRemotePath}} {{ range .EngineOptions.Labels }}--label {{.}} {{ end }}{{ range .EngineOptions.InsecureRegistry }}--insecure-registry {{.}} {{ end }}{{ range .EngineOptions.RegistryMirror }}--registry-mirror {{.}} {{ end }}{{ range .EngineOptions.ArbitraryFlags }}--{{.}} {{ end }}
MountFlags=slave
LimitNOFILE=1048576
LimitNPROC=1048576
LimitCORE=infinity
`
t, err := template.New("engineConfig").Parse(engineConfigTmpl)
if err != nil {
return nil, err
}
engineConfigContext := EngineConfigContext{
DockerPort: dockerPort,
AuthOptions: provisioner.AuthOptions,
EngineOptions: provisioner.EngineOptions,
}
t.Execute(&engineCfg, engineConfigContext)
return &DockerOptions{
EngineOptions: engineCfg.String(),
EngineOptionsPath: provisioner.DaemonOptionsFile,
}, nil
}

16
libmachine/provision/centos.go
View File

@ -11,21 +11,11 @@ func init() {
}
func NewCentosProvisioner(d drivers.Driver) Provisioner {
g := GenericProvisioner{
DockerOptionsDir: "/etc/docker",
DaemonOptionsFile: "/etc/systemd/system/docker.service",
OsReleaseID: "centos",
Packages: []string{},
Driver: d,
return &CentosProvisioner{
NewRedHatProvisioner("centos", d),
}
p := &CentosProvisioner{
RedHatProvisioner{
GenericProvisioner: g,
},
}
return p
}
type CentosProvisioner struct {
RedHatProvisioner
*RedHatProvisioner
}

1
libmachine/provision/coreos.go
View File

@ -45,7 +45,6 @@ type CoreOSProvisioner struct {
}
func (provisioner *CoreOSProvisioner) Service(name string, action serviceaction.ServiceAction) error {
// daemon-reload to catch config updates; systemd -- ugh
if _, err := provisioner.SSHCommand("sudo systemctl daemon-reload"); err != nil {
return err
}

67
libmachine/provision/debian.go
View File

@ -1,9 +1,7 @@
package provision
import (
"bytes"
"fmt"
"text/template"
"github.com/docker/machine/libmachine/auth"
"github.com/docker/machine/libmachine/drivers"
@ -23,35 +21,12 @@ func init() {
func NewDebianProvisioner(d drivers.Driver) Provisioner {
return &DebianProvisioner{
GenericProvisioner{
DockerOptionsDir: "/etc/docker",
DaemonOptionsFile: "/etc/systemd/system/docker.service",
OsReleaseID: "debian",
Packages: []string{
"curl",
},
Driver: d,
},
NewSystemdProvisioner("debian", d),
}
}
type DebianProvisioner struct {
GenericProvisioner
}
func (provisioner *DebianProvisioner) Service(name string, action serviceaction.ServiceAction) error {
// daemon-reload to catch config updates; systemd -- ugh
if _, err := provisioner.SSHCommand("sudo systemctl daemon-reload"); err != nil {
return err
}
command := fmt.Sprintf("sudo systemctl -f %s %s", action.String(), name)
if _, err := provisioner.SSHCommand(command); err != nil {
return err
}
return nil
SystemdProvisioner
}
func (provisioner *DebianProvisioner) Package(name string, action pkgaction.PackageAction) error {
@ -179,41 +154,3 @@ func (provisioner *DebianProvisioner) Provision(swarmOptions swarm.Options, auth
return nil
}
func (provisioner *DebianProvisioner) GenerateDockerOptions(dockerPort int) (*DockerOptions, error) {
var (
engineCfg bytes.Buffer
)
driverNameLabel := fmt.Sprintf("provider=%s", provisioner.Driver.DriverName())
provisioner.EngineOptions.Labels = append(provisioner.EngineOptions.Labels, driverNameLabel)
engineConfigTmpl := `[Service]
ExecStart=/usr/bin/docker -d -H tcp://0.0.0.0:{{.DockerPort}} -H unix:///var/run/docker.sock --storage-driver {{.EngineOptions.StorageDriver}} --tlsverify --tlscacert {{.AuthOptions.CaCertRemotePath}} --tlscert {{.AuthOptions.ServerCertRemotePath}} --tlskey {{.AuthOptions.ServerKeyRemotePath}} {{ range .EngineOptions.Labels }}--label {{.}} {{ end }}{{ range .EngineOptions.InsecureRegistry }}--insecure-registry {{.}} {{ end }}{{ range .EngineOptions.RegistryMirror }}--registry-mirror {{.}} {{ end }}{{ range .EngineOptions.ArbitraryFlags }}--{{.}} {{ end }}
MountFlags=slave
LimitNOFILE=1048576
LimitNPROC=1048576
LimitCORE=infinity
Environment={{range .EngineOptions.Env}}{{ printf "%q" . }} {{end}}
[Install]
WantedBy=multi-user.target
`
t, err := template.New("engineConfig").Parse(engineConfigTmpl)
if err != nil {
return nil, err
}
engineConfigContext := EngineConfigContext{
DockerPort: dockerPort,
AuthOptions: provisioner.AuthOptions,
EngineOptions: provisioner.EngineOptions,
}
t.Execute(&engineCfg, engineConfigContext)
return &DockerOptions{
EngineOptions: engineCfg.String(),
EngineOptionsPath: provisioner.DaemonOptionsFile,
}, nil
}

16
libmachine/provision/fedora.go
View File

@ -11,21 +11,11 @@ func init() {
}
func NewFedoraProvisioner(d drivers.Driver) Provisioner {
g := GenericProvisioner{
DockerOptionsDir: "/etc/docker",
DaemonOptionsFile: "/etc/systemd/system/docker.service",
OsReleaseID: "fedora",
Packages: []string{},
Driver: d,
return &FedoraProvisioner{
NewRedHatProvisioner("fedora", d),
}
p := &FedoraProvisioner{
RedHatProvisioner{
GenericProvisioner: g,
},
}
return p
}
type FedoraProvisioner struct {
RedHatProvisioner
*RedHatProvisioner
}

13
libmachine/provision/generic.go
View File

@ -12,6 +12,7 @@ import (
)
type GenericProvisioner struct {
SSHCommander
OsReleaseID string
DockerOptionsDir string
DaemonOptionsFile string
@ -23,6 +24,14 @@ type GenericProvisioner struct {
SwarmOptions swarm.Options
}
type GenericSSHCmder struct {
Driver drivers.Driver
}
func (sshCmder GenericSSHCmder) SSHCommand(args string) (string, error) {
return drivers.RunSSHCommandFromDriver(sshCmder.Driver, args)
}
func (provisioner *GenericProvisioner) Hostname() (string, error) {
return provisioner.SSHCommand("hostname")
}
@ -52,10 +61,6 @@ func (provisioner *GenericProvisioner) GetDockerOptionsDir() string {
return provisioner.DockerOptionsDir
}
func (provisioner *GenericProvisioner) SSHCommand(args string) (string, error) {
return drivers.RunSSHCommandFromDriver(provisioner.Driver, args)
}
func (provisioner *GenericProvisioner) CompatibleWithHost() bool {
return provisioner.OsReleaseInfo.ID == provisioner.OsReleaseID
}

10
libmachine/provision/provisioner.go
View File

@ -14,8 +14,15 @@ import (
var provisioners = make(map[string]*RegisteredProvisioner)
type SSHCommander interface {
// Short-hand for accessing an SSH command from the driver.
SSHCommand(args string) (string, error)
}
// Provisioner defines distribution specific actions
type Provisioner interface {
SSHCommander
// Create the files for the daemon to consume configuration settings (return struct of content and path)
GenerateDockerOptions(dockerPort int) (*DockerOptions, error)
@ -51,9 +58,6 @@ type Provisioner interface {
// Get the driver which is contained in the provisioner.
GetDriver() drivers.Driver
// Short-hand for accessing an SSH command from the driver.
SSHCommand(args string) (string, error)
// Set the OS Release info depending on how it's represented
// internally
SetOsReleaseInfo(info *OsRelease)

67
libmachine/provision/redhat.go
View File

@ -13,7 +13,6 @@ import (
"github.com/docker/machine/libmachine/mcnutils"
"github.com/docker/machine/libmachine/provision/pkgaction"
"github.com/docker/machine/libmachine/provision/serviceaction"
"github.com/docker/machine/libmachine/ssh"
"github.com/docker/machine/libmachine/swarm"
)
@ -44,47 +43,22 @@ type PackageListInfo struct {
func init() {
Register("RedHat", &RegisteredProvisioner{
New: NewRedHatProvisioner,
New: func(d drivers.Driver) Provisioner {
return NewRedHatProvisioner("rhel", d)
},
})
}
func NewRedHatProvisioner(d drivers.Driver) Provisioner {
func NewRedHatProvisioner(osReleaseID string, d drivers.Driver) *RedHatProvisioner {
systemdProvisioner := NewSystemdProvisioner(osReleaseID, d)
systemdProvisioner.SSHCommander = RedHatSSHCommander{Driver: d}
return &RedHatProvisioner{
GenericProvisioner: GenericProvisioner{
DockerOptionsDir: "/etc/docker",
DaemonOptionsFile: "/etc/systemd/system/docker.service",
OsReleaseID: "rhel",
Packages: []string{
"curl",
},
Driver: d,
},
systemdProvisioner,
}
}
type RedHatProvisioner struct {
GenericProvisioner
}
func (provisioner *RedHatProvisioner) SSHCommand(args string) (string, error) {
client, err := drivers.GetSSHClientFromDriver(provisioner.Driver)
if err != nil {
return "", err
}
// redhat needs "-t" for tty allocation on ssh therefore we check for the
// external client and add as needed.
// Note: CentOS 7.0 needs multiple "-tt" to force tty allocation when ssh has
// no local tty.
switch c := client.(type) {
case ssh.ExternalClient:
c.BaseArgs = append(c.BaseArgs, "-tt")
client = c
case ssh.NativeClient:
return c.OutputWithPty(args)
}
return client.Output(args)
SystemdProvisioner
}
func (provisioner *RedHatProvisioner) SetHostname(hostname string) error {
@ -110,31 +84,6 @@ func (provisioner *RedHatProvisioner) SetHostname(hostname string) error {
return nil
}
func (provisioner *RedHatProvisioner) Service(name string, action serviceaction.ServiceAction) error {
reloadDaemon := false
switch action {
case serviceaction.Start, serviceaction.Restart:
reloadDaemon = true
}
// systemd needs reloaded when config changes on disk; we cannot
// be sure exactly when it changes from the provisioner so
// we call a reload on every restart to be safe
if reloadDaemon {
if _, err := provisioner.SSHCommand("sudo systemctl daemon-reload"); err != nil {
return err
}
}
command := fmt.Sprintf("sudo systemctl %s %s", action.String(), name)
if _, err := provisioner.SSHCommand(command); err != nil {
return err
}
return nil
}
func (provisioner *RedHatProvisioner) Package(name string, action pkgaction.PackageAction) error {
var packageAction string

31
libmachine/provision/redhat_ssh_commander.go Normal file
View File

@ -0,0 +1,31 @@
package provision
import (
"github.com/docker/machine/libmachine/drivers"
"github.com/docker/machine/libmachine/ssh"
)
type RedHatSSHCommander struct {
Driver drivers.Driver
}
func (sshCmder RedHatSSHCommander) SSHCommand(args string) (string, error) {
client, err := drivers.GetSSHClientFromDriver(sshCmder.Driver)
if err != nil {
return "", err
}
// redhat needs "-t" for tty allocation on ssh therefore we check for the
// external client and add as needed.
// Note: CentOS 7.0 needs multiple "-tt" to force tty allocation when ssh has
// no local tty.
switch c := client.(type) {
case ssh.ExternalClient:
c.BaseArgs = append(c.BaseArgs, "-tt")
client = c
case ssh.NativeClient:
return c.OutputWithPty(args)
}
return client.Output(args)
}

2
libmachine/provision/redhat_test.go
View File

@ -9,7 +9,7 @@ func TestRedHatGenerateYumRepoList(t *testing.T) {
info := &OsRelease{
ID: "rhel",
}
p := NewRedHatProvisioner(nil)
p := NewRedHatProvisioner("rhel", nil)
p.SetOsReleaseInfo(info)
buf, err := generateYumRepoList(p)

92
libmachine/provision/systemd.go Normal file
View File

@ -0,0 +1,92 @@
package provision
import (
"bytes"
"fmt"
"text/template"
"github.com/docker/machine/libmachine/drivers"
"github.com/docker/machine/libmachine/provision/serviceaction"
)
type SystemdProvisioner struct {
GenericProvisioner
}
func NewSystemdProvisioner(osReleaseID string, d drivers.Driver) SystemdProvisioner {
return SystemdProvisioner{
GenericProvisioner{
SSHCommander: GenericSSHCmder{Driver: d},
DockerOptionsDir: "/etc/docker",
DaemonOptionsFile: "/etc/systemd/system/docker.service",
OsReleaseID: osReleaseID,
Packages: []string{
"curl",
},
Driver: d,
},
}
}
func (p *SystemdProvisioner) GenerateDockerOptions(dockerPort int) (*DockerOptions, error) {
var (
engineCfg bytes.Buffer
)
driverNameLabel := fmt.Sprintf("provider=%s", p.Driver.DriverName())
p.EngineOptions.Labels = append(p.EngineOptions.Labels, driverNameLabel)
engineConfigTmpl := `[Service]
ExecStart=/usr/bin/docker -d -H tcp://0.0.0.0:{{.DockerPort}} -H unix:///var/run/docker.sock --storage-driver {{.EngineOptions.StorageDriver}} --tlsverify --tlscacert {{.AuthOptions.CaCertRemotePath}} --tlscert {{.AuthOptions.ServerCertRemotePath}} --tlskey {{.AuthOptions.ServerKeyRemotePath}} {{ range .EngineOptions.Labels }}--label {{.}} {{ end }}{{ range .EngineOptions.InsecureRegistry }}--insecure-registry {{.}} {{ end }}{{ range .EngineOptions.RegistryMirror }}--registry-mirror {{.}} {{ end }}{{ range .EngineOptions.ArbitraryFlags }}--{{.}} {{ end }}
MountFlags=slave
LimitNOFILE=1048576
LimitNPROC=1048576
LimitCORE=infinity
Environment={{range .EngineOptions.Env}}{{ printf "%q" . }} {{end}}
[Install]
WantedBy=multi-user.target
`
t, err := template.New("engineConfig").Parse(engineConfigTmpl)
if err != nil {
return nil, err
}
engineConfigContext := EngineConfigContext{
DockerPort: dockerPort,
AuthOptions: p.AuthOptions,
EngineOptions: p.EngineOptions,
}
t.Execute(&engineCfg, engineConfigContext)
return &DockerOptions{
EngineOptions: engineCfg.String(),
EngineOptionsPath: p.DaemonOptionsFile,
}, nil
}
func (p *SystemdProvisioner) Service(name string, action serviceaction.ServiceAction) error {
reloadDaemon := false
switch action {
case serviceaction.Start, serviceaction.Restart:
reloadDaemon = true
}
// systemd needs reloaded when config changes on disk; we cannot
// be sure exactly when it changes from the provisioner so
// we call a reload on every restart to be safe
if reloadDaemon {
if _, err := p.SSHCommand("sudo systemctl daemon-reload"); err != nil {
return err
}
}
command := fmt.Sprintf("sudo systemctl -f %s %s", action.String(), name)
if _, err := p.SSHCommand(command); err != nil {
return err
}
return nil
}

73
libmachine/provision/ubuntu_systemd.go
View File

@ -1,10 +1,8 @@
package provision
import (
"bytes"
"fmt"
"strconv"
"text/template"
"github.com/docker/machine/libmachine/auth"
"github.com/docker/machine/libmachine/drivers"
@ -24,20 +22,12 @@ func init() {
func NewUbuntuSystemdProvisioner(d drivers.Driver) Provisioner {
return &UbuntuSystemdProvisioner{
GenericProvisioner{
DockerOptionsDir: "/etc/docker",
DaemonOptionsFile: "/etc/systemd/system/docker.service",
OsReleaseID: "ubuntu",
Packages: []string{
"curl",
},
Driver: d,
},
NewSystemdProvisioner("ubuntu", d),
}
}
type UbuntuSystemdProvisioner struct {
GenericProvisioner
SystemdProvisioner
}
func (provisioner *UbuntuSystemdProvisioner) CompatibleWithHost() bool {
@ -55,21 +45,6 @@ func (provisioner *UbuntuSystemdProvisioner) CompatibleWithHost() bool {
}
func (provisioner *UbuntuSystemdProvisioner) Service(name string, action serviceaction.ServiceAction) error {
// daemon-reload to catch config updates; systemd -- ugh
if _, err := provisioner.SSHCommand("sudo systemctl daemon-reload"); err != nil {
return err
}
command := fmt.Sprintf("sudo systemctl -f %s %s", action.String(), name)
if _, err := provisioner.SSHCommand(command); err != nil {
return err
}
return nil
}
func (provisioner *UbuntuSystemdProvisioner) Package(name string, action pkgaction.PackageAction) error {
var packageAction string
@ -147,12 +122,6 @@ func (provisioner *UbuntuSystemdProvisioner) Provision(swarmOptions swarm.Option
provisioner.EngineOptions.StorageDriver = "aufs"
}
// HACK: since debian does not come with sudo by default we install
log.Debug("installing sudo")
if _, err := provisioner.SSHCommand("if ! type sudo; then apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y sudo; fi"); err != nil {
return err
}
log.Debug("setting hostname")
if err := provisioner.SetHostname(provisioner.Driver.GetMachineName()); err != nil {
return err
@ -195,41 +164,3 @@ func (provisioner *UbuntuSystemdProvisioner) Provision(swarmOptions swarm.Option
return nil
}
func (provisioner *UbuntuSystemdProvisioner) GenerateDockerOptions(dockerPort int) (*DockerOptions, error) {
var (
engineCfg bytes.Buffer
)
driverNameLabel := fmt.Sprintf("provider=%s", provisioner.Driver.DriverName())
provisioner.EngineOptions.Labels = append(provisioner.EngineOptions.Labels, driverNameLabel)
engineConfigTmpl := `[Service]
ExecStart=/usr/bin/docker -d -H tcp://0.0.0.0:{{.DockerPort}} -H unix:///var/run/docker.sock --storage-driver {{.EngineOptions.StorageDriver}} --tlsverify --tlscacert {{.AuthOptions.CaCertRemotePath}} --tlscert {{.AuthOptions.ServerCertRemotePath}} --tlskey {{.AuthOptions.ServerKeyRemotePath}} {{ range .EngineOptions.Labels }}--label {{.}} {{ end }}{{ range .EngineOptions.InsecureRegistry }}--insecure-registry {{.}} {{ end }}{{ range .EngineOptions.RegistryMirror }}--registry-mirror {{.}} {{ end }}{{ range .EngineOptions.ArbitraryFlags }}--{{.}} {{ end }}
MountFlags=slave
LimitNOFILE=1048576
LimitNPROC=1048576
LimitCORE=infinity
Environment={{range .EngineOptions.Env}}{{ printf "%q" . }} {{end}}
[Install]
WantedBy=multi-user.target
`
t, err := template.New("engineConfig").Parse(engineConfigTmpl)
if err != nil {
return nil, err
}
engineConfigContext := EngineConfigContext{
DockerPort: dockerPort,
AuthOptions: provisioner.AuthOptions,
EngineOptions: provisioner.EngineOptions,
}
t.Execute(&engineCfg, engineConfigContext)
return &DockerOptions{
EngineOptions: engineCfg.String(),
EngineOptionsPath: provisioner.DaemonOptionsFile,
}, nil
}