Revision a629ecb9

b/lib/luxi.py
439 439
    """Send a generic request and return the response.
440 440

  
441 441
    """
442
    if not isinstance(args, (list, tuple)):
443
      raise errors.ProgrammerError("Invalid parameter passed to CallMethod:"
444
                                   " expected list, got %s" % type(args))
442 445
    return CallLuxiMethod(self._SendMethodCall, method, args,
443 446
                          version=constants.LUXI_VERSION)
444 447

  
445 448
  def SetQueueDrainFlag(self, drain_flag):
446
    return self.CallMethod(REQ_QUEUE_SET_DRAIN_FLAG, drain_flag)
449
    return self.CallMethod(REQ_QUEUE_SET_DRAIN_FLAG, (drain_flag, ))
447 450

  
448 451
  def SetWatcherPause(self, until):
449
    return self.CallMethod(REQ_SET_WATCHER_PAUSE, [until])
452
    return self.CallMethod(REQ_SET_WATCHER_PAUSE, (until, ))
450 453

  
451 454
  def SubmitJob(self, ops):
452 455
    ops_state = map(lambda op: op.__getstate__(), ops)
......
459 462
    return self.CallMethod(REQ_SUBMIT_MANY_JOBS, jobs_state)
460 463

  
461 464
  def CancelJob(self, job_id):
462
    return self.CallMethod(REQ_CANCEL_JOB, job_id)
465
    return self.CallMethod(REQ_CANCEL_JOB, (job_id, ))
463 466

  
464 467
  def ArchiveJob(self, job_id):
465
    return self.CallMethod(REQ_ARCHIVE_JOB, job_id)
468
    return self.CallMethod(REQ_ARCHIVE_JOB, (job_id, ))
466 469

  
467 470
  def AutoArchiveJobs(self, age):
468 471
    timeout = (DEF_RWTO - 1) / 2
......
510 513
    @rtype: L{objects.QueryResponse}
511 514

  
512 515
    """
513
    req = objects.QueryRequest(what=what, fields=fields, qfilter=qfilter)
514
    result = self.CallMethod(REQ_QUERY, req.ToDict())
516
    result = self.CallMethod(REQ_QUERY, (what, fields, qfilter))
515 517
    return objects.QueryResponse.FromDict(result)
516 518

  
517 519
  def QueryFields(self, what, fields):
......
523 525
    @rtype: L{objects.QueryFieldsResponse}
524 526

  
525 527
    """
526
    req = objects.QueryFieldsRequest(what=what, fields=fields)
527
    result = self.CallMethod(REQ_QUERY_FIELDS, req.ToDict())
528
    result = self.CallMethod(REQ_QUERY_FIELDS, (what, fields))
528 529
    return objects.QueryFieldsResponse.FromDict(result)
529 530

  
530 531
  def QueryJobs(self, job_ids, fields):
......
546 547
    return self.CallMethod(REQ_QUERY_CLUSTER_INFO, ())
547 548

  
548 549
  def QueryConfigValues(self, fields):
549
    return self.CallMethod(REQ_QUERY_CONFIG_VALUES, fields)
550
    return self.CallMethod(REQ_QUERY_CONFIG_VALUES, (fields, ))
550 551

  
551 552
  def QueryTags(self, kind, name):
552 553
    return self.CallMethod(REQ_QUERY_TAGS, (kind, name))
b/lib/server/masterd.py
193 193
    queue = self.server.context.jobqueue
194 194

  
195 195
    # TODO: Parameter validation
196
    if not isinstance(args, (tuple, list)):
197
      logging.info("Received invalid arguments of type '%s'", type(args))
198
      raise ValueError("Invalid arguments type '%s'" % type(args))
196 199

  
197 200
    # TODO: Rewrite to not exit in each 'if/elif' branch
198 201

  
......
209 212
      return queue.SubmitManyJobs(jobs)
210 213

  
211 214
    elif method == luxi.REQ_CANCEL_JOB:
212
      job_id = args
215
      (job_id, ) = args
213 216
      logging.info("Received job cancel request for %s", job_id)
214 217
      return queue.CancelJob(job_id)
215 218

  
216 219
    elif method == luxi.REQ_ARCHIVE_JOB:
217
      job_id = args
220
      (job_id, ) = args
218 221
      logging.info("Received job archive request for %s", job_id)
219 222
      return queue.ArchiveJob(job_id)
220 223

  
......
231 234
                                     prev_log_serial, timeout)
232 235

  
233 236
    elif method == luxi.REQ_QUERY:
234
      req = objects.QueryRequest.FromDict(args)
237
      (what, fields, qfilter) = args
238
      req = objects.QueryRequest(what=what, fields=fields, qfilter=qfilter)
235 239

  
236 240
      if req.what in constants.QR_VIA_OP:
237 241
        result = self._Query(opcodes.OpQuery(what=req.what, fields=req.fields,
......
249 253
      return result
250 254

  
251 255
    elif method == luxi.REQ_QUERY_FIELDS:
252
      req = objects.QueryFieldsRequest.FromDict(args)
256
      (what, fields) = args
257
      req = objects.QueryFieldsRequest(what=what, fields=fields)
253 258

  
254 259
      try:
255 260
        fielddefs = query.ALL_FIELDS[req.what]
......
298 303
      return self._Query(op)
299 304

  
300 305
    elif method == luxi.REQ_QUERY_EXPORTS:
301
      nodes, use_locking = args
306
      (nodes, use_locking) = args
302 307
      if use_locking:
303 308
        raise errors.OpPrereqError("Sync queries are not allowed",
304 309
                                   errors.ECODE_INVAL)
......
307 312
      return self._Query(op)
308 313

  
309 314
    elif method == luxi.REQ_QUERY_CONFIG_VALUES:
310
      fields = args
315
      (fields, ) = args
311 316
      logging.info("Received config values query request for %s", fields)
312 317
      op = opcodes.OpClusterConfigQuery(output_fields=fields)
313 318
      return self._Query(op)
......
318 323
      return self._Query(op)
319 324

  
320 325
    elif method == luxi.REQ_QUERY_TAGS:
321
      kind, name = args
326
      (kind, name) = args
322 327
      logging.info("Received tags query request")
323 328
      op = opcodes.OpTagsGet(kind=kind, name=name)
324 329
      return self._Query(op)
......
331 336
      return self.server.context.glm.OldStyleQueryLocks(fields)
332 337

  
333 338
    elif method == luxi.REQ_QUEUE_SET_DRAIN_FLAG:
334
      drain_flag = args
339
      (drain_flag, ) = args
335 340
      logging.info("Received queue drain flag change request to %s",
336 341
                   drain_flag)
337 342
      return queue.SetDrainFlag(drain_flag)

Also available in: Unified diff