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.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
}
// 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},
{&d.StorageType, flAzureStorageType},
}
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)
d.DNSLabel = fl.String(flAzureDNSLabel)
d.CustomDataFile = fl.String(flAzureCustomData)
d.ClientID = fl.String(flAzureClientID)
d.ClientSecret = fl.String(flAzureClientSecret)
// 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.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()
}
// 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.StringSlice("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
}
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.Endpoint = flags.String("amazonec2-endpoint")
region, err := validateAwsRegion(flags.String("amazonec2-region"))
if err != nil && d.Endpoint == "" {
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.BlockDurationMinutes = int64(flags.Int("amazonec2-block-duration-minutes"))
d.InstanceType = flags.String("amazonec2-instance-type")
d.VpcId = flags.String("amazonec2-vpc-id")
d.SubnetId = flags.String("amazonec2-subnet-id")
d.SecurityGroupNames = flags.StringSlice("amazonec2-security-group")
d.Tags = flags.String("amazonec2-tags")
zone := flags.String("amazonec2-zone")
d.Zone = zone[:]
d.DeviceName = flags.String("amazonec2-device-name")
d.RootSize = int64(flags.Int("amazonec2-root-size"))
d.VolumeType = flags.String("amazonec2-volume-type")
d.IamInstanceProfile = flags.String("amazonec2-iam-instance-profile")
d.SSHUser = flags.String("amazonec2-ssh-user")
d.SSHPort = 22
d.PrivateIPOnly = flags.Bool("amazonec2-private-address-only")
d.UsePrivateIP = flags.Bool("amazonec2-use-private-address")
d.Monitoring = flags.Bool("amazonec2-monitoring")
d.UseEbsOptimizedInstance = flags.Bool("amazonec2-use-ebs-optimized-instance")
d.SSHPrivateKeyPath = flags.String("amazonec2-ssh-keypath")
d.KeyName = flags.String("amazonec2-keypair-name")
d.ExistingKey = flags.String("amazonec2-keypair-name") != ""
d.SetSwarmConfigFromFlags(flags)
d.RetryCount = flags.Int("amazonec2-retries")
d.OpenPorts = flags.StringSlice("amazonec2-open-port")
d.DisableSSL = flags.Bool("amazonec2-insecure-transport")
if d.DisableSSL && d.Endpoint == "" {
return errorDisableSSLWithoutCustomEndpoint
}
if d.KeyName != "" && d.SSHPrivateKeyPath == "" {
return errorNoPrivateSSHKey
}
if d.AccessKey == "" && d.SecretKey == "" {
credentials, err := d.awsCredentials.NewSharedCredentials("", "").Get()
if err != nil {
log.Debug("Could not load credentials from ~/.aws/credentials")
} else {
log.Debug("Successfully loaded credentials from ~/.aws/credentials")
d.AccessKey = credentials.AccessKeyID
d.SecretKey = credentials.SecretAccessKey
d.SessionToken = credentials.SessionToken
}
}
if d.AccessKey == "" {
return errorMissingAccessKeyOption
}
if d.SecretKey == "" {
return errorMissingSecretKeyOption
}
if d.VpcId == "" {
d.VpcId, err = d.getDefaultVPCId()
if err != nil {
log.Warnf("Couldn't determine your account Default VPC ID : %q", err)
}
}
if d.SubnetId == "" && d.VpcId == "" {
return errorNoVPCIdFound
}
if d.SubnetId != "" && d.VpcId != "" {
subnetFilter := []*ec2.Filter{
{
Name: aws.String("subnet-id"),
Values: []*string{&d.SubnetId},
},
}
subnets, err := d.getClient().DescribeSubnets(&ec2.DescribeSubnetsInput{
Filters: subnetFilter,
})
if err != nil {
return err
}
if *subnets.Subnets[0].VpcId != d.VpcId {
return fmt.Errorf("SubnetId: %s does not belong to VpcId: %s", d.SubnetId, d.VpcId)
}
}
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
}
// SetConfigFromFlags configures the driver with the object that was returned
// by RegisterCreateFlags
func (d *Driver) SetConfigFromFlags(flags drivers.DriverOptions) error {
d.ApiURL = flags.String("cloudstack-api-url")
d.ApiKey = flags.String("cloudstack-api-key")
d.SecretKey = flags.String("cloudstack-secret-key")
d.UsePrivateIP = flags.Bool("cloudstack-use-private-address")
d.UsePortForward = flags.Bool("cloudstack-use-port-forward")
d.HTTPGETOnly = flags.Bool("cloudstack-http-get-only")
d.JobTimeOut = int64(flags.Int("cloudstack-timeout"))
d.SSHUser = flags.String("cloudstack-ssh-user")
d.CIDRList = flags.StringSlice("cloudstack-cidr")
d.Expunge = flags.Bool("cloudstack-expunge")
if err := d.setZone(flags.String("cloudstack-zone")); err != nil {
return err
}
if err := d.setTemplate(flags.String("cloudstack-template")); err != nil {
return err
}
if err := d.setServiceOffering(flags.String("cloudstack-service-offering")); err != nil {
return err
}
if err := d.setNetwork(flags.String("cloudstack-network")); err != nil {
return err
}
if err := d.setPublicIP(flags.String("cloudstack-public-ip")); err != nil {
return err
}
if err := d.setUserData(flags.String("cloudstack-userdata-file")); err != nil {
return err
}
d.SwarmMaster = flags.Bool("swarm-master")
d.SwarmDiscovery = flags.String("swarm-discovery")
d.SSHKeyPair = d.MachineName
if d.ApiURL == "" {
return &configError{option: "api-url"}
}
if d.ApiKey == "" {
return &configError{option: "api-key"}
}
if d.SecretKey == "" {
return &configError{option: "secret-key"}
}
if d.Template == "" {
return &configError{option: "template"}
}
if d.ServiceOffering == "" {
return &configError{option: "service-offering"}
}
if d.Zone == "" {
return &configError{option: "zone"}
}
if len(d.CIDRList) == 0 {
d.CIDRList = []string{"0.0.0.0/0"}
}
d.DisassociatePublicIP = false
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-id")
d.SecretKey = flags.String("aliyunecs-access-key-secret")
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")
d.Zone = flags.String("aliyunecs-zone")
d.SwarmMaster = flags.Bool("swarm-master")
d.SwarmHost = flags.String("swarm-host")
d.SwarmDiscovery = flags.String("swarm-discovery")
d.SSHUser = defaultSSHUser
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")
d.SLBID = flags.String("aliyunecs-slb-id")
d.DiskSize = flags.Int("aliyunecs-disk-size")
d.DiskCategory = ecs.DiskCategory(flags.String("aliyunecs-disk-category"))
tags := flags.StringSlice("aliyunecs-tag")
d.UpgradeKernel = flags.Bool("aliyunecs-upgrade-kernel")
tagMap := make(map[string]string)
if len(tags) > 0 {
for _, tag := range tags {
s := strings.Split(tag, "=")
if len(s) != 2 {
log.Infof("%s | Invalid tag for --aliyunecs-tag", tag)
return fmt.Errorf("%s | Invalid tag for --aliyunecs-tag", tag)
}
k := strings.TrimSpace(s[0])
v := strings.TrimSpace(s[1])
tagMap[k] = v
}
}
if len(tagMap) > 0 {
d.Tags = tagMap
}
if d.RouteCIDR != "" {
_, _, err := net.ParseCIDR(d.RouteCIDR)
if err != nil {
return fmt.Errorf("%s | Invalid CIDR value for --aliyunecs-route-cidr", d.MachineName)
}
}
//TODO support PayByTraffic
if d.InternetMaxBandwidthOut < 0 || d.InternetMaxBandwidthOut > 100 {
return fmt.Errorf("%s | aliyunecs driver --aliyunecs-internet-max-bandwidth: The value should be in 1 ~ 100", d.MachineName)
}
if d.InternetMaxBandwidthOut == 0 {
d.InternetMaxBandwidthOut = 1
}
if d.AccessKey == "" {
return fmt.Errorf("%s | aliyunecs driver requires the --aliyunecs-access-key-id option", d.MachineName)
}
if d.SecretKey == "" {
return fmt.Errorf("%s | aliyunecs driver requires the --aliyunecs-access-key-secret option", d.MachineName)
}
//VpcId and VSwitchId are optional or required together
if (d.VpcId == "" && d.VSwitchId != "") || (d.VpcId != "" && d.VSwitchId == "") {
return fmt.Errorf("%s | aliyunecs driver requires both the --aliyunecs-vpc-id and --aliyunecs-vswitch-id for Virtual Private Cloud", d.MachineName)
}
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
}