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