mirror of https://github.com/docker/docs.git
123 lines
3.4 KiB
Go
123 lines
3.4 KiB
Go
package libmachine
|
|
|
|
import (
|
|
"path/filepath"
|
|
|
|
"github.com/docker/machine/libmachine/auth"
|
|
"github.com/docker/machine/libmachine/engine"
|
|
"github.com/docker/machine/libmachine/swarm"
|
|
"github.com/docker/machine/utils"
|
|
)
|
|
|
|
// In the 0.0.1 => 0.0.2 transition, the JSON representation of
|
|
// machines changed from a "flat" to a more "nested" structure
|
|
// for various options and configuration settings. To preserve
|
|
// compatibility with existing machines, these migration functions
|
|
// have been introduced. They preserve backwards compat at the expense
|
|
// of some duplicated information.
|
|
|
|
// validates host config and modifies if needed
|
|
// this is used for configuration updates
|
|
func FillNestedHost(host *Host) *Host {
|
|
certInfo := getCertInfoFromHost(host)
|
|
|
|
if host.HostOptions == nil {
|
|
host.HostOptions = &HostOptions{}
|
|
}
|
|
if host.HostOptions.EngineOptions == nil {
|
|
host.HostOptions.EngineOptions = &engine.EngineOptions{}
|
|
}
|
|
|
|
if host.HostOptions.SwarmOptions == nil {
|
|
host.HostOptions.SwarmOptions = &swarm.SwarmOptions{
|
|
Address: "",
|
|
Discovery: host.SwarmDiscovery,
|
|
Host: host.SwarmHost,
|
|
Master: host.SwarmMaster,
|
|
}
|
|
}
|
|
|
|
host.HostOptions.AuthOptions = &auth.AuthOptions{
|
|
StorePath: host.StorePath,
|
|
CaCertPath: certInfo.CaCertPath,
|
|
CaCertRemotePath: "",
|
|
ServerCertPath: certInfo.ServerCertPath,
|
|
ServerKeyPath: certInfo.ServerKeyPath,
|
|
ClientKeyPath: certInfo.ClientKeyPath,
|
|
ServerCertRemotePath: "",
|
|
ServerKeyRemotePath: "",
|
|
PrivateKeyPath: certInfo.CaKeyPath,
|
|
ClientCertPath: certInfo.ClientCertPath,
|
|
}
|
|
|
|
return host
|
|
}
|
|
|
|
// fills nested host metadata and modifies if needed
|
|
// this is used for configuration updates
|
|
func FillNestedHostMetadata(m *HostMetadata) *HostMetadata {
|
|
if m.HostOptions.EngineOptions == nil {
|
|
m.HostOptions.EngineOptions = &engine.EngineOptions{}
|
|
}
|
|
|
|
if m.HostOptions.AuthOptions == nil {
|
|
m.HostOptions.AuthOptions = &auth.AuthOptions{
|
|
StorePath: m.StorePath,
|
|
CaCertPath: m.CaCertPath,
|
|
CaCertRemotePath: "",
|
|
ServerCertPath: m.ServerCertPath,
|
|
ServerKeyPath: m.ServerKeyPath,
|
|
ClientKeyPath: "",
|
|
ServerCertRemotePath: "",
|
|
ServerKeyRemotePath: "",
|
|
PrivateKeyPath: m.PrivateKeyPath,
|
|
ClientCertPath: m.ClientCertPath,
|
|
}
|
|
}
|
|
|
|
return m
|
|
}
|
|
|
|
func getCertInfoFromHost(h *Host) CertPathInfo {
|
|
// setup cert paths
|
|
caCertPath := h.CaCertPath
|
|
caKeyPath := h.PrivateKeyPath
|
|
clientCertPath := h.ClientCertPath
|
|
clientKeyPath := h.ClientKeyPath
|
|
serverCertPath := h.ServerCertPath
|
|
serverKeyPath := h.ServerKeyPath
|
|
|
|
if caCertPath == "" {
|
|
caCertPath = filepath.Join(utils.GetMachineCertDir(), "ca.pem")
|
|
}
|
|
|
|
if caKeyPath == "" {
|
|
caKeyPath = filepath.Join(utils.GetMachineCertDir(), "ca-key.pem")
|
|
}
|
|
|
|
if clientCertPath == "" {
|
|
clientCertPath = filepath.Join(utils.GetMachineCertDir(), "cert.pem")
|
|
}
|
|
|
|
if clientKeyPath == "" {
|
|
clientKeyPath = filepath.Join(utils.GetMachineCertDir(), "key.pem")
|
|
}
|
|
|
|
if serverCertPath == "" {
|
|
serverCertPath = filepath.Join(utils.GetMachineCertDir(), "server.pem")
|
|
}
|
|
|
|
if serverKeyPath == "" {
|
|
serverKeyPath = filepath.Join(utils.GetMachineCertDir(), "server-key.pem")
|
|
}
|
|
|
|
return CertPathInfo{
|
|
CaCertPath: caCertPath,
|
|
CaKeyPath: caKeyPath,
|
|
ClientCertPath: clientCertPath,
|
|
ClientKeyPath: clientKeyPath,
|
|
ServerCertPath: serverCertPath,
|
|
ServerKeyPath: serverKeyPath,
|
|
}
|
|
}
|