source: ogClient-Git/src/ogRest.py @ b2fd0b5

Last change on this file since b2fd0b5 was b2fd0b5, checked in by Alvaro Neira Ayuso <alvaroneay@…>, 5 years ago

Add image/create command for creating a new image

This patch allows us to use a new support for creating images using ogClient.
ogClient receives from the server a message which json body must be:

{"disk" : "1", "partition" : "1", "code" : "1", "id" : "1", "name" : "test",
"repository" : "192.168.2.4" }

ogClient returns to the server the software inventory executed before
create the image. The message for the server is:

{ "disk" : "0", "partition" : "1", "software" : "xyz" }

"xyz" will be the output saved during the execution of InventarioSoftware? in
a specific path.
  • Property mode set to 100644
File size: 7.8 KB
Line 
1#
2# Copyright (C) 2020 Soleta Networks <info@soleta.eu>
3#
4# This program is free software: you can redistribute it and/or modify it under
5# the terms of the GNU Affero General Public License as published by the
6# Free Software Foundation, version 3.
7#
8
9import threading
10import platform
11import time
12from enum import Enum
13import json
14import queue
15import sys
16import os
17import signal
18
19from src.HTTPParser import *
20
21if platform.system() == 'Linux':
22        from src.linux import ogOperations
23
24class jsonResponse():
25        def __init__(self):
26                self.jsontree = {}
27
28        def addElement(self, key, value):
29                self.jsontree[key] = value
30
31        def dumpMsg(self):
32                return json.dumps(self.jsontree)
33
34class restResponse():
35        def getResponse(response, jsonResp=None):
36                msg = ''
37                if response == ogResponses.BAD_REQUEST:
38                        msg = 'HTTP/1.0 400 Bad Request'
39                elif response == ogResponses.IN_PROGRESS:
40                        msg = 'HTTP/1.0 202 Accepted'
41                elif response == ogResponses.OK:
42                        msg = 'HTTP/1.0 200 OK'
43                elif response == ogResponses.INTERNAL_ERR:
44                        msg = 'HTTP/1.0 500 Internal Server Error'
45                elif response == ogResponses.UNAUTHORIZED:
46                        msg = 'HTTP/1.0 401 Unauthorized'
47                else:
48                        return msg
49
50                msg += '\r\n'
51
52                if jsonResp:
53                        msg += 'Content-Length:' + str(len(jsonResp.dumpMsg()))
54                        msg += '\r\nContent-Type:application/json'
55                        msg += '\r\n\r\n' + jsonResp.dumpMsg()
56                else:
57                        msg += '\r\n'
58
59                return msg
60
61class ogThread():
62        # Executing cmd thread
63        def execcmd(client, httpparser, ogRest):
64                if httpparser.getCMD() == None:
65                        client.send(restResponse.getResponse(ogResponses.BAD_REQUEST))
66                        return
67
68                try:
69                        shellout = ogOperations.execCMD(httpparser, ogRest)
70                except ValueError as err:
71                        client.send(restResponse.getResponse(ogResponses.BAD_REQUEST))
72                        return
73
74                if httpparser.getEcho():
75                        jsonResp = jsonResponse()
76                        jsonResp.addElement('out', shellout)
77                        client.send(restResponse.getResponse(ogResponses.OK, jsonResp))
78                else:
79                        client.send(restResponse.getResponse(ogResponses.OK))
80
81        # Powering off thread
82        def poweroff():
83                time.sleep(2)
84                ogOperations.poweroff()
85
86        # Rebooting thread
87        def reboot():
88                ogOperations.reboot()
89
90        # Process session
91        def procsession(client, httpparser, ogRest):
92                try:
93                        ogOperations.procsession(httpparser, ogRest)
94                except ValueError as err:
95                        client.send(restResponse.getResponse(ogResponses.INTERNAL_ERR))
96                        return
97
98                client.send(restResponse.getResponse(ogResponses.OK))
99
100        # Process software
101        def procsoftware(client, httpparser, path, ogRest):
102                try:
103                        ogOperations.procsoftware(httpparser, path, ogRest)
104                except ValueError as err:
105                        client.send(restResponse.getResponse(ogResponses.INTERNAL_ERR))
106                        return
107
108                jsonResp = jsonResponse()
109                jsonResp.addElement('disk', httpparser.getDisk())
110                jsonResp.addElement('partition', httpparser.getPartition())
111
112                f = open(path, "r")
113                lines = f.readlines()
114                f.close()
115                jsonResp.addElement('software', lines[0])
116
117                client.send(restResponse.getResponse(ogResponses.OK, jsonResp))
118
119        # Process hardware
120        def prochardware(client, path, ogRest):
121                try:
122                        ogOperations.prochardware(path, ogRest)
123                except ValueError as err:
124                        client.send(restResponse.getResponse(ogResponses.INTERNAL_ERR))
125                        return
126
127                jsonResp = jsonResponse()
128                f = open(path, "r")
129                lines = f.readlines()
130                f.close()
131                jsonResp.addElement('hardware', lines[0])
132                client.send(restResponse.getResponse(ogResponses.OK, jsonResp))
133
134        # Process setup
135        def procsetup(client, httpparser, ogRest):
136                jsonResp = jsonResponse()
137                jsonResp.addElement('disk', httpparser.getDisk())
138                jsonResp.addElement('cache', httpparser.getCache())
139                jsonResp.addElement('cache_size', httpparser.getCacheSize())
140                listconfig = ogOperations.procsetup(httpparser, ogRest)
141                jsonResp.addElement('partition_setup', listconfig)
142                client.send(restResponse.getResponse(ogResponses.OK, jsonResp))
143
144        # Process image restore
145        def procirestore(client, httpparser, ogRest):
146                try:
147                        ogOperations.procirestore(httpparser, ogRest)
148                except ValueError as err:
149                        client.send(restResponse.getResponse(ogResponses.INTERNAL_ERR))
150                        return
151
152                client.send(restResponse.getResponse(ogResponses.OK))
153
154        # Process image create
155        def procicreate(client, path, httpparser, ogRest):
156                try:
157                        ogOperations.procicreate(path, httpparser, ogRest)
158                except ValueError as err:
159                        client.send(restResponse.getResponse(ogResponses.INTERNAL_ERR))
160                        return
161
162                f = open(path, "r")
163                lines = f.readlines()
164                f.close()
165                jsonResp.addElement('software', lines[0])
166                client.send(restResponse.getResponse(ogResponses.OK, jsonResp))
167
168class ogResponses(Enum):
169        BAD_REQUEST=0
170        IN_PROGRESS=1
171        OK=2
172        INTERNAL_ERR=3
173        UNAUTHORIZED=4
174
175class ogRest():
176        def __init__(self):
177                self.proc = None
178                self.terminated = False
179
180        def processOperation(self, httpparser, client):
181                op = httpparser.getRequestOP()
182                URI = httpparser.getURI()
183
184                if (not "stop" in URI and not self.proc == None and self.proc.poll() == None):
185                        client.send(restResponse.getResponse(ogResponses.UNAUTHORIZED))
186                        return
187
188                if ("GET" in op):
189                        if "hardware" in URI:
190                                self.process_hardware(client)
191                        elif ("run/schedule" in URI):
192                                self.process_schedule(client)
193                        else:
194                                client.send(restResponse.getResponse(ogResponses.BAD_REQUEST))
195                elif ("POST" in op):
196                        if ("poweroff" in URI):
197                                self.process_poweroff(client)
198                        elif "probe" in URI:
199                                self.process_probe(client)
200                        elif ("reboot" in URI):
201                                self.process_reboot(client)
202                        elif ("shell/run" in URI):
203                                self.process_shellrun(client, httpparser)
204                        elif ("session" in URI):
205                                self.process_session(client, httpparser)
206                        elif ("software" in URI):
207                                self.process_software(client, httpparser)
208                        elif ("setup" in URI):
209                                self.process_setup(client, httpparser)
210                        elif ("image/restore" in URI):
211                                self.process_irestore(client, httpparser)
212                        elif ("stop" in URI):
213                                self.process_stop(client)
214                        elif ("image/create" in URI):
215                                self.process_icreate(client, httpparser)
216                        else:
217                                client.send(restResponse.getResponse(ogResponses.BAD_REQUEST))
218                else:
219                        client.send(restResponse.getResponse(ogResponses.BAD_REQUEST))
220
221                return 0
222
223        def process_reboot(self, client):
224                client.send(restResponse.getResponse(ogResponses.IN_PROGRESS))
225                client.disconnect()
226                threading.Thread(target=ogThread.reboot).start()
227
228        def process_poweroff(self, client):
229                client.send(restResponse.getResponse(ogResponses.IN_PROGRESS))
230                client.disconnect()
231                threading.Thread(target=ogThread.poweroff).start()
232
233        def process_probe(self, client):
234                jsonResp = jsonResponse()
235                jsonResp.addElement('status', 'OPG')
236                client.send(restResponse.getResponse(ogResponses.OK, jsonResp))
237
238        def process_shellrun(self, client, httpparser):
239                threading.Thread(target=ogThread.execcmd, args=(client, httpparser, self,)).start()
240
241        def process_session(self, client, httpparser):
242                threading.Thread(target=ogThread.procsession, args=(client, httpparser, self,)).start()
243
244        def process_software(self, client, httpparser):
245                path = '/tmp/CSft-' + client.ip + '-' + httpparser.getPartition()
246                threading.Thread(target=ogThread.procsoftware, args=(client, httpparser, path, self,)).start()
247
248        def process_hardware(self, client):
249                path = '/tmp/Chrd-' + client.ip
250                threading.Thread(target=ogThread.prochardware, args=(client, path, self,)).start()
251
252        def process_schedule(self, client):
253                client.send(restResponse.getResponse(ogResponses.OK))
254
255        def process_setup(self, client, httpparser):
256                threading.Thread(target=ogThread.procsetup, args=(client, httpparser, self,)).start()
257
258        def process_irestore(self, client, httpparser):
259                threading.Thread(target=ogThread.procirestore, args=(client, httpparser, self,)).start()
260
261        def process_stop(self, client):
262                client.disconnect()
263                if self.proc == None:
264                        return
265
266                if self.proc.poll() == None:
267                        os.killpg(os.getpgid(self.proc.pid), signal.SIGTERM)
268                        self.terminated = True
269                        sys.exit(0)
270
271        def process_icreate(self, client, httpparser):
272                path = '/tmp/CSft-' + client.ip + '-' + httpparser.getPartition()
273                threading.Thread(target=ogThread.procicreate, args=(client, path, httpparser, self,)).start()
Note: See TracBrowser for help on using the repository browser.