Synnefo » snf-ganeti

  _OP_REQP = ["instance_name", "mem_size", "disk_size",

  def _RunAllocator(self):

    """Run the allocator based on input opcode.

    """

    al_data = _IAllocatorGetClusterData(self.cfg, self.sstore)

    disks = [{"size": self.op.disk_size, "mode": "w"},

             {"size": self.op.swap_size, "mode": "w"}]

    nics = [{"mac": self.op.mac, "ip": getattr(self.op, "ip", None),

             "bridge": self.op.bridge}]

    op = opcodes.OpTestAllocator(name=self.op.instance_name,

                                 disk_template=self.op.disk_template,

                                 tags=[],

                                 os=self.op.os_type,

                                 vcpus=self.op.vcpus,

                                 mem_size=self.op.mem_size,

                                 disks=disks,

                                 nics=nics)

    _IAllocatorAddNewInstance(al_data, op)

    if _JSON_INDENT is None:

      text = simplejson.dumps(al_data)

    else:

      text = simplejson.dumps(al_data, indent=_JSON_INDENT)

    result = _IAllocatorRun(self.op.iallocator, text)

    result = _IAllocatorValidateResult(result)

    if not result["success"]:

      raise errors.OpPrereqError("Can't compute nodes using"

                                 " iallocator '%s': %s" % (self.op.iallocator,

                                                           result["info"]))

    req_nodes = 1

    if self.op.disk_template in constants.DTS_NET_MIRROR:

      req_nodes += 1

    if len(result["nodes"]) != req_nodes:

      raise errors.OpPrereqError("iallocator '%s' returned invalid number"

                                 " of nodes (%s), required %s" %

                                 (len(result["nodes"]), req_nodes))

    self.op.pnode = result["nodes"][0]

    logger.ToStdout("Selected nodes for the instance: %s" %

                    (", ".join(result["nodes"]),))

    logger.Info("Selected nodes for instance %s via iallocator %s: %s" %

                (self.op.instance_name, self.op.iallocator, result["nodes"]))

    if req_nodes == 2:

      self.op.snode = result["nodes"][1]

    # set optional parameters to none if they don't exist

    for attr in ["kernel_path", "initrd_path", "hvm_boot_order", "pnode",

                 "iallocator"]:

    #### allocator run

    if [self.op.iallocator, self.op.pnode].count(None) != 1:

      raise errors.OpPrereqError("One and only one of iallocator and primary"

                                 " node must be given")

    if self.op.iallocator is not None:

      self._RunAllocator()

    raise errors.OpExecError("Can't find allocator '%s'" % name)

def _IAllocatorValidateResult(data):

  """Process the allocator results.

  """

  try:

    rdict = simplejson.loads(data)

  except Exception, err:

    raise errors.OpExecError("Can't parse iallocator results: %s" % str(err))

  if not isinstance(rdict, dict):

    raise errors.OpExecError("Can't parse iallocator results: not a dict")

  for key in "success", "info", "nodes":

    if key not in rdict:

      raise errors.OpExecError("Can't parse iallocator results:"

                               " missing key '%s'" % key)

  if not isinstance(rdict["nodes"], list):

    raise errors.OpExecError("Can't parse iallocator results: 'nodes' key"

                             " is not a list")

  return rdict