scotttam-RocketAMF 0.2.2

data/lib/rocketamf/remoting.rb

@@ -0,0 +1,144 @@
+module RocketAMF
+  # Container for the AMF request/response.
+  class Envelope
+    attr_reader :amf_version, :headers, :messages
+
+    def initialize props={}
+      @amf_version = props[:amf_version] || 0
+      @headers = props[:headers] || []
+      @messages = props[:messages] || []
+    end
+
+    # Populates the envelope from the given stream or string. Returns self for easy
+    # chaining.
+    #
+    # Example:
+    #
+    #    req = RocketAMF::Envelope.new.populate_from_stream(env['rack.input'].read)
+    #--
+    # Implemented in pure/remoting.rb RocketAMF::Pure::Envelope
+    def populate_from_stream stream
+      raise AMFError, 'Must load "rocketamf/pure"'
+    end
+
+    # Serializes the envelope to a string and returns it
+    #--
+    # Implemented in pure/remoting.rb RocketAMF::Pure::Envelope
+    def serialize
+      raise AMFError, 'Must load "rocketamf/pure"'
+    end
+
+    # Builds response from the request, iterating over each method call and using
+    # the return value as the method call's return value
+    #--
+    # Iterate over all the sent messages. If they're somthing we can handle, like
+    # a command message, then simply add the response message ourselves. If it's
+    # a method call, then call the block with the method and args, catching errors
+    # for handling. Then create the appropriate response message using the return
+    # value of the block as the return value for the method call.
+    def each_method_call request, &block
+      raise 'Response already constructed' if @constructed
+
+      # Set version from response
+      # Can't just copy version because FMS sends version as 1
+      @amf_version = request.amf_version == 3 ? 3 : 0 
+
+      request.messages.each do |m|
+        # What's the request body?
+        case m.data
+        when Values::CommandMessage
+          # Pings should be responded to with an AcknowledgeMessage built using the ping
+          # Everything else is unsupported
+          command_msg = m.data
+          if command_msg.operation == Values::CommandMessage::CLIENT_PING_OPERATION
+            response_value = Values::AcknowledgeMessage.new(command_msg)
+          else
+            e = Exception.new("CommandMessage #{command_msg.operation} not implemented")
+            e.set_backtrace ["RocketAMF::Envelope each_method_call"]
+            response_value = Values::ErrorMessage.new(command_msg, e)
+          end
+        when Values::RemotingMessage
+          # Using RemoteObject style message calls
+          remoting_msg = m.data
+          acknowledge_msg = Values::AcknowledgeMessage.new(remoting_msg)
+          method_base = remoting_msg.source.to_s.empty? ? '' : remoting_msg.source+'.'
+          body = dispatch_call :method => method_base+remoting_msg.operation, :args => remoting_msg.body, :source => remoting_msg, :block => block
+
+          # Response should be the bare ErrorMessage if there was an error
+          if body.is_a?(Values::ErrorMessage)
+            response_value = body
+          else
+            acknowledge_msg.body = body
+            response_value = acknowledge_msg
+          end
+        else
+          # Standard response message
+          response_value = dispatch_call :method => m.target_uri, :args => m.data, :source => m, :block => block
+        end
+
+        target_uri = m.response_uri
+        target_uri += response_value.is_a?(Values::ErrorMessage) ? '/onStatus' : '/onResult'
+        @messages << ::RocketAMF::Message.new(target_uri, '', response_value)
+      end
+
+      @constructed = true
+    end
+
+    # Whether or not the response has been constructed. Can be used to prevent
+    # serialization when no processing has taken place.
+    def constructed?
+      @constructed
+    end
+
+    # Return the serialized envelope as a string
+    def to_s
+      serialize
+    end
+
+    private
+    def dispatch_call p
+      begin
+        p[:block].call(p[:method], p[:args])
+      rescue Exception => e
+        # Create ErrorMessage object using the source message as the base
+        Values::ErrorMessage.new(p[:source], e)
+      end
+    end
+  end
+
+  class Request < Envelope #:nodoc:
+    def initialize props={}
+      $stderr.puts("DEPRECATION WARNING: Use RocketAMF::Envelope instead of RocketAMF::Request")
+      super(props)
+    end
+  end
+
+  class Response < Envelope #:nodoc:
+    def initialize props={}
+      $stderr.puts("DEPRECATION WARNING: Use RocketAMF::Envelope instead of RocketAMF::Request")
+      super(props)
+    end
+  end
+
+  # RocketAMF::Envelope header
+  class Header
+    attr_accessor :name, :must_understand, :data
+
+    def initialize name, must_understand, data
+      @name = name
+      @must_understand = must_understand
+      @data = data
+    end
+  end
+
+  # RocketAMF::Envelope message
+  class Message
+    attr_accessor :target_uri, :response_uri, :data
+
+    def initialize target_uri, response_uri, data
+      @target_uri = target_uri
+      @response_uri = response_uri
+      @data = data
+    end
+  end
+end

data/lib/rocketamf/values/array_collection.rb

@@ -0,0 +1,13 @@
+module RocketAMF
+  module Values #:nodoc:
+    class ArrayCollection < Array
+      def externalized_data
+        [] + self # Duplicate as an array
+      end
+
+      def externalized_data=(data)
+        push(*data)
+      end
+    end
+  end
+end

data/lib/rocketamf/values/messages.rb

@@ -0,0 +1,133 @@
+module RocketAMF
+  module Values #:nodoc:
+    # Base class for all special AS3 response messages. Maps to
+    # <tt>flex.messaging.messages.AbstractMessage</tt>.
+    class AbstractMessage
+      attr_accessor :clientId
+      attr_accessor :destination
+      attr_accessor :messageId
+      attr_accessor :timestamp
+      attr_accessor :timeToLive
+      attr_accessor :headers
+      attr_accessor :body
+
+      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
+        @clientId = rand_uuid
+        @destination = nil
+        @messageId = rand_uuid
+        @timestamp = Time.new.to_i*100
+        @timeToLive = 0
+        @headers = {}
+        @body = nil
+      end
+    end
+
+    # Maps to <tt>flex.messaging.messages.AsyncMessage</tt>
+    class AsyncMessage < AbstractMessage
+      attr_accessor :correlationId
+    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
+        @clientId = rand_uuid
+        @destination = nil
+        @messageId = rand_uuid
+        @timestamp = Time.new.to_i*100
+        @timeToLive = 0
+        @headers = {}
+        @body = nil
+
+        if message.is_a?(AbstractMessage)
+          @correlationId = message.messageId
+        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 :extendedData
+
+      # The fault code for the error, which defaults to the class name of the
+      # causing exception
+      attr_accessor :faultCode
+
+      # Detailed description of what caused the error
+      attr_accessor :faultDetail
+
+      # A simple description of the error
+      attr_accessor :faultString
+
+      # Optional "root cause" of the error
+      attr_accessor :rootCause
+
+      def initialize message=nil, exception=nil
+        super message
+
+        unless exception.nil?
+          @e = exception
+          @faultCode = @e.class.name
+          @faultDetail = @e.backtrace.join("\n")
+          @faultString = @e.message
+        end
+      end
+
+      def encode_amf serializer
+        if serializer.version == 0
+          data = {
+            :faultCode => @faultCode,
+            :faultDetail => @faultDetail,
+            :faultString => @faultString
+          }
+          serializer.write_hash(data)
+        else
+          serializer.write_object(self)
+        end
+      end
+    end
+  end
+end

data/lib/rocketamf/values/typed_hash.rb

@@ -0,0 +1,13 @@
+module RocketAMF
+  module Values #:nodoc:
+    # Hash-like object that can store a type string. Used to preserve type information
+    # for unmapped objects after deserialization.
+    class TypedHash < Hash
+      attr_reader :type
+
+      def initialize type
+        @type = type
+      end
+    end
+  end
+end

data/spec/amf/class_mapping_spec.rb

@@ -0,0 +1,150 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+class ClassMappingTest
+  attr_accessor :prop_a
+  attr_accessor :prop_b
+  attr_accessor :prop_c
+end
+class ClassMappingTest2 < ClassMappingTest; end;
+
+module ANamespace; class TestRubyClass; end; end
+
+describe RocketAMF::ClassMapping do
+  before :each do
+    @mapper = RocketAMF::ClassMapping.new
+    @mapper.define do |m|
+      m.map :as => 'ASClass', :ruby => 'ClassMappingTest'
+    end
+  end
+
+  describe "class name mapping" do
+    it "should allow resetting of mappings back to defaults" do
+      @mapper.reset
+      @mapper.get_as_class_name('ClassMappingTest').should be_nil
+      @mapper.get_as_class_name('RocketAMF::Values::AcknowledgeMessage').should_not be_nil
+    end
+
+    it "should return AS class name for ruby objects" do
+      @mapper.get_as_class_name(ClassMappingTest.new).should == 'ASClass'
+      @mapper.get_as_class_name('ClassMappingTest').should == 'ASClass'
+      @mapper.get_as_class_name('BadClass').should be_nil
+    end
+
+    it "should instantiate a ruby class" do
+      @mapper.get_ruby_obj('ASClass').should be_a(ClassMappingTest)
+    end
+
+    it "should properly instantiate namespaced classes" do
+      @mapper.define {|m| m.map :as => 'ASClass', :ruby => 'ANamespace::TestRubyClass'}
+      @mapper.get_ruby_obj('ASClass').should be_a(ANamespace::TestRubyClass)
+    end
+
+    it "should return a hash with original type if not mapped" do
+      obj = @mapper.get_ruby_obj('UnmappedClass')
+      obj.should be_a(RocketAMF::Values::TypedHash)
+      obj.type.should == 'UnmappedClass'
+    end
+
+    it "should map special classes from AS by default" do
+      as_classes = [
+        'flex.messaging.messages.AcknowledgeMessage',
+        'flex.messaging.messages.CommandMessage',
+        'flex.messaging.messages.RemotingMessage',
+        'flex.messaging.io.ArrayCollection'
+      ]
+
+      as_classes.each do |as_class|
+        @mapper.get_ruby_obj(as_class).should_not be_a(RocketAMF::Values::TypedHash)
+      end
+    end
+
+    it "should map special classes from ruby by default" do
+      ruby_classes = [
+        'RocketAMF::Values::AcknowledgeMessage',
+        'RocketAMF::Values::ErrorMessage',
+        'RocketAMF::Values::ArrayCollection'
+      ]
+
+      ruby_classes.each do |obj|
+        @mapper.get_as_class_name(obj).should_not be_nil
+      end
+    end
+
+    it "should allow config modification" do
+      @mapper.define do |m|
+        m.map :as => 'SecondClass', :ruby => 'ClassMappingTest'
+      end
+      @mapper.get_as_class_name(ClassMappingTest.new).should == 'SecondClass'
+    end
+  end
+
+  describe "ruby object populator" do
+    it "should populate a ruby class" do
+      obj = @mapper.populate_ruby_obj ClassMappingTest.new, {:prop_a => 'Data'}
+      obj.prop_a.should == 'Data'
+    end
+
+    it "should populate a typed hash" do
+      obj = @mapper.populate_ruby_obj RocketAMF::Values::TypedHash.new('UnmappedClass'), {:prop_a => 'Data'}
+      obj[:prop_a].should == 'Data'
+    end
+
+    it "should allow custom populators" do
+      class CustomPopulator
+        def can_handle? obj
+          true
+        end
+        def populate obj, props, dynamic_props
+          obj[:populated] = true
+          obj.merge! props
+          obj.merge! dynamic_props if dynamic_props
+        end
+      end
+
+      @mapper.object_populators << CustomPopulator.new
+      obj = @mapper.populate_ruby_obj({}, {:prop_a => 'Data'})
+      obj[:populated].should == true
+      obj[:prop_a].should == 'Data'
+    end
+  end
+
+  describe "property extractor" do
+    it "should extract hash properties" do
+      hash = {:a => 'test1', 'b' => 'test2'}
+      props = @mapper.props_for_serialization(hash)
+      props.should == {'a' => 'test1', 'b' => 'test2'}
+    end
+
+    it "should extract object properties" do
+      obj = ClassMappingTest.new
+      obj.prop_a = 'Test A'
+      obj.prop_b = 'Test B'
+
+      hash = @mapper.props_for_serialization obj
+      hash.should == {'prop_a' => 'Test A', 'prop_b' => 'Test B', 'prop_c' => nil}
+    end
+
+    it "should extract inherited object properties" do
+      obj = ClassMappingTest2.new
+      obj.prop_a = 'Test A'
+      obj.prop_b = 'Test B'
+
+      hash = @mapper.props_for_serialization obj
+      hash.should == {'prop_a' => 'Test A', 'prop_b' => 'Test B', 'prop_c' => nil}
+    end
+
+    it "should allow custom serializers" do
+      class CustomSerializer
+        def can_handle? obj
+          true
+        end
+        def serialize obj
+          {:success => true}
+        end
+      end
+
+      @mapper.object_serializers << CustomSerializer.new
+      @mapper.props_for_serialization(nil).should == {:success => true}
+    end
+  end
+end