Synnefo » snf-ganeti

    """

    env = {

      "CLUSTER": self.op.cluster_name,

      }

  def CheckPrereq(self):

    """Verify that the passed name is a valid one.

      raise errors.OpPrereqError("Cannot resolve my own hostname ('%s')" %

                                 hostname_local)

      raise errors.OpPrereqError("My own hostname (%s) does not match the"

                                 " resolver (%s): probably not using FQDN"

                                 " for hostname." %

      raise errors.OpPrereqError("This host's IP resolves to the private"

                                 " range (%s). Please fix DNS or /etc/hosts." %

    self.clustername = clustername = utils.LookupHostname(self.op.cluster_name)

    if not clustername:

      raise errors.OpPrereqError("Cannot resolve given cluster name ('%s')"

                                 % self.op.cluster_name)

    if result.failed:

      raise errors.OpPrereqError("Inconsistency: this host's name resolves"

                                 " to %s,\nbut this ip address does not"

                                 " belong to this host."

    secondary_ip = getattr(self.op, "secondary_ip", None)

    if secondary_ip and not utils.IsValidIP(secondary_ip):

      raise errors.OpPrereqError("Invalid secondary ip given")

      result = utils.RunCmd(["fping", "-S127.0.0.1", "-q", secondary_ip])

      if result.failed:

        raise errors.OpPrereqError("You gave %s as secondary IP,\n"

    # set up the simple store

    ss = ssconf.SimpleStore()

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

    ss.SetKey(ss.SS_MASTER_NETDEV, self.op.master_netdev)

    # set up the inter-node password and certificate

    _InitGanetiServerSetup(ss)

    # start the master ip

    # set up ssh config and /etc/hosts

    f = open('/etc/ssh/ssh_host_rsa_key.pub', 'r')

      f.close()

    sshkey = sshline.split(" ")[1]

    # init of cluster config file

    cfgw = config.ConfigWriter()

                    sshkey, self.op.mac_prefix,

                    self.op.vg_name, self.op.def_bridge)

      raise errors.OpPrereqError("Cannot resolve the new cluster name ('%s')" %

                                 self.op.name)

    old_name = self.sstore.GetClusterName()

    old_ip = self.sstore.GetMasterIP()

    if new_name == old_name and new_ip == old_ip:

    if not dns_data:

      raise errors.OpPrereqError("Node %s is not resolvable" % node_name)

    secondary_ip = getattr(self.op, "secondary_ip", None)

    if secondary_ip is None:

      secondary_ip = primary_ip

      raise errors.OpPrereqError("New instance name '%s' not found in dns" %

                                 self.op.new_name)

    if not getattr(self.op, "ignore_ip", False):

      result = utils.RunCmd(command)

      if not result.failed:

        raise errors.OpPrereqError("IP %s of instance %s already in use" %

  def Exec(self, feedback_fn):

      raise errors.OpPrereqError("Instance name '%s' not found in dns" %

                                 self.op.instance_name)

    instance_list = self.cfg.GetInstanceList()

    if instance_name in instance_list:

      raise errors.OpPrereqError("Instance '%s' is already in the cluster" %

    if ip is None or ip.lower() == "none":

      inst_ip = None

    elif ip.lower() == "auto":

    else:

      if not utils.IsValidIP(ip):

        raise errors.OpPrereqError("given IP address '%s' doesn't look"

      inst_ip = ip

    self.inst_ip = inst_ip

    result = utils.RunCmd(command)

    if not result.failed:

      raise errors.OpPrereqError("IP %s of instance %s already in use" %

    # bridge verification

    bridge = getattr(self.op, "bridge", None)

  return names_filtered[0]

def LookupHostname(hostname):

  """Look up hostname

    hostname: hostname to look up, can be also be a non FQDN

  Returns:

  """

  try:

  except socket.gaierror:

    # hostname not found in DNS

    return None

def ListVolumeGroups():