RocketAMF-ouvrages 1.0.0

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,117 @@
+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, class_mapper=nil
+        stream = StringIO.new(stream) unless StringIO === stream
+        des = Deserializer.new(class_mapper || RocketAMF::ClassMapper.new)
+        des.source = 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 = des.deserialize(0, nil)
+
+          @headers[name] = 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 = des.deserialize(0, nil)
+          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 a string
+      def serialize class_mapper=nil
+        ser = Serializer.new(class_mapper || RocketAMF::ClassMapper.new)
+        stream = ser.stream
+
+        # Write version
+        stream << pack_int16_network(@amf_version)
+
+        # Write headers
+        stream << pack_int16_network(@headers.length) # Header count
+        @headers.each_value do |h|
+          # Write header name
+          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
+
+          # Write must understand flag
+          stream << pack_int8(h.must_understand ? 1 : 0)
+
+          # Serialize data
+          stream << pack_word32_network(-1) # length of data - -1 if you don't know
+          ser.serialize(0, h.data)
+        end
+
+        # Write messages
+        stream << pack_int16_network(@messages.length) # Message count
+        @messages.each do |m|
+          # Write target_uri
+          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
+
+          # Write response_uri
+          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
+
+          # Serialize data
+          stream << pack_word32_network(-1) # length of data - -1 if you don't know
+          if @amf_version == 3
+            stream << AMF0_AMF3_MARKER
+            ser.serialize(3, m.data)
+          else
+            ser.serialize(0, m.data)
+          end
+        end
+
+        stream
+      end
+
+      private
+      include RocketAMF::Pure::ReadIOHelpers
+      include RocketAMF::Pure::WriteIOHelpers
+    end
+  end
+end

data/lib/rocketamf/pure/serializer.rb

@@ -0,0 +1,474 @@
+require 'rocketamf/pure/io_helpers'
+
+module RocketAMF
+  module Pure
+    # Pure ruby serializer for AMF0 and AMF3
+    class Serializer
+      attr_reader :stream, :version
+
+      # Pass in the class mapper instance to use when serializing. This enables
+      # better caching behavior in the class mapper and allows one to change
+      # mappings between serialization attempts.
+      def initialize class_mapper
+        @class_mapper = class_mapper
+        @stream = ""
+        @depth = 0
+      end
+
+      # Serialize the given object using AMF0 or AMF3. Can be called from inside
+      # encode_amf, but make sure to pass in the proper version or it may not be
+      # possible to decode. Use the serializer version attribute for this.
+      def serialize version, obj
+        raise ArgumentError, "unsupported version #{version}" unless [0,3].include?(version)
+        @version = version
+
+        # Initialize caches
+        if @depth == 0
+          if @version == 0
+            @ref_cache = SerializerCache.new :object
+          else
+            @string_cache = SerializerCache.new :string
+            @object_cache = SerializerCache.new :object
+            @trait_cache = SerializerCache.new :string
+          end
+        end
+        @depth += 1
+
+        # Perform serialization
+        if @version == 0
+          amf0_serialize(obj)
+        else
+          amf3_serialize(obj)
+        end
+
+        # Cleanup
+        @depth -= 1
+        if @depth == 0
+          @ref_cache = nil
+          @string_cache = nil
+          @object_cache = nil
+          @trait_cache = nil
+        end
+
+        return @stream
+      end
+
+      # Helper for writing arrays inside encode_amf. It uses the current AMF
+      # version to write the array.
+      def write_array arr
+        if @version == 0
+          amf0_write_array arr
+        else
+          amf3_write_array arr
+        end
+      end
+
+      # Helper for writing objects inside encode_amf. It uses the current AMF
+      # version to write the object. If you pass in a property hash, it will use
+      # it rather than having the class mapper determine properties. For AMF3,
+      # you can also specify a traits hash, which can be used to reduce serialized
+      # data size or serialize things as externalizable.
+      def write_object obj, props=nil, traits=nil
+        if @version == 0
+          amf0_write_object obj, props
+        else
+          amf3_write_object obj, props, traits
+        end
+      end
+
+      private
+      include RocketAMF::Pure::WriteIOHelpers
+
+      def amf0_serialize obj
+        if @ref_cache[obj] != nil
+          amf0_write_reference @ref_cache[obj]
+        elsif obj.respond_to?(:encode_amf)
+          obj.encode_amf(self)
+        elsif obj.is_a?(NilClass)
+          amf0_write_null
+        elsif obj.is_a?(TrueClass) || obj.is_a?(FalseClass)
+          amf0_write_boolean obj
+        elsif obj.is_a?(Numeric)
+          amf0_write_number obj
+        elsif obj.is_a?(Symbol) || obj.is_a?(String)
+          amf0_write_string obj.to_s
+        elsif obj.is_a?(Time)
+          amf0_write_time obj
+        elsif obj.is_a?(Date)
+          amf0_write_date obj
+        elsif obj.is_a?(Array)
+          amf0_write_array obj
+        elsif obj.is_a?(Hash) ||obj.is_a?(Object)
+          amf0_write_object obj
+        end
+      end
+
+      def amf0_write_null
+        @stream << AMF0_NULL_MARKER
+      end
+
+      def amf0_write_boolean bool
+        @stream << AMF0_BOOLEAN_MARKER
+        @stream << pack_int8(bool ? 1 : 0)
+      end
+
+      def amf0_write_number num
+        @stream << AMF0_NUMBER_MARKER
+        @stream << pack_double(num)
+      end
+
+      def amf0_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 amf0_write_time time
+        @stream << AMF0_DATE_MARKER
+
+        time = time.getutc # Dup and convert to UTC
+        milli = (time.to_f * 1000).to_i
+        @stream << pack_double(milli)
+
+        @stream << pack_int16_network(0) # Time zone
+      end
+
+      def amf0_write_date date
+        @stream << AMF0_DATE_MARKER
+        @stream << pack_double(date.strftime("%Q").to_i)
+        @stream << pack_int16_network(0) # Time zone
+      end
+
+      def amf0_write_reference index
+        @stream << AMF0_REFERENCE_MARKER
+        @stream << pack_int16_network(index)
+      end
+
+      def amf0_write_array array
+        @ref_cache.add_obj array
+        @stream << AMF0_STRICT_ARRAY_MARKER
+        @stream << pack_word32_network(array.length)
+        array.each do |elem|
+          amf0_serialize elem
+        end
+      end
+
+      def amf0_write_object obj, props=nil
+        @ref_cache.add_obj obj
+
+        props = @class_mapper.props_for_serialization obj if props.nil?
+
+        # Is it a typed object?
+        class_name = @class_mapper.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.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
+          amf0_serialize value
+        end
+
+        # Write end
+        @stream << pack_int16_network(0)
+        @stream << AMF0_OBJECT_END_MARKER
+      end
+
+      def amf3_serialize obj
+        if obj.respond_to?(:encode_amf)
+          obj.encode_amf(self)
+        elsif obj.is_a?(NilClass)
+          amf3_write_null
+        elsif obj.is_a?(TrueClass)
+          amf3_write_true
+        elsif obj.is_a?(FalseClass)
+          amf3_write_false
+        elsif obj.is_a?(Numeric)
+          amf3_write_numeric obj
+        elsif obj.is_a?(Symbol) || obj.is_a?(String)
+          amf3_write_string obj.to_s
+        elsif obj.is_a?(Time)
+          amf3_write_time obj
+        elsif obj.is_a?(Date)
+          amf3_write_date obj
+        elsif obj.is_a?(StringIO)
+          amf3_write_byte_array obj
+        elsif obj.is_a?(Array)
+          amf3_write_array obj
+        elsif obj.is_a?(Hash) || obj.is_a?(Object)
+          amf3_write_object obj
+        end
+      end
+
+      def amf3_write_reference index
+        header = index << 1 # shift value left to leave a low bit of 0
+        @stream << pack_integer(header)
+      end
+
+      def amf3_write_null
+        @stream << AMF3_NULL_MARKER
+      end
+
+      def amf3_write_true
+        @stream << AMF3_TRUE_MARKER
+      end
+
+      def amf3_write_false
+        @stream << AMF3_FALSE_MARKER
+      end
+
+      def amf3_write_numeric num
+        if !num.integer? || num < MIN_INTEGER || num > MAX_INTEGER # Check valid range for 29 bits
+          @stream << AMF3_DOUBLE_MARKER
+          @stream << pack_double(num)
+        else
+          @stream << AMF3_INTEGER_MARKER
+          @stream << pack_integer(num)
+        end
+      end
+
+      def amf3_write_string str
+        @stream << AMF3_STRING_MARKER
+        amf3_write_utf8_vr str
+      end
+
+      def amf3_write_time time
+        @stream << AMF3_DATE_MARKER
+        if @object_cache[time] != nil
+          amf3_write_reference @object_cache[time]
+        else
+          # Cache time
+          @object_cache.add_obj time
+
+          # Build AMF string
+          time = time.getutc # Dup and convert to UTC
+          milli = (time.to_f * 1000).to_i
+          @stream << AMF3_NULL_MARKER
+          @stream << pack_double(milli)
+        end
+      end
+
+      def amf3_write_date date
+        @stream << AMF3_DATE_MARKER
+        if @object_cache[date] != nil
+          amf3_write_reference @object_cache[date]
+        else
+          # Cache date
+          @object_cache.add_obj date
+
+          # Build AMF string
+          @stream << AMF3_NULL_MARKER
+          @stream << pack_double(date.strftime("%Q").to_i)
+        end
+      end
+
+      def amf3_write_byte_array array
+        @stream << AMF3_BYTE_ARRAY_MARKER
+        if @object_cache[array] != nil
+          amf3_write_reference @object_cache[array]
+        else
+          @object_cache.add_obj array
+          str = array.string
+          @stream << pack_integer(str.bytesize << 1 | 1)
+          @stream << str
+        end
+      end
+
+      def amf3_write_array array
+        # Is it an array collection?
+        is_ac = false
+        if array.respond_to?(:is_array_collection?)
+          is_ac = array.is_array_collection?
+        else
+          is_ac = @class_mapper.use_array_collection
+        end
+
+        # Write type marker
+        @stream << (is_ac ? AMF3_OBJECT_MARKER : AMF3_ARRAY_MARKER)
+
+        # Write reference or cache array
+        if @object_cache[array] != nil
+          amf3_write_reference @object_cache[array]
+          return
+        else
+          @object_cache.add_obj array
+          @object_cache.add_obj nil if is_ac # The array collection source array
+        end
+
+        # Write out traits and array marker if it's an array collection
+        if is_ac
+          class_name = "flex.messaging.io.ArrayCollection"
+          if @trait_cache[class_name] != nil
+            @stream << pack_integer(@trait_cache[class_name] << 2 | 0x01)
+          else
+            @trait_cache.add_obj class_name
+            @stream << "\a" # Externalizable, non-dynamic
+            amf3_write_utf8_vr(class_name)
+          end
+          @stream << AMF3_ARRAY_MARKER
+        end
+
+        # Build AMF string for array
+        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|
+          amf3_serialize elem
+        end
+      end
+
+      def amf3_write_object obj, props=nil, traits=nil
+        @stream << AMF3_OBJECT_MARKER
+
+        # Caching...
+        if @object_cache[obj] != nil
+          amf3_write_reference @object_cache[obj]
+          return
+        end
+        @object_cache.add_obj obj
+
+        # Calculate traits if not given
+        is_default = false
+        if traits.nil?
+          traits = {
+                    :class_name => @class_mapper.get_as_class_name(obj),
+                    :members => [],
+                    :externalizable => false,
+                    :dynamic => true
+                   }
+          is_default = true unless traits[:class_name]
+        end
+        class_name = is_default ? "__default__" : traits[:class_name]
+
+        # Write out traits
+        if (class_name && @trait_cache[class_name] != nil)
+          @stream << pack_integer(@trait_cache[class_name] << 2 | 0x01)
+        else
+          @trait_cache.add_obj class_name if 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
+          if class_name == "__default__"
+            amf3_write_utf8_vr("")
+          else
+            amf3_write_utf8_vr(class_name.to_s)
+          end
+
+          # Write out members
+          traits[:members].each {|m| amf3_write_utf8_vr(m)}
+        end
+
+        # If externalizable, take externalized data shortcut
+        if traits[:externalizable]
+          obj.write_external(self)
+          return
+        end
+
+        # Extract properties if not given
+        props = @class_mapper.props_for_serialization(obj) if props.nil?
+
+        # Write out sealed properties
+        traits[:members].each do |m|
+          amf3_serialize props[m]
+          props.delete(m)
+        end
+
+        # Write out dynamic properties
+        if traits[:dynamic]
+          # Write out dynamic properties
+          props.sort.each do |key, val| # Sort props until Ruby 1.9 becomes common
+            amf3_write_utf8_vr key.to_s
+            amf3_serialize val
+          end
+
+          # Write close
+          @stream << AMF3_CLOSE_DYNAMIC_OBJECT
+        end
+      end
+
+      def amf3_write_utf8_vr str, encode=true
+        if str.respond_to?(:encode)
+          if encode
+            str = str.encode("UTF-8")
+          else
+            str = str.dup if str.frozen?
+          end
+          str.force_encoding("ASCII-8BIT")
+        end
+
+        if str == ''
+          @stream << AMF3_EMPTY_STRING
+        elsif @string_cache[str] != nil
+          amf3_write_reference @string_cache[str]
+        else
+          # Cache string
+          @string_cache.add_obj str
+
+          # Build AMF string
+          @stream << pack_integer(str.bytesize << 1 | 1)
+          @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
+          @obj_references = []
+        end
+
+        def [] obj
+          super(obj.object_id)
+        end
+
+        def add_obj obj
+          @obj_references << obj
+          self[obj.object_id] = @cache_index
+          @cache_index += 1
+        end
+      end
+    end
+  end
+end