func authMethods(ctx *cli.Context) (methods []ssh.AuthMethod, err error) {
reader := bufio.NewReader(os.Stdin)
fmt.Print("Password: "******"key")
if keyPath == "" {
keyPath = filepath.Join(usr.HomeDir, ".ssh", "id_rsa")
}
key, err := ioutil.ReadFile(keyPath)
if err != nil {
return
}
privateKey, err := ssh.ParsePrivateKey(key)
if err != nil {
return
}
methods = append(methods, ssh.PublicKeys(privateKey))
return
}
func dropletActionSnapshot(ctx *cli.Context) {
if ctx.Int("id") == 0 && len(ctx.Args()) != 1 {
log.Fatal("Error: Must provide ID or name for Droplet to resize.")
}
name := ctx.String("name")
tokenSource := &TokenSource{
AccessToken: APIKey,
}
oauthClient := oauth2.NewClient(oauth2.NoContext, tokenSource)
client := godo.NewClient(oauthClient)
id := ctx.Int("id")
if id == 0 {
droplet, err := FindDropletByName(client, ctx.Args()[0])
if err != nil {
log.Fatal(err)
} else {
id = droplet.ID
}
}
droplet, _, err := client.Droplets.Get(id)
if err != nil {
log.Fatal("Unable to find Droplet: %s.", err)
}
action, _, err := client.DropletActions.Snapshot(droplet.ID, name)
if err != nil {
log.Fatal(err)
}
WriteOutput(action)
}
func TestApp_RunAsSubcommandParseFlags(t *testing.T) {
var context *cli.Context
a := cli.NewApp()
a.Commands = []cli.Command{
{
Name: "foo",
Action: func(c *cli.Context) {
context = c
},
Flags: []cli.Flag{
cli.StringFlag{
Name: "lang",
Value: "english",
Usage: "language for the greeting",
},
},
Before: func(_ *cli.Context) error { return nil },
},
}
a.Run([]string{"", "foo", "--lang", "spanish", "abcd"})
expect(t, context.Args().Get(0), "abcd")
expect(t, context.String("lang"), "spanish")
}
func sshDestroy(ctx *cli.Context) {
if ctx.Int("id") == 0 && ctx.String("fingerprint") == "" && len(ctx.Args()) < 1 {
fmt.Printf("Error: Must provide ID, fingerprint or name for SSH Key to destroy.\n")
os.Exit(1)
}
tokenSource := &TokenSource{
AccessToken: APIKey,
}
oauthClient := oauth2.NewClient(oauth2.NoContext, tokenSource)
client := godo.NewClient(oauthClient)
id := ctx.Int("id")
fingerprint := ctx.String("fingerprint")
var key godo.Key
if id == 0 && fingerprint == "" {
key, err := FindKeyByName(client, ctx.Args().First())
if err != nil {
fmt.Printf("%s\n", err)
os.Exit(64)
} else {
id = key.ID
}
} else if id != 0 {
key, _, err := client.Keys.GetByID(id)
if err != nil {
fmt.Printf("Unable to find SSH Key: %s\n", err)
os.Exit(1)
} else {
id = key.ID
}
} else {
key, _, err := client.Keys.GetByFingerprint(fingerprint)
if err != nil {
fmt.Printf("Unable to find SSH Key: %s\n", err)
os.Exit(1)
} else {
id = key.ID
}
}
_, err := client.Keys.DeleteByID(id)
if err != nil {
fmt.Printf("Unable to destroy SSH Key: %s\n", err)
os.Exit(1)
}
fmt.Printf("Key %s destroyed.\n", key.Name)
}
func dropletActionResize(ctx *cli.Context) {
if ctx.Int("id") == 0 && len(ctx.Args()) != 1 {
fmt.Printf("Error: Must provide ID or name for Droplet to destroy.\n")
os.Exit(1)
}
size := ctx.String("size")
disk := ctx.Bool("disk")
tokenSource := &TokenSource{
AccessToken: APIKey,
}
oauthClient := oauth2.NewClient(oauth2.NoContext, tokenSource)
client := godo.NewClient(oauthClient)
id := ctx.Int("id")
if id == 0 {
droplet, err := FindDropletByName(client, ctx.Args()[0])
if err != nil {
fmt.Printf("%s\n", err)
os.Exit(64)
} else {
id = droplet.ID
}
}
droplet, _, err := client.Droplets.Get(id)
if err != nil {
fmt.Printf("Unable to find Droplet: %s\n", err)
os.Exit(1)
}
action, _, err := client.DropletActions.Resize(droplet.ID, size, disk)
if err != nil {
fmt.Println(err)
os.Exit(1)
}
WriteOutput(action)
}
func domainRecordCreate(ctx *cli.Context) {
if len(ctx.Args()) != 1 {
cli.ShowAppHelp(ctx)
fmt.Printf("Must specify a domain name to add a record to.\n")
os.Exit(1)
}
domainName := ctx.Args().First()
tokenSource := &TokenSource{
AccessToken: APIKey,
}
oauthClient := oauth2.NewClient(oauth2.NoContext, tokenSource)
client := godo.NewClient(oauthClient)
createRequest := &godo.DomainRecordEditRequest{
Type: strings.ToUpper(ctx.String("type")),
Name: ctx.String("name"),
Data: ctx.String("data"),
}
if createRequest.Type == "MX" || createRequest.Type == "SRV" {
createRequest.Priority = ctx.Int("priority")
}
if createRequest.Type == "SRV" {
createRequest.Port = ctx.Int("port")
createRequest.Weight = ctx.Int("weight")
}
domainRecord, _, err := client.Domains.CreateRecord(domainName, createRequest)
if err != nil {
fmt.Printf("%s\n", err)
os.Exit(1)
}
WriteOutput(domainRecord)
}
func dropletCreate(ctx *cli.Context) {
if len(ctx.Args()) != 1 {
log.Fatal("Error: Must provide name for Droplet.")
}
tokenSource := &TokenSource{
AccessToken: APIKey,
}
oauthClient := oauth2.NewClient(oauth2.NoContext, tokenSource)
client := godo.NewClient(oauthClient)
// Add domain to end if available.
dropletName := ctx.Args().First()
if ctx.Bool("add-region") {
dropletName = fmt.Sprintf("%s.%s", dropletName, ctx.String("region"))
}
if ctx.String("domain") != "" {
dropletName = fmt.Sprintf("%s.%s", dropletName, ctx.String("domain"))
}
// Loop through the SSH Keys and add by name. DO API should have handled
// this case as well.
var sshKeys []godo.DropletCreateSSHKey
keyNames := ctx.String("ssh-keys")
if keyNames != "" {
for _, keyName := range strings.Split(keyNames, ",") {
sshKey, err := FindKeyByName(client, keyName)
if sshKey != nil && err == nil {
sshKeys = append(sshKeys, godo.DropletCreateSSHKey{ID: sshKey.ID})
} else {
log.Fatalf("Warning: Could not find key: %q.", keyName)
}
}
}
userData := ""
userDataPath := ctx.String("user-data-file")
if userDataPath != "" {
file, err := os.Open(userDataPath)
if err != nil {
log.Fatalf("Error opening user data file: %s.", err)
}
userDataFile, err := ioutil.ReadAll(file)
if err != nil {
log.Fatalf("Error reading user data file: %s.", err)
}
userData = string(userDataFile)
} else {
userData = ctx.String("user-data")
}
createRequest := &godo.DropletCreateRequest{
Name: dropletName,
Region: ctx.String("region"),
Size: ctx.String("size"),
Image: godo.DropletCreateImage{
Slug: ctx.String("image"),
},
SSHKeys: sshKeys,
Backups: ctx.Bool("backups"),
IPv6: ctx.Bool("ipv6"),
PrivateNetworking: ctx.Bool("private-networking"),
UserData: userData,
}
droplet, resp, err := client.Droplets.Create(createRequest)
if err != nil {
log.Fatalf("Unable to create Droplet: %s.", err)
}
if ctx.Bool("wait-for-active") {
util.WaitForActive(client, resp.Links.Actions[0].HREF)
}
WriteOutput(droplet)
}