diff --git a/.env.dev b/.env.dev index 2e8834143..3f904078c 100644 --- a/.env.dev +++ b/.env.dev @@ -1,9 +1,11 @@ API_AUTHENTICATION_REQUIRED=True RAVEN_ENABLED=false RAVEN_DSN=https://44332e9fdd3d42879c7d35bf8562c6a4:0062dc16a22b41679cd5765e5342f716@sentry.eliotberriot.com/5 -DJANGO_ALLOWED_HOSTS=localhost,nginx +DJANGO_ALLOWED_HOSTS=.funkwhale.test,localhost,nginx,0.0.0.0,127.0.0.1 DJANGO_SETTINGS_MODULE=config.settings.local DJANGO_SECRET_KEY=dev C_FORCE_ROOT=true -FUNKWHALE_URL=http://localhost +FUNKWHALE_HOSTNAME=localhost +FUNKWHALE_PROTOCOL=http PYTHONDONTWRITEBYTECODE=true +WEBPACK_DEVSERVER_PORT=8080 diff --git a/README.rst b/README.rst index 2d5d2011d..747a1e220 100644 --- a/README.rst +++ b/README.rst @@ -206,3 +206,80 @@ Typical workflow for a merge request 6. Push your branch 7. Create your merge request 8. Take a step back and enjoy, we're really grateful you did all of this and took the time to contribute! + + +Working with federation locally +------------------------------- + +To achieve that, you'll need: + +1. to update your dns resolver to resolve all your .dev hostnames locally +2. a reverse proxy (such as traefik) to catch those .dev requests and + and with https certificate +3. two instances (or more) running locally, following the regular dev setup + +Resolve .dev names locally +^^^^^^^^^^^^^^^^^^^^^^^^^^ + +If you use dnsmasq, this is as simple as doing:: + + echo "address=/test/172.17.0.1" | sudo tee /etc/dnsmasq.d/test.conf + sudo systemctl restart dnsmasq + +If you use NetworkManager with dnsmasq integration, use this instead:: + + echo "address=/test/172.17.0.1" | sudo tee /etc/NetworkManager/dnsmasq.d/test.conf + sudo systemctl restart NetworkManager + +Add wildcard certificate to the trusted certificates +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +Simply copy bundled certificates:: + + sudo cp docker/ssl/test.crt /usr/local/share/ca-certificates/ + sudo update-ca-certificates + +This certificate is a wildcard for ``*.funkwhale.test`` + +Run a reverse proxy for your instances +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + +Crete docker network +^^^^^^^^^^^^^^^^^^^^ + +Create the federation network:: + + docker network create federation + +Launch everything +^^^^^^^^^^^^^^^^^ + +Launch the traefik proxy:: + + docker-compose -f docker/traefik.yml up -d + +Then, in separate terminals, you can setup as many different instances as you +need:: + + export COMPOSE_PROJECT_NAME=node2 + docker-compose -f dev.yml run --rm api python manage.py migrate + docker-compose -f dev.yml run --rm api python manage.py createsuperuser + docker-compose -f dev.yml up nginx api front + +Note that by default, if you don't export the COMPOSE_PROJECT_NAME, +we will default to node1 as the name of your instance. + +Assuming your project name is ``node1``, your server will be reachable +at ``https://node1.funkwhale.test/``. Not that you'll have to trust +the SSL Certificate as it's self signed. + +When working on federation with traefik, ensure you have this in your ``env``:: + + # This will ensure we don't bind any port on the host, and thus enable + # multiple instances of funkwhale to be spawned concurrently. + WEBPACK_DEVSERVER_PORT_BINDING= + # This disable certificate verification + EXTERNAL_REQUESTS_VERIFY_SSL=false + # this ensure you don't have incorrect urls pointing to http resources + FUNKWHALE_PROTOCOL=https diff --git a/api/config/api_urls.py b/api/config/api_urls.py index cab6805b6..cf5b03744 100644 --- a/api/config/api_urls.py +++ b/api/config/api_urls.py @@ -32,6 +32,10 @@ v1_patterns += [ include( ('funkwhale_api.instance.urls', 'instance'), namespace='instance')), + url(r'^federation/', + include( + ('funkwhale_api.federation.api_urls', 'federation'), + namespace='federation')), url(r'^providers/', include( ('funkwhale_api.providers.urls', 'providers'), diff --git a/api/config/settings/common.py b/api/config/settings/common.py index 7b7f6e64c..ebfd21dd6 100644 --- a/api/config/settings/common.py +++ b/api/config/settings/common.py @@ -25,8 +25,26 @@ try: except FileNotFoundError: pass -FUNKWHALE_URL = env('FUNKWHALE_URL') -FUNKWHALE_HOSTNAME = urlsplit(FUNKWHALE_URL).netloc +FUNKWHALE_HOSTNAME = None +FUNKWHALE_HOSTNAME_SUFFIX = env('FUNKWHALE_HOSTNAME_SUFFIX', default=None) +FUNKWHALE_HOSTNAME_PREFIX = env('FUNKWHALE_HOSTNAME_PREFIX', default=None) +if FUNKWHALE_HOSTNAME_PREFIX and FUNKWHALE_HOSTNAME_SUFFIX: + # We're in traefik case, in development + FUNKWHALE_HOSTNAME = '{}.{}'.format( + FUNKWHALE_HOSTNAME_PREFIX, FUNKWHALE_HOSTNAME_SUFFIX) + FUNKWHALE_PROTOCOL = env('FUNKWHALE_PROTOCOL', default='https') +else: + try: + FUNKWHALE_HOSTNAME = env('FUNKWHALE_HOSTNAME') + FUNKWHALE_PROTOCOL = env('FUNKWHALE_PROTOCOL', default='https') + except Exception: + FUNKWHALE_URL = env('FUNKWHALE_URL') + _parsed = urlsplit(FUNKWHALE_URL) + FUNKWHALE_HOSTNAME = _parsed.netloc + FUNKWHALE_PROTOCOL = _parsed.scheme + +FUNKWHALE_URL = '{}://{}'.format(FUNKWHALE_PROTOCOL, FUNKWHALE_HOSTNAME) + FEDERATION_ENABLED = env.bool('FEDERATION_ENABLED', default=True) FEDERATION_HOSTNAME = env('FEDERATION_HOSTNAME', default=FUNKWHALE_HOSTNAME) @@ -406,3 +424,8 @@ ACCOUNT_USERNAME_BLACKLIST = [ 'staff', 'service', ] + env.list('ACCOUNT_USERNAME_BLACKLIST', default=[]) + +EXTERNAL_REQUESTS_VERIFY_SSL = env.bool( + 'EXTERNAL_REQUESTS_VERIFY_SSL', + default=True +) diff --git a/api/funkwhale_api/common/fields.py b/api/funkwhale_api/common/fields.py index 1a18b5f27..98e971662 100644 --- a/api/funkwhale_api/common/fields.py +++ b/api/funkwhale_api/common/fields.py @@ -1,5 +1,9 @@ +import django_filters + from django.db import models +from funkwhale_api.music import utils + PRIVACY_LEVEL_CHOICES = [ ('me', 'Only me'), @@ -25,3 +29,15 @@ def privacy_level_query(user, lookup_field='privacy_level'): 'followers', 'instance', 'everyone' ] }) + + +class SearchFilter(django_filters.CharFilter): + def __init__(self, *args, **kwargs): + self.search_fields = kwargs.pop('search_fields') + super().__init__(*args, **kwargs) + + def filter(self, qs, value): + if not value: + return qs + query = utils.get_query(value, self.search_fields) + return qs.filter(query) diff --git a/api/funkwhale_api/federation/activity.py b/api/funkwhale_api/federation/activity.py index 7d20d7f9c..becf6c96f 100644 --- a/api/funkwhale_api/federation/activity.py +++ b/api/funkwhale_api/federation/activity.py @@ -1,14 +1,5 @@ -import logging -import json -import requests_http_signature -import uuid - -from funkwhale_api.common import session - -from . import models -from . import signing - -logger = logging.getLogger(__name__) +from . import serializers +from . import tasks ACTIVITY_TYPES = [ 'Accept', @@ -61,86 +52,16 @@ OBJECT_TYPES = [ def deliver(activity, on_behalf_of, to=[]): - from . import actors - logger.info('Preparing activity delivery to %s', to) - auth = signing.get_auth( - on_behalf_of.private_key, on_behalf_of.private_key_id) - for url in to: - recipient_actor = actors.get_actor(url) - logger.debug('delivering to %s', recipient_actor.inbox_url) - logger.debug('activity content: %s', json.dumps(activity)) - response = session.get_session().post( - auth=auth, - json=activity, - url=recipient_actor.inbox_url, - headers={ - 'Content-Type': 'application/activity+json' - } - ) - response.raise_for_status() - logger.debug('Remote answered with %s', response.status_code) - - -def get_follow(follow_id, follower, followed): - return { - '@context': [ - 'https://www.w3.org/ns/activitystreams', - 'https://w3id.org/security/v1', - {} - ], - 'actor': follower.url, - 'id': follower.url + '#follows/{}'.format(follow_id), - 'object': followed.url, - 'type': 'Follow' - } - - -def get_undo(id, actor, object): - return { - '@context': [ - 'https://www.w3.org/ns/activitystreams', - 'https://w3id.org/security/v1', - {} - ], - 'type': 'Undo', - 'id': id + '/undo', - 'actor': actor.url, - 'object': object, - } - - -def get_accept_follow(accept_id, accept_actor, follow, follow_actor): - return { - "@context": [ - "https://www.w3.org/ns/activitystreams", - "https://w3id.org/security/v1", - {} - ], - "id": accept_actor.url + '#accepts/follows/{}'.format( - accept_id), - "type": "Accept", - "actor": accept_actor.url, - "object": { - "id": follow['id'], - "type": "Follow", - "actor": follow_actor.url, - "object": accept_actor.url - }, - } - - -def accept_follow(target, follow, actor): - accept_uuid = uuid.uuid4() - accept = get_accept_follow( - accept_id=accept_uuid, - accept_actor=target, - follow=follow, - follow_actor=actor) - deliver( - accept, - to=[actor.url], - on_behalf_of=target) - return models.Follow.objects.get_or_create( - actor=actor, - target=target, + return tasks.send.delay( + activity=activity, + actor_id=on_behalf_of.pk, + to=to ) + + +def accept_follow(follow): + serializer = serializers.AcceptFollowSerializer(follow) + return deliver( + serializer.data, + to=[follow.actor.url], + on_behalf_of=follow.target) diff --git a/api/funkwhale_api/federation/actors.py b/api/funkwhale_api/federation/actors.py index a461eb76a..27a418c7d 100644 --- a/api/funkwhale_api/federation/actors.py +++ b/api/funkwhale_api/federation/actors.py @@ -31,6 +31,8 @@ def remove_tags(text): def get_actor_data(actor_url): response = session.get_session().get( actor_url, + timeout=5, + verify=settings.EXTERNAL_REQUESTS_VERIFY_SSL, headers={ 'Accept': 'application/activity+json', } @@ -42,6 +44,7 @@ def get_actor_data(actor_url): raise ValueError( 'Invalid actor payload: {}'.format(response.text)) + def get_actor(actor_url): data = get_actor_data(actor_url) serializer = serializers.ActorSerializer(data=data) @@ -150,24 +153,32 @@ class SystemActor(object): def handle_follow(self, ac, sender): system_actor = self.get_actor_instance() - if self.manually_approves_followers: - fr, created = models.FollowRequest.objects.get_or_create( - actor=sender, - target=system_actor, - approved=None, - ) - return fr + serializer = serializers.FollowSerializer( + data=ac, context={'follow_actor': sender}) + if not serializer.is_valid(): + return logger.info('Invalid follow payload') + approved = True if not self.manually_approves_followers else None + follow = serializer.save(approved=approved) + if follow.approved: + return activity.accept_follow(follow) - return activity.accept_follow( - system_actor, ac, sender - ) + def handle_accept(self, ac, sender): + system_actor = self.get_actor_instance() + serializer = serializers.AcceptFollowSerializer( + data=ac, + context={'follow_target': sender, 'follow_actor': system_actor}) + if not serializer.is_valid(raise_exception=True): + return logger.info('Received invalid payload') + + return serializer.save() def handle_undo_follow(self, ac, sender): - actor = self.get_actor_instance() - models.Follow.objects.filter( - actor=sender, - target=actor, - ).delete() + system_actor = self.get_actor_instance() + serializer = serializers.UndoFollowSerializer( + data=ac, context={'actor': sender, 'target': system_actor}) + if not serializer.is_valid(): + return logger.info('Received invalid payload') + serializer.save() def handle_undo(self, ac, sender): if ac['object']['type'] != 'Follow': @@ -343,15 +354,15 @@ class TestActor(SystemActor): super().handle_follow(ac, sender) # also, we follow back test_actor = self.get_actor_instance() - follow_uuid = uuid.uuid4() - follow = activity.get_follow( - follow_id=follow_uuid, - follower=test_actor, - followed=sender) + follow_back = models.Follow.objects.get_or_create( + actor=test_actor, + target=sender, + approved=None, + )[0] activity.deliver( - follow, - to=[ac['actor']], - on_behalf_of=test_actor) + serializers.FollowSerializer(follow_back).data, + to=[follow_back.target.url], + on_behalf_of=follow_back.actor) def handle_undo_follow(self, ac, sender): super().handle_undo_follow(ac, sender) @@ -364,11 +375,7 @@ class TestActor(SystemActor): ) except models.Follow.DoesNotExist: return - undo = activity.get_undo( - id=follow.get_federation_url(), - actor=actor, - object=serializers.FollowSerializer(follow).data, - ) + undo = serializers.UndoFollowSerializer(follow).data follow.delete() activity.deliver( undo, diff --git a/api/funkwhale_api/federation/admin.py b/api/funkwhale_api/federation/admin.py new file mode 100644 index 000000000..6a097174b --- /dev/null +++ b/api/funkwhale_api/federation/admin.py @@ -0,0 +1,66 @@ +from django.contrib import admin + +from . import models + + +@admin.register(models.Actor) +class ActorAdmin(admin.ModelAdmin): + list_display = [ + 'url', + 'domain', + 'preferred_username', + 'type', + 'creation_date', + 'last_fetch_date'] + search_fields = ['url', 'domain', 'preferred_username'] + list_filter = [ + 'type' + ] + + +@admin.register(models.Follow) +class FollowAdmin(admin.ModelAdmin): + list_display = [ + 'actor', + 'target', + 'approved', + 'creation_date' + ] + list_filter = [ + 'approved' + ] + search_fields = ['actor__url', 'target__url'] + list_select_related = True + + +@admin.register(models.Library) +class LibraryAdmin(admin.ModelAdmin): + list_display = [ + 'actor', + 'url', + 'creation_date', + 'fetched_date', + 'tracks_count'] + search_fields = ['actor__url', 'url'] + list_filter = [ + 'federation_enabled', + 'download_files', + 'autoimport', + ] + list_select_related = True + + +@admin.register(models.LibraryTrack) +class LibraryTrackAdmin(admin.ModelAdmin): + list_display = [ + 'title', + 'artist_name', + 'album_title', + 'url', + 'library', + 'creation_date', + 'published_date', + ] + search_fields = [ + 'library__url', 'url', 'artist_name', 'title', 'album_title'] + list_select_related = True diff --git a/api/funkwhale_api/federation/api_urls.py b/api/funkwhale_api/federation/api_urls.py new file mode 100644 index 000000000..41dd1c0f9 --- /dev/null +++ b/api/funkwhale_api/federation/api_urls.py @@ -0,0 +1,15 @@ +from rest_framework import routers + +from . import views + +router = routers.SimpleRouter() +router.register( + r'libraries', + views.LibraryViewSet, + 'libraries') +router.register( + r'library-tracks', + views.LibraryTrackViewSet, + 'library-tracks') + +urlpatterns = router.urls diff --git a/api/funkwhale_api/federation/dynamic_preferences_registry.py b/api/funkwhale_api/federation/dynamic_preferences_registry.py index c7cb015a8..43877c75c 100644 --- a/api/funkwhale_api/federation/dynamic_preferences_registry.py +++ b/api/funkwhale_api/federation/dynamic_preferences_registry.py @@ -4,3 +4,17 @@ from dynamic_preferences import types from dynamic_preferences.registries import global_preferences_registry federation = types.Section('federation') + + +@global_preferences_registry.register +class MusicCacheDuration(types.IntPreference): + show_in_api = True + section = federation + name = 'music_cache_duration' + default = 60 * 24 * 2 + verbose_name = 'Music cache duration' + help_text = ( + 'How much minutes do you want to keep a copy of federated tracks' + 'locally? Federated files that were not listened in this interval ' + 'will be erased and refetched from the remote on the next listening.' + ) diff --git a/api/funkwhale_api/federation/factories.py b/api/funkwhale_api/federation/factories.py index b3ac72039..0754c4b2f 100644 --- a/api/funkwhale_api/federation/factories.py +++ b/api/funkwhale_api/federation/factories.py @@ -113,15 +113,6 @@ class FollowFactory(factory.DjangoModelFactory): ) -@registry.register -class FollowRequestFactory(factory.DjangoModelFactory): - target = factory.SubFactory(ActorFactory) - actor = factory.SubFactory(ActorFactory) - - class Meta: - model = models.FollowRequest - - @registry.register class LibraryFactory(factory.DjangoModelFactory): actor = factory.SubFactory(ActorFactory) @@ -194,6 +185,11 @@ class LibraryTrackFactory(factory.DjangoModelFactory): class Meta: model = models.LibraryTrack + class Params: + with_audio_file = factory.Trait( + audio_file=factory.django.FileField() + ) + @registry.register(name='federation.Note') class NoteFactory(factory.Factory): diff --git a/api/funkwhale_api/federation/filters.py b/api/funkwhale_api/federation/filters.py new file mode 100644 index 000000000..c911f1a89 --- /dev/null +++ b/api/funkwhale_api/federation/filters.py @@ -0,0 +1,66 @@ +import django_filters + +from funkwhale_api.common import fields + +from . import models + + +class LibraryFilter(django_filters.FilterSet): + approved = django_filters.BooleanFilter('following__approved') + q = fields.SearchFilter(search_fields=[ + 'actor__domain', + ]) + + class Meta: + model = models.Library + fields = { + 'approved': ['exact'], + 'federation_enabled': ['exact'], + 'download_files': ['exact'], + 'autoimport': ['exact'], + 'tracks_count': ['exact'], + } + + +class LibraryTrackFilter(django_filters.FilterSet): + library = django_filters.CharFilter('library__uuid') + q = fields.SearchFilter(search_fields=[ + 'artist_name', + 'title', + 'album_title', + 'library__actor__domain', + ]) + + class Meta: + model = models.LibraryTrack + fields = { + 'library': ['exact'], + 'artist_name': ['exact', 'icontains'], + 'title': ['exact', 'icontains'], + 'album_title': ['exact', 'icontains'], + 'audio_mimetype': ['exact', 'icontains'], + } + + +class FollowFilter(django_filters.FilterSet): + pending = django_filters.CharFilter(method='filter_pending') + ordering = django_filters.OrderingFilter( + # tuple-mapping retains order + fields=( + ('creation_date', 'creation_date'), + ('modification_date', 'modification_date'), + ), + ) + q = fields.SearchFilter(search_fields=[ + 'actor__domain', + 'actor__preferred_username', + ]) + + class Meta: + model = models.Follow + fields = ['approved', 'pending', 'q'] + + def filter_pending(self, queryset, field_name, value): + if value.lower() in ['true', '1', 'yes']: + queryset = queryset.filter(approved__isnull=True) + return queryset diff --git a/api/funkwhale_api/federation/library.py b/api/funkwhale_api/federation/library.py new file mode 100644 index 000000000..c53ce5430 --- /dev/null +++ b/api/funkwhale_api/federation/library.py @@ -0,0 +1,166 @@ +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 diff --git a/api/funkwhale_api/federation/migrations/0004_auto_20180410_2025.py b/api/funkwhale_api/federation/migrations/0004_auto_20180410_2025.py new file mode 100644 index 000000000..bea4d14ae --- /dev/null +++ b/api/funkwhale_api/federation/migrations/0004_auto_20180410_2025.py @@ -0,0 +1,35 @@ +# Generated by Django 2.0.3 on 2018-04-10 20:25 + +from django.db import migrations, models +import django.db.models.deletion + + +class Migration(migrations.Migration): + + dependencies = [ + ('federation', '0003_auto_20180407_1010'), + ] + + operations = [ + migrations.RemoveField( + model_name='followrequest', + name='actor', + ), + migrations.RemoveField( + model_name='followrequest', + name='target', + ), + migrations.AddField( + model_name='follow', + name='approved', + field=models.NullBooleanField(default=None), + ), + migrations.AddField( + model_name='library', + name='follow', + field=models.OneToOneField(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='library', to='federation.Follow'), + ), + migrations.DeleteModel( + name='FollowRequest', + ), + ] diff --git a/api/funkwhale_api/federation/migrations/0005_auto_20180413_1723.py b/api/funkwhale_api/federation/migrations/0005_auto_20180413_1723.py new file mode 100644 index 000000000..00ba5c83d --- /dev/null +++ b/api/funkwhale_api/federation/migrations/0005_auto_20180413_1723.py @@ -0,0 +1,26 @@ +# Generated by Django 2.0.3 on 2018-04-13 17:23 + +import django.contrib.postgres.fields.jsonb +import django.core.serializers.json +from django.db import migrations, models +import funkwhale_api.federation.models + + +class Migration(migrations.Migration): + + dependencies = [ + ('federation', '0004_auto_20180410_2025'), + ] + + operations = [ + migrations.AddField( + model_name='librarytrack', + name='audio_file', + field=models.FileField(blank=True, null=True, upload_to=funkwhale_api.federation.models.get_file_path), + ), + migrations.AlterField( + model_name='librarytrack', + name='metadata', + field=django.contrib.postgres.fields.jsonb.JSONField(default={}, encoder=django.core.serializers.json.DjangoJSONEncoder, max_length=10000), + ), + ] diff --git a/api/funkwhale_api/federation/models.py b/api/funkwhale_api/federation/models.py index bf1e5d830..066c5847b 100644 --- a/api/funkwhale_api/federation/models.py +++ b/api/funkwhale_api/federation/models.py @@ -1,10 +1,16 @@ +import os import uuid +import tempfile from django.conf import settings from django.contrib.postgres.fields import JSONField +from django.core.serializers.json import DjangoJSONEncoder from django.db import models from django.utils import timezone +from funkwhale_api.common import session +from funkwhale_api.music import utils as music_utils + TYPE_CHOICES = [ ('Person', 'Person'), ('Application', 'Application'), @@ -109,6 +115,7 @@ class Follow(models.Model): creation_date = models.DateTimeField(default=timezone.now) modification_date = models.DateTimeField( auto_now=True) + approved = models.NullBooleanField(default=None) class Meta: unique_together = ['actor', 'target'] @@ -117,49 +124,6 @@ class Follow(models.Model): return '{}#follows/{}'.format(self.actor.url, self.uuid) -class FollowRequest(models.Model): - uuid = models.UUIDField(default=uuid.uuid4, unique=True) - actor = models.ForeignKey( - Actor, - related_name='emmited_follow_requests', - on_delete=models.CASCADE, - ) - target = models.ForeignKey( - Actor, - related_name='received_follow_requests', - on_delete=models.CASCADE, - ) - creation_date = models.DateTimeField(default=timezone.now) - modification_date = models.DateTimeField( - auto_now=True) - approved = models.NullBooleanField(default=None) - - def approve(self): - from . import activity - from . import serializers - self.approved = True - self.save(update_fields=['approved']) - Follow.objects.get_or_create( - target=self.target, - actor=self.actor - ) - if self.target.is_local: - follow = { - '@context': serializers.AP_CONTEXT, - 'actor': self.actor.url, - 'id': self.actor.url + '#follows/{}'.format(uuid.uuid4()), - 'object': self.target.url, - 'type': 'Follow' - } - activity.accept_follow( - self.target, follow, self.actor - ) - - def refuse(self): - self.approved = False - self.save(update_fields=['approved']) - - class Library(models.Model): creation_date = models.DateTimeField(default=timezone.now) modification_date = models.DateTimeField( @@ -179,12 +143,32 @@ class Library(models.Model): # should we automatically import new files from this library? autoimport = models.BooleanField() tracks_count = models.PositiveIntegerField(null=True, blank=True) + follow = models.OneToOneField( + Follow, + related_name='library', + null=True, + blank=True, + on_delete=models.SET_NULL, + ) + + +def get_file_path(instance, filename): + uid = str(uuid.uuid4()) + chunk_size = 2 + chunks = [uid[i:i+chunk_size] for i in range(0, len(uid), chunk_size)] + parts = chunks[:3] + [filename] + return os.path.join('federation_cache', *parts) class LibraryTrack(models.Model): url = models.URLField(unique=True) audio_url = models.URLField() audio_mimetype = models.CharField(max_length=200) + audio_file = models.FileField( + upload_to=get_file_path, + null=True, + blank=True) + creation_date = models.DateTimeField(default=timezone.now) modification_date = models.DateTimeField( auto_now=True) @@ -195,4 +179,35 @@ class LibraryTrack(models.Model): artist_name = models.CharField(max_length=500) album_title = models.CharField(max_length=500) title = models.CharField(max_length=500) - metadata = JSONField(default={}, max_length=10000) + metadata = JSONField( + default={}, max_length=10000, encoder=DjangoJSONEncoder) + + @property + def mbid(self): + try: + return self.metadata['recording']['musicbrainz_id'] + except KeyError: + pass + + def download_audio(self): + from . import actors + auth = actors.SYSTEM_ACTORS['library'].get_request_auth() + remote_response = session.get_session().get( + self.audio_url, + auth=auth, + stream=True, + timeout=20, + verify=settings.EXTERNAL_REQUESTS_VERIFY_SSL, + headers={ + 'Content-Type': 'application/activity+json' + } + ) + with remote_response as r: + remote_response.raise_for_status() + extension = music_utils.get_ext_from_type(self.audio_mimetype) + title = ' - '.join([self.title, self.album_title, self.artist_name]) + filename = '{}.{}'.format(title, extension) + tmp_file = tempfile.TemporaryFile() + for chunk in r.iter_content(chunk_size=512): + tmp_file.write(chunk) + self.audio_file.save(filename, tmp_file) diff --git a/api/funkwhale_api/federation/serializers.py b/api/funkwhale_api/federation/serializers.py index 17541c50f..4964106d8 100644 --- a/api/funkwhale_api/federation/serializers.py +++ b/api/funkwhale_api/federation/serializers.py @@ -8,7 +8,7 @@ from django.db import transaction from rest_framework import serializers from dynamic_preferences.registries import global_preferences_registry -from funkwhale_api.common.utils import set_query_parameter +from funkwhale_api.common import utils as funkwhale_utils from . import activity from . import models @@ -21,38 +21,39 @@ AP_CONTEXT = [ {}, ] -class ActorSerializer(serializers.ModelSerializer): - # left maps to activitypub fields, right to our internal models - id = serializers.URLField(source='url') - outbox = serializers.URLField(source='outbox_url') - inbox = serializers.URLField(source='inbox_url') - following = serializers.URLField(source='following_url', required=False) - followers = serializers.URLField(source='followers_url', required=False) - preferredUsername = serializers.CharField( - source='preferred_username', required=False) - publicKey = serializers.JSONField(source='public_key', required=False) - manuallyApprovesFollowers = serializers.NullBooleanField( - source='manually_approves_followers', required=False) - summary = serializers.CharField(max_length=None, required=False) - class Meta: - model = models.Actor - fields = [ - 'id', - 'type', - 'name', - 'summary', - 'preferredUsername', - 'publicKey', - 'inbox', - 'outbox', - 'following', - 'followers', - 'manuallyApprovesFollowers', - ] +class ActorSerializer(serializers.Serializer): + id = serializers.URLField() + outbox = serializers.URLField() + inbox = serializers.URLField() + type = serializers.ChoiceField(choices=models.TYPE_CHOICES) + preferredUsername = serializers.CharField() + manuallyApprovesFollowers = serializers.NullBooleanField(required=False) + name = serializers.CharField(required=False, max_length=200) + summary = serializers.CharField(max_length=None, required=False) + followers = serializers.URLField(required=False, allow_null=True) + following = serializers.URLField(required=False, allow_null=True) + publicKey = serializers.JSONField(required=False) def to_representation(self, instance): - ret = super().to_representation(instance) + ret = { + 'id': instance.url, + 'outbox': instance.outbox_url, + 'inbox': instance.inbox_url, + 'preferredUsername': instance.preferred_username, + 'type': instance.type, + } + if instance.name: + ret['name'] = instance.name + if instance.followers_url: + ret['followers'] = instance.followers_url + if instance.following_url: + ret['following'] = instance.following_url + if instance.summary: + ret['summary'] = instance.summary + if instance.manually_approves_followers is not None: + ret['manuallyApprovesFollowers'] = instance.manually_approves_followers + ret['@context'] = AP_CONTEXT if instance.public_key: ret['publicKey'] = { @@ -66,8 +67,21 @@ class ActorSerializer(serializers.ModelSerializer): return ret def prepare_missing_fields(self): - kwargs = {} - domain = urllib.parse.urlparse(self.validated_data['url']).netloc + kwargs = { + 'url': self.validated_data['id'], + 'outbox_url': self.validated_data['outbox'], + 'inbox_url': self.validated_data['inbox'], + 'following_url': self.validated_data.get('following'), + 'followers_url': self.validated_data.get('followers'), + 'summary': self.validated_data.get('summary'), + 'type': self.validated_data['type'], + 'name': self.validated_data.get('name'), + 'preferred_username': self.validated_data['preferredUsername'], + } + maf = self.validated_data.get('manuallyApprovesFollowers') + if maf is not None: + kwargs['manually_approves_followers'] = maf + domain = urllib.parse.urlparse(kwargs['url']).netloc kwargs['domain'] = domain for endpoint, url in self.initial_data.get('endpoints', {}).items(): if endpoint == 'sharedInbox': @@ -80,45 +94,386 @@ class ActorSerializer(serializers.ModelSerializer): return kwargs def build(self): - d = self.validated_data.copy() - d.update(self.prepare_missing_fields()) - return self.Meta.model(**d) + d = self.prepare_missing_fields() + return models.Actor(**d) def save(self, **kwargs): - kwargs.update(self.prepare_missing_fields()) - return super().save(**kwargs) + d = self.prepare_missing_fields() + d.update(kwargs) + return models.Actor.objects.create( + **d + ) def validate_summary(self, value): if value: return value[:500] -class FollowSerializer(serializers.ModelSerializer): - # left maps to activitypub fields, right to our internal models - id = serializers.URLField(source='get_federation_url') - object = serializers.URLField(source='target.url') - actor = serializers.URLField(source='actor.url') - type = serializers.CharField(source='ap_type') - +class APIActorSerializer(serializers.ModelSerializer): class Meta: model = models.Actor fields = [ 'id', - 'object', - 'actor', - 'type' + 'url', + 'creation_date', + 'summary', + 'preferred_username', + 'name', + 'last_fetch_date', + 'domain', + 'type', + 'manually_approves_followers', + ] + +class LibraryActorSerializer(ActorSerializer): + url = serializers.ListField( + child=serializers.JSONField()) + + def validate(self, validated_data): + try: + urls = validated_data['url'] + except KeyError: + raise serializers.ValidationError('Missing URL field') + + for u in urls: + try: + if u['name'] != 'library': + continue + validated_data['library_url'] = u['href'] + break + except KeyError: + continue + + return validated_data + + +class APIFollowSerializer(serializers.ModelSerializer): + class Meta: + model = models.Follow + fields = [ + 'uuid', + 'actor', + 'target', + 'approved', + 'creation_date', + 'modification_date', + ] + + +class APILibrarySerializer(serializers.ModelSerializer): + actor = APIActorSerializer() + follow = APIFollowSerializer() + + class Meta: + model = models.Library + + read_only_fields = [ + 'actor', + 'uuid', + 'url', + 'tracks_count', + 'follow', + 'fetched_date', + 'modification_date', + 'creation_date', + ] + fields = [ + 'autoimport', + 'federation_enabled', + 'download_files', + ] + read_only_fields + + +class APILibraryScanSerializer(serializers.Serializer): + until = serializers.DateTimeField(required=False) + + +class APILibraryFollowUpdateSerializer(serializers.Serializer): + follow = serializers.IntegerField() + approved = serializers.BooleanField() + + def validate_follow(self, value): + from . import actors + library_actor = actors.SYSTEM_ACTORS['library'].get_actor_instance() + qs = models.Follow.objects.filter( + pk=value, + target=library_actor, + ) + try: + return qs.get() + except models.Follow.DoesNotExist: + raise serializers.ValidationError('Invalid follow') + + def save(self): + new_status = self.validated_data['approved'] + follow = self.validated_data['follow'] + if new_status == follow.approved: + return follow + + follow.approved = new_status + follow.save(update_fields=['approved', 'modification_date']) + if new_status: + activity.accept_follow(follow) + return follow + + +class APILibraryCreateSerializer(serializers.ModelSerializer): + actor = serializers.URLField() + federation_enabled = serializers.BooleanField() + uuid = serializers.UUIDField(read_only=True) + + class Meta: + model = models.Library + fields = [ + 'uuid', + 'actor', + 'autoimport', + 'federation_enabled', + 'download_files', + ] + + def validate(self, validated_data): + from . import actors + from . import library + + actor_url = validated_data['actor'] + actor_data = actors.get_actor_data(actor_url) + acs = LibraryActorSerializer(data=actor_data) + acs.is_valid(raise_exception=True) + try: + actor = models.Actor.objects.get(url=actor_url) + except models.Actor.DoesNotExist: + actor = acs.save() + library_actor = actors.SYSTEM_ACTORS['library'].get_actor_instance() + validated_data['follow'] = models.Follow.objects.get_or_create( + actor=library_actor, + target=actor, + )[0] + if validated_data['follow'].approved is None: + funkwhale_utils.on_commit( + activity.deliver, + FollowSerializer(validated_data['follow']).data, + on_behalf_of=validated_data['follow'].actor, + to=[validated_data['follow'].target.url], + ) + + library_data = library.get_library_data( + acs.validated_data['library_url']) + if 'errors' in library_data: + # we pass silently because it may means we require permission + # before scanning + pass + validated_data['library'] = library_data + validated_data['library'].setdefault( + 'id', acs.validated_data['library_url'] + ) + validated_data['actor'] = actor + return validated_data + + def create(self, validated_data): + library = models.Library.objects.update_or_create( + url=validated_data['library']['id'], + defaults={ + 'actor': validated_data['actor'], + 'follow': validated_data['follow'], + 'tracks_count': validated_data['library'].get('totalItems'), + 'federation_enabled': validated_data['federation_enabled'], + 'autoimport': validated_data['autoimport'], + 'download_files': validated_data['download_files'], + } + )[0] + return library + + +class APILibraryTrackSerializer(serializers.ModelSerializer): + library = APILibrarySerializer() + + class Meta: + model = models.LibraryTrack + fields = [ + 'id', + 'url', + 'audio_url', + 'audio_mimetype', + 'creation_date', + 'modification_date', + 'fetched_date', + 'published_date', + 'metadata', + 'artist_name', + 'album_title', + 'title', + 'library', + 'local_track_file', + ] + + +class FollowSerializer(serializers.Serializer): + id = serializers.URLField() + object = serializers.URLField() + actor = serializers.URLField() + type = serializers.ChoiceField(choices=['Follow']) + + def validate_object(self, v): + expected = self.context.get('follow_target') + if expected and expected.url != v: + raise serializers.ValidationError('Invalid target') + try: + return models.Actor.objects.get(url=v) + except models.Actor.DoesNotExist: + raise serializers.ValidationError('Target not found') + + def validate_actor(self, v): + expected = self.context.get('follow_actor') + if expected and expected.url != v: + raise serializers.ValidationError('Invalid actor') + try: + return models.Actor.objects.get(url=v) + except models.Actor.DoesNotExist: + raise serializers.ValidationError('Actor not found') + + def save(self, **kwargs): + return models.Follow.objects.get_or_create( + actor=self.validated_data['actor'], + target=self.validated_data['object'], + **kwargs, + )[0] + def to_representation(self, instance): - ret = super().to_representation(instance) - ret['@context'] = AP_CONTEXT + return { + '@context': AP_CONTEXT, + 'actor': instance.actor.url, + 'id': instance.get_federation_url(), + 'object': instance.target.url, + 'type': 'Follow' + } return ret -class ActorWebfingerSerializer(serializers.ModelSerializer): +class APIFollowSerializer(serializers.ModelSerializer): + actor = APIActorSerializer() + target = APIActorSerializer() + class Meta: - model = models.Actor - fields = ['url'] + model = models.Follow + fields = [ + 'uuid', + 'id', + 'approved', + 'creation_date', + 'modification_date', + 'actor', + 'target', + ] + + +class AcceptFollowSerializer(serializers.Serializer): + id = serializers.URLField() + actor = serializers.URLField() + object = FollowSerializer() + type = serializers.ChoiceField(choices=['Accept']) + + def validate_actor(self, v): + expected = self.context.get('follow_target') + if expected and expected.url != v: + raise serializers.ValidationError('Invalid actor') + try: + return models.Actor.objects.get(url=v) + except models.Actor.DoesNotExist: + raise serializers.ValidationError('Actor not found') + + def validate(self, validated_data): + # we ensure the accept actor actually match the follow target + if validated_data['actor'] != validated_data['object']['object']: + raise serializers.ValidationError('Actor mismatch') + try: + validated_data['follow'] = models.Follow.objects.filter( + target=validated_data['actor'], + actor=validated_data['object']['actor'] + ).exclude(approved=True).get() + except models.Follow.DoesNotExist: + raise serializers.ValidationError('No follow to accept') + return validated_data + + def to_representation(self, instance): + return { + "@context": AP_CONTEXT, + "id": instance.get_federation_url() + '/accept', + "type": "Accept", + "actor": instance.target.url, + "object": FollowSerializer(instance).data + } + + def save(self): + self.validated_data['follow'].approved = True + self.validated_data['follow'].save() + return self.validated_data['follow'] + + +class UndoFollowSerializer(serializers.Serializer): + id = serializers.URLField() + actor = serializers.URLField() + object = FollowSerializer() + type = serializers.ChoiceField(choices=['Undo']) + + def validate_actor(self, v): + expected = self.context.get('follow_target') + if expected and expected.url != v: + raise serializers.ValidationError('Invalid actor') + try: + return models.Actor.objects.get(url=v) + except models.Actor.DoesNotExist: + raise serializers.ValidationError('Actor not found') + + def validate(self, validated_data): + # we ensure the accept actor actually match the follow actor + if validated_data['actor'] != validated_data['object']['actor']: + raise serializers.ValidationError('Actor mismatch') + try: + validated_data['follow'] = models.Follow.objects.filter( + actor=validated_data['actor'], + target=validated_data['object']['object'] + ).get() + except models.Follow.DoesNotExist: + raise serializers.ValidationError('No follow to remove') + return validated_data + + def to_representation(self, instance): + return { + "@context": AP_CONTEXT, + "id": instance.get_federation_url() + '/undo', + "type": "Undo", + "actor": instance.actor.url, + "object": FollowSerializer(instance).data + } + + def save(self): + return self.validated_data['follow'].delete() + + +class ActorWebfingerSerializer(serializers.Serializer): + subject = serializers.CharField() + aliases = serializers.ListField(child=serializers.URLField()) + links = serializers.ListField() + actor_url = serializers.URLField(required=False) + + def validate(self, validated_data): + validated_data['actor_url'] = None + for l in validated_data['links']: + try: + if not l['rel'] == 'self': + continue + if not l['type'] == 'application/activity+json': + continue + validated_data['actor_url'] = l['href'] + break + except KeyError: + pass + if validated_data['actor_url'] is None: + raise serializers.ValidationError('No valid actor url found') + return validated_data def to_representation(self, instance): data = {} @@ -206,15 +561,22 @@ OBJECT_SERIALIZERS = { class PaginatedCollectionSerializer(serializers.Serializer): + type = serializers.ChoiceField(choices=['Collection']) + totalItems = serializers.IntegerField(min_value=0) + actor = serializers.URLField() + id = serializers.URLField() + first = serializers.URLField() + last = serializers.URLField() def to_representation(self, conf): paginator = Paginator( conf['items'], conf.get('page_size', 20) ) - first = set_query_parameter(conf['id'], page=1) + first = funkwhale_utils.set_query_parameter(conf['id'], page=1) current = first - last = set_query_parameter(conf['id'], page=paginator.num_pages) + last = funkwhale_utils.set_query_parameter( + conf['id'], page=paginator.num_pages) d = { 'id': conf['id'], 'actor': conf['actor'].url, @@ -230,12 +592,35 @@ class PaginatedCollectionSerializer(serializers.Serializer): class CollectionPageSerializer(serializers.Serializer): + type = serializers.ChoiceField(choices=['CollectionPage']) + totalItems = serializers.IntegerField(min_value=0) + items = serializers.ListField() + actor = serializers.URLField() + id = serializers.URLField() + first = serializers.URLField() + last = serializers.URLField() + next = serializers.URLField(required=False) + prev = serializers.URLField(required=False) + partOf = serializers.URLField() + + def validate_items(self, v): + item_serializer = self.context.get('item_serializer') + if not item_serializer: + return v + raw_items = [item_serializer(data=i, context=self.context) for i in v] + for i in raw_items: + i.is_valid(raise_exception=True) + + return raw_items def to_representation(self, conf): page = conf['page'] - first = set_query_parameter(conf['id'], page=1) - last = set_query_parameter(conf['id'], page=page.paginator.num_pages) - id = set_query_parameter(conf['id'], page=page.number) + first = funkwhale_utils.set_query_parameter( + conf['id'], page=1) + last = funkwhale_utils.set_query_parameter( + conf['id'], page=page.paginator.num_pages) + id = funkwhale_utils.set_query_parameter( + conf['id'], page=page.number) d = { 'id': id, 'partOf': conf['id'], @@ -256,11 +641,11 @@ class CollectionPageSerializer(serializers.Serializer): } if page.has_previous(): - d['prev'] = set_query_parameter( + d['prev'] = funkwhale_utils.set_query_parameter( conf['id'], page=page.previous_page_number()) - if page.has_previous(): - d['next'] = set_query_parameter( + if page.has_next(): + d['next'] = funkwhale_utils.set_query_parameter( conf['id'], page=page.next_page_number()) if self.context.get('include_ap_context', True): diff --git a/api/funkwhale_api/federation/tasks.py b/api/funkwhale_api/federation/tasks.py new file mode 100644 index 000000000..adc354c4f --- /dev/null +++ b/api/funkwhale_api/federation/tasks.py @@ -0,0 +1,111 @@ +import datetime +import json +import logging + +from django.conf import settings +from django.utils import timezone + +from requests.exceptions import RequestException +from dynamic_preferences.registries import global_preferences_registry + +from funkwhale_api.common import session +from funkwhale_api.history.models import Listening +from funkwhale_api.taskapp import celery + +from . import actors +from . import library as lb +from . import models +from . import signing + + +logger = logging.getLogger(__name__) + + +@celery.app.task( + name='federation.send', + autoretry_for=[RequestException], + retry_backoff=30, + max_retries=5) +@celery.require_instance(models.Actor, 'actor') +def send(activity, actor, to): + logger.info('Preparing activity delivery to %s', to) + auth = signing.get_auth( + actor.private_key, actor.private_key_id) + for url in to: + recipient_actor = actors.get_actor(url) + logger.debug('delivering to %s', recipient_actor.inbox_url) + logger.debug('activity content: %s', json.dumps(activity)) + response = session.get_session().post( + auth=auth, + json=activity, + url=recipient_actor.inbox_url, + timeout=5, + verify=settings.EXTERNAL_REQUESTS_VERIFY_SSL, + headers={ + 'Content-Type': 'application/activity+json' + } + ) + response.raise_for_status() + logger.debug('Remote answered with %s', response.status_code) + + +@celery.app.task( + name='federation.scan_library', + autoretry_for=[RequestException], + retry_backoff=30, + max_retries=5) +@celery.require_instance(models.Library, 'library') +def scan_library(library, until=None): + if not library.federation_enabled: + return + + data = lb.get_library_data(library.url) + scan_library_page.delay( + library_id=library.id, page_url=data['first'], until=until) + library.fetched_date = timezone.now() + library.tracks_count = data['totalItems'] + library.save(update_fields=['fetched_date', 'tracks_count']) + + +@celery.app.task( + name='federation.scan_library_page', + autoretry_for=[RequestException], + retry_backoff=30, + max_retries=5) +@celery.require_instance(models.Library, 'library') +def scan_library_page(library, page_url, until=None): + if not library.federation_enabled: + return + + data = lb.get_library_page(library, page_url) + lts = [] + for item_serializer in data['items']: + item_date = item_serializer.validated_data['published'] + if until and item_date < until: + return + lts.append(item_serializer.save()) + + next_page = data.get('next') + if next_page and next_page != page_url: + scan_library_page.delay(library_id=library.id, page_url=next_page) + + +@celery.app.task(name='federation.clean_music_cache') +def clean_music_cache(): + preferences = global_preferences_registry.manager() + delay = preferences['federation__music_cache_duration'] + if delay < 1: + return # cache clearing disabled + + candidates = models.LibraryTrack.objects.filter( + audio_file__isnull=False + ).values_list('local_track_file__track', flat=True) + listenings = Listening.objects.filter( + creation_date__gte=timezone.now() - datetime.timedelta(minutes=delay), + track__pk__in=candidates).values_list('track', flat=True) + too_old = set(candidates) - set(listenings) + + to_remove = models.LibraryTrack.objects.filter( + local_track_file__track__pk__in=too_old).only('audio_file') + for lt in to_remove: + lt.audio_file.delete() diff --git a/api/funkwhale_api/federation/views.py b/api/funkwhale_api/federation/views.py index 35d8a75a5..381f87eff 100644 --- a/api/funkwhale_api/federation/views.py +++ b/api/funkwhale_api/federation/views.py @@ -1,21 +1,32 @@ from django import forms from django.conf import settings from django.core import paginator +from django.db import transaction from django.http import HttpResponse from django.urls import reverse -from rest_framework import viewsets -from rest_framework import views +from rest_framework import mixins +from rest_framework import permissions as rest_permissions from rest_framework import response +from rest_framework import views +from rest_framework import viewsets from rest_framework.decorators import list_route, detail_route +from rest_framework.serializers import ValidationError +from funkwhale_api.common import utils as funkwhale_utils +from funkwhale_api.common.permissions import HasModelPermission from funkwhale_api.music.models import TrackFile +from . import activity from . import actors from . import authentication +from . import filters +from . import library +from . import models from . import permissions from . import renderers from . import serializers +from . import tasks from . import utils from . import webfinger @@ -58,7 +69,7 @@ class InstanceActorViewSet(FederationMixin, viewsets.GenericViewSet): data = handler(request.data, actor=request.actor) except NotImplementedError: return response.Response(status=405) - return response.Response(data, status=200) + return response.Response({}, status=200) @detail_route(methods=['get', 'post']) def outbox(self, request, *args, **kwargs): @@ -70,7 +81,7 @@ class InstanceActorViewSet(FederationMixin, viewsets.GenericViewSet): data = handler(request.data, actor=request.actor) except NotImplementedError: return response.Response(status=405) - return response.Response(data, status=200) + return response.Response({}, status=200) class WellKnownViewSet(FederationMixin, viewsets.GenericViewSet): @@ -121,7 +132,7 @@ class MusicFilesViewSet(FederationMixin, viewsets.GenericViewSet): qs = TrackFile.objects.order_by('-creation_date').select_related( 'track__artist', 'track__album__artist' - ) + ).filter(library_track__isnull=True) if page is None: conf = { 'id': utils.full_url(reverse('federation:music:files-list')), @@ -154,3 +165,127 @@ class MusicFilesViewSet(FederationMixin, viewsets.GenericViewSet): return response.Response(status=404) return response.Response(data) + + +class LibraryPermission(HasModelPermission): + model = models.Library + + +class LibraryViewSet( + mixins.RetrieveModelMixin, + mixins.UpdateModelMixin, + mixins.ListModelMixin, + viewsets.GenericViewSet): + permission_classes = [LibraryPermission] + queryset = models.Library.objects.all().select_related( + 'actor', + 'follow', + ) + lookup_field = 'uuid' + filter_class = filters.LibraryFilter + serializer_class = serializers.APILibrarySerializer + ordering_fields = ( + 'id', + 'creation_date', + 'fetched_date', + 'actor__domain', + 'tracks_count', + ) + + @list_route(methods=['get']) + def fetch(self, request, *args, **kwargs): + account = request.GET.get('account') + if not account: + return response.Response( + {'account': 'This field is mandatory'}, status=400) + + data = library.scan_from_account_name(account) + return response.Response(data) + + @detail_route(methods=['post']) + def scan(self, request, *args, **kwargs): + library = self.get_object() + serializer = serializers.APILibraryScanSerializer( + data=request.data + ) + serializer.is_valid(raise_exception=True) + result = tasks.scan_library.delay( + library_id=library.pk, + until=serializer.validated_data.get('until') + ) + return response.Response({'task': result.id}) + + @list_route(methods=['get']) + def following(self, request, *args, **kwargs): + library_actor = actors.SYSTEM_ACTORS['library'].get_actor_instance() + queryset = models.Follow.objects.filter( + actor=library_actor + ).select_related( + 'actor', + 'target', + ).order_by('-creation_date') + filterset = filters.FollowFilter(request.GET, queryset=queryset) + final_qs = filterset.qs + serializer = serializers.APIFollowSerializer(final_qs, many=True) + data = { + 'results': serializer.data, + 'count': len(final_qs), + } + return response.Response(data) + + @list_route(methods=['get', 'patch']) + def followers(self, request, *args, **kwargs): + if request.method.lower() == 'patch': + serializer = serializers.APILibraryFollowUpdateSerializer( + data=request.data) + serializer.is_valid(raise_exception=True) + follow = serializer.save() + return response.Response( + serializers.APIFollowSerializer(follow).data + ) + + library_actor = actors.SYSTEM_ACTORS['library'].get_actor_instance() + queryset = models.Follow.objects.filter( + target=library_actor + ).select_related( + 'actor', + 'target', + ).order_by('-creation_date') + filterset = filters.FollowFilter(request.GET, queryset=queryset) + final_qs = filterset.qs + serializer = serializers.APIFollowSerializer(final_qs, many=True) + data = { + 'results': serializer.data, + 'count': len(final_qs), + } + return response.Response(data) + + @transaction.atomic + def create(self, request, *args, **kwargs): + serializer = serializers.APILibraryCreateSerializer(data=request.data) + serializer.is_valid(raise_exception=True) + library = serializer.save() + return response.Response(serializer.data, status=201) + + +class LibraryTrackViewSet( + mixins.ListModelMixin, + viewsets.GenericViewSet): + permission_classes = [LibraryPermission] + queryset = models.LibraryTrack.objects.all().select_related( + 'library__actor', + 'library__follow', + 'local_track_file', + ) + filter_class = filters.LibraryTrackFilter + serializer_class = serializers.APILibraryTrackSerializer + ordering_fields = ( + 'id', + 'artist_name', + 'title', + 'album_title', + 'creation_date', + 'modification_date', + 'fetched_date', + 'published_date', + ) diff --git a/api/funkwhale_api/federation/webfinger.py b/api/funkwhale_api/federation/webfinger.py index 4e9753385..f5cb99635 100644 --- a/api/funkwhale_api/federation/webfinger.py +++ b/api/funkwhale_api/federation/webfinger.py @@ -2,8 +2,11 @@ from django import forms from django.conf import settings from django.urls import reverse +from funkwhale_api.common import session + from . import actors from . import utils +from . import serializers VALID_RESOURCE_TYPES = ['acct'] @@ -23,17 +26,32 @@ def clean_resource(resource_string): return resource_type, resource -def clean_acct(acct_string): +def clean_acct(acct_string, ensure_local=True): try: username, hostname = acct_string.split('@') except ValueError: raise forms.ValidationError('Invalid format') - if hostname.lower() != settings.FEDERATION_HOSTNAME: + if ensure_local and hostname.lower() != settings.FEDERATION_HOSTNAME: raise forms.ValidationError( 'Invalid hostname {}'.format(hostname)) - if username not in actors.SYSTEM_ACTORS: + if ensure_local and username not in actors.SYSTEM_ACTORS: raise forms.ValidationError('Invalid username') return username, hostname + + +def get_resource(resource_string): + resource_type, resource = clean_resource(resource_string) + username, hostname = clean_acct(resource, ensure_local=False) + url = 'https://{}/.well-known/webfinger?resource={}'.format( + hostname, resource_string) + response = session.get_session().get( + url, + verify=settings.EXTERNAL_REQUESTS_VERIFY_SSL, + timeout=5) + response.raise_for_status() + serializer = serializers.ActorWebfingerSerializer(data=response.json()) + serializer.is_valid(raise_exception=True) + return serializer.validated_data diff --git a/api/funkwhale_api/music/forms.py b/api/funkwhale_api/music/forms.py index 04e4bfe05..e68ab73cc 100644 --- a/api/funkwhale_api/music/forms.py +++ b/api/funkwhale_api/music/forms.py @@ -19,5 +19,5 @@ class TranscodeForm(forms.Form): choices=BITRATE_CHOICES, required=False) track_file = forms.ModelChoiceField( - queryset=models.TrackFile.objects.all() + queryset=models.TrackFile.objects.exclude(audio_file__isnull=True) ) diff --git a/api/funkwhale_api/music/migrations/0023_auto_20180407_1010.py b/api/funkwhale_api/music/migrations/0023_auto_20180407_1010.py index 0539d90f6..ed7404ac4 100644 --- a/api/funkwhale_api/music/migrations/0023_auto_20180407_1010.py +++ b/api/funkwhale_api/music/migrations/0023_auto_20180407_1010.py @@ -4,7 +4,6 @@ from django.conf import settings from django.db import migrations, models import django.db.models.deletion import django.utils.timezone -import uuid class Migration(migrations.Migration): @@ -18,17 +17,17 @@ class Migration(migrations.Migration): migrations.AddField( model_name='album', name='uuid', - field=models.UUIDField(db_index=True, default=uuid.uuid4, unique=True), + field=models.UUIDField(db_index=True, null=True, unique=True), ), migrations.AddField( model_name='artist', name='uuid', - field=models.UUIDField(db_index=True, default=uuid.uuid4, unique=True), + field=models.UUIDField(db_index=True, null=True, unique=True), ), migrations.AddField( model_name='importbatch', name='uuid', - field=models.UUIDField(db_index=True, default=uuid.uuid4, unique=True), + field=models.UUIDField(db_index=True, null=True, unique=True), ), migrations.AddField( model_name='importjob', @@ -38,17 +37,17 @@ class Migration(migrations.Migration): migrations.AddField( model_name='importjob', name='uuid', - field=models.UUIDField(db_index=True, default=uuid.uuid4, unique=True), + field=models.UUIDField(db_index=True, null=True, unique=True), ), migrations.AddField( model_name='lyrics', name='uuid', - field=models.UUIDField(db_index=True, default=uuid.uuid4, unique=True), + field=models.UUIDField(db_index=True, null=True, unique=True), ), migrations.AddField( model_name='track', name='uuid', - field=models.UUIDField(db_index=True, default=uuid.uuid4, unique=True), + field=models.UUIDField(db_index=True, null=True, unique=True), ), migrations.AddField( model_name='trackfile', @@ -68,12 +67,12 @@ class Migration(migrations.Migration): migrations.AddField( model_name='trackfile', name='uuid', - field=models.UUIDField(db_index=True, default=uuid.uuid4, unique=True), + field=models.UUIDField(db_index=True, null=True, unique=True), ), migrations.AddField( model_name='work', name='uuid', - field=models.UUIDField(db_index=True, default=uuid.uuid4, unique=True), + field=models.UUIDField(db_index=True, null=True, unique=True), ), migrations.AlterField( model_name='importbatch', diff --git a/api/funkwhale_api/music/migrations/0024_populate_uuid.py b/api/funkwhale_api/music/migrations/0024_populate_uuid.py new file mode 100644 index 000000000..10c78a3db --- /dev/null +++ b/api/funkwhale_api/music/migrations/0024_populate_uuid.py @@ -0,0 +1,80 @@ +# -*- coding: utf-8 -*- +from __future__ import unicode_literals +import os +import uuid +from django.db import migrations, models + + +def populate_uuids(apps, schema_editor): + models = [ + 'Album', + 'Artist', + 'Importbatch', + 'Importjob', + 'Lyrics', + 'Track', + 'Trackfile', + 'Work', + ] + for m in models: + kls = apps.get_model('music', m) + qs = kls.objects.filter(uuid__isnull=True).only('id') + print('Setting uuids for {} ({} objects)'.format(m, len(qs))) + for o in qs: + o.uuid = uuid.uuid4() + o.save(update_fields=['uuid']) + + +def rewind(apps, schema_editor): + pass + + +class Migration(migrations.Migration): + + dependencies = [ + ('music', '0023_auto_20180407_1010'), + ] + + operations = [ + migrations.RunPython(populate_uuids, rewind), + migrations.AlterField( + model_name='album', + name='uuid', + field=models.UUIDField(db_index=True, default=uuid.uuid4, unique=True), + ), + migrations.AlterField( + model_name='artist', + name='uuid', + field=models.UUIDField(db_index=True, default=uuid.uuid4, unique=True), + ), + migrations.AlterField( + model_name='importbatch', + name='uuid', + field=models.UUIDField(db_index=True, default=uuid.uuid4, unique=True), + ), + migrations.AlterField( + model_name='importjob', + name='uuid', + field=models.UUIDField(db_index=True, default=uuid.uuid4, unique=True), + ), + migrations.AlterField( + model_name='lyrics', + name='uuid', + field=models.UUIDField(db_index=True, default=uuid.uuid4, unique=True), + ), + migrations.AlterField( + model_name='track', + name='uuid', + field=models.UUIDField(db_index=True, default=uuid.uuid4, unique=True), + ), + migrations.AlterField( + model_name='trackfile', + name='uuid', + field=models.UUIDField(db_index=True, default=uuid.uuid4, unique=True), + ), + migrations.AlterField( + model_name='work', + name='uuid', + field=models.UUIDField(db_index=True, default=uuid.uuid4, unique=True), + ), + ] diff --git a/api/funkwhale_api/music/permissions.py b/api/funkwhale_api/music/permissions.py index a8e62f1e7..61fc65beb 100644 --- a/api/funkwhale_api/music/permissions.py +++ b/api/funkwhale_api/music/permissions.py @@ -3,6 +3,7 @@ from django.conf import settings from rest_framework.permissions import BasePermission from funkwhale_api.federation import actors +from funkwhale_api.federation import models class Listen(BasePermission): @@ -20,4 +21,8 @@ class Listen(BasePermission): return False library = actors.SYSTEM_ACTORS['library'].get_actor_instance() - return library.followers.filter(url=actor.url).exists() + return models.Follow.objects.filter( + target=library, + actor=actor, + approved=True + ).exists() diff --git a/api/funkwhale_api/music/serializers.py b/api/funkwhale_api/music/serializers.py index 42795dbea..b5f69eb1d 100644 --- a/api/funkwhale_api/music/serializers.py +++ b/api/funkwhale_api/music/serializers.py @@ -3,8 +3,9 @@ from rest_framework import serializers from taggit.models import Tag from funkwhale_api.activity import serializers as activity_serializers -from funkwhale_api.federation.serializers import AP_CONTEXT from funkwhale_api.federation import utils as federation_utils +from funkwhale_api.federation.models import LibraryTrack +from funkwhale_api.federation.serializers import AP_CONTEXT from . import models @@ -153,3 +154,25 @@ class TrackActivitySerializer(activity_serializers.ModelSerializer): def get_type(self, obj): return 'Audio' + + +class SubmitFederationTracksSerializer(serializers.Serializer): + library_tracks = serializers.PrimaryKeyRelatedField( + many=True, + queryset=LibraryTrack.objects.filter(local_track_file__isnull=True), + ) + + @transaction.atomic + def save(self, **kwargs): + batch = models.ImportBatch.objects.create( + source='federation', + **kwargs + ) + for lt in self.validated_data['library_tracks']: + models.ImportJob.objects.create( + batch=batch, + library_track=lt, + mbid=lt.mbid, + source=lt.url, + ) + return batch diff --git a/api/funkwhale_api/music/views.py b/api/funkwhale_api/music/views.py index 0870d9816..e8ace1b3a 100644 --- a/api/funkwhale_api/music/views.py +++ b/api/funkwhale_api/music/views.py @@ -1,6 +1,7 @@ import ffmpeg import os import json +import logging import subprocess import unicodedata import urllib @@ -22,7 +23,6 @@ from rest_framework import permissions from musicbrainzngs import ResponseError from funkwhale_api.common import utils as funkwhale_utils -from funkwhale_api.common import session from funkwhale_api.federation import actors from funkwhale_api.requests.models import ImportRequest from funkwhale_api.musicbrainz import api @@ -40,6 +40,8 @@ from . import serializers from . import tasks from . import utils +logger = logging.getLogger(__name__) + class SearchMixin(object): search_fields = [] @@ -203,31 +205,22 @@ class TrackFileViewSet(viewsets.ReadOnlyModelViewSet): return Response(status=404) mt = f.mimetype + audio_file = f.audio_file try: library_track = f.library_track except ObjectDoesNotExist: library_track = None - if library_track and not f.audio_file: - # we proxy the response to the remote library - # since we did not mirror the file locally + if library_track and not audio_file: + if not library_track.audio_file: + # we need to populate from cache + library_track.download_audio() + audio_file = library_track.audio_file mt = library_track.audio_mimetype - file_extension = utils.get_ext_from_type(mt) - filename = '{}.{}'.format(f.track.full_name, file_extension) - auth = actors.SYSTEM_ACTORS['library'].get_request_auth() - remote_response = session.get_session().get( - library_track.audio_url, - auth=auth, - stream=True, - headers={ - 'Content-Type': 'application/activity+json' - }) - response = StreamingHttpResponse(remote_response.iter_content()) - else: - response = Response() - filename = f.filename - response['X-Accel-Redirect'] = "{}{}".format( - settings.PROTECT_FILES_PATH, - f.audio_file.url) + response = Response() + filename = f.filename + response['X-Accel-Redirect'] = "{}{}".format( + settings.PROTECT_FILES_PATH, + audio_file.url) filename = "filename*=UTF-8''{}".format( urllib.parse.quote(filename)) response["Content-Disposition"] = "attachment; {}".format(filename) @@ -247,6 +240,8 @@ class TrackFileViewSet(viewsets.ReadOnlyModelViewSet): return Response(form.errors, status=400) f = form.cleaned_data['track_file'] + if not f.audio_file: + return Response(status=400) output_kwargs = { 'format': form.cleaned_data['to'] } @@ -390,6 +385,22 @@ class SubmitViewSet(viewsets.ViewSet): data, request, batch=None, import_request=import_request) return Response(import_data) + @list_route(methods=['post']) + @transaction.non_atomic_requests + def federation(self, request, *args, **kwargs): + serializer = serializers.SubmitFederationTracksSerializer( + data=request.data) + serializer.is_valid(raise_exception=True) + batch = serializer.save(submitted_by=request.user) + for job in batch.jobs.all(): + funkwhale_utils.on_commit( + tasks.import_job_run.delay, + import_job_id=job.pk, + use_acoustid=False, + ) + + return Response({'id': batch.id}, status=201) + @transaction.atomic def _import_album(self, data, request, batch=None, import_request=None): # we import the whole album here to prevent race conditions that occurs diff --git a/api/funkwhale_api/radios/models.py b/api/funkwhale_api/radios/models.py index d9c12534c..0273b5387 100644 --- a/api/funkwhale_api/radios/models.py +++ b/api/funkwhale_api/radios/models.py @@ -4,6 +4,7 @@ from django.core.exceptions import ValidationError from django.contrib.postgres.fields import JSONField from django.contrib.contenttypes.fields import GenericForeignKey from django.contrib.contenttypes.models import ContentType +from django.core.serializers.json import DjangoJSONEncoder from funkwhale_api.music.models import Track @@ -23,7 +24,7 @@ class Radio(models.Model): creation_date = models.DateTimeField(default=timezone.now) is_public = models.BooleanField(default=False) version = models.PositiveIntegerField(default=0) - config = JSONField() + config = JSONField(encoder=DjangoJSONEncoder) def get_candidates(self): return filters.run(self.config) diff --git a/api/funkwhale_api/users/models.py b/api/funkwhale_api/users/models.py index 9516c108f..572fa9ddc 100644 --- a/api/funkwhale_api/users/models.py +++ b/api/funkwhale_api/users/models.py @@ -31,6 +31,9 @@ class User(AbstractUser): 'dynamic_preferences.change_globalpreferencemodel': { 'external_codename': 'settings.change', }, + 'federation.change_library': { + 'external_codename': 'federation.manage', + }, } privacy_level = fields.get_privacy_field() diff --git a/api/tests/federation/test_activity.py b/api/tests/federation/test_activity.py index 09c5e3bf7..c2673ff3b 100644 --- a/api/tests/federation/test_activity.py +++ b/api/tests/federation/test_activity.py @@ -1,14 +1,16 @@ import uuid from funkwhale_api.federation import activity +from funkwhale_api.federation import serializers -def test_deliver(nodb_factories, r_mock, mocker): - to = nodb_factories['federation.Actor']() +def test_deliver(factories, r_mock, mocker, settings): + settings.CELERY_TASK_ALWAYS_EAGER = True + to = factories['federation.Actor']() mocker.patch( 'funkwhale_api.federation.actors.get_actor', return_value=to) - sender = nodb_factories['federation.Actor']() + sender = factories['federation.Actor']() ac = { 'id': 'http://test.federation/activity', 'type': 'Create', @@ -38,37 +40,9 @@ def test_deliver(nodb_factories, r_mock, mocker): def test_accept_follow(mocker, factories): deliver = mocker.patch( 'funkwhale_api.federation.activity.deliver') - actor = factories['federation.Actor']() - target = factories['federation.Actor'](local=True) - follow = { - 'actor': actor.url, - 'type': 'Follow', - 'id': 'http://test.federation/user#follows/267', - 'object': target.url, - } - uid = uuid.uuid4() - mocker.patch('uuid.uuid4', return_value=uid) - expected_accept = { - "@context": [ - "https://www.w3.org/ns/activitystreams", - "https://w3id.org/security/v1", - {} - ], - "id": target.url + '#accepts/follows/{}'.format(uid), - "type": "Accept", - "actor": target.url, - "object": { - "id": follow['id'], - "type": "Follow", - "actor": actor.url, - "object": target.url - }, - } - activity.accept_follow( - target, follow, actor - ) + follow = factories['federation.Follow'](approved=None) + expected_accept = serializers.AcceptFollowSerializer(follow).data + activity.accept_follow(follow) deliver.assert_called_once_with( - expected_accept, to=[actor.url], on_behalf_of=target + expected_accept, to=[follow.actor.url], on_behalf_of=follow.target ) - follow_instance = actor.emitted_follows.first() - assert follow_instance.target == target diff --git a/api/tests/federation/test_actors.py b/api/tests/federation/test_actors.py index 090d9b03f..fe70cc6e5 100644 --- a/api/tests/federation/test_actors.py +++ b/api/tests/federation/test_actors.py @@ -7,6 +7,7 @@ from django.utils import timezone from rest_framework import exceptions +from funkwhale_api.federation import activity from funkwhale_api.federation import actors from funkwhale_api.federation import models from funkwhale_api.federation import serializers @@ -261,8 +262,6 @@ def test_test_actor_handles_follow( deliver = mocker.patch( 'funkwhale_api.federation.activity.deliver') actor = factories['federation.Actor']() - now = timezone.now() - mocker.patch('django.utils.timezone.now', return_value=now) accept_follow = mocker.patch( 'funkwhale_api.federation.activity.accept_follow') test_actor = actors.SYSTEM_ACTORS['test'].get_actor_instance() @@ -272,28 +271,15 @@ def test_test_actor_handles_follow( 'id': 'http://test.federation/user#follows/267', 'object': test_actor.url, } - uid = uuid.uuid4() - mocker.patch('uuid.uuid4', return_value=uid) - expected_follow = { - '@context': serializers.AP_CONTEXT, - 'actor': test_actor.url, - 'id': test_actor.url + '#follows/{}'.format(uid), - 'object': actor.url, - 'type': 'Follow' - } - actors.SYSTEM_ACTORS['test'].post_inbox(data, actor=actor) - accept_follow.assert_called_once_with( - test_actor, data, actor + follow = models.Follow.objects.get(target=test_actor, approved=True) + follow_back = models.Follow.objects.get(actor=test_actor, approved=None) + accept_follow.assert_called_once_with(follow) + deliver.assert_called_once_with( + serializers.FollowSerializer(follow_back).data, + on_behalf_of=test_actor, + to=[actor.url] ) - expected_calls = [ - mocker.call( - expected_follow, - to=[actor.url], - on_behalf_of=test_actor, - ) - ] - deliver.assert_has_calls(expected_calls) def test_test_actor_handles_undo_follow( @@ -346,12 +332,10 @@ def test_library_actor_handles_follow_manual_approval( } library_actor.system_conf.post_inbox(data, actor=actor) - fr = library_actor.received_follow_requests.first() + follow = library_actor.received_follows.first() - assert library_actor.received_follow_requests.count() == 1 - assert fr.target == library_actor - assert fr.actor == actor - assert fr.approved is None + assert follow.actor == actor + assert follow.approved is None def test_library_actor_handles_follow_auto_approval( @@ -369,10 +353,27 @@ def test_library_actor_handles_follow_auto_approval( } library_actor.system_conf.post_inbox(data, actor=actor) - assert library_actor.received_follow_requests.count() == 0 - accept_follow.assert_called_once_with( - library_actor, data, actor + follow = library_actor.received_follows.first() + + assert follow.actor == actor + assert follow.approved is True + + +def test_library_actor_handles_accept( + mocker, factories): + library_actor = actors.SYSTEM_ACTORS['library'].get_actor_instance() + actor = factories['federation.Actor']() + pending_follow = factories['federation.Follow']( + actor=library_actor, + target=actor, + approved=None, ) + serializer = serializers.AcceptFollowSerializer(pending_follow) + library_actor.system_conf.post_inbox(serializer.data, actor=actor) + + pending_follow.refresh_from_db() + + assert pending_follow.approved is True def test_library_actor_handle_create_audio_no_library(mocker, factories): diff --git a/api/tests/federation/test_authentication.py b/api/tests/federation/test_authentication.py index c6a97a07a..2f69e4d4f 100644 --- a/api/tests/federation/test_authentication.py +++ b/api/tests/federation/test_authentication.py @@ -10,8 +10,10 @@ def test_authenticate(factories, mocker, api_request): 'funkwhale_api.federation.actors.get_actor_data', return_value={ 'id': actor_url, + 'type': 'Person', 'outbox': 'https://test.com', 'inbox': 'https://test.com', + 'preferredUsername': 'test', 'publicKey': { 'publicKeyPem': public.decode('utf-8'), 'owner': actor_url, diff --git a/api/tests/federation/test_library.py b/api/tests/federation/test_library.py new file mode 100644 index 000000000..7a3abf5d8 --- /dev/null +++ b/api/tests/federation/test_library.py @@ -0,0 +1,70 @@ +from funkwhale_api.federation import library +from funkwhale_api.federation import serializers + + +def test_library_scan_from_account_name(mocker, factories): + actor = factories['federation.Actor']( + preferred_username='library', + domain='test.library' + ) + get_resource_result = {'actor_url': actor.url} + get_resource = mocker.patch( + 'funkwhale_api.federation.webfinger.get_resource', + return_value=get_resource_result) + + actor_data = serializers.ActorSerializer(actor).data + actor_data['manuallyApprovesFollowers'] = False + actor_data['url'] = [{ + 'type': 'Link', + 'name': 'library', + 'mediaType': 'application/activity+json', + 'href': 'https://test.library' + }] + get_actor_data = mocker.patch( + 'funkwhale_api.federation.actors.get_actor_data', + return_value=actor_data) + + get_library_data_result = {'test': 'test'} + get_library_data = mocker.patch( + 'funkwhale_api.federation.library.get_library_data', + return_value=get_library_data_result) + + result = library.scan_from_account_name('library@test.actor') + + get_resource.assert_called_once_with('acct:library@test.actor') + get_actor_data.assert_called_once_with(actor.url) + get_library_data.assert_called_once_with(actor_data['url'][0]['href']) + + assert result == { + 'webfinger': get_resource_result, + 'actor': actor_data, + 'library': get_library_data_result, + 'local': { + 'following': False, + 'awaiting_approval': False, + }, + } + + +def test_get_library_data(r_mock, factories): + actor = factories['federation.Actor']() + url = 'https://test.library' + conf = { + 'id': url, + 'items': [], + 'actor': actor, + 'page_size': 5, + } + data = serializers.PaginatedCollectionSerializer(conf).data + r_mock.get(url, json=data) + + result = library.get_library_data(url) + for f in ['totalItems', 'actor', 'id', 'type']: + assert result[f] == data[f] + + +def test_get_library_data_requires_authentication(r_mock, factories): + url = 'https://test.library' + r_mock.get(url, status_code=403) + result = library.get_library_data(url) + assert result['errors'] == ['Permission denied while scanning library'] diff --git a/api/tests/federation/test_models.py b/api/tests/federation/test_models.py index b17b6eb65..ae158e659 100644 --- a/api/tests/federation/test_models.py +++ b/api/tests/federation/test_models.py @@ -35,50 +35,6 @@ def test_follow_federation_url(factories): assert follow.get_federation_url() == expected -def test_follow_request_approve(mocker, factories): - uid = uuid.uuid4() - mocker.patch('uuid.uuid4', return_value=uid) - accept_follow = mocker.patch( - 'funkwhale_api.federation.activity.accept_follow') - fr = factories['federation.FollowRequest'](target__local=True) - fr.approve() - - follow = { - '@context': serializers.AP_CONTEXT, - 'actor': fr.actor.url, - 'id': fr.actor.url + '#follows/{}'.format(uid), - 'object': fr.target.url, - 'type': 'Follow' - } - - assert fr.approved is True - assert list(fr.target.followers.all()) == [fr.actor] - accept_follow.assert_called_once_with( - fr.target, follow, fr.actor - ) - - -def test_follow_request_approve_non_local(mocker, factories): - uid = uuid.uuid4() - mocker.patch('uuid.uuid4', return_value=uid) - accept_follow = mocker.patch( - 'funkwhale_api.federation.activity.accept_follow') - fr = factories['federation.FollowRequest']() - fr.approve() - - assert fr.approved is True - assert list(fr.target.followers.all()) == [fr.actor] - accept_follow.assert_not_called() - - -def test_follow_request_refused(mocker, factories): - fr = factories['federation.FollowRequest']() - fr.refuse() - - assert fr.approved is False - assert fr.target.followers.count() == 0 - - def test_library_model_unique_per_actor(factories): library = factories['federation.Library']() with pytest.raises(db.IntegrityError): diff --git a/api/tests/federation/test_serializers.py b/api/tests/federation/test_serializers.py index 45778ed48..6d33a529d 100644 --- a/api/tests/federation/test_serializers.py +++ b/api/tests/federation/test_serializers.py @@ -1,4 +1,5 @@ import arrow +import pytest from django.urls import reverse from django.core.paginator import Paginator @@ -34,7 +35,7 @@ def test_actor_serializer_from_ap(db): } serializer = serializers.ActorSerializer(data=payload) - assert serializer.is_valid() + assert serializer.is_valid(raise_exception=True) actor = serializer.build() @@ -65,7 +66,7 @@ def test_actor_serializer_only_mandatory_field_from_ap(db): } serializer = serializers.ActorSerializer(data=payload) - assert serializer.is_valid() + assert serializer.is_valid(raise_exception=True) actor = serializer.build() @@ -170,6 +171,184 @@ def test_follow_serializer_to_ap(factories): assert serializer.data == expected +def test_follow_serializer_save(factories): + actor = factories['federation.Actor']() + target = factories['federation.Actor']() + + data = expected = { + 'id': 'https://test.follow', + 'type': 'Follow', + 'actor': actor.url, + 'object': target.url, + } + serializer = serializers.FollowSerializer(data=data) + + assert serializer.is_valid(raise_exception=True) + + follow = serializer.save() + + assert follow.pk is not None + assert follow.actor == actor + assert follow.target == target + assert follow.approved is None + + +def test_follow_serializer_save_validates_on_context(factories): + actor = factories['federation.Actor']() + target = factories['federation.Actor']() + impostor = factories['federation.Actor']() + + data = expected = { + 'id': 'https://test.follow', + 'type': 'Follow', + 'actor': actor.url, + 'object': target.url, + } + serializer = serializers.FollowSerializer( + data=data, + context={'follow_actor': impostor, 'follow_target': impostor}) + + assert serializer.is_valid() is False + + assert 'actor' in serializer.errors + assert 'object' in serializer.errors + + +def test_accept_follow_serializer_representation(factories): + follow = factories['federation.Follow'](approved=None) + + expected = { + '@context': [ + 'https://www.w3.org/ns/activitystreams', + 'https://w3id.org/security/v1', + {}, + ], + 'id': follow.get_federation_url() + '/accept', + 'type': 'Accept', + 'actor': follow.target.url, + 'object': serializers.FollowSerializer(follow).data, + } + + serializer = serializers.AcceptFollowSerializer(follow) + + assert serializer.data == expected + + +def test_accept_follow_serializer_save(factories): + follow = factories['federation.Follow'](approved=None) + + data = { + '@context': [ + 'https://www.w3.org/ns/activitystreams', + 'https://w3id.org/security/v1', + {}, + ], + 'id': follow.get_federation_url() + '/accept', + 'type': 'Accept', + 'actor': follow.target.url, + 'object': serializers.FollowSerializer(follow).data, + } + + serializer = serializers.AcceptFollowSerializer(data=data) + assert serializer.is_valid(raise_exception=True) + serializer.save() + + follow.refresh_from_db() + + assert follow.approved is True + + +def test_accept_follow_serializer_validates_on_context(factories): + follow = factories['federation.Follow'](approved=None) + impostor = factories['federation.Actor']() + data = { + '@context': [ + 'https://www.w3.org/ns/activitystreams', + 'https://w3id.org/security/v1', + {}, + ], + 'id': follow.get_federation_url() + '/accept', + 'type': 'Accept', + 'actor': impostor.url, + 'object': serializers.FollowSerializer(follow).data, + } + + serializer = serializers.AcceptFollowSerializer( + data=data, + context={'follow_actor': impostor, 'follow_target': impostor}) + + assert serializer.is_valid() is False + assert 'actor' in serializer.errors['object'] + assert 'object' in serializer.errors['object'] + + +def test_undo_follow_serializer_representation(factories): + follow = factories['federation.Follow'](approved=True) + + expected = { + '@context': [ + 'https://www.w3.org/ns/activitystreams', + 'https://w3id.org/security/v1', + {}, + ], + 'id': follow.get_federation_url() + '/undo', + 'type': 'Undo', + 'actor': follow.actor.url, + 'object': serializers.FollowSerializer(follow).data, + } + + serializer = serializers.UndoFollowSerializer(follow) + + assert serializer.data == expected + + +def test_undo_follow_serializer_save(factories): + follow = factories['federation.Follow'](approved=True) + + data = { + '@context': [ + 'https://www.w3.org/ns/activitystreams', + 'https://w3id.org/security/v1', + {}, + ], + 'id': follow.get_federation_url() + '/undo', + 'type': 'Undo', + 'actor': follow.actor.url, + 'object': serializers.FollowSerializer(follow).data, + } + + serializer = serializers.UndoFollowSerializer(data=data) + assert serializer.is_valid(raise_exception=True) + serializer.save() + + with pytest.raises(models.Follow.DoesNotExist): + follow.refresh_from_db() + + +def test_undo_follow_serializer_validates_on_context(factories): + follow = factories['federation.Follow'](approved=True) + impostor = factories['federation.Actor']() + data = { + '@context': [ + 'https://www.w3.org/ns/activitystreams', + 'https://w3id.org/security/v1', + {}, + ], + 'id': follow.get_federation_url() + '/undo', + 'type': 'Undo', + 'actor': impostor.url, + 'object': serializers.FollowSerializer(follow).data, + } + + serializer = serializers.UndoFollowSerializer( + data=data, + context={'follow_actor': impostor, 'follow_target': impostor}) + + assert serializer.is_valid() is False + assert 'actor' in serializer.errors['object'] + assert 'object' in serializer.errors['object'] + + def test_paginated_collection_serializer(factories): tfs = factories['music.TrackFile'].create_batch(size=5) actor = factories['federation.Actor'](local=True) @@ -201,6 +380,71 @@ def test_paginated_collection_serializer(factories): assert serializer.data == expected +def test_paginated_collection_serializer_validation(): + data = { + 'type': 'Collection', + 'id': 'https://test.federation/test', + 'totalItems': 5, + 'actor': 'http://test.actor', + 'first': 'https://test.federation/test?page=1', + 'last': 'https://test.federation/test?page=1', + 'items': [] + } + + serializer = serializers.PaginatedCollectionSerializer( + data=data + ) + + assert serializer.is_valid(raise_exception=True) is True + assert serializer.validated_data['totalItems'] == 5 + assert serializer.validated_data['id'] == data['id'] + assert serializer.validated_data['actor'] == data['actor'] + + +def test_collection_page_serializer_validation(): + base = 'https://test.federation/test' + data = { + 'type': 'CollectionPage', + 'id': base + '?page=2', + 'totalItems': 5, + 'actor': 'https://test.actor', + 'items': [], + 'first': 'https://test.federation/test?page=1', + 'last': 'https://test.federation/test?page=3', + 'prev': base + '?page=1', + 'next': base + '?page=3', + 'partOf': base, + } + + serializer = serializers.CollectionPageSerializer( + data=data + ) + + assert serializer.is_valid(raise_exception=True) is True + assert serializer.validated_data['totalItems'] == 5 + assert serializer.validated_data['id'] == data['id'] + assert serializer.validated_data['actor'] == data['actor'] + assert serializer.validated_data['items'] == [] + assert serializer.validated_data['prev'] == data['prev'] + assert serializer.validated_data['next'] == data['next'] + assert serializer.validated_data['partOf'] == data['partOf'] + + +def test_collection_page_serializer_can_validate_child(): + base = 'https://test.federation/test' + data = { + 'items': [{'in': 'valid'}], + } + + serializer = serializers.CollectionPageSerializer( + data=data, + context={'item_serializer': serializers.AudioSerializer} + ) + + assert serializer.is_valid() is False + assert 'items' in serializer.errors + + def test_collection_page_serializer(factories): tfs = factories['music.TrackFile'].create_batch(size=5) actor = factories['federation.Actor'](local=True) @@ -262,6 +506,25 @@ def test_activity_pub_audio_serializer_to_library_track(factories): assert lt.published_date == arrow.get(audio['published']) +def test_activity_pub_audio_serializer_to_library_track_no_duplicate( + factories): + remote_library = factories['federation.Library']() + audio = factories['federation.Audio']() + serializer1 = serializers.AudioSerializer( + data=audio, context={'library': remote_library}) + serializer2 = serializers.AudioSerializer( + data=audio, context={'library': remote_library}) + + assert serializer1.is_valid() is True + assert serializer2.is_valid() is True + + lt1 = serializer1.save() + lt2 = serializer2.save() + + assert lt1 == lt2 + assert models.LibraryTrack.objects.count() == 1 + + def test_activity_pub_audio_serializer_to_ap(factories): tf = factories['music.TrackFile'](mimetype='audio/mp3') library = actors.SYSTEM_ACTORS['library'].get_actor_instance() @@ -375,3 +638,46 @@ def test_collection_serializer_to_ap(factories): collection, context={'actor': library, 'id': 'https://test.id'}) assert serializer.data == expected + + +def test_api_library_create_serializer_save(factories, r_mock): + library_actor = actors.SYSTEM_ACTORS['library'].get_actor_instance() + actor = factories['federation.Actor']() + follow = factories['federation.Follow']( + target=actor, + actor=library_actor, + ) + actor_data = serializers.ActorSerializer(actor).data + actor_data['url'] = [{ + 'href': 'https://test.library', + 'name': 'library', + 'type': 'Link', + }] + library_conf = { + 'id': 'https://test.library', + 'items': range(10), + 'actor': actor, + 'page_size': 5, + } + library_data = serializers.PaginatedCollectionSerializer(library_conf).data + r_mock.get(actor.url, json=actor_data) + r_mock.get('https://test.library', json=library_data) + data = { + 'actor': actor.url, + 'autoimport': False, + 'federation_enabled': True, + 'download_files': False, + } + + serializer = serializers.APILibraryCreateSerializer(data=data) + assert serializer.is_valid(raise_exception=True) is True + library = serializer.save() + follow = models.Follow.objects.get( + target=actor, actor=library_actor, approved=None) + + assert library.autoimport is data['autoimport'] + assert library.federation_enabled is data['federation_enabled'] + assert library.download_files is data['download_files'] + assert library.tracks_count == 10 + assert library.actor == actor + assert library.follow == follow diff --git a/api/tests/federation/test_tasks.py b/api/tests/federation/test_tasks.py new file mode 100644 index 000000000..506fbc1fe --- /dev/null +++ b/api/tests/federation/test_tasks.py @@ -0,0 +1,140 @@ +import datetime + +from django.core.paginator import Paginator +from django.utils import timezone + +from funkwhale_api.federation import serializers +from funkwhale_api.federation import tasks + + +def test_scan_library_does_nothing_if_federation_disabled(mocker, factories): + library = factories['federation.Library'](federation_enabled=False) + tasks.scan_library(library_id=library.pk) + + assert library.tracks.count() == 0 + + +def test_scan_library_page_does_nothing_if_federation_disabled( + mocker, factories): + library = factories['federation.Library'](federation_enabled=False) + tasks.scan_library_page(library_id=library.pk, page_url=None) + + assert library.tracks.count() == 0 + + +def test_scan_library_fetches_page_and_calls_scan_page( + mocker, factories, r_mock): + now = timezone.now() + library = factories['federation.Library'](federation_enabled=True) + collection_conf = { + 'actor': library.actor, + 'id': library.url, + 'page_size': 10, + 'items': range(10), + } + collection = serializers.PaginatedCollectionSerializer(collection_conf) + scan_page = mocker.patch( + 'funkwhale_api.federation.tasks.scan_library_page.delay') + r_mock.get(collection_conf['id'], json=collection.data) + tasks.scan_library(library_id=library.pk) + + scan_page.assert_called_once_with( + library_id=library.id, + page_url=collection.data['first'], + until=None, + ) + library.refresh_from_db() + assert library.fetched_date > now + + +def test_scan_page_fetches_page_and_creates_tracks( + mocker, factories, r_mock): + library = factories['federation.Library'](federation_enabled=True) + tfs = factories['music.TrackFile'].create_batch(size=5) + page_conf = { + 'actor': library.actor, + 'id': library.url, + 'page': Paginator(tfs, 5).page(1), + 'item_serializer': serializers.AudioSerializer, + } + page = serializers.CollectionPageSerializer(page_conf) + r_mock.get(page.data['id'], json=page.data) + + tasks.scan_library_page(library_id=library.pk, page_url=page.data['id']) + + lts = list(library.tracks.all().order_by('-published_date')) + assert len(lts) == 5 + + +def test_scan_page_trigger_next_page_scan_skip_if_same( + mocker, factories, r_mock): + patched_scan = mocker.patch( + 'funkwhale_api.federation.tasks.scan_library_page.delay' + ) + library = factories['federation.Library'](federation_enabled=True) + tfs = factories['music.TrackFile'].create_batch(size=1) + page_conf = { + 'actor': library.actor, + 'id': library.url, + 'page': Paginator(tfs, 3).page(1), + 'item_serializer': serializers.AudioSerializer, + } + page = serializers.CollectionPageSerializer(page_conf) + data = page.data + data['next'] = data['id'] + r_mock.get(page.data['id'], json=data) + + tasks.scan_library_page(library_id=library.pk, page_url=data['id']) + patched_scan.assert_not_called() + + +def test_scan_page_stops_once_until_is_reached( + mocker, factories, r_mock): + library = factories['federation.Library'](federation_enabled=True) + tfs = list(reversed(factories['music.TrackFile'].create_batch(size=5))) + page_conf = { + 'actor': library.actor, + 'id': library.url, + 'page': Paginator(tfs, 3).page(1), + 'item_serializer': serializers.AudioSerializer, + } + page = serializers.CollectionPageSerializer(page_conf) + r_mock.get(page.data['id'], json=page.data) + + tasks.scan_library_page( + library_id=library.pk, + page_url=page.data['id'], + until=tfs[1].creation_date) + + lts = list(library.tracks.all().order_by('-published_date')) + assert len(lts) == 2 + for i, tf in enumerate(tfs[:1]): + assert tf.creation_date == lts[i].published_date + + +def test_clean_federation_music_cache_if_no_listen(preferences, factories): + preferences['federation__music_cache_duration'] = 60 + lt1 = factories['federation.LibraryTrack'](with_audio_file=True) + lt2 = factories['federation.LibraryTrack'](with_audio_file=True) + lt3 = factories['federation.LibraryTrack'](with_audio_file=True) + tf1 = factories['music.TrackFile'](library_track=lt1) + tf2 = factories['music.TrackFile'](library_track=lt2) + tf3 = factories['music.TrackFile'](library_track=lt3) + + # we listen to the first one, and the second one (but weeks ago) + listening1 = factories['history.Listening']( + track=tf1.track, + creation_date=timezone.now()) + listening2 = factories['history.Listening']( + track=tf2.track, + creation_date=timezone.now() - datetime.timedelta(minutes=61)) + + tasks.clean_music_cache() + + lt1.refresh_from_db() + lt2.refresh_from_db() + lt3.refresh_from_db() + + assert bool(lt1.audio_file) is True + assert bool(lt2.audio_file) is False + assert bool(lt3.audio_file) is False diff --git a/api/tests/federation/test_views.py b/api/tests/federation/test_views.py index c26810dad..8c5235b8b 100644 --- a/api/tests/federation/test_views.py +++ b/api/tests/federation/test_views.py @@ -1,9 +1,12 @@ -from django.urls import reverse from django.core.paginator import Paginator +from django.urls import reverse +from django.utils import timezone import pytest from funkwhale_api.federation import actors +from funkwhale_api.federation import activity +from funkwhale_api.federation import models from funkwhale_api.federation import serializers from funkwhale_api.federation import utils from funkwhale_api.federation import webfinger @@ -117,6 +120,19 @@ def test_audio_file_list_actor_page( assert response.data == expected +def test_audio_file_list_actor_page_exclude_federated_files( + db, settings, api_client, factories): + settings.FEDERATION_MUSIC_NEEDS_APPROVAL = False + library = actors.SYSTEM_ACTORS['library'].get_actor_instance() + tfs = factories['music.TrackFile'].create_batch(size=5, federation=True) + + url = reverse('federation:music:files-list') + response = api_client.get(url) + + assert response.status_code == 200 + assert response.data['totalItems'] == 0 + + def test_audio_file_list_actor_page_error( db, settings, api_client, factories): settings.FEDERATION_MUSIC_NEEDS_APPROVAL = False @@ -151,3 +167,216 @@ def test_library_actor_includes_library_link(db, settings, api_client): ] assert response.status_code == 200 assert response.data['url'] == expected_links + + +def test_can_fetch_library(superuser_api_client, mocker): + result = {'test': 'test'} + scan = mocker.patch( + 'funkwhale_api.federation.library.scan_from_account_name', + return_value=result) + + url = reverse('api:v1:federation:libraries-fetch') + response = superuser_api_client.get( + url, data={'account': 'test@test.library'}) + + assert response.status_code == 200 + assert response.data == result + scan.assert_called_once_with('test@test.library') + + +def test_follow_library(superuser_api_client, mocker, factories, r_mock): + library_actor = actors.SYSTEM_ACTORS['library'].get_actor_instance() + actor = factories['federation.Actor']() + follow = {'test': 'follow'} + on_commit = mocker.patch( + 'funkwhale_api.common.utils.on_commit') + actor_data = serializers.ActorSerializer(actor).data + actor_data['url'] = [{ + 'href': 'https://test.library', + 'name': 'library', + 'type': 'Link', + }] + library_conf = { + 'id': 'https://test.library', + 'items': range(10), + 'actor': actor, + 'page_size': 5, + } + library_data = serializers.PaginatedCollectionSerializer(library_conf).data + r_mock.get(actor.url, json=actor_data) + r_mock.get('https://test.library', json=library_data) + data = { + 'actor': actor.url, + 'autoimport': False, + 'federation_enabled': True, + 'download_files': False, + } + + url = reverse('api:v1:federation:libraries-list') + response = superuser_api_client.post( + url, data) + + assert response.status_code == 201 + + follow = models.Follow.objects.get( + actor=library_actor, + target=actor, + approved=None, + ) + library = follow.library + + assert response.data == serializers.APILibraryCreateSerializer( + library).data + + on_commit.assert_called_once_with( + activity.deliver, + serializers.FollowSerializer(follow).data, + on_behalf_of=library_actor, + to=[actor.url] + ) + + +def test_can_list_system_actor_following(factories, superuser_api_client): + library_actor = actors.SYSTEM_ACTORS['library'].get_actor_instance() + follow1 = factories['federation.Follow'](actor=library_actor) + follow2 = factories['federation.Follow']() + + url = reverse('api:v1:federation:libraries-following') + response = superuser_api_client.get(url) + + assert response.status_code == 200 + assert response.data['results'] == [ + serializers.APIFollowSerializer(follow1).data + ] + + +def test_can_list_system_actor_followers(factories, superuser_api_client): + library_actor = actors.SYSTEM_ACTORS['library'].get_actor_instance() + follow1 = factories['federation.Follow'](actor=library_actor) + follow2 = factories['federation.Follow'](target=library_actor) + + url = reverse('api:v1:federation:libraries-followers') + response = superuser_api_client.get(url) + + assert response.status_code == 200 + assert response.data['results'] == [ + serializers.APIFollowSerializer(follow2).data + ] + + +def test_can_list_libraries(factories, superuser_api_client): + library1 = factories['federation.Library']() + library2 = factories['federation.Library']() + + url = reverse('api:v1:federation:libraries-list') + response = superuser_api_client.get(url) + + assert response.status_code == 200 + assert response.data['results'] == [ + serializers.APILibrarySerializer(library1).data, + serializers.APILibrarySerializer(library2).data, + ] + + +def test_can_detail_library(factories, superuser_api_client): + library = factories['federation.Library']() + + url = reverse( + 'api:v1:federation:libraries-detail', + kwargs={'uuid': str(library.uuid)}) + response = superuser_api_client.get(url) + + assert response.status_code == 200 + assert response.data == serializers.APILibrarySerializer(library).data + + +def test_can_patch_library(factories, superuser_api_client): + library = factories['federation.Library']() + data = { + 'federation_enabled': not library.federation_enabled, + 'download_files': not library.download_files, + 'autoimport': not library.autoimport, + } + url = reverse( + 'api:v1:federation:libraries-detail', + kwargs={'uuid': str(library.uuid)}) + response = superuser_api_client.patch(url, data) + + assert response.status_code == 200 + library.refresh_from_db() + + for k, v in data.items(): + assert getattr(library, k) == v + + +def test_scan_library(factories, mocker, superuser_api_client): + scan = mocker.patch( + 'funkwhale_api.federation.tasks.scan_library.delay', + return_value=mocker.Mock(id='id')) + library = factories['federation.Library']() + now = timezone.now() + data = { + 'until': now, + } + url = reverse( + 'api:v1:federation:libraries-scan', + kwargs={'uuid': str(library.uuid)}) + response = superuser_api_client.post(url, data) + + assert response.status_code == 200 + assert response.data == {'task': 'id'} + scan.assert_called_once_with( + library_id=library.pk, + until=now + ) + + +def test_list_library_tracks(factories, superuser_api_client): + library = factories['federation.Library']() + lts = list(reversed(factories['federation.LibraryTrack'].create_batch( + size=5, library=library))) + factories['federation.LibraryTrack'].create_batch(size=5) + url = reverse('api:v1:federation:library-tracks-list') + response = superuser_api_client.get(url, {'library': library.uuid}) + + assert response.status_code == 200 + assert response.data == { + 'results': serializers.APILibraryTrackSerializer(lts, many=True).data, + 'count': 5, + 'previous': None, + 'next': None, + } + + +def test_can_update_follow_status(factories, superuser_api_client, mocker): + patched_accept = mocker.patch( + 'funkwhale_api.federation.activity.accept_follow' + ) + library_actor = actors.SYSTEM_ACTORS['library'].get_actor_instance() + follow = factories['federation.Follow'](target=library_actor) + + payload = { + 'follow': follow.pk, + 'approved': True + } + url = reverse('api:v1:federation:libraries-followers') + response = superuser_api_client.patch(url, payload) + follow.refresh_from_db() + + assert response.status_code == 200 + assert follow.approved is True + patched_accept.assert_called_once_with(follow) + + +def test_can_filter_pending_follows(factories, superuser_api_client): + library_actor = actors.SYSTEM_ACTORS['library'].get_actor_instance() + follow = factories['federation.Follow']( + target=library_actor, + approved=True) + + params = {'pending': True} + url = reverse('api:v1:federation:libraries-followers') + response = superuser_api_client.get(url, params) + + assert response.status_code == 200 + assert len(response.data['results']) == 0 diff --git a/api/tests/federation/test_webfinger.py b/api/tests/federation/test_webfinger.py index 96258455a..4b8dca207 100644 --- a/api/tests/federation/test_webfinger.py +++ b/api/tests/federation/test_webfinger.py @@ -40,3 +40,29 @@ def test_webfinger_clean_acct_errors(resource, message, settings): webfinger.clean_resource(resource) assert message == str(excinfo) + + +def test_webfinger_get_resource(r_mock): + resource = 'acct:test@test.webfinger' + payload = { + 'subject': resource, + 'aliases': ['https://test.webfinger'], + 'links': [ + { + 'rel': 'self', + 'type': 'application/activity+json', + 'href': 'https://test.webfinger/user/test' + } + ] + } + r_mock.get( + 'https://test.webfinger/.well-known/webfinger?resource={}'.format( + resource + ), + json=payload + ) + + data = webfinger.get_resource('acct:test@test.webfinger') + + assert data['actor_url'] == 'https://test.webfinger/user/test' + assert data['subject'] == resource diff --git a/api/tests/music/test_permissions.py b/api/tests/music/test_permissions.py index 6cce85e08..d36f37886 100644 --- a/api/tests/music/test_permissions.py +++ b/api/tests/music/test_permissions.py @@ -47,10 +47,25 @@ def test_list_permission_protect_following_actor( factories, api_request, settings): settings.PROTECT_AUDIO_FILES = True library_actor = actors.SYSTEM_ACTORS['library'].get_actor_instance() - follow = factories['federation.Follow'](target=library_actor) + follow = factories['federation.Follow']( + approved=True, target=library_actor) view = APIView.as_view() permission = permissions.Listen() request = api_request.get('/') setattr(request, 'actor', follow.actor) assert permission.has_permission(request, view) is True + + +def test_list_permission_protect_following_actor_not_approved( + factories, api_request, settings): + settings.PROTECT_AUDIO_FILES = True + library_actor = actors.SYSTEM_ACTORS['library'].get_actor_instance() + follow = factories['federation.Follow']( + approved=False, target=library_actor) + view = APIView.as_view() + permission = permissions.Listen() + request = api_request.get('/') + setattr(request, 'actor', follow.actor) + + assert permission.has_permission(request, view) is False diff --git a/api/tests/music/test_views.py b/api/tests/music/test_views.py index 468ea77e3..81f34fbe9 100644 --- a/api/tests/music/test_views.py +++ b/api/tests/music/test_views.py @@ -1,6 +1,8 @@ import io import pytest +from django.urls import reverse + from funkwhale_api.music import views from funkwhale_api.federation import actors @@ -52,7 +54,9 @@ def test_can_serve_track_file_as_remote_library( settings.PROTECT_AUDIO_FILES = True library_actor = actors.SYSTEM_ACTORS['library'].get_actor_instance() follow = factories['federation.Follow']( - actor=authenticated_actor, target=library_actor) + approved=True, + actor=authenticated_actor, + target=library_actor) track_file = factories['music.TrackFile']() response = api_client.get(track_file.path) @@ -77,9 +81,31 @@ def test_can_proxy_remote_track( settings.PROTECT_AUDIO_FILES = False track_file = factories['music.TrackFile'](federation=True) - r_mock.get(track_file.library_track.audio_url, body=io.StringIO('test')) + r_mock.get(track_file.library_track.audio_url, body=io.BytesIO(b'test')) response = api_client.get(track_file.path) + library_track = track_file.library_track + library_track.refresh_from_db() assert response.status_code == 200 - assert list(response.streaming_content) == [b't', b'e', b's', b't'] - assert response['Content-Type'] == track_file.library_track.audio_mimetype + assert response['X-Accel-Redirect'] == "{}{}".format( + settings.PROTECT_FILES_PATH, + library_track.audio_file.url) + assert library_track.audio_file.read() == b'test' + + +def test_can_create_import_from_federation_tracks( + factories, superuser_api_client, mocker): + lts = factories['federation.LibraryTrack'].create_batch(size=5) + mocker.patch('funkwhale_api.music.tasks.import_job_run') + + payload = { + 'library_tracks': [l.pk for l in lts] + } + url = reverse('api:v1:submit-federation') + response = superuser_api_client.post(url, payload) + + assert response.status_code == 201 + batch = superuser_api_client.user.imports.latest('id') + assert batch.jobs.count() == 5 + for i, job in enumerate(batch.jobs.all()): + assert job.library_track == lts[i] diff --git a/changes/changelog.d/136.feature b/changes/changelog.d/136.feature new file mode 100644 index 000000000..d869df31b --- /dev/null +++ b/changes/changelog.d/136.feature @@ -0,0 +1 @@ +Can now follow and import music from remote libraries (#136, #137) diff --git a/dev.yml b/dev.yml index 409b6b4a7..9488d4a6f 100644 --- a/dev.yml +++ b/dev.yml @@ -10,22 +10,39 @@ services: - "HOST=0.0.0.0" - "WEBPACK_DEVSERVER_PORT=${WEBPACK_DEVSERVER_PORT-8080}" ports: - - "${WEBPACK_DEVSERVER_PORT-8080}:${WEBPACK_DEVSERVER_PORT-8080}" + - "${WEBPACK_DEVSERVER_PORT_BINDING-8080:}${WEBPACK_DEVSERVER_PORT-8080}" volumes: - './front:/app' - './po:/po' + networks: + - federation + - internal + labels: + traefik.backend: "${COMPOSE_PROJECT_NAME-node1}" + traefik.frontend.rule: "Host: ${COMPOSE_PROJECT_NAME-node1}.funkwhale.test" + traefik.enable: 'true' + traefik.federation.protocol: 'http' + traefik.federation.port: "${WEBPACK_DEVSERVER_PORT-8080}" postgres: env_file: - .env.dev - .env image: postgres + volumes: + - "./data/${COMPOSE_PROJECT_NAME-node1}/postgres:/var/lib/postgresql/data" + networks: + - internal redis: env_file: - .env.dev - .env image: redis:3.0 + volumes: + - "./data/${COMPOSE_PROJECT_NAME-node1}/redis:/data" + networks: + - internal celeryworker: env_file: @@ -39,11 +56,17 @@ services: - redis command: celery -A funkwhale_api.taskapp worker -l debug environment: + - "FUNKWHALE_HOSTNAME=${FUNKWHALE_HOSTNAME-localhost}" + - "FUNKWHALE_HOSTNAME_SUFFIX=funkwhale.test" + - "FUNKWHALE_HOSTNAME_PREFIX=${COMPOSE_PROJECT_NAME}" + - "FUNKWHALE_PROTOCOL=${FUNKWHALE_PROTOCOL-http}" - "DATABASE_URL=postgresql://postgres@postgres/postgres" - "CACHE_URL=redis://redis:6379/0" volumes: - ./api:/app - ./data/music:/music + networks: + - internal api: env_file: - .env.dev @@ -56,12 +79,17 @@ services: - ./api:/app - ./data/music:/music environment: + - "FUNKWHALE_HOSTNAME=${FUNKWHALE_HOSTNAME-localhost}" + - "FUNKWHALE_HOSTNAME_SUFFIX=funkwhale.test" + - "FUNKWHALE_HOSTNAME_PREFIX=${COMPOSE_PROJECT_NAME}" + - "FUNKWHALE_PROTOCOL=${FUNKWHALE_PROTOCOL-http}" - "DATABASE_URL=postgresql://postgres@postgres/postgres" - "CACHE_URL=redis://redis:6379/0" links: - postgres - redis - + networks: + - internal nginx: command: /entrypoint.sh env_file: @@ -70,6 +98,8 @@ services: image: nginx environment: - "WEBPACK_DEVSERVER_PORT=${WEBPACK_DEVSERVER_PORT-8080}" + - "COMPOSE_PROJECT_NAME=${COMPOSE_PROJECT_NAME- }" + - "FUNKWHALE_HOSTNAME=${FUNKWHALE_HOSTNAME-localhost}" links: - api - front @@ -79,8 +109,9 @@ services: - ./deploy/funkwhale_proxy.conf:/etc/nginx/funkwhale_proxy.conf.template:ro - ./api/funkwhale_api/media:/protected/media ports: - - "0.0.0.0:6001:6001" - + - "6001" + networks: + - internal docs: build: docs command: python serve.py @@ -89,3 +120,9 @@ services: ports: - '35730:35730' - '8001:8001' + +networks: + internal: + federation: + external: + name: federation diff --git a/docker/nginx/entrypoint.sh b/docker/nginx/entrypoint.sh index 1819acf1c..14e072a7e 100755 --- a/docker/nginx/entrypoint.sh +++ b/docker/nginx/entrypoint.sh @@ -1,10 +1,17 @@ #!/bin/bash -eux -FIRST_HOST=$(echo ${DJANGO_ALLOWED_HOSTS} | cut -d, -f1) + +FORWARDED_PORT="$WEBPACK_DEVSERVER_PORT" +COMPOSE_PROJECT_NAME="${COMPOSE_PROJECT_NAME// /}" +if [ -n "$COMPOSE_PROJECT_NAME" ]; then + echo + FUNKWHALE_HOSTNAME="$COMPOSE_PROJECT_NAME.funkwhale.test" + FORWARDED_PORT="443" +fi echo "Copying template file..." cp /etc/nginx/funkwhale_proxy.conf{.template,} -sed -i "s/X-Forwarded-Host \$host:\$server_port/X-Forwarded-Host ${FIRST_HOST}:${WEBPACK_DEVSERVER_PORT}/" /etc/nginx/funkwhale_proxy.conf -sed -i "s/proxy_set_header Host \$host/proxy_set_header Host ${FIRST_HOST}/" /etc/nginx/funkwhale_proxy.conf -sed -i "s/proxy_set_header X-Forwarded-Port \$server_port/proxy_set_header X-Forwarded-Port ${WEBPACK_DEVSERVER_PORT}/" /etc/nginx/funkwhale_proxy.conf +sed -i "s/X-Forwarded-Host \$host:\$server_port/X-Forwarded-Host ${FUNKWHALE_HOSTNAME}:${FORWARDED_PORT}/" /etc/nginx/funkwhale_proxy.conf +sed -i "s/proxy_set_header Host \$host/proxy_set_header Host ${FUNKWHALE_HOSTNAME}/" /etc/nginx/funkwhale_proxy.conf +sed -i "s/proxy_set_header X-Forwarded-Port \$server_port/proxy_set_header X-Forwarded-Port ${FORWARDED_PORT}/" /etc/nginx/funkwhale_proxy.conf cat /etc/nginx/funkwhale_proxy.conf nginx -g "daemon off;" diff --git a/docker/ssl/test.crt b/docker/ssl/test.crt new file mode 100644 index 000000000..e4d3eefb8 --- /dev/null +++ b/docker/ssl/test.crt @@ -0,0 +1,22 @@ +-----BEGIN CERTIFICATE----- +MIIDljCCAn6gAwIBAgIJAOA/w9NwL3aMMA0GCSqGSIb3DQEBCwUAMGAxCzAJBgNV +BAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBX +aWRnaXRzIFB0eSBMdGQxGTAXBgNVBAMMECouZnVua3doYWxlLnRlc3QwHhcNMTgw +NDA4MTMwNDAzWhcNMjgwNDA1MTMwNDAzWjBgMQswCQYDVQQGEwJBVTETMBEGA1UE +CAwKU29tZS1TdGF0ZTEhMB8GA1UECgwYSW50ZXJuZXQgV2lkZ2l0cyBQdHkgTHRk +MRkwFwYDVQQDDBAqLmZ1bmt3aGFsZS50ZXN0MIIBIjANBgkqhkiG9w0BAQEFAAOC +AQ8AMIIBCgKCAQEAyGqRLEMFs1mpRwauTicIRj2zwBUe6JMNRbIvOUkaj2KY6avA +7tiNti/ygBoTyJl2JK3mmLqxElqedpMhjVvYde/PyjXoZ+0Vq4FWv89LV6ZM/Scf +TCIYwWF1ppi6GYFmU3WCIMISkKiPBtMArB0oZxiUWLmkyd8jih2wnQOpkQ20FfG0 +CtlrKlQKyAe7X3zPuqGfaMUN7J4w9g3/SC66YulbAtI1/Z4tuG8J4m2RC6jH1hVy +364l3ifEC+m9Kax/ystfu/mkLdyQgRfOZTNf2JhS3BL8zpoWMXFK+4+7TYisrV1h +0pzIAsoQeBB+cFOOFEwRAv0FxSWnZ+/shjnwbwIDAQABo1MwUTAdBgNVHQ4EFgQU +sULmofttRyWUMM93IsD8jBvyCd4wHwYDVR0jBBgwFoAUsULmofttRyWUMM93IsD8 +jBvyCd4wDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAQEAUg/fiXut +hW6fDx9f0JdB4uLiLnv8tDP35ackLLapFJhXtflIXcqCzxStQ46nMs1wjaZPb+ws +pLULzvTKTxJbu+JYc2nvis4m2oSFczJ3S9tgug4Ppv8yS7N1pp7kfjOvBjgh6sYW +p+Ctb5r8qvgvT9yDTeCnsqktb/OkRHlHwhRYfnuxh+96s4mzifqFUP4uCCcFYPTc +RE0Ag3oI5sHOdDk/cdYE5PGQPjSP6gzn0lsrz1Q3x1C8+txSHzsJnvS3Ost+dwcy +JSjDBXauy9cZv93Voevcl16Ioo7trtkp4dwAoep52vOT/KMkJ4zm19msV3BP4wMa +BUqrV2F7twD5zw== +-----END CERTIFICATE----- diff --git a/docker/ssl/test.key b/docker/ssl/test.key new file mode 100644 index 000000000..669e5f700 --- /dev/null +++ b/docker/ssl/test.key @@ -0,0 +1,28 @@ +-----BEGIN PRIVATE KEY----- +MIIEwAIBADANBgkqhkiG9w0BAQEFAASCBKowggSmAgEAAoIBAQDIapEsQwWzWalH +Bq5OJwhGPbPAFR7okw1Fsi85SRqPYpjpq8Du2I22L/KAGhPImXYkreaYurESWp52 +kyGNW9h178/KNehn7RWrgVa/z0tXpkz9Jx9MIhjBYXWmmLoZgWZTdYIgwhKQqI8G +0wCsHShnGJRYuaTJ3yOKHbCdA6mRDbQV8bQK2WsqVArIB7tffM+6oZ9oxQ3snjD2 +Df9ILrpi6VsC0jX9ni24bwnibZELqMfWFXLfriXeJ8QL6b0prH/Ky1+7+aQt3JCB +F85lM1/YmFLcEvzOmhYxcUr7j7tNiKytXWHSnMgCyhB4EH5wU44UTBEC/QXFJadn +7+yGOfBvAgMBAAECggEBAMVB3lEqRloYTbxSnwzc7g/0ew77usg+tDl8/23qvfGS +od6b5fEvw4sl9hCPmhk+skG3x9dbKR1fg8hBWCzB0XOC7YmhNXXUrBd53eA8L3O9 +gtlHwE424Ra0zg+DEug3rHdImSOU4KDwxpV46Jh+ul1+m8QYNFFdBqXSQxrHmAXj +MQ6++rjoJ+bhucmjBouzMYXHTGhdae3kjDFrFJ4cUsH6F03NcDwS+AmZxa/DWQ/H +SoBQBeLoE6I1aKhLgY91yO1e7CtSzS2GFCODReN4b3cylaR7jE7Mg87TZcga6Wfa +Xcd120VVlVq6HmZc/Xob7aUim3AuY2er8bcvmg1XOsECgYEA5EMM5UlpLdNWv1hp +5IMvkeCbXtLJ3IOHO0xLkFdx0CxaR9TyAAqIrSh1t9rFhYqLUNiOdMc2TqrvdgEU +B/QZrAevWRc5sjPvFXmYeWSCi/tjRgQh4jClWDX/TlfAlP55z2BFyMPMX6//WbBQ +5aL9xymTymzFFcaE8EytT5Jz8rUCgYEA4MVF3IkaQepl6H1gf2T6ev+MtGk9AGg9 +DSJpio7hfMcY5X3NrTJJFF9DJFXqfo3ILOMyUpIUHqkCGKXil0n9ypLp4vq7l+6c +m1gtKFXh7uKAV4XtSnR0nuK/N10JJp2HbbFYGlziRaa1iEPAFvLDQHu4jyf5sXyV +HvreuQgGWRMCgYEAlUaQKWaP5UsfoPUGE04DjwfvM9zv7EkL6CimBhhZswU+aVmG +haZd6bfa/EiTAhkvsMheqVoaVuoMvgRIgEcPfuRrtPyuW68A/O9PWpvzj+3v5zsO +maisiPqPI0HaDNY6/PZ9zKTXhABKIvJehT7JbjTvlOL7JJl2GNxcPvyM3T0CgYEA +tnVtUKi69+ce8qtUOhXufwoTXiBPtJTpelAE/MUfpfq46xJEc+PuDuuFxWk5AaJ2 +bHnBz+VlD76CRR/j4IvfySGZWvfOcHbyCeh6P9P3o8OaC3JcPaRrRs8qCfcsBny6 +AwGDU2MzCvdZRVQ6CmbmuOG13//DYaCQLKXZRrqM7KECgYEAxDsqtyHA/a38UhS8 +iQ8HqrZp8CuzJoJw/QILvzjojD1cvmwF73RrPEpRfEaLWVQGQ5F1IlHk/009C5zy +eUT4ZaPxLem6khBf7pn3xXaVBGZsYoltek5sUBsu/jA+4Sw6bcUmhBRBCs98JGpR +DVJtvOTk9aGW8M8UbgqwW+e/6ng= +-----END PRIVATE KEY----- diff --git a/docker/traefik.toml b/docker/traefik.toml new file mode 100644 index 000000000..85da2ea72 --- /dev/null +++ b/docker/traefik.toml @@ -0,0 +1,26 @@ +defaultEntryPoints = ["http", "https"] + +################################################################ +# Web configuration backend +################################################################ +[web] +address = ":8040" +################################################################ +# Docker configuration backend +################################################################ +[docker] +domain = "funkwhale.test" +watch = true +exposedbydefault = false + +[entryPoints] + [entryPoints.http] + address = ":80" + [entryPoints.http.redirect] + entryPoint = "https" + [entryPoints.https] + address = ":443" + [entryPoints.https.tls] + [[entryPoints.https.tls.certificates]] + certFile = "/ssl/traefik.crt" + keyFile = "/ssl/traefik.key" diff --git a/docker/traefik.yml b/docker/traefik.yml new file mode 100644 index 000000000..0b15b3290 --- /dev/null +++ b/docker/traefik.yml @@ -0,0 +1,22 @@ +version: '2.1' + +services: + traefik: + image: traefik:alpine + volumes: + - /var/run/docker.sock:/var/run/docker.sock + - ./traefik.toml:/traefik.toml + - ./ssl/test.key:/ssl/traefik.key + - ./ssl/test.crt:/ssl/traefik.crt + ports: + - '80:80' + - '443:443' + - '8040:8040' + networks: + federation: + + +networks: + federation: + external: + name: federation diff --git a/docs/features.rst b/docs/features.rst index d72a826b6..e0f490e4b 100644 --- a/docs/features.rst +++ b/docs/features.rst @@ -42,3 +42,14 @@ The project itself is splitted in two parts: While the main interface to the server and API is the bundled front-end, the project itself is agnostic in the way you connect to it. Therefore, desktop clients or apps could be developped and implement the same (or even more) features as the bundled frontend. This modularity also makes it possible do deploy only a single component from the system. + +Federation +---------- + +Each Funkwhale instance is able to fetch music from other compatible servers, +and share its own library on the network. The federation is implemented +using the ActivityPub protocol, in order to leverage existing tools +and be compatible with other services such as Mastodon. + +As of today, federation only targets music acquisition, meaning user interaction +are not shared via ActivityPub. This will be implemented at a later point. diff --git a/docs/federation.rst b/docs/federation.rst new file mode 100644 index 000000000..42edb0162 --- /dev/null +++ b/docs/federation.rst @@ -0,0 +1,40 @@ +Federation +========== + +Each Funkwale instance can federates its music library with other instances +of the network. This means that an instance A can acquire music from instance B +and share its own library with an instance C. + +We support various levels of controls for federation-related features. + +Acquire music via federation +---------------------------- + +Instance libraries are protected by default. To access another instance +library, you have to follow it. This follow request will be sent to +the other instance which can accept or deny it. Once your follow request +is accepted, you can start browsing the other instance library +and import music from it. + +By default, we do not duplicate audio files from federated tracks, to reduce +disk usage on your instance. When someone listens to a federated track, +the audio file is requested on the fly from the remote instance, and +store in a local cache. It is automatically deleted after a configurable +amount of time if it was not listened again in the meantime. + +If you want to mirror a remote instance collection, including its audio files, +we offer an option for that. + +We also support an "autoimport" mode for each remote library. When enabled, +any new track published in the remote library will be directly imported +in your instance. + +Share music via federation +-------------------------- + +Federation is enabled by default, but requires manually approving +each other instance asking for access to library. This is by design, +to ensure your library is not shared publicly without your consent. + +However, we offer a configuration option to alter this behaviour and +disable the manual approval part. diff --git a/docs/importing-music.rst b/docs/importing-music.rst index 92ff6bfb5..f09eea7b1 100644 --- a/docs/importing-music.rst +++ b/docs/importing-music.rst @@ -67,3 +67,9 @@ under creative commons (courtesy of Jamendo): ./download-tracks.sh music.txt This will download a bunch of zip archives (one per album) under the ``data/music`` directory and unzip their content. + +From other instances +-------------------- + +Funkwhale also supports importing music from other instances. Please refer +to :doc:`federation` for more details. diff --git a/docs/index.rst b/docs/index.rst index f5acecce5..82dcf8c88 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -15,6 +15,7 @@ Funkwhale is a self-hosted, modern free and open-source music server, heavily in installation/index configuration importing-music + federation upgrading changelog diff --git a/front/src/components/Home.vue b/front/src/components/Home.vue index 0e24dcd59..ce1307ff0 100644 --- a/front/src/components/Home.vue +++ b/front/src/components/Home.vue @@ -3,7 +3,7 @@

- Welcome on Funkwhale + Welcome on Funkwhale

We think listening music should be simple.

diff --git a/front/src/components/Pagination.vue b/front/src/components/Pagination.vue index 47cf5183a..ca40cdd07 100644 --- a/front/src/components/Pagination.vue +++ b/front/src/components/Pagination.vue @@ -1,25 +1,25 @@