scalm-RocketAMF 1.0.0

data/lib/rocketamf/remoting.rb

@@ -0,0 +1,196 @@
+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 using the given
+    # class mapper, or creates a new one. 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, class_mapper=nil
+      raise AMFError, 'Must load "rocketamf/pure"'
+    end
+
+    # Creates the appropriate message and adds it to <tt>messages</tt> to call
+    # the given target using the standard (old) remoting APIs. You can call multiple
+    # targets in the same request, unlike with the flex remotings APIs.
+    #
+    # Example:
+    #
+    #    req = RocketAMF::Envelope.new
+    #    req.call 'test', "arg_1", ["args", "args"]
+    #    req.call 'Controller.action'
+    def call target, *args
+      raise "Cannot use different call types" unless @call_type.nil? || @call_type == :simple
+      @call_type = :simple
+
+      msg_num = messages.length+1
+      @messages << RocketAMF::Message.new(target, "/#{msg_num}", args)
+    end
+
+    # Creates the appropriate message and adds it to <tt>messages</tt> using the
+    # new flex (RemoteObject) remoting APIs. You can only make one flex remoting
+    # call per envelope, and the AMF version must be set to 3.
+    #
+    # Example:
+    #
+    #    req = RocketAMF::Envelope.new :amf_version => 3
+    #    req.call_flex 'Controller.action', "arg_1", ["args", "args"]
+    def call_flex target, *args
+      raise "Can only call one flex target per request" if @call_type == :flex
+      raise "Cannot use different call types" if @call_type == :simple
+      raise "Cannot use flex remoting calls with AMF0" if @amf_version != 3
+      @call_type = :flex
+
+      flex_msg = RocketAMF::Values::RemotingMessage.new
+      target_parts = target.split(".")
+      flex_msg.operation = target_parts.pop # Use pop so that a missing source is possible without issues
+      flex_msg.source = target_parts.pop
+      flex_msg.body = args
+      @messages << RocketAMF::Message.new('null', '/2', flex_msg) # /2 because it always sends a command message before
+    end
+
+    # Serializes the envelope to a string using the given class mapper, or creates
+    # a new one, and returns the result
+    #--
+    # Implemented in pure/remoting.rb RocketAMF::Pure::Envelope
+    def serialize class_mapper=nil
+      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. Marks as envelope as
+    # constructed after running.
+    #--
+    # 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
+
+    # Returns the result of a response envelope, or an array of results if there
+    # are multiple action call messages. It automatically unwraps flex-style
+    # RemoteObject response messages, where the response result is inside a
+    # RocketAMF::Values::AcknowledgeMessage.
+    #
+    # Example:
+    #
+    #    req = RocketAMF::Envelope.new
+    #    req.call('TestController.test', 'first_arg', 'second_arg')
+    #    res = RocketAMF::Envelope.new
+    #    res.each_method_call req do |method, args|
+    #      ['a', 'b']
+    #    end
+    #    res.result     #=> ['a', 'b']
+    def result
+      results = []
+      messages.each do |msg|
+        if msg.data.is_a?(Values::AcknowledgeMessage)
+          results << msg.data.body
+        else
+          results << msg.data
+        end
+      end
+      results.length > 1 ? results : results[0]
+    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
+
+    def dispatch_call p #:nodoc:
+      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
+
+  # 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/messages.rb

@@ -0,0 +1,214 @@
+module RocketAMF
+  module Values #:nodoc:
+    # Base class for all special AS3 response messages. Maps to
+    # <tt>flex.messaging.messages.AbstractMessage</tt>.
+    class AbstractMessage
+      EXTERNALIZABLE_FIELDS = [
+        %w[ body clientId destination headers messageId timestamp timeToLive ],
+        %w[ clientIdBytes messageIdBytes ]
+      ]
+      attr_accessor :clientId
+      attr_accessor :destination
+      attr_accessor :messageId
+      attr_accessor :timestamp
+      attr_accessor :timeToLive
+      attr_accessor :headers
+      attr_accessor :body
+
+      def clientIdBytes= bytes
+        @clientId = pretty_uuid(bytes) unless bytes.nil?
+      end
+
+      def messageIdBytes= bytes
+        @messageId = pretty_uuid(bytes) unless bytes.nil?
+      end
+
+      def read_external des
+        read_external_fields des, EXTERNALIZABLE_FIELDS
+      end
+
+      private
+      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
+
+      def pretty_uuid bytes
+        "%08x-%04x-%04x-%04x-%08x%04x" % bytes.string.unpack("NnnnNn")
+      end
+
+      def read_external_fields des, fields
+        # Read flags
+        flags = []
+        loop do
+          flags << des.source.read(1).unpack('C').first
+          break if flags.last < 128
+        end
+
+        # Read fields and any remaining unmapped fields in a byte-set
+        fields.each_with_index do |list, i|
+          break if flags[i].nil?
+
+          list.each_with_index do |name, j|
+            if flags[i] & 2**j != 0
+              send("#{name}=", des.read_object)
+            end
+          end
+
+          # Read remaining flags even though we don't recognize them
+          # Zero out high bit, as it's the has-next-field marker
+          f = (flags[i] & ~128) >> list.length
+          while f > 0
+            des.read_object if (f & 1) != 0
+            f >>= 1
+          end
+        end
+      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
+
+      def initialize
+        @clientId = nil
+        @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
+      EXTERNALIZABLE_FIELDS = [
+        %w[ correlationId correlationIdBytes]
+      ]
+      attr_accessor :correlationId
+
+      def correlationIdBytes= bytes
+        @correlationId = pretty_uuid(bytes) unless bytes.nil?
+      end
+
+      def read_external des
+        super des
+        read_external_fields des, EXTERNALIZABLE_FIELDS
+      end
+    end
+
+    class AsyncMessageExt < AsyncMessage #:nodoc:
+    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
+
+      EXTERNALIZABLE_FIELDS = [
+        %w[ operation ]
+      ]
+      attr_accessor :operation
+
+      def initialize
+        @operation = UNKNOWN_OPERATION
+      end
+
+      def read_external des
+        super des
+        read_external_fields des, EXTERNALIZABLE_FIELDS
+      end
+    end
+
+    class CommandMessageExt < CommandMessage #:nodoc:
+    end
+
+    # Maps to <tt>flex.messaging.messages.AcknowledgeMessage</tt>
+    class AcknowledgeMessage < AsyncMessage
+      EXTERNALIZABLE_FIELDS = [[]]
+
+      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
+
+      def read_external des
+        super des
+        read_external_fields des, EXTERNALIZABLE_FIELDS
+      end
+    end
+
+    class AcknowledgeMessageExt < AcknowledgeMessage #:nodoc:
+    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_object(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/class_mapping_spec.rb

@@ -0,0 +1,110 @@
+require "spec_helper.rb"
+
+describe RocketAMF::ClassMapping do
+  before :each do
+    RocketAMF::ClassMapping.reset
+    RocketAMF::ClassMapping.define do |m|
+      m.map :as => 'ASClass', :ruby => 'ClassMappingTest'
+    end
+    @mapper = RocketAMF::ClassMapping.new
+  end
+
+  describe "class name mapping" do
+    it "should allow resetting of mappings back to defaults" do
+      @mapper.get_as_class_name('ClassMappingTest').should_not be_nil
+      RocketAMF::ClassMapping.reset
+      @mapper = RocketAMF::ClassMapping.new
+      @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(RocketAMF::Values::TypedHash.new('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
+      RocketAMF::ClassMapping.mappings.map :as => 'ASClass', :ruby => 'ANamespace::TestRubyClass'
+      @mapper = RocketAMF::ClassMapping.new
+      @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'
+      ]
+
+      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'
+      ]
+
+      ruby_classes.each do |obj|
+        @mapper.get_as_class_name(obj).should_not be_nil
+      end
+    end
+
+    it "should allow config modification" do
+      RocketAMF::ClassMapping.mappings.map :as => 'SecondClass', :ruby => 'ClassMappingTest'
+      @mapper = RocketAMF::ClassMapping.new
+      @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
+  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'
+
+      hash = @mapper.props_for_serialization obj
+      hash.should == {'prop_a' => 'Test A', 'prop_b' => nil}
+    end
+
+    it "should extract inherited object properties" do
+      obj = ClassMappingTest2.new
+      obj.prop_a = 'Test A'
+      obj.prop_c = 'Test C'
+
+      hash = @mapper.props_for_serialization obj
+      hash.should == {'prop_a' => 'Test A', 'prop_b' => nil, 'prop_c' => 'Test C'}
+    end
+  end
+end