Synnefo » snf-ganeti » ganeti-local

      # activate ip

      master_node = ssconf.SimpleStore().GetMasterNode()

      result = rpc.RpcRunner.call_node_start_master(master_node, False, False)

      if msg:

        logging.error("Can't activate master IP address: %s", msg)

  """

  result = rpc.RpcRunner.call_node_stop_master(master, True)

  if msg:

    logging.warning("Could not disable the master role: %s" % msg)

  result = rpc.RpcRunner.call_node_leave_cluster(master)

  if msg:

    logging.warning("Could not shutdown the node daemon and cleanup"

                    " the node: %s", msg)

  logging.info("Setting master to %s, old master: %s", new_master, old_master)

  result = rpc.RpcRunner.call_node_stop_master(old_master, True)

  if msg:

    logging.error("Could not disable the master role on the old master"

                 " %s, please disable manually: %s", old_master, msg)

  cfg.Update(cluster_info)

  result = rpc.RpcRunner.call_node_start_master(new_master, True, no_voting)

  if msg:

    logging.error("Could not start the master role on the new master"

                  " %s, please check: %s", new_master, msg)

  for node in results:

    nres = results[node]

    data = nres.payload

    fail = False

    if msg:

      logging.warning("Error contacting node %s: %s", node, msg)

    changed = []

    for node, dskl in per_node_disks.items():

      result = self.rpc.call_blockdev_getsizes(node, [v[2] for v in dskl])

        self.LogWarning("Failure in blockdev_getsizes call to node"

                        " %s, ignoring", node)

        continue

      # and make sure the new node will not have old files around

      if not new_node.master_candidate:

        result = self.rpc.call_node_demote_from_mc(new_node.name)

        if msg:

          self.LogWarning("Node failed to demote itself from master"

                          " candidate status: %s" % msg)

          changed_mc = True

          result.append(("master_candidate", "auto-demotion due to drain"))

          rrc = self.rpc.call_node_demote_from_mc(node.name)

          if msg:

            self.LogWarning("Node failed to demote itself: %s" % msg)

        if node.offline:

        if result.offline:

          # offline nodes will be in both lists

          off_nodes.append(name)

          bad_nodes.append(name)

        else:

          if result.payload:

    result = rpc.RpcRunner.call_upload_file(node_list, self._cfg_file,

                                            address_list=addr_list)

    for to_node, to_result in result.items():

      if msg:

        msg = ("Copy of file %s to node %s failed: %s" %

               (self._cfg_file, to_node, msg))

          self._UnlockedGetNodeList(),

          self._UnlockedGetSsconfValues())

        for nname, nresu in result.items():

          if msg:

            logging.warning("Error while uploading ssconf files to"

                            " node %s: %s", nname, msg)

    # Clean queue directory on added node

    result = rpc.RpcRunner.call_jobqueue_purge(node_name)

    if msg:

      logging.warning("Cannot cleanup queue directory on node %s: %s",

                      node_name, msg)

      result = rpc.RpcRunner.call_jobqueue_update([node_name],

                                                  [node.primary_ip],

                                                  file_name, content)

      if msg:

        logging.error("Failed to upload file %s to node %s: %s",

                      file_name, node_name, msg)

    success = []

    for node in nodes:

      if msg:

        failed.append(node)

        logging.error("RPC call %s failed on node %s: %s",

      res = results[node_name]

      if res.offline:

        continue

      if msg:

        self.lu.LogWarning("Communication failure to node %s: %s",

                           node_name, msg)

      ec = errors.OpExecError

    raise ec(msg)

class Client:

  """RPC Client class.