funkwhale/api/funkwhale_api/federation/library.py

import json
import requests

from django.conf import settings

from funkwhale_api.common import session

from . import actors
from . import models
from . import serializers
from . import signing
from . import webfinger


def scan_from_account_name(account_name):
    """
    Given an account name such as library@test.library, will:

    1. Perform the webfinger lookup
    2. Perform the actor lookup
    3. Perform the library's collection lookup

    and return corresponding data in a dictionary.
    """
    data = {}
    try:
        username, domain = webfinger.clean_acct(
            account_name, ensure_local=False)
    except serializers.ValidationError:
        return {
            'webfinger': {
                'errors': ['Invalid account string']
            }
        }
    system_library = actors.SYSTEM_ACTORS['library'].get_actor_instance()
    library = models.Library.objects.filter(
        actor__domain=domain,
        actor__preferred_username=username
    ).select_related('actor').first()
    data['local'] = {
        'following': False,
        'awaiting_approval': False,
    }
    try:
        follow = models.Follow.objects.get(
            target__preferred_username=username,
            target__domain=username,
            actor=system_library,
        )
        data['local']['awaiting_approval'] = not bool(follow.approved)
        data['local']['following'] = True
    except models.Follow.DoesNotExist:
        pass

    try:
        data['webfinger'] = webfinger.get_resource(
            'acct:{}'.format(account_name))
    except requests.ConnectionError:
        return {
            'webfinger': {
                'errors': ['This webfinger resource is not reachable']
            }
        }
    except requests.HTTPError as e:
        return {
            'webfinger': {
                'errors': [
                    'Error {} during webfinger request'.format(
                        e.response.status_code)]
            }
        }
    except json.JSONDecodeError as e:
        return {
            'webfinger': {
                'errors': ['Could not process webfinger response']
            }
        }

    try:
        data['actor'] = actors.get_actor_data(data['webfinger']['actor_url'])
    except requests.ConnectionError:
        data['actor'] = {
            'errors': ['This actor is not reachable']
        }
        return data
    except requests.HTTPError as e:
        data['actor'] = {
            'errors': [
                'Error {} during actor request'.format(
                    e.response.status_code)]
        }
        return data

    serializer = serializers.LibraryActorSerializer(data=data['actor'])
    if not serializer.is_valid():
        data['actor'] = {
            'errors': ['Invalid ActivityPub actor']
        }
        return data
    data['library'] = get_library_data(
        serializer.validated_data['library_url'])

    return data


def get_library_data(library_url):
    actor = actors.SYSTEM_ACTORS['library'].get_actor_instance()
    auth = signing.get_auth(actor.private_key, actor.private_key_id)
    try:
        response = session.get_session().get(
            library_url,
            auth=auth,
            timeout=5,
            verify=settings.EXTERNAL_REQUESTS_VERIFY_SSL,
            headers={
                'Content-Type': 'application/activity+json'
            }
        )
    except requests.ConnectionError:
        return {
            'errors': ['This library is not reachable']
        }
    scode = response.status_code
    if scode == 401:
        return {
            'errors': ['This library requires authentication']
        }
    elif scode == 403:
        return {
            'errors': ['Permission denied while scanning library']
        }
    elif scode >= 400:
        return {
            'errors': ['Error {} while fetching the library'.format(scode)]
        }
    serializer = serializers.PaginatedCollectionSerializer(
        data=response.json(),
    )
    if not serializer.is_valid():
        return {
            'errors': [
                'Invalid ActivityPub response from remote library']
        }

    return serializer.validated_data


def get_library_page(library, page_url):
    actor = actors.SYSTEM_ACTORS['library'].get_actor_instance()
    auth = signing.get_auth(actor.private_key, actor.private_key_id)
    response = session.get_session().get(
        page_url,
        auth=auth,
        timeout=5,
        verify=settings.EXTERNAL_REQUESTS_VERIFY_SSL,
        headers={
            'Content-Type': 'application/activity+json'
        }
    )
    serializer = serializers.CollectionPageSerializer(
        data=response.json(),
        context={
            'library': library,
            'item_serializer': serializers.AudioSerializer})
    serializer.is_valid(raise_exception=True)
    return serializer.validated_data