def _send_dir(access, local_dir_path, listing):
    access, listing = _load_access_listing(access, listing)
    auth = access['auth']
    remote_dir_path = os.path.normpath(cut_remote_user_dir(access['dirPath']))

    with create_ssh_client(
            host=access['host'],
            port=access.get('port', DEFAULT_PORT),
            username=auth['username'],
            password=auth.get('password'),
            private_key=auth.get('privateKey'),
            passphrase=auth.get('passphrase'),
            timeout=access.get('timeout', DEFAULT_TIMEOUT),
            auth_timeout=access.get('authTimeout', DEFAULT_AUTH_TIMEOUT),
            banner_timeout=access.get('bannerTimeout',
                                      DEFAULT_BANNER_TIMEOUT)) as ssh_client:
        if listing:
            with ssh_client.open_sftp() as sftp_client:
                ssh_mkdir(sftp_client, remote_dir_path)
                send_directory(listing, sftp_client, local_dir_path,
                               remote_dir_path)
        else:
            with ssh_client.open_sftp() as sftp_client:
                remote_parent_dir = os.path.dirname(remote_dir_path)
                ssh_mkdir(sftp_client, remote_parent_dir)
            with SCPClient(ssh_client.get_transport()) as scp_client:
                scp_client.put(local_dir_path, remote_dir_path, recursive=True)
def _send_file(access, local_file_path):
    with open(access) as f:
        access = json.load(f)

    if not os.path.isfile(local_file_path):
        raise FileNotFoundError(
            'Could not find local file "{}"'.format(local_file_path))

    auth = access['auth']
    remote_file_path = cut_remote_user_dir(access['filePath'])

    remote_dir_path = os.path.dirname(remote_file_path)

    with create_ssh_client(
            host=access['host'],
            port=access.get('port', DEFAULT_PORT),
            username=auth['username'],
            password=auth.get('password'),
            private_key=auth.get('privateKey'),
            passphrase=auth.get('passphrase'),
            timeout=access.get('timeout', DEFAULT_TIMEOUT),
            auth_timeout=access.get('authTimeout', DEFAULT_AUTH_TIMEOUT),
            banner_timeout=access.get('bannerTimeout',
                                      DEFAULT_BANNER_TIMEOUT)) as client:
        with client.open_sftp() as sftp:
            ssh_mkdir(sftp, remote_dir_path)
            sftp.put(local_file_path, remote_file_path)
def _receive_file_validate(access):
    with open(access) as f:
        access = json.load(f)

    jsonschema.validate(access, FILE_SCHEMA)

    auth = access['auth']

    remote_file_path = cut_remote_user_dir(access['filePath'])

    with create_ssh_client(
            host=access['host'],
            port=access.get('port', DEFAULT_PORT),
            username=auth['username'],
            password=auth.get('password'),
            private_key=auth.get('privateKey'),
            passphrase=auth.get('passphrase'),
            timeout=access.get('timeout', DEFAULT_TIMEOUT),
            auth_timeout=access.get('authTimeout', DEFAULT_AUTH_TIMEOUT),
            banner_timeout=access.get('bannerTimeout',
                                      DEFAULT_BANNER_TIMEOUT)) as client:
        with client.open_sftp() as sftp:
            try:
                with sftp.open(remote_file_path, mode='r', bufsize=0):
                    pass
            except FileNotFoundError:
                raise FileNotFoundError(
                    'Could not find remote file "{}"'.format(remote_file_path))
def _receive_file(access, local_file_path):
    with open(access) as f:
        access = json.load(f)

    if not os.path.isdir(os.path.dirname(local_file_path)):
        raise NotADirectoryError(
            'Could not create local file "{}". The parent directory does not exist.'
            .format(local_file_path))

    auth = access['auth']

    remote_file_path = cut_remote_user_dir(access['filePath'])

    with create_ssh_client(
            host=access['host'],
            port=access.get('port', DEFAULT_PORT),
            username=auth['username'],
            password=auth.get('password'),
            private_key=auth.get('privateKey'),
            passphrase=auth.get('passphrase'),
            timeout=access.get('timeout', DEFAULT_TIMEOUT),
            auth_timeout=access.get('authTimeout', DEFAULT_AUTH_TIMEOUT),
            banner_timeout=access.get('bannerTimeout',
                                      DEFAULT_BANNER_TIMEOUT)) as client:
        with client.open_sftp() as sftp:
            try:
                sftp.get(remote_file_path, local_file_path)
            except FileNotFoundError:
                raise FileNotFoundError(
                    'Remote file "{}" could not be found'.format(
                        remote_file_path))
def _receive_dir(access, local_dir_path, listing):
    local_dir_path = os.path.normpath(local_dir_path)
    access, listing = _load_access_listing(access, listing)
    auth = access['auth']
    remote_dir_path = os.path.normpath(cut_remote_user_dir(access['dirPath']))

    if not os.path.isdir(os.path.dirname(local_dir_path)):
        raise FileNotFoundError(
            'Could not create local directory "{}", because parent directory does not exist'
            .format(local_dir_path))

    with create_ssh_client(
            host=access['host'],
            port=access.get('port', DEFAULT_PORT),
            username=auth['username'],
            password=auth.get('password'),
            private_key=auth.get('privateKey'),
            passphrase=auth.get('passphrase'),
            timeout=access.get('timeout', DEFAULT_TIMEOUT),
            auth_timeout=access.get('authTimeout', DEFAULT_AUTH_TIMEOUT),
            banner_timeout=access.get('bannerTimeout',
                                      DEFAULT_BANNER_TIMEOUT)) as client:
        with SCPClient(client.get_transport()) as scp_client:
            if listing:
                try:
                    os.mkdir(local_dir_path)
                except FileExistsError:
                    pass
                fetch_directory(listing, scp_client, local_dir_path,
                                remote_dir_path)
            else:
                try:
                    scp_client.get(remote_dir_path,
                                   local_dir_path,
                                   recursive=True)
                except SCPException:
                    raise FileNotFoundError(
                        'Could not find remote directory "{}"'.format(
                            remote_dir_path))
                except FileNotFoundError:
                    raise NotADirectoryError(
                        'Could not create local directory "{}", because parent directory does not exist'
                        .format(local_dir_path))
def _send_file_validate(access):
    with open(access) as f:
        access = json.load(f)

    jsonschema.validate(access, FILE_SCHEMA)

    # check whether authentication works
    auth = access['auth']
    with create_ssh_client(host=access['host'],
                           port=access.get('port', DEFAULT_PORT),
                           username=auth['username'],
                           password=auth.get('password'),
                           private_key=auth.get('privateKey'),
                           passphrase=auth.get('passphrase'),
                           timeout=access.get('timeout', DEFAULT_TIMEOUT),
                           auth_timeout=access.get('authTimeout',
                                                   DEFAULT_AUTH_TIMEOUT),
                           banner_timeout=access.get('bannerTimeout',
                                                     DEFAULT_BANNER_TIMEOUT)):
        pass
def _send_dir_validate(access, listing):
    access, listing = _load_access_listing(access, listing)

    jsonschema.validate(access, DIR_SCHEMA)
    if listing:
        jsonschema.validate(listing, LISTING_SCHEMA)

    # check whether authentication works
    auth = access['auth']
    with create_ssh_client(host=access['host'],
                           port=access.get('port', DEFAULT_PORT),
                           username=auth['username'],
                           password=auth.get('password'),
                           private_key=auth.get('privateKey'),
                           passphrase=auth.get('passphrase'),
                           timeout=access.get('timeout', DEFAULT_TIMEOUT),
                           auth_timeout=access.get('authTimeout',
                                                   DEFAULT_AUTH_TIMEOUT),
                           banner_timeout=access.get('bannerTimeout',
                                                     DEFAULT_BANNER_TIMEOUT)):
        pass
Beispiel #8
0
def _mount_dir(access, local_dir_path):
    with open(access) as f:
        access = json.load(f)

    os.makedirs(local_dir_path, exist_ok=True)

    host = access['host']
    port = access.get('port', DEFAULT_PORT)
    dir_path = access['dirPath']
    auth = access['auth']
    username = auth['username']
    password = auth.get('password')
    private_key = auth.get('privateKey')
    passphrase = auth.get('passphrase')
    ciphers = access.get('ciphers')

    enable_password = False
    identity_file = None

    if private_key:
        identity_file = create_identity_file(private_key)
    elif password:
        enable_password = True
    else:
        raise InvalidAuthenticationError(
            'At least password or private_key must be present.')

    try:
        check_remote_dir_available(access)
    except FileNotFoundError:
        with create_ssh_client(
                host=access['host'],
                port=access.get('port', DEFAULT_PORT),
                username=auth['username'],
                password=auth.get('password'),
                private_key=auth.get('privateKey'),
                passphrase=auth.get('passphrase')) as ssh_client:
            with ssh_client.open_sftp() as sftp_client:
                ssh_mkdir(sftp_client, dir_path)

    with create_configfile(ciphers,
                           enable_password=enable_password) as temp_configfile:
        command = create_sshfs_command(
            host=host,
            port=port,
            username=username,
            local_dir_path=local_dir_path,
            remote_path=dir_path,
            configfile_path=temp_configfile.name,
            writable=access.get('writable', False),
            enable_password_stdin=enable_password,
            identity_file=identity_file.name if identity_file else None)

        if private_key:
            if passphrase:
                try:
                    _mount_with_key_and_passphrase(command, passphrase)
                except InvalidAuthenticationError as e:
                    raise InvalidAuthenticationError(
                        'Could not mount directory using\n\thost={host}\n\tport={port}\n\tlocalDir={local_dir_path}\n\t'
                        'dirPath={dir_path}\n\tauthentication=key + passphrase\nvia sshfs:\n{error}.'
                        .format(host=host,
                                port=port,
                                local_dir_path=local_dir_path,
                                dir_path=dir_path,
                                error=str(e)))
                finally:
                    identity_file.close()
            else:
                process_result = subprocess.run(command,
                                                stderr=subprocess.PIPE)

                identity_file.close()

                if process_result.returncode != 0:
                    raise InvalidAuthenticationError(
                        'Could not mount directory using\n\thost={host}\n\tport={port}\n\tlocalDir={local_dir_path}\n\t'
                        'dirPath={dir_path}\n\tauthentication=key no passphrase\nvia sshfs:\n{error}'
                        .format(host=host,
                                port=port,
                                local_dir_path=local_dir_path,
                                dir_path=dir_path,
                                error=process_result.stderr.decode('utf-8')))
        elif password:
            process_result = subprocess.run(command,
                                            input=password.encode('utf-8'),
                                            stderr=subprocess.PIPE)

            if process_result.returncode != 0:
                raise InvalidAuthenticationError(
                    'Could not mount directory using\n\thost={host}\n\tport={port}\n\tlocalDir={local_dir_path}\n\t'
                    'dirPath={dir_path}\n\tauthentication=password\nvia sshfs:\n{error}'
                    .format(host=host,
                            port=port,
                            local_dir_path=local_dir_path,
                            dir_path=dir_path,
                            error=process_result.stderr.decode('utf-8')))