Synnefo » snf-ganeti

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

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

    if self.REQ_MASTER:

      if master != utils.HostInfo().name:

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

                                   " node %s" % master)

    Any errors are signalled by raising errors.OpPrereqError.

    """

    nodelist = self.cfg.GetNodeList()

    if len(nodelist) != 1 or nodelist[0] != master:

    """Destroys the cluster.

    """

    if not rpc.call_node_stop_master(master, False):

      raise errors.OpExecError("Could not disable the master role")

    priv_key, pub_key, _ = ssh.GetUserFiles(constants.GANETI_RUNAS)

    # FIXME: verify OS list

    # do local checksums

    file_names.append(constants.SSL_CERT_FILE)

    file_names.append(constants.CLUSTER_CONF_FILE)

    local_checksums = utils.FingerprintFiles(file_names)

  HPATH = "cluster-rename"

  HTYPE = constants.HTYPE_CLUSTER

  _OP_REQP = ["name"]

  def BuildHooksEnv(self):

    """Build hooks env.

    """

    env = {

      "NEW_NAME": self.op.name,

      }

    return env, [mn], [mn]

  def CheckPrereq(self):

    new_name = hostname.name

    self.ip = new_ip = hostname.ip

    if new_name == old_name and new_ip == old_ip:

      raise errors.OpPrereqError("Neither the name nor the IP address of the"

                                 " cluster has changed")

    """

    clustername = self.op.name

    ip = self.ip

    # shutdown the master IP

    if not rpc.call_node_stop_master(master, False):

      raise errors.OpExecError("Could not disable the master role")

    try:

      # modify the sstore

      ss.SetKey(ss.SS_MASTER_IP, ip)

      ss.SetKey(ss.SS_CLUSTER_NAME, clustername)

    """

    env = {

      "NEW_VG_NAME": self.op.vg_name,

      }

    return env, [mn], [mn]

  def CheckPrereq(self):

    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:

                                 " you gave (%s). Please fix and re-run this"

                                 " command." % new_node.secondary_ip)

    node_verify_param = {

      'nodelist': [node],

      # TODO: do a node-net-test as well?

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

    # including the node just added

    dist_nodes = self.cfg.GetNodeList()

    if not self.op.readd:

      dist_nodes.append(node)

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

                       (fname, to_node))

      to_copy.append(constants.VNC_PASSWORD_FILE)

    for fname in to_copy:

      result = rpc.call_upload_file([node], fname)

    """

    result = {

      "software_version": constants.RELEASE_VERSION,

      "protocol_version": constants.PROTOCOL_VERSION,

      "config_version": constants.CONFIG_VERSION,

      "os_api_version": constants.OS_API_VERSION,

      "export_version": constants.EXPORT_VERSION,

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

      }

    return result

      "FORCE": self.op.force,

      }

    env.update(_BuildInstanceHookEnvByObject(self.instance))

          list(self.instance.secondary_nodes))

    return env, nl, nl

      "IGNORE_SECONDARIES": self.op.ignore_secondaries,

      }

    env.update(_BuildInstanceHookEnvByObject(self.instance))

          list(self.instance.secondary_nodes))

    return env, nl, nl

    """

    env = _BuildInstanceHookEnvByObject(self.instance)

          list(self.instance.secondary_nodes))

    return env, nl, nl

    """

    env = _BuildInstanceHookEnvByObject(self.instance)

          list(self.instance.secondary_nodes))

    return env, nl, nl

    """

    env = _BuildInstanceHookEnvByObject(self.instance)

    env["INSTANCE_NEW_NAME"] = self.op.new_name

          list(self.instance.secondary_nodes))

    return env, nl, nl

    """

    env = _BuildInstanceHookEnvByObject(self.instance)

    return env, nl, nl

  def CheckPrereq(self):

      "IGNORE_CONSISTENCY": self.op.ignore_consistency,

      }

    env.update(_BuildInstanceHookEnvByObject(self.instance))

    return env, nl, nl

  def CheckPrereq(self):

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

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

             "bridge": self.op.bridge}]

                     mode=constants.IALLOCATOR_MODE_ALLOC,

                     name=self.op.instance_name,

                     disk_template=self.op.disk_template,

      nics=[(self.inst_ip, self.op.bridge, self.op.mac)],

    ))

          self.secondaries)

    return env, nl, nl

                                   self.op.vnc_bind_address)

    # Xen HVM device type checks

      if self.op.hvm_nic_type not in constants.HT_HVM_VALID_NIC_TYPES:

        raise errors.OpPrereqError("Invalid NIC type %s specified for Xen HVM"

                                   " hypervisor" % self.op.hvm_nic_type)

    if self.inst_ip is not None:

      nic.ip = self.inst_ip

    if ht_kind in constants.HTS_REQ_PORT:

      network_port = self.cfg.AllocatePort()

    else:

    # build the full file storage dir path

    file_storage_dir = os.path.normpath(os.path.join(

                                        string_file_storage_dir, instance))

    """Compute a new secondary node using an IAllocator.

    """

                     mode=constants.IALLOCATOR_MODE_RELOC,

                     name=self.op.instance_name,

                     relocate_from=[self.sec_node])

      }

    env.update(_BuildInstanceHookEnvByObject(self.instance))

    nl = [

      self.instance.primary_node,

      ]

    if self.op.remote_node is not None:

      }

    env.update(_BuildInstanceHookEnvByObject(self.instance))

    nl = [

      self.instance.primary_node,

      ]

    return env, nl, nl

        "vcpus": instance.vcpus,

        }

      if htkind == constants.HT_XEN_PVM30:

        idict["kernel_path"] = instance.kernel_path

        idict["initrd_path"] = instance.initrd_path

        mac = self.instance.nics[0].mac

      args['nics'] = [(ip, bridge, mac)]

    env = _BuildInstanceHookEnvByObject(self.instance, override=args)

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

    return env, nl, nl

                           " node %s" % node)

    # Xen HVM device type checks

      if self.op.hvm_nic_type is not None:

        if self.op.hvm_nic_type not in constants.HT_HVM_VALID_NIC_TYPES:

          raise errors.OpPrereqError("Invalid NIC type %s specified for Xen"

      "EXPORT_DO_SHUTDOWN": self.op.shutdown,

      }

    env.update(_BuildInstanceHookEnvByObject(self.instance))

          self.op.target_node]

    return env, nl, nl

  """IAllocator framework.

  An IAllocator instance has three sets of attributes:

    - input data (all members of the _KEYS class attribute are required)

    - four buffer attributes (in|out_data|text), that represent the

      input (to the external script) in text and data structure format,

    "relocate_from",

    ]

    self.cfg = cfg

    # init buffer variables

    self.in_text = self.out_text = self.in_data = self.out_data = None

    # init all input fields so that pylint is happy

    # cluster data

    data = {

      "version": 1,

      "cluster_tags": list(cfg.GetClusterInfo().GetTags()),

      # we don't have job IDs

      }

    """

    data = self.in_text

    if not isinstance(result, (list, tuple)) or len(result) != 4:

      raise errors.OpExecError("Invalid result from master iallocator runner")

    """

    if self.op.mode == constants.IALLOCATOR_MODE_ALLOC:

                       mode=self.op.mode,

                       name=self.op.name,

                       mem_size=self.op.mem_size,

                       vcpus=self.op.vcpus,

                       )

    else:

                       mode=self.op.mode,

                       name=self.op.name,

                       relocate_from=list(self.relocate_from),