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