Synnefo » snf-ganeti

def _GetSshRunner():

  return ssh.SshRunner()

      success, message = _GetSshRunner().VerifyNodeHostname(node)

  remotecmd = _GetSshRunner().BuildCmd(dest_node, constants.GANETI_RUNAS,

                                       destcmd)

  remotecmd = _GetSshRunner().BuildCmd(src_node, constants.GANETI_RUNAS,

                                       destcmd)

    self.__ssh = None

  def __GetSSH(self):

    """Returns the SshRunner object

    """

    if not self.__ssh:

      self.__ssh = ssh.SshRunner()

    return self.__ssh

  ssh = property(fget=__GetSSH)

    self.ssh.Run(node.name, 'root', "%s stop" % constants.NODE_INITD_SCRIPT)

    result = self.ssh.Run(node, 'root', mycommand, batch=False, ask_key=True)

    success, msg = self.ssh.VerifyNodeHostname(node)

      if not self.ssh.CopyFileToNode(node, fname):

      if not self.ssh.CopyFileToNode(node, filename):

      result = self.ssh.Run(node, "root", self.op.command)

class SshRunner:

  """Wrapper for SSH commands.

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

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

    Args:

      hostname: the target host, string

      user: user to auth as

      command: the command

      batch: if true, ssh will run in batch mode with no prompting

      ask_key: if true, ssh will run with StrictHostKeyChecking=ask, so that

               we can connect to an unknown host (not valid in batch mode)

    Returns:

      The ssh call to run 'command' on the remote host.

    """

    argv = ["ssh", "-q"]

    argv.extend(KNOWN_HOSTS_OPTS)

    if batch:

      # if we are in batch mode, we can't ask the key

      if ask_key:

        raise errors.ProgrammerError("SSH call requested conflicting options")

      argv.extend(BATCH_MODE_OPTS)

    elif ask_key:

      argv.extend(ASK_KEY_OPTS)

    argv.extend(["%s@%s" % (user, hostname), command])

    return argv

  def Run(self, hostname, user, command, batch=True, ask_key=False):

    """Runs a command on a remote node.

    This method has the same return value as `utils.RunCmd()`, which it

    uses to launch ssh.

    Args:

      hostname: the target host, string

      user: user to auth as

      command: the command

      batch: if true, ssh will run in batch mode with no prompting

      ask_key: if true, ssh will run with StrictHostKeyChecking=ask, so that

               we can connect to an unknown host (not valid in batch mode)

    Returns:

      `utils.RunResult` like `utils.RunCmd()`

    """

    return utils.RunCmd(self.BuildCmd(hostname, user, command, batch=batch,

                                      ask_key=ask_key))

  def CopyFileToNode(self, node, filename):

    """Copy a file to another node with scp.

    Args:

      node: node in the cluster

      filename: absolute pathname of a local file

    Returns:

      success: True/False

    """

    if not os.path.isfile(filename):

      logger.Error("file %s does not exist" % (filename))

      return False

    if not os.path.isabs(filename):

      logger.Error("file %s must be an absolute path" % (filename))

      return False

    command = ["scp", "-q", "-p"]

    command.extend(KNOWN_HOSTS_OPTS)

    command.extend(BATCH_MODE_OPTS)

    command.append(filename)

    command.append("%s:%s" % (node, filename))

    result = utils.RunCmd(command)

    if result.failed:

      logger.Error("copy to node %s failed (%s) error %s,"

                   " command was %s" %

                   (node, result.fail_reason, result.output, result.cmd))

    return not result.failed

  def VerifyNodeHostname(self, node):

    """Verify hostname consistency via SSH.

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

    reported by the node to the name with have (the one that we

    connected to).

    This is used to detect problems in ssh known_hosts files

    (conflicting known hosts) and incosistencies between dns/hosts

    entries and local machine names

    Args:

      node: nodename of a host to check. can be short or full qualified hostname

    Returns:

      (success, detail)

      where

        success: True/False

        detail: String with details

    """

    retval = self.Run(node, 'root', 'hostname')

    if retval.failed:

      msg = "ssh problem"

      output = retval.output

      if output:

        msg += ": %s" % output

      return False, msg

    remotehostname = retval.stdout.strip()

    if not remotehostname or remotehostname != node:

      return False, "hostname mismatch, got %s" % remotehostname

    return True, "host matches"