func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
if drivers.EngineInstallURLFlagSet(flags) {
return errors.New("--engine-install-url cannot be used with the vmwarefusion driver, use --vmwarefusion-boot2docker-url instead")
}
d.Memory = flags.Int("vmwarefusion-memory-size")
d.CPU = flags.Int("vmwarefusion-cpu-count")
d.DiskSize = flags.Int("vmwarefusion-disk-size")
d.Boot2DockerURL = flags.String("vmwarefusion-boot2docker-url")
d.ConfigDriveURL = flags.String("vmwarefusion-configdrive-url")
d.ISO = d.ResolveStorePath(isoFilename)
d.ConfigDriveISO = d.ResolveStorePath(isoConfigDrive)
d.SetSwarmConfigFromFlags(flags)
d.SSHUser = flags.String("vmwarefusion-ssh-user")
d.SSHPassword = flags.String("vmwarefusion-ssh-password")
d.SSHPort = 22
d.NoShare = flags.Bool("vmwarefusion-no-share")
// We support a maximum of 16 cpu to be consistent with Virtual Hardware 10
// specs.
if d.CPU < 1 {
d.CPU = int(runtime.NumCPU())
}
if d.CPU > 16 {
d.CPU = 16
}
return nil
}
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.AuthUrl = flags.String("openstack-auth-url")
d.ActiveTimeout = flags.Int("openstack-active-timeout")
d.Insecure = flags.Bool("openstack-insecure")
d.DomainID = flags.String("openstack-domain-id")
d.DomainName = flags.String("openstack-domain-name")
d.Username = flags.String("openstack-username")
d.Password = flags.String("openstack-password")
d.TenantName = flags.String("openstack-tenant-name")
d.TenantId = flags.String("openstack-tenant-id")
d.Region = flags.String("openstack-region")
d.AvailabilityZone = flags.String("openstack-availability-zone")
d.EndpointType = flags.String("openstack-endpoint-type")
d.FlavorId = flags.String("openstack-flavor-id")
d.FlavorName = flags.String("openstack-flavor-name")
d.ImageId = flags.String("openstack-image-id")
d.ImageName = flags.String("openstack-image-name")
d.NetworkId = flags.String("openstack-net-id")
d.NetworkName = flags.String("openstack-net-name")
if flags.String("openstack-sec-groups") != "" {
d.SecurityGroups = strings.Split(flags.String("openstack-sec-groups"), ",")
}
d.FloatingIpPool = flags.String("openstack-floatingip-pool")
d.IpVersion = flags.Int("openstack-ip-version")
d.SSHUser = flags.String("openstack-ssh-user")
d.SSHPort = flags.Int("openstack-ssh-port")
d.SwarmMaster = flags.Bool("swarm-master")
d.SwarmHost = flags.String("swarm-host")
d.SwarmDiscovery = flags.String("swarm-discovery")
return d.checkConfig()
}
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
if drivers.EngineInstallURLFlagSet(flags) {
return errors.New("--engine-install-url cannot be used with the virtualbox driver, use --virtualbox-boot2docker-url instead")
}
d.CPU = flags.Int("virtualbox-cpu-count")
d.Memory = flags.Int("virtualbox-memory")
d.DiskSize = flags.Int("virtualbox-disk-size")
d.Boot2DockerURL = flags.String("virtualbox-boot2docker-url")
d.SetSwarmConfigFromFlags(flags)
d.SSHUser = "******"
d.Boot2DockerImportVM = flags.String("virtualbox-import-boot2docker-vm")
d.HostDNSResolver = flags.Bool("virtualbox-host-dns-resolver")
d.NatNicType = flags.String("virtualbox-nat-nictype")
d.HostOnlyCIDR = flags.String("virtualbox-hostonly-cidr")
d.HostOnlyNicType = flags.String("virtualbox-hostonly-nictype")
d.HostOnlyPromiscMode = flags.String("virtualbox-hostonly-nicpromisc")
d.UIType = flags.String("virtualbox-ui-type")
d.HostOnlyNoDHCP = flags.Bool("virtualbox-hostonly-no-dhcp")
d.NoShare = flags.Bool("virtualbox-no-share")
d.DNSProxy = !flags.Bool("virtualbox-no-dns-proxy")
d.NoVTXCheck = flags.Bool("virtualbox-no-vtx-check")
d.ShareFolder = flags.String("virtualbox-share-folder")
return nil
}
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.URL = flags.String("exoscale-endpoint")
d.ApiKey = flags.String("exoscale-api-key")
d.ApiSecretKey = flags.String("exoscale-api-secret-key")
d.InstanceProfile = flags.String("exoscale-instance-profile")
d.DiskSize = flags.Int("exoscale-disk-size")
d.Image = flags.String("exoscale-image")
securityGroups := flags.StringSlice("exoscale-security-group")
if len(securityGroups) == 0 {
securityGroups = []string{"docker-machine"}
}
d.SecurityGroup = strings.Join(securityGroups, ",")
d.AvailabilityZone = flags.String("exoscale-availability-zone")
d.SwarmMaster = flags.Bool("swarm-master")
d.SwarmHost = flags.String("swarm-host")
d.SwarmDiscovery = flags.String("swarm-discovery")
if d.URL == "" {
d.URL = "https://api.exoscale.ch/compute"
}
if d.ApiKey == "" || d.ApiSecretKey == "" {
return fmt.Errorf("Please specify an API key (--exoscale-api-key) and an API secret key (--exoscale-api-secret-key).")
}
return nil
}
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.Memory = flags.Int("vmwarefusion-memory-size")
d.CPU = flags.Int("vmwarefusion-cpu-count")
d.DiskSize = flags.Int("vmwarefusion-disk-size")
d.Boot2DockerURL = flags.String("vmwarefusion-boot2docker-url")
d.ConfigDriveURL = flags.String("vmwarefusion-configdrive-url")
d.ISO = d.ResolveStorePath(isoFilename)
d.SwarmMaster = flags.Bool("swarm-master")
d.SwarmHost = flags.String("swarm-host")
d.SwarmDiscovery = flags.String("swarm-discovery")
d.SSHUser = flags.String("vmwarefusion-ssh-user")
d.SSHPassword = flags.String("vmwarefusion-ssh-password")
d.SSHPort = 22
// We support a maximum of 16 cpu to be consistent with Virtual Hardware 10
// specs.
if d.CPU < 1 {
d.CPU = int(runtime.NumCPU())
}
if d.CPU > 16 {
d.CPU = 16
}
return nil
}
// SetConfigFromFlags initializes the driver based on the command line flags.
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.Project = flags.String("google-project")
if d.Project == "" {
return fmt.Errorf("Please specify the Google Cloud Project name using the option --google-project.")
}
d.Zone = flags.String("google-zone")
d.UseExisting = flags.Bool("google-use-existing")
if !d.UseExisting {
d.MachineType = flags.String("google-machine-type")
d.MachineImage = flags.String("google-machine-image")
d.DiskSize = flags.Int("google-disk-size")
d.DiskType = flags.String("google-disk-type")
d.Address = flags.String("google-address")
d.Preemptible = flags.Bool("google-preemptible")
d.UseInternalIP = flags.Bool("google-use-internal-ip") || flags.Bool("google-use-internal-ip-only")
d.UseInternalIPOnly = flags.Bool("google-use-internal-ip-only")
d.Scopes = flags.String("google-scopes")
d.Tags = flags.String("google-tags")
}
d.SSHUser = flags.String("google-username")
d.SSHPort = 22
d.SetSwarmConfigFromFlags(flags)
return nil
}
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.Boot2DockerURL = flags.String("hyperv-boot2docker-url")
d.VSwitch = flags.String("hyperv-virtual-switch")
d.DiskSize = flags.Int("hyperv-disk-size")
d.MemSize = flags.Int("hyperv-memory")
d.CPU = flags.Int("hyperv-cpu-count")
d.SwarmMaster = flags.Bool("swarm-master")
d.SwarmHost = flags.String("swarm-host")
d.SwarmDiscovery = flags.String("swarm-discovery")
d.SSHUser = "******"
return nil
}
// SetConfigFromFlags configures the driver with the object that was returned
// by RegisterCreateFlags
func (d *Driver) SetConfigFromFlags(opts drivers.DriverOptions) error {
d.CPU = opts.Int("parallels-cpu-count")
d.Memory = opts.Int("parallels-memory")
d.DiskSize = opts.Int("parallels-disk-size")
d.Boot2DockerURL = opts.String("parallels-boot2docker-url")
d.SetSwarmConfigFromFlags(opts)
d.SSHUser = defaultSSHUser
d.SSHPort = defaultSSHPort
d.NoShare = opts.Bool("parallels-no-share")
return nil
}
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.Boot2DockerURL = flags.String("xhyve-boot2docker-url")
d.CPU = flags.Int("xhyve-cpu-count")
d.Memory = flags.Int("xhyve-memory")
d.DiskSize = int64(flags.Int("xhyve-disk-size"))
d.BootCmd = flags.String("xhyve-boot-cmd")
d.SwarmMaster = flags.Bool("swarm-master")
d.SwarmHost = flags.String("swarm-host")
d.SwarmDiscovery = flags.String("swarm-discovery")
d.SSHUser = "******"
d.SSHPort = 22
return nil
}
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.SubscriptionID = flags.String("azure-subscription-id")
cert := flags.String("azure-subscription-cert")
publishSettings := flags.String("azure-publish-settings-file")
image := flags.String("azure-image")
username := flags.String("azure-username")
if cert != "" {
if _, err := os.Stat(cert); os.IsNotExist(err) {
return err
}
d.SubscriptionCert = cert
}
if publishSettings != "" {
if _, err := os.Stat(publishSettings); os.IsNotExist(err) {
return err
}
d.PublishSettingsFilePath = publishSettings
}
if (d.SubscriptionID == "" || d.SubscriptionCert == "") && d.PublishSettingsFilePath == "" {
return errors.New("Please specify azure subscription params using options: --azure-subscription-id and --azure-subscription-cert or --azure-publish-settings-file")
}
if image == "" {
d.Image = "b39f27a8b8c64d52b05eac6a62ebad85__Ubuntu-14_04_1-LTS-amd64-server-20140927-en-us-30GB"
} else {
d.Image = image
}
d.Location = flags.String("azure-location")
d.Size = flags.String("azure-size")
if strings.ToLower(username) == "docker" {
return errors.New("'docker' is not valid user name for docker host. Please specify another user name")
}
d.SSHUser = username
d.UserPassword = flags.String("azure-password")
d.DockerPort = flags.Int("azure-docker-port")
d.DockerSwarmMasterPort = flags.Int("azure-docker-swarm-master-port")
d.SSHPort = flags.Int("azure-ssh-port")
d.SwarmMaster = flags.Bool("swarm-master")
d.SwarmHost = flags.String("swarm-host")
d.SwarmDiscovery = flags.String("swarm-discovery")
return nil
}
// SetConfigFromFlags configures the driver with the object that was returned
// by RegisterCreateFlags
func (d *Driver) SetConfigFromFlags(opts drivers.DriverOptions) error {
d.CPU = opts.Int("parallels-cpu-count")
d.Memory = opts.Int("parallels-memory")
d.DiskSize = opts.Int("parallels-disk-size")
d.Boot2DockerURL = opts.String("parallels-boot2docker-url")
d.SwarmMaster = opts.Bool("swarm-master")
d.SwarmHost = opts.String("swarm-host")
d.SwarmDiscovery = opts.String("swarm-discovery")
d.SSHUser = "******"
d.SSHPort = 22
d.NoShare = opts.Bool("parallels-no-share")
return nil
}
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.Boot2DockerURL = flags.String("xhyve-boot2docker-url")
d.CPU = flags.Int("xhyve-cpu-count")
d.Memory = flags.Int("xhyve-memory")
d.DiskSize = flags.Int("xhyve-disk-size")
d.ISO = path.Join(d.LocalArtifactPath("."), isoFilename)
d.SwarmMaster = flags.Bool("swarm-master")
d.SwarmHost = flags.String("swarm-host")
d.SwarmDiscovery = flags.String("swarm-discovery")
d.SSHUser = "******"
d.SSHPort = 22
return nil
}
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.CloudFormationURL = flags.String("cloudformation-url")
d.SSHPrivateKeyPath = flags.String("cloudformation-keypath")
d.KeyPairName = flags.String("cloudformation-keypairname")
d.SSHUser = flags.String("cloudformation-ssh-user")
d.UsePrivateIP = flags.Bool("cloudformation-use-private-address")
d.CloudFormationParameters = flags.String("cloudformation-parameters")
d.CloudFormationTags = flags.String("cloudformation-tags")
if d.CloudFormationURL == "" {
return fmt.Errorf("cloudformation driver requires the --cloudformation-url")
}
return nil
}
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.UserName = flags.String("vmwarevcloudair-username")
d.UserPassword = flags.String("vmwarevcloudair-password")
d.VDCID = flags.String("vmwarevcloudair-vdcid")
d.PublicIP = flags.String("vmwarevcloudair-publicip")
d.SwarmMaster = flags.Bool("swarm-master")
d.SwarmHost = flags.String("swarm-host")
d.SwarmDiscovery = flags.String("swarm-discovery")
// Check for required Params
if d.UserName == "" || d.UserPassword == "" || d.VDCID == "" || d.PublicIP == "" {
return fmt.Errorf("Please specify vcloudair mandatory params using options: -vmwarevcloudair-username -vmwarevcloudair-password -vmwarevcloudair-vdcid and -vmwarevcloudair-publicip")
}
// If ComputeID is not set we're using a VPC, hence setting ComputeID = VDCID
if flags.String("vmwarevcloudair-computeid") == "" {
d.ComputeID = flags.String("vmwarevcloudair-vdcid")
} else {
d.ComputeID = flags.String("vmwarevcloudair-computeid")
}
// If the Org VDC Network is empty, set it to the default routed network.
if flags.String("vmwarevcloudair-orgvdcnetwork") == "" {
d.OrgVDCNet = flags.String("vmwarevcloudair-vdcid") + "-default-routed"
} else {
d.OrgVDCNet = flags.String("vmwarevcloudair-orgvdcnetwork")
}
// If the Edge Gateway is empty, just set it to the default edge gateway.
if flags.String("vmwarevcloudair-edgegateway") == "" {
d.EdgeGateway = flags.String("vmwarevcloudair-vdcid")
} else {
d.EdgeGateway = flags.String("vmwarevcloudair-edgegateway")
}
d.Catalog = flags.String("vmwarevcloudair-catalog")
d.CatalogItem = flags.String("vmwarevcloudair-catalogitem")
d.DockerPort = flags.Int("vmwarevcloudair-docker-port")
d.SSHUser = "******"
d.SSHPort = flags.Int("vmwarevcloudair-ssh-port")
d.Provision = flags.Bool("vmwarevcloudair-provision")
d.CPUCount = flags.Int("vmwarevcloudair-cpu-count")
d.MemorySize = flags.Int("vmwarevcloudair-memory-size")
return nil
}
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.AccessToken = flags.String("vscale-access-token")
d.Location = flags.String("vscale-location")
d.Rplan = flags.String("vscale-rplan")
d.MadeFrom = flags.String("vscale-made-from")
d.SwarmMaster = flags.Bool("swarm-master")
d.SwarmHost = flags.String("swarm-host")
d.SwarmDiscovery = flags.String("swarm-discovery")
d.SSHPort = 22
if d.AccessToken == "" {
return fmt.Errorf("vscale driver requres the --vscale-access-token option")
}
return nil
}
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
log.Debugf("SetConfigFromFlags aclled")
d.Memory = flags.Int("kvm-memory")
d.DiskSize = flags.Int("kvm-disk-size")
d.CPU = flags.Int("kvm-cpu-count")
d.Network = flags.String("kvm-network")
d.Boot2DockerURL = flags.String("kvm-boot2docker-url")
d.SwarmMaster = flags.Bool("swarm-master")
d.SwarmHost = flags.String("swarm-host")
d.SwarmDiscovery = flags.String("swarm-discovery")
d.ISO = d.ResolveStorePath(isoFilename)
d.SSHUser = "******"
d.SSHPort = 22
d.DiskPath = d.ResolveStorePath(fmt.Sprintf("%s.img", d.MachineName))
return nil
}
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.CPU = flags.Int("virtualbox-cpu-count")
d.Memory = flags.Int("virtualbox-memory")
d.DiskSize = flags.Int("virtualbox-disk-size")
d.Boot2DockerURL = flags.String("virtualbox-boot2docker-url")
d.SwarmMaster = flags.Bool("swarm-master")
d.SwarmHost = flags.String("swarm-host")
d.SwarmDiscovery = flags.String("swarm-discovery")
d.SSHUser = "******"
d.Boot2DockerImportVM = flags.String("virtualbox-import-boot2docker-vm")
d.HostOnlyCIDR = flags.String("virtualbox-hostonly-cidr")
d.HostOnlyNicType = flags.String("virtualbox-hostonly-nictype")
d.HostOnlyPromiscMode = flags.String("virtualbox-hostonly-nicpromisc")
d.NoShare = flags.Bool("virtualbox-no-share")
return nil
}
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.AccessKeyID = flags.String("access-key-id")
d.AccessKeySecret = flags.String("access-key-secret")
d.RegionId = flags.String("region-id")
d.ZoneId = flags.String("zone-id")
d.ImageId = flags.String("image-id")
d.InstanceType = flags.String("instance-type")
d.SecurityGroupId = flags.String("security-group-id")
d.InternetChargeType = flags.String("internet-charge-type")
d.Password = flags.String("root-password")
d.IoOptimized = flags.String("io-optimized")
d.VSwitchId = flags.String("vswitch-id")
d.SwarmMaster = flags.Bool("swarm-master")
d.SwarmHost = flags.String("swarm-host")
d.SwarmDiscovery = flags.String("swarm-discovery")
return d.checkConfig()
}
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.AuthUrl = flags.String("openstack-auth-url")
d.ActiveTimeout = flags.Int("openstack-active-timeout")
d.Insecure = flags.Bool("openstack-insecure")
d.CaCert = flags.String("openstack-cacert")
d.DomainID = flags.String("openstack-domain-id")
d.DomainName = flags.String("openstack-domain-name")
d.Username = flags.String("openstack-username")
d.Password = flags.String("openstack-password")
d.TenantName = flags.String("openstack-tenant-name")
d.TenantId = flags.String("openstack-tenant-id")
d.Region = flags.String("openstack-region")
d.AvailabilityZone = flags.String("openstack-availability-zone")
d.EndpointType = flags.String("openstack-endpoint-type")
d.FlavorId = flags.String("openstack-flavor-id")
d.FlavorName = flags.String("openstack-flavor-name")
d.ImageId = flags.String("openstack-image-id")
d.ImageName = flags.String("openstack-image-name")
d.NetworkId = flags.String("openstack-net-id")
d.NetworkName = flags.String("openstack-net-name")
if flags.String("openstack-sec-groups") != "" {
d.SecurityGroups = strings.Split(flags.String("openstack-sec-groups"), ",")
}
d.FloatingIpPool = flags.String("openstack-floatingip-pool")
d.IpVersion = flags.Int("openstack-ip-version")
d.ComputeNetwork = flags.Bool("openstack-nova-network")
d.SSHUser = flags.String("openstack-ssh-user")
d.SSHPort = flags.Int("openstack-ssh-port")
d.KeyPairName = flags.String("openstack-keypair-name")
d.PrivateKeyFile = flags.String("openstack-private-key-file")
if flags.String("openstack-user-data-file") != "" {
userData, err := ioutil.ReadFile(flags.String("openstack-user-data-file"))
if err == nil {
d.UserData = userData
} else {
return err
}
}
d.SetSwarmConfigFromFlags(flags)
return d.checkConfig()
}
// SetConfigFromFlags assigns and verifies the command-line arguments presented to the driver.
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.ApplicationKey = flags.String("ovh-application-key")
d.ApplicationSecret = flags.String("ovh-application-secret")
d.ConsumerKey = flags.String("ovh-consumer-key")
// Store configuration parameters as-is
d.ProjectName = flags.String("ovh-project")
d.RegionName = flags.String("ovh-region")
d.FlavorName = flags.String("ovh-flavor")
d.KeyPairName = flags.String("ovh-ssh-key")
// Swarm configuration, must be in each driver
d.SwarmMaster = flags.Bool("swarm-master")
d.SwarmHost = flags.String("swarm-host")
d.SwarmDiscovery = flags.String("swarm-discovery")
d.SSHUser = "******"
return nil
}
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.APIClient = flags.String("brightbox-client")
d.APISecret = flags.String("brightbox-client-secret")
d.UserName = flags.String("brightbox-user-name")
d.password = flags.String("brightbox-password")
d.Account = flags.String("brightbox-account")
d.Image = flags.String("brightbox-image")
d.APIURL = flags.String("brightbox-api-url")
d.ServerType = flags.String("brightbox-type")
d.IPv6 = !flags.Bool("brightbox-ipv4")
groupList := flags.StringSlice("brightbox-group")
if groupList != nil {
d.ServerGroups = &groupList
}
d.Zone = flags.String("brightbox-zone")
d.SSHPort = defaultSSHPort
serverName := d.GetMachineName() + " (docker-machine)"
d.Name = &serverName
return d.checkConfig()
}
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.Memory = flags.Int("vmwareappcatalyst-memory-size")
d.CPU = flags.Int("vmwareappcatalyst-cpu-count")
d.SwarmMaster = flags.Bool("swarm-master")
d.SwarmHost = flags.String("swarm-host")
d.SwarmDiscovery = flags.String("swarm-discovery")
d.SSHUser = flags.String("vmwareappcatalyst-ssh-user")
d.SSHPort = 22
d.VMLocation = flags.String("vmwareappcatalyst-vm-location")
d.APIPort = flags.Int("vmwareappcatalyst-api-port")
// We support a maximum of 16 cpu.
if d.CPU < 1 {
d.CPU = int(runtime.NumCPU())
}
if d.CPU > 16 {
d.CPU = 16
}
return nil
}
// SetConfigFromFlags initializes the driver based on the command line flags.
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.Zone = flags.String("google-zone")
d.MachineType = flags.String("google-machine-type")
d.DiskSize = flags.Int("google-disk-size")
d.DiskType = flags.String("google-disk-type")
d.Address = flags.String("google-address")
d.Preemptible = flags.Bool("google-preemptible")
d.AuthTokenPath = flags.String("google-auth-token")
d.Project = flags.String("google-project")
d.Scopes = flags.String("google-scopes")
d.Tags = flags.String("google-tags")
d.SwarmMaster = flags.Bool("swarm-master")
d.SwarmHost = flags.String("swarm-host")
d.SwarmDiscovery = flags.String("swarm-discovery")
if d.Project == "" {
return fmt.Errorf("Please specify the Google Cloud Project name using the option --google-project.")
}
d.SSHUser = flags.String("google-username")
d.SSHPort = 22
return nil
}
// SetConfigFromFlags configures the driver with the object that was returned
// by RegisterCreateFlags
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.CloudApiURL = flags.String("triton-url")
d.Account = flags.String("triton-account")
d.DataCenter = flags.String("triton-datacenter")
d.PrivateKey = flags.String("triton-key")
d.SkipTlsVerify = flags.Bool("triton-skip-tls-verify")
if d.CloudApiURL == "" {
if d.DataCenter == "" {
return fmt.Errorf("You must specify a cloudapi url or datacenter name")
}
// Shortend format for the cloudapi name, e.g. "us-east-1"
d.CloudApiURL = fmt.Sprintf("https://%s.%s", d.DataCenter, TritonDefaultCloudapiDomain)
}
if d.Account == "" {
return fmt.Errorf("You must specify the account name using --triton-account")
}
if d.PrivateKey == "" {
homedir := mcnutils.GetHomeDir()
if homedir == "" {
return fmt.Errorf("You must specify the SSH key using --triton-key")
}
d.PrivateKey = path.Join(homedir, ".ssh", "id_rsa")
}
_, err := os.Stat(d.PrivateKey)
if err != nil {
return fmt.Errorf("Unable to access SSH key file %s", d.PrivateKey)
}
log.Debugf("CloudApiURL: %s", d.CloudApiURL)
log.Debugf("Account: %s", d.Account)
log.Debugf("DataCenter: %s", d.DataCenter)
log.Debugf("PrivateKey: %s", d.PrivateKey)
log.Debugf("SkipTlsVerify: %d", d.SkipTlsVerify)
return nil
}
// SetConfigFromFlags - gets the mcnflag configuration flags
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
log.Debug("SetConfigFromFlags...")
d.ClientICSP = d.ClientICSP.NewICSPClient(flags.String("oneview-icsp-user"),
flags.String("oneview-icsp-password"),
flags.String("oneview-icsp-domain"),
flags.String("oneview-icsp-endpoint"),
flags.Bool("oneview-sslverify"),
1)
d.ClientOV = d.ClientOV.NewOVClient(flags.String("oneview-ov-user"),
flags.String("oneview-ov-password"),
flags.String("oneview-ov-domain"),
flags.String("oneview-ov-endpoint"),
flags.Bool("oneview-sslverify"),
1)
d.ClientICSP.RefreshVersion()
d.ClientOV.RefreshVersion()
d.IloUser = flags.String("oneview-ilo-user")
d.IloPassword = flags.String("oneview-ilo-password")
d.IloPort = flags.Int("oneview-ilo-port")
d.PublicSlotID = flags.Int("oneview-public-slotid")
d.PublicConnectionName = flags.String("oneview-public-connection-name")
d.SSHUser = flags.String("oneview-ssh-user")
d.SSHPort = flags.Int("oneview-ssh-port")
d.ServerTemplate = flags.String("oneview-server-template")
d.OSBuildPlan = flags.String("oneview-os-plan")
d.SwarmMaster = flags.Bool("swarm-master")
d.SwarmHost = flags.String("swarm-host")
d.SwarmDiscovery = flags.String("swarm-discovery")
// TODO : we should verify settings for each client
// check for the ov endpoint
if d.ClientOV.Endpoint == "" {
return ErrDriverMissingEndPointOptionOV
}
// check for the icsp endpoint
if d.ClientICSP.Endpoint == "" {
return ErrDriverMissingEndPointOptionICSP
}
// check for the template name
if d.ServerTemplate == "" {
return ErrDriverMissingTemplateOption
}
if d.OSBuildPlan == "" {
return ErrDriverMissingBuildPlanOption
}
return nil
}
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.SSHUser = B2D_USER
d.SSHPort = 22
d.Server = flags.String("xenserver-server")
d.Username = flags.String("xenserver-username")
d.Password = flags.String("xenserver-password")
d.Boot2DockerURL = flags.String("xenserver-boot2docker-url")
d.CPU = uint(flags.Int("xenserver-vcpu-count"))
d.Memory = uint(flags.Int("xenserver-memory-size"))
d.DiskSize = uint(flags.Int("xenserver-disk-size"))
d.SR = flags.String("xenserver-sr-label")
d.Network = flags.String("xenserver-network-label")
d.Host = flags.String("xenserver-host-label")
d.UploadTimeout = uint(flags.Int("xenserver-upload-timeout"))
d.WaitTimeout = uint(flags.Int("xenserver-wait-timeout"))
d.SwarmMaster = flags.Bool("swarm-master")
d.SwarmHost = flags.String("swarm-host")
d.SwarmDiscovery = flags.String("swarm-discovery")
d.ISO = filepath.Join(d.StorePath, isoFilename)
d.TAR = filepath.Join(d.StorePath, tarFilename)
return nil
}
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.SSHUser = "******"
d.SSHPort = 22
d.CPU = flags.Int("vmwarevsphere-cpu-count")
d.Memory = flags.Int("vmwarevsphere-memory-size")
d.DiskSize = flags.Int("vmwarevsphere-disk-size")
d.Boot2DockerURL = flags.String("vmwarevsphere-boot2docker-url")
d.IP = flags.String("vmwarevsphere-vcenter")
d.Username = flags.String("vmwarevsphere-username")
d.Password = flags.String("vmwarevsphere-password")
d.Network = flags.String("vmwarevsphere-network")
d.Datastore = flags.String("vmwarevsphere-datastore")
d.Datacenter = flags.String("vmwarevsphere-datacenter")
d.Pool = flags.String("vmwarevsphere-pool")
d.HostIP = flags.String("vmwarevsphere-compute-ip")
d.SwarmMaster = flags.Bool("swarm-master")
d.SwarmHost = flags.String("swarm-host")
d.SwarmDiscovery = flags.String("swarm-discovery")
d.ISO = d.ResolveStorePath(isoFilename)
return nil
}
// SetConfigFromFlags assigns and verifies the command-line arguments presented to the driver.
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.AuthUrl = authUrl
d.Username = flags.String("ovh-username")
d.Password = flags.String("ovh-password")
d.TenantId = flags.String("ovh-tenant-id")
d.TenantName = flags.String("ovh-tenant-name")
d.Region = flags.String("ovh-region")
d.FlavorName = flags.String("ovh-flavor")
d.ImageName = imageName
d.SSHUser = SSHUser
d.IpVersion = 4
d.NetworkName = networkName
if flags.String("ovh-sec-groups") != "" {
d.SecurityGroups = strings.Split(flags.String("ovh-sec-groups"), ",")
}
d.SwarmMaster = flags.Bool("swarm-master")
d.SwarmHost = flags.String("swarm-host")
d.SwarmDiscovery = flags.String("swarm-discovery")
if d.Username == "" {
return missingEnvOrOption("Username", "OS_USERNAME", "--ovh-username")
}
if d.Username == "" {
return missingEnvOrOption("Password", "OS_PASSWORD", "--ovh-password")
}
if d.Username == "" {
return missingEnvOrOption("Project name", "OS_TENANT_NAME", "--ovh-tenant_name")
}
if d.Username == "" {
return missingEnvOrOption("Project ID", "OS_TENANT_ID", "--ovh-tenant-id")
}
return nil
}
// SetConfigFromFlags assigns and verifies the command-line arguments presented to the driver.
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.Username = flags.String("rackspace-username")
d.APIKey = flags.String("rackspace-api-key")
d.Region = flags.String("rackspace-region")
d.EndpointType = flags.String("rackspace-endpoint-type")
d.ImageId = flags.String("rackspace-image-id")
d.FlavorId = flags.String("rackspace-flavor-id")
d.SSHUser = flags.String("rackspace-ssh-user")
d.SSHPort = flags.Int("rackspace-ssh-port")
d.SwarmMaster = flags.Bool("swarm-master")
d.SwarmHost = flags.String("swarm-host")
d.SwarmDiscovery = flags.String("swarm-discovery")
if d.Region == "" {
return missingEnvOrOption("Region", "OS_REGION_NAME", "--rackspace-region")
}
if d.Username == "" {
return missingEnvOrOption("Username", "OS_USERNAME", "--rackspace-username")
}
if d.APIKey == "" {
return missingEnvOrOption("API key", "OS_API_KEY", "--rackspace-api-key")
}
if d.ImageId == "" {
// Default to the Ubuntu 14.04 image.
// This is done here, rather than in the option registration, to keep the default value
// from making "machine create --help" ugly.
d.ImageId = "598a4282-f14b-4e50-af4c-b3e52749d9f9"
}
if d.EndpointType != "publicURL" && d.EndpointType != "adminURL" && d.EndpointType != "internalURL" {
return fmt.Errorf(`Invalid endpoint type "%s". Endpoint type must be publicURL, adminURL or internalURL.`, d.EndpointType)
}
return nil
}
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.CPU = flags.Int("virtualbox-cpu-count")
d.Memory = flags.Int("virtualbox-memory")
d.DiskSize = flags.Int("virtualbox-disk-size")
d.Boot2DockerURL = flags.String("virtualbox-boot2docker-url")
d.SetSwarmConfigFromFlags(flags)
d.SSHUser = "******"
d.Boot2DockerImportVM = flags.String("virtualbox-import-boot2docker-vm")
d.HostDNSResolver = flags.Bool("virtualbox-host-dns-resolver")
d.HostOnlyCIDR = flags.String("virtualbox-hostonly-cidr")
d.HostOnlyNicType = flags.String("virtualbox-hostonly-nictype")
d.HostOnlyPromiscMode = flags.String("virtualbox-hostonly-nicpromisc")
d.NoShare = flags.Bool("virtualbox-no-share")
d.DNSProxy = flags.Bool("virtualbox-dns-proxy")
d.NoVTXCheck = flags.Bool("virtualbox-no-vtx-check")
return nil
}