#!/usr/bin/env python # tsshbatch.py - Non-Interactive ssh Connection # Copyright (c) 2011-2014 TundraWare Inc. # Permission Hereby Granted For Unrestricted Personal Or Commercial Use # See "tsshbatch-license.txt" For Licensing Details # # For Updates See: http://www.tundraware.com/Software/tsshbatch # A tip of the hat for some of the ideas in the program goes to: # # http://jessenoller.com/2009/02/05/ssh-programming-with-paramiko-completely-different/ ##### # Program Housekeeping ##### PROGNAME = "tsshbatch.py" BASENAME = PROGNAME.split(".py")[0] PROGENV = BASENAME.upper() CMDINCL = PROGENV + "CMDS" HOSTINCL = PROGENV + "HOSTS" CVSID = "$Id: tsshbatch.py,v 1.206 2014/12/08 18:19:11 tundra Exp $" VERSION = CVSID.split()[2] CPRT = "(c)" PROGDATE = "2011-2014" OWNER = "TundraWare Inc." RIGHTS = "All Rights Reserved." COPYRIGHT = "Copyright %s %s, %s %s" % (CPRT, PROGDATE, OWNER, RIGHTS) PROGVER = PROGNAME + " " + VERSION + (" - %s" % COPYRIGHT) HOMEPAGE = "http://www.tundraware.com/Software/%s\n" % BASENAME ##### # Suppress Deprecation Warnings # Required in some older environments where paramiko version # is behind the python libs version. ##### import warnings warnings.filterwarnings("ignore", "", DeprecationWarning) ##### # Imports ##### import commands import getopt import getpass import os import paramiko import shlex import socket import sys import time ##### # Constants And Literals ##### ABORTING = 'Aborting ...' COMMENT = '#' COMMANDS = 'Commands' CONSUCCESS = 'SUCCESS: Connection Established' EXECUTE = '!' GETFILES = 'Files To GET' HOSTSEP = '-' HOSTNOISE = '[%s]' HOSTLIST = 'Hosts' INDENTWIDTH = 8 OPTIONSLIST = 'EKG:H:NP:ST:aef:hkl:n:p:qstvxy' PADWIDTH = 12 PATHDELIM = ':' PATHSEP = os.sep PUTFILES = 'Files To PUT' SEPARATOR = ' ---> ' STDIN = '-' SUDO = 'sudo' SUDOPROMPT = 'READINGSUDOPW' SUDOARGS = '-S -p %s' % SUDOPROMPT SUDOPWHINT = '(Default: login password): ' SYMTABLE = 'Symbol Table' TESTRUN = 'Test Run For' TRAILER = ': ' USERVAR = 'USER' USAGE = \ PROGVER + "\n" +\ HOMEPAGE + "\n\n" +\ "Usage: tsshbatch.py [-EKNSTaehkqstvy -G 'file dest' -P 'file dest' -f cmdfile -l logfile -n name -p pw ] -H 'host ..' | hostlistfile [command arg ... ]\n" +\ " where,\n" +\ "\n" +\ " -E Write error output to stdout instead of stderr\n" +\ " -K Force password prompting - Overrides previous -k\n" +\ " -G 'file dest' GET file on host and write local dest directory\n" +\ " -H '...' List of targeted hosts passed as a single argument\n" +\ " -N Force prompting for username\n" +\ " -P 'file dest' PUT local file to host dest directory\n" +\ " -S Force prompting for sudo password\n" +\ " -T seconds Timeout for ssh connection attempts (Default: 15 sec)\n" +\ " -a Don't abort program after failed file transfers\n" +\ " -e Don't report remote host stderr output\n" +\ " -f cmdfile Read commands from file\n" +\ " -h Display help\n" +\ " -k Use key exchange-based authentication\n" +\ " -l logfile Log errors to logfile (Default: /dev/null)\n" +\ " -n name Specify login name\n" +\ " -p pw Specify login password\n" +\ " -q Quiet mode - produce less 'noisy' output\n" +\ " -s Silence all program noise - only return command output\n" +\ " -t Run in test mode, don't actually execute commands\n" +\ " -v Display extended program version information\n" +\ " -x Turn off test mode (if on) and execute requests\n" +\ " -y Turn on 'noisy' reporting for additional detail\n" ##### # Directives & Related Support ##### ASSIGN = '=' DEFINE = '.define' INCLUDE = '.include' ##### # Builtin Definitions ##### DATE = '__DATE__' DATETIME = '__DATETIME__' HOSTNAME = '__HOSTNAME__' HOSTNUM = '__HOSTNUM__' HOSTSHORT = '__HOSTSHORT__' TIME = '__TIME__' # This is needed to differentiate between user-defined and builtin # variables later in order to support the user being able to redefine # them. BuiltIns = (DATE, DATETIME, HOSTNAME, HOSTNUM, HOSTSHORT, TIME) ##### # Global Symbol Table ##### SymbolTable = {} ##### # Error Messages ##### eBADARG = "Invalid command line: %s!" eBADEXEC = "Execution variable failed: %s" eBADFILE = "Cannot open '%s'!" eBADSUDO = "sudo Failed (Check Password Or Command!) sudo Error Report: %s" eBADTXRQ = "Bad Transfer Request: %s Must Have Exactly 1 Source And 1 Destination!" eBADDEFINE = "Bad Symbol Definition: %s" eBADTIMEOUT = "Timeout Value Must Be an Integer!" eCMDFAILURE = "Failed To Run Command(s): %s" eFXERROR = "File Transfer Error: %s" eINCLUDECYCLE = "Circular Include At: %s" eNOCONNECT = "Cannot Connect: %s" eNOHOSTS = "No Hosts Specified!" eNOLOGIN = "Cannot Login! (Login/Password Bad?)" ##### # Informational Messages ##### iTXFILE = "Writing %s To %s ..." ##### # Prompts ##### pPASS = "Password: " pSUDO = "%s Password: " % SUDO pUSER = "Username (%s): " ##### # Options That Can Be Overriden By User #### ABORTONFXERROR = True # Abort after a file transfer error GETSUDOPW = False # Prompt for sudo password Hosts = [] # List of hosts to target KEYEXCHANGE = False # Do key exchange-based auth? LOGFILE = "/dev/null" # Where paramiko logging output goes PROMPTUSERNAME = False # Don't use $USER, prompt for username PWORD = "" # Password REDIRSTDERR = False # Redirect stderr to stdout REPORTERR = True # Report stderr output from remote host TESTMODE = True # Run program in test mode, don't actually execute commands TIMEOUT = 15 # Connection attempt timeout (sec) UNAME = "" # Login name # Noise levels NOISELEVEL = 0 # Normal noisy SILENT = 1 # No program noise at all QUIET = 2 # Make output less noisy NOISY = 3 # Print output with extra detail ##### # Global Data Structures ##### Commands = [] FileIncludeStack = [] Get_Transfer_List = {} Put_Transfer_List = {} ##### # Functions ##### # Gets rid of comments and strips leading/trailing whitespace def ConditionLine(line): return line.split(COMMENT)[0].strip() # End of 'ConditionLine()' ##### # Check To See If A Key Exists In A String, Excluding Quoted Substrings ##### def KeyInString(key, string): """ Look for 'key' in 'string', but exclude segments of the string that are contained within single- or double quotes. """ quote_chars = ('"', "'") InLiteral = False search = "" index = 0 while index < len(string): char = string[index] if InLiteral: if char == quote_char: InLiteral = False elif char in quote_chars: quote_char = char InLiteral = True else: search += char index += 1 status = False if search.count(key) > 0: status = True return status # End of KeyInString ##### # Print Message(s) To stderr ##### def PrintStderr(msg, EOL="\n"): # If we've been told to redirect to stdout, do so instead if REDIRSTDERR: PrintStdout(msg, EOL) else: sys.stderr.write(msg + EOL) sys.stderr.flush() # End of 'PrintStderr()' ##### # Print Message(s) To stdout ##### def PrintStdout(msg, EOL="\n"): sys.stdout.write(msg + EOL) sys.stdout.flush() # End of 'PrintStdout()' ##### # Display An Error Message And Exit ##### def ErrorExit(msg): if msg: PrintStderr(msg) os._exit(1) # End Of 'ErrorExit()' ##### # Transfer Files To A Host ##### def HostFileTransfer(host, user, pw, filelist, GET=False): try: ssh = paramiko.SSHClient() # Connect and run the command, reporting results as we go ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) if KEYEXCHANGE: ssh.connect(host, timeout=TIMEOUT) else: ssh.connect(host, username=user, password=pw, allow_agent=False, look_for_keys=False, timeout=TIMEOUT) sftp = ssh.open_sftp() for src in filelist: # Process any .define substitions srcfile = VarSub(src) for destdir in filelist[src]: # Process any .define substitutions destdir = VarSub(destdir) # Make sure we have a trailing path separator destination = destdir if destination[-1] != PATHSEP: destination += PATHSEP if GET: destination += host + HOSTSEP + os.path.basename(srcfile) PrintStdout(iTXFILE % (host + ":" + srcfile, destination)) sftp.get(srcfile, destination) os.chmod(destination, sftp.stat(srcfile).st_mode) else: destination += os.path.basename(srcfile) PrintStdout(iTXFILE % (srcfile, host + ":" + destination)) sftp.put(srcfile, destination) sftp.chmod(destination, os.stat(srcfile).st_mode) sftp.close() ssh.close() except: PrintReport([host, eFXERROR % str(sys.exc_info()[1])], HANDLER=PrintStderr) try: sftp.close() ssh.close() except: pass # Do we continue or not? if ABORTONFXERROR: ErrorExit("") # End of 'HostFileTransfer()' def HostCommands(host, user, pw, sudopw, commands): # Figure out if we want report formatting Format = True if NOISELEVEL == SILENT: Format = False ssh = paramiko.SSHClient() # Connect and run the command, reporting results as we go try: ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) if KEYEXCHANGE: ssh.connect(host, timeout=TIMEOUT) else: ssh.connect(host, username=user, password=pw, allow_agent=False, look_for_keys=False, timeout=TIMEOUT) if NOISELEVEL != QUIET: PrintReport([host, CONSUCCESS], FORMAT=Format) # Run all requested commands for command in commands: # Dereference variables command = VarSub(command) # It's possible to get blank lines from stdin. # Ignore them. if not command: continue # If this is a sudo run, force password to be read # from stdin thereby avoiding fiddling around with ptys. if KeyInString(SUDO + " ", command): command = command.replace(SUDO, "%s %s" % (SUDO, SUDOARGS), 1) stdin, stdout, stderr = ssh.exec_command(command) # If doing a sudo command, send the password if KeyInString(SUDO + " ", command): stdin.write("%s\n" % sudopw) stdin.flush() # If all we see on stderr at this point is our original # prompt, then then the sudo promotion worked. A bad # password or bad command will generate additional noise # from sudo telling us to try again or that there was a # command error. sudonoise = " ".join(stderr.readline().split(SUDOPROMPT)).strip() if sudonoise: # sudo had problems PrintReport([host + " [%s]" % command, eCMDFAILURE % (eBADSUDO % sudonoise)] + ["\n"], HANDLER=PrintStderr) ssh.close() raise SystemExit cmdreport = " [%s]" % command if NOISELEVEL == QUIET: cmdreport = "" PrintReport([host + " (stdout)" + cmdreport, "\n"] + stdout.readlines() + ["\n"], FORMAT=Format) if REPORTERR: PrintReport([host + " (stderr)" + cmdreport, "\n"] + stderr.readlines() + ["\n"], HANDLER=PrintStderr, FORMAT=Format) # Handle aborts except SystemExit: ErrorExit(ABORTING) # Catch authentication problems explicitly except paramiko.AuthenticationException: PrintReport([host, eCMDFAILURE % eNOLOGIN], HANDLER=PrintStderr) # Everything else is some kind of connection problem except: PrintReport([host, eCMDFAILURE % (eNOCONNECT % str(sys.exc_info()[1]))], HANDLER=PrintStderr) ssh.close() # End of 'HostCommands()' ##### # Print Report ##### # Expects input as [host, success/failure message, result1, result2, ...] # Uses print handler to stdout by default but can be overriden at call # time to invoke any arbitrary handler function. def PrintReport(results, HANDLER=PrintStdout, FORMAT=True): if FORMAT: hostname = results[0] HANDLER(SEPARATOR + hostname + TRAILER + (PADWIDTH - len(results[0])) * " " + results[1]) # Prepend the host name if we've asked for noisy reporting hostnoise ="" if NOISELEVEL == NOISY: hostnoise = HOSTNOISE % hostname for r in results[2:]: # Command Results HANDLER(hostnoise + INDENTWIDTH * " " + r.strip()) # In (silent) unformatted mode we just return results with no # headers or formatting. We suppress the last line in the list. # It is an empty line introduced for formatting by the caller, but # isn't really part of the returned output. else: for r in results[2:-1]: HANDLER(r, EOL="") # End of 'PrintReport()' ##### # Process A File Transfer Request ##### def ProcessTXRQ(request, storage): src_dest = request.split() if len(src_dest) != 2: ErrorExit(eBADTXRQ % src_dest) else: if src_dest[0] not in storage: storage[src_dest[0]] = [src_dest[1],] else: storage[src_dest[0]].append(src_dest[1]) # End of 'ProcessTXRQ' ##### # Read File Handling Comments And Directives ##### def ReadFile(fname, envvar, listcontainer, containingfile=""): # Check to see if we can find the file, searching the # the relevant include environment variable path, if any filename = SearchPath(fname, envvar) if not filename: ErrorExit(eBADFILE % fname) # Make sure we don't have a cyclic include reference if filename in FileIncludeStack: ErrorExit(eINCLUDECYCLE % containingfile + SEPARATOR + filename) else: FileIncludeStack.append(filename) # Push it on to the stack history try: f = open(filename) for line in f.readlines(): # Cleanup comments and whitespace line = ConditionLine(line) # Process variable definitions if line.startswith(DEFINE): line = line.split(DEFINE)[1] if line.count(ASSIGN) == 0: ErrorExit(eBADDEFINE % line) else: name = line.split(ASSIGN)[0].strip() val = "=".join(line.split(ASSIGN)[1:]).strip() # Process references to execution variables if val.startswith(EXECUTE): try: origval = val status, val = commands.getstatusoutput(val[1:].strip()) # Blow out if the command failed if status: raise except: PrintReport([PROGNAME, eBADEXEC % origval], HANDLER=PrintStderr) ErrorExit("") if name: SymbolTable[name] = val else: ErrorExit(eBADDEFINE % line) # Process file includes elif line: if line.startswith(INCLUDE): fname = ConditionLine(line.split(INCLUDE)[1]) ReadFile(fname, envvar, listcontainer, containingfile=filename) # It's a normal line - do variable substitution and save else: listcontainer.append(line) f.close() FileIncludeStack.pop() # Remove this invocation from the stack return listcontainer except: ErrorExit(eBADFILE % filename) # End of 'ReadFile()' ##### # Search A Path For A File, Returning First Match ##### def SearchPath(filename, pathlist, delimiter=PATHDELIM): # What we'll return if we find nothing retval = "" # Handle fully qualified filenames # But ignore this, if its a directory with a matching name if os.path.exists(filename) and os.path.isfile(filename): retval = os.path.realpath(filename) # Find first instance along specified path if one has been specified elif pathlist: paths = pathlist.split(delimiter) for path in paths: if path and path[-1] != PATHSEP: path += PATHSEP path += filename if os.path.exists(path): retval = os.path.realpath(path) break return retval # End of 'SearchPath()' ##### # Do Variable Substitution In A String ##### def VarSub(line): for symbol in SymbolTable: line = line.replace(symbol, SymbolTable[symbol]) return line # End of 'VarSub()' # ---------------------- Program Entry Point ---------------------- # ##### # Process Any Options User Set In The Environment Or On Command Line ##### # Handle any options set in the environment OPTIONS = sys.argv[1:] envopt = os.getenv(PROGENV) if envopt: OPTIONS = shlex.split(envopt) + OPTIONS # Combine them with those given on the command line # This allows the command line to override defaults # set in the environment try: opts, args = getopt.getopt(OPTIONS, OPTIONSLIST) except getopt.GetoptError, (errmsg, badarg): ErrorExit(eBADARG % errmsg) for opt, val in opts: if opt == "-E": REDIRSTDERR = True if opt == "-K": KEYEXCHANGE = False if opt == "-G": ProcessTXRQ(val, Get_Transfer_List) if opt == "-H": Hosts = val.split() if opt == "-N": PROMPTUSERNAME = True KEYEXCHANGE = False if opt == "-P": ProcessTXRQ(val, Put_Transfer_List) if opt == "-S": GETSUDOPW = True if opt == "-T": try: TIMEOUT = int(val) except: ErrorExit(eBADTIMEOUT) if opt == "-a": ABORTONFXERROR = False if opt == "-e": REPORTERR = False if opt == "-f": Commands = ReadFile(val, os.getenv(CMDINCL), Commands) if opt == "-h": PrintStdout(USAGE) sys.exit() if opt == "-k": KEYEXCHANGE = True if opt == "-l": LOGFILE = val if opt == "-n": UNAME = val if opt == "-p": PWORD = val if opt == "-q": NOISELEVEL = QUIET if opt == "-s": NOISELEVEL = SILENT if opt == "-t": TESTMODE = True if opt == "-v": PrintStdout(CVSID) sys.exit() if opt == "-x": TESTMODE = False if opt == "-y": NOISELEVEL = NOISY ##### # Intitialize paramiko Logging ##### paramiko.util.log_to_file(LOGFILE) ##### # Host & Command Line Command Definition Processing ##### # Get the list of hosts if not specified on command line. # The assumption is that the first argument is the file # containing the list of targeted hosts and the remaining # arguments form the command. if not Hosts: # Even if we are only doing file transfers and no command # is specified, we have to have at least one argument here # to tell us what hosts we're working on. if not args: ErrorExit(eNOHOSTS) Hosts = ReadFile(args[0], os.getenv(HOSTINCL), Hosts) command = " ".join(args[1:]) # If hosts were passed on the command line, all the arguments # are understood to form the command. else: command = " ".join(args[0:]) # Put it in a list data structure because this is what the # HostCommands() function expects. This is necessary to handle multi # command input from from a file. command = ConditionLine(command) if command: # Do variable substitution here like any other command Commands.append(command) ##### # Authentication Credential Processing ##### # Precedence of authentication credential sources: # # 1) Key exchange # 2) Forced prompting for name via -N # 3) Command Line/$TSSHBATCH env variable sets name # 4) Name picked up from $USER (Default behavior) if not KEYEXCHANGE: # Preset commandline and/or program option variable username takes precedence if not UNAME: UNAME = os.getenv(USERVAR) # By default, use the above as the login name and don't prompt for it # unless overriden on the command line with -N if PROMPTUSERNAME: current_user = UNAME UNAME = raw_input(pUSER %current_user) if not UNAME: # User just hit return - wants default UNAME = current_user # Preset commandline and/or program option variable password takes precedence if not PWORD: PWORD = getpass.getpass(pPASS) ##### # If Needed, Get sudo Password #### # The need to prompt for a sudo password depends on a number of # conditions: # # If a login password is present either via manual entry or -p, sudo # will use that without further prompting. (Default) # # The user is prompted for a sudo password under two conditions: # # 1) -k option was selected but no password was set with -p # 2) -S option was selected # # If the user IS prompted for a sudo password, any login password # previously entered - either via -p or interactive entry - will be # used as the default. The user can hit enter to accept this or enter # a different password. This allows login and sudo passwords to be # the same or different. # Find out if we have any sudo commands SUDOPRESENT = False for command in Commands: if KeyInString(SUDO + " ", command): SUDOPRESENT = True # Check condition 1) above. # (Condition 2 handled during options processing). if KEYEXCHANGE and not PWORD: GETSUDOPW = True SUDOPW = PWORD if SUDOPRESENT and GETSUDOPW: sudopwmsg = pSUDO if PWORD: sudopwmsg = sudopwmsg[:-2] + " " + SUDOPWHINT SUDOPW = getpass.getpass(sudopwmsg) if PWORD and not SUDOPW: SUDOPW = PWORD ##### # Do The Requested Work ##### # If we're running testmode, just report the final list of # hosts and commands that would be run if TESTMODE: symtbl = [] gets = [] puts = [] # Unroll and format dictionary structures symbols = SymbolTable.keys() symbols.sort() for symbol in symbols: symtbl.append(symbol + (PADWIDTH - len(symbol)) * " "+ SEPARATOR + SymbolTable[symbol]) for xfers, unrolled in ((Get_Transfer_List, gets), (Put_Transfer_List, puts)): for source in xfers: for dest in xfers[source]: # Dereference any variables in the file transfer specification source = VarSub(source) dest = VarSub(dest) unrolled.append(source + (PADWIDTH*3 - len(source)) * " "+ SEPARATOR + dest) # Dereference any variables in the list of commands index = 0 while (index < len(Commands)): Commands[index] = VarSub(Commands[index]) index += 1 # Dereference any variables in the list of hosts index = 0 while (index < len(Hosts)): Hosts[index] = VarSub(Hosts[index]) index += 1 for prompt, description, items in ((TESTRUN, " ".join(OPTIONS), ["\n"]), (SYMTABLE, "", symtbl + ["\n"]), (HOSTLIST, "", Hosts + ["\n"]), (GETFILES, "", gets + ["\n"]), (PUTFILES, "", puts + ["\n"]), (COMMANDS, "", Commands + ["\n"]) ): PrintReport([prompt, description] + items) # Otherwise, actually do the work by iterating over the list of hosts, # executing any file transfers and commands. Accomodate commenting # out hosts in a list. else : # Check to see if user is trying to override any builtins protected = [] for builtin in BuiltIns: if builtin in SymbolTable: protected.append(builtin) # Now iterate over requested hosts hostnum = 0 for host in Hosts: # Update the host counter hostnum += 1 # Add internally generated symbols to the symbol table. # That way, both user-defined and builtin symbols will # subsequently be substituted. internals = [ (DATE, time.strftime("%Y%m%d")), (DATETIME, time.strftime("%Y%m%d%H%M%S")), (HOSTNAME, host), (HOSTNUM, str(hostnum)), (HOSTSHORT, host.split('.')[0]), (TIME, time.strftime("%H%M%S")), ] # Install builtins in the symbol table but only if the # user isn't overriding them. for symbol, value in internals: if symbol not in protected: SymbolTable[symbol] = value # Apply any relevant variable dereferencing host = VarSub(host) if Get_Transfer_List: HostFileTransfer(host, UNAME, PWORD, Get_Transfer_List, GET=True) if Put_Transfer_List: HostFileTransfer(host, UNAME, PWORD, Put_Transfer_List, GET=False) if Commands: HostCommands(host, UNAME, PWORD, SUDOPW, Commands)