325 lines
9.7 KiB
Go
325 lines
9.7 KiB
Go
package api
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"net/url"
|
|
"time"
|
|
)
|
|
|
|
// Server represents a server
|
|
type Server struct {
|
|
// Arch is the architecture target of the server
|
|
Arch string `json:"arch,omitempty"`
|
|
|
|
// Identifier is a unique identifier for the server
|
|
Identifier string `json:"id,omitempty"`
|
|
|
|
// Name is the user-defined name of the server
|
|
Name string `json:"name,omitempty"`
|
|
|
|
// CreationDate is the creation date of the server
|
|
CreationDate string `json:"creation_date,omitempty"`
|
|
|
|
// ModificationDate is the date of the last modification of the server
|
|
ModificationDate string `json:"modification_date,omitempty"`
|
|
|
|
// Image is the image used by the server
|
|
Image Image `json:"image,omitempty"`
|
|
|
|
// DynamicIPRequired is a flag that defines a server with a dynamic ip address attached
|
|
DynamicIPRequired *bool `json:"dynamic_ip_required,omitempty"`
|
|
|
|
// PublicIP is the public IP address bound to the server
|
|
PublicAddress IPAddress `json:"public_ip,omitempty"`
|
|
|
|
// State is the current status of the server
|
|
State string `json:"state,omitempty"`
|
|
|
|
// StateDetail is the detailed status of the server
|
|
StateDetail string `json:"state_detail,omitempty"`
|
|
|
|
// PrivateIP represents the private IPV4 attached to the server (changes on each boot)
|
|
PrivateIP string `json:"private_ip,omitempty"`
|
|
|
|
// Bootscript is the unique identifier of the selected bootscript
|
|
Bootscript *Bootscript `json:"bootscript,omitempty"`
|
|
|
|
// BootType defines the type of boot. Can be local or bootscript
|
|
BootType string `json:"boot_type,omitempty"`
|
|
|
|
// Hostname represents the ServerName in a format compatible with unix's hostname
|
|
Hostname string `json:"hostname,omitempty"`
|
|
|
|
// Tags represents user-defined tags
|
|
Tags []string `json:"tags,omitempty"`
|
|
|
|
// Volumes are the attached volumes
|
|
Volumes map[string]Volume `json:"volumes,omitempty"`
|
|
|
|
// SecurityGroup is the selected security group object
|
|
SecurityGroup SecurityGroupRef `json:"security_group,omitempty"`
|
|
|
|
// Organization is the owner of the server
|
|
Organization string `json:"organization,omitempty"`
|
|
|
|
// CommercialType is the commercial type of the server (i.e: C1, C2[SML], VC1S)
|
|
CommercialType string `json:"commercial_type,omitempty"`
|
|
|
|
// Location of the server
|
|
Location struct {
|
|
Platform string `json:"platform_id,omitempty"`
|
|
Chassis string `json:"chassis_id,omitempty"`
|
|
Cluster string `json:"cluster_id,omitempty"`
|
|
Hypervisor string `json:"hypervisor_id,omitempty"`
|
|
Blade string `json:"blade_id,omitempty"`
|
|
Node string `json:"node_id,omitempty"`
|
|
ZoneID string `json:"zone_id,omitempty"`
|
|
} `json:"location,omitempty"`
|
|
|
|
IPV6 *IPV6 `json:"ipv6,omitempty"`
|
|
|
|
EnableIPV6 bool `json:"enable_ipv6,omitempty"`
|
|
|
|
// This fields are not returned by the API, we generate it
|
|
DNSPublic string `json:"dns_public,omitempty"`
|
|
DNSPrivate string `json:"dns_private,omitempty"`
|
|
}
|
|
|
|
// ServerPatchDefinition represents a server with nullable fields (for PATCH)
|
|
type ServerPatchDefinition struct {
|
|
Arch *string `json:"arch,omitempty"`
|
|
Name *string `json:"name,omitempty"`
|
|
CreationDate *string `json:"creation_date,omitempty"`
|
|
ModificationDate *string `json:"modification_date,omitempty"`
|
|
Image *Image `json:"image,omitempty"`
|
|
DynamicIPRequired *bool `json:"dynamic_ip_required,omitempty"`
|
|
PublicAddress *IPAddress `json:"public_ip,omitempty"`
|
|
State *string `json:"state,omitempty"`
|
|
StateDetail *string `json:"state_detail,omitempty"`
|
|
PrivateIP *string `json:"private_ip,omitempty"`
|
|
Bootscript *string `json:"bootscript,omitempty"`
|
|
Hostname *string `json:"hostname,omitempty"`
|
|
Volumes *map[string]Volume `json:"volumes,omitempty"`
|
|
SecurityGroup *SecurityGroupRef `json:"security_group,omitempty"`
|
|
Organization *string `json:"organization,omitempty"`
|
|
Tags *[]string `json:"tags,omitempty"`
|
|
IPV6 *IPV6 `json:"ipv6,omitempty"`
|
|
EnableIPV6 *bool `json:"enable_ipv6,omitempty"`
|
|
}
|
|
|
|
// ServerDefinition represents a server with image definition
|
|
type ServerDefinition struct {
|
|
// Name is the user-defined name of the server
|
|
Name string `json:"name"`
|
|
|
|
// Image is the image used by the server
|
|
Image *string `json:"image,omitempty"`
|
|
|
|
// Volumes are the attached volumes
|
|
Volumes map[string]string `json:"volumes,omitempty"`
|
|
|
|
// DynamicIPRequired is a flag that defines a server with a dynamic ip address attached
|
|
DynamicIPRequired *bool `json:"dynamic_ip_required,omitempty"`
|
|
|
|
// Bootscript is the bootscript used by the server
|
|
Bootscript *string `json:"bootscript"`
|
|
|
|
// Tags are the metadata tags attached to the server
|
|
Tags []string `json:"tags,omitempty"`
|
|
|
|
// Organization is the owner of the server
|
|
Organization string `json:"organization"`
|
|
|
|
// CommercialType is the commercial type of the server (i.e: C1, C2[SML], VC1S)
|
|
CommercialType string `json:"commercial_type"`
|
|
|
|
// BootType defines the type of boot. Can be local or bootscript
|
|
BootType string `json:"boot_type,omitempty"`
|
|
|
|
PublicIP string `json:"public_ip,omitempty"`
|
|
|
|
EnableIPV6 bool `json:"enable_ipv6,omitempty"`
|
|
|
|
SecurityGroup string `json:"security_group,omitempty"`
|
|
}
|
|
|
|
// Servers represents a group of servers
|
|
type Servers struct {
|
|
// Servers holds servers of the response
|
|
Servers []Server `json:"servers,omitempty"`
|
|
}
|
|
|
|
// ServerAction represents an action to perform on a server
|
|
type ServerAction struct {
|
|
// Action is the name of the action to trigger
|
|
Action string `json:"action,omitempty"`
|
|
}
|
|
|
|
// OneServer represents the response of a GET /servers/UUID API call
|
|
type OneServer struct {
|
|
Server Server `json:"server,omitempty"`
|
|
}
|
|
|
|
// PatchServer updates a server
|
|
func (s *API) PatchServer(serverID string, definition ServerPatchDefinition) error {
|
|
resp, err := s.PatchResponse(s.computeAPI, fmt.Sprintf("servers/%s", serverID), definition)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
if _, err := s.handleHTTPError([]int{http.StatusOK}, resp); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// GetServers gets the list of servers from the API
|
|
func (s *API) GetServers(all bool, limit int) ([]Server, error) {
|
|
query := url.Values{}
|
|
if !all {
|
|
query.Set("state", "running")
|
|
}
|
|
// TODO per_page=20&page=2&state=running
|
|
if limit > 0 {
|
|
// FIXME: wait for the API to be ready
|
|
// query.Set("per_page", strconv.Itoa(limit))
|
|
panic("Not implemented yet")
|
|
}
|
|
|
|
servers, err := s.fetchServers(query)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
for i, server := range servers.Servers {
|
|
servers.Servers[i].DNSPublic = server.Identifier + URLPublicDNS
|
|
servers.Servers[i].DNSPrivate = server.Identifier + URLPrivateDNS
|
|
}
|
|
return servers.Servers, nil
|
|
}
|
|
|
|
// SortServers represents a wrapper to sort by CreationDate the servers
|
|
type SortServers []Server
|
|
|
|
func (s SortServers) Len() int {
|
|
return len(s)
|
|
}
|
|
|
|
func (s SortServers) Swap(i, j int) {
|
|
s[i], s[j] = s[j], s[i]
|
|
}
|
|
|
|
func (s SortServers) Less(i, j int) bool {
|
|
date1, _ := time.Parse("2006-01-02T15:04:05.000000+00:00", s[i].CreationDate)
|
|
date2, _ := time.Parse("2006-01-02T15:04:05.000000+00:00", s[j].CreationDate)
|
|
return date2.Before(date1)
|
|
}
|
|
|
|
// GetServer gets a server from the API
|
|
func (s *API) GetServer(serverID string) (*Server, error) {
|
|
if serverID == "" {
|
|
return nil, fmt.Errorf("cannot get server without serverID")
|
|
}
|
|
resp, err := s.GetResponsePaginate(s.computeAPI, "servers/"+serverID, url.Values{})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
body, err := s.handleHTTPError([]int{http.StatusOK}, resp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var oneServer OneServer
|
|
|
|
if err = json.Unmarshal(body, &oneServer); err != nil {
|
|
return nil, err
|
|
}
|
|
// FIXME arch, owner, title
|
|
oneServer.Server.DNSPublic = oneServer.Server.Identifier + URLPublicDNS
|
|
oneServer.Server.DNSPrivate = oneServer.Server.Identifier + URLPrivateDNS
|
|
return &oneServer.Server, nil
|
|
}
|
|
|
|
// PostServerAction posts an action on a server
|
|
func (s *API) PostServerAction(serverID, action string) (*Task, error) {
|
|
data := ServerAction{
|
|
Action: action,
|
|
}
|
|
resp, err := s.PostResponse(s.computeAPI, fmt.Sprintf("servers/%s/action", serverID), data)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
body, err := s.handleHTTPError([]int{http.StatusAccepted}, resp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var t oneTask
|
|
if err = json.Unmarshal(body, &t); err != nil {
|
|
return nil, err
|
|
}
|
|
return &t.Task, err
|
|
}
|
|
|
|
func (s *API) fetchServers(query url.Values) (*Servers, error) {
|
|
resp, err := s.GetResponsePaginate(s.computeAPI, "servers", query)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
body, err := s.handleHTTPError([]int{http.StatusOK}, resp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var servers Servers
|
|
|
|
if err = json.Unmarshal(body, &servers); err != nil {
|
|
return nil, err
|
|
}
|
|
return &servers, nil
|
|
}
|
|
|
|
// DeleteServer deletes a server
|
|
func (s *API) DeleteServer(serverID string) error {
|
|
resp, err := s.DeleteResponse(s.computeAPI, fmt.Sprintf("servers/%s", serverID))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
if _, err = s.handleHTTPError([]int{http.StatusNoContent}, resp); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// CreateServer creates a new server
|
|
func (s *API) CreateServer(definition ServerDefinition) (*Server, error) {
|
|
definition.Organization = s.Organization
|
|
|
|
resp, err := s.PostResponse(s.computeAPI, "servers", definition)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
body, err := s.handleHTTPError([]int{http.StatusCreated}, resp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var data OneServer
|
|
|
|
if err = json.Unmarshal(body, &data); err != nil {
|
|
return nil, err
|
|
}
|
|
return &data.Server, nil
|
|
}
|