fedipub 0.0.1 → 0.9.0

data/config/routes.rb

@@ -0,0 +1,53 @@
+Fedipub::Engine.routes.draw do
+  if Fedipub.configuration.enable_discovery
+    scope path: '/' do
+      get '/.well-known/webfinger', to: 'server/web_finger#find', as: :webfinger
+      get '/.well-known/host-meta', to: 'server/web_finger#host_meta', as: :host_meta
+      get '/.well-known/nodeinfo', to: 'server/nodeinfo#index', as: :node_info
+      get '/nodeinfo/2.0', to: 'server/nodeinfo#show', as: :show_node_info
+    end
+  end
+
+  if Fedipub.configuration.client_routes_path
+    scope Fedipub.configuration.client_routes_path, module: :client, as: :client do
+      resources :activities, only: [:index] do
+        collection do
+          get :feed, to: 'activities#feed'
+        end
+      end
+      resources :actors, only: [:index, :show] do
+        collection do
+          get :lookup, to: 'actors#lookup'
+        end
+        resources :activities, only: [:index]
+      end
+      get :feed, to: 'activities#feed'
+      resources :followings, only: [:new, :create, :destroy] do
+        collection do
+          post :follow, to: 'followings#follow'
+        end
+
+        member do
+          put :accept, to: 'followings#accept'
+        end
+      end
+    end
+  end
+
+  scope Fedipub.configuration.server_routes_path, module: :server, as: :server, defaults: { format: :activitypub } do
+    resources :actors, only: [:show] do
+      member do
+        get :followers
+        get :following
+      end
+      get :outbox, to: 'activities#outbox'
+      post :inbox, to: 'activities#create'
+      resources :activities, only: [:show]
+      resources :followings, only: [:show]
+    end
+
+    scope :published do
+      get ':publishable_type/:id', to: 'published#show', as: :published
+    end
+  end
+end

data/db/migrate/20200712133150_create_federails_actors.rb

@@ -0,0 +1,22 @@
+class CreateFederailsActors < ActiveRecord::Migration[7.0]
+  def change
+    create_table :federails_actors do |t|
+      t.string :name
+      t.string :federated_url
+      t.string :username
+      t.string :server
+      t.string :inbox_url
+      t.string :outbox_url
+      t.string :followers_url
+      t.string :followings_url
+      t.string :profile_url
+
+      t.integer :entity_id, null: true
+      t.string :entity_type, null: true
+
+      t.timestamps
+      t.index :federated_url, unique: true
+      t.index [:entity_type, :entity_id], name: 'index_federails_actors_on_entity', unique: true
+    end
+  end
+end

data/db/migrate/20200712143127_create_federails_followings.rb

@@ -0,0 +1,14 @@
+class CreateFederailsFollowings < ActiveRecord::Migration[7.0]
+  def change
+    create_table :federails_followings do |t|
+      t.references :actor, null: false, foreign_key: { to_table: :federails_actors }
+      t.references :target_actor, null: false, foreign_key: { to_table: :federails_actors }
+      t.integer :status, default: 0
+      t.string :federated_url
+
+      t.timestamps
+
+      t.index [:actor_id, :target_actor_id], unique: true
+    end
+  end
+end

data/db/migrate/20200712174938_create_federails_activities.rb

@@ -0,0 +1,11 @@
+class CreateFederailsActivities < ActiveRecord::Migration[7.0]
+  def change
+    create_table :federails_activities do |t|
+      t.references :entity, polymorphic: true, null: false
+      t.string :action, null: false, default: nil
+      t.references :actor, null: false, foreign_key: { to_table: :federails_actors }
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20241002094500_add_uuids.rb

@@ -0,0 +1,13 @@
+class AddUuids < ActiveRecord::Migration[7.0]
+  def change
+    [
+      :federails_actors,
+      :federails_activities,
+      :federails_followings,
+    ].each do |table|
+      change_table table do |t|
+        t.string :uuid, default: nil, index: { unique: true }
+      end
+    end
+  end
+end

data/db/migrate/20241002094501_add_keypair_to_actors.rb

@@ -0,0 +1,8 @@
+class AddKeypairToActors < ActiveRecord::Migration[7.0]
+  def change
+    change_table :federails_actors do |t|
+      t.text :public_key
+      t.text :private_key
+    end
+  end
+end

data/db/migrate/20250122160618_add_extensions_to_federails_actors.rb

@@ -0,0 +1,5 @@
+class AddExtensionsToFederailsActors < ActiveRecord::Migration[7.1]
+  def change
+    add_column :federails_actors, :extensions, :json, default: nil, null: true
+  end
+end

data/db/migrate/20250301082500_add_local_to_actors.rb

@@ -0,0 +1,11 @@
+class AddLocalToActors < ActiveRecord::Migration[7.0]
+  def change
+    add_column :federails_actors, :local, :boolean, null: false, default: false
+
+    reversible do |dir|
+      dir.up do
+        exec_update 'UPDATE federails_actors SET local=true WHERE entity_type IS NOT NULL'
+      end
+    end
+  end
+end

data/db/migrate/20250329123939_add_actor_type_to_actors.rb

@@ -0,0 +1,5 @@
+class AddActorTypeToActors < ActiveRecord::Migration[7.2]
+  def change
+    add_column :federails_actors, :actor_type, :string, null: true
+  end
+end

data/db/migrate/20250329123940_add_tombstoned_at_to_actors.rb

@@ -0,0 +1,5 @@
+class AddTombstonedAtToActors < ActiveRecord::Migration[7.0]
+  def change
+    add_column :federails_actors, :tombstoned_at, :datetime, default: nil
+  end
+end

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/db/migrate/20260421170640_add_result_and_instrument_to_federails_activities.rb

@@ -0,0 +1,6 @@
+class AddResultAndInstrumentToFederailsActivities < ActiveRecord::Migration[7.2]
+  def change
+    add_column :federails_activities, :result, :string
+    add_column :federails_activities, :instrument, :string
+  end
+end

data/db/migrate/20260723113716_rename_federails_to_fedipub.rb

@@ -0,0 +1,15 @@
+class RenameFederailsToFedipub < ActiveRecord::Migration[7.2]
+  def change
+    # Activities
+    rename_index 'federails_activities', 'index_federails_activities_on_entity', 'index_fedipub_activities_on_entity'
+    rename_table 'federails_activities', 'fedipub_activities'
+    # Actors
+    rename_index 'federails_actors', 'index_federails_actors_on_entity', 'index_fedipub_actors_on_entity'
+    rename_table 'federails_actors', 'fedipub_actors'
+    # Followings
+    rename_index 'federails_followings', 'index_federails_followings_on_actor_id_and_target_actor_id', 'index_fedipub_followings_on_actor_id_and_target_actor_id'
+    rename_table 'federails_followings', 'fedipub_followings'
+    # Hosts
+    rename_table 'federails_hosts', 'fedipub_hosts'
+  end
+end

data/lib/fedipub/configuration.rb

@@ -0,0 +1,119 @@
+module Fedipub
+  # rubocop:disable Style/ClassVars
+
+  # Stores the Fedipub configuration in a _singleton_.
+  module Configuration
+    # Application name, used in well-known and nodeinfo endpoints
+    mattr_accessor :app_name
+    @@app_name = nil
+
+    # Application version, used in well-known and nodeinfo endpoints
+    mattr_accessor :app_version
+    @@app_version = nil
+
+    # Force https urls in various rendered content (currently in webfinger views)
+    mattr_accessor :force_ssl
+    @@force_ssl = nil
+
+    # Site hostname
+    mattr_reader :site_host
+    @@site_host = nil
+
+    # Site port
+    mattr_reader :site_port
+    @@site_port = nil
+
+    # Whether to enable ".well-known" and "nodeinfo" endpoints
+    mattr_accessor :enable_discovery
+    @@enable_discovery = true
+
+    # Does the site allow open registrations? (only used for nodeinfo reporting)
+    # Can either be a static boolean, or a Proc which will be called to get the state.
+    mattr_writer :open_registrations
+    @@open_registrations = false
+    def self.open_registrations
+      @@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
+
+    # Route path for the federation URLs (to "Fedipub::Server::*" controllers)
+    mattr_accessor :server_routes_path
+    @@server_routes_path = :federation
+
+    # Route path for the webapp URLs (to "Fedipub::Client::*" controllers)
+    mattr_accessor :client_routes_path
+    @@client_routes_path = :app
+
+    # Default controller to use as base for client controllers
+    mattr_accessor :base_client_controller
+    @@base_client_controller = 'ActionController::Base'
+
+    # @!method self.remote_follow_url_method
+    #
+    # Route method for remote-following requests
+
+    # @!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 Fedipub 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'
+    mattr_accessor :remote_follow_url_method
+    @@remote_follow_url_method = 'fedipub.new_client_following_url'
+
+    def self.site_host=(value)
+      @@site_host = value
+      Fedipub::Engine.routes.default_url_options[:host] = value
+    end
+
+    def self.site_port=(value)
+      @@site_port = value
+      Fedipub::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 Fedipub::ActorEntity)
+    mattr_reader :actor_types
+    @@actor_types = {}
+
+    def self.register_actor_class(klass, config = {})
+      @@actor_types[klass.name] = config.merge(class: klass)
+    end
+
+    # List of data types (classes using Fedipub::DataEntity)
+    mattr_reader :data_types
+    @@data_types = {}
+
+    def self.register_data_type(klass, config = {})
+      @@data_types[klass.name] = config.merge(class: klass)
+    end
+  end
+  # rubocop:enable Style/ClassVars
+end

data/lib/fedipub/data_transformer/note.rb

@@ -0,0 +1,36 @@
+require 'fedipub/utils/context'
+
+module Fedipub
+  module DataTransformer
+    module Note
+      # Renders a Note. The entity is used to determine actor and generic fields data
+      #
+      # @param entity [#federail_actor, #federated_url, #created_at, #updated_at] A model instance
+      # @param content [String] Note content
+      # @param name [String, nil] Optional name/title
+      # @param custom [Hash] Optional additional keys (e.g.: attachment, icon, ...). Defaults will override these.
+      #
+      # @return [Hash]
+      #
+      # @example
+      #   Fedipub::DataTransformer::Note.to_federation(comment, content: comment.content, custom: { 'inReplyTo' => comment.parent.federated_url })
+      #
+      # See:
+      #   - 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: {})
+        # 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,
+                     'content'      => content,
+                     'attributedTo' => entity.fedipub_actor.federated_url,
+                     'published'    => entity.created_at,
+                     'updated'      => entity.updated_at
+      end
+    end
+  end
+end

data/lib/fedipub/engine.rb

@@ -0,0 +1,11 @@
+module Fedipub
+  class Engine < ::Rails::Engine
+    isolate_namespace Fedipub
+
+    config.generators do |g|
+      g.test_framework :rspec
+      g.fixture_replacement :factory_bot
+      g.factory_bot dir: 'spec/factories'
+    end
+  end
+end

data/lib/fedipub/maintenance/actors_updater.rb

@@ -0,0 +1,66 @@
+module Fedipub
+  module Maintenance
+    class ActorsUpdater
+      class << self
+        # Fetches all distant actors again and update their local copy
+        #
+        # A block can be passed with two arguments: the actor being updated and the update status
+        #
+        # @param actors [Integer, Fedipub::Actor, Array<Fedipub::Actor>, nil] Actor ID, Actor or list of actors to update.
+        #   If nothing is passed, all distant actors are processed
+        # @example
+        #   Update all distant actors
+        #     Fedipub::Maintenance::ActorUpdater.run
+        #   With an actor id:
+        #     Fedipub::Maintenance::ActorUpdater.run 1
+        #   With a federated URL:
+        #     Fedipub::Maintenance::ActorUpdater.run 'https://example.com/actor'
+        #   With a federated URL:
+        #     Fedipub::Maintenance::ActorUpdater.run ['https://example.com/actors/1', 'https://example.com/actors/1']
+        #   With actors:
+        #     Fedipub::Maintenance::ActorUpdater.run Fedipub::Actor.last(10)
+        #   Update all distant actors and puts status for each actor
+        #     Fedipub::Maintenance::ActorUpdater.run {|actor, status| puts "#{actor.federated_url}: #{status}"}
+        def run(actors = nil, &block)
+          actors_list(actors).each do |actor|
+            status = update(actor)
+
+            yield(actor, status) if block
+          end
+        end
+
+        private
+
+        # Make a list of actors to update from the passed attribute
+        def actors_list(param) # rubocop:disable Metrics/PerceivedComplexity, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/AbcSize
+          if param.nil?
+            Fedipub::Actor.distant
+          elsif param.is_a? String
+            [Fedipub::Actor.distant.find_by!(federated_url: param)]
+          elsif param.is_a? Integer
+            [Fedipub::Actor.distant.find(param)]
+          elsif param.is_a?(Fedipub::Actor)
+            [param]
+          elsif param.respond_to?(:pluck) && param.first.is_a?(Fedipub::Actor)
+            param
+          elsif param.is_a?(Array) && param.first.is_a?(String)
+            Fedipub::Actor.distant.where(federated_url: param)
+          else
+            raise "Cannot extract actors from #{param.class}"
+          end
+        end
+
+        # @param actor [Fedipub::Actor]
+        def update(actor)
+          return :ignored_local if actor.local?
+
+          actor.sync! ? :updated : :failed
+        rescue ActiveRecord::RecordNotFound
+          :not_found
+        rescue StandardError
+          :failed
+        end
+      end
+    end
+  end
+end

data/lib/fedipub/maintenance/hosts_updater.rb

@@ -0,0 +1,19 @@
+module Fedipub
+  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 ||= Fedipub::Configuration.remote_entities_cache_duration
+
+          domains = Fedipub::Actor.distant.distinct(:server).pluck(:server) + Fedipub::Host.pluck(:domain)
+          domains.uniq!
+
+          domains.each do |domain|
+            Fedipub::Host.create_or_update domain, min_update_interval: cache_interval
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fedipub/utils/actor.rb

@@ -0,0 +1,85 @@
+module Fedipub
+  module Utils
+    class Actor
+      # List of the attributes computed for local actors
+      COMPUTED_ATTRIBUTES = [
+        :federated_url,
+        :username,
+        :name,
+        :server,
+        :inbox_url,
+        :outbox_url,
+        :followers_url,
+        :followings_url,
+        :profile_url,
+      ].freeze
+
+      class << self
+        # @param actor [Fedipub::Actor]
+        # @return [Fedipub::Actor]
+        def tombstone!(actor)
+          if actor.local?
+            tombstone_local_actor actor
+          else
+            tombstone_distant_actor actor
+          end
+
+          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)
+          Fedipub::Actor.transaction do
+            hash = {
+              tombstoned_at: Time.current,
+              entity:        actor.entity || nil,
+            }
+            # Hardcode attributes depending on the actor's entity
+            COMPUTED_ATTRIBUTES.each { |attribute| hash[attribute] = actor.send(attribute) }
+
+            actor.update! hash
+
+            Activity.create! actor: actor, action: 'Delete', entity: actor
+          end
+        end
+
+        def untombstone_local_actor(actor)
+          return unless actor.tombstoned?
+          raise 'Cannot restore a local actor without an entity' if actor.entity.blank?
+
+          Fedipub::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
+
+            delete_activity.undo!
+          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
+end

data/lib/fedipub/utils/context.rb

@@ -0,0 +1,12 @@
+module Fedipub
+  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/fedipub/utils/host.rb

@@ -0,0 +1,54 @@
+module Fedipub
+  module Utils
+    class Host
+      class << self
+        COMMON_PORTS = [80, 443].freeze
+
+        ##
+        # @return [String] Host and port of the current instance
+        def localhost
+          uri = URI.parse Fedipub.configuration.site_host
+          host_and_port (uri.host || 'localhost'), Fedipub.configuration.site_port
+        end
+
+        ##
+        # Checks if the given URL points somewhere on current instance
+        #
+        # @param url [String] URL to check
+        #
+        # @return [true, false]
+        def local_url?(url)
+          uri = URI.parse url
+          host = host_and_port uri.host, uri.port
+          localhost == host
+        end
+
+        ##
+        # Gets the route on the current instance, or nil
+        #
+        # @param url [String] URL to check
+        #
+        # @return [ActionDispatch::Routing::RouteSet, nil] nil when URL do not match a route
+        def local_route(url)
+          return nil unless local_url? url
+
+          Rails.application.routes.recognize_path(url)
+        rescue ActionController::RoutingError
+          nil
+        end
+
+        private
+
+        def host_and_port(host, port)
+          port_string = if port.present? && COMMON_PORTS.exclude?(port)
+                          ":#{port}"
+                        else
+                          ''
+                        end
+
+          "#{host}#{port_string}"
+        end
+      end
+    end
+  end
+end

data/lib/fedipub/utils/json_request.rb

@@ -0,0 +1,41 @@
+require 'faraday'
+require 'faraday/follow_redirects'
+
+module Fedipub
+  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