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
}
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.SSHUser = "******"
d.SetSwarmConfigFromFlags(flags)
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("hyper-v-boot2docker-url")
d.boot2DockerLoc = flags.String("hyper-v-boot2docker-location")
d.vSwitch = flags.String("hyper-v-virtual-switch")
d.DiskSize = flags.Int("hyper-v-disk-size")
d.MemSize = flags.Int("hyper-v-memory")
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 {
if drivers.EngineInstallURLFlagSet(flags) {
return errors.New("--engine-install-url cannot be used with the hyperv driver, use --hyperv-boot2docker-url instead")
}
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.SSHUser = "******"
d.SetSwarmConfigFromFlags(flags)
return nil
}
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
url := flags.String("url")
if url == "" {
return fmt.Errorf("--url option is required")
}
d.URL = url
u, err := neturl.Parse(url)
if err != nil {
return err
}
d.IPAddress = u.Host
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
}
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.ClientID = flags.Int("ubiquity-client-id")
d.Username = flags.String("ubiquity-api-username")
d.Token = flags.String("ubiquity-api-token")
d.ZoneID = flags.Int("ubiquity-zone-id")
d.FlavorID = flags.Int("ubiquity-flavor-id")
d.ImageID = flags.Int("ubiquity-image-id")
if d.ClientID <= 0 {
return fmt.Errorf("ubiquity driver requires the --ubiquity-client-id option")
}
if d.Username == "" {
return fmt.Errorf("ubiquity driver requires the --ubiquity-api-username option")
}
if d.Token == "" {
return fmt.Errorf("ubiquity driver requires the --ubiquity-api-token option")
}
return nil
}
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.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-no-dns-proxy")
d.NoVTXCheck = flags.Bool("virtualbox-no-vtx-check")
return nil
}
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.APIKey = flags.String("vultr-api-key")
d.OSID = flags.Int("vultr-os-id")
d.RegionID = flags.Int("vultr-region-id")
d.PlanID = flags.Int("vultr-plan-id")
d.ScriptID = flags.Int("vultr-pxe-script")
d.IPv6 = flags.Bool("vultr-ipv6")
d.PrivateNetworking = flags.Bool("vultr-private-networking")
d.Backups = flags.Bool("vultr-backups")
d.UserDataFile = flags.String("vultr-userdata")
d.SwarmMaster = flags.Bool("swarm-master")
d.SwarmHost = flags.String("swarm-host")
d.SwarmDiscovery = flags.String("swarm-discovery")
d.SSHUser = flags.String("vultr-ssh-user")
d.SSHPort = 22
if d.APIKey == "" {
return fmt.Errorf("Vultr driver requires the --vultr-api-key option")
}
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(opts drivers.DriverOptions) error {
spew.Dump(opts)
d.DindImage = opts.String("dind-image")
d.DockerHost = opts.String("dind-host")
d.CertPath = opts.String("dind-cert-path")
return nil
}
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.UserID = flags.String("scaleway-user-id")
d.Token = flags.String("scaleway-token")
d.Organization = flags.String("scaleway-organization")
d.Image = flags.String("scaleway-image")
d.Volumes = flags.String("scaleway-volumes")
d.SSHUser = "******"
d.SSHPort = 22
if d.UserID == "" {
return fmt.Errorf("scaleway driver requires the --scaleway-userid option")
}
if d.Token == "" {
return fmt.Errorf("scaleway driver requires the --scaleway-token option")
}
if d.Organization == "" {
return fmt.Errorf("scaleway driver requires the --scaleway-organization option")
}
if d.Image == "" {
return fmt.Errorf("scaleway driver requires the --scaleway-image option")
}
return nil
}
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.Boot2DockerURL = flags.String("xhyve-boot2docker-url")
d.BootCmd = flags.String("xhyve-boot-cmd")
d.CPU = flags.Int("xhyve-cpu-count")
if d.CPU < 1 {
d.CPU = int(runtime.NumCPU())
}
d.DiskSize = int64(flags.Int("xhyve-disk-size"))
d.Memory = flags.Int("xhyve-memory-size")
d.NFSShare = flags.Bool("xhyve-experimental-nfs-share")
d.Qcow2 = flags.Bool("xhyve-qcow2")
d.SSHPort = 22
d.SSHUser = "******"
d.SwarmDiscovery = flags.String("swarm-discovery")
d.SwarmHost = flags.String("swarm-host")
d.SwarmMaster = flags.Bool("swarm-master")
d.UUID = flags.String("xhyve-uuid")
d.Virtio9p = flags.Bool("xhyve-virtio-9p")
d.Virtio9pFolder = "/Users"
return nil
}
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.ApiKey = flags.String("gandi-api-key")
d.Image = flags.String("gandi-image")
d.Datacenter = flags.String("gandi-datacenter")
d.Url = flags.String("gandi-url")
d.Memory = flags.Int("gandi-memory")
d.Core = flags.Int("gandi-core")
if d.ApiKey == "" {
return fmt.Errorf("gandi driver requires the -gandi-api-key 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.IPAddress = flags.String("generic-ip-address")
d.SSHUser = flags.String("generic-ssh-user")
d.SSHKey = flags.String("generic-ssh-key")
d.SSHPort = flags.Int("generic-ssh-port")
if d.IPAddress == "" {
return errors.New("generic driver requires the --generic-ip-address option")
}
return nil
}
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 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
}
// 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
}
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.IPAddress = flags.String("hypriot-ip-address")
d.SSHUser = flags.String("hypriot-ssh-user")
d.SSHKey = flags.String("hypriot-ssh-key")
d.SSHPort = flags.Int("hypriot-ssh-port")
if d.IPAddress == "" {
return fmt.Errorf("hypriot driver requires the --hypriot-ip-address option")
}
if d.SSHKey == "" {
return fmt.Errorf("hypriot driver requires the --hypriot-ssh-key option")
}
return nil
}
// SetConfigFromFlags initializes driver values from the command line values
// and checks if the arguments have values.
func (d *Driver) SetConfigFromFlags(fl drivers.DriverOptions) error {
// Initialize driver context for machine
d.ctx = &azureutil.DeploymentContext{}
// Required string flags
flags := []struct {
target *string
flag string
}{
{&d.BaseDriver.SSHUser, flAzureSSHUser},
{&d.SubscriptionID, flAzureSubscriptionID},
{&d.ResourceGroup, flAzureResourceGroup},
{&d.Location, flAzureLocation},
{&d.Size, flAzureSize},
{&d.Image, flAzureImage},
{&d.VirtualNetwork, flAzureVNet},
{&d.SubnetName, flAzureSubnet},
{&d.SubnetPrefix, flAzureSubnetPrefix},
{&d.AvailabilitySet, flAzureAvailabilitySet},
}
for _, f := range flags {
*f.target = fl.String(f.flag)
if *f.target == "" {
return requiredOptionError(f.flag)
}
}
// Optional flags or Flags of other types
d.Environment = fl.String(flAzureEnvironment)
d.OpenPorts = fl.StringSlice(flAzurePorts)
d.PrivateIPAddr = fl.String(flAzurePrivateIPAddr)
d.UsePrivateIP = fl.Bool(flAzureUsePrivateIP)
d.NoPublicIP = fl.Bool(flAzureNoPublicIP)
d.StaticPublicIP = fl.Bool(flAzureStaticPublicIP)
d.DockerPort = fl.Int(flAzureDockerPort)
// Set flags on the BaseDriver
d.BaseDriver.SSHPort = sshPort
d.SetSwarmConfigFromFlags(fl)
log.Debug("Set configuration from flags.")
return nil
}
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.APIKey = flags.String("linode-api-key")
d.DataCenterId = flags.Int("linode-datacenter-id")
d.PlanId = flags.Int("linode-plan-id")
d.PaymentTerm = flags.Int("linode-payment-term")
d.RootPassword = flags.String("linode-root-pass")
d.SSHPort = flags.Int("linode-ssh-port")
d.DistributionId = flags.Int("linode-distribution-id")
d.KernelId = flags.Int("linode-kernel-id")
d.LinodeLabel = flags.String("linode-label")
d.DockerPort = flags.Int("linode-docker-port")
if d.APIKey == "" {
return fmt.Errorf("linode driver requires the --linode-api-key option")
}
if d.RootPassword == "" {
return fmt.Errorf("linode driver requires the --linode-root-pass option")
}
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.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.URL = flags.String("exoscale-url")
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.SSHUser = flags.String("exoscale-ssh-user")
d.UserDataFile = flags.String("exoscale-userdata")
d.SetSwarmConfigFromFlags(flags)
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 {
if drivers.EngineInstallURLFlagSet(flags) {
return errors.New("--engine-install-url cannot be used with the vmwarevsphere driver, use --vmwarevsphere-boot2docker-url instead")
}
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.Port = flags.Int("vmwarevsphere-vcenter-port")
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.HostSystem = flags.String("vmwarevsphere-hostsystem")
d.SetSwarmConfigFromFlags(flags)
d.ISO = d.ResolveStorePath(isoFilename)
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.Port = flags.Int("vmwarevsphere-vcenter-port")
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.HostSystem = flags.String("vmwarevsphere-hostsystem")
d.SetSwarmConfigFromFlags(flags)
d.ISO = d.ResolveStorePath(isoFilename)
return nil
}