// DeleteSimpleDBDomains deletes one or more SimpleDB Domains
func DeleteSimpleDBDomains(search, region string) (err error) {
domainList := new(SimpleDBDomains)
// Check if we were given a region or not
if region != "" {
err = GetRegionSimpleDBDomains(aws.String(region), domainList, search)
} else {
domainList, _ = GetSimpleDBDomains(search)
}
if err != nil {
terminal.ErrorLine("Error gathering SimpleDB domains list")
return
}
if len(*domainList) > 0 {
// Print the table
domainList.PrintTable()
} else {
terminal.ErrorLine("No SimpleDB Domains found, Aborting!")
return
}
// Confirm
if !terminal.PromptBool("Are you sure you want to delete these SimpleDB Domains?") {
terminal.ErrorLine("Aborting!")
return
}
// Delete 'Em
for _, domain := range *domainList {
svc := simpledb.New(session.New(&aws.Config{Region: aws.String(domain.Region)}))
params := &simpledb.DeleteDomainInput{
DomainName: aws.String(domain.Name),
}
_, err = svc.DeleteDomain(params)
if err != nil {
terminal.ErrorLine("Error while deleting SimpleDB Domain [" + domain.Name + "] in [" + domain.Region + "], Aborting!")
return
}
terminal.Information("Deleted SimpleDB Domain [" + domain.Name + "] in [" + domain.Region + "]!")
}
terminal.Information("Done!")
return
}
// SaveKeyPairClass reads unmarshals a byte slice and inserts it into the db
func SaveKeyPairClass(className string, data []byte) (class KeyPairClass, err error) {
err = json.Unmarshal(data, &class)
if err != nil {
return
}
// Generate the keys if needed.
if class.PrivateKey1 == "" {
var publicKey, privateKey string
publicKey, privateKey, err = GenerateKeyPair(className)
if err != nil {
terminal.ErrorLine("Error while generating keypair class: " + className)
return
}
privateKeyLen := len(privateKey) / 4
class.PublicKey = publicKey
class.PrivateKey1 = privateKey[:privateKeyLen]
class.PrivateKey2 = privateKey[privateKeyLen : privateKeyLen*2]
class.PrivateKey3 = privateKey[privateKeyLen*2 : privateKeyLen*3]
class.PrivateKey4 = privateKey[privateKeyLen*3:]
}
err = Insert("keypairs", KeyPairClasses{className: class})
if err != nil {
println(err)
}
return
}
// DeleteKeyPairs deletes an existing KeyPair from AWS
func DeleteKeyPairs(name string, dryRun bool) error {
if dryRun {
terminal.Information("--dry-run flag is set, not making any actual changes!")
}
keyList, err := GetKeyPairs(name)
if err != nil {
terminal.ErrorLine("Error gathering KeyPair list")
return nil
}
if len(*keyList) > 0 {
// Print the table
keyList.PrintTable()
} else {
terminal.ErrorLine("No KeyPairs found, Aborting!")
return nil
}
// Confirm
if !terminal.PromptBool("Are you sure you want to delete these KeyPairs?") {
terminal.ErrorLine("Aborting!")
return nil
}
// Delete 'Em
for _, key := range *keyList {
svc := ec2.New(session.New(&aws.Config{Region: aws.String(key.Region)}))
params := &ec2.DeleteKeyPairInput{
KeyName: aws.String(key.KeyName),
DryRun: aws.Bool(dryRun),
}
_, err := svc.DeleteKeyPair(params)
if err != nil {
terminal.ErrorLine(err.Error())
} else {
terminal.Information("Deleted KeyPair [" + key.KeyName + "] in region [" + key.Region + "]!")
}
}
return nil
}
// DeleteIAMUsers deletes one or more IAM Users that match the provided username
func DeleteIAMUsers(username string) (err error) {
userList, err := GetIAMUsers(username)
if err != nil {
terminal.ErrorLine("Error gathering SimpleDB domains list")
return
}
if len(*userList) > 0 {
// Print the table
userList.PrintTable()
} else {
terminal.ErrorLine("No IAM Users found, Aborting!")
return
}
// Confirm
if !terminal.PromptBool("Are you sure you want to delete these IAM Users?") {
terminal.ErrorLine("Aborting!")
return
}
// Delete 'Em
for _, user := range *userList {
svc := iam.New(session.New())
params := &iam.DeleteUserInput{
UserName: aws.String(user.UserName),
}
_, err := svc.DeleteUser(params)
if err != nil {
terminal.ErrorLine("Error while deleting IAM User [" + user.UserName + "], Aborting!")
return err
}
terminal.Information("Deleted IAM User [" + user.UserName + "]!")
}
terminal.Information("Done!")
return
}
// private function without terminal prompts
func updateSecurityGroups(secGrpList *SecurityGroups, dryRun bool) error {
for _, secGrp := range *secGrpList {
// Verify the security group class input
cfg, err := config.LoadSecurityGroupClass(secGrp.Class)
if err != nil {
terminal.Information("Skipping Security Group [" + secGrp.Name + "]")
terminal.ErrorLine(err.Error())
continue
} else {
terminal.Information("Found Security Group class configuration for [" + secGrp.Class + "]")
}
// TODO
fmt.Println("\n\n")
fmt.Println("aws\n")
fmt.Println(secGrp.SecurityGroupGrants)
fmt.Println("awsm\n")
fmt.Println(cfg.SecurityGroupGrants)
fmt.Println("\n\n")
hash1, err := hashstructure.Hash(secGrp.SecurityGroupGrants, nil)
if err != nil {
panic(err)
}
fmt.Printf("\n\n%d\n\n", hash1)
hash2, err := hashstructure.Hash(cfg.SecurityGroupGrants, nil)
if err != nil {
panic(err)
}
fmt.Printf("\n\n%d\n\n", hash2)
}
return nil
}
// Main Function
////////////////..........
func main() {
// Check for Creds
found := aws.CheckCreds()
if !found {
return
}
// Check for the awsm db
if !config.CheckDB() {
create := terminal.BoxPromptBool("No awsm database found!", "Do you want to create one now?")
if !create {
terminal.Information("Ok then, maybe next time.. ")
return
}
err := config.CreateAwsmDatabase()
if err != nil {
terminal.ErrorLine(err.Error())
return
}
}
var dryRun bool
var force bool
var double bool // optional flag when updating an auto-scale group
app := cli.NewApp()
app.Name = "awsm"
app.Usage = "AWSM Interface"
app.Version = "1.0"
app.Author = "Ahmad A"
app.Email = "*****@*****.**"
app.EnableBashCompletion = true
app.Flags = []cli.Flag{
cli.BoolFlag{
Name: "dry-run",
Destination: &dryRun,
Usage: "dry-run (Don't make any real changes)",
},
}
app.Commands = []cli.Command{
{
Name: "api",
Usage: "Start the awsm api server",
Action: func(c *cli.Context) error {
api.StartAPI()
return nil
},
},
/*
{
Name: "dashboard",
Usage: "Launch the awsm Dashboard GUI",
Flags: []cli.Flag{
cli.BoolFlag{
Name: "dev-mode",
Destination: &dryRun,
Usage: "dev-mode (Don't reopen dashboard on each restart)",
},
},
Action: func(c *cli.Context) error {
aws.RunDashboard(c.Bool("dev-mode"))
return nil
},
},
*/
{
Name: "attachVolume",
Usage: "Attach an AWS EBS Volume to an EC2 Instance",
Arguments: []cli.Argument{
cli.Argument{
Name: "volume",
Description: "The volume to attach",
Optional: false,
},
cli.Argument{
Name: "instance",
Description: "The instance to attach the volume to",
Optional: false,
},
},
Action: func(c *cli.Context) error {
err := aws.AttachVolume(c.NamedArg("volume"), c.NamedArg("instance"), dryRun)
if err != nil {
terminal.ErrorLine(err.Error())
}
return nil
},
},
{
Name: "installKeyPair",
Usage: "Installs a Key Pair locally",
Arguments: []cli.Argument{
cli.Argument{
Name: "class",
Description: "The class of the key pair",
Optional: false,
},
},
Action: func(c *cli.Context) error {
err := aws.InstallKeyPair(c.NamedArg("class"), dryRun)
if err != nil {
terminal.ErrorLine(err.Error())
}
return nil
},
},
{
Name: "copyImage",
Usage: "Copy an AWS Machine Image to another region",
Arguments: []cli.Argument{
cli.Argument{
Name: "search",
Description: "The image to copy",
Optional: false,
},
cli.Argument{
Name: "region",
Description: "The region to copy the image to",
Optional: false,
},
},
Action: func(c *cli.Context) error {
err := aws.CopyImage(c.NamedArg("search"), c.NamedArg("region"), dryRun)
if err != nil {
terminal.ErrorLine(err.Error())
}
return nil
},
},
{
Name: "copySnapshot",
Usage: "Copy an AWS EBS Snapshot to another region",
Arguments: []cli.Argument{
cli.Argument{
Name: "search",
Description: "The snapshot to copy",
Optional: false,
},
cli.Argument{
Name: "region",
Description: "The region to copy the snapshot to",
Optional: false,
},
},
Action: func(c *cli.Context) error {
err := aws.CopySnapshot(c.NamedArg("search"), c.NamedArg("region"), dryRun)
if err != nil {
terminal.ErrorLine(err.Error())
}
return nil
},
},
{
Name: "createAddress",
Usage: "Create an AWS Elastic IP Address",
Arguments: []cli.Argument{
cli.Argument{
Name: "region",
Description: "The region to create the elastic ip in",
Optional: false,
},
cli.Argument{
Name: "domain",
Description: "The domain to create the elastic ip in (classic or vpc)",
Optional: false,
},
},
Action: func(c *cli.Context) error {
err := aws.CreateAddress(c.NamedArg("region"), c.NamedArg("domain"), dryRun)
if err != nil {
terminal.ErrorLine(err.Error())
}
return nil
},
},
{
Name: "createAutoScaleGroups",
Usage: "Create an AWS AutoScaling Groups",
Arguments: []cli.Argument{
cli.Argument{
Name: "class",
Description: "The class of the autoscaling groups to create",
Optional: false,
},
},
Action: func(c *cli.Context) error {
err := aws.CreateAutoScaleGroups(c.NamedArg("class"), dryRun)
if err != nil {
terminal.ErrorLine(err.Error())
}
return nil
},
},
{
Name: "createIAMUser",
Usage: "Create an IAM User",
Arguments: []cli.Argument{
cli.Argument{
Name: "username",
Description: "The username for this IAM user",
Optional: false,
},
cli.Argument{
Name: "path",
Description: "The optional path for the user",
Optional: true,
},
},
Action: func(c *cli.Context) error {
err := aws.CreateIAMUser(c.NamedArg("username"), c.NamedArg("path"))
if err != nil {
terminal.ErrorLine(err.Error())
}
return nil
},
},
{
Name: "createImage",
Usage: "Create an AWS Machine Image from a running instance",
Arguments: []cli.Argument{
cli.Argument{
Name: "search",
Description: "The AMI to create an image of",
Optional: false,
},
cli.Argument{
Name: "class",
Description: "The class of the new image",
Optional: false,
},
cli.Argument{
Name: "name",
Description: "The name of the new image",
Optional: false,
},
},
Action: func(c *cli.Context) error {
err := aws.CreateImage(c.NamedArg("search"), c.NamedArg("class"), c.NamedArg("name"), dryRun)
if err != nil {
terminal.ErrorLine(err.Error())
}
return nil
},
},
{
Name: "createLaunchConfigurations",
Usage: "Create an AWS AutoScaling Launch Configurations",
Arguments: []cli.Argument{
cli.Argument{
Name: "class",
Description: "The class of the launch configuration groups to create",
Optional: false,
},
},
Action: func(c *cli.Context) error {
err := aws.CreateLaunchConfigurations(c.NamedArg("class"), dryRun)
if err != nil {
terminal.ErrorLine(err.Error())
}
return nil
},
},
{
Name: "createKeyPair",
Usage: "Create an AWS Key Pair in the specified region",
Arguments: []cli.Argument{
cli.Argument{
Name: "class",
Description: "The class of the key pair",
Optional: false,
},
cli.Argument{
Name: "region",
Description: "The region to create the keypair in",
Optional: false,
},
},
Action: func(c *cli.Context) error {
err := aws.CreateKeyPair(c.NamedArg("class"), c.NamedArg("region"), dryRun)
if err != nil {
terminal.ErrorLine(err.Error())
}
return nil
},
},
{
Name: "createSimpleDBDomain",
Usage: "Create an AWS SimpleDB Domain",
Arguments: []cli.Argument{
cli.Argument{
Name: "domain",
Description: "The domain of the db",
Optional: false,
},
cli.Argument{
Name: "region",
Description: "The region of the db",
Optional: false,
},
},
Action: func(c *cli.Context) error {
err := aws.CreateSimpleDBDomain(c.NamedArg("domain"), c.NamedArg("region"))
if err != nil {
terminal.ErrorLine(err.Error())
}
return nil
},
},
{
Name: "createSnapshot",
Usage: "Create an AWS EBS snapshot of a volume",
Arguments: []cli.Argument{
cli.Argument{
Name: "search",
Description: "The volume to create a snapshot from",
Optional: false,
},
cli.Argument{
Name: "class",
Description: "The class of the new snapshot",
Optional: false,
},
cli.Argument{
Name: "name",
Description: "The name of the new snapshot",
Optional: false,
},
},
Action: func(c *cli.Context) error {
err := aws.CreateSnapshot(c.NamedArg("search"), c.NamedArg("class"), c.NamedArg("name"), dryRun)
if err != nil {
terminal.ErrorLine(err.Error())
}
return nil
},
},
{
Name: "createVolume",
Usage: "Create an AWS EBS volume",
Arguments: []cli.Argument{
cli.Argument{
Name: "class",
Description: "The class of the new volume",
Optional: false,
},
cli.Argument{
Name: "name",
Description: "The name of the new volume",
Optional: false,
},
cli.Argument{
Name: "az",
Description: "The Availability Zone to create the volume in",
Optional: false,
},
},
Action: func(c *cli.Context) error {
err := aws.CreateVolume(c.NamedArg("class"), c.NamedArg("name"), c.NamedArg("az"), dryRun)
if err != nil {
terminal.ErrorLine(err.Error())
}
return nil
},
},
{
Name: "createVpc",
Usage: "Create an AWS VPC",
Arguments: []cli.Argument{
cli.Argument{
Name: "class",
Description: "The class of VPC to create",
Optional: false,
},
cli.Argument{
Name: "name",
Description: "The name of the VPC",
Optional: false,
},
cli.Argument{
Name: "ip",
Description: "The IP address of this VPC (not including CIDR)",
Optional: false,
},
cli.Argument{
Name: "region",
Description: "The region to create the VPC in",
Optional: false,
},
},
Action: func(c *cli.Context) error {
err := aws.CreateVpc(c.NamedArg("class"), c.NamedArg("name"), c.NamedArg("ip"), c.NamedArg("region"), dryRun)
if err != nil {
terminal.ErrorLine(err.Error())
}
return nil
},
},
{
Name: "createSubnet",
Usage: "Create an AWS VPC Subnet",
Arguments: []cli.Argument{
cli.Argument{
Name: "class",
Description: "The class of Subnet to create",
Optional: false,
},
cli.Argument{
Name: "name",
Description: "The name of the Subnet",
Optional: false,
},
cli.Argument{
Name: "vpc",
Description: "The VPC to create the Subnet in",
Optional: false,
},
cli.Argument{
Name: "ip",
Description: "The IP address of this Subnet (not including CIDR)",
Optional: false,
},
cli.Argument{
Name: "az",
Description: "The Availability Zone to create the Subnet in",
Optional: true,
},
},
Action: func(c *cli.Context) error {
err := aws.CreateSubnet(c.NamedArg("class"), c.NamedArg("name"), c.NamedArg("vpc"), c.NamedArg("ip"), c.NamedArg("az"), dryRun)
if err != nil {
terminal.ErrorLine(err.Error())
}
return nil
},
},
{
Name: "deleteAddresses",
Usage: "Delete AWS Elastic IP Addresses",
Arguments: []cli.Argument{
cli.Argument{
Name: "search",
Description: "The search term for the elastic ip to delete",
Optional: false,
},
cli.Argument{
Name: "region",
Description: "The region to delete the elastic ip from",
Optional: true,
},
},
Action: func(c *cli.Context) error {
err := aws.DeleteAddresses(c.NamedArg("search"), c.NamedArg("region"), dryRun)
if err != nil {
terminal.ErrorLine(err.Error())
}
return nil
},
},
{
Name: "deleteAutoScaleGroups",
Usage: "Delete AWS AutoScaling Groups",
Arguments: []cli.Argument{
cli.Argument{
Name: "search",
Description: "The search term for the autoscaling group to delete",
Optional: false,
},
cli.Argument{
Name: "region",
Description: "The region to delete the autoscaling group from",
Optional: true,
},
},
Flags: []cli.Flag{
cli.BoolFlag{
Name: "force",
Destination: &force,
Usage: "force (Force deletes all instances and lifecycle actions)",
},
},
Action: func(c *cli.Context) error {
err := aws.DeleteAutoScaleGroups(c.NamedArg("search"), c.NamedArg("region"), force, dryRun)
if err != nil {
terminal.ErrorLine(err.Error())
}
return nil
},
},
{
Name: "deleteIAMUsers",
Usage: "Delete AWS IAM Users",
Arguments: []cli.Argument{
cli.Argument{
Name: "search",
Description: "The search term for iam username",
Optional: false,
},
},
Action: func(c *cli.Context) error {
err := aws.DeleteIAMUsers(c.NamedArg("search"))
if err != nil {
terminal.ErrorLine(err.Error())
}
return nil
},
},
{
Name: "deleteImages",
Usage: "Delete AWS Machine Images",
Arguments: []cli.Argument{
cli.Argument{
Name: "search",
Description: "The search term for images to delete",
Optional: false,
},
cli.Argument{
Name: "region",
Description: "The region of the images (optional)",
Optional: true,
},
},
Action: func(c *cli.Context) error {
err := aws.DeleteImages(c.NamedArg("search"), c.NamedArg("region"), dryRun)
if err != nil {
terminal.ErrorLine(err.Error())
}
return nil
},
},
{
Name: "deleteKeyPairs",
Usage: "Delete AWS KeyPairs",
Arguments: []cli.Argument{
cli.Argument{
Name: "name",
Description: "The name of the AWS KeyPair to delete",
Optional: false,
},
},
Action: func(c *cli.Context) error {
errs := aws.DeleteKeyPairs(c.NamedArg("name"), dryRun)
if errs != nil {
return cli.NewExitError("Errors Deleting KeyPair!", 1)
}
return nil
},
},
{
Name: "deleteLaunchConfigurations",
Usage: "Delete AWS AutoScaling Launch Configurations",
Arguments: []cli.Argument{
cli.Argument{
Name: "search",
Description: "The search term for the launch configuration to delete",
Optional: false,
},
cli.Argument{
Name: "region",
Description: "The region to delete the launch configuration from",
Optional: true,
},
},
Action: func(c *cli.Context) error {
err := aws.DeleteLaunchConfigurations(c.NamedArg("search"), c.NamedArg("region"), dryRun)
if err != nil {
terminal.ErrorLine(err.Error())
}
return nil
},
},
{
Name: "deleteSecurityGroups",
Usage: "Delete AWS Security Groups",
Arguments: []cli.Argument{
cli.Argument{
Name: "search",
Description: "The search term for the security group to delete",
Optional: false,
},
cli.Argument{
Name: "region",
Description: "The region to delete the security group from",
Optional: true,
},
},
Action: func(c *cli.Context) error {
err := aws.DeleteSecurityGroups(c.NamedArg("search"), c.NamedArg("region"), dryRun)
if err != nil {
terminal.ErrorLine(err.Error())
}
return nil
},
},
{
Name: "deleteSnapshots",
Usage: "Delete AWS EBS Snapshots",
Arguments: []cli.Argument{
cli.Argument{
Name: "search",
Description: "The search term for snapshots to delete",
Optional: false,
},
cli.Argument{
Name: "region",
Description: "The region of the snapshots (optional)",
Optional: true,
},
},
Action: func(c *cli.Context) error {
err := aws.DeleteSnapshots(c.NamedArg("search"), c.NamedArg("region"), dryRun)
if err != nil {
terminal.ErrorLine(err.Error())
}
return nil
},
},
{
Name: "deleteSimpleDBDomains",
Usage: "Delete AWS SimpleDB Domains",
Arguments: []cli.Argument{
cli.Argument{
Name: "search",
Description: "The search term for simpleDB domain to delete",
Optional: false,
},
cli.Argument{
Name: "region",
Description: "The region of the DBs (optional)",
Optional: true,
},
},
Action: func(c *cli.Context) error {
err := aws.DeleteSimpleDBDomains(c.NamedArg("search"), c.NamedArg("region"))
if err != nil {
terminal.ErrorLine(err.Error())
}
return nil
},
},
{
Name: "deleteVolumes",
Usage: "Delete AWS EBS Volumes",
Arguments: []cli.Argument{
cli.Argument{
Name: "volume",
Description: "The volume to delete",
Optional: false,
},
cli.Argument{
Name: "region",
Description: "The region of the volumes (optional)",
Optional: true,
},
},
Action: func(c *cli.Context) error {
err := aws.DeleteVolumes(c.NamedArg("volume"), c.NamedArg("region"), dryRun)
if err != nil {
terminal.ErrorLine(err.Error())
}
return nil
},
},
{
Name: "deleteSubnets",
Usage: "Delete AWS VPC Subnets",
Arguments: []cli.Argument{
cli.Argument{
Name: "search",
Description: "The search term for Subnets to delete",
Optional: false,
},
cli.Argument{
Name: "region",
Description: "The region of the subnets (optional)",
Optional: true,
},
},
Action: func(c *cli.Context) error {
err := aws.DeleteSubnets(c.NamedArg("search"), c.NamedArg("region"), dryRun)
if err != nil {
terminal.ErrorLine(err.Error())
}
return nil
},
},
{
Name: "deleteVpcs",
Usage: "Delete AWS VPCs",
Arguments: []cli.Argument{
cli.Argument{
Name: "search",
Description: "The search term for VPCs to delete",
Optional: false,
},
cli.Argument{
Name: "region",
Description: "The region of the VPCs (optional)",
Optional: true,
},
},
Action: func(c *cli.Context) error {
err := aws.DeleteVpcs(c.NamedArg("search"), c.NamedArg("region"), dryRun)
if err != nil {
terminal.ErrorLine(err.Error())
}
return nil
},
},
{
Name: "detachVolume",
Usage: "Detach an AWS EBS Volume",
Arguments: []cli.Argument{
cli.Argument{
Name: "volume",
Description: "The volume to detach",
Optional: false,
},
cli.Argument{
Name: "instance",
Description: "The instance to detach the volume from",
Optional: false,
},
},
Flags: []cli.Flag{
cli.BoolFlag{
Name: "force",
Destination: &force,
Usage: "force detach",
},
},
Action: func(c *cli.Context) error {
err := aws.DetachVolume(c.NamedArg("volume"), c.NamedArg("instance"), force, dryRun)
if err != nil {
terminal.ErrorLine(err.Error())
}
return nil
},
},
{
Name: "stopInstances",
Usage: "Stop AWS instances",
Arguments: []cli.Argument{
cli.Argument{
Name: "search",
Description: "The search term for instance to stop",
Optional: false,
},
cli.Argument{
Name: "region",
Description: "The region of the instance (optional)",
Optional: true,
},
},
Flags: []cli.Flag{
cli.BoolFlag{
Name: "force",
Destination: &force,
Usage: "force (Force deletes all instances and lifecycle actions)",
},
},
Action: func(c *cli.Context) error {
err := aws.StopInstances(c.NamedArg("search"), c.NamedArg("region"), force, dryRun)
if err != nil {
terminal.ErrorLine(err.Error())
}
return nil
},
},
{
Name: "startInstances",
Usage: "Start AWS instances",
Arguments: []cli.Argument{
cli.Argument{
Name: "search",
Description: "The search term for Instance to start",
Optional: false,
},
cli.Argument{
Name: "region",
Description: "The region of the instance (optional)",
Optional: true,
},
},
Action: func(c *cli.Context) error {
err := aws.StartInstances(c.NamedArg("search"), c.NamedArg("region"), dryRun)
if err != nil {
terminal.ErrorLine(err.Error())
}
return nil
},
},
{
Name: "rebootInstances",
Usage: "Reboot AWS instances",
Arguments: []cli.Argument{
cli.Argument{
Name: "search",
Description: "The search term for instance to reboot",
Optional: false,
},
cli.Argument{
Name: "region",
Description: "The region of the instance (optional)",
Optional: true,
},
},
Action: func(c *cli.Context) error {
err := aws.RebootInstances(c.NamedArg("search"), c.NamedArg("region"), dryRun)
if err != nil {
terminal.ErrorLine(err.Error())
}
return nil
},
},
{
Name: "terminateInstances",
Usage: "Terminate AWS instances",
Arguments: []cli.Argument{
cli.Argument{
Name: "name",
Description: "The search term for instance to terminate",
Optional: false,
},
cli.Argument{
Name: "region",
Description: "The region of the instance (optional)",
Optional: true,
},
},
Action: func(c *cli.Context) error {
err := aws.TerminateInstances(c.NamedArg("name"), c.NamedArg("region"), dryRun)
if err != nil {
terminal.ErrorLine(err.Error())
}
return nil
},
},
{
Name: "launchInstance",
Usage: "Launch an EC2 instance",
Arguments: []cli.Argument{
cli.Argument{
Name: "class",
Description: "The class of the instance (dev, stage, etc)",
Optional: false,
},
cli.Argument{
Name: "sequence",
Description: "The sequence of the instance (1...100)",
Optional: false,
},
cli.Argument{
Name: "az",
Description: "The availability zone to launch the instance in (us-west-2a, us-east-1a, etc)",
Optional: false,
},
},
Action: func(c *cli.Context) error {
err := aws.LaunchInstance(c.NamedArg("class"), c.NamedArg("sequence"), c.NamedArg("az"), dryRun)
if err != nil {
terminal.ErrorLine(err.Error())
}
return nil
},
},
{
Name: "listAddresses",
Usage: "Lists AWS Elastic IP Addresses",
Arguments: []cli.Argument{
cli.Argument{
Name: "search",
Description: "The keyword to search for",
Optional: true,
},
},
Action: func(c *cli.Context) error {
addresses, errs := aws.GetAddresses(c.NamedArg("search"), false)
if errs != nil {
return cli.NewExitError("Error Listing Addresses!", 1)
}
addresses.PrintTable()
return nil
},
},
{
Name: "listAlarms",
Usage: "Lists CloudWatch Alarms",
Action: func(c *cli.Context) error {
alarms, errs := aws.GetAlarms()
if errs != nil {
return cli.NewExitError("Error Listing Alarms!", 1)
}
alarms.PrintTable()
return nil
},
},
{
Name: "listAutoScaleGroups",
Usage: "Lists AutoScale Groups",
Arguments: []cli.Argument{
cli.Argument{
Name: "search",
Description: "The keyword to search for",
Optional: true,
},
},
Action: func(c *cli.Context) error {
groups, errs := aws.GetAutoScaleGroups(c.NamedArg("search"))
if errs != nil {
return cli.NewExitError("Error Listing Auto Scale Groups!", 1)
}
groups.PrintTable()
return nil
},
},
{
Name: "listIAMUsers",
Usage: "Lists IAM Users",
Arguments: []cli.Argument{
cli.Argument{
Name: "search",
Description: "The keyword to search for",
Optional: true,
},
},
Action: func(c *cli.Context) error {
iam, errs := aws.GetIAMUsers(c.NamedArg("search"))
if errs != nil {
return cli.NewExitError("Error Listing IAM Users!", 1)
}
iam.PrintTable()
return nil
},
},
{
Name: "listImages",
Usage: "Lists AWS Machine Images owned by us",
Arguments: []cli.Argument{
cli.Argument{
Name: "search",
Description: "The keyword to search for",
Optional: true,
},
},
Action: func(c *cli.Context) error {
images, errs := aws.GetImages(c.NamedArg("search"), false)
if errs != nil {
return cli.NewExitError("Error Listing Images!", 1)
}
images.PrintTable()
return nil
},
},
{
Name: "listInstances",
Usage: "Lists AWS EC2 Instances",
Arguments: []cli.Argument{
cli.Argument{
Name: "search",
Description: "The keyword to search for",
Optional: true,
},
},
Action: func(c *cli.Context) error {
instances, errs := aws.GetInstances(c.NamedArg("search"), false)
if errs != nil {
return cli.NewExitError("Error Listing Instances!", 1)
}
instances.PrintTable()
return nil
},
},
{
Name: "listKeyPairs",
Usage: "Lists AWS Key Pairs",
Arguments: []cli.Argument{
cli.Argument{
Name: "search",
Description: "The keyword to search for",
Optional: true,
},
},
Action: func(c *cli.Context) error {
keyPairs, errs := aws.GetKeyPairs(c.NamedArg("search"))
if errs != nil {
return cli.NewExitError("Error Listing Key Pairs!", 1)
}
keyPairs.PrintTable()
return nil
},
},
{
Name: "listLaunchConfigurations",
Usage: "Lists Launch Configurations",
Arguments: []cli.Argument{
cli.Argument{
Name: "search",
Description: "The keyword to search for",
Optional: true,
},
},
Action: func(c *cli.Context) error {
launchConfigs, errs := aws.GetLaunchConfigurations(c.NamedArg("search"))
if errs != nil {
return cli.NewExitError("Error Listing Launch Configurations!", 1)
}
launchConfigs.PrintTable()
return nil
},
},
{
Name: "listLoadBalancers",
Usage: "Lists Elastic Load Balancers",
Action: func(c *cli.Context) error {
loadBalancers, errs := aws.GetLoadBalancers()
if errs != nil {
return cli.NewExitError("Error Listing Load Balancers!", 1)
}
loadBalancers.PrintTable()
return nil
},
},
{
Name: "listScalingPolicies",
Usage: "Lists Scaling Policies",
Action: func(c *cli.Context) error {
policies, errs := aws.GetScalingPolicies()
if errs != nil {
return cli.NewExitError("Error Listing Auto Scaling Policies!", 1)
}
policies.PrintTable()
return nil
},
},
{
Name: "listSecurityGroups",
Usage: "Lists Security Groups",
Arguments: []cli.Argument{
cli.Argument{
Name: "search",
Description: "The keyword to search for",
Optional: true,
},
},
Action: func(c *cli.Context) error {
groups, errs := aws.GetSecurityGroups(c.NamedArg("search"))
if errs != nil {
return cli.NewExitError("Error Listing Security Groups!", 1)
}
groups.PrintTable()
return nil
},
},
{
Name: "listSnapshots",
Usage: "Lists AWS EBS Snapshots",
Arguments: []cli.Argument{
cli.Argument{
Name: "search",
Description: "The keyword to search for",
Optional: true,
},
},
Action: func(c *cli.Context) error {
snapshots, errs := aws.GetSnapshots(c.NamedArg("search"), false)
if errs != nil {
return cli.NewExitError("Error Listing Snapshots!", 1)
}
snapshots.PrintTable()
return nil
},
},
{
Name: "listSubnets",
Usage: "Lists AWS Subnets",
Arguments: []cli.Argument{
cli.Argument{
Name: "search",
Description: "The keyword to search for",
Optional: true,
},
},
Action: func(c *cli.Context) error {
subnets, errs := aws.GetSubnets(c.NamedArg("search"))
if errs != nil {
return cli.NewExitError("Error Listing Subnets!", 1)
}
subnets.PrintTable()
return nil
},
},
{
Name: "listSimpleDBDomains",
Usage: "Lists AWS SimpleDB Domains",
Arguments: []cli.Argument{
cli.Argument{
Name: "search",
Description: "The keyword to search for",
Optional: true,
},
},
Action: func(c *cli.Context) error {
domains, errs := aws.GetSimpleDBDomains(c.NamedArg("search"))
if errs != nil {
return cli.NewExitError("Error Listing Simple DB Domains!", 1)
}
domains.PrintTable()
return nil
},
},
{
Name: "listVolumes",
Usage: "Lists AWS EBS Volumes",
Arguments: []cli.Argument{
cli.Argument{
Name: "search",
Description: "The keyword to search for",
Optional: true,
},
},
Action: func(c *cli.Context) error {
volumes, errs := aws.GetVolumes(c.NamedArg("search"), false)
if errs != nil {
return cli.NewExitError("Error Listing Volumes!", 1)
}
volumes.PrintTable()
return nil
},
},
{
Name: "listVpcs",
Usage: "Lists AWS Vpcs",
Arguments: []cli.Argument{
cli.Argument{
Name: "search",
Description: "The keyword to search for",
Optional: true,
},
},
Action: func(c *cli.Context) error {
vpcs, errs := aws.GetVpcs(c.NamedArg("search"))
if errs != nil {
return cli.NewExitError("Error Listing VPCs!", 1)
}
vpcs.PrintTable()
return nil
},
},
{
Name: "resumeProcesses",
Usage: "Resume scaling processes on autoscaling groups",
Arguments: []cli.Argument{
cli.Argument{
Name: "search",
Description: "The search term for the autoscaling group to resume",
Optional: false,
},
cli.Argument{
Name: "region",
Description: "The region to resume the processes in",
Optional: true,
},
},
Action: func(c *cli.Context) error {
err := aws.ResumeProcesses(c.NamedArg("search"), c.NamedArg("region"), dryRun)
if err != nil {
terminal.ErrorLine(err.Error())
}
return nil
},
},
{
Name: "runCommand",
Usage: "Run a command on a set of instances",
Action: func(c *cli.Context) error {
// TODO
return nil
},
},
{
Name: "suspendProcesses",
Usage: "Suspend scaling processes on autoscaling groups",
Arguments: []cli.Argument{
cli.Argument{
Name: "search",
Description: "The search term for the autoscaling group to suspend",
Optional: false,
},
cli.Argument{
Name: "region",
Description: "The region to suspend the processes in",
Optional: true,
},
},
Action: func(c *cli.Context) error {
err := aws.SuspendProcesses(c.NamedArg("search"), c.NamedArg("region"), dryRun)
if err != nil {
terminal.ErrorLine(err.Error())
}
return nil
},
},
{
Name: "updateAutoScaleGroups",
Usage: "Update AutoScaling Groups",
Arguments: []cli.Argument{
cli.Argument{
Name: "search",
Description: "The search term autoscaling group to update",
Optional: false,
},
cli.Argument{
Name: "version",
Description: "The version of the launch configuration group to use (defaults to the most recent)",
Optional: true,
},
},
Flags: []cli.Flag{
cli.BoolFlag{
Name: "double",
Destination: &double,
Usage: "double (Doubles the desired-capacity and max-capacity)",
},
},
Action: func(c *cli.Context) error {
err := aws.UpdateAutoScaleGroups(c.NamedArg("search"), c.NamedArg("version"), double, dryRun)
if err != nil {
terminal.ErrorLine(err.Error())
}
return nil
},
},
{
Name: "updateSecurityGroups",
Usage: "Update Security Groups",
Arguments: []cli.Argument{
cli.Argument{
Name: "search",
Description: "The search term autoscaling group to update",
Optional: false,
},
cli.Argument{
Name: "region",
Description: "The region to update the security groups in (optional)",
Optional: true,
},
},
Flags: []cli.Flag{
cli.BoolFlag{
Name: "double",
Destination: &double,
Usage: "double (Doubles the desired-capacity and max-capacity)",
},
},
Action: func(c *cli.Context) error {
err := aws.UpdateSecurityGroups(c.NamedArg("search"), c.NamedArg("region"), dryRun)
if err != nil {
terminal.ErrorLine(err.Error())
}
return nil
},
},
}
app.Run(os.Args)
}