def run_command_on_instances(instances, command, env_file, key_file): ec2r = boto3.resource('ec2') ssh = SSHClient() ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) for instance in instances['Instances']: inst_id = instance['InstanceId'] instance_obj = ec2r.Instance(inst_id) instance_obj.reload() inst_ip = instance_obj.public_dns_name sys.stderr.write("Copying env_file.txt to host...\n") call([ 'scp', '-i', key_file, env_file.name, 'ubuntu@%s:/home/ubuntu/env_file.txt' % inst_ip ]) time.sleep(2) sys.stderr.write("Running command %s on remote host...\n" % (command)) ssh.connect(inst_ip, username='******', key_filename=key_file) stdin, stdout, stderr = ssh.exec_command(command) stdin.flush() output = stdout.read().splitlines() error = stderr.read().splitlines() sys.stderr.write( 'Startup standard output\n%s:Startup standard error:\n%s\n' % (output, error)) ssh.close()
def execute_remote_command(ip, command, quiet=False, username=REMOTE_USER): client = SSHClient() client.set_missing_host_key_policy(IgnoreHostKeyPolicy) client.connect(ip, username=username) stdin, stdout, stderr = client.exec_command(command) rc = stdout.channel.recv_exit_status() out = stdout.read().decode('utf-8').splitlines() err = stderr.read().decode('utf-8').splitlines() client.close() if rc != 0 and not quiet: log = logging.getLogger('TPCH') log.error("ssh command returned %d" % rc) log.error("ssh -l %s %s %s" % (username, ip, command)) print(command) for line in out: print(line) for line in err: print(line) print() if rc != 0: raise RuntimeError(command) return out, err
def create_worker(host): config = SSHConfig() proxy = None if os.path.exists(os.path.expanduser('~/.ssh/config')): config.parse(open(os.path.expanduser('~/.ssh/config'))) if host.hostname is not None and \ 'proxycommand' in config.lookup(host.hostname): proxy = ProxyCommand(config.lookup(host.hostname)['proxycommand']) # proxy = paramiko.ProxyCommand("ssh -o StrictHostKeyChecking=no [email protected] nc 118.138.239.241 22") worker = SSHClient() worker.load_system_host_keys() worker.set_missing_host_key_policy(AutoAddPolicy()) worker.hostname = host.hostname # store all this for later reference (e.g., logging, reconnection) worker.username = host.username worker.password = host.password worker.proxy = proxy if not host.key_filename is None: worker.pkey = RSAKey.from_private_key_file(host.key_filename, host.key_password) else: worker.pkey = None # time.sleep(4) # worker.connect(hostname=host.hostname, username=host.username, password=host.password, key_filename=host.key_filename, sock=proxy, timeout=3600) worker.connect(hostname=host.hostname, username=host.username, password=host.password, pkey=worker.pkey, sock=proxy) return worker
def try_ssh(virtual_machine: VirtualMachine, retries: int = 10): """ Try to connect to a virtual machine using ssh :param virtual_machine: the virtual machine :param retries: the maximum of retries """ retry = 0 connected = False ssh = SSHClient() ssh.set_missing_host_key_policy(AutoAddPolicy()) ssh.load_system_host_keys() while retry < retries and not connected: try: logger.debug('Trying ssh connection to %s %s out of %s retries', virtual_machine.hostname, retry, retries) ssh.connect(virtual_machine.hostname, port=virtual_machine.ssh_port, username=virtual_machine.ssh_username, password=virtual_machine.ssh_password) connected = True except (BadHostKeyException, AuthenticationException, SSHException, socket.error): time.sleep(10) retry += 1 if not connected: raise Exception( '[{}] Unable to connect to the machine after {} tries'.format( virtual_machine.hostname, retry)) logger.info('Connection established to %s after %d out of %d retries', virtual_machine.name, retry, retries)
def run_remote_command(args, hostgroup_name, hostgroup, command): """Run the appropriate command on hosts in a given host group based on the action being taken""" client = SSHClient() client.load_system_host_keys() client.set_missing_host_key_policy(AutoAddPolicy()) ssh_key = None host_results = {} if args.ssh_key: ssh_key = "%s/.ssh/%s" % (os.environ['HOME'], args.ssh_key) for host in hostgroup: try: client.connect(host.address, allow_agent=True, username=os.getenv('USER')) except Exception, e: print "Error running remote command on (%s:%s) (%s)" % ( host.name, host.address, e) continue print "(%s:%s) => (%s)" % (host.name, host.address, command) chan = client.get_transport().open_session() chan.set_combine_stderr(True) chan.exec_command(command) dump_channel(chan) rv = chan.recv_exit_status() host_results[host.name] = rv chan.close() client.close() _summarize_exit_code(rv)
def ssh(self, address): """ Create an SSH connection to the instance. """ try: ssh = SSHClient() # ssh.load_system_host_keys() """ VM instances' IP addresses are indeterminate, so there is no good way to detect a Man In The Middle attack. The fact that a different instance now has the same IP address could be a MITM attack, or it could be due to deletion of the old instance, or it could be due to re-arranging of IP addresses among the same set of instances. We don't care much about MITM attacks anyway - they would merely cause us to test the correct functioning of some attacker's computer, instead of our instance, which would be bad only if the attacker's computer were less broken than our instance, thus hiding problems with our instance. This is a less bad problem than SSH connectivity randomly failing when IP addresses get re-used. So just disable protection against MITM attacks, by: 1. Auto-adding unknown hosts to the known hosts file and 2. Not loading any known hosts files. """ ssh.set_missing_host_key_policy(AutoAddPolicy()) ssh.connect(address, username=self.params['ssh_username'], key_filename=self.params['ssh_key_file']) except: self.logger.debug(self.instance().get_console_output(10)) raise return ssh
def connect(self, instance, ssh_user, ssh_ports, cmd, ssh_key_name): """ execute a command on instance with ssh and return if cmd param is not None connect to ssh if cmd is None :param instance: :param ssh_user: :param ssh_ports: :param ssh_key_name: :param cmd: execute this command if not None :return: """ # get instance public ip ssh_ip = instance.ip # we need to find the ssh key try: key_file = open(os.path.join(os.path.expanduser(self._key_path), ssh_key_name), 'r') except FileNotFoundError: try: key_file = open(os.path.join(os.path.expanduser(self._key_path), ssh_key_name + '.pem'), 'r') except FileNotFoundError: raise CourirSshException('private key %(key_name)s nor %(key_name)s.pem not found' % { 'key_name': ssh_key_name }) client = SSHClient() client.set_missing_host_key_policy(AutoAddPolicy()) logger.debug('connecting to %s with port %s and user %s', ssh_ip, ssh_ports[0], ssh_user) mykey = RSAKey.from_private_key(key_file) # we try with each ssh_port we have for count, ssh_port in enumerate(ssh_ports): try: logger.debug(ssh_ip) logger.debug(ssh_port) client.connect(hostname=ssh_ip, port=int(ssh_port), username=ssh_user, pkey=mykey, timeout=4) if cmd is None: with NamedTemporaryFile(mode='w+') as tmp_key_file: mykey.write_private_key(tmp_key_file, password=None) tmp_key_file.flush() cmd = 'ssh -i %s %s@%s -p %s' % (tmp_key_file.name, ssh_user, ssh_ip, ssh_port) logger.debug(cmd) os.system(cmd) else: stdin, stdout, stderr = client.exec_command(command=cmd) out_str = stdout.read() out_err = stderr.read().strip(' \t\n\r') print(out_str) if out_err != '': print(out_err) sys.exit(1) except (ConnectionRefusedError, socket.timeout): # we will try another tcp port if count < len(ssh_ports): continue else: raise CourirSshException('connection error')
def turn_off(id): server = SERVERS.get(id) if not server: return server_not_found() exit_status = -1 ssh_settings = server['ssh'] client = SSHClient() client.load_system_host_keys() client.set_missing_host_key_policy(AutoAddPolicy()) client.connect(ssh_settings['address'], username=ssh_settings['username'], password=ssh_settings['password']) stdin, stdout, stderr = client.exec_command('shutdown -p now') #print("stdout: " + str(stdout.readlines())) #print("stderr: " + str(stderr.readlines())) exit_status = stdout.channel.recv_exit_status() print("Shutdown, exit status: %s" % exit_status) client.close() return jsonify({"success": exit_status == 0})
class RemoteRunner(Runner): def __init__(self, *args, **kwargs): super(RemoteRunner, self).__init__(*args, **kwargs) self.context def start(self, command): self.ssh_client = SSHClient() self.ssh_client.load_system_host_keys() self.ssh_client.set_missing_host_key_policy(AutoAddPolicy()) self.ssh_client.connect(self.context.remote_runner.hostname, username=self.context.remote_runner.username) self.ssh_channel = self.ssh_client.get_transport().open_session() if self.using_pty: self.ssh_channel.get_pty() self.ssh_channel.exec_command(command) def stdout_reader(self): return self.ssh_channel.recv def stderr_reader(self): return self.ssh_channel.recv_stderr def default_encoding(self): return locale.getpreferredencoding(True) def wait(self): return self.ssh_channel.recv_exit_status() def returncode(self): return self.ssh_channel.recv_exit_status()
class MySSHClient(): def __init__(self): self.ssh_client = SSHClient() def ssh_login(self, host_ip, username, password): try: self.ssh_client.set_missing_host_key_policy(AutoAddPolicy()) self.ssh_client.connect(host_ip, port=22, username=username, password=password) except AuthenticationException: log.warning('username or password error') return 1001 except NoValidConnectionsError: log.warning('connect time out') return 1002 except: log.warning('unkown error') print("Unexpect error:", sys.exc_info()[0]) return 1003 return 1000 def ssh_logout(self): log.warning('will exit host') self.ssh_client.close() def execute_some_command(self, command): _, stdout, _ = self.ssh_client.exec_command(command) print(stdout.read().decode())
class Host: def __init__(self, name): self.name = name self.ip = None self.ssh_pkey = None self._ssh = None def __str__(self): return self.name def transport(self): """Returns the ssh transport for this host.""" if self._ssh == None: self._ssh = SSHClient() # import keys using paramikos method self._ssh.load_system_host_keys() # import openssh system host keys host_keys_file = '/etc/ssh/ssh_known_hosts' if os.path.exists(host_keys_file): self._ssh.load_system_host_keys(host_keys_file) # import saved host keys from/for multiapt host_keys_file = os.getenv('HOME','/')+'/.ssh/known_hosts_multiapt' if os.path.exists(host_keys_file): self._ssh.load_host_keys(host_keys_file) # now set our own filename for key save purposes self._ssh._host_keys_filename = host_keys_file # enable our own policy for host key problems self._ssh.set_missing_host_key_policy(SSHAskHostKeyPolicy()) if Main.debug: print 'D: ssh.connect()' self._ssh.connect(self.ip, username=config.remote_username, pkey=self.ssh_pkey) return self._ssh
def ssh_login(host, username, password): r = SSH_Client() r.load_system_host_keys() r.set_missing_host_key_policy(AutoAddPolicy()) info("Trying to open a SSH connection to {}".format(host)) try: r.connect(host, username=username, password=password) except SSH_BadHostKeyException as errstr: error("SSH host key for {0} could not be verified: {1}".format(host, errstr)) return False except SSH_AuthenticationException: error("SSH authentication failed for {}".format(host)) return False except SSH_SSHException as errstr: error("Unknown SSH error while connecting to {0}: {1}".format(host, errstr)) return False except OSError as err: error("Can't connect to SSH server {0}: '{1}'".format(host, err)) return False except: error("Unknown error encountered while connecting to SSH server {}".format(host)) return False info("SSH connection to {} opened successfully".format(host)) return r
def ssh_connection( instance: Instance, ssh_credentials: SSHCredentials ) -> Iterator[SSHClient]: """Connect to server and yield SSH client.""" username, key_filename = ssh_credentials instance_ssh_port: int = cast(int, instance.ssh_port) ignore_host_key_policy: Union[ Type[MissingHostKeyPolicy], MissingHostKeyPolicy ] = cast( Union[Type[MissingHostKeyPolicy], MissingHostKeyPolicy], IgnoreHostKeyPolicy ) client = SSHClient() client.set_missing_host_key_policy(ignore_host_key_policy) client.connect( hostname=str(instance.public_ip), port=instance_ssh_port, username=username, key_filename=key_filename, ) yield client client.close()
def create_backup_repository(service): """ - create filesystem folders - store ssh key - create subaccount """ # Create folder and SSH key client = SSHClient() client.load_system_host_keys() client.connect(**settings.STORAGE_SERVER) ftp = client.open_sftp() dirname = str(uuid4()) ftp.mkdir(dirname) ftp.chdir(dirname) ftp.mkdir(".ssh") ftp.chdir(".ssh") with ftp.open("authorized_keys", "w") as handle: handle.write(service.last_report.ssh_key) # Create account on the service url = "https://robot-ws.your-server.de/storagebox/{}/subaccount".format( settings.STORAGE_BOX) response = requests.post( url, data={ "homedirectory": "weblate/{}".format(dirname), "ssh": "1", "external_reachability": "1", "comment": "Weblate backup service {}".format(service.pk), }, auth=(settings.STORAGE_USER, settings.STORAGE_PASSWORD), ) data = response.json() return "ssh://{}@{}:23/./backups".format(data["subaccount"]["username"], data["subaccount"]["server"])
class SshClient(): def __init__(self): self.ssh_client = SSHClient() def ssh_login(self, host_ip, username, password): try: # 设置允许连接known_hosts文件中的主机(默认连接不在known_hosts文件中的主机会拒绝连接抛出SSHException) self.ssh_client.set_missing_host_key_policy(AutoAddPolicy()) self.ssh_client.connect(host_ip, port=22, username=username, password=password) except AuthenticationException: print('username or password error') return 1001 except NoValidConnectionsError: print('connect time out') return 1002 except: print("Unexpected error:", sys.exc_info()[0]) return 1003 return 1000 def execute_some_command(self, command): stdin, stdout, stderr = self.ssh_client.exec_command(command) print(stdout.read().decode()) return stdout.read().decode() def ssh_logout(self): self.ssh_client.close()
def __connect(self): assert self._server_pub_key and self._server_url and isinstance(self._my_host_key_policy, MissingHostKeyPolicy) client = SSHClient() client.set_missing_host_key_policy(self._my_host_key_policy) client.connect(self._server_url) # host alias from .ssh/config # self._ssh_client = client return True
class SSHTarget: def __init__(self, host, port=22, timeout=10): self.host = host self.port = int(port) self.timeout = timeout self.ssh_client = SSHClient() self.ssh_client.set_missing_host_key_policy(AutoAddPolicy()) def connect(self, username, password): self.ssh_client.connect(self.host, self.port, username, password, timeout=self.timeout) def connect_with_key(self, username, key): self.ssh_client.connect(self.host, self.port, username, key_filename=key, timeout=self.timeout) def close(self): self.ssh_client.close() def send(self, data): tdin, stdout, stderr = self.ssh_client.exec_command(data) if stderr.readline() != "": Logger.warning("STDERR was not null! (" + stderr.read().decode("utf-8") + ")") return stdout.read().decode("utf-8")
def create_worker(host): config = SSHConfig() proxy = None if os.path.exists(os.path.expanduser('~/.ssh/config')): with open(os.path.expanduser('~/.ssh/config')) as f: config.parse(f) if host.hostname is not None and 'proxycommand' in config.lookup( host.hostname): proxy = ProxyCommand(config.lookup(host.hostname)['proxycommand']) worker = SSHClient() worker.load_system_host_keys() worker.set_missing_host_key_policy(AutoAddPolicy()) # store data for later reference worker.host = host.hostname worker.username = host.username worker.password = host.password worker.key_filename = host.key_filename worker.connect(hostname=host.hostname, username=host.username, password=host.password, key_filename=host.key_filename, sock=proxy) return worker
class Host: def __init__(self, name): self.name = name self.ip = None self.ssh_pkey = None self._ssh = None def __str__(self): return self.name def transport(self): """Returns the ssh transport for this host.""" if self._ssh == None: self._ssh = SSHClient() # import keys using paramikos method self._ssh.load_system_host_keys() # import openssh system host keys host_keys_file = '/etc/ssh/ssh_known_hosts' if os.path.exists(host_keys_file): self._ssh.load_system_host_keys(host_keys_file) # import saved host keys from/for multiapt host_keys_file = os.getenv('HOME', '/') + '/.ssh/known_hosts_multiapt' if os.path.exists(host_keys_file): self._ssh.load_host_keys(host_keys_file) # now set our own filename for key save purposes self._ssh._host_keys_filename = host_keys_file # enable our own policy for host key problems self._ssh.set_missing_host_key_policy(SSHAskHostKeyPolicy()) if Main.debug: print 'D: ssh.connect()' self._ssh.connect(self.ip, username=config.remote_username, pkey=self.ssh_pkey) return self._ssh
def run(self): if self.GITHUB_TOKEN is None: logging.critical('No github OAuth token defined in the GITHUB_TOKEN env variable') sys.exit(1) if self.SSH_PKEY is None: logging.critical('SSH_KEY not configured, please set it to you private SSH key file') sys.exit(1) github = Github(self.GITHUB_TOKEN) ssh = SSHClient() ssh.load_system_host_keys() ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) self.SSH_PKEY = os.path.expanduser(self.SSH_PKEY) orga = github.get_organization('nuxeo') # type: Organization repo = orga.get_repo('nuxeo.com') # type: Repository opened_pulls = [('/var/www/nuxeo.com/pr-%d.' % pull.number) + self.PREVIEW_DOMAIN for pull in repo.get_pulls()] try: proxy = ProxyCommand(('ssh -i %s -W 10.10.0.63:22 ' % self.SSH_PKEY) + self.BASTION_IP) ssh.connect('10.10.0.63', username='******', sock=proxy, key_filename=self.SSH_PKEY) _, stdout, _ = ssh.exec_command('ls -d /var/www/nuxeo.com/pr-*') [ssh.exec_command('rm -rf ' + line.strip()) for line in stdout.readlines() if line.strip() not in opened_pulls] ssh.close() except SSHException, e: logging.critical('Could work on remote: %s', e) sys.exit(1)
def create_new_connection(self, index): """Attempts to create a new SSHThread object at the given index""" # Spawns a paramiko SSHClient ssh_client = SSHClient() ssh_client.load_system_host_keys() ssh_client.set_missing_host_key_policy(AutoAddPolicy()) # We loop until we can make a connection while True: # Get the next ssh connection name (hostname) to attempt ssh_name = next(self.ssh_gen) # Ignore if we already have a connection with this computer if ssh_name in self.active_connections: continue # Try the connection and continue on a fail try: ssh_client.connect(ssh_name, timeout=TIMEOUT, port=PORT) except Exception as e: #print(e) time.sleep(0.1) continue # Store connection in array and add hostname to set self.ssh_threads[index] = SSHThread(ssh_client, self.command, ssh_name, self.print_finish) self.active_connections.add(ssh_name) print("Connection made with %s." % ssh_name) break
class RemoteClient(object): def __init__(self, host, ip=None, user='******'): self.host = host self.ip = ip self.user = user self.client = SSHClient() self.sftpclient = None self.client.set_missing_host_key_policy(AutoAddPolicy()) self.client.load_system_host_keys() logging.debug("RemoteClient created for host: %s", host) def startup(self): try: logging.debug("Trying to connect to remote server %s", self.host) self.client.connect(self.host, port=22, username=self.user) self.sftpclient = self.client.open_sftp() except PasswordRequiredException: raise ClientNotSetupException('Pubkey is encrypted.') except SSHException as e: raise ClientNotSetupException(e) except: if self.ip: logging.warning("Connection with hostname failed. Retrying " "with IP") self._try_with_ip() else: logging.error("Connection to %s failed.", self.host) raise ClientNotSetupException('Could not connect to the host.') def _try_with_ip(self): try: logging.debug("Connecting to IP:%s User:%s", self.ip, self.user) self.client.connect(self.ip, port=22, username=self.user) self.sftpclient = self.client.open_sftp() except PasswordRequiredException: raise ClientNotSetupException('Pubkey is encrypted.') except SSHException as e: raise ClientNotSetupException(e) except socket.error: logging.error("Connection with IP (%s) failed.", self.ip) raise ClientNotSetupException('Could not connect to the host.') def run(self, command): if not self.client: raise ClientNotSetupException( 'Cannot run procedure. Client not initialized') buffers = self.client.exec_command(command) output = [] for buf in buffers: try: output.append(buf.read()) except IOError: output.append('') return tuple(output)
def _get_ssh_connection(self): """Returns an ssh connection to the specified host""" _timeout = True ssh = SSHClient() ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) _start_time = time.time() saved_exception = exceptions.StandardError() #doing this because the log file fills up with these messages #this way it only logs it once log_attempted = False socket_error_logged = False auth_error_logged = False ssh_error_logged = False while not self._is_timed_out(self.timeout, _start_time): try: if not log_attempted: self._log.debug('Attempting to SSH connect to: ') self._log.debug('host: %s, username: %s, password: %s' % (self.host, self.username, self.password)) log_attempted = True ssh.connect(hostname=self.host, username=self.username, password=self.password, timeout=20, key_filename=[], look_for_keys=False, allow_agent=False) _timeout = False break except socket.error as e: if not socket_error_logged: self._log.error('Socket Error: %s' % str(e)) socket_error_logged = True saved_exception = e continue except paramiko.AuthenticationException as e: if not auth_error_logged: self._log.error('Auth Exception: %s' % str(e)) auth_error_logged = True saved_exception = e time.sleep(2) continue except paramiko.SSHException as e: if not ssh_error_logged: self._log.error('SSH Exception: %s' % str(e)) ssh_error_logged = True saved_exception = e time.sleep(2) continue #Wait 2 seconds otherwise time.sleep(2) if _timeout: self._log.error('SSHConnector timed out while trying to establish a connection') raise saved_exception #This MUST be done because the transport gets garbage collected if it #is not done here, which causes the connection to close on invoke_shell #which is needed for exec_shell_command ResourceManager.register(self, ssh.get_transport()) return ssh
class MySshClient(): def __init__(self): self.config = configparser.ConfigParser() self.filename = os.path.join(os.path.dirname(__file__), args.filename).replace("\\", "/") self.config.read(self.filename) self.ssh_client = SSHClient() self.shell = None # 此函数用于输入用户名密码登录主机 def ssh_login(self): try: # 设置允许连接known_hosts文件中的主机(默认连接不在known_hosts文件中的主机会拒绝连接抛出SSHException) self.ssh_client.set_missing_host_key_policy(AutoAddPolicy()) self.ssh_client.connect(hostname=self.config.get('ssh', 'host'), port=self.config.get('ssh', 'port'), username=self.config.get('ssh', 'username'), password=self.config.get('ssh', 'password')) except AuthenticationException: logging.warning('username or password error') return False except NoValidConnectionsError: logging.warning('connect time out') return False except: logging.warning('unknow error') print("Unexpected error:", sys.exc_info()[0]) return False return True # 此函数用于执行command参数中的命令并打印命令执行结果 def execute_some_command(self,command): try: stdin, stdout, stderr = self.ssh_client.exec_command(command) readlines = stdout.readlines() str1 = stdout.read().decode() for line in readlines: print(line) except Exception as e: logging.error(str(e)) def multi_run_comment(self, command_list): if not self.shell: self.shell = self.ssh_client.invoke_shell() try: for cmd in command_list: print("do cmd", cmd) self.shell.send(cmd + '\n') time.sleep(0.8) recved_buff = self.shell.recv(1024) print('recved_buff', recved_buff) except Exception as e: logging.error(str(e)) # 此函数用于退出登录 def ssh_logout(self): logging.warning('will exit host') self.ssh_client.close()
class MySshClient(): def __init__(self): self.ssh_client = SSHClient() # 此函数用于输入用户名密码登录主机 def ssh_login(self, host_ip, username, password): try: # 设置允许连接known_hosts文件中的主机(默认连接不在known_hosts文件中的主机会拒绝连接抛出SSHException) self.ssh_client.set_missing_host_key_policy(AutoAddPolicy()) self.ssh_client.connect(host_ip, port=22, username=username, password=password) except AuthenticationException: logging.warning('username or password error') return 1001 except NoValidConnectionsError: logging.warning('connect time out') return 1002 except: logging.warning('unknow error') print("Unexpected error:", sys.exc_info()[0]) return 1003 return 1000 # 此函数用于执行command参数中的命令并打印命令执行结果 def execute_some_command(self, command): stdin, stdout, stderr = self.ssh_client.exec_command(command) res=stdout.read().decode() print(res) return res # 此函数用于退出登录 def ssh_logout(self): logging.warning('will exit host') self.ssh_client.close()
def unsafe_connect(): client = SSHClient() client.set_missing_host_key_policy(AutoAddPolicy) client.connect("example.com") # ... interaction with server client.close()
def _remote(self): client = SSHClient() client.load_system_host_keys() client.connect(hostname=self.host, port=self.port, username=self.username, password=self.password) return client
def connect_ssh(dns_name, identity_file): ''' ''' client = SSHClient() client.set_missing_host_key_policy(AutoAddPolicy()) client.connect(dns_name, username='******', key_filename=identity_file) return client
def verify(self): client = SSHClient() client.set_missing_host_key_policy(self) client.connect( self.host, username=self.username, password=self.password, )
def ssh_client(*args, **kwargs): client = SSHClient() try: client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) client.connect(*args, **kwargs) except Exception, e: logger.warn("Could not connect to remote host.") logger.exception(e) raise e
def timecheck(h): cmd = "sudo sysctl -w net.core.somaxconn=16000;" s = SSHClient() print "> %s" % (h,) s.set_missing_host_key_policy(AutoAddPolicy()) s.connect(hostname=h[1], username=h[0])#, password='') (_in, _out, _err) = s.exec_command( cmd, bufsize=4096) print "< %s" % (h,) return (h,_out.read())
class Context(object): def __init__(self, hostname, username, password, xml=False): self.hostname = hostname self.username = username self.password = password self.xml = xml self.ssh_client = SSHClient() self.ssh_client.set_missing_host_key_policy(AutoAddPolicy()) self.ssh_client.connect(self.hostname, username=self.username, password=self.password)
def timecheck(h): cmd = "date +%s" s = SSHClient() print "> %s" % (h,) s.set_missing_host_key_policy(AutoAddPolicy()) s.connect(hostname=h[1], username=h[0]) (_in, _out, _err) = s.exec_command( cmd, bufsize=4096) print "< %s" % (h,) return (h,_out.read())
def _exec_ssh_cmd(self, cmdline): client = SSHClient() client.set_missing_host_key_policy(AutoAddPolicy()) client.connect(self.droplet_ip, username='******', key_filename=self.ssh_key_path) stdin, stdout, stderr = client.exec_command(cmdline) for line in stdout: logging.info(line) for line in stderr: logging.info(line)
def __create_ssh_client(self): sshclient = SSHClient() sshclient.set_missing_host_key_policy(paramiko.AutoAddPolicy()) for i in range(1, MAX_WAIT_FOR_LOOPS): try: sshclient.connect(hostname=self.hostname, port=22, username=self.login_user, password=self.login_password, timeout=SLEEP_TIMEOUT) return sshclient except socket.error: # no route to host is expected here at first time.sleep(SLEEP_TIMEOUT)
def install_kinto_remotely(id_alwaysdata, credentials, ssh_host, prefixed_username, status_handler): logs = StringIO() # SSH Login ssh = SSHClient() ssh.set_missing_host_key_policy(AutoAddPolicy()) ssh.connect(ssh_host, username=prefixed_username, password=credentials[1], look_for_keys=False) # Install pip retry = 30 error = None while retry > 0: try: stdin, stdout, stderr = ssh.exec_command( "PYTHONPATH=~/.local/ easy_install-2.6 --install-dir=~/.local -U pip" ) retry = 0 except ssh_exception.AuthenticationException as e: error = e sleep(5) retry -= 1 if retry == 0 and error is not None: logs.write(error) logs.write(stdout.read()) logs.write(stderr.read()) status_handler.ssh_logs = logs # Install virtualenv stdin, stdout, stderr = ssh.exec_command( "PYTHONPATH=~/.local/ ~/.local/pip install --user --no-binary --upgrade " "setuptools virtualenv virtualenvwrapper" ) logs.write(stdout.read()) logs.write(stderr.read()) status_handler.ssh_logs = logs # Create virtualenv stdin, stdout, stderr = ssh.exec_command("~/.local/bin/virtualenv kinto/venv/ --python=python2.7") logs.write(stdout.read()) logs.write(stderr.read()) status_handler.ssh_logs = logs # Install Kinto in the virtualenv stdin, stdout, stderr = ssh.exec_command("kinto/venv/bin/pip install kinto[postgresql] kinto-attachment flup") logs.write(stdout.read()) logs.write(stderr.read()) status_handler.ssh_logs = logs # Run kinto migration to setup the database. stdin, stdout, stderr = ssh.exec_command("kinto/venv/bin/kinto --ini kinto/kinto.ini migrate") logs.write(stdout.read()) logs.write(stderr.read()) status_handler.ssh_logs = logs ssh.close()
def run(self, project): if not self.vm.start_VM(): return -1, '' if not os.path.exists(os.path.join(project.tempdir, project.target)): raise FileNotFoundError('Error: Executable file has not been created!') copy_to_vm = [os.path.join(project.tempdir, project.target)] copy_from_vm = ['CUnitAutomated-Results.xml'] print('Connecting to remote machine...') client = SSHClient() client.set_missing_host_key_policy(AutoAddPolicy()) client.load_system_host_keys() client.connect(self.host, username=self.username, password=self.password, timeout=10) return_code = 0 data = '' with client.open_sftp() as sftp: try: self.rmtree(sftp, self.remote_path) except FileNotFoundError: pass try: sftp.mkdir(self.remote_path) except OSError: pass for f in copy_to_vm: remote_file = os.path.join(self.remote_path, os.path.basename(f)) sftp.put(f, remote_file) sftp.chmod(remote_file, 0o777) stdin, stdout, stderr = client.exec_command('cd {}; timeout {}s {}'.format(self.remote_path, self.timeout, remote_file)) return_code = stdout.channel.recv_exit_status() print('[Remote] Error code: {}'.format(return_code)) stdout_string = '[Remote] ' + ''.join(stdout) if stdout_string: print('[Remote] STDOUT:') print(stdout_string) stderr_string = '[Remote] ' + ''.join(stderr) if stderr_string: print('[Remote] STDERR:') print(stderr_string) for f in copy_from_vm: # get all result files remote_file = os.path.join(self.remote_path, os.path.basename(f)) try: with tempfile.TemporaryFile() as local_file: sftp.getfo(remote_file, local_file) local_file.seek(0) data = local_file.read() except FileNotFoundError: print('Remote file not found!') # delete all files in home directory self.rmtree(sftp, self.remote_path) client.close() if self.shutdown_vm_after: self.vm.stop_VM() return return_code, data
def createClient(host, username=None, pkeyPath=None): """ Creates an SSH client object that can be used to perform SSH-related operations """ client = SSHClient() client.set_missing_host_key_policy(AutoAddPolicy()) pkey = RSAKey.from_private_key_file(os.path.expanduser(pkeyPath)) if pkeyPath else None client.connect(host, username=username, pkey=pkey) return client
def newSshClient(hostname, username="******", localPrivKey=None, timeout=None): from paramiko.client import SSHClient, AutoAddPolicy localPrivKey = localPrivKey or loadRsaPrivKey() missingHostKeyPolicy = AutoAddPolicy() ssh = SSHClient() ssh.set_missing_host_key_policy(missingHostKeyPolicy) ssh.connect(hostname, username=username, pkey=localPrivKey, timeout=timeout) return ssh
def _connect(self): client = SSHClient() client.load_system_host_keys() client.set_missing_host_key_policy(AutoAddPolicy()) try: client.connect(hostname=self.host, port=self.port, username=self.user, password=self.passwd, timeout=3) self.closed = False return client except AuthenticationException, e: return e
def _exec_ssh_cmd(self, cmdline): pkey_buf = StringIO(self.state.pkey) client = SSHClient() client.set_missing_host_key_policy(AutoAddPolicy()) client.connect(self.droplet_ip, username='******', pkey=RSAKey.from_private_key(pkey_buf)) stdin, stdout, stderr = client.exec_command(cmdline) for line in stdout: logging.info(line) for line in stderr: logging.info(line)
def ssh_instance_pass(step, instance_name, password): out = bash('ssh %s -A -f -L 11112:%s:22 root@%s -N' % (SSH_OPTS, world.instances[instance_name]['ip'], config['cloud']['master'])) if out.successful(): from paramiko.client import SSHClient client = SSHClient() client.load_system_host_keys() client.connect('localhost', username='******', password=password, port=11112) #stdin, stdout, stderr = client.exec_command('hostname') client.exec_command('hostname') print 'done' client.close()
def test_credentials(hostname, username, password, port): """ Returns True if the credentials work """ client = SSHClient() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) try: client.connect(hostname, username=username, password=password, port=port) return True except Exception as e: print(e) return False
class datastore_sftp(datastore): """ collect of independent functions, not really a Class """ def __init__(self): # Remote path for saving all resources self.base_folder = settings.SFTP_DATASTORE_REMOTEBASEFOLDER # Local base folder for saving temporary files before upload self.tmp_folder = settings.SFTP_DATASTORE_LOCALTMPFOLDER # url for donwloading resources self.public_base_url = settings.SFTP_BASE_URL self.buckets = [] self.connection = None self.ssh_client = SSHClient() self.ssh_client.set_missing_host_key_policy(AutoAddPolicy()) self.ssh_client.load_system_host_keys() self.sftp = None def connect(self): """ don't use at INIT because it hangs all application""" logger = logging.getLogger(__name__) logger.error('Connecting SFTP %s:%s (%s, %s)' %( settings.SFTP_DATASTORE_HOSTNAME, settings.SFTP_DATASTORE_PORT, settings.SFTP_DATASTORE_USER, settings.SFTP_DATASTORE_PASSWORD) ) # TODO: Remove con = sftp.Connection( host=settings.SFTP_DATASTORE_HOSTNAME, port=settings.SFTP_DATASTORE_PORT, username=settings.SFTP_DATASTORE_USER, password=settings.SFTP_DATASTORE_PASSWORD, log=True ) self.connection = con # self.ssh_client.connect( settings.SFTP_DATASTORE_HOSTNAME, port=settings.SFTP_DATASTORE_PORT, username=settings.SFTP_DATASTORE_USER, password=settings.SFTP_DATASTORE_PASSWORD ) self.sftp = self.ssh_client.open_sftp() # list all buckets (folders) try: self.buckets = self.sftp.listdir(path=self.base_folder) logger.error('Buckets: %s' %str(self.buckets)) except Exception, e: logger.error('Error Connecting SFTP %s' % str(e)) self.sftp.close()
def test_keyfile(hostname, username, key_filename, port=22, timeout=15): """ Tests if a key file works """ client = SSHClient() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) try: client.connect( hostname, port=port, username=username, key_filename=key_filename, timeout=10) return True except Exception as e: print(e) return False
class Shared(object): def __init__(self, args): self.args = args self.client = Client( 'http://{0}{1}'.format(self.args.address, ':{0}'.format(self.args.port) if self.args.port else ''), '/api/v2.0/', username=self.args.username, password=self.args.password, ) self.ssh_client = SSHClient() self.ssh_client.set_missing_host_key_policy(AutoAddPolicy()) self.ssh_client.connect(args.address, port=args.sshport, username=args.username, password=args.password)
def recvr(h): s = SSHClient() print "> %s" % (h,) s.set_missing_host_key_policy(AutoAddPolicy()) s.connect(hostname=h[1], username=h[0]) (_in, _out, _err) = s.exec_command(client_cmd, bufsize=4096) _in.write(bytecode) _in.flush() print "< %s" % (h,) err = _err.read() if(err): print err return (h,_out.read())
def executar_comando_remoto(com): hosts = ["192.168.0.2"] ssh = SSHClient() ssh.load_system_host_keys() ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) for h in hosts: try: ssh.connect(h) stdin,stdout,stderr = ssh.exec_command(com) if stderr.channel.recv_exit_status() != 0: print stderr.read() else: print stdout.read() except Exception as e: print "Nao conseguiu conectar ao servidor %s"%e
def configure_cfme(ipaddr, ssh_username, ssh_password, region, db_password): cmd = "appliance_console_cli --region %s --internal --force-key -p %s" % (region, db_password) client = SSHClient() try: client.set_missing_host_key_policy(AutoAddPolicy()) client.connect(ipaddr, username=ssh_username, password=ssh_password, allow_agent=False) print "Will run below command on host: %s" % (ipaddr) print cmd stdin, stdout, stderr = client.exec_command(cmd) status = stdout.channel.recv_exit_status() out = stdout.readlines() err = stderr.readlines() return status, out, err finally: client.close()
class SshOps: def __init__(self): self.client = SSHClient() self.client.load_system_host_keys() self.client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) config = ConfigParser.ConfigParser() config.read("/home/forlinux/www/4803-Python/ProjetoDexter/config.cfg") self.client.connect(config.get("docker","address")) def runCommand(self,command): stdin,stdout,stderr = self.client.exec_command(command) if stderr.channel.recv_exit_status() != 0: return {"status":1,"message":stderr.read()} else: return {"status":0,"message":stdout.read()}
def stop_instance(instance): try: stop_script_location = instance.tags['stop_script'] except KeyError: stop_script_location = '~/shutdown.sh' client = SSHClient() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) client.load_system_host_keys() client.connect(instance.ip_address, username="******") stdin, stdout, stderr = client.exec_command('%s "%s" "%s"' % (stop_script_location, app.config["API_KEY"], app.config["MY_URL"] + "/api/v1/stats")) try: for s in [stdin, stdout, stderr]: app.logger.info(s.read()) except IOError: pass client.close()