diaspora_federation 0.0.13 → 0.1.0

data/lib/diaspora_federation/entities/signed_retraction.rb

@@ -30,10 +30,15 @@ module DiasporaFederation
       #   @return [String] author signature
       property :target_author_signature, default: nil
 
+      # @!attribute [r] target
+      #   target entity
+      #   @return [RelatedEntity] target entity
+      entity :target, Entities::RelatedEntity
+
       # use only {Retraction} for receive
       # @return [Retraction] instance as normal retraction
       def to_retraction
-        Retraction.new(author: author, target_guid: target_guid, target_type: target_type)
+        Retraction.new(author: author, target_guid: target_guid, target_type: target_type, target: target)
       end
 
       # Create signature for a retraction
@@ -44,14 +49,20 @@ module DiasporaFederation
         Base64.strict_encode64(privkey.sign(Relayable::DIGEST, [ret.target_guid, ret.target_type].join(";")))
       end
 
+      # @return [String] string representation of this object
+      def to_s
+        "SignedRetraction:#{target_type}:#{target_guid}"
+      end
+
       private
 
       # @param [Nokogiri::XML::Element] root_node xml nodes
       # @return [Retraction] instance
-      def self.populate_entity(root_node)
-        super(root_node).to_retraction
+      private_class_method def self.populate_entity(root_node)
+        entity_data = entity_data(root_node)
+        entity_data[:target] = Retraction.send(:fetch_target, entity_data[:target_type], entity_data[:target_guid])
+        new(entity_data).to_retraction
       end
-      private_class_method :populate_entity
 
       # It updates also the signatures with the keys of the author and the parent
       # if the signatures are not there yet and if the keys are available.
@@ -64,7 +75,7 @@ module DiasporaFederation
       end
 
       def sign_with_author
-        privkey = DiasporaFederation.callbacks.trigger(:fetch_private_key_by_diaspora_id, author)
+        privkey = DiasporaFederation.callbacks.trigger(:fetch_private_key, author)
         SignedRetraction.sign_with_key(privkey, self) unless privkey.nil?
       end
     end

data/lib/diaspora_federation/entities/status_message.rb

@@ -30,6 +30,17 @@ module DiasporaFederation
       #   shows whether the status message is visible to everyone or only to some aspects
       #   @return [Boolean] is it public
       property :public, default: false
+
+      private
+
+      def validate
+        super
+        photos.each do |photo|
+          if photo.author != author
+            raise ValidationError, "nested #{photo} has different author: author=#{author} obj=#{self}"
+          end
+        end
+      end
     end
   end
 end

data/lib/diaspora_federation/entity.rb

@@ -34,6 +34,11 @@ module DiasporaFederation
   #   are intended to be immutable data containers, only.
   class Entity
     extend PropertiesDSL
+    include Logging
+
+    # Invalid XML characters
+    # @see https://www.w3.org/TR/REC-xml/#charsets "Extensible Markup Language (XML) 1.0"
+    INVALID_XML_REGEX = /[^\x09\x0A\x0D\x20-\uD7FF\uE000-\uFFFD\u{10000}-\u{10FFFF}]/
 
     # Initializes the Entity with the given attribute hash and freezes the created
     # instance it returns.
@@ -50,27 +55,35 @@ module DiasporaFederation
     # @param [Hash] data entity data
     # @return [Entity] new instance
     def initialize(data)
+      logger.debug "create entity #{self.class} with data: #{data}"
       raise ArgumentError, "expected a Hash" unless data.is_a?(Hash)
+
       entity_data = self.class.resolv_aliases(data)
-      missing_props = self.class.missing_props(entity_data)
-      unless missing_props.empty?
-        raise ArgumentError, "missing required properties: #{missing_props.join(', ')}"
-      end
+      validate_missing_props(entity_data)
 
       self.class.default_values.merge(entity_data).each do |name, value|
-        instance_variable_set("@#{name}", nilify(value)) if setable?(name, value)
+        instance_variable_set("@#{name}", instantiate_nested(name, nilify(value))) if setable?(name, value)
       end
 
       freeze
       validate
     end
 
-    # Returns a Hash representing this Entity (attributes => values)
+    # Returns a Hash representing this Entity (attributes => values).
+    # Nested entities are also converted to a Hash.
     # @return [Hash] entity data (mostly equal to the hash used for initialization).
     def to_h
-      self.class.class_props.keys.each_with_object({}) do |prop, hash|
-        hash[prop] = public_send(prop)
-      end
+      properties.map {|key, value|
+        type = self.class.class_props[key]
+
+        if type == String || value.nil?
+          [key, value]
+        elsif type.instance_of?(Class)
+          [key, value.to_h]
+        elsif type.instance_of?(Array)
+          [key, value.map(&:to_h)]
+        end
+      }.to_h
     end
 
     # Returns the XML representation for this entity constructed out of
@@ -131,8 +144,18 @@ module DiasporaFederation
       Entities.const_get(class_name)
     end
 
+    # @return [String] string representation of this object
+    def to_s
+      "#{self.class.name.rpartition('::').last}#{":#{guid}" if respond_to?(:guid)}"
+    end
+
     private
 
+    def validate_missing_props(entity_data)
+      missing_props = self.class.missing_props(entity_data)
+      raise ArgumentError, "missing required properties: #{missing_props.join(', ')}" unless missing_props.empty?
+    end
+
     def setable?(name, val)
       type = self.class.class_props[name]
       return false if type.nil? # property undefined
@@ -145,18 +168,30 @@ module DiasporaFederation
     end
 
     def setable_nested?(type, val)
-      type.is_a?(Class) && type.ancestors.include?(Entity) && val.is_a?(Entity)
+      type.instance_of?(Class) && type.ancestors.include?(Entity) && (val.is_a?(Entity) || val.is_a?(Hash))
     end
 
     def setable_multi?(type, val)
-      type.instance_of?(Array) && val.instance_of?(Array) && val.all? {|v| v.instance_of?(type.first) }
+      type.instance_of?(Array) && val.instance_of?(Array) &&
+        (val.all? {|v| v.instance_of?(type.first) } || val.all? {|v| v.instance_of?(Hash) })
     end
 
     def nilify(value)
-      return nil if value.respond_to?(:empty?) && value.empty?
+      return nil if value.respond_to?(:empty?) && value.empty? && !value.instance_of?(Array)
       value
     end
 
+    def instantiate_nested(name, value)
+      if value.instance_of?(Array)
+        return value unless value.first.instance_of?(Hash)
+        value.map {|hash| self.class.class_props[name].first.new(hash) }
+      elsif value.instance_of?(Hash)
+        self.class.class_props[name].new(value)
+      else
+        value
+      end
+    end
+
     def validate
       validator_name = "#{self.class.name.split('::').last}Validator"
       return unless Validators.const_defined? validator_name
@@ -173,8 +208,15 @@ module DiasporaFederation
       "Failed validation for properties: #{errors.join(' | ')}"
     end
 
+    # @return [Hash] hash with all properties
+    def properties
+      self.class.class_props.keys.each_with_object({}) do |prop, hash|
+        hash[prop] = public_send(prop)
+      end
+    end
+
     def xml_elements
-      Hash[to_h.map {|name, value| [name, self.class.class_props[name] == String ? value.to_s : value] }]
+      properties.map {|name, value| [name, self.class.class_props[name] == String ? value.to_s : value] }.to_h
     end
 
     def add_property_to_xml(doc, root_element, name, value)
@@ -183,7 +225,8 @@ module DiasporaFederation
       else
         # call #to_xml for each item and append to root
         [*value].compact.each do |item|
-          root_element << item.to_xml
+          child = item.to_xml
+          root_element << child if child
         end
       end
     end
@@ -192,26 +235,30 @@ module DiasporaFederation
     def simple_node(doc, name, value)
       xml_name = self.class.xml_names[name]
       Nokogiri::XML::Element.new(xml_name ? xml_name.to_s : name, doc).tap do |node|
-        node.content = value unless value.empty?
+        node.content = value.gsub(INVALID_XML_REGEX, "\uFFFD") unless value.empty?
       end
     end
 
     # @param [Nokogiri::XML::Element] root_node xml nodes
     # @return [Entity] instance
-    def self.populate_entity(root_node)
-      entity_data = Hash[class_props.map {|name, type|
-        [name, parse_element_from_node(name, type, root_node)]
-      }]
+    private_class_method def self.populate_entity(root_node)
+      new(entity_data(root_node))
+    end
 
-      new(entity_data)
+    # @param [Nokogiri::XML::Element] root_node xml nodes
+    # @return [Hash] entity data
+    private_class_method def self.entity_data(root_node)
+      class_props.map {|name, type|
+        value = parse_element_from_node(name, type, root_node)
+        [name, value] if value
+      }.compact.to_h
     end
-    private_class_method :populate_entity
 
     # @param [String] name property name to parse
     # @param [Class] type target type to parse
     # @param [Nokogiri::XML::Element] root_node XML node to parse
     # @return [Object] parsed data
-    def self.parse_element_from_node(name, type, root_node)
+    private_class_method def self.parse_element_from_node(name, type, root_node)
       if type == String
         parse_string_from_node(name, root_node)
       elsif type.instance_of?(Array)
@@ -220,41 +267,37 @@ module DiasporaFederation
         parse_entity_from_node(type, root_node)
       end
     end
-    private_class_method :parse_element_from_node
 
     # create simple entry in data hash
     #
     # @param [String] name xml tag to parse
     # @param [Nokogiri::XML::Element] root_node XML root_node to parse
     # @return [String] data
-    def self.parse_string_from_node(name, root_node)
+    private_class_method def self.parse_string_from_node(name, root_node)
       node = root_node.xpath(name.to_s)
       node = root_node.xpath(xml_names[name].to_s) if node.empty?
       node.first.text if node.any?
     end
-    private_class_method :parse_string_from_node
 
     # create an entry in the data hash for the nested entity
     #
     # @param [Class] type target type to parse
     # @param [Nokogiri::XML::Element] root_node XML node to parse
     # @return [Entity] parsed child entity
-    def self.parse_entity_from_node(type, root_node)
+    private_class_method def self.parse_entity_from_node(type, root_node)
       node = root_node.xpath(type.entity_name)
       type.from_xml(node.first) if node.any?
     end
-    private_class_method :parse_entity_from_node
 
     # collect all nested children of that type and create an array in the data hash
     #
     # @param [Class] type target type to parse
     # @param [Nokogiri::XML::Element] root_node XML node to parse
     # @return [Array<Entity>] array with parsed child entities
-    def self.parse_array_from_node(type, root_node)
+    private_class_method def self.parse_array_from_node(type, root_node)
       node = root_node.xpath(type.entity_name)
-      node.map {|child| type.from_xml(child) }
+      node.map {|child| type.from_xml(child) } unless node.empty?
     end
-    private_class_method :parse_array_from_node
 
     # Raised, if entity is not valid
     class ValidationError < RuntimeError

data/lib/diaspora_federation/federation/fetcher.rb

@@ -7,7 +7,9 @@ module DiasporaFederation
       # @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}")
+        url = DiasporaFederation.callbacks.trigger(
+          :fetch_person_url_to, author, "/fetch/#{entity_name(entity_type)}/#{guid}"
+        )
         response = HttpClient.get(url)
         raise "Failed to fetch #{url}: #{response.status}" unless response.success?
 
@@ -18,6 +20,14 @@ module DiasporaFederation
         raise NotFetchable, "Failed to fetch #{entity_type}:#{guid} from #{author}: #{e.class}: #{e.message}"
       end
 
+      private_class_method def self.entity_name(class_name)
+        return class_name if class_name =~ /^[a-z]*(_[a-z]*)*$/
+
+        raise DiasporaFederation::Entity::UnknownEntity, class_name unless Entities.const_defined?(class_name)
+
+        class_name.gsub(/(.)([A-Z])/, '\1_\2').downcase
+      end
+
       # Raised, if the entity is not fetchable
       class NotFetchable < RuntimeError
       end

data/lib/diaspora_federation/federation/receiver.rb

@@ -2,6 +2,8 @@ module DiasporaFederation
   module Federation
     # this module is for parse and receive entities.
     module Receiver
+      extend Logging
+
       # receive a public message
       # @param [String] data message to receive
       # @param [Boolean] legacy use old slap parser
@@ -13,6 +15,10 @@ module DiasporaFederation
                       Salmon::MagicEnvelope.unenvelop(magic_env_xml)
                     end
         Public.new(magic_env).receive
+      rescue => e
+        logger.error "failed to receive public message: #{e.class}: #{e.message}"
+        logger.debug "received data:\n#{data}"
+        raise e
       end
 
       # receive a private message
@@ -30,6 +36,10 @@ module DiasporaFederation
                       Salmon::MagicEnvelope.unenvelop(magic_env_xml)
                     end
         Private.new(magic_env, recipient_id).receive
+      rescue => e
+        logger.error "failed to receive private message for #{recipient_id}: #{e.class}: #{e.message}"
+        logger.debug "received data:\n#{data}"
+        raise e
       end
     end
   end

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

@@ -3,6 +3,8 @@ module DiasporaFederation
     module Receiver
       # common functionality for receivers
       class AbstractReceiver
+        include Logging
+
         # 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
@@ -14,20 +16,32 @@ module DiasporaFederation
 
         # validate and receive the entity
         def receive
-          validate
-          DiasporaFederation.callbacks.trigger(:receive_entity, entity, recipient_id)
+          validate_and_receive
+        rescue => e
+          logger.error "failed to receive #{entity}"
+          raise e
         end
 
         private
 
         attr_reader :entity, :sender, :recipient_id
 
+        def validate_and_receive
+          validate
+          DiasporaFederation.callbacks.trigger(:receive_entity, entity, recipient_id)
+          logger.info "successfully received #{entity} from person #{sender}#{" for #{recipient_id}" if recipient_id}"
+        end
+
         def validate
-          raise InvalidSender unless sender_valid?
+          raise InvalidSender, "invalid sender: #{sender}" unless sender_valid?
         end
 
         def sender_valid?
-          sender == entity.author # TODO: handle sender of relayables
+          if entity.respond_to?(:sender_valid?)
+            entity.sender_valid?(sender)
+          else
+            sender == entity.author
+          end
         end
       end
     end

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

@@ -8,6 +8,10 @@ module DiasporaFederation
       # Raised, if receiving a private message without recipient.
       class RecipientRequired < RuntimeError
       end
+
+      # Raised, if receiving a message with public receiver which is not public but should be.
+      class NotPublic < RuntimeError
+      end
     end
   end
 end

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

@@ -3,6 +3,16 @@ module DiasporaFederation
     module Receiver
       # receiver for public entities
       class Public < AbstractReceiver
+        private
+
+        def validate
+          super
+          raise NotPublic if entity_can_be_public_but_it_is_not?
+        end
+
+        def entity_can_be_public_but_it_is_not?
+          entity.respond_to?(:public) && !entity.public
+        end
       end
     end
   end

data/lib/diaspora_federation/federation/sender.rb

@@ -24,7 +24,7 @@ module DiasporaFederation
       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]] }]
+        hydra.send.map {|url| [url, targets[url]] }.to_h
       end
     end
   end

data/lib/diaspora_federation/http_client.rb

@@ -23,7 +23,7 @@ module DiasporaFederation
       @connection.dup
     end
 
-    def self.create_default_connection
+    private_class_method def self.create_default_connection
       options = {
         request: {timeout: DiasporaFederation.http_timeout},
         ssl:     {ca_file: DiasporaFederation.certificate_authorities}
@@ -36,6 +36,5 @@ module DiasporaFederation
 
       @connection.headers["User-Agent"] = DiasporaFederation.http_user_agent
     end
-    private_class_method :create_default_connection
   end
 end

data/lib/diaspora_federation/logging.rb

@@ -3,6 +3,12 @@ module DiasporaFederation
   #
   # it uses the logging-gem if available
   module Logging
+    # add +logger+ also as class method when included
+    # @param [Class] klass the class into which the module is included
+    def self.included(klass)
+      klass.extend(self)
+    end
+
     private
 
     # get the logger for this class