// CreateDroplet creates a new droplet with a hostname, key and image_id. It // returns back the dropletInfo. func (d *DigitalOcean) CreateDroplet(hostname string, keyId, image_id uint) (*DropletInfo, error) { params := url.Values{} params.Set("name", hostname) found_size, err := d.Client.Size(d.Builder.Size) if err != nil { return nil, fmt.Errorf("Invalid size or lookup failure: '%s': %s", d.Builder.Size, err) } found_region, err := d.Client.Region(d.Builder.Region) if err != nil { return nil, fmt.Errorf("Invalid region or lookup failure: '%s': %s", d.Builder.Region, err) } params.Set("size_slug", found_size.Slug) params.Set("image_id", strconv.Itoa(int(image_id))) params.Set("region_slug", found_region.Slug) params.Set("ssh_key_ids", fmt.Sprintf("%v", keyId)) params.Set("private_networking", fmt.Sprintf("%v", d.Builder.PrivateNetworking)) body, err := digitalocean.NewRequest(*d.Client, "droplets/new", params) if err != nil { return nil, err } info := &DropletInfo{} if err := mapstructure.Decode(body, info); err != nil { return nil, err } return info, nil }
// Droplets returns a slice of all Droplets. func (d *DigitalOcean) Droplets() (Droplets, error) { resp, err := digitalocean.NewRequest(*d.Client, "droplets", url.Values{}) if err != nil { return nil, err } var result DropletsResp if err := mapstructure.Decode(resp, &result); err != nil { return nil, err } return result.Droplets, nil }
// Keys returns all available public SSH Keys func (d *DigitalOcean) Keys() (SSHKeys, error) { resp, err := digitalocean.NewRequest(*d.Client, "ssh_keys", url.Values{}) if err != nil { return nil, err } var result SSHKeys if err := mapstructure.Decode(resp["ssh_keys"], &result); err != nil { return nil, err } return result, nil }
// Reboot restart the machine for the given dropletID and returns the eventId // back to track the event. func (d *DigitalOcean) Reboot(dropletId uint) (int, error) { path := fmt.Sprintf("droplets/%v/reboot", dropletId) body, err := digitalocean.NewRequest(*d.Client, path, url.Values{}) if err != nil { return 0, err } eventId, ok := body["event_id"].(float64) if !ok { return 0, fmt.Errorf("restart malformed data %v", body) } return int(eventId), nil }
// CheckEvent checks the given eventID and returns back the result. It's useful // for checking the status of an event. Usually it's called in a for/select // statement and get polled. func (d *DigitalOcean) CheckEvent(eventId int) (*Event, error) { path := fmt.Sprintf("events/%d", eventId) body, err := digitalocean.NewRequest(*d.Client, path, url.Values{}) if err != nil { return nil, err } event := &Event{} if err := mapstructure.Decode(body, event); err != nil { return nil, err } return event, nil }
func (d *DigitalOcean) Rename(dropletId uint, newName string) (int, error) { params := url.Values{} params.Set("name", newName) path := fmt.Sprintf("droplets/%v/rename", dropletId) body, err := digitalocean.NewRequest(*d.Client, path, params) if err != nil { return 0, err } eventId, ok := body["event_id"].(float64) if !ok { return 0, fmt.Errorf("restart malformed data %v", body) } return int(eventId), nil }
// Image returns a slice of all images. func (d *DigitalOcean) Images(myImages bool) (Images, error) { v := url.Values{} if myImages { v.Set("filter", "my_images") } resp, err := digitalocean.NewRequest(*d.Client, "images", v) if err != nil { return nil, err } var result digitalocean.ImagesResp if err := mapstructure.Decode(resp, &result); err != nil { return nil, err } return result.Images, nil }
func (d *DigitalOcean) ShowDroplet(dropletId uint) (*Droplet, error) { path := fmt.Sprintf("droplets/%v", dropletId) resp, err := digitalocean.NewRequest(*d.Client, path, url.Values{}) if err != nil { return nil, err } droplet, ok := resp["droplet"].(map[string]interface{}) if !ok { return nil, fmt.Errorf("show droplet malformed data received %v", resp) } var result Droplet if err := mapstructure.Decode(droplet, &result); err != nil { return nil, err } return &result, err }
// ShowKey shows the key content for the given key id func (d *DigitalOcean) ShowKey(keyId uint) (*SSHKey, error) { path := fmt.Sprintf("ssh_keys/%v", keyId) resp, err := digitalocean.NewRequest(*d.Client, path, url.Values{}) if err != nil { return nil, err } ssh_key, ok := resp["ssh_key"].(map[string]interface{}) if !ok { return nil, fmt.Errorf("showKey: malformed data received %v", resp) } var result SSHKey if err := mapstructure.Decode(ssh_key, &result); err != nil { return nil, err } return &result, nil }