diaspora_federation 0.0.12 → 0.0.13

data/lib/diaspora_federation/federation.rb

@@ -0,0 +1,9 @@
+module DiasporaFederation
+  # This module contains the federation logic
+  module Federation
+  end
+end
+
+require "diaspora_federation/federation/fetcher"
+require "diaspora_federation/federation/receiver"
+require "diaspora_federation/federation/sender"

data/lib/diaspora_federation/federation/fetcher.rb

@@ -0,0 +1,26 @@
+module DiasporaFederation
+  module Federation
+    # this module is for fetching entities from other pods
+    module Fetcher
+      # fetches a public entity from a remote pod
+      # @param [String] author the diaspora ID of the author of the entity
+      # @param [Symbol, String] entity_type snake_case version of the entity class
+      # @param [String] guid guid of the entity to fetch
+      def self.fetch_public(author, entity_type, guid)
+        url = DiasporaFederation.callbacks.trigger(:fetch_person_url_to, author, "/fetch/#{entity_type}/#{guid}")
+        response = HttpClient.get(url)
+        raise "Failed to fetch #{url}: #{response.status}" unless response.success?
+
+        magic_env_xml = Nokogiri::XML::Document.parse(response.body).root
+        magic_env = Salmon::MagicEnvelope.unenvelop(magic_env_xml)
+        Receiver::Public.new(magic_env).receive
+      rescue => e
+        raise NotFetchable, "Failed to fetch #{entity_type}:#{guid} from #{author}: #{e.class}: #{e.message}"
+      end
+
+      # Raised, if the entity is not fetchable
+      class NotFetchable < RuntimeError
+      end
+    end
+  end
+end

data/lib/diaspora_federation/federation/receiver.rb

@@ -0,0 +1,41 @@
+module DiasporaFederation
+  module Federation
+    # this module is for parse and receive entities.
+    module Receiver
+      # receive a public message
+      # @param [String] data message to receive
+      # @param [Boolean] legacy use old slap parser
+      def self.receive_public(data, legacy=false)
+        magic_env = if legacy
+                      Salmon::Slap.from_xml(data)
+                    else
+                      magic_env_xml = Nokogiri::XML::Document.parse(data).root
+                      Salmon::MagicEnvelope.unenvelop(magic_env_xml)
+                    end
+        Public.new(magic_env).receive
+      end
+
+      # receive a private message
+      # @param [String] data message to receive
+      # @param [OpenSSL::PKey::RSA] recipient_private_key recipient private key to decrypt the message
+      # @param [Object] recipient_id the identifier to persist the entity for the correct user,
+      #   see +receive_entity+ callback
+      # @param [Boolean] legacy use old slap parser
+      def self.receive_private(data, recipient_private_key, recipient_id, legacy=false)
+        raise ArgumentError, "no recipient key provided" unless recipient_private_key.instance_of?(OpenSSL::PKey::RSA)
+        magic_env = if legacy
+                      Salmon::EncryptedSlap.from_xml(data, recipient_private_key)
+                    else
+                      magic_env_xml = Salmon::EncryptedMagicEnvelope.decrypt(data, recipient_private_key)
+                      Salmon::MagicEnvelope.unenvelop(magic_env_xml)
+                    end
+        Private.new(magic_env, recipient_id).receive
+      end
+    end
+  end
+end
+
+require "diaspora_federation/federation/receiver/exceptions"
+require "diaspora_federation/federation/receiver/abstract_receiver"
+require "diaspora_federation/federation/receiver/public"
+require "diaspora_federation/federation/receiver/private"

data/lib/diaspora_federation/federation/receiver/abstract_receiver.rb

@@ -0,0 +1,35 @@
+module DiasporaFederation
+  module Federation
+    module Receiver
+      # common functionality for receivers
+      class AbstractReceiver
+        # create a new receiver
+        # @param [MagicEnvelope] magic_envelope the received magic envelope
+        # @param [Object] recipient_id the identifier of the recipient of a private message
+        def initialize(magic_envelope, recipient_id=nil)
+          @entity = magic_envelope.payload
+          @sender = magic_envelope.sender
+          @recipient_id = recipient_id
+        end
+
+        # validate and receive the entity
+        def receive
+          validate
+          DiasporaFederation.callbacks.trigger(:receive_entity, entity, recipient_id)
+        end
+
+        private
+
+        attr_reader :entity, :sender, :recipient_id
+
+        def validate
+          raise InvalidSender unless sender_valid?
+        end
+
+        def sender_valid?
+          sender == entity.author # TODO: handle sender of relayables
+        end
+      end
+    end
+  end
+end

data/lib/diaspora_federation/federation/receiver/exceptions.rb

@@ -0,0 +1,13 @@
+module DiasporaFederation
+  module Federation
+    module Receiver
+      # Raised, if the sender of the {Salmon::MagicEnvelope} is not allowed to send the entity.
+      class InvalidSender < RuntimeError
+      end
+
+      # Raised, if receiving a private message without recipient.
+      class RecipientRequired < RuntimeError
+      end
+    end
+  end
+end

data/lib/diaspora_federation/federation/receiver/private.rb

@@ -0,0 +1,15 @@
+module DiasporaFederation
+  module Federation
+    module Receiver
+      # receiver for private entities
+      class Private < AbstractReceiver
+        private
+
+        def validate
+          raise RecipientRequired if recipient_id.nil?
+          super
+        end
+      end
+    end
+  end
+end

data/lib/diaspora_federation/federation/receiver/public.rb

@@ -0,0 +1,9 @@
+module DiasporaFederation
+  module Federation
+    module Receiver
+      # receiver for public entities
+      class Public < AbstractReceiver
+      end
+    end
+  end
+end

data/lib/diaspora_federation/federation/sender.rb

@@ -0,0 +1,33 @@
+module DiasporaFederation
+  module Federation
+    # Federation logic to send messages to other pods
+    module Sender
+      # Send a public message to all urls
+      #
+      # @param [String] sender_id sender diaspora-ID
+      # @param [String] obj_str object string representation for logging (e.g. type@guid)
+      # @param [Array<String>] urls receive-urls from pods
+      # @param [String] xml salmon-xml
+      # @return [Array<String>] url to retry
+      def self.public(sender_id, obj_str, urls, xml)
+        hydra = HydraWrapper.new(sender_id, obj_str)
+        urls.each {|url| hydra.insert_job(url, xml) }
+        hydra.send
+      end
+
+      # Send a private message to receive-urls
+      #
+      # @param [String] sender_id sender diaspora-ID
+      # @param [String] obj_str object string representation for logging (e.g. type@guid)
+      # @param [Hash] targets Hash with receive-urls (key) of peoples with encrypted salmon-xml for them (value)
+      # @return [Hash] targets to retry
+      def self.private(sender_id, obj_str, targets)
+        hydra = HydraWrapper.new(sender_id, obj_str)
+        targets.each {|url, xml| hydra.insert_job(url, xml) }
+        Hash[hydra.send.map {|url| [url, targets[url]] }]
+      end
+    end
+  end
+end
+
+require "diaspora_federation/federation/sender/hydra_wrapper"

data/lib/diaspora_federation/federation/sender/hydra_wrapper.rb

@@ -0,0 +1,92 @@
+module DiasporaFederation
+  module Federation
+    module Sender
+      # A wrapper for [Typhoeus::Hydra]
+      #
+      # Uses parallel http requests to send out the salmon-messages
+      class HydraWrapper
+        include Logging
+
+        # Hydra default opts
+        # @return [Hash] hydra opts
+        def self.hydra_opts
+          @hydra_opts ||= {
+            maxredirs: DiasporaFederation.http_redirect_limit,
+            timeout:   DiasporaFederation.http_timeout,
+            method:    :post,
+            verbose:   DiasporaFederation.http_verbose,
+            cainfo:    DiasporaFederation.certificate_authorities,
+            headers:   {
+              "Expect"            => "",
+              "Transfer-Encoding" => "",
+              "User-Agent"        => DiasporaFederation.http_user_agent
+            }
+          }
+        end
+
+        # Create a new instance for a message
+        #
+        # @param [String] sender_id sender diaspora-ID
+        # @param [String] obj_str object string representation for logging (e.g. type@guid)
+        def initialize(sender_id, obj_str)
+          @sender_id = sender_id
+          @obj_str = obj_str
+          @urls_to_retry = []
+        end
+
+        # Prepares and inserts job into the hydra queue
+        # @param [String] url the receive-url for the xml
+        # @param [String] xml xml salmon message
+        def insert_job(url, xml)
+          request = Typhoeus::Request.new(url, HydraWrapper.hydra_opts.merge(body: {xml: xml}))
+          prepare_request(request)
+          hydra.queue(request)
+        end
+
+        # Sends all queued messages
+        # @return [Array<String>] urls to retry
+        def send
+          hydra.run
+          @urls_to_retry
+        end
+
+        private
+
+        # @return [Typhoeus::Hydra] hydra
+        def hydra
+          @hydra ||= Typhoeus::Hydra.new(max_concurrency: DiasporaFederation.http_concurrency)
+        end
+
+        # Logic for after complete
+        # @param [Typhoeus::Request] request
+        def prepare_request(request)
+          request.on_complete do |response|
+            DiasporaFederation.callbacks.trigger(:update_pod, pod_url(response.effective_url), status(response))
+
+            success = response.success?
+            log_line = "success=#{success} sender=#{@sender_id} obj=#{@obj_str} url=#{response.effective_url} " \
+                       "message=#{response.return_code} code=#{response.response_code} time=#{response.total_time}"
+            if success
+              logger.info(log_line)
+            else
+              logger.warn(log_line)
+
+              @urls_to_retry << request.url
+            end
+          end
+        end
+
+        # Get the pod root-url from the send-url
+        # @param [String] url
+        # @return [String] pod root-url
+        def pod_url(url)
+          URI.parse(url).tap {|uri| uri.path = "/" }.to_s
+        end
+
+        def status(res)
+          res.return_code == :ok ? res.response_code : res.return_code
+        end
+      end
+    end
+  end
+end

data/lib/diaspora_federation/{fetcher.rb → http_client.rb}

@@ -2,11 +2,11 @@ require "faraday"
 require "faraday_middleware/response/follow_redirects"
 
 module DiasporaFederation
-  # A wrapper for {https://github.com/lostisland/faraday Faraday} used for
-  # fetching
+  # A wrapper for {https://github.com/lostisland/faraday Faraday}.
   #
   # @see Discovery::Discovery
-  class Fetcher
+  # @see Federation::Fetcher
+  class HttpClient
     # Perform a GET request
     #
     # @param [String] uri the URI
@@ -25,16 +25,16 @@ module DiasporaFederation
 
     def self.create_default_connection
       options = {
-        request: {timeout: 30},
+        request: {timeout: DiasporaFederation.http_timeout},
         ssl:     {ca_file: DiasporaFederation.certificate_authorities}
       }
 
       @connection = Faraday::Connection.new(options) do |builder|
-        builder.use FaradayMiddleware::FollowRedirects, limit: 4
+        builder.use FaradayMiddleware::FollowRedirects, limit: DiasporaFederation.http_redirect_limit
         builder.adapter Faraday.default_adapter
       end
 
-      @connection.headers["User-Agent"] = "DiasporaFederation/#{DiasporaFederation::VERSION}"
+      @connection.headers["User-Agent"] = DiasporaFederation.http_user_agent
     end
     private_class_method :create_default_connection
   end

data/lib/diaspora_federation/properties_dsl.rb

@@ -7,12 +7,13 @@ module DiasporaFederation
   #   property :optional, default: false
   #   property :dynamic_default, default: -> { Time.now }
   #   property :another_prop, xml_name: :another_name
+  #   property :original_prop, alias: :alias_prop
   #   entity :nested, NestedEntity
   #   entity :multiple, [OtherEntity]
   module PropertiesDSL
-    # @return [Array<Hash>] hash of declared entity properties
+    # @return [Hash] hash of declared entity properties
     def class_props
-      @class_props ||= []
+      @class_props ||= {}
     end
 
     # Define a generic (string-type) property
@@ -42,32 +43,48 @@ module DiasporaFederation
     # Return array of missing required property names
     # @return [Array<Symbol>] missing required property names
     def missing_props(args)
-      class_prop_names - default_props.keys - args.keys
+      class_props.keys - default_props.keys - args.keys
     end
 
     # Return a new hash of default values, with dynamic values
     # resolved on each call
     # @return [Hash] default values
     def default_values
-      default_props.each_with_object({}) { |(name, prop), hash|
+      default_props.each_with_object({}) {|(name, prop), hash|
         hash[name] = prop.respond_to?(:call) ? prop.call : prop
       }
     end
 
-    # Returns all nested Entities
-    # @return [Array<Hash>] nested properties
-    def nested_class_props
-      @nested_class_props ||= class_props.select {|p| p[:type] != String }
+    # @param [Hash] data entity data
+    # @return [Hash] hash with resolved aliases
+    def resolv_aliases(data)
+      Hash[data.map {|name, value|
+        if class_prop_aliases.has_key? name
+          prop_name = class_prop_aliases[name]
+          raise InvalidData, "only use '#{name}' OR '#{prop_name}'" if data.has_key? prop_name
+          [prop_name, value]
+        else
+          [name, value]
+        end
+      }]
+    end
+
+    # @return [Symbol] alias for the xml-generation/parsing
+    # @deprecated
+    def xml_names
+      @xml_names ||= {}
     end
 
-    # Returns all property names
-    # @return [Array] property names
-    def class_prop_names
-      @class_prop_names ||= class_props.map {|p| p[:name] }
+    # finds a property by +xml_name+ or +name+
+    # @param [String] xml_name name of the property from the received xml
+    # @return [Hash] the property data
+    def find_property_for_xml_name(xml_name)
+      class_props.keys.find {|name| name.to_s == xml_name || xml_names[name].to_s == xml_name }
     end
 
     private
 
+    # @deprecated
     def determine_xml_name(name, type, opts={})
       raise ArgumentError, "xml_name is not supported for nested entities" if type != String && opts.has_key?(:xml_name)
 
@@ -88,10 +105,13 @@ module DiasporaFederation
     def define_property(name, type, opts={})
       raise InvalidName unless name_valid?(name)
 
-      class_props << {name: name, xml_name: determine_xml_name(name, type, opts), type: type}
+      class_props[name] = type
       default_props[name] = opts[:default] if opts.has_key? :default
+      xml_names[name] = determine_xml_name(name, type, opts)
 
       instance_eval { attr_reader name }
+
+      define_alias(name, opts[:alias]) if opts.has_key? :alias
     end
 
     # checks if the name is a +Symbol+ or a +String+
@@ -105,7 +125,7 @@ module DiasporaFederation
     # @param [Class] type the type to check
     # @return [Boolean]
     def type_valid?(type)
-      [type].flatten.all? { |type|
+      [type].flatten.all? {|type|
         type.respond_to?(:ancestors) && type.ancestors.include?(Entity)
       }
     end
@@ -114,6 +134,19 @@ module DiasporaFederation
       @default_props ||= {}
     end
 
+    # Returns all alias mappings
+    # @return [Hash] alias properties
+    def class_prop_aliases
+      @class_prop_aliases ||= {}
+    end
+
+    # @param [Symbol] name property name
+    # @param [Symbol] alias_name alias name
+    def define_alias(name, alias_name)
+      class_prop_aliases[alias_name] = name
+      instance_eval { alias_method alias_name, name }
+    end
+
     # Raised, if the name is of an unexpected type
     class InvalidName < RuntimeError
     end
@@ -121,5 +154,9 @@ module DiasporaFederation
     # Raised, if the type is of an unexpected type
     class InvalidType < RuntimeError
     end
+
+    # Raised, if the data contains property twice (with name AND alias)
+    class InvalidData < RuntimeError
+    end
   end
 end