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