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 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_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 report(self): ''' Get instance and connection info for all enabled projects. ''' client = SSHClient() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) client.connect(env['OS_SSH_HOST'], username=env['OS_SSH_USERNAME'], password=env['OS_SSH_PASSWORD']) for project in self.project_list: if not eval(project[2]) or project[1] in ('admin', 'services'): continue ttys = [] stdin, stdout, stderr = client.exec_command('source /etc/nova/openrc && nova list --tenant %s'%project[0]) output = stdout.read() serverlist = filter(lambda x: x.count(project[0]), output.splitlines()).__len__() stdin, stdout, stderr = client.exec_command('source /etc/nova/openrc && neutron floatingip-list --tenant-id %s -F floating_ip_address'%project[0]) floatingips = re.findall('\d+\.\d+\.\d+\.\d+', stdout.read()) print "====INFO====", project[1], project[2], project[0], serverlist, floatingips ttys = [] for ip in floatingips: if not self.ping_ip_reachable(ip): continue sshp = SshconnectionProcess(ip) sshp.run() ttys += sshp.return_result() self.report_result.append({project[1].encode('ascii'): \ {'instance':serverlist, 'connection':ttys.__len__(), 'enable': eval(project[2]), \ 'tenant_id':project[0].encode('ascii'), 'floatingips':floatingips}}) client.close()
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 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
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()
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()
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()
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()
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 PRISMASSHClient: def __init__(self, address, user=None, passwd=None): self.client = SSHClient() self.client.set_missing_host_key_policy(AutoAddPolicy()) self.client.load_system_host_keys() if user is None: self.client.connect(address) else: if passwd is not None: self.client.connect(address, username=user, password=passwd) else: self.client.connect(address, username=user) def close(self): self.client.close() def list_from_directory(self, directory): stdin, stdout, stderr = self.client.exec_command("ls " + directory) result = stdout.read().splitlines() return result def download_file(self, remote_filepath, local_filepath): sftp = self.client.open_sftp() sftp.get(remote_filepath, local_filepath) sftp.close() def size_of_file(self, remote_filepath): sftp = self.client.open_sftp() stat = sftp.stat(remote_filepath) sftp.close() return stat.st_size
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})
def unsafe_connect(): client = SSHClient() client.set_missing_host_key_policy(AutoAddPolicy) client.connect("example.com") # ... interaction with server client.close()
class TransferAgent(object): def __init__(self): self.client = SSHClient() self.client.load_system_host_keys() self.sftp_client = None def load_host_keys(self, filepath): self.client.load_host_keys(filepath) def connect(self, host, username=None, port=22, private_key_file=None): self.client.connect(host, username=username, port=port, key_filename=private_key_file) self.sftp_client = self.client.open_sftp() return self def close(self): self.sftp_client.close() self.client.close() def dest_file_exists(self, destpath): try: self.sftp_client.stat(destpath) except: return False return True def transfer(self, srcpath, destdir, callback=None, randomize=True, name_length=7, max_attempts=4): if not randomize: destpath = self.transform_path(srcpath, destdir) return self.do_transfer(srcpath, destpath, callback=callback) for _ in range(max_attempts): name = generate_random_name(name_length) destpath = self.transform_path(srcpath, destdir, rename=name) if self.dest_file_exists(destpath): continue return self.do_transfer(srcpath, destpath, callback=callback) raise TransferError("Exceeded max transfer attempts") def do_transfer(self, src, dest, callback=None): self.sftp_client.put(src, dest, callback=callback) return dest def transform_path(self, srcpath, destdir, rename=None): basename = os.path.basename(srcpath) _, ext = os.path.splitext(basename) if rename: basename = rename + ext return posixpath.join(destdir, basename)
def ssh_client(host): client = SSHClient() # client.load_system_host_keys() client.set_missing_host_key_policy(WarningPolicy) try: client.connect(host, username="******") yield client finally: client.close()
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 keystone_project_list(self): ''' command: openstack project list, keystone tenant-list(deprecated) ''' client = SSHClient() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) client.connect(env['OS_SSH_HOST'], username=env['OS_SSH_USERNAME'], password=env['OS_SSH_PASSWORD']) stdin, stdout, stderr = client.exec_command('source /etc/nova/openrc && openstack project list --long') output = stdout.read() self.project_list = re.findall('(\w{32})\s+\|\s+([\w-]+)\s+\|\s+[\w\t]*\s+\|\s+(True|False)\s+\|', output) client.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 neutront_floating_ip_list(self): ''' command: neutron floatingip-list [--show-details], neutron floatingip-show FLOATINGIP_ID ''' client = SSHClient() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) client.connect(env['OS_SSH_HOST'], username=env['OS_SSH_USERNAME'], password=env['OS_SSH_PASSWORD']) stdin, stdout, stderr = client.exec_command('source /etc/nova/openrc && neutron floatingip-list') output = stdout.read() self.floating_ips = re.findall('([\w-]+)\s+\|\s+([\d.]+)\s+\|\s+([\d.]+)\s+\|\s+([\w-]+)', output) client.close()
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 place_code_on_workers(): client = SSHClient() client.load_system_host_keys() for worker in worker_list.keys(): client.connect(worker, username=USERNAME) scp = SCPClient(client.get_transport()) scp.put(['worker.py'], remote_path='/home/{}/'.format(USERNAME)) print("{color}[{}] {}{end_color}".format( worker, "Copied worker.py", color=worker_list[worker]['text_color'], end_color=Colors.ENDC)) client.close()
def ssh_ping(hostname, port): ssh_client = SSHClient() ssh_client.set_missing_host_key_policy(AutoAddPolicy) try: ssh_client.connect(hostname, port=port, username='******', pkey=RSAKey.from_private_key( StringIO(Setting.ssh_private_key))) except AuthenticationException: return False ssh_client.close() return True
def fetch_moosefs_drive_content(self, remote_host_ip: str) -> dict: # A sample result dictionary # result_dict = { # 'files': ['temp_file101', 'temp_file102'], # 'cotent': [file 1 content here', 'file 2 content here' ] # } try: result_dict = dict() result_dict['files'] = list() result_dict['content'] = list() mfsClientVM = SSHClient() mfsClientVM.set_missing_host_key_policy(paramiko.AutoAddPolicy()) mfsClientVM.load_system_host_keys() mfsClientVM.connect(hostname=remote_host_ip, username=self.remote_host_username) print("Fetching file and its content on VM with IP: " + remote_host_ip) # Fetch file name on client VM stdin, stdout, stderr = mfsClientVM.exec_command( 'cd /mnt/mfs/; ls') outlines = stdout.readlines() stdin.close() file_name = ''.join(outlines) file_name = str(file_name).rstrip('\n') result_dict['files'].append(file_name) print('File name is: ' + file_name) # Fetch file content on client VM stdin, stdout, stderr = mfsClientVM.exec_command( 'cd /mnt/mfs/; cat ' + file_name) outlines = stdout.readlines() stdin.close() file_content = ''.join(outlines) file_content = str(file_content).rstrip('\n') result_dict['content'].append(file_content) print('File Content is: ' + file_content) mfsClientVM.close() return result_dict except Exception as e: print( "Something went wrong while fetching the moosefs drive content" ) print("Error Details: " + str(e)) return None
def add_public_key(hostname, port, password): ssh_client = SSHClient() ssh_client.set_missing_host_key_policy(AutoAddPolicy) ssh_client.connect(hostname, port=port, username='******', password=password) try: _, stdout, stderr = ssh_client.exec_command( 'mkdir -p -m 700 /root/.ssh && \ echo %r >> /root/.ssh/authorized_keys && \ chmod 600 /root/.ssh/authorized_keys' % Setting.ssh_public_key) if stdout.channel.recv_exit_status() != 0: raise Exception('Add public key error: ' + ''.join(x for x in stderr)) finally: ssh_client.close()
def start_training(): client_list = [] for worker_name in worker_list.keys(): client = SSHClient() client.load_system_host_keys() client.connect(worker_name, username=USERNAME) channel = client.get_transport().open_session() client_list.append((worker_name, client, channel, {'stdout': "", 'stderr': ""})) for worker_name, client, channel, outs in client_list: channel.exec_command('python3 worker.py') at_least_one_worker_still_running = True while at_least_one_worker_still_running: at_least_one_worker_still_running = False for worker_name, client, channel, outs in client_list: rl, wl, xl = select([channel], [], [], 0.0) if not channel.exit_status_ready(): at_least_one_worker_still_running = True if len(rl) > 0: outs['stdout'] += channel.recv(RECV_BUFFER_SIZE).decode('utf-8') outs['stderr'] += channel.recv_stderr(RECV_BUFFER_SIZE).decode('utf-8') if channel.exit_status_ready(): if len(outs['stdout']) > 0: print("{color}[{}] {}{end_color}".format( worker_name, outs['stdout'], color=worker_list[worker_name]['text_color'], end_color=Colors.ENDC)) outs['stdout'] = "" if len(outs['stderr']) > 0: print("{color}[{}] {}{end_color}".format( worker_name, outs['stderr'], color=worker_list[worker_name]['text_color'], end_color=Colors.ENDC)) outs['stderr'] = "" lines_stdout = outs['stdout'].split("\n") outs['stdout'] = lines_stdout[-1] lines_stderr = outs['stderr'].split("\n") outs['stderr'] = lines_stderr[-1] for line in lines_stdout[:-1]: print("{color}[{}] {}{end_color}".format( worker_name, line, color=worker_list[worker_name]['text_color'], end_color=Colors.ENDC)) for line in lines_stderr[:-1]: print("{color}[{}] {}{end_color}".format( worker_name, line, color=worker_list[worker_name]['warn_color'], end_color=Colors.ENDC)) for worker_name, client, channel, outs in client_list: client.close()
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()
def ssh_connection( instance: Instance, ssh_credentials: SSHCredentials ) -> Iterator[SSHClient]: """Connect to server and yield SSH client.""" _, _, public_ip, ssh_port, _ = instance username, key_filename = ssh_credentials client = SSHClient() client.set_missing_host_key_policy(IgnoreHostKeyPolicy) client.connect( hostname=public_ip, port=ssh_port, username=username, key_filename=key_filename ) yield client client.close()
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()
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 stdin, stdout, stderr = ssh.exec_command( 'PYTHONPATH=~/.local/ easy_install-2.6 --install-dir=~/.local -U pip') 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 _exec_command(command, switch_name=''): if not switch_name: switch_name = [s for s in current_app.config['switches']][0] current_app.logger.info('running on %s: %s' % (switch_name, command)) client = SSHClient() client.set_missing_host_key_policy(AutoAddPolicy()) client.connect(current_app.config['switches'][switch_name]['address'], username=current_app.config['switches'][switch_name]['user'], key_filename=current_app.config['switches'][switch_name]['key']) sin, sout, serr = client.exec_command(command) output = sout.read().decode('ascii') errout = serr.read().decode('ascii') client.close() if errout or 'Cmd exec error' in output: abort(500, "Error executing '%s' on %s" % (command, switch_name)) current_app.logger.info('output from %s: %s' % (switch_name, output)) return output, errout
def configure_secondary_cfme(ipaddr, primary_ip, ssh_username, ssh_password, db_password): cmd = "appliance_console_cli --hostname %s --dbname vmdb_production" \ "--fetch-key %s --username root --password %s --sshpassword %s" \ % (primary_ip, primary_ip, db_password, ssh_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()
def ssh_signup(user): # TODO: configure nodes used for authentication auth_node = next(iter(SSH.AVAILABLE_NODES)) ssh_key = TensorHiveManager().dedicated_ssh_key test_client = SSHClient() test_client.load_system_host_keys() test_client.set_missing_host_key_policy(WarningPolicy()) try: test_client.connect(auth_node, username=user['username'], pkey=ssh_key) except AuthenticationException: return {'msg': G['unpriviliged']}, 403 except (BadHostKeyException, SSHException, socket.error) as e: return 'An error ocurred while authenticating: {}'.format(e), 500 finally: test_client.close() return do_create(user)
def verify_moosefs_drive_content(self, remote_host_ip: str) -> list: # A sample result dictionary # result_dict = { # 'files': ['temp_file101', 'temp_file102'], # 'cotent': [file 1 content here', 'file 2 content here' ] # } try: result_list = list() mfsClientVM = SSHClient() mfsClientVM.set_missing_host_key_policy(paramiko.AutoAddPolicy()) mfsClientVM.load_system_host_keys() # mfsClientVM.connect(hostname=remote_host_ip, # username=self.remote_host_username, # key_filename='cs6620Key101.pem') mfsClientVM.connect(hostname=remote_host_ip, username=self.remote_host_username) print("Verifying file content on VM with IP: " + remote_host_ip) # Count Bs in file on client VM stdin, stdout, stderr = mfsClientVM.exec_command( 'cd /mnt/mfs/test7; grep -c "B" testfile.txt') outlines = stdout.readlines() stdin.close() count = ''.join(outlines) # count = int(count) result_list.append(count) print('File contains ' + count + ' Bs') mfsClientVM.close() return result_list except Exception as e: print( "Something went wrong while verifying the moosefs drive content" ) print("Error Details: " + str(e)) return None
def run_command(self, command_str): """ Uses paramiko ssh client to execute `command_str` on this remote Instance. Args: command_str (str): The remote shell command to execute. """ ssh_client = SSHClient() ssh_client.set_missing_host_key_policy(AutoAddPolicy) print("Connecting to %s:%i " % (self.ssh_host, self.ssh_port)) try: ssh_client.connect(self.ssh_host, port=int(self.ssh_port), username='******', key_filename=self.client._get_ssh_key_file()) print("Running command '%s'" % command_str) stdin, stdout, stderr = ssh_client.exec_command(command_str) print(stdout.read().decode('utf-8')) print(stderr.read().decode('utf-8')) # except NoValidConnectionsError as err: # raise InstanceError(self.id, err.errors) finally: ssh_client.close()
class RemoteSession(): def __init__(self, ip, username=REMOTE_USER): self.username = username self.client = SSHClient() self.client.set_missing_host_key_policy(IgnoreHostKeyPolicy) self.client.connect(ip, username=self.username) self.sftp = self.client.open_sftp() def execute(self, command): stdin, stdout, stderr = self.client.exec_command(command) rc = stdout.channel.recv_exit_status() out = stdout.read().decode('utf-8').splitlines() err = stderr.read().decode('utf-8').splitlines() if rc != 0 and not quiet: log = logging.getLogger('TPCH') log.error("ssh command returned %d" % rc) log.error("ssh -l %s %s %s" % (self.username, ip, command)) print(command) for line in out: print(line) for line in err: print(line) print() return def download(self, src, dst): self.sftp.get(src, dst) return def close(self): self.client.close()
def efact_check_history(self): efact = self.env.ref("l10n_es_facturae_efact.efact_backend") ICP = self.env["ir.config_parameter"].sudo() connection = SSHClient() connection.load_system_host_keys() connection.connect( ICP.get_param("account.invoice.efact.server", default=None), port=int(ICP.get_param("account.invoice.efact.port", default=None)), username=ICP.get_param("account.invoice.efact.user", default=None), password=ICP.get_param("account.invoice.efact.password", default=None), ) sftp = connection.open_sftp() path = sftp.normalize(".") sftp.chdir(path + statout_path) attrs = sftp.listdir_attr(".") attrs.sort(key=lambda attr: attr.st_atime) to_remove = [] for attr in attrs: file = sftp.open(attr.filename) datas = file.read() file.close() update_record = efact.create_record( "l10n_es_facturae_efact_update", { "edi_exchange_state": "input_received", "exchange_filename": attr.filename, }, ) update_record._set_file_content(datas) efact.with_delay().exchange_process(update_record) to_remove.append(attr.filename) for filename in to_remove: sftp.remove(filename) sftp.close() connection.close()
class SSH(AbstractFs): policy = AutoAddPolicy recv_size = 1024 _ssh = None _basepath = "/" def __init__(self, host, username="******", basepath=None): logger.debug("Creating SSH client") self._ssh = SSHClient() self._ssh.load_system_host_keys() logger.debug("Setting %s for missing host keys", self.policy.__name__) self._ssh.set_missing_host_key_policy(self.policy) logger.info( "Connecting to %s%s%s", "{}@".format(username) or "", host, ":{}".format(basepath) or "", ) self._ssh.connect(host, username=username, compress="true") if basepath: logger.info("Use basepath %s", basepath) self._basepath = basepath def _collect_stream(self, channel, recv_fn): content = "" buffer = None while True: buffer = recv_fn(self.recv_size) content += buffer.decode("utf-8") if len(buffer) == 0: break return content def _exec(self, cmd, log_error=True): channel = self._ssh.get_transport().open_session() channel.exec_command(cmd) stdout = self._collect_stream(channel, channel.recv) stderr = self._collect_stream(channel, channel.recv_stderr) exit_code = channel.recv_exit_status() logger.debug(stdout) if exit_code != 0 and log_error: logger.error(stderr) logger.error("Command %s failed with exit code %s", cmd, exit_code) return exit_code, stdout, stderr def touch(self, filename): logger.debug("Touching file %s", filename) self._exec('touch "{}"'.format(filename)) def rename(self, remote_src, remote_dest): logger.debug("Renaming %s into %s", remote_src, remote_dest) exit_code, _, _ = self._exec('mv "{}" "{}"'.format(remote_src, remote_dest)) if exit_code != 0: raise SSHError("Failed renaming {} into {}".format(remote_src, remote_dest)) def exists(self, path): logger.debug("Checking if %s exists...", path) exit_code, _, _ = self._exec('test -f "{}"'.format(path), log_error=False) exists = exit_code == 0 logger.debug("File %s does%s exists.", path, "" if exists else " not") return exists def copy(self, remote_src, local_dst): exit_code, remote_content, _ = self._exec('cat "{}"'.format(remote_src)) if exit_code != 0: raise SSHError("Cannot read from %s", remote_src) with open(local_dst, "w") as f: f.write(remote_content) # def remove(self, path): # return os.remove(path) def symlink(self, remote_src, remote_dest, relative_to=None): if relative_to: remote_src = remote_src.replace(relative_to, ".") logger.debug("Symlinking %s to %s", remote_src, remote_dest) exit_code, _, _ = self._exec('ln -sf "{}" "{}"'.format(remote_src, remote_dest)) if exit_code != 0: raise SSHError("Failed symlinking {} to {}".format(remote_src, remote_dest)) def glob(self, remote_path, regex_str): logger.debug("Globbing %s for %s", remote_path, regex_str) exit_code, remote_content, _ = self._exec('ls "{}"'.format(remote_path)) if exit_code != 0: raise SSHError("Failed listing {}".format(remote_path)) regex = re.compile(regex_str) entries = (e for e in remote_content.split() if regex.match(e)) entries = (os.path.join(remote_path, e) for e in entries) return entries def rmtree(self, remote_path): logger.debug("Removing tree %s", remote_path) exit_code, _, _ = self._exec('rm -rf "{}"'.format(remote_path)) if exit_code != 0: raise SSHError("Failed removing {}".format(remote_path)) def close(self): logger.debug("Closing SSH connection...") self._ssh.close() logger.debug("Connection closed.")
class SshClusterConnection(AbstractConnection): def __init__(self, girder_token, cluster): self._girder_token = girder_token self._cluster = cluster def _load_rsa_key(self, path, passphrase): return RSAKey.from_private_key_file(path, password=passphrase) def __enter__(self): self._client = SSHClient() self._client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) username = parse('config.ssh.user').find(self._cluster)[0].value hostname = parse('config.host').find(self._cluster)[0].value passphrase \ = parse('config.ssh.passphrase').find(self._cluster) if passphrase: passphrase = passphrase[0].value else: passphrase = None key_name = parse('config.ssh.key').find(self._cluster)[0].value key_path = os.path.join(cumulus.config.ssh.keyStore, key_name) private_key = self._load_rsa_key(key_path, passphrase) self._client.connect(hostname=hostname, username=username, pkey=private_key) return self def __exit__(self, type, value, traceback): self._client.close() def execute(self, command, ignore_exit_status=False, source_profile=True): if source_profile: command = 'source /etc/profile && %s' % command chan = self._client.get_transport().open_session() chan.exec_command(command) stdout = chan.makefile('r', -1) stderr = chan.makefile_stderr('r', -1) output = stdout.readlines() + stderr.readlines() exit_code = chan.recv_exit_status() if ignore_exit_status and exit_code != 0: raise SshCommandException(command, exit_code, output) return output @contextmanager def get(self, remote_path): sftp = None file = None try: sftp = self._client.get_transport().open_sftp_client() file = sftp.open(remote_path) yield file finally: if file: file.close() sftp.close() def isfile(self, remote_path): with self._client.get_transport().open_sftp_client() as sftp: try: s = sftp.stat(remote_path) except IOError: return False return stat.S_ISDIR(s.st_mode) def mkdir(self, remote_path, ignore_failure=False): with self._client.get_transport().open_sftp_client() as sftp: try: sftp.mkdir(remote_path) except IOError: if not ignore_failure: raise def makedirs(self, remote_path): with self._client.get_transport().open_sftp_client() as sftp: current_path = '' if remote_path[0] == '/': current_path = '/' for path in remote_path.split('/'): if not path: continue current_path = os.path.join(current_path, path) try: sftp.listdir(current_path) except IOError: sftp.mkdir(current_path) def put(self, stream, remote_path): with self._client.get_transport().open_sftp_client() as sftp: sftp.putfo(stream, remote_path) def stat(self, remote_path): with self._client.get_transport().open_sftp_client() as sftp: return sftp.stat(remote_path) def remove(self, remote_path): with self._client.get_transport().open_sftp_client() as sftp: return sftp.remove(remote_path) def list(self, remote_path): with self._client.get_transport().open_sftp_client() as sftp: for path in sftp.listdir_iter(remote_path): yield { 'name': path.filename, 'user': path.st_uid, 'group': path.st_gid, 'mode': path.st_mode, # For now just pass mtime through 'date': path.st_mtime, 'size': path.st_size }
class BaseSSHWrapper(BaseAutoscalingClass): """ A base class, which can connect via SSH to a machine.""" def __init__(self, readableName, address, pemFile=None, password = None, userName="******", timeout=600): """ Constr. @param readableName: A readale description of the machine. Must not be None. @param address: The address of the machine. Must not be None. @param pemFile: The pem file for SSH authentication. @param password: The password for SSH authentication. @param userName: The userName for SSH authentication. Must not be None. @param timeout: The SSH connection timeout. Must not be None. Must be positive. """ super(BaseSSHWrapper, self).__init__(readableName = readableName) assert address is not None, "Address is None" assert userName is not None, "User name is None" assert timeout is not None, "Timeout is None" assert timeout > 0, "Timeout is not positive: " + str(timeout) assert pemFile is None or os.path.isfile(pemFile), "File \"%s\" does not exist" % (pemFile) self.address = address self.password = password self.pemFile = pemFile self.userName = userName self.timeout = timeout log.info("Creating entity \"%s\" at %s", self.readableName, self.address) self.initSSHClient() def initSSHClient(self): """ Tries to establish connection with the host. @raise SSHException: if the connection could not be established. """ self.client = None waitPeriod = 10 attempts = 10 # Try to connect but not more than attempts times for iteration in range(attempts): # If not the first time - sleep a bit. Do not bombard the server with requests if iteration > 0: time.sleep(waitPeriod) # Try establishing ssh client try: self.client = SSHClient() self.client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) if self.pemFile is not None: self.client.connect(self.address, username=self.userName, key_filename=self.pemFile, timeout=self.timeout) else : self.client.connect(self.address, username=self.userName, password=self.password, timeout=self.timeout) break except (SSHException, socket.error) as e: self.client = None log.error("Could not connect to host %s err: %s", self.readableName, str(e)) # If we could not connect several times - throw an exception if self.client == None: raise SSHException('Could not connect ' + str(attempts) + ' times in a row') def getSSHClient(self): """ Retrieves an SSH connection to the machine. @return a connection @raise SSHException: if the connection could not be established. """ if self.client == None: log.warning("SSH connection to %s will be recreated", self.address) self.initSSHClient() return self.client def execRemoteCommand(self, command, asynch=False, recoverFromFailure=True): """ Executes the command on the remove machine. @param command: The command to execute on the remote host. Must not be None. @param asynch: A boolean flag, whether to run the command asynchrounously or not. @param recoverFromFailure: A boolean flag, whether to try to recover if the connection had staled or failed. @return the output of the command (a list of text lines), if it was run synchrounously. @raise SSHException: if a connection could not be established, or the command gave an error. """ assert command is not None, "Command is None" assert asynch is not None, "Asynch is None" assert recoverFromFailure is not None, "recoverFromFailure is None" try: _, stdout, stderr = self.getSSHClient().exec_command(command) output = [] if not asynch: output = stdout.readlines() errors = stderr.readlines() if errors: log.warning("Error messages encountered when connecting to %s, messages: %s", self.address, formatOutput(errors)) return output except (SSHException, socket.error) as e: if recoverFromFailure: # Mark the connection for re-instantiation and try again self.client = None return self.execRemoteCommand(command, asynch, False) else : raise e def close(self): """ Closes the underlying connection. @raise SSHException: if a connection could not be closed. """ if self.client != None: self.client.close() self.client = None def __del__(self): self.close()
def main(): user_config_file = path.join(path.expanduser('~'), '.fernglas.cfg') project_config_file = path.join(getcwd(), '.fernglas.cfg') config = SafeConfigParser() config.read([user_config_file, project_config_file]) servers = {} if not config.has_section('main'): print("No main config found") exit(1) if not config.has_option('main', 'servers'): print("No servers defined") exit(2) server_sections = config.get('main', 'servers').split(',') server_sections = [section.strip() for section in server_sections] for server in server_sections: servers[server] = dict(config.items(server)) if 'port' in servers[server]: servers[server]['port'] = int(servers[server]['port']) issue = sys.argv[1] package = run_setup(path.join(getcwd(), 'setup.py')) package_name = package.get_name() repo = Repo(getcwd()) latest_issue_commit = repo.git.log(all=True, grep=issue, n=1, format='%H') if not latest_issue_commit: print("No commits found for " + issue) exit(3) config = SSHConfig() ssh_config_path = path.expanduser('~/.ssh/config') if path.exists(ssh_config_path): try: config.parse(open(ssh_config_path)) except Exception as e: print("Could not parse ssh config: " + str(e)) client = SSHClient() client.load_system_host_keys() # XXX support ecdsa? client.set_missing_host_key_policy(AutoAddPolicy()) for key, server in servers.items(): host_config = config.lookup(server['hostname']) connect_opts = {} for key_ssh, key_paramiko in SSH_CONFIG_MAPPING.items(): if key_ssh in host_config: connect_opts[key_paramiko] = host_config[key_ssh] connect_opts.update(dict( (opt, servers[key][opt]) for opt in SSH_OPTIONS if opt in servers[key])) client.connect(**connect_opts) stdin, stdout, stderr = client.exec_command('grep {0} {1}'.format( package_name, server['versions-path'])) deployed_version = stdout.read().strip().replace(package_name, '')\ .replace('=', '').strip() version_tags = [tag for tag in repo.tags if tag.name == deployed_version] tag = version_tags[0] version_commit = tag.commit.hexsha status = repo.is_ancestor(latest_issue_commit, version_commit) print("{0} is {2}deployed to {1}".format( issue, key, (not status) and 'not ' or '')) client.close()
class SFTPClient(object): """Dynamic extension on paramiko's SFTPClient.""" MAX_PACKET_SIZE = SFTPFile.__dict__['MAX_REQUEST_SIZE'] ssh_client = None client = None raise_exceptions = False original_arguments = {} debug = False _log = logging.getLogger(LOG_NAME) _dircache = [] def __init__(self, **kwargs): """Constructor.""" self.original_arguments = kwargs.copy() self._connect(**kwargs) def __enter__(self): """For use with a with statement.""" return self def __exit__(self, exc_type, exc_val, exc_tb): """For use with a with statement.""" self.close_all() def _connect(self, **kwargs): kwargs_to_paramiko = dict( look_for_keys=kwargs.pop('look_for_keys', True), username=kwargs.pop('username'), port=kwargs.pop('port', 22), allow_agent=False, timeout=kwargs.pop('timeout', None), ) host = kwargs.pop('hostname', 'localhost') password = kwargs.pop('password') keepalive = kwargs.pop('keepalive', 5) if password: kwargs_to_paramiko['password'] = password self.raise_exceptions = kwargs.pop('raise_exceptions', False) self.ssh_client = SSHClient() self.ssh_client.load_system_host_keys() self.ssh_client.connect(host, **kwargs_to_paramiko) self.client = self.ssh_client.open_sftp() channel = self.client.get_channel() channel.settimeout(kwargs_to_paramiko['timeout']) channel.get_transport().set_keepalive(keepalive) # 'Extend' the SFTPClient class is_reconnect = kwargs.pop('is_reconnect', False) members = inspect.getmembers(self.client, predicate=inspect.ismethod) self._log.debug('Dynamically adding methods from original SFTPClient') for (method_name, method) in members: if method_name[0:2] == '__' or method_name == '_log': self._log.debug('Ignorning {}()'.format(method_name)) continue if not is_reconnect and hasattr(self, method_name): raise AttributeError('Not overwriting property "{}". This ' 'version of Paramiko is not ' 'supported.'.format(method_name)) self._log.debug('Adding method {}()'.format(method_name)) setattr(self, method_name, method) def close_all(self): """Close client and SSH client handles.""" self.client.close() self.ssh_client.close() def clear_directory_cache(self): """Reset directory cache.""" self._dircache = [] def listdir_attr_recurse(self, path='.'): """List directory attributes recursively.""" for da in self.client.listdir_attr(path=path): is_dir = da.st_mode & 0o700 == 0o700 if is_dir: try: for x in self.listdir_attr_recurse( path_join(path, da.filename)): yield x except IOError as e: if self.raise_exceptions: raise e else: yield (path_join(path, da.filename), da,) def _get_callback(self, start_time, _log): def cb(tx_bytes, total_bytes): total_time = datetime.now() - start_time total_time = total_time.total_seconds() total_time_s = floor(total_time) if (total_time_s % LOG_INTERVAL) != 0: return nsize_tx = naturalsize(tx_bytes, binary=True, format='%.2f') nsize_total = naturalsize(total_bytes, binary=True, format='%.2f') speed_in_s = tx_bytes / total_time speed_in_s = naturalsize(speed_in_s, binary=True, format='%.2f') _log.info('Downloaded {} / {} in {} ({}/s)'.format( nsize_tx, nsize_total, naturaldelta(datetime.now() - start_time), speed_in_s, total_time_s)) return cb def mirror(self, path='.', destroot='.', keep_modes=True, keep_times=True, resume=True): """ Mirror a remote directory to a local location. path is the remote directory. destroot must be the location where destroot/path will be created (the path must not already exist). keep_modes and keep_times are boolean to ensure permissions and time are retained respectively. Pass resume=False to disable file resumption. """ n = 0 resume_seek = None cwd = self.getcwd() for _path, info in self.listdir_attr_recurse(path=path): if info.st_mode & 0o700 == 0o700: continue dest_path = path_join(destroot, dirname(_path)) dest = path_join(dest_path, basename(_path)) if dest_path not in self._dircache: try: makedirs(dest_path) except OSError: pass self._dircache.append(dest_path) if isdir(dest): continue try: with open(dest, 'rb'): current_size = os.stat(dest).st_size if current_size != info.st_size: resume_seek = current_size if resume: self._log.info('Resuming file {} at {} ' 'bytes'.format(dest, current_size)) raise IOError() # ugly goto except IOError: while True: try: # Only size is used to determine complete-ness here # Hash verification is in the util module if resume_seek and resume: read_tuples = [] n_reads = ceil((info.st_size - resume_seek) / self.MAX_PACKET_SIZE) - 1 n_left = ((info.st_size - resume_seek) % self.MAX_PACKET_SIZE) offset = 0 for n in range(n_reads): read_tuples.append((resume_seek + offset, self.MAX_PACKET_SIZE,)) offset += self.MAX_PACKET_SIZE read_tuples.append((resume_seek + offset, n_left,)) with self.client.open(_path) as rf: with open(dest, 'ab') as f: f.seek(resume_seek) resume_seek = None for chunk in rf.readv(read_tuples): f.write(chunk) else: dest = realpath(dest) self._log.info('Downloading {} -> ' '{}'.format(_path, dest)) start_time = datetime.now() self.client.get(_path, dest) self._get_callback(start_time, self._log)( info.st_size, info.st_size) # Do not count files that were already downloaded n += 1 break except (socket.timeout, SFTPError) as e: # Resume at position - 10 bytes resume_seek = os.stat(dest).st_size - 10 if isinstance(e, socket.timeout): self._log.error('Connection timed out') else: self._log.error('{!s}'.format(e)) if resume: self._log.info('Resuming GET {} at {} ' 'bytes'.format(_path, resume_seek)) else: self._log.debug('Not resuming (resume = {}, ' 'exception: {})'.format(resume, e)) raise e self._log.debug('Re-establishing connection') self.original_arguments['is_reconnect'] = True self._connect(**self.original_arguments) if cwd: self.chdir(cwd) # Okay to fix existing files even if they are already downloaded try: if keep_modes: chmod(dest, info.st_mode) if keep_times: utime(dest, (info.st_atime, info.st_mtime,)) except IOError: pass return n def __str__(self): """Return string representation.""" return '{} (wrapped by {}.SFTPClient)'.format( str(self.client), __name__) __unicode__ = __str__
from paramiko.client import SSHClient client = SSHClient() client.load_system_host_keys() client.connect(hostname = opt_server, username = opt_username, key_filename = opt_keyfile) output = client.exec_command('ls') print output from scp import SCPClient scp = SCPClient(client.get_transport()) scp.put("ssh.py", "ssh.py") scp.put("scp.py", "scp.py") print client.exec_command('md5sum ssh.py scp.py') client.close() """ The UUID of a task will serve as the filename for all the files associated with the task. As well as the handle for marking/handling the task. A task has these states - TODO (we should verify that the file has been generated, if not, alert) copy the file on WEB01 to OPT01 mark the task as GOING_TO_RUN submit the job as qsub (a shell script with param) (qsub should be able to mark something as READY_TO_MAIL - READY_TO_MAIL copy the file from OPT01 to WEB01 send the email out
ftp.mkd(".local") except ftplib.error_perm: pass try: ftp.mkd("kinto") except ftplib.error_perm: pass try: ftp.storbinary("STOR kinto/kinto.ini", StringIO(config)) except ftplib.error_perm: print("A kinto config already exist.") else: print("A kinto config has been uploaded.") ftp.close() # Install kinto[postgresql] ssh = SSHClient() ssh.set_missing_host_key_policy(AutoAddPolicy()) ssh.connect(settings['ssh_host'], username=settings['prefixed_username'], password=PASSWORD, look_for_keys=False) stdin, stdout, stderr = ssh.exec_command('PYTHONPATH=~/.local/ easy_install-2.6 --install-dir=~/.local -U pip') print(stdout.read(), stderr.read()) stdin, stdout, stderr = ssh.exec_command('PYTHONPATH=~/.local/ ~/.local/pip install --user --no-binary --upgrade setuptools virtualenv virtualenvwrapper') print(stdout.read(), stderr.read()) stdin, stdout, stderr = ssh.exec_command('~/.local/bin/virtualenv kinto/venv/ --python=python2.7') print(stdout.read(), stderr.read()) stdin, stdout, stderr = ssh.exec_command('kinto/venv/bin/pip install kinto cliquet[postgresql]') print(stdout.read(), stderr.read()) ssh.close()