abstractclient.py

Go to the documentation of this file.

#  Copyright 2008-2015 Nokia Networks
#  Copyright 2016-     Robot Framework Foundation
#
#  Licensed under the Apache License, Version 2.0 (the "License");
#  you may not use this file except in compliance with the License.
#  You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing, software
#  distributed under the License is distributed on an "AS IS" BASIS,
#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#  See the License for the specific language governing permissions and
#  limitations under the License.
 
from fnmatch import fnmatchcase
import os
import re
import stat
import time
import glob
import posixpath
import ntpath
import fnmatch
 
from .config import (Configuration, IntegerEntry, NewlineEntry, StringEntry,
                     TimeEntry)
from .logger import logger
from .utils import is_bytes, is_string, unicode, is_list_like
 
 
class SSHClientException(RuntimeError):
    pass
 
 
class _ClientConfiguration(Configuration):
 
    def __init__(self, host, alias, port, timeout, newline, prompt, term_type,
                 width, height, path_separator, encoding, escape_ansi, encoding_errors):
        super(_ClientConfiguration, self).__init__(
            index=IntegerEntry(None),
            host=StringEntry(host),
            alias=StringEntry(alias),
            port=IntegerEntry(port),
            timeout=TimeEntry(timeout),
            newline=NewlineEntry(newline),
            prompt=StringEntry(prompt),
            term_type=StringEntry(term_type),
            width=IntegerEntry(width),
            height=IntegerEntry(height),
            path_separator=StringEntry(path_separator),
            encoding=StringEntry(encoding),
            escape_ansi=StringEntry(escape_ansi),
            encoding_errors=StringEntry(encoding_errors)
        )
 
 
 
class AbstractSSHClient():
    def __init__(self, host, alias=None, port=22, timeout=3, newline='LF',
                 prompt=None, term_type='vt100', width=80, height=24,
                 path_separator='/', encoding='utf8', escape_ansi=False, encoding_errors='strict'):
        self.configconfig = _ClientConfiguration(host, alias, port, timeout, newline,
                                           prompt, term_type, width, height,
                                           path_separator, encoding, escape_ansi, encoding_errors)
        self._sftp_client_sftp_client = None
        self._scp_transfer_client_scp_transfer_client = None
        self._scp_all_client_scp_all_client = None
        self._shell_shell = None
        self._started_commands_started_commands = []
        self.clientclient = self._get_client_get_client()
        self.widthwidth = width
        self.heightheight = height
 
    def _get_client(self):
        raise NotImplementedError('This should be implemented in the subclass.')
 
    @staticmethod
    
    def enable_logging(path):
        raise NotImplementedError
 
    @property
    
    sftp_client = property
    
    def sftp_client(self):
        if not self._sftp_client_sftp_client:
            self._sftp_client_sftp_client = self._create_sftp_client_create_sftp_client()
        return self._sftp_client_sftp_client
 
    @property
    
    scp_transfer_client = property
    
    def scp_transfer_client(self):
        if not self._scp_transfer_client_scp_transfer_client:
            self._scp_transfer_client_scp_transfer_client = self._create_scp_transfer_client_create_scp_transfer_client()
        return self._scp_transfer_client_scp_transfer_client
 
    @property
    
    scp_all_client = property
    
    def scp_all_client(self):
        if not self._scp_all_client_scp_all_client:
            self._scp_all_client_scp_all_client = self._create_scp_all_client_create_scp_all_client()
        return self._scp_all_client_scp_all_client
 
    @property
    
    shell = property
    
    def shell(self):
        if not self._shell_shell:
            self._shell_shell = self._create_shell_create_shell()
        if self.widthwidth != self.configconfig.width or self.heightheight != self.configconfig.height:
            self._shell_shell.resize(self.configconfig.width, self.configconfig.height)
            self.widthwidth, self.heightheight = self.configconfig.width, self.configconfig.height
        return self._shell_shell
 
    def _create_sftp_client(self):
        raise NotImplementedError
 
    def _create_scp_transfer_client(self):
        raise NotImplementedError
 
    def _create_scp_all_client(self):
        raise NotImplementedError
 
    def _create_shell(self):
        raise NotImplementedError
 
    
    def close(self):
        self._sftp_client_sftp_client = None
        self._scp_transfer_client_scp_transfer_client = None
        self._scp_all_client_scp_all_client = None
        self._shell_shell = None
        self.clientclient.close()
        try:
            logger.log_background_messages()
        except AttributeError:
            pass
 
    
    def login(self, username=None, password=None, allow_agent=False, look_for_keys=False, delay=None, proxy_cmd=None,
              read_config=False, jumphost_connection=None, keep_alive_interval='0 seconds'):
        keep_alive_interval = int(TimeEntry(keep_alive_interval).value)
        username = self._encode_encode(username)
        if not password or password == '""':
            password = None
        if password and not allow_agent:
            password = self._encode_encode(password)
        try:
            self._login_login(username, password, allow_agent, look_for_keys, proxy_cmd, read_config,
                        jumphost_connection, keep_alive_interval)
        except SSHClientException:
            self.clientclient.close()
            raise SSHClientException("Authentication failed for user '%s'."
                                     % self._decode_decode(username))
        return self._read_login_output_read_login_output(delay)
 
    def _encode(self, text):
        if is_bytes(text):
            return text
        if not is_string(text):
            text = unicode(text)
        return text.encode(self.configconfig.encoding, self.configconfig.encoding_errors)
 
    def _decode(self, bytes):
        return bytes.decode(self.configconfig.encoding, self.configconfig.encoding_errors)
 
    def _login(self, username, password, allow_agent, look_for_keys, proxy_cmd, read_config,
               jumphost_connection, keep_alive_interval):
        raise NotImplementedError
 
    def _read_login_output(self, delay):
        if not self.configconfig.prompt:
            return self.readread(delay)
        elif self.configconfig.prompt.startswith('REGEXP:'):
            return self.read_until_regexpread_until_regexp(self.configconfig.prompt[7:])
        return self.read_until_promptread_until_prompt()
 
    
    def login_with_public_key(self, username, keyfile, password, allow_agent=False,
                              look_for_keys=False, delay=None, proxy_cmd=None,
                              jumphost_connection=None, read_config=False, keep_alive_interval='0 seconds'):
        if username:
            username = self._encode_encode(username)
        if keyfile:
            self._verify_key_file_verify_key_file(keyfile)
        keep_alive_interval = int(TimeEntry(keep_alive_interval).value)
        try:
            self._login_with_public_key_login_with_public_key(username, keyfile, password,
                                        allow_agent, look_for_keys,
                                        proxy_cmd, jumphost_connection,
                                        read_config, keep_alive_interval)
        except SSHClientException:
            self.clientclient.close()
            raise SSHClientException("Login with public key failed for user "
                                     "'%s'." % self._decode_decode(username))
        return self._read_login_output_read_login_output(delay)
 
    def _verify_key_file(self, keyfile):
        if not os.path.exists(keyfile):
            raise SSHClientException("Given key file '%s' does not exist." %
                                     keyfile)
        try:
            open(keyfile).close()
        except IOError:
            raise SSHClientException("Could not read key file '%s'." % keyfile)
 
    def _login_with_public_key(self, username, keyfile, password,
                               allow_agent, look_for_keys, proxy_cmd,
                               jumphost_index_or_alias, read_config, keep_alive_interval):
        raise NotImplementedError
 
    @staticmethod
    def get_banner_without_login(host, port=22):
        raise NotImplementedError('Not supported on this Python interpreter.')
 
    def get_banner(self):
        raise NotImplementedError('Not supported on this Python interpreter.')
 
    
    def execute_command(self, command, sudo=False,  sudo_password=None, timeout=None, output_during_execution=False,
                        output_if_timeout=False, invoke_subsystem=False, forward_agent=False):
        self.start_commandstart_command(command, sudo, sudo_password, invoke_subsystem, forward_agent)
        return self.read_command_outputread_command_output(timeout=timeout, output_during_execution=output_during_execution,
                                        output_if_timeout=output_if_timeout)
 
    
    def start_command(self, command, sudo=False,  sudo_password=None, invoke_subsystem=False, forward_agent=False):
        command = self._encode_encode(command)
 
        self._started_commands_started_commands.append(self._start_command_start_command(command, sudo, sudo_password, invoke_subsystem, forward_agent))
 
    def _start_command(self, command, sudo=False, sudo_password=None, invoke_subsystem=False, forward_agent=False):
        raise NotImplementedError
 
    
    def read_command_output(self, timeout=None, output_during_execution=False, output_if_timeout=False):
        if timeout:
            timeout = float(TimeEntry(timeout).value)
        try:
            return self._started_commands_started_commands.pop().read_outputs(timeout, output_during_execution, output_if_timeout)
        except IndexError:
            raise SSHClientException('No started commands to read output from.')
 
    
    def write(self, text, add_newline=False):
        text = self._encode_encode(text)
        if add_newline:
            text += self._encode_encode(self.configconfig.newline)
        self.shellshellshell.write(text)
 
    
    def read(self, delay=None):
        output = self.shellshellshell.read()
        if delay:
            output += self._delayed_read_delayed_read(delay)
        return self._decode_decode(output)
 
    def _delayed_read(self, delay):
        delay = TimeEntry(delay).value
        max_time = time.time() + self.configconfig.get('timeout').value
        output = b''
        while time.time() < max_time:
            time.sleep(delay)
            read = self.shellshellshell.read()
            if not read:
                break
            output += read
        return output
 
    
    def read_char(self):
        server_output = b''
        while True:
            try:
                server_output += self.shellshellshell.read_byte()
                return self._decode_decode(server_output)
            except UnicodeDecodeError as e:
                if e.reason == 'unexpected end of data':
                    pass
                else:
                    raise
 
    
    def read_until(self, expected):
        return self._read_until_read_until(lambda s: expected in s, expected)
 
    def _read_until(self, matcher, expected, timeout=None):
        output = ''
        timeout = TimeEntry(timeout) if timeout else self.configconfig.get('timeout')
        max_time = time.time() + timeout.value
        while time.time() < max_time:
            char = self.read_charread_char()
            if not char:
                time.sleep(.00001)  # Release GIL so paramiko I/O thread can run
            output += char
            if matcher(output):
                return output
        raise SSHClientException("No match found for '%s' in %s\nOutput:\n%s."
                                 % (expected, timeout, output))
 
    
    def read_until_newline(self):
        return self.read_untilread_until(self.configconfig.newline)
 
    
    def read_until_prompt(self, strip_prompt=False):
        if not self.configconfig.prompt:
            raise SSHClientException('Prompt is not set.')
 
        if self.configconfig.prompt.startswith('REGEXP:'):
            output = self.read_until_regexpread_until_regexp(self.configconfig.prompt[7:])
        else:
            output = self.read_untilread_until(self.configconfig.prompt)
        if strip_prompt:
            output = self._strip_prompt_strip_prompt(output)
        return output
 
    def _strip_prompt(self, output):
        if self.configconfig.prompt.startswith('REGEXP:'):
            pattern = re.compile(self.configconfig.prompt[7:])
            match = pattern.search(output)
            length = match.end() - match.start()
        else:
            length = len(self.configconfig.prompt)
        return output[:-length]
 
    
    def read_until_regexp(self, regexp):
        if is_string(regexp):
            regexp = re.compile(regexp)
        return self._read_until_read_until(lambda s: regexp.search(s), regexp.pattern)
 
    
    def read_until_regexp_with_prefix(self, regexp, prefix):
        if is_string(regexp):
            regexp = re.compile(regexp)
        matcher = regexp.search
        expected = regexp.pattern
        ret = ""
        timeout = self.configconfig.get('timeout')
        start_time = time.time()
        while time.time() < float(timeout.value) + start_time:
            ret += self.read_charread_char()
            if matcher(prefix + self._encode_encode(ret)):
                return ret
        raise SSHClientException(
            "No match found for '%s' in %s\nOutput:\n%s"
            % (expected, timeout, ret))
 
    
    def write_until_expected(self, text, expected, timeout, interval):
        expected = self._encode_encode(expected)
        interval = TimeEntry(interval)
        timeout = TimeEntry(timeout)
        max_time = time.time() + timeout.value
        while time.time() < max_time:
            self.writewrite(text)
            try:
                return self._read_until_read_until(lambda s: expected in self._encode_encode(s), expected,
                                        timeout=interval.value)
            except SSHClientException:
                pass
        raise SSHClientException("No match found for '%s' in %s."
                                 % (self._decode_decode(expected), timeout))
 
    
    def put_file(self, source, destination='.', mode='0o744', newline='',
                 scp='OFF', scp_preserve_times=False):
        client = self._create_client_create_client(scp)
        return client.put_file(source, destination, scp_preserve_times, mode, newline,
                               self.configconfig.path_separator)
 
    
    def put_directory(self, source, destination='.', mode='0o744', newline='',
                      recursive=False, scp='OFF', scp_preserve_times=False):
        client = self._create_client_create_client(scp)
        return client.put_directory(source, destination, scp_preserve_times, mode,
                                    newline, self.configconfig.path_separator, recursive)
 
    
    def get_file(self, source, destination='.', scp='OFF', scp_preserve_times=False):
        client = self._create_client_create_client(scp)
        if scp == 'ALL':
            sources = self._get_files_for_scp_all_get_files_for_scp_all(source)
            return client.get_file(sources, destination, scp_preserve_times, self.configconfig.path_separator)
        return client.get_file(source, destination, scp_preserve_times, self.configconfig.path_separator)
 
    def _get_files_for_scp_all(self, source):
        sources = self.execute_commandexecute_command('printf "%%s\\n" %s' % source)
        result = sources[0].split('\n')
        result[:] = [x for x in result if x]  # remove empty entries
        return result
 
    
    def get_directory(self, source, destination='.', recursive=False,
                      scp='OFF', scp_preserve_times=False):
        client = self._create_client_create_client(scp)
        return client.get_directory(source, destination, scp_preserve_times,
                                    self.configconfig.path_separator,
                                    recursive)
 
    
    def list_dir(self, path, pattern=None, absolute=False):
        items = self.sftp_clientsftp_clientsftp_client.list_dir(path, pattern, absolute)
        return sorted(items)
 
    
    def list_files_in_dir(self, path, pattern=None, absolute=False):
        files = self.sftp_clientsftp_clientsftp_client.list_files_in_dir(path, pattern, absolute)
        return sorted(files)
 
    
    def list_dirs_in_dir(self, path, pattern=None, absolute=False):
        dirs = self.sftp_clientsftp_clientsftp_client.list_dirs_in_dir(path, pattern, absolute)
        return sorted(dirs)
 
    
    def is_dir(self, path):
        has_glob = bool([ops for ops in '*?![' if(ops in path)])
        if has_glob:
            dir_dir = path[:(-len(path.split(self.configconfig.path_separator)[-1]))]
            dirs = self.sftp_clientsftp_clientsftp_client.list_dirs_in_dir(dir_dir)
            for dirname in dirs:
                if fnmatch.fnmatch(dirname, path.split(self.configconfig.path_separator)[-1]):
                    return self.sftp_clientsftp_clientsftp_client.is_dir(dir_dir + dirname)
        return self.sftp_clientsftp_clientsftp_client.is_dir(path)
 
    
    def is_file(self, path):
        if bool([ops for ops in '*?![' if(ops in path)]):
            file_dir = path[:(-len(path.split(self.configconfig.path_separator)[-1]))]
            if file_dir == '':
                return self.sftp_clientsftp_clientsftp_client.is_file(path)
            files = self.sftp_clientsftp_clientsftp_client.list_files_in_dir(file_dir)
            for filename in files:
                if fnmatch.fnmatch(filename, path.split(self.configconfig.path_separator)[-1]):
                    return self.sftp_clientsftp_clientsftp_client.is_file(file_dir + filename)
        return self.sftp_clientsftp_clientsftp_client.is_file(path)
 
    def _create_client(self, scp):
        if scp.upper() == 'ALL':
            return self.scp_all_clientscp_all_clientscp_all_client
        elif scp.upper() == 'TRANSFER':
            return self.scp_transfer_clientscp_transfer_clientscp_transfer_client
        else:
            return self.sftp_clientsftp_clientsftp_client
 
 
 
class AbstractShell():
 
    
    def read(self):
        raise NotImplementedError
 
    
    def read_byte(self):
        raise NotImplementedError
 
    
    def write(self, text):
        raise NotImplementedError
 
 
 
class AbstractSFTPClient():
 
    def __init__(self, encoding):
        self._encoding_encoding = encoding
        self._homedir_homedir = self._absolute_path_absolute_path(b'.')
 
    def _absolute_path(self, path):
        raise NotImplementedError
 
    
    def is_file(self, path):
        try:
            item = self._stat_stat(path)
        except IOError:
            return False
        return item.is_regular()
 
    def _stat(self, path):
        raise NotImplementedError
 
    
    def is_dir(self, path):
        try:
            item = self._stat_stat(path)
        except IOError:
            return False
        return item.is_directory()
 
    
    def list_dir(self, path, pattern=None, absolute=False):
        return self._list_filtered_list_filtered(path, self._get_item_names_get_item_names, pattern,
                                   absolute)
 
    def _list_filtered(self, path, filter_method, pattern=None, absolute=False):
        self._verify_remote_dir_exists_verify_remote_dir_exists(path)
        items = filter_method(path)
        if pattern:
            items = self._filter_by_pattern_filter_by_pattern(items, pattern)
        if absolute:
            items = self._include_absolute_path_include_absolute_path(items, path)
        return items
 
    def _verify_remote_dir_exists(self, path):
        if not self.is_diris_dir(path):
            raise SSHClientException("There was no directory matching '%s'." %
                                     path)
 
    def _get_item_names(self, path):
        return [item.name for item in self._list_list(path)]
 
    def _list(self, path):
        raise NotImplementedError
 
    def _filter_by_pattern(self, items, pattern):
        return [name for name in items if fnmatchcase(name, pattern)]
 
    def _include_absolute_path(self, items, path):
        absolute_path = self._absolute_path_absolute_path(path)
        if absolute_path[1:3] == ':\\':
            absolute_path += '\\'
        else:
            absolute_path += '/'
        return [absolute_path + name for name in items]
 
    
    def list_files_in_dir(self, path, pattern=None, absolute=False):
        return self._list_filtered_list_filtered(path, self._get_file_names_get_file_names, pattern,
                                   absolute)
 
    def _get_file_names(self, path):
        return [item.name
                for item in self._list_list(path)
                if item.is_regular()
                or (item.is_link()
                    and not self._is_dir_symlink_is_dir_symlink(path, item.name))]
 
    def _is_dir_symlink(self, path, item):
        resolved_link = self._readlink_readlink('%s/%s' % (path, item))
        return self.is_diris_dir('%s/%s' % (path, resolved_link))
 
    
    def list_dirs_in_dir(self, path, pattern=None, absolute=False):
        return self._list_filtered_list_filtered(path, self._get_directory_names_get_directory_names, pattern,
                                   absolute)
 
    def _get_directory_names(self, path):
        return [item.name for item in self._list_list(path) if item.is_directory()]
 
    def get_directory(self, source, destination, scp_preserve_time, path_separator='/',
                      recursive=False):
        destination = self.build_destinationbuild_destination(source, destination, path_separator)
        return self._get_directory_get_directory(source, destination, path_separator, recursive, scp_preserve_time)
 
    
    def _get_directory(self, source, destination, path_separator='/',
                       recursive=False, scp_preserve_times=False):
        source = self._remove_ending_path_separator_remove_ending_path_separator(path_separator, source)
        self._verify_remote_dir_exists_verify_remote_dir_exists(source)
        files = []
        items = self.list_dirlist_dir(source)
        if items:
            for item in items:
                remote = source + path_separator + item
                local = os.path.join(destination, item)
                if self.is_fileis_file(remote):
                    files += self.get_fileget_file(remote, local, scp_preserve_times)
                elif recursive:
                    files += self.get_directoryget_directory(remote, local, scp_preserve_times, path_separator,
                                                recursive)
        else:
            if not os.path.exists(destination):
                os.makedirs(destination)
            files.append((source, destination))
        return files
 
    
    def build_destination(self, source, destination, path_separator):
        if os.path.exists(destination) or destination == '.':
            fullpath_destination = os.path.join(destination, self.get_parent_folderget_parent_folder(source, path_separator))
            if not os.path.exists(fullpath_destination):
                os.makedirs(fullpath_destination)
            return fullpath_destination
        else:
            return destination
 
    def get_parent_folder(self, source, path_separator):
        if source.endswith(path_separator):
            return (source[:-len(path_separator)]).split(path_separator)[-1]
        else:
            return source.split(path_separator)[-1]
 
    def _remove_ending_path_separator(self, path_separator, source):
        if source.endswith(path_separator):
            source = source[:-len(path_separator)]
        return source
 
    
    def get_file(self, source, destination, scp_preserve_times, path_separator='/'):
        remote_files = self._get_get_file_sources_get_get_file_sources(source, path_separator)
        if not remote_files:
            msg = "There were no source files matching '%s'." % source
            raise SSHClientException(msg)
        local_files = self._get_get_file_destinations_get_get_file_destinations(remote_files, destination)
        files = list(zip(remote_files, local_files))
        for src, dst in files:
            self._get_file_get_file(src, dst, scp_preserve_times)
        return files
 
    def _get_get_file_sources(self, source, path_separator):
        if path_separator in source:
            path, pattern = source.rsplit(path_separator, 1)
        else:
            path, pattern = '', source
        if not path:
            path = '.'
        if not self.is_fileis_file(source):
            return [filename for filename in
                    self.list_files_in_dirlist_files_in_dir(path, pattern, absolute=True)]
        else:
            return [source]
 
    def _get_get_file_destinations(self, source_files, destination):
        target_is_dir = destination.endswith(os.sep) or destination == '.'
        if not target_is_dir and len(source_files) > 1:
            raise SSHClientException('Cannot copy multiple source files to one '
                                     'destination file.')
        destination = os.path.abspath(destination.replace('/', os.sep))
        self._create_missing_local_dirs_create_missing_local_dirs(destination, target_is_dir)
        if target_is_dir:
            return [os.path.join(destination, os.path.basename(name))
                    for name in source_files]
        return [destination]
 
    def _create_missing_local_dirs(self, destination, target_is_dir):
        if not target_is_dir:
            destination = os.path.dirname(destination)
        if not os.path.exists(destination):
            os.makedirs(destination)
 
    def _get_file(self, source, destination, scp_preserve_times):
        raise NotImplementedError
 
    
    def put_directory(self, source, destination, scp_preserve_times,mode, newline,
                      path_separator='/', recursive=False):
        self._verify_local_dir_exists_verify_local_dir_exists(source)
        destination = self._remove_ending_path_separator_remove_ending_path_separator(path_separator,
                                                         destination)
        if self.is_diris_dir(destination):
            destination = destination + path_separator +\
                          source.rsplit(os.path.sep)[-1]
        return self._put_directory_put_directory(source, destination, mode, newline,
                                   path_separator, recursive, scp_preserve_times)
 
    def _put_directory(self, source, destination, mode, newline,
                       path_separator, recursive, scp_preserve_times=False):
        files = []
        items = os.listdir(source)
        if items:
            for item in items:
                local_path = os.path.join(source, item)
                remote_path = destination + path_separator + item
                if os.path.isfile(local_path):
                    files += self.put_fileput_file(local_path, remote_path, scp_preserve_times,
                                           mode, newline, path_separator)
                elif recursive and os.path.isdir(local_path):
                    files += self._put_directory_put_directory(local_path, remote_path,
                                                 mode, newline,
                                                 path_separator, recursive, scp_preserve_times)
        else:
            self._create_missing_remote_path_create_missing_remote_path(destination, mode)
            files.append((source, destination))
        return files
 
    def _verify_local_dir_exists(self, path):
        if not os.path.isdir(path):
            raise SSHClientException("There was no source path matching '%s'."
                                     % path)
 
    
    def put_file(self, sources, destination, scp_preserve_times, mode, newline, path_separator='/'):
        if mode:
            mode = int(mode, 8)
        newline = {'CRLF': '\r\n', 'LF': '\n'}.get(newline.upper(), None)
        local_files = self._get_put_file_sources_get_put_file_sources(sources)
        remote_files, remote_dir = self._get_put_file_destinations_get_put_file_destinations(local_files,
                                                                   destination,
                                                                   path_separator)
        self._create_missing_remote_path_create_missing_remote_path(remote_dir, mode)
        files = list(zip(local_files, remote_files))
        for source, destination in files:
            self._put_file_put_file(source, destination, mode, newline, path_separator, scp_preserve_times)
        return files
 
    def _get_put_file_sources(self, source):
        source = source.replace('/', os.sep)
        if not os.path.exists(source):
            sources = [f for f in glob.glob(source)]
        else:
            sources = [f for f in [source]]
        if not sources:
            msg = "There are no source files matching '%s'." % source
            raise SSHClientException(msg)
        return sources
 
    def _get_put_file_destinations(self, sources, destination, path_separator):
        if destination[1:3] == ':' + path_separator:
            destination = path_separator + destination
        destination = self._format_destination_path_format_destination_path(destination)
        if destination == '.':
            destination = self._homedir_homedir + '/'
        if len(sources) > 1 and destination[-1] != '/' and not self.is_diris_dir(destination):
            raise ValueError('It is not possible to copy multiple source '
                             'files to one destination file.')
        dir_path, filename = self._parse_path_elements_parse_path_elements(destination,
                                                       path_separator)
        if filename:
            files = [path_separator.join([dir_path, filename])]
        else:
            files = [path_separator.join([dir_path, os.path.basename(path)])
                     for path in sources]
        return files, dir_path
 
    def _format_destination_path(self, destination):
        destination = destination.replace('\\', '/')
        destination = ntpath.splitdrive(destination)[-1]
        return destination
 
    def _parse_path_elements(self, destination, path_separator):
        def _isabs(path):
            if destination.startswith(path_separator):
                return True
            if path_separator == '\\' and path[1:3] == ':\\':
                return True
            return False
        if not _isabs(destination):
            destination = path_separator.join([self._homedir_homedir, destination])
        if self.is_diris_dir(destination):
            return destination, ''
        return destination.rsplit(path_separator, 1)
 
    def _create_missing_remote_path(self, path, mode):
        if path.startswith(b'/'):
            current_dir = b'/'
        else:
            current_dir = self._absolute_path_absolute_path(b'.').encode(self._encoding_encoding)
        for dir_name in path.split(b'/'):
            if dir_name:
                current_dir = posixpath.join(current_dir, dir_name)
            try:
                self._client.stat(current_dir)
            except:
                if not isinstance(mode, int):
                    mode = int(mode, 8)
                self._client.mkdir(current_dir, mode)
 
    def _put_file(self, source, destination, mode, newline, path_separator, scp_preserve_times=False):
        remote_file = self._create_remote_file_create_remote_file(destination, mode)
        with open(source, 'rb') as local_file:
            position = 0
            while True:
                data = local_file.read(4096)
                if not data:
                    break
                if newline:
                    data = re.sub(br'(\r\n|\r|\n)', newline.encode(self._encoding_encoding), data)
                self._write_to_remote_file_write_to_remote_file(remote_file, data, position)
                position += len(data)
            self._close_remote_file_close_remote_file(remote_file)
 
    def _create_remote_file(self, destination, mode):
        raise NotImplementedError
 
    def _write_to_remote_file(self, remote_file, data, position):
        raise NotImplementedError
 
    def _close_remote_file(self, remote_file):
        raise NotImplementedError
 
    def create_local_ssh_tunnel(self, local_port, remote_host, remote_port, client):
        raise NotImplementedError
 
    def _readlink(self, path):
        raise NotImplementedError
 
 
 
class AbstractCommand():
 
    def __init__(self, command, encoding):
        self._command_command = command
        self._encoding_encoding = encoding
        self._shell_shell = None
 
    
    def run_in(self, shell, sudo=False,  sudo_password=None, invoke_subsystem=False):
        self._shell_shell = shell
        if invoke_subsystem:
            self._invoke_invoke()
        elif not sudo:
            self._execute_execute()
        else:
            self._execute_with_sudo_execute_with_sudo(sudo_password)
 
    def _execute(self):
        raise NotImplementedError
 
    def _invoke(self):
        raise NotImplementedError
 
    def _execute_with_sudo(self, sudo_password=None):
        raise NotImplementedError
 
    
    def read_outputs(self):
        raise NotImplementedError
 
 
 
class SFTPFileInfo():
 
    def __init__(self, name, mode):
        self.namename = name
        self.modemode = mode
 
    
    def is_regular(self):
        return stat.S_ISREG(self.modemode)
 
    
    def is_directory(self):
        return stat.S_ISDIR(self.modemode)
 
    
    def is_link(self):
        return stat.S_ISLNK(self.modemode)