Revision 3d8548c4
b/daemons/ganeti-masterd | ||
---|---|---|
175 | 175 |
while True: |
176 | 176 |
msg = self.read_message() |
177 | 177 |
if msg is None: |
178 |
print "client closed connection"
|
|
178 |
logging.info("client closed connection")
|
|
179 | 179 |
break |
180 |
|
|
180 | 181 |
request = simplejson.loads(msg) |
182 |
logging.debug("request: %s", request) |
|
181 | 183 |
if not isinstance(request, dict): |
182 |
print "wrong request received: %s" % msg
|
|
184 |
logging.error("wrong request received: %s", msg)
|
|
183 | 185 |
break |
184 |
method = request.get('request', None) |
|
185 |
data = request.get('data', None) |
|
186 |
if method is None or data is None: |
|
187 |
print "no method or data in request" |
|
186 |
|
|
187 |
method = request.get(luxi.KEY_METHOD, None) |
|
188 |
args = request.get(luxi.KEY_ARGS, None) |
|
189 |
if method is None or args is None: |
|
190 |
logging.error("no method or args in request") |
|
188 | 191 |
break |
189 |
print "request:", method, data |
|
190 |
result = self._ops.handle_request(method, data) |
|
191 |
print "result:", result |
|
192 |
self.send_message(simplejson.dumps({'success': True, 'result': result})) |
|
192 |
|
|
193 |
success = False |
|
194 |
try: |
|
195 |
result = self._ops.handle_request(method, args) |
|
196 |
success = True |
|
197 |
except: |
|
198 |
logging.error("Unexpected exception", exc_info=True) |
|
199 |
err = sys.exc_info() |
|
200 |
result = "Caught exception: %s" % str(err[1]) |
|
201 |
|
|
202 |
response = { |
|
203 |
luxi.KEY_SUCCESS: success, |
|
204 |
luxi.KEY_RESULT: result, |
|
205 |
} |
|
206 |
logging.debug("response: %s", response) |
|
207 |
self.send_message(simplejson.dumps(response)) |
|
193 | 208 |
|
194 | 209 |
def read_message(self): |
195 | 210 |
while not self._msgs: |
b/lib/luxi.py | ||
---|---|---|
40 | 40 |
from ganeti import constants |
41 | 41 |
|
42 | 42 |
|
43 |
KEY_REQUEST = 'request' |
|
44 |
KEY_DATA = 'data' |
|
43 |
KEY_METHOD = 'method' |
|
44 |
KEY_ARGS = 'args' |
|
45 |
KEY_SUCCESS = "success" |
|
46 |
KEY_RESULT = "result" |
|
47 |
|
|
45 | 48 |
REQ_SUBMIT = 'submit' |
46 | 49 |
REQ_ABORT = 'abort' |
47 | 50 |
REQ_QUERY = 'query' |
... | ... | |
82 | 85 |
|
83 | 86 |
""" |
84 | 87 |
|
88 |
|
|
85 | 89 |
class NoMasterError(ProtocolError): |
86 | 90 |
"""The master cannot be reached |
87 | 91 |
|
... | ... | |
261 | 265 |
address = constants.MASTER_SOCKET |
262 | 266 |
self.transport = transport(address, timeouts=timeouts) |
263 | 267 |
|
264 |
def SendRequest(self, request, data):
|
|
268 |
def CallMethod(self, method, args):
|
|
265 | 269 |
"""Send a generic request and return the response. |
266 | 270 |
|
267 | 271 |
""" |
268 |
msg = {KEY_REQUEST: request, KEY_DATA: data} |
|
269 |
result = self.transport.Call(serializer.DumpJson(msg, indent=False)) |
|
272 |
# Build request |
|
273 |
request = { |
|
274 |
KEY_METHOD: method, |
|
275 |
KEY_ARGS: args, |
|
276 |
} |
|
277 |
|
|
278 |
# Send request and wait for response |
|
279 |
result = self.transport.Call(serializer.DumpJson(request, indent=False)) |
|
270 | 280 |
try: |
271 | 281 |
data = serializer.LoadJson(result) |
272 | 282 |
except Exception, err: |
273 | 283 |
raise ProtocolError("Error while deserializing response: %s" % str(err)) |
284 |
|
|
285 |
# Validate response |
|
274 | 286 |
if (not isinstance(data, dict) or |
275 |
'success' not in data or
|
|
276 |
'result' not in data):
|
|
287 |
KEY_SUCCESS not in data or
|
|
288 |
KEY_RESULT not in data):
|
|
277 | 289 |
raise DecodingError("Invalid response from server: %s" % str(data)) |
278 |
return data |
|
290 |
|
|
291 |
if not data[KEY_SUCCESS]: |
|
292 |
# TODO: decide on a standard exception |
|
293 |
raise RequestError(data[KEY_RESULT]) |
|
294 |
|
|
295 |
return data[KEY_RESULT] |
|
279 | 296 |
|
280 | 297 |
def SubmitJob(self, job): |
281 | 298 |
"""Submit a job""" |
282 |
result = self.SendRequest(REQ_SUBMIT, SerializeJob(job)) |
|
283 |
if not result['success']: |
|
284 |
raise RequestError(result['result']) |
|
285 |
return result['result'] |
|
299 |
return self.CallMethod(REQ_SUBMIT, SerializeJob(job)) |
|
286 | 300 |
|
287 | 301 |
def Query(self, data): |
288 | 302 |
"""Make a query""" |
289 |
result = self.SendRequest(REQ_QUERY, data) |
|
290 |
if not result['success']: |
|
291 |
raise RequestError(result[result]) |
|
292 |
result = result['result'] |
|
303 |
result = self.CallMethod(REQ_QUERY, data) |
|
293 | 304 |
if data["object"] == "jobs": |
294 | 305 |
# custom job processing of query values |
295 | 306 |
for row in result: |
... | ... | |
297 | 308 |
if field == "op_list": |
298 | 309 |
row[idx] = [opcodes.OpCode.LoadOpCode(i) for i in row[idx]] |
299 | 310 |
return result |
311 |
|
|
312 |
# TODO: class Server(object) |
Also available in: Unified diff