def test_connect_does_not_prompt_password_when_ssh_raises_channel_exception(self): def raise_channel_exception_once(*args, **kwargs): if raise_channel_exception_once.should_raise_channel_exception: raise_channel_exception_once.should_raise_channel_exception = False raise ssh.ChannelException(2, 'Connect failed') raise_channel_exception_once.should_raise_channel_exception = True def generate_fake_client(): fake_client = Fake('SSHClient', allows_any_call=True, expect_call=True) fake_client.provides('connect').calls(raise_channel_exception_once) return fake_client fake_ssh = Fake('ssh', allows_any_call=True) fake_ssh.provides('SSHClient').calls(generate_fake_client) # We need the real exceptions here to preserve the inheritence structure fake_ssh.SSHException = ssh.SSHException fake_ssh.ChannelException = ssh.ChannelException patched_connect = patch_object('fabric.network', 'ssh', fake_ssh) patched_password = patch_object('fabric.network', 'prompt_for_password', Fake('prompt_for_password', callable = True).times_called(0)) try: connect('user', 'localhost', 22, HostConnectionCache()) finally: # Restore ssh patched_connect.restore() patched_password.restore()
def test_connect_does_not_prompt_password_when_ssh_raises_channel_exception( self): def raise_channel_exception_once(*args, **kwargs): if raise_channel_exception_once.should_raise_channel_exception: raise_channel_exception_once.should_raise_channel_exception = False raise ssh.ChannelException(2, 'Connect failed') raise_channel_exception_once.should_raise_channel_exception = True def generate_fake_client(): fake_client = Fake('SSHClient', allows_any_call=True, expect_call=True) fake_client.provides('connect').calls(raise_channel_exception_once) return fake_client fake_ssh = Fake('ssh', allows_any_call=True) fake_ssh.provides('SSHClient').calls(generate_fake_client) # We need the real exceptions here to preserve the inheritence structure fake_ssh.SSHException = ssh.SSHException fake_ssh.ChannelException = ssh.ChannelException patched_connect = patch_object('fabric.network', 'ssh', fake_ssh) patched_password = patch_object( 'fabric.network', 'prompt_for_password', Fake('prompt_for_password', callable=True).times_called(0)) try: connect('user', 'localhost', 22, HostConnectionCache()) finally: # Restore ssh patched_connect.restore() patched_password.restore()
def disconnect(): yield host = env.host_string if host and host in connections: normalized_host = normalize(host) connections[host].get_transport().close() connect(normalized_host[0], normalized_host[1], normalized_host[2], HostConnectionCache())
def fetch_files(file_list): fetch_successes = list() fetch_file_list = list() # determine what's already here for remote_filename in file_list: local_filename = lcu.remote_to_local_filename(remote_filename) if is_file(local_filename): fetch_successes.append(True) else: fetch_file_list.append((remote_filename, local_filename)) if fetch_file_list: fabric_env['key_filename'] = cl_conf.SCP_SECRET_KEYFILE # fetch what isn't already here with closing(fn.connect(cl_conf.SCP_USER, cl_conf.SCP_HOST, cl_conf.SCP_PORT, None)) as ssh: with closing(ssh.open_sftp()) as sftp: for remote_filename, local_filename in fetch_file_list: with closing(sftp.open(remote_filename)) as r_file: with open(local_filename, 'wb') as l_file: logger("Fetching file: {} to: {}".format(remote_filename, local_filename)) try: l_file.write(r_file.read()) fetch_successes.append(True) except IOError: fetch_successes.append(False) return fetch_successes
def wcl(self): with closing( connect(self.user, self.host, self.port, HostConnectionCache())) as ssh: stdin, stdout, stderr = ssh.exec_command('wc -l %s' % self.filename) return int( stdout.readlines()[0].split()[0]) - (1 if self.header else 0)
def wrapper( self, *args, **kwargs ): print 'wrapper' print kwargs with closing( connect( 'cloudmgr', '127.0.0.1', 22 ) ) as ssh: with closing( ssh.open_sftp() ) as sftp: return fct( self, os = sftp, *args, **kwargs )
def rowns(self): with closing( connect(self.user, self.host, self.port, HostConnectionCache())) as ssh: stdin, stdout, stderr = ssh.exec_command( 'awk \'BEGIN{FS="%s"}{print $1}\' %s%s' % (self.sep, self.filename, '' if not self.header else ' | tail -n +2')) return [x.strip() for x in stdout.readlines()]
def __enter__( self ): if self._identified_value.is_locale: modified_os = os modified_os.open = open return modified_os else: self._ssh = connect( 'cloudmgr', self._identified_value.run_on_server, 22 ) self._sftp = self._ssh.open_sftp() return self._sftp
def open(self, return_header=True): with closing( connect(self.user, self.host, self.port, HostConnectionCache())) as ssh: with closing(ssh.open_sftp()) as sftp: with closing(sftp.open(self.filename)) as f: if not return_header: line = f.readline() for line in f: yield line
def __enter__(self): if self._identified_value.is_locale: modified_os = os modified_os.open = open return modified_os else: self._ssh = connect('cloudmgr', self._identified_value.run_on_server, 22) self._sftp = self._ssh.open_sftp() return self._sftp
def get_intraparis_descriptor(cls, user, host, port, filenames_descriptor, d_applis ): """get_intraparis_descriptor(cls, user, host, port, filename_descriptor, callbackprocess ) user : username to remote connection host : hostname for remote connection port : remote port remote connection filenames_descriptor : remote fully qualified filename or list of remote fully qualified filenames """ with closing(connect(user, host, port)) as ssh: with closing(ssh.open_sftp()) as sftp: if filenames_descriptor.__class__==str: filenames_descriptor = [ filenames_descriptor ] for filename_descriptor in filenames_descriptor: with closing(sftp.open( filename_descriptor )) as f: for line in f: IntraparisDescriptorToDict.convert_intraparis_descriptor_feed_dict_from_line( line, d_applis )
def connect(self, key): """ Force a new connection to host string. """ from fabric.state import env user, host, port = normalize(key) key = normalize_to_string(key) seek_gateway = True # break the loop when the host is gateway itself if env.gateway: seek_gateway = normalize_to_string(env.gateway) != key key = normalize_to_string(env.gateway)+'_'+key self[key] = connect( user, host, port, cache=self, seek_gateway=seek_gateway)
def __getitem__(self, key): gw = s.env.get('gateway') if gw is None: return super(GatewayConnectionCache, self).__getitem__(key) gw_user, gw_host, gw_port = network.normalize(gw) if self._gw is None: # Normalize given key (i.e. obtain username and port, if not given) self._gw = network.connect(gw_user, gw_host, gw_port, None, False) # Normalize given key (i.e. obtain username and port, if not given) user, host, port = network.normalize(key) # Recombine for use as a key. real_key = network.join_host_strings(user, host, port) # If not found, create new connection and store it if real_key not in self: self[real_key] = connect_forward(self._gw, host, port, user) # Return the value either way return dict.__getitem__(self, real_key)
def __getitem__(self, key): gw = s.env.get('gateway') if gw is None: return super(GatewayConnectionCache, self).__getitem__(key) gw_user, gw_host, gw_port = network.normalize(gw) if self._gw is None: # Normalize given key (i.e. obtain username and port, if not given) self._gw = network.connect(gw_user, gw_host, gw_port) # Normalize given key (i.e. obtain username and port, if not given) user, host, port = network.normalize(key) # Recombine for use as a key. real_key = network.join_host_strings(user, host, port) # If not found, create new connection and store it if real_key not in self: self[real_key] = connect_forward(self._gw, host, port, user) # Return the value either way return dict.__getitem__(self, real_key)