Synnefo » snf-ganeti

    result[constants.NV_HVINFO] = hyper.GetNodeInfo(hvparams=hvparams)

  """Verify the status of the local node.

  Based on the input L{what} parameter, various checks are done on the

  @param cluster_name: the cluster's name

  @type all_hvparams: dict of dict of strings

  @param all_hvparams: a dictionary mapping hypervisor names to hvparams

  @rtype: dict

  @return: a dictionary with the same keys as the input dict, and

      values representing the result of the checks

    # Try to contact all nodes

    val = {}

    for node in nodes:

      if not success:

        val[node] = message

def RunNodeSetupCmd(cluster_name, node, basecmd, debug, verbose,

  """Runs a command to configure something on a remote machine.

  @type cluster_name: string

  @param ask_key: See L{ssh.SshRunner.BuildCmd}

  @type strict_host_check: bool

  @param strict_host_check: See L{ssh.SshRunner.BuildCmd}

  @param data: JSON-serializable input data for script (passed to stdin)

  """

  if verbose:

    cmd.append("--verbose")

  family = ssconf.SimpleStore().GetPrimaryIPFamily()

  srun = ssh.SshRunner(cluster_name,

                       ipv6=(family == netutils.IP6Address.family))

                       utils.ShellQuoteArgs(cmd),

                       batch=False, ask_key=ask_key, quiet=False,

                       strict_host_check=strict_host_check,

  tempfh = tempfile.TemporaryFile()

  try:

    raise errors.OpExecError("Command '%s' failed: %s" %

                             (result.cmd, result.fail_reason))

def _InitFileStorageDir(file_storage_dir):

                    " the node: %s", msg)

  """Add a node to the cluster.

  This function must be called before the actual opcode, and will ssh

  @param cluster_name: the cluster name

  @param node: the name of the new node

  """

  data = {

  RunNodeSetupCmd(cluster_name, node, pathutils.NODE_DAEMON_SETUP,

                  opts.debug, opts.verbose,

  _WaitForNodeDaemon(node)

    srun = ssh.SshRunner(cluster_name=cluster_name)

    ssh_cmd = srun.BuildCmd(console.host, console.user, cmd,

                            batch=True, quiet=False, tty=True)

    if show_command:

  return result

  """Configures a destination node's SSH daemon.

  @param options: Command line options

  @param cluster_name: Cluster name

  @type node: string

  @param node: Destination node name

  """

  if options.force_join:

  bootstrap.RunNodeSetupCmd(cluster_name, node, pathutils.PREPARE_NODE_JOIN,

                            options.debug, options.verbose, False,

@UsesRPC

  node = netutils.GetHostname(name=args[0]).name

  readd = opts.readd

  try:

                           use_locking=False)

  except (errors.OpPrereqError, errors.OpExecError):

    node_exists = ""

    sip = None

             "and grant full intra-cluster ssh root access to/from it\n", node)

  if opts.node_setup:

  if opts.disk_state:

    disk_state = utils.FlatToDict(opts.disk_state)

    if self._exclusive_storage:

      node_verify_param[constants.NV_EXCLUSIVEPVS] = True

    # At this point, we have the in-memory data structures complete,

    # except for the runtime information, which we'll gather next

    all_nvinfo = self.rpc.call_node_verify(self.my_node_uuids,

                                           node_verify_param,

                                           self.cfg.GetClusterName(),

    nvinfo_endtime = time.time()

    if self.extra_lv_nodes and vg_name is not None:

          self.rpc.call_node_verify(self.extra_lv_nodes,

                                    {constants.NV_LVLIST: vg_name},

                                    self.cfg.GetClusterName(),

    else:

      extra_lv_nvinfo = {}

      key = constants.NV_FILELIST

      vf_nvinfo.update(self.rpc.call_node_verify(

         additional_node_uuids, {key: node_verify_param[key]},

    else:

      vf_nvinfo = all_nvinfo

      vf_node_info = self.my_node_info.values()

    else:

      self.master_candidate = False

    if self.op.readd:

      self.new_node = existing_node_info

    else:

      self.new_node = objects.Node(name=node_name,

                                   primary_ip=self.op.primary_ip,

                                   secondary_ip=secondary_ip,

      cname = self.cfg.GetClusterName()

      result = rpcrunner.call_node_verify_light(

          [node_name], vparams, cname,

      (errmsgs, _) = CheckNodePVs(result.payload, excl_stor)

      if errmsgs:

        raise errors.OpPrereqError("Checks on node PVs failed: %s" %

    result = self.rpc.call_node_verify(

               node_verifier_uuids, node_verify_param,

               self.cfg.GetClusterName(),

    for verifier in node_verifier_uuids:

      result[verifier].Raise("Cannot communicate with node %s" % verifier)

      nl_payload = result[verifier].payload[constants.NV_NODELIST]

    return self._UnlockedGetAllNodeGroupsInfo()

  @locking.ssynchronized(_config_lock, shared=1)

  def GetNodeGroupList(self):

    """Get a list of node groups.

    ("checkdict", None, "What to verify"),

    ("cluster_name", None, "Cluster name"),

    ("all_hvparams", None, "Dictionary mapping hypervisor names to hvparams"),

    ], None, None, "Request verification of given parameters"),

  ("node_volumes", MULTI, None, constants.RPC_TMO_FAST, [], None, None,

   "Gets all volumes on node(s)"),

      ("checkdict", None, "What to verify"),

      ("cluster_name", None, "Cluster name"),

      ("hvparams", None, "Dictionary mapping hypervisor names to hvparams"),

      ], None, None, "Request verification of given parameters"),

    ]),

  "RpcClientConfig": _Prepare([

    """Run a verify sequence on this node.

    """

  @classmethod

  def perspective_node_verify_light(cls, params):

    """Run a light verify sequence on this node.

    """

    return cls.perspective_node_verify(params)

  @staticmethod

    self.ipv6 = ipv6

  def _BuildSshOptions(self, batch, ask_key, use_cluster_key,

    """Builds a list with needed SSH options.

    @param batch: same as ssh's batch option

    @param strict_host_check: this makes the host key checking strict

    @param private_key: use this private key instead of the default

    @param quiet: whether to enable -q to ssh

    @rtype: list

    @return: the list of options ready to use in L{utils.process.RunCmd}

    if private_key:

      options.append("-i%s" % private_key)

    # TODO: Too many boolean options, maybe convert them to more descriptive

    # constants.

  def BuildCmd(self, hostname, user, command, batch=True, ask_key=False,

               tty=False, use_cluster_key=True, strict_host_check=True,

    """Build an ssh command to execute a command on a remote node.

    @param hostname: the target host, string

    @param strict_host_check: whether to check the host's SSH key at all

    @param private_key: use this private key instead of the default

    @param quiet: whether to enable -q to ssh

    @return: the ssh call to run 'command' on the remote host.

    argv = [constants.SSH]

    argv.extend(self._BuildSshOptions(batch, ask_key, use_cluster_key,

                                      strict_host_check, private_key,

    if tty:

      argv.extend(["-t", "-t"])

    return not result.failed

    """Verify hostname consistency via SSH.

    This functions connects via ssh to a node and compares the hostname

    @param node: nodename of a host to check; can be short or

        full qualified hostname

    @return: (success, detail), where:

        - success: True/False

           "else"

           "  echo \"$GANETI_HOSTNAME\";"

           "fi")

    if retval.failed:

      msg = "ssh problem"

    # this a real functional test, but requires localhost to be reachable

    local_data = (netutils.Hostname.GetSysName(),

                  constants.IP4_ADDRESS_LOCALHOST)

    self.failUnless(constants.NV_MASTERIP in result,

                    "Master IP data not returned")

    self.failUnless(result[constants.NV_MASTERIP], "Cannot reach localhost")

    bad_data =  ("master.example.com", "192.0.2.1")

    # we just test that whatever TcpPing returns, VerifyNode returns too

    netutils.TcpPing = lambda a, b, source=None: False

    self.failUnless(constants.NV_MASTERIP in result,

                    "Master IP data not returned")

    self.failIf(result[constants.NV_MASTERIP],