func TestDefaultRegion(t *testing.T) {
exp := "foo"
m := db.Machine{Provider: "Amazon", Region: exp}
m = DefaultRegion(m)
if m.Region != exp {
t.Errorf("expected %s, found %s", exp, m.Region)
}
m.Region = ""
m = DefaultRegion(m)
exp = "us-west-1"
if m.Region != exp {
t.Errorf("expected %s, found %s", exp, m.Region)
}
m.Region = ""
m.Provider = "Google"
exp = "us-east1-b"
m = DefaultRegion(m)
if m.Region != exp {
t.Errorf("expected %s, found %s", exp, m.Region)
}
m.Region = ""
m.Provider = "Azure"
exp = "Central US"
m = DefaultRegion(m)
if m.Region != exp {
t.Errorf("expected %s, found %s", exp, m.Region)
}
m.Region = ""
m.Provider = "Vagrant"
exp = ""
m = DefaultRegion(m)
if m.Region != exp {
t.Errorf("expected %s, found %s", exp, m.Region)
}
m.Region = ""
m.Provider = "Panic"
defer func() {
if r := recover(); r == nil {
t.Error("Expected panic")
}
}()
m = DefaultRegion(m)
}
// DefaultRegion populates `m.Region` for the provided db.Machine if one isn't
// specified. This is intended to allow users to omit the cloud provider region when
// they don't particularly care where a system is placed.
func DefaultRegion(m db.Machine) db.Machine {
if m.Region != "" {
return m
}
switch m.Provider {
case db.Amazon:
m.Region = amazon.DefaultRegion
case db.Google:
m.Region = google.DefaultRegion
case db.Vagrant:
default:
panic(fmt.Sprintf("Unknown Cloud Provider: %s", m.Provider))
}
return m
}
// toDBMachine converts machines specified in the Stitch into db.Machines that can
// be compared against what's already in the db.
// Specifically, it sets the role of the db.Machine, the size (which may depend
// on RAM and CPU constraints), and the provider.
// Additionally, it skips machines with invalid roles, sizes or providers.
func toDBMachine(machines []stitch.Machine, maxPrice float64) []db.Machine {
var hasMaster, hasWorker bool
var dbMachines []db.Machine
for _, stitchm := range machines {
var m db.Machine
role, err := db.ParseRole(stitchm.Role)
if err != nil {
log.WithError(err).Error("Error parsing role.")
continue
}
m.Role = role
hasMaster = hasMaster || role == db.Master
hasWorker = hasWorker || role == db.Worker
p, err := db.ParseProvider(stitchm.Provider)
if err != nil {
log.WithError(err).Error("Error parsing provider.")
continue
}
m.Provider = p
m.Size = stitchm.Size
if m.Size == "" {
providerInst := provider.New(p)
m.Size = providerInst.ChooseSize(
stitchm.RAM, stitchm.CPU, maxPrice)
if m.Size == "" {
log.Errorf("No valid size for %v, skipping.", m)
continue
}
}
m.DiskSize = stitchm.DiskSize
if m.DiskSize == 0 {
m.DiskSize = defaultDiskSize
}
m.SSHKeys = stitchm.SSHKeys
m.Region = stitchm.Region
dbMachines = append(dbMachines, provider.DefaultRegion(m))
}
if !hasMaster && hasWorker {
log.Warning("A Master was specified but no workers.")
return nil
} else if hasMaster && !hasWorker {
log.Warning("A Worker was specified but no masters.")
return nil
}
return dbMachines
}
// DefaultRegion populates `m.Region` for the provided db.Machine if one isn't
// specified. This is intended to allow users to omit the cloud provider region when
// they don't particularly care where a system is placed.
func DefaultRegion(m db.Machine) db.Machine {
if m.Region != "" {
return m
}
region := ""
switch m.Provider {
case "Amazon":
region = "us-west-1"
case "Google":
region = "us-east1-b"
case "Azure":
region = "Central US"
case "Vagrant":
default:
panic(fmt.Sprintf("Unknown Cloud Provider: %s", m.Provider))
}
m.Region = region
return m
}