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):
 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
 115     Returns:
 116       The ssh call to run 'command' on the remote host.
 117
 118     """
 119     argv = [constants.SSH, "-q"]
 120     argv.extend(KNOWN_HOSTS_OPTS)
 121     argv.append(self._GetHostKeyAliasOption())
 122     if batch:
 123       # if we are in batch mode, we can't ask the key
 124       if ask_key:
 125         raise errors.ProgrammerError("SSH call requested conflicting options")
 126       argv.extend(BATCH_MODE_OPTS)
 127     elif ask_key:
 128       argv.extend(ASK_KEY_OPTS)
 129     if tty:
 130       argv.append("-t")
 131     argv.extend(["%s@%s" % (user, hostname), command])
 132     return argv
 133
 134   def Run(self, hostname, user, command, batch=True, ask_key=False):
 135     """Runs a command on a remote node.
 136
 137     This method has the same return value as `utils.RunCmd()`, which it
 138     uses to launch ssh.
 139
 140     Args:
 141       hostname: the target host, string
 142       user: user to auth as
 143       command: the command
 144       batch: if true, ssh will run in batch mode with no prompting
 145       ask_key: if true, ssh will run with StrictHostKeyChecking=ask, so that
 146                we can connect to an unknown host (not valid in batch mode)
 147
 148     Returns:
 149       `utils.RunResult` like `utils.RunCmd()`
 150
 151     """
 152     return utils.RunCmd(self.BuildCmd(hostname, user, command, batch=batch,
 153                                       ask_key=ask_key))
 154
 155   def CopyFileToNode(self, node, filename):
 156     """Copy a file to another node with scp.
 157
 158     Args:
 159       node: node in the cluster
 160       filename: absolute pathname of a local file
 161
 162     Returns:
 163       success: True/False
 164
 165     """
 166     if not os.path.isabs(filename):
 167       logger.Error("file %s must be an absolute path" % (filename))
 168       return False
 169
 170     if not os.path.isfile(filename):
 171       logger.Error("file %s does not exist" % (filename))
 172       return False
 173
 174     command = [constants.SCP, "-q", "-p"]
 175     command.extend(KNOWN_HOSTS_OPTS)
 176     command.extend(BATCH_MODE_OPTS)
 177     command.append(self._GetHostKeyAliasOption())
 178     command.append(filename)
 179     command.append("%s:%s" % (node, filename))
 180
 181     result = utils.RunCmd(command)
 182
 183     if result.failed:
 184       logger.Error("copy to node %s failed (%s) error %s,"
 185                    " command was %s" %
 186                    (node, result.fail_reason, result.output, result.cmd))
 187
 188     return not result.failed
 189
 190   def VerifyNodeHostname(self, node):
 191     """Verify hostname consistency via SSH.
 192
 193     This functions connects via ssh to a node and compares the hostname
 194     reported by the node to the name with have (the one that we
 195     connected to).
 196
 197     This is used to detect problems in ssh known_hosts files
 198     (conflicting known hosts) and incosistencies between dns/hosts
 199     entries and local machine names
 200
 201     Args:
 202       node: nodename of a host to check. can be short or full qualified hostname
 203
 204     Returns:
 205       (success, detail)
 206       where
 207         success: True/False
 208         detail: String with details
 209
 210     """
 211     retval = self.Run(node, 'root', 'hostname')
 212
 213     if retval.failed:
 214       msg = "ssh problem"
 215       output = retval.output
 216       if output:
 217         msg += ": %s" % output
 218       return False, msg
 219
 220     remotehostname = retval.stdout.strip()
 221
 222     if not remotehostname or remotehostname != node:
 223       return False, "hostname mismatch, got %s" % remotehostname
 224
 225     return True, "host matches"
 226
 227
 228 def WriteKnownHostsFile(cfg, sstore, file_name):
 229   """Writes the cluster-wide equally known_hosts file.
 230
 231   """
 232   utils.WriteFile(file_name, mode=0700,
 233                   data="%s ssh-rsa %s\n" % (sstore.GetClusterName(),
 234                                             cfg.GetHostKey()))