scotttam-RocketAMF 0.2.2

data/lib/rocketamf/pure/io_helpers.rb

@@ -0,0 +1,94 @@
+module RocketAMF
+  module Pure
+    module ReadIOHelpers #:nodoc:
+      def read_int8 source
+        source.read(1).unpack('c').first
+      end
+
+      def read_word8 source
+        source.read(1).unpack('C').first
+      end
+
+      def read_double source
+        source.read(8).unpack('G').first
+      end
+
+      def read_word16_network source
+        source.read(2).unpack('n').first
+      end
+
+      def read_int16_network source
+        str = source.read(2)
+        str.reverse! if byte_order_little? # swap bytes as native=little (and we want network)
+        str.unpack('s').first
+      end
+
+      def read_word32_network source
+        source.read(4).unpack('N').first
+      end
+
+      def byte_order
+        if [0x12345678].pack("L") == "\x12\x34\x56\x78"
+          :BigEndian
+        else
+          :LittleEndian
+        end
+      end
+
+      def byte_order_little?
+        (byte_order == :LittleEndian) ? true : false;
+      end
+    end
+
+    module WriteIOHelpers #:nodoc:
+      def pack_integer(integer)
+        integer = integer & 0x1fffffff
+        if(integer < 0x80)
+          [integer].pack('c')
+        elsif(integer < 0x4000)
+          [integer >> 7 & 0x7f | 0x80].pack('c')+
+          [integer & 0x7f].pack('c')
+        elsif(integer < 0x200000)
+          [integer >> 14 & 0x7f | 0x80].pack('c') +
+          [integer >> 7 & 0x7f | 0x80].pack('c') +
+          [integer & 0x7f].pack('c')
+        else
+          [integer >> 22 & 0x7f | 0x80].pack('c')+
+          [integer >> 15 & 0x7f | 0x80].pack('c')+
+          [integer >> 8 & 0x7f | 0x80].pack('c')+
+          [integer & 0xff].pack('c')
+        end
+      end
+
+      def pack_double(double)
+        [double].pack('G')
+      end
+
+      def pack_int8(val)
+        [val].pack('c')
+      end
+
+      def pack_int16_network(val)
+        [val].pack('n')
+      end
+
+      def pack_word32_network(val)
+        str = [val].pack('L')
+        str.reverse! if byte_order_little? # swap bytes as native=little (and we want network)
+        str
+      end
+
+      def byte_order
+        if [0x12345678].pack("L") == "\x12\x34\x56\x78"
+          :BigEndian
+        else
+          :LittleEndian
+        end
+      end
+
+      def byte_order_little?
+        (byte_order == :LittleEndian) ? true : false;
+      end
+    end
+  end
+end

data/lib/rocketamf/pure/remoting.rb

@@ -0,0 +1,134 @@
+require 'rocketamf/pure/io_helpers'
+
+module RocketAMF
+  module Pure
+    # Included into RocketAMF::Envelope, this module replaces the
+    # populate_from_stream and serialize methods with actual working versions
+    module Envelope
+      # Included into RocketAMF::Envelope, this method handles deserializing an
+      # AMF request/response into the envelope
+      def populate_from_stream stream
+        stream = StringIO.new(stream) unless StringIO === stream
+
+        # Initialize
+        @amf_version = 0
+        @headers = []
+        @messages = []
+
+        # Read AMF version
+        @amf_version = read_word16_network stream
+
+        # Read in headers
+        header_count = read_word16_network stream
+        0.upto(header_count-1) do
+          name = stream.read(read_word16_network(stream))
+          name.force_encoding("UTF-8") if name.respond_to?(:force_encoding)
+          must_understand = read_int8(stream) != 0
+          length = read_word32_network stream
+          data = RocketAMF.deserialize stream
+          @headers << RocketAMF::Header.new(name, must_understand, data)
+        end
+
+        # Read in messages
+        message_count = read_word16_network stream
+        0.upto(message_count-1) do
+          target_uri = stream.read(read_word16_network(stream))
+          target_uri.force_encoding("UTF-8") if target_uri.respond_to?(:force_encoding)
+          response_uri = stream.read(read_word16_network(stream))
+          response_uri.force_encoding("UTF-8") if response_uri.respond_to?(:force_encoding)
+          length = read_word32_network stream
+          data = RocketAMF.deserialize stream
+          if data.is_a?(Array) && data.length == 1 && data[0].is_a?(::RocketAMF::Values::AbstractMessage)
+            data = data[0]
+          end
+          @messages << RocketAMF::Message.new(target_uri, response_uri, data)
+        end
+
+        self
+      end
+
+      # Included into RocketAMF::Envelope, this method handles serializing an
+      # AMF request/response into the envelope
+      def serialize
+        stream = ""
+
+        # Write version
+        stream << pack_int16_network(@amf_version)
+
+        # Write headers
+        stream << pack_int16_network(@headers.length) # Header count
+        @headers.each do |h|
+          name_str = h.name
+          name_str.encode!("UTF-8").force_encoding("ASCII-8BIT") if name_str.respond_to?(:encode)
+          stream << pack_int16_network(name_str.bytesize)
+          stream << name_str
+          stream << pack_int8(h.must_understand ? 1 : 0)
+          stream << pack_word32_network(-1)
+          stream << RocketAMF.serialize(h.data, 0)
+        end
+
+        # Write messages
+        stream << pack_int16_network(@messages.length) # Message count
+        @messages.each do |m|
+          uri_str = m.target_uri
+          uri_str.encode!("UTF-8").force_encoding("ASCII-8BIT") if uri_str.respond_to?(:encode)
+          stream << pack_int16_network(uri_str.bytesize)
+          stream << uri_str
+
+          uri_str = m.response_uri
+          uri_str.encode!("UTF-8").force_encoding("ASCII-8BIT") if uri_str.respond_to?(:encode)
+          stream << pack_int16_network(uri_str.bytesize)
+          stream << uri_str
+
+          stream << pack_word32_network(-1)
+          stream << AMF0_AMF3_MARKER if @amf_version == 3
+          stream << RocketAMF.serialize(m.data, @amf_version)
+        end
+
+        stream
+      end
+
+      def deserialize(stream)
+        return nil unless stream
+        stream = StringIO.new(stream) unless StringIO === stream
+
+        amf_hash = {}
+        amf_hash[:amf_version] = read_int16_network(stream)
+
+        headers = []
+        header_count = read_int16_network(stream)
+        header_count.to_i.times do
+          header = {}
+          header_name_length = read_int16_network(stream)
+          header[:name] = stream.read(header_name_length)
+          header[:must_understand] = read_int8(stream)
+          buffer = read_word32_network(stream)
+          header[:content] = RocketAMF.deserialize(stream, @amf_version)
+          headers << header
+        end
+        amf_hash[:headers] = headers
+
+        bodies = []
+        body_count = read_int16_network(stream)
+        body_count.to_i.times do
+          body = {}
+          target_uri_length = read_int16_network(stream)
+          body[:target_uri] = stream.read(target_uri_length)
+          response_uri_length = read_int16_network(stream)
+          body[:response_uri] = stream.read(response_uri_length)
+          buffer = read_word32_network(stream)
+          amf_version_3 = read_int16_network(stream) if @amf_version == 3
+          body[:content] = RocketAMF.deserialize(stream, @amf_version)
+          bodies << body
+        end
+        amf_hash[:bodies] = bodies
+
+        amf_hash
+      end
+
+      private
+      include RocketAMF::Pure::ReadIOHelpers
+      include RocketAMF::Pure::WriteIOHelpers
+    end
+  end
+end

data/lib/rocketamf/pure/serializer.rb

@@ -0,0 +1,433 @@
+require 'rocketamf/pure/io_helpers'
+
+module RocketAMF
+  module Pure
+    # AMF0 implementation of serializer
+    class Serializer
+      attr_reader :ref_cache, :stream
+
+      def initialize
+        @ref_cache = SerializerCache.new :object
+        @stream = ""
+      end
+
+      def version
+        0
+      end
+
+      def serialize obj
+        if @ref_cache[obj] != nil
+          write_reference @ref_cache[obj]
+        elsif obj.respond_to?(:encode_amf)
+          obj.encode_amf(self)
+        elsif obj.is_a?(NilClass)
+          write_null
+        elsif obj.is_a?(TrueClass) || obj.is_a?(FalseClass)
+          write_boolean obj
+        elsif obj.is_a?(Float) || obj.is_a?(Integer)
+          write_number obj
+        elsif obj.is_a?(Symbol) || obj.is_a?(String)
+          write_string obj.to_s
+        elsif obj.is_a?(Time)
+          write_date obj
+        elsif obj.is_a?(Array)
+          write_array obj
+        elsif obj.is_a?(Hash)
+          write_hash obj
+        elsif obj.is_a?(Object)
+          write_object obj
+        end
+        @stream
+      end
+
+      def write_null
+        @stream << AMF0_NULL_MARKER
+      end
+
+      def write_boolean bool
+        @stream << AMF0_BOOLEAN_MARKER
+        @stream << pack_int8(bool ? 1 : 0)
+      end
+
+      def write_number num
+        @stream << AMF0_NUMBER_MARKER
+        @stream << pack_double(num)
+      end
+
+      def write_string str
+        str = str.encode("UTF-8").force_encoding("ASCII-8BIT") if str.respond_to?(:encode)
+        len = str.bytesize
+        if len > 2**16-1
+          @stream << AMF0_LONG_STRING_MARKER
+          @stream << pack_word32_network(len)
+        else
+          @stream << AMF0_STRING_MARKER
+          @stream << pack_int16_network(len)
+        end
+        @stream << str
+      end
+
+      def write_date date
+        @stream << AMF0_DATE_MARKER
+
+        date = date.getutc # Dup and convert to UTC
+        milli = (date.to_f * 1000).to_i
+        @stream << pack_double(milli)
+
+        @stream << pack_int16_network(0) # Time zone
+      end
+
+      def write_reference index
+        @stream << AMF0_REFERENCE_MARKER
+        @stream << pack_int16_network(index)
+      end
+
+      def write_array array
+        @ref_cache.add_obj array
+        @stream << AMF0_STRICT_ARRAY_MARKER
+        @stream << pack_word32_network(array.length)
+        array.each do |elem|
+          serialize elem
+        end
+      end
+
+      def write_hash hash
+        @ref_cache.add_obj hash
+        @stream << AMF0_HASH_MARKER
+        @stream << pack_word32_network(hash.length)
+        write_prop_list RocketAMF::ClassMapper.props_for_serialization(hash)
+      end
+
+      def write_object obj
+        @ref_cache.add_obj obj
+        props = RocketAMF::ClassMapper.props_for_serialization obj
+        write_custom_object obj, props, false
+      end
+
+      # Used to write out custom objects when writing a custom <tt>encode_amf</tt>
+      # method. The class name is taken from the given obj, and the props array
+      # is serialized as the contents of the object.
+      def write_custom_object obj, props, do_cache=true
+        @ref_cache.add_obj obj if do_cache
+
+        # Is it a typed object?
+        class_name = RocketAMF::ClassMapper.get_as_class_name obj
+        if class_name
+          class_name = class_name.encode("UTF-8").force_encoding("ASCII-8BIT") if class_name.respond_to?(:encode)
+          @stream << AMF0_TYPED_OBJECT_MARKER
+          @stream << pack_int16_network(class_name.bytesize)
+          @stream << class_name
+        else
+          @stream << AMF0_OBJECT_MARKER
+        end
+
+        write_prop_list props
+      end
+
+      private
+      include RocketAMF::Pure::WriteIOHelpers
+      def write_prop_list obj
+        # Write prop list
+        props = RocketAMF::ClassMapper.props_for_serialization obj
+        props.sort.each do |key, value| # Sort keys before writing
+          key = key.encode("UTF-8").force_encoding("ASCII-8BIT") if key.respond_to?(:encode)
+          @stream << pack_int16_network(key.bytesize)
+          @stream << key
+          serialize value
+        end
+
+        # Write end
+        @stream << pack_int16_network(0)
+        @stream << AMF0_OBJECT_END_MARKER
+      end
+    end
+
+    # AMF3 implementation of serializer
+    class AMF3Serializer
+      attr_reader :string_cache, :object_cache, :trait_cache, :stream
+
+      def initialize
+        @string_cache = SerializerCache.new :string
+        @object_cache = SerializerCache.new :object
+        @trait_cache = SerializerCache.new :trait
+        @stream = ""
+      end
+
+      def version
+        3
+      end
+
+      def serialize obj
+        if obj.respond_to?(:encode_amf)
+          obj.encode_amf(self)
+        elsif obj.is_a?(NilClass)
+          write_null
+        elsif obj.is_a?(TrueClass)
+          write_true
+        elsif obj.is_a?(FalseClass)
+          write_false
+        elsif obj.is_a?(Float)
+          write_float obj
+        elsif obj.is_a?(Integer)
+          write_integer obj
+        elsif obj.is_a?(Symbol) || obj.is_a?(String)
+          write_string obj.to_s
+        elsif obj.is_a?(Time)
+          write_date obj
+        elsif obj.is_a?(StringIO)
+          write_byte_array obj
+        elsif obj.is_a?(RocketAMF::Values::ArrayCollection)
+          write_array_collection obj
+        elsif obj.is_a?(Array)
+          write_array obj
+        elsif obj.is_a?(Hash) || obj.is_a?(Object)
+          write_object obj
+        end
+        @stream
+      end
+
+      def write_reference index
+        header = index << 1 # shift value left to leave a low bit of 0
+        @stream << pack_integer(header)
+      end
+
+      def write_null
+        @stream << AMF3_NULL_MARKER
+      end
+
+      def write_true
+        @stream << AMF3_TRUE_MARKER
+      end
+
+      def write_false
+        @stream << AMF3_FALSE_MARKER
+      end
+
+      def write_integer int
+        if int < MIN_INTEGER || int > MAX_INTEGER # Check valid range for 29 bits
+          write_float int.to_f
+        else
+          @stream << AMF3_INTEGER_MARKER
+          @stream << pack_integer(int)
+        end
+      end
+
+      def write_float float
+        @stream << AMF3_DOUBLE_MARKER
+        @stream << pack_double(float)
+      end
+
+      def write_string str
+        @stream << AMF3_STRING_MARKER
+        write_utf8_vr str
+      end
+
+      def write_date date
+        @stream << AMF3_DATE_MARKER
+        if @object_cache[date] != nil
+          write_reference @object_cache[date]
+        else
+          # Cache date
+          @object_cache.add_obj date
+
+          # Build AMF string
+          date = date.getutc # Dup and convert to UTC
+          milli = (date.to_f * 1000).to_i
+          @stream << AMF3_NULL_MARKER
+          @stream << pack_double(milli)
+        end
+      end
+
+      def write_byte_array array
+        @stream << AMF3_BYTE_ARRAY_MARKER
+        if @object_cache[array] != nil
+          write_reference @object_cache[array]
+        else
+          @object_cache.add_obj array
+          write_utf8_vr array.string
+        end
+      end
+
+      def write_array_collection array
+        write_custom_object array, nil, {:class_name => RocketAMF::ClassMapper.get_as_class_name(array), :members => [], :externalizable => true, :dynamic => false}
+      end
+
+      def write_array array
+        @stream << AMF3_ARRAY_MARKER
+        if @object_cache[array] != nil
+          write_reference @object_cache[array]
+        else
+          # Cache array
+          @object_cache.add_obj array
+
+          # Build AMF string
+          header = array.length << 1 # make room for a low bit of 1
+          header = header | 1 # set the low bit to 1
+          @stream << pack_integer(header)
+          @stream << AMF3_CLOSE_DYNAMIC_ARRAY
+          array.each do |elem|
+            serialize elem
+          end
+        end
+      end
+
+      def write_object obj, traits=nil
+        @stream << AMF3_OBJECT_MARKER
+        if @object_cache[obj] != nil
+          write_reference @object_cache[obj]
+        else
+          # Cache object
+          @object_cache.add_obj obj
+
+          # Calculate traits if not given
+          if traits.nil?
+            traits = {
+                      :class_name => RocketAMF::ClassMapper.get_as_class_name(obj),
+                      :members => [],
+                      :externalizable => false,
+                      :dynamic => true
+                     }
+          end
+
+          # Write object
+          props = RocketAMF::ClassMapper.props_for_serialization obj
+          write_custom_object obj, props, traits, false
+        end
+      end
+
+      # Used to write out custom objects when writing a custom <tt>encode_amf</tt>
+      # method. The class name is taken from the given obj, and the props array
+      # is serialized as the contents of the object.
+      def write_custom_object obj, props, traits, do_cache=true
+        if do_cache
+          @stream << AMF3_OBJECT_MARKER
+          if @object_cache[obj] != nil
+            write_reference @object_cache[obj]
+            return
+          else
+            # Cache object
+            @object_cache.add_obj obj
+          end
+        end
+
+        # Write out traits
+        if traits[:class_name] && @trait_cache[traits] != nil
+          @stream << pack_integer(@trait_cache[traits] << 2 | 0x01)
+        else
+          @trait_cache.add_obj traits if traits[:class_name]
+
+          # Write out trait header
+          header = 0x03 # Not object ref and not trait ref
+          header |= 0x02 << 2 if traits[:dynamic]
+          header |= 0x01 << 2 if traits[:externalizable]
+          header |= traits[:members].length << 4
+          @stream << pack_integer(header)
+
+          # Write out class name
+          write_utf8_vr(traits[:class_name].to_s)
+
+          # Write out members
+          traits[:members].each {|m| write_utf8_vr(m)}
+        end
+
+        # If externalizable, take externalized data shortcut
+        if traits[:externalizable]
+          serialize obj.externalized_data
+          return
+        end
+
+        # Write out sealed properties
+        traits[:members].each do |m|
+          serialize props[m]
+          props.delete(m)
+        end
+
+        if traits[:dynamic]
+          # Write out dynamic properties
+          props.sort.each do |key, val| # Sort props until Ruby 1.9 becomes common
+            write_utf8_vr key.to_s
+            serialize val
+          end
+
+          # Write close
+          @stream << AMF3_CLOSE_DYNAMIC_OBJECT
+        end
+      end
+
+      private
+      include RocketAMF::Pure::WriteIOHelpers
+
+      def write_utf8_vr str
+        str = str.encode("UTF-8").force_encoding("ASCII-8BIT") if str.respond_to?(:encode)
+
+        if str == ''
+          @stream << AMF3_EMPTY_STRING
+        elsif @string_cache[str] != nil
+          write_reference @string_cache[str]
+        else
+          # Cache string
+          @string_cache.add_obj str
+
+          # Build AMF string
+          header = str.bytesize << 1 # make room for a low bit of 1
+          header = header | 1 # set the low bit to 1
+          @stream << pack_integer(header)
+          @stream << str
+        end
+      end
+    end
+
+    class SerializerCache #:nodoc:
+      def self.new type
+        if type == :string
+          StringCache.new
+        elsif type == :object
+          ObjectCache.new
+        elsif type == :trait
+          TraitCache.new
+        end
+      end
+
+      class StringCache < Hash #:nodoc:
+        def initialize
+          @cache_index = 0
+        end
+
+        def add_obj str
+          self[str] = @cache_index
+          @cache_index += 1
+        end
+      end
+
+      class ObjectCache < Hash #:nodoc:
+        def initialize
+          @cache_index = 0
+        end
+
+        def [] obj
+          super(obj.object_id)
+        end
+
+        def add_obj obj
+          self[obj.object_id] = @cache_index
+          @cache_index += 1
+        end
+      end
+
+      class TraitCache < Hash #:nodoc:
+        def initialize
+          @cache_index = 0
+        end
+
+        def [] obj
+          super(obj[:class_name])
+        end
+
+        def add_obj obj
+          self[obj[:class_name]] = @cache_index
+          @cache_index += 1
+        end
+      end
+    end
+  end
+end