Merge "Add create vm script and foreman config"
[genesis.git] / opensteak / tools / opensteak / foreman_objects / api.py
1 #!/usr/bin/python3
2 # -*- coding: utf-8 -*-
3 # Licensed under the Apache License, Version 2.0 (the "License"); you may
4 # not use this file except in compliance with the License. You may obtain
5 # a copy of the License at
6 #
7 #      http://www.apache.org/licenses/LICENSE-2.0
8 #
9 # Unless required by applicable law or agreed to in writing, software
10 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
11 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
12 # License for the specific language governing permissions and limitations
13 # under the License.
14 #
15 # Authors:
16 # @author: David Blaisonneau <david.blaisonneau@orange.com>
17 # @author: Arnaud Morin <arnaud1.morin@orange.com>
18
19 import json
20 import requests
21 from requests_futures.sessions import FuturesSession
22 from pprint import pformat
23
24
25 class Api:
26     """
27     Api class
28     Class to deal with the foreman API v2
29     """
30     def __init__(self, password, login='admin', ip='127.0.0.1', printErrors=False):
31         """ Function __init__
32         Init the API with the connection params
33
34         @param password: authentication password
35         @param password: authentication login - default is admin
36         @param ip: api ip - default is localhost
37         @return RETURN: self
38         """
39         self.base_url = 'http://{}/api/v2/'.format(ip)
40         self.headers = {'Accept': 'version=2',
41                         'Content-Type': 'application/json; charset=UTF-8'}
42         self.auth = (login, password)
43         self.errorMsg = ''
44         self.printErrors = printErrors
45
46     def list(self, obj, filter=False, only_id=False, limit=20):
47         """ Function list
48         Get the list of an object
49
50         @param obj: object name ('hosts', 'puppetclasses'...)
51         @param filter: filter for objects
52         @param only_id: boolean to only return dict with name/id
53         @return RETURN: the list of the object
54         """
55         self.url = '{}{}/?per_page={}'.format(self.base_url, obj, limit)
56         if filter:
57             self.url += '&search={}'.format(filter)
58         self.resp = requests.get(url=self.url, auth=self.auth,
59                                  headers=self.headers)
60         if only_id:
61             if self.__process_resp__(obj) is False:
62                 return False
63             if type(self.res['results']) is list:
64                 return dict((x['name'], x['id']) for x in self.res['results'])
65             elif type(self.res['results']) is dict:
66                 r = {}
67                 for v in self.res['results'].values():
68                     for vv in v:
69                         r[vv['name']] = vv['id']
70                 return r
71             else:
72                 return False
73         else:
74             return self.__process_resp__(obj)
75
76     def get(self, obj, id, sub_object=None):
77         """ Function get
78         Get an object by id
79
80         @param obj: object name ('hosts', 'puppetclasses'...)
81         @param id: the id of the object (name or id)
82         @return RETURN: the targeted object
83         """
84         self.url = '{}{}/{}'.format(self.base_url, obj, id)
85         if sub_object:
86             self.url += '/' + sub_object
87         self.resp = requests.get(url=self.url, auth=self.auth,
88                                  headers=self.headers)
89         if self.__process_resp__(obj):
90             return self.res
91         return False
92
93     def get_id_by_name(self, obj, name):
94         """ Function get_id_by_name
95         Get the id of an object
96
97         @param obj: object name ('hosts', 'puppetclasses'...)
98         @param id: the id of the object (name or id)
99         @return RETURN: the targeted object
100         """
101         list = self.list(obj, filter='name = "{}"'.format(name),
102                          only_id=True, limit=1)
103         return list[name] if name in list.keys() else False
104
105     def set(self, obj, id, payload, action='', async=False):
106         """ Function set
107         Set an object by id
108
109         @param obj: object name ('hosts', 'puppetclasses'...)
110         @param id: the id of the object (name or id)
111         @param action: specific action of an object ('power'...)
112         @param payload: the dict of the payload
113         @param async: should this request be async, if true use
114                         return.result() to get the response
115         @return RETURN: the server response
116         """
117         self.url = '{}{}/{}'.format(self.base_url, obj, id)
118         if action:
119             self.url += '/{}'.format(action)
120         self.payload = json.dumps(payload)
121         if async:
122             session = FuturesSession()
123             return session.put(url=self.url, auth=self.auth,
124                                headers=self.headers, data=self.payload)
125         else:
126             self.resp = requests.put(url=self.url, auth=self.auth,
127                                      headers=self.headers, data=self.payload)
128             if self.__process_resp__(obj):
129                 return self.res
130             return False
131
132     def create(self, obj, payload, async=False):
133         """ Function create
134         Create an new object
135
136         @param obj: object name ('hosts', 'puppetclasses'...)
137         @param payload: the dict of the payload
138         @param async: should this request be async, if true use
139                         return.result() to get the response
140         @return RETURN: the server response
141         """
142         self.url = self.base_url + obj
143         self.payload = json.dumps(payload)
144         if async:
145             session = FuturesSession()
146             return session.post(url=self.url, auth=self.auth,
147                                 headers=self.headers, data=self.payload)
148         else:
149             self.resp = requests.post(url=self.url, auth=self.auth,
150                                       headers=self.headers,
151                                       data=self.payload)
152             return self.__process_resp__(obj)
153
154     def delete(self, obj, id):
155         """ Function delete
156         Delete an object by id
157
158         @param obj: object name ('hosts', 'puppetclasses'...)
159         @param id: the id of the object (name or id)
160         @return RETURN: the server response
161         """
162         self.url = '{}{}/{}'.format(self.base_url, obj, id)
163         self.resp = requests.delete(url=self.url,
164                                     auth=self.auth,
165                                     headers=self.headers, )
166         return self.__process_resp__(obj)
167
168     def __process_resp__(self, obj):
169         """ Function __process_resp__
170         Process the response sent by the server and store the result
171
172         @param obj: object name ('hosts', 'puppetclasses'...)
173         @return RETURN: the server response
174         """
175         self.last_obj = obj
176         if self.resp.status_code > 299:
177             self.errorMsg = ">> Error {} for object '{}'".format(self.resp.status_code,
178                                                                  self.last_obj)
179             try:
180                 self.ret = json.loads(self.resp.text)
181                 self.errorMsg += pformat(self.ret[list(self.ret.keys())[0]])
182             except:
183                 self.ret = self.resp.text
184                 self.errorMsg += self.ret
185             if self.printErrors:
186                 print(self.errorMsg)
187             return False
188         self.res = json.loads(self.resp.text)
189         if 'results' in self.res.keys():
190             return self.res['results']
191         return self.res
192
193     def __str__(self):
194         ret = pformat(self.base_url) + "\n"
195         ret += pformat(self.headers) + "\n"
196         ret += pformat(self.auth) + "\n"
197         return ret