def job(self, device, _): path_backup = Path.cwd() / 'logs' / 'job_logs' now = strip_all(str(datetime.now())) path_dir = path_backup / f'logs_{now}' source = path_backup / f'logs_{now}.tgz' makedirs(path_dir) for job in fetch_all('Job'): with open(path_dir / f'{job.name}.json', 'w') as log_file: dump(job.logs, log_file) with open_tar(source, 'w:gz') as tar: tar.add(path_dir, arcname='/') ssh_client = SSHClient() ssh_client.set_missing_host_key_policy(AutoAddPolicy()) ssh_client.connect(device.ip_address, username=device.username, password=device.password, look_for_keys=False) destination = f'{self.destination_path}/logs_{now}.tgz' self.transfer_file(ssh_client, source, destination) ssh_client.close() if self.delete_folder: rmtree(path_dir) if self.delete_archive: remove(source) return { 'success': True, 'result': f'logs stored in {destination} ({device.ip_address})' }
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 _execute_command_on_node(host, cmd): ssh = SSHClient() try: _setup_ssh_connection(host, ssh) return _open_channel_and_execute(ssh, cmd) finally: ssh.close()
def _exec_ssh_command(exec_info_dict, username, ip, password, command, phase): ssh = SSHClient() ssh.load_system_host_keys() ssh.connect(ip, username=username, password=password) stdin, stdout, stderr = ssh.exec_command("source ~/.profile && " + command) #print(stdout.read()) # blocking ### for debugging #print(stderr.read()) # blocking #exit_status = 0 ### exit_status = stdout.channel.recv_exit_status() # blocking ssh.close() workstation_exec_info_dict = exec_info_dict.get(username, {}) workstation_exec_info_dict[phase] = { "command": command, "ssh_exit_status": exit_status } exec_info_dict[username] = workstation_exec_info_dict
def __init__(self, cfg, info, log_fd, log_file): super(XBuilderMirrorPlugin, self).__init__(cfg, info, log_fd, log_file) self.ssh = self.cfg['mirror'].copy() for k, v in self.ssh.items(): if not v and k != 'pkey': raise XUtilsError('[mirror plugin]: mandatory parameter \'%s\' not set.' % k) # Test SSH connection ssh = SSHClient() try: ssh.set_missing_host_key_policy(AutoAddPolicy()) ssh.connect(self.ssh['server'], username=self.ssh['user'], key_filename=self.ssh['pkey']) except BadHostKeyException: raise XUtilsError('Server host key verification failed.') except AuthenticationException: raise XUtilsError('Authentication to %s@%s failed.' % (self.ssh['user'], self.ssh['server'])) except SSHException: raise XUtilsError('Unable to establish a SSH connection to %s' % self.ssh['server']) finally: stdin, stdout, stderr = ssh.exec_command( # pylint: disable=unused-variable 'touch %s/foo && rm %s/foo' % (self.ssh['base_dir'], self.ssh['base_dir']) ) if stderr.read(): raise XUtilsError( 'User %s does not have sufficient permission on server %s to create/delete files.' % (self.ssh['user'], self.ssh['server']) ) ssh.close()
def oxe_reboot(host, port, password, swinst_password): """Reboot OXE Call Server Args: host (TYPE): Description port (TYPE): Description password (TYPE): Description swinst_password (TYPE): Description """ # connect OXE through SSH and execute 'rainbowagent -v' client = SSHClient() # use the paramiko SSHClient client.set_missing_host_key_policy( AutoAddPolicy()) # automatically add SSH key try: client.connect(host, port, username='******', password=password) except AuthenticationException: print('*** Failed to connect to {}:{}'.format(host, port)) channel = client.invoke_shell() while channel.recv_ready() is False: sleep(3) # OXE is really slow on mtcl connexion stdout = channel.recv(4096) channel.send('reboot\n') while channel.recv_ready() is False: sleep(1) stdout += channel.recv(1024) channel.send(swinst_password + '\n') while channel.recv_ready() is False: sleep(0.5) stdout += channel.recv(1024) # pprint.pprint(stdout) channel.close() client.close()
class SSHConnection: def __init__(self, controller, ip, uName, uPass): try: self.ssh = SSHClient() self.ssh.load_system_host_keys() self.ssh.set_missing_host_key_policy\ (paramiko.AutoAddPolicy()) self.ssh.connect(hostname=ip, port=22, \ username=uName, password=uPass, timeout=2) except Exception as ex: controller.error(ex) #Function to get files with SCP. def fileGet(self, controller, srcDir, dstDir): try: self.scp = SCPClient(self.ssh.get_transport()) self.scp.get(srcDir, dstDir) self.scp.close() self.ssh.close() except Exception as ex: controller.error(ex) #Function to put files with SCP. def filePut(self, controller, srcDir, dstDir): try: self.scp = SCPClient(self.ssh.get_transport()) self.scp.put(srcDir, dstDir) self.scp.close() self.ssh.close() except Exception as ex: controller.error(ex)
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 job(self, payload: dict, device: Device) -> dict: path_backup = Path.cwd() / "logs" / "job_logs" now = strip_all(str(datetime.now())) path_dir = path_backup / f"logs_{now}" source = path_backup / f"logs_{now}.tgz" makedirs(path_dir) for job in fetch_all("Job"): with open(path_dir / f"{job.name}.json", "w") as log_file: dump(job.logs, log_file) with open_tar(source, "w:gz") as tar: tar.add(path_dir, arcname="/") ssh_client = SSHClient() ssh_client.set_missing_host_key_policy(AutoAddPolicy()) ssh_client.connect( device.ip_address, username=device.username, password=device.password, look_for_keys=False, ) destination = f"{self.destination_path}/logs_{now}.tgz" self.transfer_file(ssh_client, source, destination) ssh_client.close() if self.delete_folder: rmtree(path_dir) if self.delete_archive: remove(source) return { "success": True, "result": f"logs stored in {destination} ({device.ip_address})", }
def host_connect(self, host): # Connect selector = self.imported_config['sites'][self.site]['hosts'][host] ip = selector['ip_address'] username = selector['connect_user'] secret = input('Password:'******' ' stdin, stdout, stderr = [' ', ' ', ' '] while cli_input != 'ezcli exit': cli_input = input('ezcli(' + str(host) + '):') stdin, stdout, stderr = client.exec_command(cli_input) print(stdout.read().decode("utf8")) # Print output of command. Will wait for command to finish. # Get return code from command (0 is default for success) # Because they are file objects, they need to be closed stdin.close() stdout.close() stderr.close() # Close the client itself client.close()
def sshtungetip(): """ Подключается по sftp к серверу получает данные JSON. Осуществляет поиск IP и возращает его в качестве параметра в место вызова. """ global setstatus global login setstatus = "Получение ip адреса" from paramiko import SSHClient from paramiko import AutoAddPolicy from paramiko import RSAKey getipsftp = SSHClient() pk = RSAKey.from_private_key_file('srv.key') getipsftp.load_system_host_keys() getipsftp.set_missing_host_key_policy(AutoAddPolicy()) getipsftp.connect(hostname=publicipadress[0], port=str(publicipadress[1]), username='******', pkey=pk) sftp = getipsftp.open_sftp() import json fip = None with sftp.file('ip-client.json', 'r') as f: dataip = json.load(f) getipsftp.close() for x in dataip: if login == x["User"]["login"] or login in x["User"]["FullName"]: fip = x["User"]["ipaddress"]["ip"][0] fullname = x["User"]["login"] if fip == "Не найдено" or fip is None: fip = "IP не найден" time.sleep(1) return (fip)
class SshService: def __init__(self): self._client = SSHClient() def login(self, username="******", hostname='laptop'): self._client.load_system_host_keys() self._client.connect(hostname=hostname, username=username) def exit(self): self._client.close() def exec(self, command) -> str: stdin, stdout, stderr = types(self._client.exec_command(command)) self._handle_error(stderr) return self._handle_out(stdout) def sudo_exec(self, command) -> str: stdin, stdout, stderr = types(self._client.exec_command(f"sudo -S {command}")) if stdin.writable(): stdin.write(os.getenv('sudoPass') + '\n') stdin.flush() self._handle_error(stderr) return self._handle_out(stdout) def _handle_error(self, stderr): if stderr.readable(): err = stderr.read() if len(err) > 0 and not err.startswith(b'[sudo] password for '): raise Exception(err) def _handle_out(self, stdout): if stdout.readable(): return stdout.read().decode() else: return None
class ssh_remote_command(): def __init__(self): self.sshclient = SSHClient() def issue_command(self, host, command): combinded_ouput = [] try: self.sshclient.set_missing_host_key_policy( paramiko.AutoAddPolicy()) key_path = os.path.expanduser("~/.ssh/authorized_keys") self.sshclient.connect(host, username="******", key_filename=key_path) stdin, stdout, stderr = self.sshclient.exec_command(command) output = stdout.readlines() for line in output: combinded_ouput.append(line.strip()) newstuff = ''.join(combinded_ouput) self.sshclient.close() brandnewstuff = ast.literal_eval(newstuff) return brandnewstuff except Exception as e: self.sshclient.close() logger.warn("Connection Failed: %s" % e)
def job(self, payload: dict, device: Device) -> dict: now = strip_all(str(datetime.now())) source = Path.cwd() / "migrations" / f"backup_{now}.tgz" migrate_export( Path.cwd(), { "import_export_types": list(import_properties), "name": f"backup_{now}" }, ) with open_tar(source, "w:gz") as tar: tar.add(Path.cwd() / "migrations" / f"backup_{now}", arcname="/") ssh_client = SSHClient() ssh_client.set_missing_host_key_policy(AutoAddPolicy()) ssh_client.connect( device.ip_address, username=device.username, password=device.password, look_for_keys=False, ) destination = f"{self.destination_path}/backup_{now}.tgz" self.transfer_file(ssh_client, source, destination) ssh_client.close() if self.delete_folder: rmtree(Path.cwd() / "migrations" / f"backup_{now}") if self.delete_archive: remove(source) return { "success": True, "result": f"backup stored in {destination} ({device.ip_address})", }
def ssh_cli_command(ipadd, user, pwd, namafile): client = SSHClient() client.set_missing_host_key_policy(AutoAddPolicy()) try: client.connect(ipadd, username=user, password=pwd) remote_shell = client.invoke_shell() except AuthenticationException: print("Authentication failed, please verify your credentials !") return False except SSHException as sshException: print("Unable to establish SSH connection: %s" % sshException) return False except socket.error: print("Unable to connect to host " + ipadd) return False try: f = open(namafile, "r") except: print("File " + namafile + " is not found !") return False for line in f: if (len(line) > 1): remote_shell.send(line.strip() + "\n") while not remote_shell.recv_ready(): time.sleep(.1) output = remote_shell.recv(10000) print(output.decode("ascii")) f.close() client.close() return True
def oxe_get_oxe_version(host, port, password): """Summary Args: host (TYPE): Description port (TYPE): Description password (TYPE): Description Returns: TYPE: Description """ # connect OXE through SSH and execute 'rainbowagent -v' client = SSHClient() # use the paramiko SSHClient client.set_missing_host_key_policy( AutoAddPolicy()) # automatically add SSH key try: client.connect(host, port, username='******', password=password) except AuthenticationException: print('*** Failed to connect to {}:{}'.format(host, port)) command = 'siteid' stdin, stdout, stderr = client.exec_command(command) tmp = stdout.readlines() # pprint.pprint(tmp) # todo test string patch static/dynamic major = tmp[2].split()[4].upper() static = tmp[3].split()[3] dynamic = tmp[4].split()[4] version = {'OXE version': major + '.' + static + dynamic} pprint(version) client.close() return version
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 _read_remote_results(self, retry_attempts=3): client = SSHClient() client.set_missing_host_key_policy(AutoAddPolicy()) client.load_system_host_keys() client.connect(self.remote_server, username=self.remote_user, password=self.remote_password) command = "grep {0} /var/mdta/report/CallReport.log".format( self.filename) for i in range(15): print("Attempt {0}".format(i)) stdin, stdout, stderr = client.exec_command(command) result_line = stdout.read() print(result_line) if result_line: break time.sleep(0.25) client.close() try: result_fields = result_line.decode('utf-8').split(",") result = { 'result': result_fields[-4], 'reason': result_fields[-2], 'call_id': result_fields[2] } except IndexError: address_in_use = self._check_call_start_failure() if address_in_use: if retry_attempts >= 1: time.sleep(6) print("Retries left: {0}".format(retry_attempts - 1)) self._invoke_remote_hat() result = self._read_remote_results( retry_attempts=retry_attempts - 1) else: result = { 'result': 'FAIL', 'reason': 'Unable to place call, port in use', 'call_id': '0' } elif not result_line: result = { 'result': 'FAIL', 'reason': 'No results for this test case were found in the logs.', 'call_id': '0' } else: result = { 'result': 'FAIL', 'reason': 'Failed to read results: ' + str(result_line), 'call_id': '0' } except Exception as e: result = { 'result': 'FAIL', 'reason': 'An untrapped error occurred: ' + str(e.args), 'call_id': '0' } return result
def start_monitor(self): local_name = platform.node() print "Starting Cassandra Monitor for %s" % self.server while True: try: ssh = SSHClient() ssh.load_system_host_keys() ssh.set_missing_host_key_policy(AutoAddPolicy()) ssh.connect(self.server, timeout=5, allow_agent=False) stdin, stdout, stderr = ssh.exec_command(CASS_CMD) stdin.close() for line in stdout: # Any line that shows up will be a downed server # server datacenter rack status state load owns token downed_node = line.split() raise DownedNodeException(downed_node[0]) stdout.close() err = stderr.read() if err: raise Exception("Unknown error: %s" % str) stderr.close() ssh.close() except DownedNodeException as e: self.mark_error(e.node, e) except SSHException as e: self.mark_error(self.server, "%s could not connect to %s: %s" % (local_name, self.server, e)) except Exception as e: self.mark_error(local_name, "Unknown error: %s" % e) else: self.clear_error() time.sleep(INTERVAL)
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)), key_filename=self.identity_file, username=self.config.get('user')) stdout, stderr, channel = self.exec_command(client) Printer(self.host, stdout, stderr).loop() if channel: exitcode = channel.recv_exit_status() 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 except Exception as e: print(colored('{0}: {1}'.format(self.host, e.message)), 'red') exitcode = 1 finally: client.close() return exitcode
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 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: client = SSHClient() client.load_system_host_keys() client.connect(REPOSITORY_HOST, username=REPOSITORY_USER, key_filename=REPOSITORY_KEY) 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 run_script(targets): print("[+] Running install script...") for target in targets: client = SSHClient() client.load_host_keys(HOSTS) client.connect( target, username=USER, password=PASS, ) run_script = "bash /home/wisp/install_vmtools.sh" stdin, stdout, stderr = client.exec_command(run_script) # Print any output or errors as they arise if stdout: print(stdout.read().decode("utf-8")) if stderr: print(stderr.read().decode("utf-8")) # Get recturn code print(f"\nReturn Code: {stdout.channel.recv_exit_status()}") # Close all file objects stdin.close() stdout.close() stderr.close() client.close() print(f"[+] Process for host {target} completed!")
class MySSH: def __init__(self, host, password, user): self.host = host self.password = password self.user = user try: self.client = SSHClient() # 我们第一次连接时会去核实host它会去找known_host_key的这个文件,没有按如下处理 self.client.set_missing_host_key_policy(AcceptPolicy()) # 我们hostkey不在时的规定:set policy to use when connecting to servers without a known_host_key,然后我们另起炉灶 self.client.connect(hostname=host, username=user, password=password, timeout=10) log.debug(f'{user}成功登录{host}主机') except Exception as e: print(e) log.debug(f'{user}登录{host}主机失败:原因{e}') self.client = None def send_cmd(self, cmd): """发送命令取得返回值""" try: stdin, stdout, stderr = self.client.exec_command(cmd) log.debug(f'{self.user}登录{self.host}执行了{cmd}命令') print(stdout, stderr) return stdout except SSHException as e: log.debug(f'{self.user}登录{self.host}执行了{cmd}命令未成功,原因:{e}') print(e) def close(self): """关闭连接""" self.client.close() log.debug(f'{self.user}登录的{self.host}主机断开连接')
def _ssh(self, script_file, parameters): """ Copies a templated script to the EC2 instance and yields the SSH session. """ import os.path from paramiko import SSHClient from paramiko.client import AutoAddPolicy this_file_dir = os.path.dirname(__file__) with open(os.path.join(this_file_dir, script_file)) as fh: script = fh.read() % parameters response = self.ec2.describe_instances(InstanceIds=[self.instance_id]) instance = response['Reservations'][0]['Instances'][0] ip = instance['PublicIpAddress'] ssh = SSHClient() # TODO: is there any way to get the host key via AWS APIs? ssh.set_missing_host_key_policy(AutoAddPolicy) ssh.connect(ip, username='******', pkey=self.key, look_for_keys=False) try: with ssh.open_sftp() as ftp: with ftp.file(script_file, 'w') as fh: fh.write(script) yield ssh except Exception as e: raise RuntimeError('ERROR: %s (on ubuntu@%s)' % (e, ip)) finally: ssh.close()
def scp_file(filepath): try: from paramiko import SSHClient, AutoAddPolicy from scp import SCPClient except ImportError: print( "Import Error! Please install paramiko and scp packages if not available:\n" "$ conda install paramiko\n" "$ pip install scp\n") sys.exit(1) # another way: `raise SystemExit` print("Transfering files...") ssh = SSHClient() ssh.set_missing_host_key_policy(AutoAddPolicy()) # ssh.load_system_host_keys() ssh.connect(hostname="prada-research.net", username="******", password="******") # SCPCLient takes a paramiko transport as its only argument scp_client = SCPClient(ssh.get_transport()) # scp_client.get("/var/www/html/demo/datasets/" + os.path.basename(filepath)) scp_client.put(filepath, "/var/www/html/demo/datasets/" + os.path.basename(filepath)) scp_client.close() ssh.close() print("Finished transfering.")
class SSH: def __init__(self, **kwargs): self.client = SSHClient() self.client.set_missing_host_key_policy(AutoAddPolicy()) self.kwargs = kwargs def __enter__(self): kw = self.kwargs try: self.client.connect( hostname=kw.get('hostname'), port=int(kw.get('port', 22)), username=kw.get('username'), password=kw.get('password'), ) except AuthenticationException: print("Authentication failed, please verify your credentials") except SSHException as sshException: print(f"Could not establish SSH connection {sshException}") return self def __exit__(self, exc_type, exc_val, exc_tb): self.client.close() def exec_cmd(self, cmd): stdin, stdout, stderr = self.client.exec_command(cmd) data = stdout.read() data = data.decode() return data
class ssh: def __init__(self, url, port, username, password): self.__ssh = SSHClient() self.__ssh.load_system_host_keys() self.__ssh.set_missing_host_key_policy(AutoAddPolicy()) try: self.__ssh.connect(url, port=port, username=username, password=password) except AuthenticationException: return False # Run ssh command def exec(self, command): (stdin, stdout, stderr) = self.__ssh.exec_command(command) return True if stdout.channel.recv_exit_status() == 0 else False # Put file via scp def put(self, source, dest): with SCPClient(self.__ssh.get_transport()) as scp: scp.put(source, dest) return True # Close connection def close(self): self.__ssh.close()
class Connection(object): def __init__(self, hostname="localhost", port=1247, username="******", password="******"): self.hostname = hostname self.port = port self.username = username self.password = password self.con = False self._conn_() return def _conn_(self): """ Create Conn """ self.ssh = SSHClient() self.ssh.load_system_host_keys() self.ssh.connect(hostname=self.hostname, port=self.port, username=self.username, password=self.password) self.scp = SCPClient(self.ssh.get_transport()) self.con = True return def _close_(self): """ Close connection """ if self.con: self.scp.close() self.ssh.close() return
class SshArchiver(Archiver): """ Archives artifacts using ssh. """ def start(self): """ Opens the ssh connection. """ self.ssh_client = SSHClient() self.ssh_client.set_missing_host_key_policy(WarningPolicy()) self.ssh_client.connect( self.target.host, pkey=self.target.ssh_credentials.get_pkey()) self.sftp_client = SFTPClient.from_transport( self.ssh_client.get_transport()) def end(self): """ Closes the ssh connection. """ self.ssh_client.close() def archive_artifact(self, artifact_url, destination): """ Uploads the artifact_url to the destination on the remote server, underneath the target's basedir. """ destination = os.path.join(self.target.basedir, destination) _, stdout, _ = self.ssh_client.exec_command( "mkdir -p `dirname %s`" % destination) # TODO: raise exception if the command fails _ = stdout.channel.recv_exit_status() # noqa artifact = urllib2.urlopen(artifact_url) self.sftp_client.stream_file_to_remote(artifact, destination)
def oxe_get_rainbow_agent_version(host, port, password): """Summary Args: host (TYPE): Description port (TYPE): Description password (TYPE): Description Returns: TYPE: Description """ # connect OXE through SSH and execute 'rainbowagent -v' client = SSHClient() # use the paramiko SSHClient client.set_missing_host_key_policy( AutoAddPolicy()) # automatically add SSH key try: client.connect(host, port, username='******', password=password) except AuthenticationException: print('*** Failed to connect to {}:{}'.format(host, port)) command = 'rainbowagent -v' stdin, stdout, stderr = client.exec_command(command) version = {'rainbowagent version': stdout.readlines()[0].split()[2]} pprint(version) client.close() return version
def run_cmd_ssh(cmd: str) -> Response: """ Run batch script using ssh client. Args: cmd: batch script to run. Returns: Response object containing stderr, stdout and exit_status. """ ssh_client = SSHClient() ssh_client.load_system_host_keys() ssh_client.set_missing_host_key_policy(AutoAddPolicy()) ssh_client.connect(username=config['user'], password=config['pass'], hostname=config['host'], port=int(config['ssh_port']), allow_agent=False, look_for_keys=False) cmd_st = ssh_client.exec_command(cmd) rs = namedtuple('Response', ['std_out', 'std_err', 'status_code']) rs.std_out = cmd_st[1].read() rs.std_err = cmd_st[2].read() rs.status_code = cmd_st[1].channel.recv_exit_status() ssh_client.close() return rs
class RemoteBenchMarker(): host_name = "" port = -1 username = "******" key_filename = "empty" passphrase = "-1" client = None def __init__(self, host_name, port, username, key_filename, passphrase): self.host_name = host_name self.port = port self.username = username self.key_filename = key_filename self.passphrase = passphrase self.client = SSHClient() def exec_command(self, commands): print("running commands {}".format(commands)) self.client.load_system_host_keys() self.client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) self.client.connect(hostname=self.host_name, port=self.port, username=self.username, key_filename=self.key_filename, passphrase=self.passphrase) # wait for command completion for command in commands: stdin, stdout, stderr = self.client.exec_command(command) exit_status = stdout.channel.recv_exit_status() print("{} : {} finished at {}".format(exit_status, command, datetime.now())) def close_client(self): self.client.close()
def ssh_cmd(self): ssh = SSHClient() ssh.set_missing_host_key_policy(AutoAddPolicy()) try: ssh.connect(self.host, self.port, self.user, self.password, timeout=self.timeout) except AuthenticationException as e: outList = ["ssh服务器身份验证错误,请检查核对您的用户名以及密码", str(e)] except NoValidConnectionsError as e: outList = ["ssh服务器连接错误", str(e)] except toe: outList = ["ssh服务器连接超时,请重新试试"] else: sshCmdStr = "python /etc/nginx/fprNginx.py {} {}".format( self.stream, self.cmd) _, out, __ = ssh.exec_command(sshCmdStr) outList = out.readlines() for item in outList: if "upstream name do not exists" == item.strip(): break else: outList.append("成功!") finally: ssh.close() return "".join(outList)
def vm_create_eva_cfg(host, port=22, password='******', accesses=15): """Summary Args: host (TYPE): Description port (int, optional): Description password (str, optional): Description accesses (int, optional): Description """ data = 'callserver1=' + host + '\ncallserver2=' + '\neva=' + host + '\eva_access=' + accesses client = SSHClient() # use the paramiko SSHClient client.set_missing_host_key_policy( AutoAddPolicy()) # automatically add SSH key try: client.connect(host, port, username='******', password=password) except AuthenticationException: print('*** Failed to connect to {}:{}'.format(host, port)) channel = client.invoke_shell() while channel.recv_ready() is False: sleep(3) # OXE is really slow on mtcl connexion stdout = channel.recv(4096) channel.send('cat >> /usr3/mao/eva.cfg << EOF\n' + data + '\nEOF\n') while channel.recv_ready() is False: sleep(0.5) stdout += channel.recv(1024) # print(stdout.decode(encoding='UTF-8')) channel.close() client.close()
def start_monitor(self): local_name = platform.node() print "Starting Cassandra Monitor for %s" % self.server while True: try: ssh = SSHClient() ssh.load_system_host_keys() ssh.set_missing_host_key_policy(AutoAddPolicy()) ssh.connect(self.server, timeout=5, allow_agent=False) stdin, stdout, stderr = ssh.exec_command(CASS_CMD) stdin.close() for line in stdout: # Any line that shows up will be a downed server # server datacenter rack status state load owns token downed_node = line.split() raise DownedNodeException(downed_node[0]) stdout.close() err = stderr.read() if err: raise Exception("Unknown error: %s" % err) stderr.close() ssh.close() except DownedNodeException as e: self.mark_error(e.node, e) except SSHException as e: self.mark_error(self.server, "%s could not connect to %s: %s" % (local_name, self.server, e)) except Exception as e: self.mark_error(local_name, "Unknown error: %s" % e) else: self.clear_error() time.sleep(INTERVAL)
class SSH(object): """docstring for SSH""" def __init__(self): self.client = SSHClient() self.client.set_missing_host_key_policy(AutoAddPolicy()) self.client.load_system_host_keys() def connect(self, server, user, key): logging.info("Connecting to {u}@{s} [with key:{k}]".format( u=user, s=server, k=key )) self.client.connect(server, username=user, key_filename=key, timeout=2.0) def close(): self.client.close() @property def transport(self): return self.client.get_transport() @staticmethod def SSHFactory(config): logging.debug("Creating SSH Object.") sClient = SSH() sClient.connect(config.staging, config.stagingUser, config.key ) return sClient
def _shell(self): """ Create SSHClient instance and connect to the destination host. :return: Connected to the remote destination host shell. :rtype: generator(SSHClient) :raise SshDestinationError: if the ssh client fails to connect. """ shell = SSHClient() shell.set_missing_host_key_policy(AutoAddPolicy()) try: LOG.debug( "Connecting to %s:%d as %s with key %s", self._host, self._port, self._user, self._key, ) shell.connect( hostname=self._host, key_filename=self._key, port=self._port, username=self._user, ) yield shell except FileNotFoundError: raise except (AuthenticationException, SSHException, socket.error) as err: # print(type(err)) raise SshClientException(err) finally: shell.close()
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
class RemoteClient: def __init__(self, host, user, remote_path): self.host = host self.user = user self.remote_path = remote_path self.client = None def connect(self): 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, timeout=5000) except AuthenticationException as error: logger.info("Authentication failed: did you remember to create an SSH key?") logger.error(error) raise error finally: return Connection(self.client) def disconnect(self): self.client.close() def __enter__(self): return self.connect() def __exit__(self, exc_type, exc_val, exc_tb): self.disconnect()
def make_queen_bee(hostname, username, key_filename): client = SSHClient() client.set_missing_host_key_policy(AutoAddPolicy()) client.connect( hostname, username=username, key_filename=key_filename ) _, stdout, sterr = client.exec_command('sudo pkill shutdown') print(stdout.read() + sterr.read()) boto_path = path.expanduser('~/.boto') command = 'scp -o "StrictHostKeyChecking=no" -i {} {} {}@{}:~/.boto'.format( key_filename, boto_path, username, hostname ) system(command) print(command) command = 'scp -o "StrictHostKeyChecking=no" -i {} {} {}@{}:~/.ssh/'.format( key_filename, key_filename, username, hostname ) system(command) print(command) # the royal yaass _, stdout, _ = client.exec_command('touch ~/.yaass') client.close() return hostname
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 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 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
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 update_server(server): if utilities.ping(server): client = SSHClient() if utilities.ssh(server, client): print server.name command = 'python -V' stdin, stdout, stderr = client.exec_command(command) # https://bugs.python.org/issue18338 # Apparently this is an old bug and only fixed in Python 3.4 and 2.7 # where the version is sent to stderr try: version = stderr.readlines()[0].rstrip() version = re.sub('Python ', '', version) except: version = 'None' if version == 'None': try: version = stdout.readlines()[0].rstrip() version = re.sub('Python ', '', version) except: version = 'None' print version # check existing value, if it exists, don't update if str(version) != str(server.python): utilities.log_change(server, 'python', str(server.python), str(version)) LinuxServer.objects.filter(name=server).update(python=version, modified=timezone.now()) client.close()
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
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()
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 )
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 _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))
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 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 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 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 main(): logging.basicConfig(level=logging.INFO) if isfile(get_config_path(__file__, '/esxi.ini')): config = ConfigurationINI(get_config_path(__file__, '/esxi.ini')) elif isfile('/etc/esxi.ini'): config = ConfigurationINI('/etc/esxi.ini') else: logging.critical('/etc/esxi.ini missing.') exit(0) logging.debug('Configuration file used : {conf}'.format(conf=get_config_path(__file__, '/esxi.ini'))) try: ssh = SSHClient() ssh.set_missing_host_key_policy(AutoAddPolicy()) ssh.connect(config['esxi']['hostip'], username=config['esxi']['username'], password=config['esxi']['password']) except SocketError as e: logging.critical('Host unreachable.') logging.critical(e.__str__()) exit() logging.info('vim-cmd hostsvc/firmware/sync_config') ssh.exec_command('vim-cmd hostsvc/firmware/sync_config') logging.info('vim-cmd hostsvc/firmware/backup_config') stdin, stdout, stderr = ssh.exec_command('vim-cmd hostsvc/firmware/backup_config') for l in stdout: m = search('http://\*(.*)', l.strip()) if m is not None: download = "http://{host}{position}".format( host=config['esxi']['hostip'], position=m.group(1) ) logging.info("Downloading {0}".format(download)) local_file = '{localpath}/backup-{host}-{date}.tgz'.format( host=config['esxi']['hostdns'], date=strftime(config['local']['dateformat']), localpath=config['local']['savepath'] ) urlretrieve(download, local_file) if config['webdav']['enabled']: logging.info("Uploading file on WebDAV") comediaoc = webdav_connect( config['webdav']['host'], username=config['webdav']['username'], password=config['webdav']['password'], protocol=config['webdav']['proto'], verify_ssl=False ) comediaoc.upload(local_file, '{0}/backup-{1}-{2}.tgz'.format( config['webdav']['savepath'], config['esxi']['hostdns'], strftime(config['local']['dateformat']) )) ssh.close()
def run(self): try: # run a command and wait for it to finish def run(command): _, stdout, _ = ssh.exec_command(command) stdout.channel.recv_exit_status() # send the webapp a textual progress update listener = Listener() def log(text): listener.publish(('project', self.project.name, 'deploy', 'status'), { 'text': text }) # prevent accidentally deploying on the server itself # (this doesn't prevent deploying to the server's public # IP address, so there's still a security problem here) if self.host in ['127.0.0.1', '0.0.0.0']: raise Exception('you\'re trying to deploy to the server!') # create temporary build file path = os.path.join(tempfile.mkdtemp(), 'deploy.launch') xml = roslaunch_xml_for_file(self.project.project_file_path, self.remote_deploy_path) open(path, 'w').write(xml) log('Created file: deploy.launch') # create a ssh session log('Connecting to %s@%s...' % (self.user, self.host)) ssh = SSHClient() ssh.load_system_host_keys() ssh.set_missing_host_key_policy(AutoAddPolicy()) ssh.connect(self.host, username=self.user, password=self.password) log('Connected to remote machine') # clean the deploy location run('rm -fr %s' % self.remote_deploy_path) run('mkdir -p %s' % self.remote_deploy_path) log('Cleaned deploy location') # copy the launch file over scp = SCPClient(ssh.get_transport()) scp.put(path, remote_path=self.remote_deploy_path) log('Copied file: deploy.launch') # run the file command = 'cd %s && roslaunch deploy.launch' % self.remote_deploy_path channel = ssh.invoke_shell() channel.send(command + '\nexit\n') log('Ran command: roslaunch deploy.launch') # wait for the command to finish import time while not self.die: time.sleep(0.1) except: import traceback log('Exception:\n' + traceback.format_exc()) ssh.close() log('Connection was closed')
def inspect_container(server, name): client = SSHClient() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) client.load_system_host_keys() client.connect(server[0], username=server[1], password=server[2]) stdin, stdout, stderr = client.exec_command('sudo docker inspect %s' % name) lines = stdout.readlines() client.close() return ''.join(lines)
def start_ssh(host, username, password): ssh = SSHClient() try: ssh.set_missing_host_key_policy(AutoAddPolicy()) ssh.connect(host, username=username, password=password) except SSHException: ssh.close() raise return ssh
class UbiquityBase(PDUDriver): client = None # overwrite power_count port_count = 0 def __init__(self, hostname, settings): self.hostname = hostname log.debug(settings) self.settings = settings self.sshport = 22 self.username = "******" self.password = "******" if "sshport" in settings: self.sshport = settings["sshport"] if "username" in settings: self.username = settings["username"] if "password" in settings: self.password = settings["password"] self.connect() super(UbiquityBase, self).__init__() def connect(self): log.info("Connecting to Ubiquity mfi %s@%s:%d", self.username, self.hostname, self.sshport) self.client = SSHClient() self.client.load_system_host_keys() self.client.connect(hostname=self.hostname, port=self.sshport, username=self.username, password=self.password) def port_interaction(self, command, port_number): log.debug("Running port_interaction from UbiquityBase") if port_number > self.port_count: raise RuntimeError("We only have ports 1 - %d. %d > maxPorts (%d)" % self.port_count, port_number, self.port_count) if command == "on": command = "sh -c 'echo 1 > /proc/power/relay%d'" % port_number elif command == "off": command = "sh -c 'echo 0 > /proc/power/relay%d'" % port_number try: stdin, stdout, stderr = self.client.exec_command(command, bufsize=-1, timeout=3) stdin.close() except SSHException as exc: pass def _cleanup(self): self.client.close() def _bombout(self): self.client.close() @classmethod def accepts(cls, drivername): log.debug(drivername) return False