463 lines
11 KiB
Go
463 lines
11 KiB
Go
// are here. Their API is on a path to V2, so just plain JSON is used
|
|
// in place of a proper client library for now.
|
|
|
|
package digitalocean
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"log"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
type DigitalOceanClientV2 struct {
|
|
// The http client for communicating
|
|
client *http.Client
|
|
|
|
// Credentials
|
|
APIToken string
|
|
|
|
// The base URL of the API
|
|
APIURL string
|
|
}
|
|
|
|
// Creates a new client for communicating with DO
|
|
func DigitalOceanClientNewV2(token string, url string) *DigitalOceanClientV2 {
|
|
c := &DigitalOceanClientV2{
|
|
client: &http.Client{
|
|
Transport: &http.Transport{
|
|
Proxy: http.ProxyFromEnvironment,
|
|
},
|
|
},
|
|
APIURL: url,
|
|
APIToken: token,
|
|
}
|
|
return c
|
|
}
|
|
|
|
// Creates an SSH Key and returns it's id
|
|
func (d DigitalOceanClientV2) CreateKey(name string, pub string) (uint, error) {
|
|
type KeyReq struct {
|
|
Name string `json:"name"`
|
|
PublicKey string `json:"public_key"`
|
|
}
|
|
type KeyRes struct {
|
|
SSHKey struct {
|
|
Id uint
|
|
Name string
|
|
Fingerprint string
|
|
PublicKey string `json:"public_key"`
|
|
} `json:"ssh_key"`
|
|
}
|
|
req := &KeyReq{Name: name, PublicKey: pub}
|
|
res := KeyRes{}
|
|
err := NewRequestV2(d, "v2/account/keys", "POST", req, &res)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
return res.SSHKey.Id, err
|
|
}
|
|
|
|
// Destroys an SSH key
|
|
func (d DigitalOceanClientV2) DestroyKey(id uint) error {
|
|
path := fmt.Sprintf("v2/account/keys/%v", id)
|
|
return NewRequestV2(d, path, "DELETE", nil, nil)
|
|
}
|
|
|
|
// Creates a droplet and returns it's id
|
|
func (d DigitalOceanClientV2) CreateDroplet(name string, size string, image string, region string, keyId uint, privateNetworking bool) (uint, error) {
|
|
type DropletReq struct {
|
|
Name string `json:"name"`
|
|
Region string `json:"region"`
|
|
Size string `json:"size"`
|
|
Image string `json:"image"`
|
|
SSHKeys []string `json:"ssh_keys,omitempty"`
|
|
Backups bool `json:"backups,omitempty"`
|
|
IPv6 bool `json:"ipv6,omitempty"`
|
|
PrivateNetworking bool `json:"private_networking,omitempty"`
|
|
}
|
|
type DropletRes struct {
|
|
Droplet struct {
|
|
Id uint
|
|
Name string
|
|
Memory uint
|
|
VCPUS uint `json:"vcpus"`
|
|
Disk uint
|
|
Region Region
|
|
Image Image
|
|
Size Size
|
|
Locked bool
|
|
CreateAt string `json:"created_at"`
|
|
Status string
|
|
Networks struct {
|
|
V4 []struct {
|
|
IPAddr string `json:"ip_address"`
|
|
Netmask string
|
|
Gateway string
|
|
Type string
|
|
} `json:"v4,omitempty"`
|
|
V6 []struct {
|
|
IPAddr string `json:"ip_address"`
|
|
CIDR uint `json:"cidr"`
|
|
Gateway string
|
|
Type string
|
|
} `json:"v6,omitempty"`
|
|
}
|
|
Kernel struct {
|
|
Id uint
|
|
Name string
|
|
Version string
|
|
}
|
|
BackupIds []uint
|
|
SnapshotIds []uint
|
|
ActionIds []uint
|
|
Features []string `json:"features,omitempty"`
|
|
}
|
|
}
|
|
req := &DropletReq{Name: name}
|
|
res := DropletRes{}
|
|
|
|
found_size, err := d.Size(size)
|
|
if err != nil {
|
|
return 0, fmt.Errorf("Invalid size or lookup failure: '%s': %s", size, err)
|
|
}
|
|
|
|
found_image, err := d.Image(image)
|
|
if err != nil {
|
|
return 0, fmt.Errorf("Invalid image or lookup failure: '%s': %s", image, err)
|
|
}
|
|
|
|
found_region, err := d.Region(region)
|
|
if err != nil {
|
|
return 0, fmt.Errorf("Invalid region or lookup failure: '%s': %s", region, err)
|
|
}
|
|
|
|
if found_image.Slug == "" {
|
|
req.Image = strconv.Itoa(int(found_image.Id))
|
|
} else {
|
|
req.Image = found_image.Slug
|
|
}
|
|
|
|
req.Size = found_size.Slug
|
|
req.Region = found_region.Slug
|
|
req.SSHKeys = []string{fmt.Sprintf("%v", keyId)}
|
|
req.PrivateNetworking = privateNetworking
|
|
|
|
err = NewRequestV2(d, "v2/droplets", "POST", req, &res)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
return res.Droplet.Id, err
|
|
}
|
|
|
|
// Destroys a droplet
|
|
func (d DigitalOceanClientV2) DestroyDroplet(id uint) error {
|
|
path := fmt.Sprintf("v2/droplets/%v", id)
|
|
return NewRequestV2(d, path, "DELETE", nil, nil)
|
|
}
|
|
|
|
// Powers off a droplet
|
|
func (d DigitalOceanClientV2) PowerOffDroplet(id uint) error {
|
|
type ActionReq struct {
|
|
Type string `json:"type"`
|
|
}
|
|
type ActionRes struct {
|
|
}
|
|
req := &ActionReq{Type: "power_off"}
|
|
path := fmt.Sprintf("v2/droplets/%v/actions", id)
|
|
return NewRequestV2(d, path, "POST", req, nil)
|
|
}
|
|
|
|
// Shutsdown a droplet. This is a "soft" shutdown.
|
|
func (d DigitalOceanClientV2) ShutdownDroplet(id uint) error {
|
|
type ActionReq struct {
|
|
Type string `json:"type"`
|
|
}
|
|
type ActionRes struct {
|
|
}
|
|
req := &ActionReq{Type: "shutdown"}
|
|
|
|
path := fmt.Sprintf("v2/droplets/%v/actions", id)
|
|
return NewRequestV2(d, path, "POST", req, nil)
|
|
}
|
|
|
|
// Creates a snaphot of a droplet by it's ID
|
|
func (d DigitalOceanClientV2) CreateSnapshot(id uint, name string) error {
|
|
type ActionReq struct {
|
|
Type string `json:"type"`
|
|
Name string `json:"name"`
|
|
}
|
|
type ActionRes struct {
|
|
}
|
|
req := &ActionReq{Type: "snapshot", Name: name}
|
|
path := fmt.Sprintf("v2/droplets/%v/actions", id)
|
|
return NewRequestV2(d, path, "POST", req, nil)
|
|
}
|
|
|
|
// Returns all available images.
|
|
func (d DigitalOceanClientV2) Images() ([]Image, error) {
|
|
res := ImagesResp{}
|
|
|
|
err := NewRequestV2(d, "v2/images?per_page=200", "GET", nil, &res)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return res.Images, nil
|
|
}
|
|
|
|
// Destroys an image by its ID.
|
|
func (d DigitalOceanClientV2) DestroyImage(id uint) error {
|
|
path := fmt.Sprintf("v2/images/%d", id)
|
|
return NewRequestV2(d, path, "DELETE", nil, nil)
|
|
}
|
|
|
|
// Returns DO's string representation of status "off" "new" "active" etc.
|
|
func (d DigitalOceanClientV2) DropletStatus(id uint) (string, string, error) {
|
|
path := fmt.Sprintf("v2/droplets/%v", id)
|
|
type DropletRes struct {
|
|
Droplet struct {
|
|
Id uint
|
|
Name string
|
|
Memory uint
|
|
VCPUS uint `json:"vcpus"`
|
|
Disk uint
|
|
Region Region
|
|
Image Image
|
|
Size Size
|
|
Locked bool
|
|
CreateAt string `json:"created_at"`
|
|
Status string
|
|
Networks struct {
|
|
V4 []struct {
|
|
IPAddr string `json:"ip_address"`
|
|
Netmask string
|
|
Gateway string
|
|
Type string
|
|
} `json:"v4,omitempty"`
|
|
V6 []struct {
|
|
IPAddr string `json:"ip_address"`
|
|
CIDR uint `json:"cidr"`
|
|
Gateway string
|
|
Type string
|
|
} `json:"v6,omitempty"`
|
|
}
|
|
Kernel struct {
|
|
Id uint
|
|
Name string
|
|
Version string
|
|
}
|
|
BackupIds []uint
|
|
SnapshotIds []uint
|
|
ActionIds []uint
|
|
Features []string `json:"features,omitempty"`
|
|
}
|
|
}
|
|
res := DropletRes{}
|
|
err := NewRequestV2(d, path, "GET", nil, &res)
|
|
if err != nil {
|
|
return "", "", err
|
|
}
|
|
var ip string
|
|
|
|
for _, n := range res.Droplet.Networks.V4 {
|
|
if n.Type == "public" {
|
|
ip = n.IPAddr
|
|
}
|
|
}
|
|
|
|
return ip, res.Droplet.Status, err
|
|
}
|
|
|
|
// Sends an api request and returns a generic map[string]interface of
|
|
// the response.
|
|
func NewRequestV2(d DigitalOceanClientV2, path string, method string, req interface{}, res interface{}) error {
|
|
var err error
|
|
var request *http.Request
|
|
|
|
client := d.client
|
|
|
|
buf := new(bytes.Buffer)
|
|
// Add the authentication parameters
|
|
url := fmt.Sprintf("%s/%s", d.APIURL, path)
|
|
if req != nil {
|
|
enc := json.NewEncoder(buf)
|
|
enc.Encode(req)
|
|
defer buf.Reset()
|
|
request, err = http.NewRequest(method, url, buf)
|
|
request.Header.Add("Content-Type", "application/json")
|
|
} else {
|
|
request, err = http.NewRequest(method, url, nil)
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// Add the authentication parameters
|
|
request.Header.Add("Authorization", "Bearer "+d.APIToken)
|
|
if buf != nil {
|
|
log.Printf("sending new request to digitalocean: %s buffer: %s", url, buf)
|
|
} else {
|
|
log.Printf("sending new request to digitalocean: %s", url)
|
|
}
|
|
resp, err := client.Do(request)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if method == "DELETE" && resp.StatusCode == 204 {
|
|
if resp.Body != nil {
|
|
resp.Body.Close()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
if resp.Body == nil {
|
|
return errors.New("Request returned empty body")
|
|
}
|
|
|
|
body, err := ioutil.ReadAll(resp.Body)
|
|
resp.Body.Close()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
log.Printf("response from digitalocean: %s", body)
|
|
|
|
err = json.Unmarshal(body, &res)
|
|
if err != nil {
|
|
return errors.New(fmt.Sprintf("Failed to decode JSON response %s (HTTP %v) from DigitalOcean: %s", err.Error(),
|
|
resp.StatusCode, body))
|
|
}
|
|
switch resp.StatusCode {
|
|
case 403, 401, 429, 422, 404, 503, 500:
|
|
return errors.New(fmt.Sprintf("digitalocean request error: %+v", res))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (d DigitalOceanClientV2) Image(slug_or_name_or_id string) (Image, error) {
|
|
images, err := d.Images()
|
|
if err != nil {
|
|
return Image{}, err
|
|
}
|
|
|
|
for _, image := range images {
|
|
if strings.EqualFold(image.Slug, slug_or_name_or_id) {
|
|
return image, nil
|
|
}
|
|
}
|
|
|
|
for _, image := range images {
|
|
if strings.EqualFold(image.Name, slug_or_name_or_id) {
|
|
return image, nil
|
|
}
|
|
}
|
|
|
|
for _, image := range images {
|
|
id, err := strconv.Atoi(slug_or_name_or_id)
|
|
if err == nil {
|
|
if image.Id == uint(id) {
|
|
return image, nil
|
|
}
|
|
}
|
|
}
|
|
|
|
err = errors.New(fmt.Sprintf("Unknown image '%v'", slug_or_name_or_id))
|
|
|
|
return Image{}, err
|
|
}
|
|
|
|
// Returns all available regions.
|
|
func (d DigitalOceanClientV2) Regions() ([]Region, error) {
|
|
res := RegionsResp{}
|
|
err := NewRequestV2(d, "v2/regions?per_page=200", "GET", nil, &res)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return res.Regions, nil
|
|
}
|
|
|
|
func (d DigitalOceanClientV2) Region(slug_or_name_or_id string) (Region, error) {
|
|
regions, err := d.Regions()
|
|
if err != nil {
|
|
return Region{}, err
|
|
}
|
|
|
|
for _, region := range regions {
|
|
if strings.EqualFold(region.Slug, slug_or_name_or_id) {
|
|
return region, nil
|
|
}
|
|
}
|
|
|
|
for _, region := range regions {
|
|
if strings.EqualFold(region.Name, slug_or_name_or_id) {
|
|
return region, nil
|
|
}
|
|
}
|
|
|
|
for _, region := range regions {
|
|
id, err := strconv.Atoi(slug_or_name_or_id)
|
|
if err == nil {
|
|
if region.Id == uint(id) {
|
|
return region, nil
|
|
}
|
|
}
|
|
}
|
|
|
|
err = errors.New(fmt.Sprintf("Unknown region '%v'", slug_or_name_or_id))
|
|
|
|
return Region{}, err
|
|
}
|
|
|
|
// Returns all available sizes.
|
|
func (d DigitalOceanClientV2) Sizes() ([]Size, error) {
|
|
res := SizesResp{}
|
|
err := NewRequestV2(d, "v2/sizes?per_page=200", "GET", nil, &res)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return res.Sizes, nil
|
|
}
|
|
|
|
func (d DigitalOceanClientV2) Size(slug_or_name_or_id string) (Size, error) {
|
|
sizes, err := d.Sizes()
|
|
if err != nil {
|
|
return Size{}, err
|
|
}
|
|
|
|
for _, size := range sizes {
|
|
if strings.EqualFold(size.Slug, slug_or_name_or_id) {
|
|
return size, nil
|
|
}
|
|
}
|
|
|
|
for _, size := range sizes {
|
|
if strings.EqualFold(size.Name, slug_or_name_or_id) {
|
|
return size, nil
|
|
}
|
|
}
|
|
|
|
for _, size := range sizes {
|
|
id, err := strconv.Atoi(slug_or_name_or_id)
|
|
if err == nil {
|
|
if size.Id == uint(id) {
|
|
return size, nil
|
|
}
|
|
}
|
|
}
|
|
|
|
err = errors.New(fmt.Sprintf("Unknown size '%v'", slug_or_name_or_id))
|
|
|
|
return Size{}, err
|
|
}
|