func (c *ImportClusterCmd) Run() error {
if c.Region == "" {
return fmt.Errorf("--region is required")
}
clusterName := rootCommand.clusterName
if clusterName == "" {
return fmt.Errorf("--name is required")
}
tags := map[string]string{"KubernetesCluster": clusterName}
cloud, err := awsup.NewAWSCloud(c.Region, tags)
if err != nil {
return fmt.Errorf("error initializing AWS client: %v", err)
}
stateStore, err := rootCommand.StateStore()
if err != nil {
return fmt.Errorf("error state store: %v", err)
}
d := &kutil.ImportCluster{}
d.ClusterName = clusterName
d.Cloud = cloud
d.StateStore = stateStore
err = d.ImportAWSCluster()
if err != nil {
return err
}
fmt.Printf("\nImported settings for cluster %q\n", clusterName)
return nil
}
func (c *RollingUpdateClusterCmd) Run() error {
if c.Region == "" {
return fmt.Errorf("--region is required")
}
clusterName := rootCommand.clusterName
if clusterName == "" {
return fmt.Errorf("--name is required")
}
tags := map[string]string{"KubernetesCluster": clusterName}
cloud, err := awsup.NewAWSCloud(c.Region, tags)
if err != nil {
return fmt.Errorf("error initializing AWS client: %v", err)
}
d := &kutil.RollingUpdateCluster{}
d.ClusterName = clusterName
d.Region = c.Region
d.Cloud = cloud
nodesets, err := d.ListNodesets()
if err != nil {
return err
}
err = c.printNodesets(nodesets)
if err != nil {
return err
}
if !c.Yes {
return fmt.Errorf("Must specify --yes to rolling-update")
}
return d.RollingUpdateNodesets(nodesets)
}
func BuildCloud(cluster *api.Cluster) (fi.Cloud, error) {
var cloud fi.Cloud
region := ""
project := ""
switch cluster.Spec.CloudProvider {
case "gce":
{
nodeZones := make(map[string]bool)
for _, zone := range cluster.Spec.Zones {
nodeZones[zone.Name] = true
tokens := strings.Split(zone.Name, "-")
if len(tokens) <= 2 {
return nil, fmt.Errorf("Invalid GCE Zone: %v", zone.Name)
}
zoneRegion := tokens[0] + "-" + tokens[1]
if region != "" && zoneRegion != region {
return nil, fmt.Errorf("Clusters cannot span multiple regions")
}
region = zoneRegion
}
project = cluster.Spec.Project
if project == "" {
return nil, fmt.Errorf("project is required for GCE")
}
gceCloud, err := gce.NewGCECloud(region, project)
if err != nil {
return nil, err
}
cloud = gceCloud
}
case "aws":
{
nodeZones := make(map[string]bool)
for _, zone := range cluster.Spec.Zones {
if len(zone.Name) <= 2 {
return nil, fmt.Errorf("Invalid AWS zone: %q", zone.Name)
}
nodeZones[zone.Name] = true
zoneRegion := zone.Name[:len(zone.Name)-1]
if region != "" && zoneRegion != region {
return nil, fmt.Errorf("Clusters cannot span multiple regions")
}
region = zoneRegion
}
err := awsup.ValidateRegion(region)
if err != nil {
return nil, err
}
cloudTags := map[string]string{awsup.TagClusterName: cluster.Name}
awsCloud, err := awsup.NewAWSCloud(region, cloudTags)
if err != nil {
return nil, err
}
var zoneNames []string
for _, z := range cluster.Spec.Zones {
zoneNames = append(zoneNames, z.Name)
}
err = awsCloud.ValidateZones(zoneNames)
if err != nil {
return nil, err
}
cloud = awsCloud
}
default:
return nil, fmt.Errorf("unknown CloudProvider %q", cluster.Spec.CloudProvider)
}
return cloud, nil
}
func (c *UpgradeClusterCmd) Run() error {
if c.NewClusterName == "" {
return fmt.Errorf("--newname is required")
}
oldStateStore, err := rootCommand.StateStore()
if err != nil {
return err
}
newStateStore, err := rootCommand.StateStoreForCluster(c.NewClusterName)
if err != nil {
return err
}
cluster, instanceGroups, err := api.ReadConfig(oldStateStore)
if err != nil {
return fmt.Errorf("error reading configuration: %v", err)
}
oldClusterName := cluster.Name
if oldClusterName == "" {
return fmt.Errorf("(Old) ClusterName must be set in configuration")
}
if len(cluster.Spec.Zones) == 0 {
return fmt.Errorf("Configuration must include Zones")
}
region := ""
for _, zone := range cluster.Spec.Zones {
if len(zone.Name) <= 2 {
return fmt.Errorf("Invalid AWS zone: %q", zone.Name)
}
zoneRegion := zone.Name[:len(zone.Name)-1]
if region != "" && zoneRegion != region {
return fmt.Errorf("Clusters cannot span multiple regions")
}
region = zoneRegion
}
tags := map[string]string{"KubernetesCluster": oldClusterName}
cloud, err := awsup.NewAWSCloud(region, tags)
if err != nil {
return fmt.Errorf("error initializing AWS client: %v", err)
}
d := &kutil.UpgradeCluster{}
d.NewClusterName = c.NewClusterName
d.OldClusterName = oldClusterName
d.Cloud = cloud
d.ClusterConfig = cluster
d.InstanceGroups = instanceGroups
d.OldStateStore = oldStateStore
d.NewStateStore = newStateStore
err = d.Upgrade()
if err != nil {
return err
}
return nil
}
func (c *DeleteClusterCmd) Run() error {
var stateStore fi.StateStore
var err error
var cloud fi.Cloud
clusterName := ""
region := ""
if c.External {
region = c.Region
if region == "" {
return fmt.Errorf("--region is required")
}
clusterName := rootCommand.clusterName
if clusterName == "" {
return fmt.Errorf("--name is required (when --external)")
}
tags := map[string]string{"KubernetesCluster": clusterName}
cloud, err = awsup.NewAWSCloud(c.Region, tags)
if err != nil {
return fmt.Errorf("error initializing AWS client: %v", err)
}
} else {
stateStore, err = rootCommand.StateStore()
if err != nil {
return err
}
cluster, _, err := api.ReadConfig(stateStore)
if err != nil {
return err
}
if rootCommand.clusterName != cluster.Name {
return fmt.Errorf("sanity check failed: cluster name mismatch")
}
clusterName = cluster.Name
cloud, err = cloudup.BuildCloud(cluster)
if err != nil {
return err
}
}
d := &kutil.DeleteCluster{}
d.ClusterName = clusterName
d.Region = region
d.Cloud = cloud
resources, err := d.ListResources()
if err != nil {
return err
}
if len(resources) == 0 {
fmt.Printf("Nothing to delete\n")
} else {
columns := []string{"TYPE", "ID", "NAME"}
fields := []string{"Type", "ID", "Name"}
var b bytes.Buffer
w := new(tabwriter.Writer)
// Format in tab-separated columns with a tab stop of 8.
w.Init(os.Stdout, 0, 8, 0, '\t', tabwriter.StripEscape)
writeHeader := true
if writeHeader {
for i, c := range columns {
if i != 0 {
b.WriteByte('\t')
}
b.WriteByte(tabwriter.Escape)
b.WriteString(c)
b.WriteByte(tabwriter.Escape)
}
b.WriteByte('\n')
_, err := w.Write(b.Bytes())
if err != nil {
return fmt.Errorf("error writing to output: %v", err)
}
b.Reset()
}
for _, t := range resources {
for i := range columns {
if i != 0 {
b.WriteByte('\t')
}
v := reflect.ValueOf(t)
if v.Kind() == reflect.Ptr {
v = v.Elem()
}
fv := v.FieldByName(fields[i])
s := fi.ValueAsString(fv)
b.WriteByte(tabwriter.Escape)
b.WriteString(s)
b.WriteByte(tabwriter.Escape)
}
b.WriteByte('\n')
_, err := w.Write(b.Bytes())
if err != nil {
return fmt.Errorf("error writing to output: %v", err)
}
b.Reset()
}
w.Flush()
if !c.Yes {
return fmt.Errorf("Must specify --yes to delete")
}
err := d.DeleteResources(resources)
if err != nil {
return err
}
}
if stateStore != nil {
if !c.Yes {
return fmt.Errorf("Must specify --yes to delete")
}
err := api.DeleteConfig(stateStore)
if err != nil {
return fmt.Errorf("error removing cluster from state store: %v", err)
}
}
fmt.Printf("\nCluster deleted\n")
return nil
}
