X-Git-Url: https://code.grnet.gr/git/ganeti-local/blobdiff_plain/f6d9f4c349b403cb5d9a0cc0793d781ad2a805a1..b6b45e0d6251cd870658be36004ce4116f4a63c6:/lib/ssh.py

diff --git a/lib/ssh.py b/lib/ssh.py
index e99e3cd..e891314 100644
--- a/lib/ssh.py
+++ b/lib/ssh.py
@@ -25,12 +25,11 @@
 
 
 import os
+import logging
 
-from ganeti import logger
 from ganeti import utils
 from ganeti import errors
 from ganeti import constants
-from ganeti import ssconf
 
 
 def GetUserFiles(user, mkdir=False):
@@ -72,13 +71,24 @@ class SshRunner:
   """Wrapper for SSH commands.
 
   """
-  def __init__(self, sstore=None):
-    if sstore is None:
-      self.sstore = ssconf.SimpleStore()
-    else:
-      self.sstore = sstore
+  def __init__(self, cluster_name):
+    self.cluster_name = cluster_name
 
-  def _BuildSshOptions(self, batch, ask_key, use_cluster_key):
+  def _BuildSshOptions(self, batch, ask_key, use_cluster_key,
+                       strict_host_check):
+    """Builds a list with needed SSH options.
+
+    @param batch: same as ssh's batch option
+    @param ask_key: allows ssh to ask for key confirmation; this
+        parameter conflicts with the batch one
+    @param use_cluster_key: if True, use the cluster name as the
+        HostKeyAlias name
+    @param strict_host_check: this makes the host key checking strict
+
+    @rtype: list
+    @return: the list of options ready to use in L{utils.RunCmd}
+
+    """
     options = [
       "-oEscapeChar=none",
       "-oHashKnownHosts=no",
@@ -87,17 +97,22 @@ class SshRunner:
       ]
 
     if use_cluster_key:
-      options.append("-oHostKeyAlias=%s" % self.sstore.GetClusterName())
+      options.append("-oHostKeyAlias=%s" % self.cluster_name)
+
+    # TODO: Too many boolean options, maybe convert them to more descriptive
+    # constants.
 
     # Note: ask_key conflicts with batch mode
     if batch:
       if ask_key:
         raise errors.ProgrammerError("SSH call requested conflicting options")
 
-      options.extend([
-        "-oBatchMode=yes",
-        "-oStrictHostKeyChecking=yes",
-        ])
+      options.append("-oBatchMode=yes")
+
+      if strict_host_check:
+        options.append("-oStrictHostKeyChecking=yes")
+      else:
+        options.append("-oStrictHostKeyChecking=no")
 
     elif ask_key:
       options.extend([
@@ -107,24 +122,26 @@ class SshRunner:
     return options
 
   def BuildCmd(self, hostname, user, command, batch=True, ask_key=False,
-               tty=False, use_cluster_key=True):
+               tty=False, use_cluster_key=True, strict_host_check=True):
     """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)
-      use_cluster_key: Whether to expect and use the cluster-global SSH key
+    @param hostname: the target host, string
+    @param user: user to auth as
+    @param command: the command
+    @param batch: if true, ssh will run in batch mode with no prompting
+    @param ask_key: if true, ssh will run with
+        StrictHostKeyChecking=ask, so that we can connect to an
+        unknown host (not valid in batch mode)
+    @param use_cluster_key: whether to expect and use the
+        cluster-global SSH key
+    @param strict_host_check: whether to check the host's SSH key at all
 
-    Returns:
-      The ssh call to run 'command' on the remote host.
+    @return: the ssh call to run 'command' on the remote host.
 
     """
     argv = [constants.SSH, "-q"]
-    argv.extend(self._BuildSshOptions(batch, ask_key, use_cluster_key))
+    argv.extend(self._BuildSshOptions(batch, ask_key, use_cluster_key,
+                                      strict_host_check))
     if tty:
       argv.append("-t")
     argv.extend(["%s@%s" % (user, hostname), command])
@@ -136,11 +153,10 @@ class SshRunner:
     This method has the same return value as `utils.RunCmd()`, which it
     uses to launch ssh.
 
-    Args:
-      See SshRunner.BuildCmd.
+    Args: see SshRunner.BuildCmd.
 
-    Returns:
-      `utils.RunResult` like `utils.RunCmd()`
+    @rtype: L{utils.RunResult}
+    @return: the result as from L{utils.RunCmd()}
 
     """
     return utils.RunCmd(self.BuildCmd(*args, **kwargs))
@@ -148,33 +164,32 @@ class SshRunner:
   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
+    @param node: node in the cluster
+    @param filename: absolute pathname of a local file
 
-    Returns:
-      success: True/False
+    @rtype: boolean
+    @return: the success of the operation
 
     """
     if not os.path.isabs(filename):
-      logger.Error("file %s must be an absolute path" % (filename))
+      logging.error("File %s must be an absolute path", filename)
       return False
 
     if not os.path.isfile(filename):
-      logger.Error("file %s does not exist" % (filename))
+      logging.error("File %s does not exist", filename)
       return False
 
     command = [constants.SCP, "-q", "-p"]
-    command.extend(self._BuildSshOptions(True, False, True))
+    command.extend(self._BuildSshOptions(True, False, True, True))
     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))
+      logging.error("Copy to node %s failed (%s) error %s,"
+                    " command was %s",
+                    node, result.fail_reason, result.output, result.cmd)
 
     return not result.failed
 
@@ -186,17 +201,15 @@ class SshRunner:
     connected to).
 
     This is used to detect problems in ssh known_hosts files
-    (conflicting known hosts) and incosistencies between dns/hosts
+    (conflicting known hosts) and inconsistencies between dns/hosts
     entries and local machine names
 
-    Args:
-      node: nodename of a host to check. can be short or full qualified hostname
+    @param 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
+    @return: (success, detail), where:
+        - success: True/False
+        - detail: string with details
 
     """
     retval = self.Run(node, 'root', 'hostname')
@@ -206,20 +219,28 @@ class SshRunner:
       output = retval.output
       if output:
         msg += ": %s" % output
+      else:
+        msg += ": %s (no output)" % retval.fail_reason
+      logging.error("Command %s failed: %s" % (retval.cmd, msg))
       return False, msg
 
     remotehostname = retval.stdout.strip()
 
     if not remotehostname or remotehostname != node:
-      return False, "hostname mismatch, got %s" % remotehostname
+      if node.startswith(remotehostname + "."):
+        msg = "hostname not FQDN"
+      else:
+        msg = "hostname mistmatch"
+      return False, ("%s: expected %s but got %s" %
+                     (msg, node, remotehostname))
 
     return True, "host matches"
 
 
-def WriteKnownHostsFile(cfg, sstore, file_name):
+def WriteKnownHostsFile(cfg, file_name):
   """Writes the cluster-wide equally known_hosts file.
 
   """
-  utils.WriteFile(file_name, mode=0700,
-                  data="%s ssh-rsa %s\n" % (sstore.GetClusterName(),
+  utils.WriteFile(file_name, mode=0600,
+                  data="%s ssh-rsa %s\n" % (cfg.GetClusterName(),
                                             cfg.GetHostKey()))