1package egoscale
2
3import (
4	"encoding/json"
5	"fmt"
6	"net/url"
7	"regexp"
8	"strings"
9)
10
11func (exo *Client) GetSecurityGroups() (map[string]string, error) {
12	var sgs map[string]string
13	params := url.Values{}
14	resp, err := exo.Request("listSecurityGroups", params)
15
16	if err != nil {
17		return nil, err
18	}
19
20	var r ListSecurityGroupsResponse
21	if err := json.Unmarshal(resp, &r); err != nil {
22		return nil, err
23	}
24
25	sgs = make(map[string]string)
26	for _, sg := range r.SecurityGroups {
27		sgs[sg.Name] = sg.Id
28	}
29	return sgs, nil
30}
31
32func (exo *Client) GetSecurityGroupId(name string) (string, error) {
33	params := url.Values{}
34	resp, err := exo.Request("listSecurityGroups", params); if err != nil {
35		return "", err
36	}
37
38	var r ListSecurityGroupsResponse
39	err = json.Unmarshal(resp, &r); if err != nil {
40		return "", err
41	}
42
43	for _, sg := range r.SecurityGroups {
44		if sg.Name == name {
45			return sg.Id, nil
46		}
47	}
48
49	return "", nil
50}
51
52func (exo *Client) GetZones() (map[string]string, error) {
53	var zones map[string]string
54	params := url.Values{}
55	resp, err := exo.Request("listZones", params)
56
57	if err != nil {
58		return nil, err
59	}
60
61	var r ListZonesResponse
62	if err := json.Unmarshal(resp, &r); err != nil {
63		return nil, err
64	}
65
66	zones = make(map[string]string)
67	for _, zone := range r.Zones {
68		zones[zone.Name] = zone.Id
69	}
70	return zones, nil
71}
72
73func (exo *Client) GetProfiles() (map[string]string, error) {
74
75	var profiles map[string]string
76	params := url.Values{}
77	resp, err := exo.Request("listServiceOfferings", params)
78
79	if err != nil {
80		return nil, err
81	}
82
83	var r ListServiceOfferingsResponse
84	if err := json.Unmarshal(resp, &r); err != nil {
85		return nil, err
86	}
87
88	profiles = make(map[string]string)
89	for _, offering := range r.ServiceOfferings {
90		profiles[strings.ToLower(offering.Name)] = offering.Id
91	}
92
93	return profiles, nil
94}
95
96func (exo *Client) GetKeypairs() ([]SSHKeyPair, error) {
97	params := url.Values{}
98
99	resp, err := exo.Request("listSSHKeyPairs", params)
100
101	if err != nil {
102		return nil, err
103	}
104
105	var r ListSSHKeyPairsResponse
106	if err := json.Unmarshal(resp, &r); err != nil {
107		return nil, err
108	}
109
110	var keypairs = make([]SSHKeyPair, r.Count, r.Count)
111	for i, keypair := range r.SSHKeyPairs {
112		keypairs[i] = *keypair
113	}
114	return keypairs, nil
115}
116
117func (exo *Client) GetAffinityGroups() (map[string]string, error) {
118	var affinitygroups map[string]string
119	params := url.Values{}
120
121	resp, err := exo.Request("listAffinityGroups", params)
122
123	if err != nil {
124		return nil, err
125	}
126
127	var r ListAffinityGroupsResponse
128	if err := json.Unmarshal(resp, &r); err != nil {
129		return nil, err
130	}
131
132	affinitygroups = make(map[string]string)
133	for _, affinitygroup := range r.AffinityGroups {
134		affinitygroups[affinitygroup.Name] = affinitygroup.Id
135	}
136	return affinitygroups, nil
137
138}
139
140func (exo *Client) GetImages() (map[string]map[int]string, error) {
141	var images map[string]map[int]string
142	images = make(map[string]map[int]string)
143
144	params := url.Values{}
145	params.Set("templatefilter", "featured")
146
147	resp, err := exo.Request("listTemplates", params)
148
149	if err != nil {
150		return nil, err
151	}
152
153	var r ListTemplatesResponse
154	if err := json.Unmarshal(resp, &r); err != nil {
155		return nil, err
156	}
157
158	re := regexp.MustCompile(`^Linux (?P<name>.+?) (?P<version>[0-9.]+).*$`)
159	for _, template := range r.Templates {
160		size := int(template.Size / (1024 * 1024 * 1024))
161		submatch := re.FindStringSubmatch(template.Name)
162		if len(submatch) > 0 {
163			name := strings.Replace(strings.ToLower(submatch[1]), " ", "-", -1)
164			version := submatch[2]
165			image := fmt.Sprintf("%s-%s", name, version)
166
167			_, present := images[image]
168			if !present {
169				images[image] = make(map[int]string)
170			}
171			images[image][size] = template.Id
172
173			images[fmt.Sprintf("%s-%s", name, version)][size] = template.Id
174		}
175	}
176	return images, nil
177}
178
179func (exo *Client) GetTopology() (*Topology, error) {
180
181	zones, err := exo.GetZones()
182	if err != nil {
183		return nil, err
184	}
185	images, err := exo.GetImages()
186	if err != nil {
187		return nil, err
188	}
189	groups, err := exo.GetSecurityGroups()
190	if err != nil {
191		return nil, err
192	}
193	keypairs, err := exo.GetKeypairs()
194	if err != nil {
195		return nil, err
196	}
197
198	/* Convert the ssh keypair to contain just the name */
199	keynames := make([]string, len(keypairs))
200	for i, k := range keypairs {
201		keynames[i] = k.Name
202	}
203
204	affinitygroups, err := exo.GetAffinityGroups()
205	if err != nil {
206		return nil, err
207	}
208	profiles, err := exo.GetProfiles()
209	if err != nil {
210		return nil, err
211	}
212
213	topo := &Topology{
214		Zones:          zones,
215		Profiles:       profiles,
216		Images:         images,
217		Keypairs:       keynames,
218		AffinityGroups: affinitygroups,
219		SecurityGroups: groups,
220	}
221
222	return topo, nil
223}
224