X-Git-Url: https://code.grnet.gr/git/ganeti-local/blobdiff_plain/fff33d7011b8dd0edb37a7c1018fc7f7805ffeb2..48297fa279792c8e456bb432bf2c8d108bcb7d1f:/lib/ssh.py diff --git a/lib/ssh.py b/lib/ssh.py index 2b06a58..40df999 100644 --- a/lib/ssh.py +++ b/lib/ssh.py @@ -25,31 +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 - - -KNOWN_HOSTS_OPTS = [ - "-oGlobalKnownHostsFile=%s" % constants.SSH_KNOWN_HOSTS_FILE, - "-oUserKnownHostsFile=/dev/null", - ] - -# Note: BATCH_MODE conflicts with ASK_KEY -BATCH_MODE_OPTS = [ - "-oBatchMode=yes", - "-oEscapeChar=none", - "-oStrictHostKeyChecking=yes", - ] - -ASK_KEY_OPTS = [ - "-oEscapeChar=none", - "-oHashKnownHosts=no", - "-oStrictHostKeyChecking=ask", - ] def GetUserFiles(user, mkdir=False): @@ -91,99 +71,125 @@ 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 _GetHostKeyAliasOption(self): - return "-oHostKeyAlias=%s" % self.sstore.GetClusterName() - - def BuildCmd(self, hostname, user, command, batch=True, ask_key=False, - tty=False): - """Build an ssh command to execute a command on a remote node. + def _BuildSshOptions(self, batch, ask_key, use_cluster_key, + strict_host_check): + """Builds a list with needed SSH options. - 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) + @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 - Returns: - The ssh call to run 'command' on the remote host. + @rtype: list + @return: the list of options ready to use in L{utils.RunCmd} """ - argv = [constants.SSH, "-q"] - argv.extend(KNOWN_HOSTS_OPTS) - argv.append(self._GetHostKeyAliasOption()) + options = [ + "-oEscapeChar=none", + "-oHashKnownHosts=no", + "-oGlobalKnownHostsFile=%s" % constants.SSH_KNOWN_HOSTS_FILE, + "-oUserKnownHostsFile=/dev/null", + ] + + if use_cluster_key: + 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 we are in batch mode, we can't ask the key if ask_key: raise errors.ProgrammerError("SSH call requested conflicting options") - argv.extend(BATCH_MODE_OPTS) + + options.append("-oBatchMode=yes") + + if strict_host_check: + options.append("-oStrictHostKeyChecking=yes") + else: + options.append("-oStrictHostKeyChecking=no") + elif ask_key: - argv.extend(ASK_KEY_OPTS) + options.extend([ + "-oStrictHostKeyChecking=ask", + ]) + + return options + + def BuildCmd(self, hostname, user, command, batch=True, ask_key=False, + tty=False, use_cluster_key=True, strict_host_check=True): + """Build an ssh command to execute a command on a remote node. + + @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 + + @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, + strict_host_check)) if tty: argv.append("-t") argv.extend(["%s@%s" % (user, hostname), command]) return argv - def Run(self, hostname, user, command, batch=True, ask_key=False): + def Run(self, *args, **kwargs): """Runs a command on a remote node. This method has the same return value as `utils.RunCmd()`, which it uses to launch ssh. - 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) + 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(hostname, user, command, batch=batch, - ask_key=ask_key)) + return utils.RunCmd(self.BuildCmd(*args, **kwargs)) 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.isfile(filename): - logger.Error("file %s does not exist" % (filename)) + if not os.path.isabs(filename): + logging.error("File %s must be an absolute path", filename) return False - if not os.path.isabs(filename): - logger.Error("file %s must be an absolute path" % (filename)) + if not os.path.isfile(filename): + logging.error("File %s does not exist", filename) return False command = [constants.SCP, "-q", "-p"] - command.extend(KNOWN_HOSTS_OPTS) - command.extend(BATCH_MODE_OPTS) - command.append(self._GetHostKeyAliasOption()) + 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 @@ -198,14 +204,12 @@ class SshRunner: (conflicting known hosts) and incosistencies 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') @@ -215,6 +219,9 @@ 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() @@ -225,10 +232,10 @@ class SshRunner: 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()))