Synnefo » snf-ganeti

# 02110-1301, USA.

# pylint: disable-msg=W0613,W0201

        raise errors.OpPrereqError, ("Cluster not initialized yet,"

                                     " use 'gnt-cluster init' first.")

      if self.REQ_MASTER:

        if master != socket.gethostname():

          raise errors.OpPrereqError, ("Commands must be run on the master"

                                       " node %s" % master)

                               (result.cmd, result.exit_code, result.output))

class LUInitCluster(LogicalUnit):

  """Initialise the cluster.

  HPATH = "cluster-init"

  HTYPE = constants.HTYPE_CLUSTER

  _OP_REQP = ["cluster_name", "hypervisor_type", "vg_name", "mac_prefix",

  REQ_CLUSTER = False

  def BuildHooksEnv(self):

    """

    env = {"CLUSTER": self.op.cluster_name,

    return env, [], [self.hostname['hostname_full']]

  def CheckPrereq(self):

      raise errors.OpPrereqError, ("Invalid hypervisor type given '%s'" %

                                   self.op.hypervisor_type)

  def Exec(self, feedback_fn):

    """Initialize the cluster.

    clustername = self.clustername

    hostname = self.hostname

    # set up the simple store

    ss = ssconf.SimpleStore()

    ss.SetKey(ss.SS_HYPERVISOR, self.op.hypervisor_type)

    # set up the inter-node password and certificate

    _InitGanetiServerSetup(ss)

    Any errors are signalled by raising errors.OpPrereqError.

    """

    nodelist = self.cfg.GetNodeList()

    if len(nodelist) > 0 and nodelist != [master]:

  def Exec(self, feedback_fn):

    """Destroys the cluster.

    """

    utils.CreateBackup('/root/.ssh/id_dsa')

    utils.CreateBackup('/root/.ssh/id_dsa.pub')

class LUVerifyCluster(NoHooksLU):

    feedback_fn("* Verifying global settings")

    self.cfg.VerifyConfig()

    vg_name = self.cfg.GetVGName()

    nodelist = utils.NiceSort(self.cfg.GetNodeList())

    instancelist = utils.NiceSort(self.cfg.GetInstanceList())

    instance_list = self.cfg.GetInstanceList()

    if node.name == masternode:

      raise errors.OpPrereqError, ("Node is the master node,"

                                   " you need to failover first.")

    # check that the type of the node (single versus dual homed) is the

    # same as for the master

    master_singlehomed = myself.secondary_ip == myself.primary_ip

    newbie_singlehomed = secondary_ip == primary_ip

    if master_singlehomed != newbie_singlehomed:

    # Distribute updated /etc/hosts and known_hosts to all nodes,

    # including the node just added

    dist_nodes = self.cfg.GetNodeList() + [node]

    if myself.name in dist_nodes:

      dist_nodes.remove(myself.name)

          logger.Error("copy of file %s to node %s failed" %

                       (fname, to_node))

    to_copy.extend(ss.GetFileList())

    for fname in to_copy:

      if not ssh.CopyFileToNode(node, fname):

    """

    self.new_master = socket.gethostname()

    if self.old_master == self.new_master:

      raise errors.OpPrereqError, ("This commands must be run on the node"

      logger.Error("could disable the master role on the old master"

                   " %s, please disable manually" % self.old_master)

    if not rpc.call_node_start_master(self.new_master):

      logger.Error("could not start the master role on the new master"

                   " %s, please check" % self.new_master)

class LUQueryClusterInfo(NoHooksLU):

      "config_version": constants.CONFIG_VERSION,

      "os_api_version": constants.OS_API_VERSION,

      "export_version": constants.EXPORT_VERSION,

      "architecture": (platform.architecture()[0], platform.machine()),

      "instances": [(instance.name, instance.primary_node)

                    for instance in instances],

      "INSTANCE_SECONDARIES": " ".join(self.instance.secondary_nodes),

      "FORCE": self.op.force,

      }

          list(self.instance.secondary_nodes))

    return env, nl, nl

      "INSTANCE_PRIMARY": self.instance.primary_node,

      "INSTANCE_SECONDARIES": " ".join(self.instance.secondary_nodes),

      }

          list(self.instance.secondary_nodes))

    return env, nl, nl

      "INSTANCE_PRIMARY": self.instance.primary_node,

      "INSTANCE_SECONDARIES": " ".join(self.instance.secondary_nodes),

      }

          list(self.instance.secondary_nodes))

    return env, nl, nl

      "INSTANCE_SECONDARIES": " ".join(self.instance.secondary_nodes),

      "IGNORE_CONSISTENCY": self.op.ignore_consistency,

      }

    return env, nl, nl

  def CheckPrereq(self):

    if self.inst_ip:

      env["INSTANCE_IP"] = self.inst_ip

          self.secondaries)

    return env, nl, nl

      "NEW_SECONDARY": self.op.remote_node,

      "DISK_NAME": self.op.disk_name,

      }

          self.op.remote_node,] + list(self.instance.secondary_nodes)

    return env, nl, nl

      "DISK_ID": self.op.disk_id,

      "OLD_SECONDARY": self.old_secondary,

      }

          self.instance.primary_node] + list(self.instance.secondary_nodes)

    return env, nl, nl

      "NEW_SECONDARY": self.op.remote_node,

      "OLD_SECONDARY": self.instance.secondary_nodes[0],

      }

          self.instance.primary_node] + list(self.instance.secondary_nodes)

    return env, nl, nl

    # start of work

    remote_node = self.op.remote_node

    cfg = self.cfg

    for dev in instance.disks:

      size = dev.size

                                       "%s-%s" % (instance.name, dev.iv_name))

      iv_names[dev.iv_name] = (dev, dev.children[0], new_drbd)

      logger.Info("adding new mirror component on secondary for %s" %

      # call the primary node to add the mirror to md

      logger.Info("adding new mirror component to md")

      if not rpc.call_blockdev_addchild(instance.primary_node, dev,

        logger.Error("Can't add mirror compoment to md!")

        cfg.SetDiskID(new_drbd, remote_node)

        if not rpc.call_blockdev_remove(remote_node, new_drbd):

    if self.bridge:

      env["BRIDGE"] = self.bridge

          self.instance.primary_node] + list(self.instance.secondary_nodes)

    return env, nl, nl

      "EXPORT_NODE": self.op.target_node,

      "EXPORT_DO_SHUTDOWN": self.op.shutdown,

      }

          self.op.target_node]

    return env, nl, nl