RocketAMF 0.0.5

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,89 @@
+require 'rocketamf/pure/io_helpers'
+
+module RocketAMF
+  module Pure
+    # Request deserialization module - provides a method that can be included into
+    # RocketAMF::Request for deserializing the given stream.
+    module Request
+      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))
+          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))
+          response_uri = stream.read(read_word16_network(stream))
+          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
+
+      private
+      include RocketAMF::Pure::ReadIOHelpers
+    end
+
+    # Response serialization module - provides a method that can be included into
+    # RocketAMF::Response for deserializing the given stream.
+    module Response
+      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|
+          stream << pack_int16_network(h.name.length)
+          stream << h.name
+          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|
+          stream << pack_int16_network(m.target_uri.length)
+          stream << m.target_uri
+
+          stream << pack_int16_network(m.response_uri.length)
+          stream << m.response_uri
+
+          stream << pack_word32_network(-1)
+          stream << AMF0_AMF3_MARKER if @amf_version == 3
+          stream << RocketAMF.serialize(m.data, @amf_version)
+        end
+
+        stream
+      end
+
+      private
+      include RocketAMF::Pure::WriteIOHelpers
+    end
+  end
+end

data/lib/rocketamf/pure/serializer.rb

@@ -0,0 +1,327 @@
+require 'rocketamf/pure/io_helpers'
+
+module RocketAMF
+  module Pure
+    # AMF0 implementation of serializer
+    class Serializer
+      def initialize
+        @ref_cache = SerializerCache.new :object
+      end
+
+      def version
+        0
+      end
+
+      def serialize obj, stream = ""
+        if obj.respond_to?(:to_amf)
+          stream << obj.to_amf(self)
+        elsif @ref_cache[obj] != nil
+          write_reference @ref_cache[obj], stream
+        elsif obj.is_a?(NilClass)
+          write_null stream
+        elsif obj.is_a?(TrueClass) || obj.is_a?(FalseClass)
+          write_boolean obj, stream
+        elsif obj.is_a?(Float) || obj.is_a?(Integer)
+          write_number obj, stream
+        elsif obj.is_a?(Symbol) || obj.is_a?(String)
+          write_string obj.to_s, stream
+        elsif obj.is_a?(Time)
+          write_date obj, stream
+        elsif obj.is_a?(Array)
+          write_array obj, stream
+        elsif obj.is_a?(Hash)
+          write_hash obj, stream
+        elsif obj.is_a?(Object)
+          write_object obj, stream
+        end
+        stream
+      end
+
+      def write_null stream
+        stream << AMF0_NULL_MARKER
+      end
+
+      def write_boolean bool, stream
+        stream << AMF0_BOOLEAN_MARKER
+        stream << pack_int8(bool ? 1 : 0)
+      end
+
+      def write_number num, stream
+        stream << AMF0_NUMBER_MARKER
+        stream << pack_double(num)
+      end
+
+      def write_string str, stream
+        len = str.length
+        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
+        stream << AMF0_DATE_MARKER
+
+        date.utc unless date.utc?
+        seconds = (date.to_f * 1000).to_i
+        stream << pack_double(seconds)
+
+        stream << pack_int16_network(0)
+      end
+
+      def write_reference index, stream
+        stream << AMF0_REFERENCE_MARKER
+        stream << pack_int16_network(index)
+      end
+
+      def write_array array, stream
+        @ref_cache.add_obj array
+        stream << AMF0_STRICT_ARRAY_MARKER
+        stream << pack_word32_network(array.length)
+        array.each do |elem|
+          serialize elem, stream
+        end
+      end
+
+      def write_hash hash, stream
+        @ref_cache.add_obj hash
+        stream << AMF0_HASH_MARKER
+        stream << pack_word32_network(hash.length)
+        write_prop_list hash, stream
+      end
+
+      def write_object obj, stream
+        @ref_cache.add_obj obj
+
+        # Is it a typed object?
+        class_name = ClassMapper.get_as_class_name obj
+        if class_name
+          stream << AMF0_TYPED_OBJECT_MARKER
+          stream << pack_int16_network(class_name.length)
+          stream << class_name
+        else
+          stream << AMF0_OBJECT_MARKER
+        end
+
+        write_prop_list obj, stream
+      end
+
+      private
+      include RocketAMF::Pure::WriteIOHelpers
+      def write_prop_list obj, stream
+        # Write prop list
+        props = ClassMapper.props_for_serialization obj
+        props.sort.each do |key, value| # Sort keys before writing
+          stream << pack_int16_network(key.length)
+          stream << key
+          serialize value, stream
+        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
+
+      def initialize
+        @string_cache = SerializerCache.new :string
+        @object_cache = SerializerCache.new :object
+      end
+
+      def version
+        3
+      end
+
+      def serialize obj, stream = ""
+        if obj.respond_to?(:to_amf)
+          stream << obj.to_amf(self)
+        elsif obj.is_a?(NilClass)
+          write_null stream
+        elsif obj.is_a?(TrueClass)
+          write_true stream
+        elsif obj.is_a?(FalseClass)
+          write_false stream
+        elsif obj.is_a?(Float)
+          write_float obj, stream
+        elsif obj.is_a?(Integer)
+          write_integer obj, stream
+        elsif obj.is_a?(Symbol) || obj.is_a?(String)
+          write_string obj.to_s, stream
+        elsif obj.is_a?(Time)
+          write_date obj, stream
+        elsif obj.is_a?(Array)
+          write_array obj, stream
+        elsif obj.is_a?(Hash) || obj.is_a?(Object)
+          write_object obj, stream
+        end
+        stream
+      end
+
+      def write_reference index, stream
+        header = index << 1 # shift value left to leave a low bit of 0
+        stream << pack_integer(header)
+      end
+
+      def write_null stream
+        stream << AMF3_NULL_MARKER
+      end
+
+      def write_true stream
+        stream << AMF3_TRUE_MARKER
+      end
+
+      def write_false stream
+        stream << AMF3_FALSE_MARKER
+      end
+
+      def write_integer int, stream
+        if int < MIN_INTEGER || int > MAX_INTEGER # Check valid range for 29 bits
+          write_float int.to_f, stream
+        else
+          stream << AMF3_INTEGER_MARKER
+          stream << pack_integer(int)
+        end
+      end
+
+      def write_float float, stream
+        stream << AMF3_DOUBLE_MARKER
+        stream << pack_double(float)
+      end
+
+      def write_string str, stream
+        stream << AMF3_STRING_MARKER
+        write_utf8_vr str, stream
+      end
+
+      def write_date date, stream
+        stream << AMF3_DATE_MARKER
+        if @object_cache[date] != nil
+          write_reference @object_cache[date], stream
+        else
+          # Cache date
+          @object_cache.add_obj date
+
+          # Build AMF string
+          date.utc unless date.utc?
+          seconds = (date.to_f * 1000).to_i
+          stream << pack_integer(AMF3_NULL_MARKER)
+          stream << pack_double(seconds)
+        end
+      end
+
+      def write_array array, stream
+        stream << AMF3_ARRAY_MARKER
+        if @object_cache[array] != nil
+          write_reference @object_cache[array], stream
+        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, stream
+          end
+        end
+      end
+
+      def write_object obj, stream
+        stream << AMF3_OBJECT_MARKER
+        if @object_cache[obj] != nil
+          write_reference @object_cache[obj], stream
+        else
+          # Cache object
+          @object_cache.add_obj obj
+
+          # Always serialize things as dynamic objects
+          stream << AMF3_DYNAMIC_OBJECT
+
+          # Write class name/anonymous
+          class_name = ClassMapper.get_as_class_name obj
+          if class_name
+            write_utf8_vr class_name, stream
+          else
+            stream << AMF3_ANONYMOUS_OBJECT
+          end
+
+          # Write out properties
+          props = ClassMapper.props_for_serialization obj
+          props.sort.each do |key, val| # Sort props until Ruby 1.9 becomes common
+            write_utf8_vr key.to_s, stream
+            serialize val, stream
+          end
+
+          # Write close
+          stream << AMF3_CLOSE_DYNAMIC_OBJECT
+        end
+      end
+
+      private
+      include RocketAMF::Pure::WriteIOHelpers
+
+      def write_utf8_vr str, stream
+        if str == ''
+          stream << AMF3_EMPTY_STRING
+        elsif @string_cache[str] != nil
+          write_reference @string_cache[str], stream
+        else
+          # Cache string
+          @string_cache.add_obj str
+
+          # Build AMF string
+          header = str.length << 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
+        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
+    end
+  end
+end