func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
url := flags.String("url")
if url == "" {
return fmt.Errorf("--url option is required when no driver is selected")
}
validatedUrl, err := api.ValidateHost(url)
if err != nil {
return err
}
d.URL = validatedUrl
return nil
}
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
url := flags.String("url")
if url == "" {
return fmt.Errorf("--url option is required when no driver is selected")
}
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 {
// this is generate from host range outside driver
d.Host = flags.String("aiyara-host-ip")
d.SSHUser = flags.String("aiyara-ssh-user")
d.sshPasswd = flags.String("aiyara-ssh-passwd")
d.SSHPort = flags.Int("aiyara-ssh-port")
return nil
}
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.AccessToken = flags.String("digitalocean-access-token")
d.Image = flags.String("digitalocean-image")
d.Region = flags.String("digitalocean-region")
d.Size = flags.String("digitalocean-size")
if d.AccessToken == "" {
return fmt.Errorf("digitalocean driver requires the --digitalocean-access-token option")
}
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 fmt.Errorf("generic driver requires the --generic-ip-address option")
}
if d.SSHKey == "" {
return fmt.Errorf("generic driver requires the --generic-ssh-key option")
}
return nil
}
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.IPAddress = flags.String("hetzner-ip-address")
d.Login = flags.String("hetzner-login")
d.Password = flags.String("hetzner-password")
if d.IPAddress == "" {
return fmt.Errorf("hetzner driver requires the --hetzner-ip-address option")
}
if d.Login == "" {
return fmt.Errorf("hetzner driver requires the --hetzner-login option")
}
if d.Password == "" {
return fmt.Errorf("hetzner driver requires the --hetzner-password option")
}
return nil
}
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.Memory = flags.Int("virtualbox-memory")
d.DiskSize = flags.Int("virtualbox-disk-size")
d.Boot2DockerURL = flags.String("virtualbox-boot2docker-url")
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")
imgPath := utils.GetMachineCacheDir()
commonIsoPath := filepath.Join(imgPath, isoFilename)
d.ISO = path.Join(commonIsoPath)
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.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
}
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.NoShare = flags.Bool("virtualbox-no-share")
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.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
}
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 = "******"
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 > 16 {
d.CPU = 16
}
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("digitalocean-access-token")
d.Image = flags.String("digitalocean-image")
d.Region = flags.String("digitalocean-region")
d.Size = flags.String("digitalocean-size")
d.IPv6 = flags.Bool("digitalocean-ipv6")
d.PrivateNetworking = flags.Bool("digitalocean-private-networking")
d.Backups = flags.Bool("digitalocean-backups")
d.SwarmMaster = flags.Bool("swarm-master")
d.SwarmHost = flags.String("swarm-host")
d.SwarmDiscovery = flags.String("swarm-discovery")
d.SSHUser = flags.String("digitalocean-ssh-user")
d.SSHPort = 22
if d.AccessToken == "" {
return fmt.Errorf("digitalocean driver requires the --digitalocean-access-token option")
}
return nil
}
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.AccessKeyId = flags.String("aliyun-access-key-id")
d.AccessKeySecret = flags.String("aliyun-access-key-secret")
d.RegionId = flags.String("aliyun-region-id")
d.SecurityGroupId = flags.String("aliyun-security-group-id")
d.ImageId = flags.String("aliyun-image-id")
d.InstanceTypeId = flags.String("aliyun-instance-type-id")
d.SSHPass = flags.String("aliyun-ssh-pass")
d.BandwidthOut = flags.String("aliyun-bandwidth-out")
d.DockerArgs = flags.String("aliyun-docker-args")
d.InsecureRegistry = flags.String("aliyun-docker-registry")
d.SwarmMaster = flags.Bool("swarm-master")
d.SwarmHost = flags.String("swarm-host")
d.SwarmDiscovery = flags.String("swarm-discovery")
d.SSHUser = "******"
d.SSHPort = 22
if d.AccessKeyId == "" {
return fmt.Errorf("aliyun driver requires the --aliyun-access-key-id option")
}
if d.AccessKeySecret == "" {
return fmt.Errorf("aliyun driver requires the --aliyun-access-key-secret option")
}
if d.RegionId == "" {
return fmt.Errorf("aliyun driver requires the --aliyun-region-id option")
}
return nil
}
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.AccessKey = flags.String("amazonec2-access-key")
d.SecretKey = flags.String("amazonec2-secret-key")
d.AMI = flags.String("amazonec2-ami")
d.Region = flags.String("amazonec2-region")
d.InstanceType = flags.String("amazonec2-instance-type")
d.VpcId = flags.String("amazonec2-vpc-id")
d.SubnetId = flags.String("amazonec2-subnet-id")
zone := flags.String("amazonec2-zone")
d.Zone = zone[:]
d.RootSize = int64(flags.Int("amazonec2-root-size"))
if d.AccessKey == "" {
return fmt.Errorf("amazonec2 driver requires the --amazonec2-access-key option")
}
if d.SecretKey == "" {
return fmt.Errorf("amazonec2 driver requires the --amazonec2-secret-key option")
}
if d.SubnetId == "" && d.VpcId == "" {
return fmt.Errorf("amazonec2 driver requires either the --amazonec2-subnet-id or --amazonec2-vpc-id option")
}
return nil
}
func (driver *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
driver.SubscriptionID = flags.String("azure-subscription-id")
cert := flags.String("azure-subscription-cert")
publishSettings := flags.String("azure-publish-settings-file")
name := flags.String("azure-name")
image := flags.String("azure-image")
username := flags.String("azure-username")
if cert != "" {
if _, err := os.Stat(cert); os.IsNotExist(err) {
return err
}
driver.SubscriptionCert = cert
}
if publishSettings != "" {
if _, err := os.Stat(publishSettings); os.IsNotExist(err) {
return err
}
driver.PublishSettingsFilePath = publishSettings
}
if (driver.SubscriptionID == "" || driver.SubscriptionCert == "") && driver.PublishSettingsFilePath == "" {
return fmt.Errorf("Please specify azure subscription params using options: --azure-subscription-id and --azure-subscription-cert or --azure-publish-settings-file")
}
if name == "" {
driver.Name = generateVMName()
} else {
driver.Name = name
}
if image == "" {
driver.Image = "b39f27a8b8c64d52b05eac6a62ebad85__Ubuntu-14_04_1-LTS-amd64-server-20140927-en-us-30GB"
} else {
driver.Image = image
}
driver.Location = flags.String("azure-location")
driver.Size = flags.String("azure-size")
if strings.ToLower(username) == "docker" {
return fmt.Errorf("'docker' is not valid user name for docker host. Please specify another user name")
}
driver.UserName = username
driver.UserPassword = flags.String("azure-password")
driver.DockerPort = flags.Int("azure-docker-port")
driver.SSHPort = flags.Int("azure-ssh-port")
return nil
}
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.Client = &Client{
Endpoint: flags.String("softlayer-api-endpoint"),
User: flags.String("softlayer-user"),
ApiKey: flags.String("softlayer-api-key"),
}
d.SwarmMaster = flags.Bool("swarm-master")
d.SwarmHost = flags.String("swarm-host")
d.SwarmDiscovery = flags.String("swarm-discovery")
d.SSHUser = "******"
d.SSHPort = 22
if err := validateClientConfig(d.Client); err != nil {
return err
}
d.deviceConfig = &deviceConfig{
Hostname: flags.String("softlayer-hostname"),
DiskSize: flags.Int("softlayer-disk-size"),
Cpu: flags.Int("softlayer-cpu"),
Domain: flags.String("softlayer-domain"),
Memory: flags.Int("softlayer-memory"),
PrivateNet: flags.Bool("softlayer-private-net-only"),
LocalDisk: flags.Bool("softlayer-local-disk"),
HourlyBilling: flags.Bool("softlayer-hourly-billing"),
Image: flags.String("softlayer-image"),
Region: flags.String("softlayer-region"),
PublicVLAN: flags.Int("softlayer-public-vlan-id"),
PrivateVLAN: flags.Int("softlayer-private-vlan-id"),
}
if d.deviceConfig.Hostname == "" {
d.deviceConfig.Hostname = d.GetMachineName()
}
return validateDeviceConfig(d.deviceConfig)
}
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 {
d.AuthUrl = flags.String("openstack-auth-url")
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.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 {
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 {
region, err := validateAwsRegion(flags.String("amazonec2-region"))
if err != nil {
return err
}
image := flags.String("amazonec2-ami")
if len(image) == 0 {
image = regionDetails[region].AmiId
}
d.AccessKey = flags.String("amazonec2-access-key")
d.SecretKey = flags.String("amazonec2-secret-key")
d.SessionToken = flags.String("amazonec2-session-token")
d.Region = region
d.AMI = image
d.RequestSpotInstance = flags.Bool("amazonec2-request-spot-instance")
d.SpotPrice = flags.String("amazonec2-spot-price")
d.InstanceType = flags.String("amazonec2-instance-type")
d.VpcId = flags.String("amazonec2-vpc-id")
d.SubnetId = flags.String("amazonec2-subnet-id")
d.SecurityGroupName = flags.String("amazonec2-security-group")
zone := flags.String("amazonec2-zone")
d.Zone = zone[:]
d.RootSize = int64(flags.Int("amazonec2-root-size"))
d.IamInstanceProfile = flags.String("amazonec2-iam-instance-profile")
d.SwarmMaster = flags.Bool("swarm-master")
d.SwarmHost = flags.String("swarm-host")
d.SwarmDiscovery = flags.String("swarm-discovery")
d.SSHUser = flags.String("amazonec2-ssh-user")
d.SSHPort = 22
d.PrivateIPOnly = flags.Bool("amazonec2-private-address-only")
d.Monitoring = flags.Bool("amazonec2-monitoring")
if d.AccessKey == "" {
return fmt.Errorf("amazonec2 driver requires the --amazonec2-access-key option")
}
if d.SecretKey == "" {
return fmt.Errorf("amazonec2 driver requires the --amazonec2-secret-key option")
}
if d.SubnetId == "" && d.VpcId == "" {
return fmt.Errorf("amazonec2 driver requires either the --amazonec2-subnet-id or --amazonec2-vpc-id option")
}
if d.isSwarmMaster() {
u, err := url.Parse(d.SwarmHost)
if err != nil {
return fmt.Errorf("error parsing swarm host: %s", err)
}
parts := strings.Split(u.Host, ":")
port, err := strconv.Atoi(parts[1])
if err != nil {
return err
}
swarmPort = port
}
return nil
}
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
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 = "******"
return nil
}
// SetConfigFromFlags initializes the driver based on the command line flags.
func (driver *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
driver.ServiceOffering = flags.String("clm-ServiceOffering")
driver.ServiceName = flags.String("clm-ServiceName")
driver.TenantName = flags.String("clm-TenantName")
driver.UserName = flags.String("clm-UserName")
driver.UserPassword = flags.String("clm-UserPassword")
driver.ServiceOfferingGUID = flags.String("clm-ServiceOfferingGUID")
driver.ServiceOfferingREID = flags.String("clm-ServiceOfferingREID")
driver.ClmUserName = flags.String("clm-ClmUserName")
driver.ClmUserPassword = flags.String("clm-ClmUserPassword")
driver.ClmURL = flags.String("clm-ClmURL")
driver.HostNamePrefix = flags.String("clm-HostNamePrefix")
driver.Quantity = flags.Int("clm-Quantity")
driver.InstanceName = flags.String("google-instance-name")
driver.Zone = flags.String("google-zone")
driver.MachineType = flags.String("google-machine-type")
driver.Project = flags.String("google-project")
return nil
}
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
region, err := validateECSRegion(flags.String("aliyunecs-region"))
if err != nil {
return err
}
d.AccessKey = flags.String("aliyunecs-access-key")
d.SecretKey = flags.String("aliyunecs-secret-key")
d.Region = region
d.ImageID = flags.String("aliyunecs-image-id")
d.InstanceType = flags.String("aliyunecs-instance-type")
d.VpcId = flags.String("aliyunecs-vpc-id")
d.VSwitchId = flags.String("aliyunecs-vswitch-id")
d.SecurityGroupName = flags.String("aliyunecs-security-group")
zone := flags.String("aliyunecs-zone")
d.Zone = zone[:]
d.SwarmMaster = flags.Bool("swarm-master")
d.SwarmHost = flags.String("swarm-host")
d.SwarmDiscovery = flags.String("swarm-discovery")
d.SSHUser = "******" //TODO support non-root
d.SSHPassword = flags.String("aliyunecs-ssh-password")
d.SSHPort = 22
d.PrivateIPOnly = flags.Bool("aliyunecs-private-address-only")
d.InternetMaxBandwidthOut = flags.Int("aliyunecs-internet-max-bandwidth")
d.RouteCIDR = flags.String("aliyunecs-route-cidr")
if d.RouteCIDR != "" {
_, _, err := net.ParseCIDR(d.RouteCIDR)
if err != nil {
return fmt.Errorf("Invalid CIDR value for --aliyunecs-route-cidr")
}
}
//TODO support PayByTraffic
if d.InternetMaxBandwidthOut < 0 || d.InternetMaxBandwidthOut > 100 {
return fmt.Errorf("aliyunecs driver invalid --aliyunecs-internet-max-bandwidth the value should be in 1 ~ 100")
}
if d.InternetMaxBandwidthOut == 0 {
d.InternetMaxBandwidthOut = 1
}
if d.AccessKey == "" {
return fmt.Errorf("aliyunecs driver requires the --aliyunecs-access-key option")
}
if d.SecretKey == "" {
return fmt.Errorf("aliyunecs driver requires the --aliyunecs-secret-key option")
}
// VpcId is optional
if (d.VpcId == "" && d.VSwitchId != "") || (d.VpcId != "" && d.VSwitchId == "") {
return fmt.Errorf("aliyunecs driver requires both the --aliyunecs-vpc-id and --aliyunecs-vswitch-id for Virtual Private Cloud")
}
if d.isSwarmMaster() {
u, err := url.Parse(d.SwarmHost)
if err != nil {
return fmt.Errorf("error parsing swarm host: %s", err)
}
parts := strings.Split(u.Host, ":")
port, err := strconv.Atoi(parts[1])
if err != nil {
return err
}
swarmPort = port
}
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.ISO = d.ResolveStorePath(isoFilename)
d.SwarmMaster = flags.Bool("swarm-master")
d.SwarmHost = flags.String("swarm-host")
d.SwarmDiscovery = flags.String("swarm-discovery")
d.SSHUser = "******"
d.SSHPort = 22
// We support a maximum of 16 cpu to be consistent with Virtual Hardware 10
// specs.
if d.CPU > 16 {
d.CPU = 16
}
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(utils.GetMachineCacheDir(), isoFilename)
d.TAR = filepath.Join(utils.GetMachineCacheDir(), tarFilename)
return nil
}