amfora 0.0.1

data/lib/amf/messages.rb

@@ -0,0 +1,145 @@
+module AMF
+  module Messages #:nodoc:
+    # Base class for all special AS3 response messages. Maps to
+    # <tt>flex.messaging.messages.AbstractMessage</tt>
+    class AbstractMessage
+      attr_accessor :client_id
+      attr_accessor :destination
+      attr_accessor :message_id
+      attr_accessor :timestamp
+      attr_accessor :time_to_live
+      attr_accessor :headers
+      attr_accessor :body
+      
+      def to_amf(options = {})
+        options[:amf_version] ||= 3
+        options[:serializable_names] = (self.public_methods - Object.new.public_methods).delete_if { |elm| elm =~ /to_amf|body|.*=/ }
+        
+        AMF.serialize(self, options) do |s|
+          if body
+            s.write_utf8_vr("body")
+            s.stream << body
+          end
+        end
+      end
+
+      protected
+      def rand_uuid
+        [8,4,4,4,12].map {|n| rand_hex_3(n)}.join('-').to_s
+      end
+
+      def rand_hex_3(l)
+        "%0#{l}x" % rand(1 << l*4)
+      end
+    end
+
+    # Maps to <tt>flex.messaging.messages.RemotingMessage</tt>
+    class RemotingMessage < AbstractMessage
+      # The name of the service to be called including package name
+      attr_accessor :source
+
+      # The name of the method to be called
+      attr_accessor :operation
+
+      # The arguments to call the method with
+      attr_accessor :parameters
+
+      def initialize
+        @client_id = rand_uuid
+        @destination = nil
+        @message_id = rand_uuid
+        @timestamp = Time.new.to_i*100
+        @time_to_live = 0
+        @headers = {}
+        @body = nil
+      end
+    end
+
+    # Maps to <tt>flex.messaging.messages.AsyncMessage</tt>
+    class AsyncMessage < AbstractMessage
+      attr_accessor :correlation_id
+    end
+
+    # Maps to <tt>flex.messaging.messages.CommandMessage</tt>
+    class CommandMessage < AsyncMessage
+      SUBSCRIBE_OPERATION = 0
+      UNSUSBSCRIBE_OPERATION = 1
+      POLL_OPERATION = 2
+      CLIENT_SYNC_OPERATION = 4
+      CLIENT_PING_OPERATION = 5
+      CLUSTER_REQUEST_OPERATION = 7
+      LOGIN_OPERATION = 8
+      LOGOUT_OPERATION = 9
+      SESSION_INVALIDATE_OPERATION = 10
+      MULTI_SUBSCRIBE_OPERATION = 11
+      DISCONNECT_OPERATION = 12
+      UNKNOWN_OPERATION = 10000
+
+      attr_accessor :operation
+
+      def initialize
+        @operation = UNKNOWN_OPERATION
+      end
+    end
+
+    # Maps to <tt>flex.messaging.messages.AcknowledgeMessage</tt>
+    class AcknowledgeMessage < AsyncMessage
+      def initialize(message = nil)
+        @client_id = rand_uuid
+        @destination = nil
+        @message_id = rand_uuid
+        @timestamp = Time.new.to_i*100
+        @time_to_live = 0
+        @headers = {}
+        @body = nil
+
+        if message.is_a?(AbstractMessage)
+          @correlation_id = message.message_id
+        end
+      end
+    end
+
+    # Maps to <tt>flex.messaging.messages.ErrorMessage</tt> in AMF3 mode
+    class ErrorMessage < AcknowledgeMessage
+      # Extended data that will facilitate custom error processing on the client
+      attr_accessor :extended_data
+
+      # The fault code for the error, which defaults to the class name of the
+      # causing exception
+      attr_accessor :fault_code
+
+      # Detailed description of what caused the error
+      attr_accessor :fault_detail
+
+      # A simple description of the error
+      attr_accessor :fault_string
+
+      # Optional "root cause" of the error
+      attr_accessor :root_cause
+
+      def initialize message, exception
+        super message
+
+        @e = exception
+        @fault_code = @e.class.name
+        @fault_detail = @e.backtrace.join("\n")
+        @fault_string = @e.message
+      end
+
+      def to_amf serializer
+        stream = ""
+        # if serializer.version == 0
+        #    data = {
+        #      :faultCode => @faultCode,
+        #      :faultDetail => @faultDetail,
+        #      :faultString => @faultString
+        #    }
+        #    serializer.write_hash(data, stream)
+        #  else
+        #    serializer.write_object(self, stream)
+        #  end
+        stream
+      end
+    end
+  end
+end

data/lib/amf/pure.rb

@@ -0,0 +1,14 @@
+require 'amf/constants'
+require 'amf/pure/serializer'
+require 'amf/pure/deserializer'
+require 'amf/pure/remoting'
+
+module AMF
+  # This module holds all the modules/classes that implement AMF's
+  # functionality in pure ruby.
+  module Pure
+    $DEBUG and warn "Using pure library for AMF."
+  end
+
+  include AMF::Pure
+end

data/lib/amf/pure/deserializer.rb

@@ -0,0 +1,362 @@
+require 'amf/pure/io_helpers'
+
+module AMF
+  module Pure
+    # Pure ruby deserializer
+    #--
+    # AMF0 deserializer, it switches over to AMF3 when it sees the switch flag
+    class AMF0Deserializer
+      def initialize
+        @ref_cache = []
+      end
+
+      def deserialize(source, type=nil)
+        source = StringIO.new(source) unless StringIO === source
+        type = read_int8(source) unless type
+        case type
+        when AMF0_NUMBER_MARKER
+          read_number(source)
+        when AMF0_BOOLEAN_MARKER
+          read_boolean(source)
+        when AMF0_STRING_MARKER
+          read_string(source)
+        when AMF0_OBJECT_MARKER
+          read_object(source)
+        when AMF0_NULL_MARKER
+          nil
+        when AMF0_UNDEFINED_MARKER
+          nil
+        when AMF0_REFERENCE_MARKER
+          read_reference(source)
+        when AMF0_HASH_MARKER
+          read_hash(source)
+        when AMF0_STRICT_ARRAY_MARKER
+          read_array(source)
+        when AMF0_DATE_MARKER
+          read_date(source)
+        when AMF0_LONG_STRING_MARKER
+          read_string(source, true)
+        when AMF0_UNSUPPORTED_MARKER
+          nil
+        when AMF0_XML_MARKER
+          #read_xml source
+        when AMF0_TYPED_OBJECT_MARKER
+          read_typed_object(source)
+        when AMF0_AMF3_MARKER
+          AMF3Deserializer.new.deserialize(source)
+        end
+      end
+
+      private
+      include AMF::Pure::ReadIOHelpers
+
+      def read_number(source)
+        res = read_double(source)
+        res.is_a?(Float)&&res.nan? ? nil : res # check for NaN and convert them to nil
+      end
+
+      def read_boolean(source)
+        read_int8(source) != 0
+      end
+
+      def read_string(source, long = false)
+        len = long ? read_word32_network(source) : read_word16_network(source)
+        source.read(len)
+      end
+
+      def read_object(source, add_to_ref_cache=true)
+        obj = {}
+        @ref_cache << obj if add_to_ref_cache
+        while true
+          key = read_string(source).underscore
+          type = read_int8(source)
+          break if type == AMF0_OBJECT_END_MARKER
+          obj[key.to_sym] = deserialize(source, type)
+        end
+        obj
+      end
+
+      def read_reference(source)
+        index = read_word16_network(source)
+        @ref_cache[index]
+      end
+
+      def read_hash(source)
+        len = read_word32_network(source) # Read and ignore length
+
+        # Read first pair
+        key = read_string(source).underscore
+        
+        type = read_int8(source)
+        return [] if type == AMF0_OBJECT_END_MARKER
+
+        # We need to figure out whether this is a real hash, or whether some stupid serializer gave up
+        if key.to_i.to_s == key
+          # Array
+          obj = []
+          @ref_cache << obj
+
+          obj[key.to_i] = deserialize(source, type)
+          while true
+            key = read_string(source).underscore
+            type = read_int8(source)
+            break if type == AMF0_OBJECT_END_MARKER
+            obj[key.to_i] = deserialize(source, type)
+          end
+        else
+          # Hash
+          obj = {}
+          @ref_cache << obj
+
+          obj[key.to_sym] = deserialize(source, type)
+          while true
+            key = read_string(source).underscore
+            type = read_int8(source)
+            break if type == AMF0_OBJECT_END_MARKER
+            obj[key.to_sym] = deserialize(source, type)
+          end
+        end
+        obj
+      end
+
+      def read_array(source)
+        len = read_word32_network(source)
+        array = []
+        @ref_cache << array
+
+        0.upto(len - 1) do
+          array << deserialize(source)
+        end
+        array
+      end
+
+      def read_date(source)
+        seconds = read_double(source).to_f/1000
+        time = Time.at(seconds)
+        tz = read_word16_network(source) # Unused
+        time
+      end
+
+      def read_typed_object(source)
+        # Create object to add to ref cache
+        class_name = read_string(source)
+        obj = ClassMapper.get_ruby_obj(class_name)
+        @ref_cache << obj
+
+        # Read object props
+        props = read_object(source, false)
+        
+        # Populate object
+        ClassMapper.populate_ruby_obj(obj, props, {})
+        return obj
+      end
+    end
+
+    # AMF3 implementation of deserializer, loaded automatically by the AMF0
+    # deserializer when needed
+    class AMF3Deserializer
+      def initialize
+        @string_cache = []
+        @object_cache = []
+        @trait_cache = []
+      end
+
+      def deserialize(source, type=nil)
+        source = StringIO.new(source) unless StringIO === source
+        type = read_int8 source unless type
+        case type
+          when AMF3_UNDEFINED_MARKER
+            nil
+          when AMF3_NULL_MARKER
+            nil
+          when AMF3_FALSE_MARKER
+            false
+          when AMF3_TRUE_MARKER
+            true
+          when AMF3_INTEGER_MARKER
+            read_integer(source)
+          when AMF3_DOUBLE_MARKER
+            read_number(source)
+          when AMF3_STRING_MARKER
+            read_string(source)
+          when AMF3_XML_DOC_MARKER
+            #read_xml_string
+          when AMF3_DATE_MARKER
+            read_date(source)
+          when AMF3_ARRAY_MARKER
+            read_array(source)
+          when AMF3_OBJECT_MARKER
+            read_object(source)
+          when AMF3_XML_MARKER
+            #read_amf3_xml
+          when AMF3_BYTE_ARRAY_MARKER
+            #read_amf3_byte_array
+        end
+      end
+
+      private
+      include AMF::Pure::ReadIOHelpers
+
+      def read_integer(source)
+        n = 0
+        b = read_word8(source) || 0
+        result = 0
+
+        while ((b & 0x80) != 0 && n < 3)
+          result = result << 7
+          result = result | (b & 0x7f)
+          b = read_word8(source) || 0
+          n = n + 1
+        end
+
+        if (n < 3)
+          result = result << 7
+          result = result | b
+        else
+          #Use all 8 bits from the 4th byte
+          result = result << 8
+          result = result | b
+
+          #Check if the integer should be negative
+          if (result > MAX_INTEGER)
+            result -= (1 << 29)
+          end
+        end
+        result
+      end
+
+      def read_number(source)
+        res = read_double(source)
+        res.is_a?(Float)&&res.nan? ? nil : res # check for NaN and convert them to nil
+      end
+
+      def read_string(source)
+        type = read_integer(source)
+        is_reference = (type & 0x01) == 0
+
+        if is_reference
+          reference = type >> 1
+          return @string_cache[reference]
+        else
+          length = type >> 1
+          #HACK needed for ['',''] array of empty strings
+          #It may be better to take one more parameter that
+          #would specify whether or not they expect us to return
+          #a string
+          str = "" #if stringRequest
+          if length > 0
+            str = source.read(length)
+            @string_cache << str
+          end
+          return str
+        end
+      end
+
+      def read_array(source)
+        type = read_integer(source)
+        is_reference = (type & 0x01) == 0
+
+        if is_reference
+          reference = type >> 1
+          return @object_cache[reference]
+        else
+          length = type >> 1
+          property_name = read_string(source).underscore
+          if property_name != ""
+            array = {}
+            @object_cache << array
+            begin
+              while(property_name.length)
+                value = deserialize(source)
+                array[property_name] = value
+                property_name = read_string(source)
+              end
+            rescue Exception => e #end of object exception, because property_name.length will be non existent
+            end
+            0.upto(length - 1) do |i|
+              array["" + i.to_s] = deserialize(source)
+            end
+          else
+            array = []
+            @object_cache << array
+            0.upto(length - 1) do
+              array << deserialize(source)
+            end
+          end
+          array
+        end
+      end
+
+      def read_object(source)
+        type = read_integer(source)
+        is_reference = (type & 0x01) == 0
+
+        if is_reference
+          reference = type >> 1
+          return @object_cache[reference]
+        else
+          class_type = type >> 1
+          class_is_reference = (class_type & 0x01) == 0
+
+          if class_is_reference
+            reference = class_type >> 1
+            class_definition = @trait_cache[reference]
+          else
+            class_name = read_string(source)
+            externalizable = (class_type & 0x02) != 0
+            dynamic = (class_type & 0x04) != 0
+            attribute_count = class_type >> 3
+
+            class_attributes = []
+            attribute_count.times{class_attributes << read_string(source)} # Read class members
+
+            class_definition = {"class_name" => class_name,
+                                "members" => class_attributes,
+                                "externalizable" => externalizable,
+                                "dynamic" => dynamic}
+            @trait_cache << class_definition
+          end
+
+          obj = ClassMapper.get_ruby_obj(class_definition["class_name"])
+          @object_cache << obj
+
+          if class_definition['externalizable']
+            obj.externalized_data = deserialize(source)
+          else
+            props = {}
+            class_definition['members'].each do |key|
+              value = deserialize(source)
+              props[key.underscore.to_sym] = value
+            end
+
+            dynamic_props = nil
+            if class_definition['dynamic']
+              dynamic_props = {}
+              while (key = read_string(source).underscore) && key.length != 0  do # read next key
+                value = deserialize(source)
+                dynamic_props[key.to_sym] = value
+              end
+            end
+
+            ClassMapper.populate_ruby_obj(obj, props, dynamic_props)
+          end
+          obj
+        end
+      end
+
+      def read_date(source)
+        type = read_integer(source)
+        is_reference = (type & 0x01) == 0
+        if is_reference
+          reference = type >> 1
+          return @object_cache[reference]
+        else
+          seconds = read_double(source).to_f/1000
+          time = Time.at(seconds)
+          @object_cache << time
+          time
+        end
+      end
+    end
+  end
+end