1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
|
package hcloud
import (
"context"
"fmt"
"net/url"
"strconv"
"github.com/hetznercloud/hcloud-go/v2/hcloud/schema"
)
// ServerType represents a server type in the Hetzner Cloud.
type ServerType struct {
ID int64
Name string
Description string
Cores int
Memory float32
Disk int
StorageType StorageType
CPUType CPUType
Architecture Architecture
// IncludedTraffic is the free traffic per month in bytes
IncludedTraffic int64
Pricings []ServerTypeLocationPricing
DeprecatableResource
}
// StorageType specifies the type of storage.
type StorageType string
const (
// StorageTypeLocal is the type for local storage.
StorageTypeLocal StorageType = "local"
// StorageTypeCeph is the type for remote storage.
StorageTypeCeph StorageType = "ceph"
)
// CPUType specifies the type of the CPU.
type CPUType string
const (
// CPUTypeShared is the type for shared CPU.
CPUTypeShared CPUType = "shared"
// CPUTypeDedicated is the type for dedicated CPU.
CPUTypeDedicated CPUType = "dedicated"
)
// ServerTypeClient is a client for the server types API.
type ServerTypeClient struct {
client *Client
}
// GetByID retrieves a server type by its ID. If the server type does not exist, nil is returned.
func (c *ServerTypeClient) GetByID(ctx context.Context, id int64) (*ServerType, *Response, error) {
req, err := c.client.NewRequest(ctx, "GET", fmt.Sprintf("/server_types/%d", id), nil)
if err != nil {
return nil, nil, err
}
var body schema.ServerTypeGetResponse
resp, err := c.client.Do(req, &body)
if err != nil {
if IsError(err, ErrorCodeNotFound) {
return nil, resp, nil
}
return nil, nil, err
}
return ServerTypeFromSchema(body.ServerType), resp, nil
}
// GetByName retrieves a server type by its name. If the server type does not exist, nil is returned.
func (c *ServerTypeClient) GetByName(ctx context.Context, name string) (*ServerType, *Response, error) {
if name == "" {
return nil, nil, nil
}
serverTypes, response, err := c.List(ctx, ServerTypeListOpts{Name: name})
if len(serverTypes) == 0 {
return nil, response, err
}
return serverTypes[0], response, err
}
// Get retrieves a server type by its ID if the input can be parsed as an integer, otherwise it
// retrieves a server type by its name. If the server type does not exist, nil is returned.
func (c *ServerTypeClient) Get(ctx context.Context, idOrName string) (*ServerType, *Response, error) {
if id, err := strconv.ParseInt(idOrName, 10, 64); err == nil {
return c.GetByID(ctx, id)
}
return c.GetByName(ctx, idOrName)
}
// ServerTypeListOpts specifies options for listing server types.
type ServerTypeListOpts struct {
ListOpts
Name string
Sort []string
}
func (l ServerTypeListOpts) values() url.Values {
vals := l.ListOpts.Values()
if l.Name != "" {
vals.Add("name", l.Name)
}
for _, sort := range l.Sort {
vals.Add("sort", sort)
}
return vals
}
// List returns a list of server types for a specific page.
//
// Please note that filters specified in opts are not taken into account
// when their value corresponds to their zero value or when they are empty.
func (c *ServerTypeClient) List(ctx context.Context, opts ServerTypeListOpts) ([]*ServerType, *Response, error) {
path := "/server_types?" + opts.values().Encode()
req, err := c.client.NewRequest(ctx, "GET", path, nil)
if err != nil {
return nil, nil, err
}
var body schema.ServerTypeListResponse
resp, err := c.client.Do(req, &body)
if err != nil {
return nil, nil, err
}
serverTypes := make([]*ServerType, 0, len(body.ServerTypes))
for _, s := range body.ServerTypes {
serverTypes = append(serverTypes, ServerTypeFromSchema(s))
}
return serverTypes, resp, nil
}
// All returns all server types.
func (c *ServerTypeClient) All(ctx context.Context) ([]*ServerType, error) {
return c.AllWithOpts(ctx, ServerTypeListOpts{ListOpts: ListOpts{PerPage: 50}})
}
// AllWithOpts returns all server types for the given options.
func (c *ServerTypeClient) AllWithOpts(ctx context.Context, opts ServerTypeListOpts) ([]*ServerType, error) {
allServerTypes := []*ServerType{}
err := c.client.all(func(page int) (*Response, error) {
opts.Page = page
serverTypes, resp, err := c.List(ctx, opts)
if err != nil {
return resp, err
}
allServerTypes = append(allServerTypes, serverTypes...)
return resp, nil
})
if err != nil {
return nil, err
}
return allServerTypes, nil
}
|
