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 }