code.grnet.gr Git - ganeti-local/blob - lib/ssh.py

   1 #
   2 #
   3
   4 # Copyright (C) 2006, 2007 Google Inc.
   5 #
   6 # This program is free software; you can redistribute it and/or modify
   7 # it under the terms of the GNU General Public License as published by
   8 # the Free Software Foundation; either version 2 of the License, or
   9 # (at your option) any later version.
  10 #
  11 # This program is distributed in the hope that it will be useful, but
  12 # WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 # General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU General Public License
  17 # along with this program; if not, write to the Free Software
  18 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 # 02110-1301, USA.
  20
  21
  22 """Module encapsulating ssh functionality.
  23
  24 """
  25
  26
  27 import os
  28
  29 from ganeti import utils
  30 from ganeti import errors
  31 from ganeti import constants
  32
  33
  34 def GetUserFiles(user, mkdir=False):
  35   """Return the paths of a user's ssh files.
  36
  37   The function will return a triplet (priv_key_path, pub_key_path,
  38   auth_key_path) that are used for ssh authentication. Currently, the
  39   keys used are DSA keys, so this function will return:
  40   (~user/.ssh/id_dsa, ~user/.ssh/id_dsa.pub,
  41   ~user/.ssh/authorized_keys).
  42
  43   If the optional parameter mkdir is True, the ssh directory will be
  44   created if it doesn't exist.
  45
  46   Regardless of the mkdir parameters, the script will raise an error
  47   if ~user/.ssh is not a directory.
  48
  49   """
  50   user_dir = utils.GetHomeDir(user)
  51   if not user_dir:
  52     raise errors.OpExecError("Cannot resolve home of user %s" % user)
  53
  54   ssh_dir = os.path.join(user_dir, ".ssh")
  55   if not os.path.lexists(ssh_dir):
  56     if mkdir:
  57       try:
  58         os.mkdir(ssh_dir, 0700)
  59       except EnvironmentError, err:
  60         raise errors.OpExecError("Can't create .ssh dir for user %s: %s" %
  61                                  (user, str(err)))
  62   elif not os.path.isdir(ssh_dir):
  63     raise errors.OpExecError("path ~%s/.ssh is not a directory" % user)
  64
  65   return [os.path.join(ssh_dir, base)
  66           for base in ["id_dsa", "id_dsa.pub", "authorized_keys"]]
  67
  68
  69 class SshRunner:
  70   """Wrapper for SSH commands.
  71
  72   """
  73   def __init__(self, cluster_name):
  74     self.cluster_name = cluster_name
  75
  76   def _BuildSshOptions(self, batch, ask_key, use_cluster_key,
  77                        strict_host_check):
  78     options = [
  79       "-oEscapeChar=none",
  80       "-oHashKnownHosts=no",
  81       "-oGlobalKnownHostsFile=%s" % constants.SSH_KNOWN_HOSTS_FILE,
  82       "-oUserKnownHostsFile=/dev/null",
  83       ]
  84
  85     if use_cluster_key:
  86       options.append("-oHostKeyAlias=%s" % self.cluster_name)
  87
  88     # TODO: Too many boolean options, maybe convert them to more descriptive
  89     # constants.
  90
  91     # Note: ask_key conflicts with batch mode
  92     if batch:
  93       if ask_key:
  94         raise errors.ProgrammerError("SSH call requested conflicting options")
  95
  96       options.append("-oBatchMode=yes")
  97
  98       if strict_host_check:
  99         options.append("-oStrictHostKeyChecking=yes")
 100       else:
 101         options.append("-oStrictHostKeyChecking=no")
 102
 103     elif ask_key:
 104       options.extend([
 105         "-oStrictHostKeyChecking=ask",
 106         ])
 107
 108     return options
 109
 110   def BuildCmd(self, hostname, user, command, batch=True, ask_key=False,
 111                tty=False, use_cluster_key=True, strict_host_check=True):
 112     """Build an ssh command to execute a command on a remote node.
 113
 114     Args:
 115       hostname: the target host, string
 116       user: user to auth as
 117       command: the command
 118       batch: if true, ssh will run in batch mode with no prompting
 119       ask_key: if true, ssh will run with StrictHostKeyChecking=ask, so that
 120                we can connect to an unknown host (not valid in batch mode)
 121       use_cluster_key: Whether to expect and use the cluster-global SSH key
 122       strict_host_check: Whether to check the host's SSH key at all
 123
 124     Returns:
 125       The ssh call to run 'command' on the remote host.
 126
 127     """
 128     argv = [constants.SSH, "-q"]
 129     argv.extend(self._BuildSshOptions(batch, ask_key, use_cluster_key,
 130                                       strict_host_check))
 131     if tty:
 132       argv.append("-t")
 133     argv.extend(["%s@%s" % (user, hostname), command])
 134     return argv
 135
 136   def Run(self, *args, **kwargs):
 137     """Runs a command on a remote node.
 138
 139     This method has the same return value as `utils.RunCmd()`, which it
 140     uses to launch ssh.
 141
 142     Args:
 143       See SshRunner.BuildCmd.
 144
 145     Returns:
 146       `utils.RunResult` like `utils.RunCmd()`
 147
 148     """
 149     return utils.RunCmd(self.BuildCmd(*args, **kwargs))
 150
 151   def CopyFileToNode(self, node, filename):
 152     """Copy a file to another node with scp.
 153
 154     Args:
 155       node: node in the cluster
 156       filename: absolute pathname of a local file
 157
 158     Returns:
 159       success: True/False
 160
 161     """
 162     if not os.path.isabs(filename):
 163       logging.error("File %s must be an absolute path", filename)
 164       return False
 165
 166     if not os.path.isfile(filename):
 167       logging.error("File %s does not exist", filename)
 168       return False
 169
 170     command = [constants.SCP, "-q", "-p"]
 171     command.extend(self._BuildSshOptions(True, False, True, True))
 172     command.append(filename)
 173     command.append("%s:%s" % (node, filename))
 174
 175     result = utils.RunCmd(command)
 176
 177     if result.failed:
 178       logging.error("Copy to node %s failed (%s) error %s,"
 179                     " command was %s",
 180                     node, result.fail_reason, result.output, result.cmd)
 181
 182     return not result.failed
 183
 184   def VerifyNodeHostname(self, node):
 185     """Verify hostname consistency via SSH.
 186
 187     This functions connects via ssh to a node and compares the hostname
 188     reported by the node to the name with have (the one that we
 189     connected to).
 190
 191     This is used to detect problems in ssh known_hosts files
 192     (conflicting known hosts) and incosistencies between dns/hosts
 193     entries and local machine names
 194
 195     Args:
 196       node: nodename of a host to check. can be short or full qualified hostname
 197
 198     Returns:
 199       (success, detail)
 200       where
 201         success: True/False
 202         detail: String with details
 203
 204     """
 205     retval = self.Run(node, 'root', 'hostname')
 206
 207     if retval.failed:
 208       msg = "ssh problem"
 209       output = retval.output
 210       if output:
 211         msg += ": %s" % output
 212       return False, msg
 213
 214     remotehostname = retval.stdout.strip()
 215
 216     if not remotehostname or remotehostname != node:
 217       return False, "hostname mismatch, got %s" % remotehostname
 218
 219     return True, "host matches"
 220
 221
 222 def WriteKnownHostsFile(cfg, file_name):
 223   """Writes the cluster-wide equally known_hosts file.
 224
 225   """
 226   utils.WriteFile(file_name, mode=0700,
 227                   data="%s ssh-rsa %s\n" % (cfg.GetClusterName(),
 228                                             cfg.GetHostKey()))