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

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

(BUG) Include client parameter in restore command
  • Property mode set to 100644
File size: 7.1 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
154class ogResponses(Enum):
155        BAD_REQUEST=0
156        IN_PROGRESS=1
157        OK=2
158        INTERNAL_ERR=3
159        UNAUTHORIZED=4
160
161class ogRest():
162        def __init__(self):
163                self.proc = None
164                self.terminated = False
165
166        def processOperation(self, httpparser, client):
167                op = httpparser.getRequestOP()
168                URI = httpparser.getURI()
169
170                if (not "stop" in URI and not self.proc == None and self.proc.poll() == None):
171                        client.send(restResponse.getResponse(ogResponses.UNAUTHORIZED))
172                        return
173
174                if ("GET" in op):
175                        if "hardware" in URI:
176                                self.process_hardware(client)
177                        elif ("run/schedule" in URI):
178                                self.process_schedule(client)
179                        else:
180                                client.send(restResponse.getResponse(ogResponses.BAD_REQUEST))
181                elif ("POST" in op):
182                        if ("poweroff" in URI):
183                                self.process_poweroff(client)
184                        elif "probe" in URI:
185                                self.process_probe(client)
186                        elif ("reboot" in URI):
187                                self.process_reboot(client)
188                        elif ("shell/run" in URI):
189                                self.process_shellrun(client, httpparser)
190                        elif ("session" in URI):
191                                self.process_session(client, httpparser)
192                        elif ("software" in URI):
193                                self.process_software(client, httpparser)
194                        elif ("setup" in URI):
195                                self.process_setup(client, httpparser)
196                        elif ("image/restore" in URI):
197                                self.process_irestore(client, httpparser)
198                        elif ("stop" in URI):
199                                self.process_stop(client)
200                        else:
201                                client.send(restResponse.getResponse(ogResponses.BAD_REQUEST))
202                else:
203                        client.send(restResponse.getResponse(ogResponses.BAD_REQUEST))
204
205                return 0
206
207        def process_reboot(self, client):
208                client.send(restResponse.getResponse(ogResponses.IN_PROGRESS))
209                client.disconnect()
210                threading.Thread(target=ogThread.reboot).start()
211
212        def process_poweroff(self, client):
213                client.send(restResponse.getResponse(ogResponses.IN_PROGRESS))
214                client.disconnect()
215                threading.Thread(target=ogThread.poweroff).start()
216
217        def process_probe(self, client):
218                jsonResp = jsonResponse()
219                jsonResp.addElement('status', 'OPG')
220                client.send(restResponse.getResponse(ogResponses.OK, jsonResp))
221
222        def process_shellrun(self, client, httpparser):
223                threading.Thread(target=ogThread.execcmd, args=(client, httpparser, self,)).start()
224
225        def process_session(self, client, httpparser):
226                threading.Thread(target=ogThread.procsession, args=(client, httpparser, self,)).start()
227
228        def process_software(self, client, httpparser):
229                path = '/tmp/CSft-' + client.ip + '-' + httpparser.getPartition()
230                threading.Thread(target=ogThread.procsoftware, args=(client, httpparser, path, self,)).start()
231
232        def process_hardware(self, client):
233                path = '/tmp/Chrd-' + client.ip
234                threading.Thread(target=ogThread.prochardware, args=(client, path, self,)).start()
235
236        def process_schedule(self, client):
237                client.send(restResponse.getResponse(ogResponses.OK))
238
239        def process_setup(self, client, httpparser):
240                threading.Thread(target=ogThread.procsetup, args=(client, httpparser, self,)).start()
241
242        def process_irestore(self, client, httpparser):
243                threading.Thread(target=ogThread.procirestore, args=(client, httpparser, self,)).start()
244
245        def process_stop(self, client):
246                client.disconnect()
247                if self.proc == None:
248                        return
249
250                if self.proc.poll() == None:
251                        os.killpg(os.getpgid(self.proc.pid), signal.SIGTERM)
252                        self.terminated = True
253                        sys.exit(0)
Note: See TracBrowser for help on using the repository browser.