federails 0.6.2 → 0.8.0

data/app/views/federails/client/followings/_follower.html.erb

@@ -1,7 +1,7 @@
 <div>
   <b><%= link_to following.actor.name, federails.client_actor_url(following.actor) %></b>
   (<%= following.actor.at_address %>) (<%= following.status %>)
-  <% if following.pending? && following.target_actor == current_user.federails_actor %>
+  <% if following.pending? && following.target_actor == current_user&.federails_actor %>
     <%= button_to 'Accept', federails.accept_client_following_path(following), method: :put %>
   <% end %>
 </div>

data/app/views/federails/server/activities/_activity.activitypub.jbuilder

@@ -1,13 +1,17 @@
 context = true unless context == false
 addressing = true unless addressing == false
-json.set! '@context', 'https://www.w3.org/ns/activitystreams' if context
+set_json_ld_context(json) if context
 
 json.id Federails::Engine.routes.url_helpers.server_actor_activity_url activity.actor, activity
 json.type activity.action
 json.actor activity.actor.federated_url
 if addressing
-  json.to ['https://www.w3.org/ns/activitystreams#Public']
-  json.cc [activity.actor.followers_url]
+  json.merge!(
+    {
+      to: activity.to,
+      cc: activity.cc,
+    }.compact
+  )
 end
 
 if activity.entity.is_a? Federails::Activity

data/app/views/federails/server/actors/_actor.activitypub.jbuilder

@@ -1,11 +1,12 @@
 actor_data = actor.entity&.to_activitypub_object || {}
 
-json.set! '@context', ([
-  'https://www.w3.org/ns/activitystreams',
-  'https://w3id.org/security/v1',
-] + [
-  actor_data&.delete(:@context),
-].flatten).compact
+set_json_ld_context(
+  json,
+  additional: [
+    'https://w3id.org/security/v1',
+    actor_data.delete(:@context),
+  ]
+)
 
 json.id actor.federated_url
 json.name actor.name

data/app/views/federails/server/actors/_tombstone.activitypub.jbuilder

@@ -1,7 +1,4 @@
-json.set! '@context', [
-  'https://www.w3.org/ns/activitystreams',
-  'https://w3id.org/security/v1',
-]
+set_json_ld_context(json)
 
 json.id actor.federated_url
 json.type 'Tombstone'

data/app/views/federails/server/followings/_following.activitypub.jbuilder

@@ -1,5 +1,5 @@
 context = true unless context == false
-json.set! '@context', 'https://www.w3.org/ns/activitystreams' if context
+set_json_ld_context(json) if context
 
 json.id following.federated_url
 json.type 'Follow'

data/app/views/federails/server/nodeinfo/index.nodeinfo.jbuilder

@@ -1,6 +1,6 @@
 json.links [
   {
-    rel:  'https://nodeinfo.diaspora.software/ns/schema/2.0',
+    rel:  'http://nodeinfo.diaspora.software/ns/schema/2.0',
     href: show_node_info_url,
   },
 ]

data/app/views/federails/server/nodeinfo/show.nodeinfo.jbuilder

@@ -1,6 +1,5 @@
 json.version '2.0'
-# FIXME: Use configuration values when created
-json.software name:    Federails::Configuration.app_name,
+json.software name:    Federails::Configuration.app_name&.parameterize,
               version: Federails::Configuration.app_version
 json.protocols [
   'activitypub',
@@ -17,4 +16,4 @@ if @has_user_counts
     activeHalfyear: @active_halfyear,
   }
 end
-json.metadata({})
+json.metadata(Federails::Configuration.nodeinfo_metadata || {})

data/app/views/federails/server/published/_publishable.activitypub.jbuilder

@@ -1,5 +1,5 @@
 context = true unless context == false
-json.set! '@context', 'https://www.w3.org/ns/activitystreams' if context
+set_json_ld_context(json) if context
 
 publishable.to_activitypub_object.each_pair do |key, value|
   json.set! key, value
@@ -7,5 +7,5 @@ end
 
 json.id publishable.federated_url
 json.actor publishable.federails_actor.federated_url
-json.to ['https://www.w3.org/ns/activitystreams#Public']
+json.to [Fediverse::Collection::PUBLIC]
 json.cc [publishable.federails_actor.followers_url]

data/app/views/federails/server/published/_tombstone.activitypub.jbuilder

@@ -1,7 +1,4 @@
-json.set! '@context', [
-  'https://www.w3.org/ns/activitystreams',
-  'https://w3id.org/security/v1',
-]
+set_json_ld_context(json)
 
 json.id publishable.federated_url
 json.type 'Tombstone'

data/app/views/federails/server/shared/ordered_collection.activitypub.jbuilder

@@ -0,0 +1,6 @@
+set_json_ld_context(json)
+json.id send(url_helper, actor)
+json.type 'OrderedCollection'
+json.totalItems collection.total_count
+json.first send(url_helper, actor, page: 1)
+json.last send(url_helper, actor, page: collection.total_pages)

data/app/views/federails/server/shared/ordered_collection_page.activitypub.jbuilder

@@ -0,0 +1,12 @@
+set_json_ld_context(json)
+json.type 'OrderedCollectionPage'
+json.id send(url_helper, actor, page: collection.current_page)
+json.partOf send(url_helper, actor)
+json.first send(url_helper, actor, page: 1)
+json.last send(url_helper, actor, page: collection.total_pages)
+json.next send(url_helper, actor, page: collection.next_page) if collection.next_page
+json.prev send(url_helper, actor, page: collection.prev_page) if collection.prev_page
+json.totalItems collection.total_count
+json.orderedItems do
+  items_block.call(json, collection)
+end

data/app/views/users/show.html.erb

@@ -0,0 +1,4 @@
+This page renders a users profile; its route (<code>user_url</code>) is used as <code>:profile_url_method</code>
+in Federails integration (<code>acts_as_actor_entity</code> in <code>User</code> model).
+
+<pre><%= JSON.pretty_generate @user.as_json %></pre>

data/db/migrate/20250426061729_create_federails_hosts.rb

@@ -0,0 +1,22 @@
+class CreateFederailsHosts < ActiveRecord::Migration[7.2]
+  def change
+    create_table :federails_hosts do |t|
+      t.string :domain, null: false, default: nil
+      t.string :nodeinfo_url
+      t.string :software_name
+      t.string :software_version
+
+      # Uncomment the lines below if you use PostgreSQL
+      # t.jsonb :protocols, default: []
+      # t.jsonb :services, default: {}
+      #
+      # Other databases
+      t.text :protocols, default: '[]'
+      t.text :services, default: '{}'
+
+      t.timestamps
+
+      t.index :domain, unique: true
+    end
+  end
+end

data/db/migrate/20251121160720_add_to_and_cc_to_federails_activities.rb

@@ -0,0 +1,6 @@
+class AddToAndCcToFederailsActivities < ActiveRecord::Migration[7.2]
+  def change
+    add_column :federails_activities, :to, :string
+    add_column :federails_activities, :cc, :string
+  end
+end

data/lib/federails/configuration.rb

@@ -35,6 +35,14 @@ module Federails
       @@open_registrations.is_a?(Proc) ? @@open_registrations.call : @@open_registrations
     end
 
+    # Custom metadata for nodeinfo
+    # Can either be a static hash, or a Proc which will be called to get the state.
+    mattr_writer :nodeinfo_metadata
+    @@nodeinfo_metadata = {}
+    def self.nodeinfo_metadata
+      @@nodeinfo_metadata.is_a?(Proc) ? @@nodeinfo_metadata.call : @@nodeinfo_metadata
+    end
+
     # Application layout
     mattr_accessor :app_layout
     @@app_layout = nil
@@ -58,6 +66,13 @@ module Federails
     # @!method self.remote_follow_url_method=(value)
     #
     # Sets the route method for remote-following requests
+    #
+    # The route should lead to a page displaying the remote actor and a button to follow it.
+    # Remote actor is specified in the `uri` query parameter.
+    #
+    # Its value defaults to a route of the Federails client, so your application will break
+    # if you don't use the client routes and don't override this value.
+    #
     # @param value [String] Route method name as used in links
     # @example
     #   remote_follow_url_method 'main_app.my_custom_route_helper'
@@ -74,6 +89,16 @@ module Federails
       Federails::Engine.routes.default_url_options[:port] = value
     end
 
+    # Default amount of seconds to consider that a remote entity could be updated
+    #
+    # This setting is used for hosts information only, for now.
+    mattr_accessor :remote_entities_cache_duration
+    @@remote_entities_cache_duration = 1.day
+
+    # Job queue name
+    mattr_accessor :job_queue
+    @@job_queue = :default
+
     # List of actor types (classes using Federails::ActorEntity)
     mattr_reader :actor_types
     @@actor_types = {}

data/lib/federails/data_transformer/note.rb

@@ -1,3 +1,5 @@
+require 'federails/utils/context'
+
 module Federails
   module DataTransformer
     module Note
@@ -17,7 +19,10 @@ module Federails
       #   - https://www.w3.org/TR/activitystreams-vocabulary/#dfn-object
       #   - https://www.w3.org/TR/activitystreams-vocabulary/#dfn-note
       def self.to_federation(entity, content:, name: nil, custom: {})
-        custom.merge '@context'     => 'https://www.w3.org/ns/activitystreams',
+        # Merge default and custom contexts
+        context = Utils::Context.generate(additional: custom.delete('@context'))
+        # Merge in standard Note fields
+        custom.merge '@context'     => context,
                      'id'           => entity.federated_url,
                      'type'         => 'Note',
                      'name'         => name,

data/lib/federails/maintenance/actors_updater.rb

@@ -54,12 +54,11 @@ module Federails
         def update(actor)
           return :ignored_local if actor.local?
 
-          response = Fediverse::Webfinger.fetch_actor_url(actor.federated_url)
-          new_attributes = response.attributes.except 'id', 'uuid', 'created_at', 'updated_at', 'local', 'entity_id', 'entity_type'
-
-          actor.update(new_attributes) ? :updated : :failed
+          actor.sync! ? :updated : :failed
         rescue ActiveRecord::RecordNotFound
           :not_found
+        rescue StandardError
+          :failed
         end
       end
     end

data/lib/federails/maintenance/hosts_updater.rb

@@ -0,0 +1,19 @@
+module Federails
+  module Maintenance
+    class HostsUpdater
+      class << self
+        # Update information for all known hosts, and complete if some are missing
+        def run(cache_interval: nil)
+          cache_interval ||= Federails::Configuration.remote_entities_cache_duration
+
+          domains = Federails::Actor.distant.distinct(:server).pluck(:server) + Federails::Host.pluck(:domain)
+          domains.uniq!
+
+          domains.each do |domain|
+            Federails::Host.create_or_update domain, min_update_interval: cache_interval
+          end
+        end
+      end
+    end
+  end
+end

data/lib/federails/utils/actor.rb

@@ -27,13 +27,21 @@ module Federails
           actor
         end
 
+        def untombstone!(actor)
+          if actor.local?
+            untombstone_local_actor actor
+          else
+            untombstone_distant_actor actor
+          end
+        end
+
         private
 
         def tombstone_local_actor(actor)
           Federails::Actor.transaction do
             hash = {
               tombstoned_at: Time.current,
-              entity:        nil,
+              entity:        actor.entity || nil,
             }
             # Hardcode attributes depending on the actor's entity
             COMPUTED_ATTRIBUTES.each { |attribute| hash[attribute] = actor.send(attribute) }
@@ -44,9 +52,33 @@ module Federails
           end
         end
 
+        def untombstone_local_actor(actor)
+          return unless actor.tombstoned?
+          raise 'Cannot restore a local actor without an entity' if actor.entity.blank?
+
+          Federails::Actor.transaction do
+            # Reset hardcoded attributes depending on the actor's entity
+            hash = { tombstoned_at: nil }
+            COMPUTED_ATTRIBUTES.each { |attribute| hash[attribute] = nil }
+
+            actor.update! hash
+
+            delete_activity = Activity.find_by actor: actor, action: 'Delete', entity: actor
+            return unless delete_activity
+
+            Activity.create! actor: actor, action: 'Undo', entity: delete_activity
+          end
+        end
+
         def tombstone_distant_actor(actor)
           actor.update! tombstoned_at: Time.current
         end
+
+        def untombstone_distant_actor(actor)
+          actor.tombstoned_at = nil
+          actor.sync!
+          actor.save
+        end
       end
     end
   end

data/lib/federails/utils/context.rb

@@ -0,0 +1,12 @@
+module Federails
+  module Utils
+    module Context
+      class << self
+        def generate(additional: nil)
+          activity_streams = 'https://www.w3.org/ns/activitystreams'
+          additional.nil? ? activity_streams : [activity_streams, additional].flatten.compact
+        end
+      end
+    end
+  end
+end

data/lib/federails/utils/json_request.rb

@@ -0,0 +1,41 @@
+require 'faraday'
+require 'faraday/follow_redirects'
+
+module Federails
+  module Utils
+    # Simple wrapper to make requests expecting JSON
+    module JsonRequest
+      class UnhandledResponseStatus < StandardError; end
+
+      BASE_HEADERS = {
+        'Content-Type' => 'application/json',
+        'Accept'       => 'application/json',
+      }.freeze
+
+      # Makes a GET request and returns a +Hash+ from the parsed body
+      #
+      # @param url [String] Target URL
+      # @param params [Hash] Querystring parameters
+      # @param headers [Hash] Additional headers
+      # @param follow_redirects [Boolean] Whether to follow redirections
+      # @param expected_status [Integer] Expected response status. Will raise a +UnhandledResponseStatus+ when status is different
+      #
+      # @return The parsed JSON object
+      #
+      # @raise [UnhandledResponseStatus] when response status is not the expected_status
+      def self.get_json(url, params: {}, headers: {}, follow_redirects: false, expected_status: 200)
+        headers = BASE_HEADERS.merge headers
+
+        connection = Faraday.new url: url, params: params, headers: headers do |faraday|
+          faraday.response :follow_redirects if follow_redirects
+          faraday.adapter Faraday.default_adapter
+        end
+
+        response = connection.get
+        raise UnhandledResponseStatus, "Unhandled status code #{response.status} for GET #{url}" if expected_status && response.status != expected_status
+
+        JSON.parse(response.body)
+      end
+    end
+  end
+end

data/lib/federails/utils/object.rb

@@ -121,7 +121,7 @@ module Federails
           entity = handler[:class].new_from_activitypub_object(hash)
           return unless entity
 
-          entity.federails_actor = Federails::Actor.find_or_create_by_object hash['attributedTo'] if entity && !entity.federails_actor
+          entity.federails_actor = Federails::Actor.find_by_federation_url hash['attributedTo'] if entity && !entity.federails_actor
 
           entity
         end

data/lib/federails/utils/response_codes.rb

@@ -0,0 +1,11 @@
+module Federails
+  module Utils
+    module ResponseCodes
+      UNPROCESSABLE_CONTENT = if Gem::Version.new(Rack::RELEASE) < Gem::Version.new('3.1')
+                                :unprocessable_entity
+                              else
+                                :unprocessable_content
+                              end
+    end
+  end
+end

data/lib/federails/version.rb

@@ -1,3 +1,3 @@
 module Federails
-  VERSION = '0.6.2'.freeze
+  VERSION = '0.8.0'.freeze
 end

data/lib/federails.rb

@@ -1,7 +1,15 @@
+require 'jbuilder'
+require 'kaminari'
+require 'pundit'
+
 require 'federails/version'
 require 'federails/engine'
 require 'federails/configuration'
 require 'federails/utils/object'
+require 'federails/utils/json_request'
+require 'federails/utils/response_codes'
+
+require 'fediverse'
 
 # rubocop:disable Style/ClassVars
 
@@ -30,11 +38,14 @@ module Federails
         :site_port,
         :enable_discovery,
         :open_registrations,
+        :nodeinfo_metadata,
         :app_layout,
         :server_routes_path,
         :client_routes_path,
         :remote_follow_url_method,
         :base_client_controller,
+        :remote_entities_cache_duration,
+        :job_queue,
       ].each { |key| Configuration.send :"#{key}=", config[key] if config.key?(key) }
     end
 
@@ -77,9 +88,11 @@ module Federails
     # @return [Hash, nil] Data entity configuration
     def data_entity_handler_for(hash)
       data_entity_handlers_for(hash['type']).find do |handler|
-        return true if !handler[:filter_method] && !handler[:class].respond_to?(DEFAULT_DATA_FILTER_METHOD)
-
-        handler[:class].send(handler[:filter_method] || DEFAULT_DATA_FILTER_METHOD, hash)
+        if handler[:filter_method] || handler[:class].respond_to?(DEFAULT_DATA_FILTER_METHOD)
+          handler[:class].send(handler[:filter_method] || DEFAULT_DATA_FILTER_METHOD, hash)
+        else
+          true
+        end
       end
     end
 

data/lib/fediverse/collection.rb

@@ -0,0 +1,31 @@
+module Fediverse
+  class Collection < Array
+    PUBLIC = 'https://www.w3.org/ns/activitystreams#Public'.freeze
+
+    attr_reader :total_items, :id, :type
+
+    def self.fetch(url)
+      new.fetch(url)
+    end
+
+    def fetch(url)
+      json = Fediverse::Request.dereference(url)
+      @total_items = json['totalItems']
+      @id = json['id']
+      @type = json['type']
+      raise Errors::NotACollection unless %w[OrderedCollection Collection].include?(@type)
+
+      next_url = json['first']
+      while next_url
+        page = Fediverse::Request.dereference(next_url)
+        concat(page['orderedItems'] || page['items'])
+        next_url = page['next']
+      end
+      self
+    end
+  end
+
+  module Errors
+    class NotACollection < StandardError; end
+  end
+end

data/lib/fediverse/inbox.rb

@@ -90,11 +90,21 @@ module Fediverse
 
         object.run_callbacks :on_federails_delete_requested
       end
+
+      def handle_undelete_request(activity)
+        # Get to original object
+        delete_activity = Request.dereference(activity['object'])
+        object = Federails::Utils::Object.find_distant_object_in_all(delete_activity['object'])
+        return if object.blank?
+
+        object.run_callbacks :on_federails_undelete_requested
+      end
     end
 
     register_handler 'Follow', '*', self, :handle_create_follow_request
     register_handler 'Accept', 'Follow', self, :handle_accept_follow_request
     register_handler 'Undo', 'Follow', self, :handle_undo_follow_request
     register_handler 'Delete', '*', self, :handle_delete_request
+    register_handler 'Undo', 'Delete', self, :handle_undelete_request
   end
 end

data/lib/fediverse/node_info.rb

@@ -0,0 +1,38 @@
+module Fediverse
+  class NodeInfo
+    class NotFoundError < StandardError; end
+    class NoActivityPubError < StandardError; end
+
+    class << self
+      def fetch(domain)
+        url = nodeinfo_url(domain)
+
+        hash = Federails::Utils::JsonRequest.get_json url
+        raise NoActivityPubError, "#{domain} does not handle activitypub protocol" unless hash['protocols'].include? 'activitypub'
+
+        {
+          domain:           domain,
+          nodeinfo_url:     url,
+          software_version: hash.dig('software', 'version'),
+          software_name:    hash.dig('software', 'name'),
+          protocols:        hash['protocols'],
+          services:         hash['services'],
+        }
+      end
+
+      private
+
+      def base_url(domain)
+        scheme = Federails::Configuration.force_ssl ? 'https' : 'http'
+        @base_url = "#{scheme}://#{domain}"
+      end
+
+      def nodeinfo_url(domain)
+        response = Federails::Utils::JsonRequest.get_json "#{base_url(domain)}/.well-known/nodeinfo", follow_redirects: true
+        entry = response['links']&.find { |link| link['rel'] == 'http://nodeinfo.diaspora.software/ns/schema/2.0' }
+
+        entry['href']
+      end
+    end
+  end
+end

data/lib/fediverse/notifier.rb

@@ -7,18 +7,45 @@ module Fediverse
       #
       # @param activity [Federails::Activity]
       def post_to_inboxes(activity)
-        actors = activity.recipients
-        Rails.logger.debug('Nobody to notice') && return if actors.count.zero?
+        # Get the list of actors we need to send the activity to
+        inboxes = inboxes_for(activity)
+        Rails.logger.debug('Nobody to notice') && return if inboxes.none?
 
+        # Deliver to each inbox
         message = payload(activity)
-        actors.each do |recipient|
-          Rails.logger.debug { "Sending activity ##{activity.id} to #{recipient.inbox_url}" }
-          post_to_inbox(to: recipient, message: message, from: activity.actor)
+        inboxes.each do |url|
+          Rails.logger.debug { "Sending activity ##{activity.id} to inbox at #{url}" }
+          post_to_inbox(inbox_url: url, message: message, from: activity.actor)
         end
       end
 
       private
 
+      # Determines the list of inboxes that the activity should be delivered to
+      #
+      # @return [Array<Federails::Actor>]
+      def inboxes_for(activity)
+        return [] unless activity.actor.local?
+
+        [activity.to, activity.cc].flatten.compact.reject { |x| x == Fediverse::Collection::PUBLIC }.map do |url|
+          actor = Federails::Actor.find_or_create_by_federation_url(url)
+          [actor.inbox_url]
+        rescue ActiveRecord::RecordNotFound, ActiveRecord::RecordInvalid
+          collection_to_actors(url).map(&:inbox_url)
+        end.flatten.compact
+      end
+
+      def collection_to_actors(url)
+        collection = Collection.fetch(url)
+        collection.filter_map do |actor_url|
+          Federails::Actor.find_or_create_by_federation_url(actor_url)
+        rescue ActiveRecord::RecordNotFound, ActiveRecord::RecordInvalid
+          nil
+        end
+      rescue Errors::NotACollection
+        []
+      end
+
       def payload(activity)
         Federails::ServerController.renderer.new.render(
           template: 'federails/server/activities/show',
@@ -27,27 +54,27 @@ module Fediverse
         )
       end
 
-      def post_to_inbox(to:, message:, from: nil)
+      def post_to_inbox(inbox_url:, message:, from: nil)
         conn = Faraday.default_connection
         conn.builder.build_response(
           conn,
-          signed_request(to: to, message: message, from: from)
+          signed_request(url: inbox_url, message: message, from: from)
         )
       end
 
-      def signed_request(to:, message:, from:)
-        req = request(to: to, message: message)
+      def signed_request(url:, message:, from:)
+        req = request(url: url, message: message)
         req.headers['Signature'] = Fediverse::Signature.sign(sender: from, request: req) if from
         req
       end
 
-      def request(to:, message:) # rubocop:todo Metrics/AbcSize
+      def request(url:, message:) # rubocop:todo Metrics/AbcSize
         Faraday.default_connection.build_request(:post) do |req|
-          req.url to.inbox_url
+          req.url url
           req.body = message
           req.headers['Content-Type'] = Mime[:activitypub].to_s
           req.headers['Accept'] = Mime[:activitypub].to_s
-          req.headers['Host'] = URI.parse(to.inbox_url).host
+          req.headers['Host'] = URI.parse(url).host
           req.headers['Date'] = Time.now.utc.httpdate
           req.headers['Digest'] = digest(message)
         end