def run(args, logging): """ Runs the cmd executor :param args: A NameSpace object with the arguments required :param logging: A python logging object :return: An exit code """ hostname = build_data.read(args.build_id, 'instance', 'public_ip_address') client = SSHClient() client.set_missing_host_key_policy(AutoAddPolicy()) logging.info('Connecting to remote host "{0}"...'.format(hostname)) client.connect(hostname, port=args.port, username=args.username, key_filename=args.key_filename, timeout=args.timeout) logging.info('Executing command "{0}"...'.format(args.cmd)) # pylint: disable=W0612 stdin, stdout, stderr = client.exec_command(args.cmd) exit_code = stdout.channel.recv_exit_status() stdout = stdout.channel.makefile().read() or 'None' stderr = stderr.channel.makefile().read() or 'None' logging.info('Exit code...') logging.info(exit_code) logging.info('Standard out...') logging.info(stdout) logging.info('Standard error...') logging.info(stderr) return exit_code, stdout, stderr
class conn(): def __init__(self, user, passwd, ip): self.user = user self.passwd = passwd self.ip = ip self.sshConn = SSHClient() self.sshConn.set_missing_host_key_policy(AutoAddPolicy()) try: self.sshConn.connect(self.ip, port = 22, username = self.user,password = self.passwd, timeout = 60, allow_agent = False,look_for_keys = False) self.status = 'Succeeded' except: self.status = 'Failed' def runCommand(self, command): self.stdin, self.stdout, self.stderr = (None,None,None) if self.status == 'Succeeded': self.stdin, self.stdout, self.stderr = self.sshConn.exec_command(command) def closeSocket(self): self.sshConn.close()
def create_client(self): private = RSAKey(filename=self.get_private_key_file()) client = SSHClient() client.set_missing_host_key_policy(AutoAddPolicy()) client.load_host_keys(self.get_host_keys_file()) client.connect(self.server.host, pkey=private, look_for_keys=False, port=self.server.port, username=self.server.user) return client
def __startInstance( device , datatype , response , pcount ): processorNode = settings.PROCCESSOR_NODES[ (pcount + 1 ) % len( settings.PROCCESSOR_NODES ) ] logger.debug("Creating Node On " + processorNode ) client = SSHClient() client.load_system_host_keys() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) rsa_private_key = paramiko.RSAKey.from_private_key_file( settings.SSHID ) client.connect( processorNode , username="******" , pkey = rsa_private_key ) logger.debug( 'docker run -d ' + datatype.processor + ' python /root/Processor.py ' + settings.MASTER_HOSTNAME + \ ' ' + device.identifier + ' ' + datatype.identifier + ' ' + response.identifier ) stdin, stdout, stderr = client.exec_command( 'docker run -d ' + datatype.processor + ' python /root/Processor.py ' + settings.MASTER_HOSTNAME + \ ' ' + device.identifier + ' ' + datatype.identifier + ' ' + response.identifier ) for i in stderr.readlines(): logger.error(str(i)) for i in stdout.readlines(): logger.debug(str(i)) identifier = i return { 'identifier' : identifier , 'node' : processorNode }
def connect(self): """Initiate an ssh connection with properties passed to constructor. :returns: Instance of the paramiko SSHClient class. """ usePrivateKey = True for prop in self.required_props1: if prop not in list(self.properties.keys()): usePrivateKey = False break usePassword = True for prop in self.required_props2: if prop not in list(self.properties.keys()): usePassword = False break if not usePrivateKey and not usePassword: raise ShakeMapException('Either username/password must be specified, or the name of an SSH private key file.') ssh = SSHClient() #load hosts found in ~/.ssh/known_hosts ssh.load_system_host_keys() #should we not assume that the user has these configured already? if usePrivateKey: try: ssh.connect(self.properties['remotehost'], key_filename=self.properties['privatekey'],compress=True) except Exception as obj: raise ShakeMapException('Could not connect with private key file %s' % self.properties['privatekey']) else: try: ssh.connect(self.properties['remotehost'], username=self.properties['username'],password=self.properties['password'], compress=True) except Exception as obj: raise ShakeMapException('Could not connect with private key file %s' % self.properties['privatekey']) return ssh
def get_file(fname): ssh = SSHClient() ssh.load_system_host_keys() ssh.connect(file_server) scp = SCPClient(ssh.get_transport()) scp.get(fname) scp.close()
def _uploadFiles(self, dstdir, **sshargs): (yield TaskOutput(u"ENTER", OutputType.NOTIFY)) sshcli = SSHClient() sftpcli = None code = 0 try: if not (yield TaskOutput(u"Conntecting to %s ..." % sshargs["hostname"])): raise CommandTerminated() sshcli.set_missing_host_key_policy(AutoAddPolicy()) sshcli.connect(**sshargs) if not (yield TaskOutput(u"Connected, ready to upload ...")): raise CommandTerminated() ret = sshcli.exec_command("[ -d {0} ] && rm -rf {0}; mkdir -p {0}".format(dstdir)) errstr = ret[2].read() if errstr != "": raise Exception(errstr) sftpcli = sshcli.open_sftp() for f in os.listdir(self.hdiff_dir): if f.lower().endswith(".html"): localfile = os.path.join(self.hdiff_dir, f) remotefile = os.path.join(dstdir, f).replace(os.sep, "/") if not (yield TaskOutput(u"Uploading %s ..." % f)): raise CommandTerminated() sftpcli.put(localfile, remotefile) except CommandTerminated: code = -2 (yield TaskOutput(u"Uploading Terminited", OutputType.WARN)) except Exception as ex: code = -1 (yield TaskOutput(ex.message, OutputType.ERROR)) finally: if sftpcli: sftpcli.close() sshcli.close() (yield TaskOutput(u"EXIT %d" % code, OutputType.NOTIFY))
class SSH(object): """ package for ssh_client, in this class stores the sftp handlers and the ssh_client """ def __init__(self, host, user, password, port=22): self.host = host self.user = user self.password = password self.port = port def client_init(self): self.clt = SSHClient() self.clt.load_system_host_keys() self.clt.set_missing_host_key_policy(AutoAddPolicy()) def ssh_connect(self, task_list, ret_map): try: self.client_init() self.clt.connect(hostname=self.host, username=self.user, password=self.password, port=self.port, timeout=3) self.sftp = self.clt.open_sftp() except Exception, e: self.ssh_close() for task in task_list: if len(task) > 1: ret_map[task[0]] = (-1, "ssh connect error %s" % str(e)) return False return True
def copySCP(self, datum_original, datum_destination, server, username, option_type): """Copy data via SCP function """ util.log_to_file('ssh.log') ssh = SSHClient() ssh.load_system_host_keys() logging.info("connection to %s" % server) ssh.connect(server, username=username, compress=True, timeout=60) # SCPCLient takes a paramiko transport as its only argument client = scp.SCPClient(ssh.get_transport()) logging.info(option_type + ": %s to %s" % (datum_original['location'], datum_destination['location'])) if option_type == 'upload': client.put(datum_original['location'], datum_destination['location'], recursive=True) else: client.get(datum_original['location'], datum_destination['location'], recursive=True) client.close()
def get_file(remote_file, local_path, ip, username, password, logger=None): # Получает с удаленной машины файл remote_file с помощью scp и сохраняет его в local_path. if local_path[len(local_path) - 1] != '/': local_path += '/' ssh = SSHClient() ssh.set_missing_host_key_policy(AutoAddPolicy()) ssh.load_system_host_keys() if logger is not None: logger.info("SCP GET: connecting to %s" % (ip)) try: ssh.connect(ip, username=username, password=password) except: if logger is not None: logger.info("SCP GET: failed to connect to %s" % (ip)) return False else: if logger is not None: logger.info("SCP GET: connected to %s" % (ip)) try: if logger is not None: logger.info("SCP GET: retrieving file %s" % (remote_file)) scp = SCPClient(ssh.get_transport()) scp.get(remote_file, local_path) except: if logger is not None: logger.error("SCP GET: error: failed to retrieve file %s" % (remote_file)) ssh.close() return False else: if logger is not None: logger.info("SCP GET: file saved to %s folder" % (local_path)) ssh.close() return True
def send_file(local_file, remote_path, ip, username, password, logger=None): # Отсылает файл local_file в remote_path удаленной машины по scp if remote_path[len(remote_path) - 1] != '/': remote_path += '/' ssh = SSHClient() ssh.set_missing_host_key_policy(AutoAddPolicy()) ssh.load_system_host_keys() if logger is not None: logger.info("SCP SEND: connecting to %s" % (ip)) try: ssh.connect(ip, username=username, password=password) except: if logger is not None: logger.info("SCP SEND: failed to connect to %s" % (ip)) return False else: if logger is not None: logger.info("SCP SEND: connected to %s" % (ip)) try: if logger is not None: logger.info("SCP SEND: sending file %s" % (local_file)) scp = SCPClient(ssh.get_transport()) scp.put(local_file, remote_path) except: if logger is not None: logger.error("SCP SEND: error: failed to send file %s" % (local_file)) ssh.close() return False else: if logger is not None: logger.info("SCP SEND: file sent to %s@%s:%s " % (username, ip, remote_path)) ssh.close() return True
class sshConnection(): def __init__(self, host, user, password): self.host = host self.user = user self.password = password self.connection = None self.channel = None def connect(self): try: print "[+] Estableciendo conexion SSH con %s@%s...." % (self.user, self.host) self.connection = SSHClient() self.connection.set_missing_host_key_policy(AutoAddPolicy()) self.connection.connect( self.host, username = self.user, password = self.password, allow_agent = False, look_for_keys = False ) except AuthenticationException, e: print "[+] Error de autenticacion: " ,e return 1 except SSHException, e: print "[+] Error en SSH: " , e return 2
def get(nodes_file, request): """Return the logs""" args = dict(request.args.items()) try: container = args.pop('container') except KeyError: raise errors.BadRequest('No container on URL arguments') results = dict() with open(nodes_file) as f: nodes = yaml.load(f) try: rsa_key_file = nodes.pop('rsa_key') pkey = RSAKey.from_private_key_file(rsa_key_file) except Exception as e: print('Failed to read RSA Key, {} {}'.format(type(e), e)) raise ssh = SSHClient() ssh.set_missing_host_key_policy(AutoAddPolicy) cmd = 'docker logs {container} {args}'.format( container=container, args=' '.join(['--{}={}'.format(a, args[a]) for a in args])) for _, ips in nodes.items(): for ip in ips: ssh.connect(hostname=ip, username='******', pkey=pkey) print('ssh root@{ip} {cmd}'.format(ip=ip, cmd=cmd)) _in, _out, _err = ssh.exec_command(cmd) status = _out.channel.recv_exit_status() results[ip] = dict( status=status, stdout=_out.read(), stderr=_err.read()) ssh.close() return results
def get(self, remote_path, local_path=None, out_stream=sys.stdout, verbose=False): """ Copy a file from the remote system to the local system. :param remote_path: :param local_path: :param out_stream: :param verbose: :return: :rtype: """ if local_path is None: local_path = remote_path self.display("scp '{src}' '{dest}'".format(src=remote_path, dest=local_path), out_stream=out_stream, verbose=verbose) names = self.run(['ls', '-1', remote_path]).split('\n') ssh = SSHClient() ssh.load_system_host_keys() ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) ssh.connect(Project.address, Project.port, Project.user, Project.password) # scp = SFTPClient.from_transport(ssh.get_transport()) # output = scp.get(remote_path, local_path, recursive=True) ftp = ssh.open_sftp() for name in names: print(name) ftp.get(name, local_path) output = repr(names) self.display(output, out_stream=out_stream, verbose=verbose) return output
def ssh_cmd(ip, remote_cmd, user='******', password=None, quiet=False): """ @param server_ip @param user @param password @param remote_cmd @return A map based on pass / fail run info """ output = StringIO() error = StringIO() ssh = SSHClient() ssh.set_missing_host_key_policy(AutoAddPolicy()) ssh.connect(ip, username=user, password=password) stdin, stdout, stderr = ssh.exec_command(remote_cmd) stdin.close() exit_status = None for line in stdout.xreadlines(): if not quiet: sys.stdout.write(line) output.write(line) for line in stderr.xreadlines(): sys.stdout.write(line) error.write(line) exit_status = stdout.channel.recv_exit_status() return {'success': True if exit_status == 0 else False, 'return': output.getvalue(), 'exit_status': exit_status, 'error': error.getvalue()}
def rollback_using_import_policy(self, version): filenames = self.get_filenames(version) # Create the tar file of the selected JSON files self._generate_tar_gz(filenames, version) # Put the tar file on the APIC ssh = SSHClient() ssh.load_system_host_keys() ssh.set_missing_host_key_policy(AutoAddPolicy()) ssh.connect(self.session.ipaddr, username=self.session.uid, password=self.session.pwd) sftp = ssh.open_sftp() sftp.chdir('/home/%s' % self.session.uid) sftp.put('./ce_snapback.tar.gz', 'ce_snapback.tar.gz') # Remove the local tar file os.remove('./ce_snapback.tar.gz') # Send the import policy to the APIC url = '/api/node/mo/uni/fabric.json' payload = {"configImportP": {"attributes": { "name": "snapback", "fileName": "ce_snapback.tar.gz", "adminSt": "triggered", "importType": "replace", "importMode": "atomic"}, "children": [{"configRsImportSource": {"attributes": {"tnFileRemotePathName": "snapback"}, "children": [] }}]}} resp = self.session.push_to_apic(url, payload) return resp
def main(file, key, encrypt, host, username, password): """ The main function. Takes multiple parameters which are prompted if not given on the command line. :param file: The paht of the file to encrypt or decrypt and send. :param key: The key to encrypt or decrypt. :param encrypt: Tells if the operation is an encryption or a decryption. :param host: The host where to send the file. :param username: Username on the host. :param password: Password if needed. If not needed '-' should be used to tell that there is no password needed. """ ssh = SSHClient() ssh.load_system_host_keys() if password != "-": ssh.connect(host, username=username, password=password) else: ssh.connect(host, username=username) scp = SCPClient(ssh.get_transport()) if encrypt: print("Encrypting... ", end="") to_send = encrypt_file(file, key) print("Done.") print("Sending to {}...".format(host), end="") scp.put(to_send) print("Done.") else: print(decrypt_file(file, key))
def _exec(self): exitcode = 0 client = SSHClient() client.load_system_host_keys() client.set_missing_host_key_policy(WarningPolicy) try: client.connect(self.config.get('hostname'), int(self.config.get('port', 22)), username=self.config.get('user')) stdin, stdout, stderr = self.exec_command(client) for i, line in enumerate(stdout): line = line.rstrip() print("{0}: {1}".format(self.host, line)) for i, line in enumerate(stderr): line = line.rstrip() print(colored("{0}: {1}".format(self.host, line), 'red')) exitcode = 1 except IOError as e: print(colored('{0}: {1}'.format(self.host, str(e)), 'red')) exitcode = 1 except (BadHostKeyException, AuthException, SSHException) as e: print(colored('{0}: {1}'.format(self.host, e.message)), 'red') exitcode = 1 finally: client.close() return exitcode
def wait_for_beessh(options): pause = options.get('pause', 10) timeout = options.get('timeout', 600) client = SSHClient() client.set_missing_host_key_policy(AutoAddPolicy()) wait = 0 while wait < timeout: try: client.connect( options['hostname'], username=options['username'], key_filename=options['key_filename'], timeout=5 ) print('[Queen] connected to {} in {} seconds'.format(options['hostname'], wait)) client.close() return {options['hostname']: {'username': options['username'], 'name': options['hostname']}} except (SocketError, TimeoutError) as error: time.sleep(pause) wait += pause except Exception as error: print('[Queen] error connecting to instance', options['hostname'], error) print('[Error] timed out while connecting over ssh to {}'.format(options['hostname'])) return None
def verify_ssh_login(userid): client = SSHClient() client.load_system_host_keys() # client.set_missing_host_key_policy(WarningPolicy) client.set_missing_host_key_policy(AutoAddPolicy()) # TEST ONLY hosts = ["india.futuregrid.org"] key = os.path.expanduser(os.path.join("~", ".ssh", "id_rsa")) print "[key: %s]" % key if not userid: userid = getpass.getuser() for host in hosts: try: client.connect(host, username=userid, key_filename=key) client.close() print "[%s] succeeded with %s." % (host, userid) except (BadHostKeyException, AuthenticationException, SSHException) as e: # print sys.exc_info() print ("[%s] %s with %s. Please check your ssh setup (e.g. key " + "files, id, known_hosts)") % (host, e, userid)
def executeOnMaster(self, cmd): """ Execute command on the current master leader """ self.log.debug("Executing on master: " + cmd) if self._hostnameResolves(self.getManagementEndpoint()): ssh = SSHClient() ssh.load_system_host_keys() ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) ssh.connect( self.getManagementEndpoint(), username = self.config.get('ACS', "username"), port = 2200, key_filename = os.path.expanduser(self.config.get('SSH', "privatekey"))) session = ssh.get_transport().open_session() AgentRequestHandler(session) stdin, stdout, stderr = ssh.exec_command(cmd) stdin.close() result = "" for line in stdout.read().splitlines(): self.log.debug(line) result = result + line.decode("utf-8") + "\n" for line in stderr.read().splitlines(): self.log.error(line) else: self.log.error("Endpoint " + self.getManagementEndpoint() + " does not exist, cannot SSH into it.") result = "Exception: No cluster is available at " + self.getManagementEndpoint() ssh.close() return result
class SFTP(Operations): """A simple SFTP filesystem. Requires paramiko: http://www.lag.net/paramiko/ You need to be able to login to remote host without entering a password. """ def __init__(self, host, path='.'): self.client = SSHClient() self.client.load_system_host_keys() self.client.connect(host) self.sftp = self.client.open_sftp() self.root = path def __del__(self): self.sftp.close() self.client.close() def __call__(self, op, path, *args): print '->', op, path, args[0] if args else '' ret = '[Unhandled Exception]' try: ret = getattr(self, op)(self.root + path, *args) return ret except OSError, e: ret = str(e) raise except IOError, e: ret = str(e) raise OSError(*e.args)
def connect(self): logger.debug("Opening SSH connection to {host}:{port}".format(host=self.host, port=self.port)) client = SSHClient() client.load_system_host_keys() client.set_missing_host_key_policy(AutoAddPolicy()) try: client.connect(self.host, port=self.port, username=self.username, timeout=self.timeout) except ValueError, e: logger.error(e) logger.warning( """ Patching Crypto.Cipher.AES.new and making another attempt. See here for the details: http://uucode.com/blog/2015/02/20/workaround-for-ctr-mode-needs-counter-parameter-not-iv/ """ ) client.close() import Crypto.Cipher.AES orig_new = Crypto.Cipher.AES.new def fixed_AES_new(key, *ls): if Crypto.Cipher.AES.MODE_CTR == ls[0]: ls = list(ls) ls[1] = "" return orig_new(key, *ls) Crypto.Cipher.AES.new = fixed_AES_new client.connect(self.host, port=self.port, username=self.username, timeout=self.timeout)
def get_proxmox_ssh(proxmox): proxmox_ssh = SSHClient() proxmox_ssh.set_missing_host_key_policy(WarningPolicy()) proxmox_ssh.connect(proxmox['host'], username=proxmox['user'].split('@')[0]) return proxmox_ssh
def sync_public_key(host, port=22, username=None, password=None): try: client = SSHClient() client.connect(hostname=host, username=username, password=password) except SSHException, e: client.close() client = SSHClient() client.set_missing_host_key_policy(AutoAddPolicy()) client.connect(hostname=host, username=username, password=password) sftp_client = client.open_sftp() id_rsa_pub = "/home/%s/.ssh/id_rsa.pub" % LOCAL_USER_NAME if username == "root": remote_rsa_pub = "/root/.ssh/%s.pub" % (LOCAL_USER_NAME) else: remote_rsa_pub = "/home/%s/.ssh/%s.pub" % (username, LOCAL_USER_NAME) print remote_rsa_pub try: sftp_client.put(id_rsa_pub , remote_rsa_pub) except Exception, e: """ if the remote host did have .ssh dirctory """ print e
def connect_and_retrieve(device,lock=None): ssh_client=SSHClient() ssh_client.set_missing_host_key_policy(.AutoAdd()) try: ssh_client.connect(device.address,port=22,username=device.username,password=device.password) except AuthenticationException: continue except SSHException: return False except socket.error: return False else: try: result=better_exec("cat /tmp/running.cfg",ssh_client)+'\n' result=result+(better_exec("cat /tmp/system.cfg",ssh_client))+'\n' result=result+(better_exec("exit",ssh_client))+'\n' except paramiko.SSHException: lock.acquire() if not lock == None outfile=open('configs.txt','a') outfile.write(device.address+'FAILED') outfile.close() lock.release() if not lock == None return False else: lock.acquire() if not lock == None outfile=open('configs.txt','a') outfile.write(result) outfile.write('\n') outfile.write(device.address+'\n') outfile.close() lock.release() if not lock == None ssh_client.close() return True
def __validate_creds__(self): try: usernames=[] passwords=[] if not self.username in usernames: usernames.insert[0](self.username) if not self.password in passwords: passwords.insert[0](self.password) uname=iter(usernames) pword=iter(passwords) self.username=uname.next() self.password=pword.next() ssh_cli=SSHClient() ssh_cli.set_missing_host_key_policy(AutoAdd()) ssh_cli.connect(self.address,port=22,username=self.username,password=self.password) except paramiko.AuthenticationException: ssh_cli.close() try: self.password=pword.next() except StopIteration: try: self.username=uname.next() else: pword=iter(passwords) self.password=pword.next()
def __wait_ssh_working( self ): while True: client = SSHClient( ) try: client.set_missing_host_key_policy( self.IgnorePolicy( ) ) client.connect( hostname=self.ip_address, username=self.admin_account( ), timeout=a_short_time ) stdin, stdout, stderr = client.exec_command( 'echo hi' ) try: line = stdout.readline( ) if line == 'hi\n': return else: raise AssertionError( "Read unexpected line '%s'" % line ) finally: stdin.close( ) stdout.close( ) stderr.close( ) except AssertionError: raise except KeyboardInterrupt: raise except Exception as e: logging.info( e ) finally: client.close( ) time.sleep( a_short_time )
def main(): commands = {"deps": deps, "remote-version": remote_version, "push": push, "clean": clean, "versions": versions, "list": list_available, "stage": stage, "info": child_information, "history": child_history, "help": print_help} sys.argv.pop(0) #remove filename command = None if len(sys.argv) > 0: command = sys.argv.pop(0) if command is None or command not in commands: command = "help" try: if command=="help": client = None else: print "Setting up remote repo connection..." client = SSHClient() client.load_system_host_keys() client.connect(REPOSITORY_HOST, username=REPOSITORY_USER, key_filename=REPOSITORY_KEY) print "Connected to repo" try: commands[command](client, sys.argv) if command != "help": print "" print command + " [SUCCESSFUL]" except Exception, e: print e print command + " [FAILED]" finally: if client is not None: client.close()
def startConnection(self): """ connection to remote server can launch a thread checking every minute your mailbox... """ #if not self.directory:return #self.parent().close() self.close() client = SSHClient() client.set_missing_host_key_policy(AutoAddPolicy()) try: client.connect(str(self.host.text()), username=str(self.username.text()), password=str(self.password.text())) except SSHException: qApp.instance().showErrorMessage("Error", "The ssh session could not be established") except AuthenticationException: qApp.instance().showErrorMessage("Error","Authentication failed") except BadHostKeyException: qApp.instance().showErrorMessage("Error", "the server's host key could not be verified") sftpCp = self.cleaningRepository(client) if sftpCp: sftp = client.open_sftp() self.sftpCopying(sftp) sftp.close() else: self.retrieveDirTree(c, out) self.makeRScript(client) self.makeShellScript(client) if self.interactiveSession.isChecked(): import interactive print ('invoking a shell') chan = client.invoke_shell() chan.send('bash\n') interactive.interactive_shell(chan) chan.close() else: self.launchCommand(client) client.close()
POOL = os.environ['POOL_DIR'] TRASH = os.environ['TRASH_DIR'] DEPLOY = os.environ['DEPLOY_DIR'] SUPERVISOR_USER = os.environ['SUPERVISOR_USER'] SUPERVISOR_IP = os.environ['SUPERVISOR_IP'] ENVVAR_PATH = os.environ['ENVVAR_PATH'] ENVVAR_NAME = os.environ['ENVVAR_NAME'] POST_INSTALL_PATH = os.environ['POST_INSTALL_PATH'] POST_INSTALL_NAME = os.environ['POST_INSTALL_NAME'] APACHE_ENVVARS = '/etc/apache2/envvars' # Define ssh connection to supervisor ssh = SSHClient() ssh.load_system_host_keys() ssh.set_missing_host_key_policy(AutoAddPolicy()) ssh.connect(SUPERVISOR_IP,username=SUPERVISOR_USER) # SCPCLient takes a paramiko transport as its only argument scp = SCPClient(ssh.get_transport()) # Make log file logging.basicConfig(filename='debug.log', level=logging.DEBUG) # Helper functions def post_install(): """Execute post installation script""" log = '' if POST_INSTALL_NAME: scp.get(POST_INSTALL_PATH, ROOT) log += subprocess.check_output(os.path.join(ROOT, POST_INSTALL_NAME), executable='/bin/bash', shell=True)
def _execute(self, func, **kwargs): """ Do processing after connected to sftp server Args: func (fucntion): function which processing is written. kwargs (dict): arguments when function is executed Raises: ValueError: argumets are empty IOError: failed to get data """ if not func: raise ValueError("Function must not be empty.") for _ in range(self._retryTimes): ssh = None sftp = None try: ssh = SSHClient() ssh.set_missing_host_key_policy(AutoAddPolicy()) if self._password: ssh.connect( hostname=self._host, username=self._user, password=self._password, port=self._port, timeout=self._timeout, ) else: ssh.connect( hostname=self._host, username=self._user, key_filename=self._key, port=self._port, timeout=self._timeout, ) sftp = ssh.open_sftp() # call the argument function ret = func(sftp=sftp, **kwargs) return ret except Exception as e: self._logger.warning(e) self._logger.warning(kwargs) finally: if sftp is not None: sftp.close() if ssh is not None: ssh.close() self._logger.warning( "Unexpected error occurred. Retry will start in 10 sec.") sleep(10) raise IOError(errno.ENOENT, "SFTP failed.")
from pynput.mouse import Listener from scp import SCPClient from paramiko import SSHClient import logging import pyautogui ssh = SSHClient() ssh.load_system_host_keys() ssh.connect('ex.com', 22, "USERNAME", "PASSWORD") scpCl = SCPClient(ssh.get_transport()) count = 0 def on_click(x, y, button, pressed): if pressed: screensht = pyautogui.screenshot() scpCl.put(screensht, "test" + str(count) + ".png") #screensht.save("test"+str(count)+".png") global count count += 1 with Listener(on_click=on_click) as listener: listener.join() scpCl.close()
class ssh(ClientBase, Commands): def __init__(self, sessions, options): """ Initialize the SSH Bee, and the Base classes. :param sessions: A dict which is updated every time a new session is created. :param options: A dict containing all options """ ClientBase.__init__(self, sessions, options) Commands.__init__(self) self.client = SSHClient() self.client.set_missing_host_key_policy(AutoAddPolicy()) self.comm_chan = None def start(self): """ Launches a new SSH client session on the server taken from the `self.options` dict. :param my_ip: IP of this Client itself """ username = self.options['username'] password = self.options['password'] server_host = self.options['server'] server_port = self.options['port'] honeypot_id = self.options['honeypot_id'] session = self.create_session(server_host, server_port, honeypot_id) self.sessions[session.id] = session logger.debug( 'Sending %s bait session to {0}:{1}. (bait id: %s)'.format( 'ssh', server_host, server_port, session.id)) try: self.connect_login() session.did_connect = True # TODO: Handle failed login session.add_auth_attempt('plaintext', True, username=username, password=password) session.did_login = True except (SSHException, AuthenticationFailed) as err: logger.debug('Caught exception: {0} ({1})'.format( err, str(type(err)))) else: command_count = 0 command_limit = random.randint(6, 11) while command_count < command_limit: command_count += 1 self.sense() comm, param = self.decide() self.act(comm, param) gevent.sleep(random.uniform(0.4, 5.6)) self.logout() session.did_complete = True finally: session.alldone = True def send_command(self, cmd): """ Send a command to the remote SSH server. :param cmd: The command to send """ logger.debug('Sending {0} command.'.format(cmd)) self.comm_chan.sendall(cmd + '\n') def get_response(self): """ Get the response from the server. *This may not return the full response* :return: Response data """ while not self.comm_chan.recv_ready(): time.sleep(0.5) return self.comm_chan.recv(2048) def connect_login(self): """ Try to login to the Remote SSH Server. :return: Response text on successful login :raise: `AuthenticationFailed` on unsuccessful login """ self.client.connect(self.options['server'], self.options['port'], self.options['username'], self.options['password']) self.comm_chan = self.client.invoke_shell() time.sleep(1) # Let the server take some time to get ready. while not self.comm_chan.recv_ready(): time.sleep(0.5) login_response = self.comm_chan.recv(2048) if not login_response.endswith('$ '): raise AuthenticationFailed return login_response def logout(self): """ Logout from the remote server """ self.send_command('exit') self.get_response() self.comm_chan.close()
#!/usr/bin/python import scp import json from paramiko import SSHClient from scp import SCPClient from avi.sdk.avi_api import ApiSession host = "10.91.55.11" user = "******" password = "******" ssh = SSHClient() ssh.load_system_host_keys() ssh.connect(host, username=user, password=password) scp = SCPClient(ssh.get_transport()) scp.put('../controller.17.2.11.pkg', remote_path='/tmp') session = ssh.get_transport().open_session() session.set_combine_stderr(True) session.get_pty() session.exec_command( 'sudo cp /tmp/controller.17.2.11.pkg /var/lib/avi/upgrade_pkgs/controller.pkg' ) stdin = session.makefile('wb', -1) stdout = session.makefile('rb', -1) stdin.write(password + '\n') stdin.flush() print(stdout.read().decode("utf-8")) session.close()
class RemoteClient: '''Client for connecting to remote host via SSH & SCP''' def __init__(self, host, user, key='id_rsa', remote_path='~'): self.host = host self.user = user self.remote_path = remote_path self.key_file = str(Path.home()) + '/.ssh/' + key self.client = None self.scp = None self.conn = None def _get_ssh_key(self, pword=None): '''Fetch locally stored SSH key''' try: self.ssh_key = RSAKey.from_private_key_file(self.key_file) log.debug(f'Found RSA key at {self.key_file}') except PasswordRequiredException: pword = getpass('Enter SSH key password:'******'Found passworded RSA key at {self.key_file}') except SSHException as e: log.error(e) def _connect(self): '''Open connection to remote host''' if self.conn is None: try: self._get_ssh_key() self.client = SSHClient() self.client.load_system_host_keys() self.client.set_missing_host_key_policy(AutoAddPolicy()) self.client.connect( self.host, username=self.user, pkey=self.ssh_key, look_for_keys=True, timeout=5000 ) self.scp = SCPClient(self.client.get_transport()) except (AuthenticationException, SSHException) as e: log.error(f'Connection failed: {e}') raise e return self.client def set_loglevel(self, level="ERROR"): log.setLevel(level) return log.getLevelName() def disconnect(self): '''Close ssh connection''' if self.client: self.client.close() if self.scp: self.scp.close() def execute(self, command): ''' Execute command on remote host. :param command: Unix command as a single string. :type command: str ''' self.conn = self._connect() stdin, stdout, stderr = self.client.exec_command(command) stdout.channel.recv_exit_status() for error in stderr.readlines(): log.error(f'INPUT: {command} | ERR: {error}') return stdout.readlines() def upload(self, file, r=False): ''' Upload file to a remote directory. :param files: filename as string. :type files: str ''' self.conn = self._connect() try: self.scp.put(file, recursive=r, remote_path=self.remote_path) except SCPException as e: log.error(f'File transfer error: {e}') raise e log.info(f'Uploaded {self.remote_path}/{file} on {self.host}') def download(self, file, r=False): ''' Download file from remote directory. :param files: filename as string :type files: str ''' self.conn = self._connect() try: self.scp.get(file, recursive=r) except SCPException as e: log.error(f'File transfer error: {e}') raise e log.info(f'Pulled {self.remote_path}/{file} from {self.host}')
from userpass import Userpass import os, sys if len(sys.argv) < 3: print "usage: {} <path_to_authfile> <router>".format(sys.argv[0]) exit() #create ssh handler and read in keys ssh = SSHClient() keypath = os.path.expanduser('~/.ssh/known_hosts') ssh.load_host_keys(keypath) #load userpass file userpass = Userpass(sys.argv[1]) #connect host = sys.argv[2] ssh.connect( host, username=userpass.user, password=userpass.passwd ) stdin, stdout, stderr = ssh.exec_command( 'show version' ) for line in stdout: print '... ' + line.strip('\n') print "===" stdin, stdout, stderr = ssh.exec_command( 'show chassis hardware' ) for line in stdout: print '... ' + line.strip('\n') ssh.close()
# local_path = './video_org/delivery_place_delivery.avi' # remote_path = '/home/aucsie07/aucsie01_backup/webcam/video_org/delivery_place_delivery.avi' # local_path = './video_org/retailer_sell.avi' # remote_path = '/home/aucsie07/aucsie01_backup/webcam/video_org/retailer_sell.avi' local_path = './video_org/buyer_buy.avi' remote_path = '/home/aucsie07/aucsie01_backup/webcam/video_org/buyer_buy.avi' out = cv2.VideoWriter(local_path, fourcc, fps, frame_size_tuple) #mp4 cannot work # out = cv2.VideoWriter('./video_org/output_yieldy1.mp4', fourcc, 1, (640, 360)) ssh = SSHClient() ssh.load_system_host_keys() ssh.connect('192.168.1.133', 22, 'aucsie07', '1234') scp = SCPClient(ssh.get_transport()) stage_task = [ 'adjust_brightness', ] mqtt_service_channel = [ "sensor_login", "sensor_data", "sensor_logout", ] # Called when connect to Broker def on_VLCConnect(client, userdata, flags, rc):
from paramiko import SSHClient from scp import SCPClient import sys from string import ascii_lowercase # Define progress callback that prints the current percentage completed for the file def progress(filename, size, sent): sys.stdout.write("%s\'s progress: %.2f%% \r" % (filename, float(sent)/float(size)*100) ) for i in ['a', 'b', 'c']: for j in ascii_lowercase: print(i, j) if not (i=='a'): #and (j in ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])): ssh = SSHClient() ssh.load_system_host_keys() ssh.connect(hostname='datascience5.cs.man.ac.uk', username='******', password='******') scp = SCPClient(ssh.get_transport(), progress=progress) print('project_dataset.zip.part'+i+j) try: scp.put('/home/deadman/Uni/project/dataset/project_dataset.zip.part'+i+j, '/local/home/n82471zk/project_dataset/project_dataset.zip.part'+i+j) except: print('fail') scp.close() ssh.close() continue scp.close()
""" This file grabs a log from the roboRIO and copies it a local directory. @author Arvind """ # Imports from paramiko import SSHClient from scp import SCPClient # Declartion ssh = SSHClient() # Initialization ssh.load_system_host_keys() ssh.connect("172.22.11.2", "lvuser") # Get log with SCPClient(ssh.get_transport()) as scp: scp.get("~/log/test-log.log", "C:/Users/BUZZ-175/Development/RoboRIOLogs/test-log.log")
#file_in = "make_prediction.py" file_in = "predict.csv" if (len(sys.argv) == 1): file_in = "../dataset/predict.csv" else: file_in = sys.argv[1] file_out = os.path.splitext(file_in)[0] + "Complet" + os.path.splitext( file_in)[1] # on fait la connection SSH avec la machine AWS ssh = SSHClient() ssh.set_missing_host_key_policy(AutoAddPolicy()) ssh.connect("ec2-18-232-97-24.compute-1.amazonaws.com", username="******", key_filename="bigDataProject.pem") #on ouvre la connection SFTP ftp = ssh.open_sftp() # on envoie le fichier ftp.put(file_in, "files/" + os.path.basename(file_in)) # on execute le script ssh.exec_command("python make_prediction.py files/" + os.path.basename(file_in) + " files/" + os.path.basename(file_out)) # on recupere le nouveau fichier time.sleep(0.5)
class SSH: def __init__(self,hostname, username): self._ssh = SSHClient() self._ssh.load_system_host_keys() self._ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) self._ssh.connect(hostname=hostname, username=username, timeout=10) def __del__(self): """ Called when the instance is about to be destroyed. The connection has to be closed here. """ if self._ssh: self._ssh.close() def cmd_disk_usage(self): cmd_str = 'df -hT' stdin,stdout,stderr = self._ssh.exec_command(cmd_str) if stderr.channel.recv_exit_status() != 0: print(stderr.read()) else: output_cmd = stdout.read() return df.parse(output_cmd.decode("utf-8")) def cmd_users_connected(self): cmd_str = 'who' stdin,stdout,stderr = self._ssh.exec_command(cmd_str) if stderr.channel.recv_exit_status() != 0: print(stderr.read()) else: output_cmd = stdout.read() return who.parse(output_cmd.decode("utf-8")) def cmd_proccess_running(self): cmd_str = 'ps -aux' stdin,stdout,stderr = self._ssh.exec_command(cmd_str) if stderr.channel.recv_exit_status() != 0: print(stderr.read()) else: output_cmd = stdout.read() return ps.parse(output_cmd.decode("utf-8")) def cmd_cpu_usage(self): cmd_str = "top -b -n 2 -d1 | grep \"Cpu(s)\" | awk '{print $2}' | awk -F. '{print $1}'" stdin,stdout,stderr = self._ssh.exec_command(cmd_str) if stderr.channel.recv_exit_status() != 0: print(stderr.read()) else: output_cmd = stdout.readlines() output_for_format = [] for index, out in enumerate(output_cmd, start=0): cpu_name = 'cpu_' + str(index) output_for_format.append({'cpu': cpu_name ,'value_percent': out.replace('\n','')}) return output_for_format def mem_usage(self): cmd_str = "free | grep Mem |awk '{print $3/$2 * 100.0}'" stdin,stdout,stderr = self._ssh.exec_command(cmd_str) if stderr.channel.recv_exit_status() != 0: print(stderr.read()) else: output_cmd = stdout.read().decode("utf-8") return {'mem_usage_percent': output_cmd.replace('\n','')} def exec_cmd(self,cmd): stdin,stdout,stderr = self._ssh.exec_command(cmd) if stderr.channel.recv_exit_status() != 0: print(stderr.read()) else: return stdout.read()
warnings.filterwarnings("ignore") jsonpost = {'token_auth': creds, 'file_version': '2'} result = requests.post(url, data=json.dumps(jsonpost)) web_data = json.loads(result.text) web_data_final = result.text split_web_data = web_data_final.splitlines() alertBaseFile = 'AlertBase-CVP.json' logFile = 'bugalertUpdate.log' ssh = SSHClient() ssh.load_system_host_keys() ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) ssh.connect(cvp, username="******", password=rootpw) ssh_shell = ssh.invoke_shell() ssh_shell.send("rpm -qi cvp-base\n") time.sleep(2) output = ssh_shell.recv(8000) output = output.decode("utf-8") output = remove_last_line_from_string(output) output = remove_last_line_from_string(output) output = remove_last_line_from_string(output) output = output[(output.index('Name')):] Dict = dict( (x.strip(), y.strip()) for x, y in (element.split(': ') for element in output.split('\r\n'))) cvp_main_version = Dict["Version"][0:4] log = open(logFile, 'a+')
lines = f.readlines() server_ips = [l.strip().split(":") for l in lines] sorted_ips = natsorted(server_ips, key=operator.itemgetter(0)) print(sorted_ips) # For first server, send over dummy json, (can do it in here) # Retrieve {server_name}suffix from the server, via SCP. Store string data, # send it over to the next server via SCP. And so on ssh = SSHClient() ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) ssh.load_system_host_keys() counter = 0 prevKey = None for server in sorted_ips: name = server[0] ip = server[1] ssh.connect(ip, username="******") print("Connected to", name, "with ip", server) scp = SCPClient(ssh.get_transport(), progress=progress) if name == "cepa0": fl = io.BytesIO() fl.write(b'test') fl.seek(0) print("Put dummy key") scp.putfo(fl, repo_dir + dummy) else: # Push the last server key prev_server_key = prefix + str(counter - 1) + suffix print("Put " + prev_server_key) scp.put(prev_server_key, input_key) # Catch exception ssh.exec_command("mv " + input_key + " " + repo_dir)
class SecureShell(AbstractRemoteShell): def __init__(self, hostname, username, password=None, port=22, check_xc=False, check_err=False, wait=True, log_level=CRITICAL, **kwargs): super(SecureShell, self).__init__(hostname, check_xc=check_xc, check_err=check_err, wait=wait, log_level=log_level, **kwargs) self._hostname = hostname self._port = port self._username = username self._password = password self.connect() def do_connect(self): self._client = SSHClient() self._client.load_system_host_keys() self._client.set_missing_host_key_policy(AutoAddPolicy()) self._client.connect(hostname=self._hostname, port=self._port, username=self._username, password=self._password) self._scp_client = SCPClient(self._client.get_transport()) def do_disconnect(self): self._client.close() def execute_command(self, command, env={}, wait=True, check_err=False, cwd=None): for var, val in env.items(): command = "%s=%s; " % (var, val) + command chan = self._client.get_transport().open_session() chan.exec_command((("cd \"%s\"; " % cwd) if cwd else "") + command) queue = Queue() StandardStreamReader(chan.makefile("r"), 1, queue) StandardStreamReader(chan.makefile_stderr("r"), 2, queue) def post_process_exit_code(): queue.put((0, chan.recv_exit_status())) queue.put((0, None)) Thread(target=post_process_exit_code).start() return ShellResult(self, command, queue, wait, check_err) def do_pull(self, local_path, remote_path): self._scp_client.get(remote_path, local_path) def do_push(self, local_path, remote_path): self._scp_client.put(local_path, remote_path) def do_reboot(self): self("reboot > /dev/null 2>&1 &") sleep(.3)
class App: def __init__(self): self.root = tk.Tk() self.root.geometry("300x100") self.root.title('bridge utility') self.startCarBtn = tk.Button(self.root, text="start with car config", command=self.startCar) self.startCarBtn.pack() self.startToolBtn = tk.Button(self.root, text="start with tool config", command=self.startTool) self.checkToolBtn.pack() self.checkToolBtn = tk.Button(self.root, text="check tool status", command=self.checkTool) self.startToolBtn.pack() self.stopBtn = tk.Button(self.root, text="start", command=self.stop) self.stopBtn['state'] = 'disabled' self.stopBtn.pack() self.ssh = SSHClient() self.ssh.set_missing_host_key_policy(AutoAddPolicy) def startCar(self): self.ssh.connect(hostname=ssh_ip, username=ssh_uname, password=ssh_pass) self.ssh.exec_command( '/usr/bin/python3.8 dev/node-can-bridge/enable_can.py') self.ssh.exec_command( f'/home/ubuntu/.nvm/versions/node/v10.20.1/bin/node dev/node-can-bridge/client.js car', get_pty=True) self.stopBtn['state'] = 'enabled' self.startCarBtn['state'] = 'disabled' self.startToolBtn['state'] = 'disabled' def startTool(self): self.ssh.connect(hostname=ssh_ip, username=ssh_uname, password=ssh_pass) self.ssh.exec_command( '/usr/bin/python3.8 dev/node-can-bridge/enable_can.py') self.ssh.exec_command( f'/home/ubuntu/.nvm/versions/node/v10.20.1/bin/node dev/node-can-bridge/client.js tool', get_pty=True) self.stopBtn['state'] = 'enabled' self.startCarBtn['state'] = 'disabled' self.startToolBtn['state'] = 'disabled' def checkTool(self): self.ssh.connect(hostname=ssh_ip, username=ssh_uname, password=ssh_pass) self.ssh.exec_command( '/usr/bin/python3.8 dev/node-can-bridge/check.py') def stop(self): self.ssh.close() self.ssh = SSHClient() self.stopBtn['state'] = 'disabled' self.startCarBtn['state'] = 'enabled' self.startToolBtn['state'] = 'enabled'
def handle(self, *args, **options): """ Gets the appropriate settings from Django and deploys the repository to the target servers for the instance selected. """ # Grab the quiet settings and unique stamp quiet = options["quiet"] stamp = options["stamp"] no_confirm = options["no_confirm"] # Check to ensure the require setting is in Django's settings. if hasattr(settings, "DEPLOYER_INSTANCES"): instances = settings.DEPLOYER_INSTANCES else: raise CommandError( "You have not configured DEPLOYER_INSTANCES in your Django settings." ) # Grab the instance settings if they're properly set if options["instance"] in instances: instance = instances[options["instance"]] else: raise CommandError( "The instance name you provided ('{instance}') is not configured in " "your settings DEPLOYER_INSTANCES. Valid instance names are: " "{instances}".format( instance=options["instance"], instances=", ".join(list(instances.keys())), )) print( "We are about to deploy the instance '{instance}' to the following " "servers: {servers}.".format(instance=options["instance"], servers=", ".join( instance["servers"]))) if no_confirm: verify = "yes" else: verify = input( "Are you sure you want to do this (enter 'yes' to proceed)? ") if verify.lower() != "yes": print("You did not type 'yes' - aborting.") return # Variables for directory locations and symlinks deployer_clone_dir_format = getattr( settings, "DEPLOYER_CLONE_DIR_FORMAT", "{name}-{instance}", ) deployer_clone_dir = deployer_clone_dir_format.format( instance=options["instance"], name=instance["name"], branch=instance["branch"], server_user=instance["server_user"], ) git_dir_stamp = "{deployer_clone_dir}-{stamp}".format( deployer_clone_dir=deployer_clone_dir, stamp=stamp) install_code_path = os.path.join( instance["code_path"], deployer_clone_dir, ) install_code_path_stamp = os.path.join( instance["code_path"], git_dir_stamp, ) # On our first iteration, we clone the repository, build the virtual # environment, and collect static files; this may take some time. for index, server in enumerate(instance["servers"]): # Open an SSH connection to the server ssh = SSHClient() ssh.set_missing_host_key_policy(AutoAddPolicy()) ssh.connect(server, username=instance["server_user"]) print("Cloning code and preparing venv on node: {}...".format( server)) # Make sure the code_path directory exists stdin, stdout, stderr = ssh.exec_command(""" mkdir -p {directory} """.format(directory=instance["code_path"])) self.command_output(stdout, stderr, quiet) stdin, stdout, stderr = ssh.exec_command(""" cd {code_path} git clone --recursive --verbose -b {branch} {repository} {git_dir_stamp} """.format( code_path=instance["code_path"], branch=instance["branch"], repository=instance["repository"], git_dir_stamp=git_dir_stamp, )) self.command_output(stdout, stderr, quiet) print("Preparing the installation...") if instance.get("upgrade_pip", True): pip_upgrade_text = "pip install -U pip" else: pip_upgrade_text = "" print("pip will NOT be upgraded.") if instance.get("collectstatic", True): collectstatic_text = ( "python manage.py collectstatic --noinput --settings={s}". format(s=settings, )) else: collectstatic_text = "" print("Static files will NOT be collected.") stdin, stdout, stderr = ssh.exec_command(""" cd {install_code_path_stamp} {venv_python_path} -m venv venv . venv/bin/activate {pip_upgrade_text} pip install -U wheel pip install --ignore-installed -r {requirements} {collectstatic_text} """.format( install_code_path_stamp=install_code_path_stamp, venv_python_path=instance["venv_python_path"], pip_upgrade_text=pip_upgrade_text, requirements=instance["requirements"], collectstatic_text=collectstatic_text, )) self.command_output(stdout, stderr, quiet) if "selinux" in instance and instance["selinux"]: print( "Setting security context for RedHat / CentOS SELinux...") stdin, stdout, stderr = ssh.exec_command(""" chcon -Rv --type=httpd_sys_content_t {install_code_path_stamp} > /dev/null find {install_code_path_stamp}/venv/ \( -name "*.so" -o -name "*.so.*" \) -exec chcon -Rv --type=httpd_sys_script_exec_t {{}} \; > /dev/null """.format( install_code_path_stamp=install_code_path_stamp)) self.command_output(stdout, stderr, quiet) # On our second iteration, we update symlinks, keep only recent deployments, # run any additional commands, and run migrations. This should be fast. for index, server in enumerate(instance["servers"]): # Open an SSH connection to the server ssh = SSHClient() ssh.set_missing_host_key_policy(AutoAddPolicy()) ssh.connect(server, username=instance["server_user"]) print("") print( "Updating symlinks and running any additional defined commands on " "node: {}...".format(server)) stdin, stdout, stderr = ssh.exec_command(""" ln -sfn {install_code_path_stamp} {install_code_path} """.format( install_code_path_stamp=install_code_path_stamp, install_code_path=install_code_path, )) self.command_output(stdout, stderr, quiet) if int(instance.get("save_deploys", 0)) > 0: print( "Keeping the {} most recent deployments, and deleting the rest on " "node: {}".format(instance["save_deploys"], server)) stdin, stdout, stderr = ssh.exec_command(""" ls -1trd {install_code_path}* | head -n -{save_deploys} | xargs -d '\\n' rm -rf -- """.format( install_code_path=install_code_path, save_deploys=instance["save_deploys"] + 1, )) self.command_output(stdout, stderr, quiet) if "additional_commands" in instance: print("Performing defined additional commands...") for additional_command in instance["additional_commands"]: print("Running '{}'...".format(additional_command)) stdin, stdout, stderr = ssh.exec_command( additional_command) self.command_output(stdout, stderr, quiet) # Only run migrations when we're on the last server. if index + 1 == len(instance["servers"]) and instance.get( "migrate", True): print("Finally, running migrations...") stdin, stdout, stderr = ssh.exec_command(""" cd {install_code_path_stamp} . venv/bin/activate python manage.py migrate --noinput --settings={settings} """.format( install_code_path_stamp=install_code_path_stamp, settings=instance["settings"], )) self.command_output(stdout, stderr, quiet) else: print("Not running migrations; migrate is set to False.") print("All done!")
class SshClient(object): """ @Desc : SSH Library for Marvin. Facilitates SSH,SCP services to marvin users @Input: host: Host to connect port: port on host to connect user: Username to be used for connecting passwd: Password for connection retries and delay applies for establishing connection timeout : Applies while executing command """ def __init__(self, host, port, user, password, retries=60, delay=10, key_pair_files=None, timeout=10.0): self.host = None self.port = 22 self.user = user self.passwd = password self.keyPairFiles = key_pair_files self.ssh = SSHClient() self.ssh.set_missing_host_key_policy(AutoAddPolicy()) self.retryCnt = 0 self.delay = 0 self.timeout = 3.0 self.logger = MarvinLog('ssh').get_logger() # Check invalid host value and raise exception # At least host is required for connection if host is not None and host != '': self.host = host if retries is not None and retries > 0: self.retryCnt = retries if delay is not None and delay > 0: self.delay = delay if timeout is not None and timeout > 0: self.timeout = timeout if port is not None and port >= 0: self.port = port if self.create_connection() == FAILED: raise internalError("Connection Failed") def execute(self, command): stdin, stdout, stderr = self.ssh.exec_command(command) output = stdout.readlines() errors = stderr.readlines() results = [] if output is not None and len(output) == 0: if errors is not None and len(errors) > 0: for error in errors: results.append(error.rstrip()) else: for strOut in output: results.append(strOut.rstrip()) self.logger.debug("Executing command via host %s: %s Output: %s" % (str(self.host), command, results)) return results def create_connection(self): """ @Name: createConnection @Desc: Creates an ssh connection for retries mentioned,along with sleep mentioned @Output: SUCCESS on successful connection FAILED If connection through ssh failed """ ret = FAILED while self.retryCnt >= 0: try: self.logger.debug("Trying SSH Connection to host %s on port %s as user %s. RetryCount: %s" % (self.host, str(self.port), self.user, str(self.retryCnt))) if self.keyPairFiles is None: self.ssh.connect(hostname=self.host, port=self.port, username=self.user, password=self.passwd, timeout=self.timeout) else: self.ssh.connect(hostname=self.host, port=self.port, username=self.user, password=self.passwd, key_filename=self.keyPairFiles, timeout=self.timeout, look_for_keys=False ) self.logger.debug("Connection to host %s on port %s is SUCCESSFUL" % (str(self.host), str(self.port))) ret = SUCCESS break except BadHostKeyException as e: self.logger.debug("Failed to create connection: %s" % e) except AuthenticationException as e: self.logger.debug("Failed to create connection: %s" % e) except SSHException as e: self.logger.debug("Failed to create connection: %s" % e) except socket.error as e: self.logger.debug("Failed to create connection: %s" % e) except Exception as e: self.logger.debug("Failed to create connection: %s" % e) finally: if self.retryCnt == 0 or ret == SUCCESS: break self.retryCnt -= 1 time.sleep(self.delay) return ret def run_command(self, command): """ @Name: runCommand @Desc: Runs a command over ssh and returns the result along with status code @Input: command to execute @Output: 1: status of command executed. SUCCESS : If command execution is successful FAILED : If command execution has failed 2: stdin,stdout,stderr values of command output """ ret = {"status": FAILED, "stdin": None, "stdout": None, "stderr": INVALID_INPUT} if command is None or command == '': return ret try: stdin, stdout, stderr = self.ssh.exec_command(command, timeout=self.timeout) if stdout is not None: status_check = stdout.channel.recv_exit_status() if status_check == 0: ret["status"] = SUCCESS ret["stdout"] = stdout.readlines() if stderr is not None: ret["stderr"] = stderr.readlines() except Exception as e: self.logger.debug("Failed to run command: %s" % e) finally: self.logger.debug("Connection to host %s on port %s is SUCCESSFUL" % (str(self.host), command)) return ret def scp(self, src_file, dest_path): transport = Transport((self.host, int(self.port))) transport.connect(username=self.user, password=self.passwd) sftp = SFTPClient.from_transport(transport) try: sftp.put(src_file, dest_path) except IOError as e: raise e def __del__(self): self.close() def close(self): if self.ssh is not None: self.ssh.close() self.ssh = None
from paramiko import SSHClient from scp import SCPClient import paramiko import time host = '192.168.1.2' user = '******' secret = '12345678' port = 22 localpath = 'C:/scripts/Ubnt/car/system.cfg' #localpath1 = 'C:/scripts/Ubnt/default.cfg' remotepath = '/tmp/' ssh = SSHClient() ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) try: ssh.connect(hostname=host, username=user, password=secret, port=port) with SCPClient(ssh.get_transport()) as scp: scp.put(localpath, remote_path=remotepath) # scp.get(remote_path='/etc/default.cfg', local_path=localpath1) stdin, stdout, stderr = ssh.exec_command('cfgmtd -w -f /tmp/system.cfg') time.sleep(5) ssh.exec_command('reboot') data = stdout.read() + stderr.read() except paramiko.SSHException: print("Connection Failed") quit() print(data)
import random import sys import os import select import paramiko from paramiko import SSHClient import subprocess import time client_master = SSHClient() client_master.set_missing_host_key_policy(paramiko.AutoAddPolicy()) client_master.load_system_host_keys() client_master.connect("10.10.1.89", username="******", password="******") client_slave1 = SSHClient() client_slave1.set_missing_host_key_policy(paramiko.AutoAddPolicy()) client_slave1.load_system_host_keys() client_slave1.connect("10.10.1.90", username="******", password="******") client_slave2 = SSHClient() client_slave2.set_missing_host_key_policy(paramiko.AutoAddPolicy()) client_slave2.load_system_host_keys() client_slave2.connect("10.10.1.51", username="******", password="******") def write_stop(file, diff, misconfig_code, misconfig_node, client, write_dir): file_lines = [] ftp = client.open_sftp() remote_file = ftp.open("/home/ubuntu/Neha_Shreya/" + file) for line in remote_file: file_lines.append(line) file_lines.append("TIME:" + str(diff) + ",CODE:" + str(misconfig_code) + "\n")
from paramiko import SSHClient client = SSHClient() client.load_system_host_keys() client.connect("hostname", username="******") stdin, stdout, stderr = client.exec_command('program') print "stderr: ", stderr.readlines() print "pwd: ", stdout.readlines()
port = int((config.get("ssh", "port"))) localPath = (config.get("targets", "localdir")) remotePath = (config.get("targets", "remotedir")) keyCheck = config.has_option("ssh", "keyfile") passCheck = config.has_option("ssh", "password") client = SSHClient() client.load_system_host_keys() if keyCheck == True and passCheck == False: print("Connecting to " + host) print("Authenticating with key...") print("\n") key = (config.get("ssh", "keyfile")) client.connect(host, username=user, key_filename=key, port=port) elif passCheck == True and keyCheck == False: print("Connecting to " + host) print("Authenticating with password...") print("\n") passwd = (config.get("ssh", "password")) client.connect(host, username=user, password=passwd, port=port) elif passCheck == True and keyCheck == True: sys.exit( "Cannot authenticate. Key and password both provided. Check RetroSort.conf and try again" ) else: sys.exit("No authentication provided. Check RetroSort.conf and try again")
def verify_connection_raw(self, node_sndr, node_rcvl, counter): # Data required to verify connection # On sender side: Interface to Send packet, Destination IP, Source IP, Destination MAC # On receiver side: Interface to listen for tcpdump # print device_w_con_problem # print node_sndr + ' ' + node_rcvl try: try: if [node_sndr, node_rcvl] in device_w_con_problem or [ node_rcvl, node_sndr ] in device_w_con_problem: sys.exit() cl_s = SSHClient() cl_s.set_missing_host_key_policy(AutoAddPolicy()) cl_s.connect(dev_connect[node_sndr][0], port=int(dev_connect[node_sndr][1]), username='******', password='******') cl_r = SSHClient() cl_r.set_missing_host_key_policy(AutoAddPolicy()) cl_r.connect(dev_connect[node_rcvl][0], port=int(dev_connect[node_rcvl][1]), username='******', password='******') # print 'dev sender: {0}, dev receiver {1}'.format(dev_connect[node_sndr][1], dev_connect[node_rcvl][1]) except: pass for el in hosts_w_macs[node_sndr].keys(): if el in hosts_w_macs[node_rcvl].keys(): link = el exec_command_r = 'sudo tcpdump -i {0} -c 10 '.format( hosts_w_macs[node_rcvl][link][0]) cl_r.exec_command('sudo ifconfig {0} up'.format( hosts_w_macs[node_rcvl][link][0])) # print 'node is {0}, receive command is {1}'.format(hosts_w_macs[node_rcvl], exec_command_r) stdin_r, stdout_r, stderr_r = cl_r.exec_command(exec_command_r) stdin_s, stdout_s, stderr_s = \ cl_s.exec_command('sudo ip addr flush dev {0}'.format(hosts_w_macs[node_sndr][link][0])) cl_s.exec_command('sudo ifconfig {0} up'.format( hosts_w_macs[node_sndr][link][0])) cl_s.exec_command('sudo chmod 755 scripts/send-raw') exec_command_s = 'sudo ./scripts/send-raw -i {0} -s {1} -d {2} -m {3}' \ .format(hosts_w_macs[node_sndr][link][0], '255.255.255.254', '255.255.255.255', hosts_w_macs[node_rcvl][link][1]) # print 'node is {0}, send command is \n {1}'.format(hosts_w_macs[node_sndr], exec_command_s) for k in range(0, 30): cl_s.exec_command(exec_command_s) k += 1 # Debug section # print 'Link between devices is ' + link # print 'sudo ifconfig {0} up'.format(hosts_w_macs[node_sndr][link][0]) # print 'sudo ip addr flush dev {0}'.format(hosts_w_macs[node_sndr][link][0]) # print exec_command_s # print exec_command_r if len([ m.start() for m in re.finditer( 'IP 255.255.255.254 > 255.255.255.255: ICMP echo request', stdout_r.read()) ]) >= 5: print ' Link {0} ---> {1} '.format( node_sndr, node_rcvl) + u'\u2713'.encode('utf8') # print 'Link {0} ---> {1} established'.format(node_sndr, node_rcvl) else: print 'Sorry, there is some problem' device_w_con_problem.append([node_sndr, node_rcvl]) cl_s.close() cl_r.close() except: # print '{0} try'.format(counter) counter += 1 if counter < 5: self.verify_connection_raw(node_sndr, node_rcvl, counter) else: if [node_rcvl, node_sndr] not in device_w_con_problem: device_w_con_problem.append([node_sndr, node_rcvl]) print "There was 3 tries to establish link. Moving on" pass
from jobengine import clusters from paramiko import SSHClient from scp import SCPClient, SCPException #cluster, shell = clusters.Clusters().get_cluster("arcus-gpu") cluster = clusters.Clusters().clusters["arcus-gpu"]() print cluster if False: ssh = SSHClient() ssh.load_system_host_keys() print cluster.hostname ssh.connect(cluster.hostname, username=cluster.username) if True: shell = cluster.connect() scp = SCPClient(shell.get_transport()) scp.put("dummy", "/tmp", recursive=True)
from paramiko import SSHClient from getpass import getpass message = input("Enter message: ") user_name = input("Username: "******"ssh.ocf.berkeley.edu", username=user_name, password=passwd) sftp = ssh.open_sftp() sftp.put("sam_was_here.txt", "sam_was_here.txt") sftp.close() ssh.exec_command("echo {0} > message.txt".format(message)) ssh.close()
def verify_connection_udp(self): fine_links = [] # print 'dev con' # print dev_connect # Netmask: 255.255.255.252 = 30 # Network: 10.0.0.220/30 # Broadcast: 10.0.0.223 # HostMin: 10.0.0.221 # HostMax: 10.0.0.222 # Hosts/Net: 2 # print self.graph_nx.adj for k, v in self.adj_with_names.iteritems(): """ Every node can be connected to few nodes. So we need to verify nested loop over here. v - ['server1', 'server2'] """ # print k, v for l in v: receiver_id = find(topo_yaml['nodes'], 'name', l) receiver = topo_yaml['nodes'][receiver_id] sender_id = find(topo_yaml['nodes'], 'name', k) sender = topo_yaml['nodes'][sender_id] link_num = find_connected_link(receiver, sender) # print receiver['interfaces'] # print link_num receiver_dev = find(receiver['interfaces'], 'link-name', link_num) # print receiver_dev receiver_interface = topo_yaml['nodes'][receiver_id][ 'interfaces'][0]['interface'] # print dev_connect[l] # print 'connected_link {0}'.format(link_num) udp_receiv = SSHClient() udp_receiv.set_missing_host_key_policy(AutoAddPolicy()) udp_receiv.connect(dev_connect[l][0], port=int(dev_connect[l][1]), username='******', password='******') input_command = 'ifconfig {0}'.format(receiver_interface). \ replace('GigabitEthernet', 'Gi').replace('/', '_') s_in, s_out, s_err = udp_receiv.exec_command(input_command) # print 'input ' + input_command # print s_out.read() receiver_ip = re.search(r'inet addr:(\S+)', s_out.read()).group(1) # print "\n*** DEBug Message\n" \ # "dev sender {0} connection {1} \n" \ # "dev receiver {2} connection {3} \n" \ # "connected link {4}\n" \ # "Receiver interface - {5} IP - {6}\n" \ # "***".format(sender['name'], dev_connect[k], # receiver['name'], dev_connect[l], # link_num, receiver_interface, receiver_ip) r_in, r_out, r_err = udp_receiv.exec_command( 'python ~/scripts/sock_receiver.py ' + receiver_ip) udp_sender = SSHClient() udp_sender.set_missing_host_key_policy(AutoAddPolicy()) udp_sender.connect(dev_connect[k][0], port=int(dev_connect[k][1]), username='******', password='******') s_in, s_out, s_err = udp_sender.exec_command( 'python ~/scripts/sock_sender.py ' + receiver_ip) if 'Checking connectivity' in r_out.read(): fine_links.append(sender['name'] + ' ' + receiver['name']) # print s_out.read() print 'UDP Connection verified for following links:' for f_l in fine_links: print f_l + u' \u2713'.encode('utf8')
class S_Host(object): def __init__(self, host="127.0.0.1", password="", user="******", port=22, key_file=""): self.host = host self.user = user self.password = password self.port = port self.key_file = key_file def do_connect(self): self.ssh = SSHClient() self.ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) if self.key_file: self.ssh.connect(username=self.user, password=self.password, port=self.port, hostname=self.host, key_filename=self.key_file) else: self.ssh.connect(username=self.user, password=self.password, port=self.port, hostname=self.host) self.scp = SCPClient(self.ssh.get_transport()) return True def do_disconnect(self): try: self.scp.close() self.ssh.close() finally: return True def do_put(self, source_file, target_file, single_call=True): try: if single_call: self.do_connect() if os.path.exists(source_file): self.scp.put(source_file, target_file) else: raise ValueError("Source file %s is not exists." % source_file, "") except Exception as e: print("Transport file from %s to %s failed." % (source_file, target_file)) print("Error reasonn: %s" % e) return False finally: if single_call: self.do_disconnect() return True def do_get(self, source_file, target_file, single_call=True): try: if single_call: self.do_connect() if not os.path.isfile(target_file): self.scp.get(source_file, target_file) else: raise ValueError("Target file %s is exists." % target_file) except Exception as e: print("Transport file from %s to %s failed." % (source_file, target_file)) print("Error reasonn: %s" % e) return False finally: if single_call: self.do_disconnect() return True def do_put_files(self, source_file_list, target_dir): if not hasattr(source_file_list, "__getitem__"): raise ValueError("Input value %s cannot iterable." % source_file_list) try: self.do_connect() for file in source_file_list: file_name = os.path.basename(file) target_file_path = os.path.join(target_dir, file_name) try: self.do_put(file, target_file_path, single_call=False) except: continue finally: self.do_disconnect() return True def do_get_files(self, source_file_list, target_dir): pass if not hasattr(source_file_list, "__getitem__"): raise ValueError("Input value %s cannot iterable." % source_file_list) try: self.do_connect() for file in source_file_list: file_name = os.path.basename(file) target_file_path = os.path.join(target_dir, file_name) try: self.do_get(file, target_file_path, single_call=False) except: continue finally: self.do_disconnect() return True
class RemoteClient: """Client to interact with a remote host via SSH & SCP.""" def __init__(self, host, user, ssh_key_filepath, remote_path): self.host = host self.user = user self.ssh_key_filepath = ssh_key_filepath self.remote_path = remote_path self.client = None self.scp = None self.conn = None self.__upload_ssh_key() def __get_ssh_key(self): """ Fetch locally stored SSH key. """ try: self.ssh_key = RSAKey.from_private_key_file(self.ssh_key_filepath) logger.info(f'Found SSH key at self {self.ssh_key_filepath}') except SSHException as error: logger.error(error) return self.ssh_key def __upload_ssh_key(self): try: system( f'ssh-copy-id -i {self.ssh_key_filepath} {self.user}@{self.host}>/dev/null 2>&1' ) system( f'ssh-copy-id -i {self.ssh_key_filepath}.pub {self.user}@{self.host}>/dev/null 2>&1' ) logger.info(f'{self.ssh_key_filepath} uploaded to {self.host}') except FileNotFoundError as error: logger.error(error) def __connect(self): """ Open connection to remote host. """ try: self.client = SSHClient() self.client.load_system_host_keys() self.client.set_missing_host_key_policy(AutoAddPolicy()) self.client.connect(self.host, username=self.user, key_filename=self.ssh_key_filepath, look_for_keys=True, timeout=5000) self.scp = SCPClient(self.client.get_transport()) except AuthenticationException as error: logger.info( 'Authentication failed: did you remember to create an SSH key?' ) logger.error(error) raise error finally: return self.client def disconnect(self): """ Close ssh connection. """ self.client.close() self.scp.close() def bulk_upload(self, files): """ Upload multiple files to a remote directory. :param files: List of strings representing file paths to local files. """ if self.client is None: self.client = self.__connect() uploads = [self.__upload_single_file(file) for file in files] logger.info( f'Finished uploading {len(uploads)} files to {self.remote_path} on {self.host}' ) def __upload_single_file(self, file): """Upload a single file to a remote directory.""" try: self.scp.put(file, recursive=True, remote_path=self.remote_path) except SCPException as error: logger.error(error) raise error finally: logger.info(f'Uploaded {file} to {self.remote_path}') def download_file(self, file): """Download file from remote host.""" if self.conn is None: self.conn = self.connect() self.scp.get(file) def execute_commands(self, commands): """ Execute multiple commands in succession. :param commands: List of unix commands as strings. """ if self.client is None: self.client = self.__connect() for cmd in commands: stdin, stdout, stderr = self.client.exec_command(cmd) stdout.channel.recv_exit_status() response = stdout.readlines() for line in response: logger.info(f'INPUT: {cmd} | OUTPUT: {line}')
class StashSSH(object): def __init__(self): self.ssh_running = False self.screen = pyte.screens.DiffScreen(100, 60) self.screen.dirty.clear() #self.screen.set_mode(pyte.modes.DECTCEM) self.stream = pyte.Stream() self.stream.attach(self.screen) self.pause_output = False def connect(self, host='', passwd=None, port=22): print 'Connecting...' self.user, self.host = self.parse_host(host) self.stash = globals()['_stash'] self.passwd = passwd self.port = port self.ssh = SSHClient() self.ssh.set_missing_host_key_policy(AutoAddPolicy()) try: print 'Looking for SSH keys...' self.ssh.connect(self.host, username=self.user, password=self.passwd, port=self.port, key_filename=self.find_ssh_keys()) except: try: print 'No SSH key found. Trying password...' self.ssh.connect(self.host, username=self.user, password=self.passwd, port=self.port) except: print '*Auth Error*' return False self.ssh_running = True return True def find_ssh_keys(self): files = [] APP_DIR = os.environ['STASH_ROOT'] for file in os.listdir(APP_DIR + '/.ssh'): if '.' not in file: files.append(APP_DIR + '/.ssh/' + file) return files def parse_host(self, arg): user, host = arg.split('@') #host, path = temp.split(':') return user, host def stdout_thread(self): while self.ssh_running: if self.chan.recv_ready() and not self.pause_output: #output += self.chan.recv(1024) rcv = self.chan.recv(1024) self.stream.feed(u'%s' % rcv) if self.screen.dirty: self.screen.dirty.clear() self.update_screen() def update_screen(self): count = len(self.screen.display) for item in reversed(self.screen.display): if str(item) != ' ' * 100: break count -= 1 text = '\n'.join(self.screen.display[:count]).rstrip() + ' ' self.stash.term.truncate(0, flush=False) self.stash.term.write(text) def single_exec(self, command): sin, sout, serr = self.ssh.exec_command(command) for line in sout.readlines(): line = line.replace('\n', '') for line in serr.readlines(): print line.replace('\n', '') def get_remote_path(self): self.pause_output = True self.chan.send('pwd \n') while True: if self.chan.recv_ready(): rcv = self.chan.recv(1024) #print ' '.join([str((ord(a),a)) for a in rcv]) #print ' '.join([a for a in rcv]) res = re.search(r'pwd ?\r\n(.*)\r\n', rcv) path = res.group(1) self.pause_output = False break return path + '/' def get_file(self, remote, local): sftp = self.ssh.open_sftp() path = self.get_remote_path() sftp.get(path + remote, local) sftp.close() print 'File transfered.' def put_file(self, local, remote): sftp = self.ssh.open_sftp() path = self.get_remote_path() sftp.put(local, path + remote) sftp.close() print 'File transfered.' def edit_file(self, remote_file): import tempfile import runpy import editor try: temp = tempfile.NamedTemporaryFile( dir=os.path.expanduser('~/Documents'), suffix='.py') cur_path = editor.get_path() sftp = self.ssh.open_sftp() path = self.get_remote_path() res = sftp.getfo(path + remote_file, temp) #editor.open_file(temp.name) temp.seek(0) print '***When you are finished editing the file, you must come back to console to confirm changes***' editor.open_file(temp.name) time.sleep(1.5) console.hide_output() input = raw_input('Save Changes? Y,N: ') editor.open_file(cur_path) if input == 'y' or input == 'Y': with open(temp.name, 'r') as f: sftp.putfo(f, path + remote_file) print 'File transfered.' except Exception, e: print e finally:
files = list() if args.debug: logging.getLogger("paramiko.transport").setLevel(logging.DEBUG) ssh = SSHClient() ssh.load_system_host_keys() ssh.set_missing_host_key_policy(AutoAddPolicy()) if JUMP_BOX_USERNAME and args.jump_box: jumpbox_used = True jumpbox = SSHClient() jumpbox.set_missing_host_key_policy(AutoAddPolicy()) jumpbox.connect(JUMP_BOX, username=JUMP_BOX_USERNAME, look_for_keys=True, allow_agent=True) if args.debug: log.setLevel(logging.DEBUG) if args.static_server_list: servers = SERVERS_STATIC_LIST else: try: http = urllib3.PoolManager() r = http.request("GET", CAPE_DIST_URL) if r.status == 200: res = json.loads(r.data.decode("utf-8")).get("nodes", []) servers = [res[server]["url"].split("://")[1].split(":")[0] for server in res] + [MASTER_NODE] except (urllib3.exceptions.NewConnectionError, urllib3.exceptions.MaxRetryError): sys.exit("Can't retrieve list of servers") if args.continues_integration: