1package configgtm
2
3import (
4	"github.com/akamai/AkamaiOPEN-edgegrid-golang/client-v1"
5
6	"fmt"
7	"strconv"
8)
9
10//
11// Handle Operations on gtm datacenters
12// Based on 1.3 schema
13//
14
15// Datacenter represents a GTM datacenter
16type Datacenter struct {
17	City                       string      `json:"city,omitempty"`
18	CloneOf                    int         `json:"cloneOf,omitempty"`
19	CloudServerTargeting       bool        `json:"cloudServerTargeting"`
20	Continent                  string      `json:"continent,omitempty"`
21	Country                    string      `json:"country,omitempty"`
22	DefaultLoadObject          *LoadObject `json:"defaultLoadObject,omitempty"`
23	Latitude                   float64     `json:"latitude,omitempty"`
24	Links                      []*Link     `json:"links,omitempty"`
25	Longitude                  float64     `json:"longitude,omitempty"`
26	Nickname                   string      `json:"nickname,omitempty"`
27	PingInterval               int         `json:"pingInterval,omitempty"`
28	PingPacketSize             int         `json:"pingPacketSize,omitempty"`
29	DatacenterId               int         `json:"datacenterId,omitempty"`
30	ScorePenalty               int         `json:"scorePenalty,omitempty"`
31	ServermonitorLivenessCount int         `json:"servermonitorLivenessCount,omitempty"`
32	ServermonitorLoadCount     int         `json:"servermonitorLoadCount,omitempty"`
33	ServermonitorPool          string      `json:"servermonitorPool,omitempty"`
34	StateOrProvince            string      `json:"stateOrProvince,omitempty"`
35	Virtual                    bool        `json:"virtual"`
36}
37
38type DatacenterList struct {
39	DatacenterItems []*Datacenter `json:"items"`
40}
41
42// NewDatacenterResponse instantiates a new DatacenterResponse structure
43func NewDatacenterResponse() *DatacenterResponse {
44	dcResp := &DatacenterResponse{}
45	return dcResp
46}
47
48// NewDatacenter creates a new Datacenter object
49func NewDatacenter() *Datacenter {
50	dc := &Datacenter{}
51	return dc
52}
53
54// ListDatacenters retreieves all Datacenters
55func ListDatacenters(domainName string) ([]*Datacenter, error) {
56	dcs := &DatacenterList{}
57	req, err := client.NewRequest(
58		Config,
59		"GET",
60		fmt.Sprintf("/config-gtm/v1/domains/%s/datacenters", domainName),
61		nil,
62	)
63	if err != nil {
64		return nil, err
65	}
66
67	setVersionHeader(req, schemaVersion)
68
69	printHttpRequest(req, true)
70
71	res, err := client.Do(Config, req)
72	if err != nil {
73		return nil, err
74	}
75
76	printHttpResponse(res, true)
77
78	if client.IsError(res) && res.StatusCode != 404 {
79		return nil, client.NewAPIError(res)
80	} else if res.StatusCode == 404 {
81		return nil, CommonError{entityName: "Datacenter"}
82	} else {
83		err = client.BodyJSON(res, dcs)
84		if err != nil {
85			return nil, err
86		}
87
88		return dcs.DatacenterItems, nil
89	}
90}
91
92// GetDatacenter retrieves a Datacenter with the given name. NOTE: Id arg is int!
93func GetDatacenter(dcID int, domainName string) (*Datacenter, error) {
94
95	dc := NewDatacenter()
96	req, err := client.NewRequest(
97		Config,
98		"GET",
99		fmt.Sprintf("/config-gtm/v1/domains/%s/datacenters/%s", domainName, strconv.Itoa(dcID)),
100		nil,
101	)
102	if err != nil {
103		return nil, err
104	}
105
106	setVersionHeader(req, schemaVersion)
107
108	printHttpRequest(req, true)
109
110	res, err := client.Do(Config, req)
111	if err != nil {
112		return nil, err
113	}
114
115	printHttpRequest(req, true)
116
117	if client.IsError(res) && res.StatusCode != 404 {
118		return nil, client.NewAPIError(res)
119	} else if res.StatusCode == 404 {
120		return nil, CommonError{entityName: "Datacenter", name: strconv.Itoa(dcID)}
121	} else {
122		err = client.BodyJSON(res, dc)
123		if err != nil {
124			return nil, err
125		}
126
127		return dc, nil
128	}
129}
130
131// Create the datacenter identified by the receiver argument in the specified domain.
132func (dc *Datacenter) Create(domainName string) (*DatacenterResponse, error) {
133
134	req, err := client.NewJSONRequest(
135		Config,
136		"POST",
137		fmt.Sprintf("/config-gtm/v1/domains/%s/datacenters", domainName),
138		dc,
139	)
140	if err != nil {
141		return nil, err
142	}
143
144	setVersionHeader(req, schemaVersion)
145
146	printHttpRequest(req, true)
147
148	res, err := client.Do(Config, req)
149
150	// Network
151	if err != nil {
152		return nil, CommonError{
153			entityName:       "Domain",
154			name:             domainName,
155			httpErrorMessage: err.Error(),
156			err:              err,
157		}
158	}
159
160	printHttpResponse(res, true)
161
162	// API error
163	if client.IsError(res) {
164		err := client.NewAPIError(res)
165		return nil, CommonError{entityName: "Domain", name: domainName, apiErrorMessage: err.Detail, err: err}
166	}
167
168	responseBody := NewDatacenterResponse()
169	// Unmarshall whole response body for updated DC and in case want status
170	err = client.BodyJSON(res, responseBody)
171	if err != nil {
172		return nil, err
173	}
174
175	return responseBody, nil
176
177}
178
179// Update the datacenter identified in the receiver argument in the provided domain.
180func (dc *Datacenter) Update(domainName string) (*ResponseStatus, error) {
181
182	req, err := client.NewJSONRequest(
183		Config,
184		"PUT",
185		fmt.Sprintf("/config-gtm/v1/domains/%s/datacenters/%s", domainName, strconv.Itoa(dc.DatacenterId)),
186		dc,
187	)
188	if err != nil {
189		return nil, err
190	}
191
192	setVersionHeader(req, schemaVersion)
193
194	printHttpRequest(req, true)
195
196	res, err := client.Do(Config, req)
197
198	// Network error
199	if err != nil {
200		return nil, CommonError{
201			entityName:       "Datacenter",
202			name:             strconv.Itoa(dc.DatacenterId),
203			httpErrorMessage: err.Error(),
204			err:              err,
205		}
206	}
207
208	printHttpResponse(res, true)
209
210	// API error
211	if client.IsError(res) {
212		err := client.NewAPIError(res)
213		return nil, CommonError{entityName: "Datacenter", name: strconv.Itoa(dc.DatacenterId), apiErrorMessage: err.Detail, err: err}
214	}
215
216	responseBody := NewDatacenterResponse()
217	// Unmarshall whole response body for updated entity and in case want status
218	err = client.BodyJSON(res, responseBody)
219	if err != nil {
220		return nil, err
221	}
222
223	return responseBody.Status, nil
224}
225
226// Delete the datacenter identified by the receiver argument from the domain specified.
227func (dc *Datacenter) Delete(domainName string) (*ResponseStatus, error) {
228
229	req, err := client.NewRequest(
230		Config,
231		"DELETE",
232		fmt.Sprintf("/config-gtm/v1/domains/%s/datacenters/%s", domainName, strconv.Itoa(dc.DatacenterId)),
233		nil,
234	)
235	if err != nil {
236		return nil, err
237	}
238
239	setVersionHeader(req, schemaVersion)
240
241	printHttpRequest(req, true)
242
243	res, err := client.Do(Config, req)
244	if err != nil {
245		return nil, err
246	}
247
248	printHttpResponse(res, true)
249
250	// Network error
251	if err != nil {
252		return nil, CommonError{
253			entityName:       "Datacenter",
254			name:             strconv.Itoa(dc.DatacenterId),
255			httpErrorMessage: err.Error(),
256			err:              err,
257		}
258	}
259
260	// API error
261	if client.IsError(res) {
262		err := client.NewAPIError(res)
263		return nil, CommonError{entityName: "Datacenter", name: strconv.Itoa(dc.DatacenterId), apiErrorMessage: err.Detail, err: err}
264	}
265
266	responseBody := NewDatacenterResponse()
267	// Unmarshall whole response body in case want status
268	err = client.BodyJSON(res, responseBody)
269	if err != nil {
270		return nil, err
271	}
272
273	return responseBody.Status, nil
274}
275