rack-amf 0.0.1

data/lib/amf/pure/serializer.rb

@@ -0,0 +1,218 @@
+require 'amf/pure/io_helpers'
+
+module AMF
+  module Pure
+    # AMF0 implementation of serializer
+    class Serializer
+      def initialize
+        @ref_cache = SerializerCache.new
+      end
+
+      def version
+        0
+      end
+
+      def serialize obj, stream = ""
+        if @ref_cache[obj] != nil
+          # Write reference header
+        end
+      end
+    end
+
+    # AMF3 implementation of serializer
+    class AMF3Serializer
+      attr_reader :string_cache
+
+      def initialize
+        @string_cache = SerializerCache.new
+        @object_cache = SerializerCache.new
+      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 << 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
+
+          class_name = ClassMapper.get_as_class_name obj
+
+          # Any object that has a class name isn't dynamic
+          unless class_name
+            stream << DYNAMIC_OBJECT
+          end
+
+          # Write class name/anonymous
+          if class_name
+            write_utf8_vr class_name, stream
+          else
+            stream << 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 << CLOSE_DYNAMIC_OBJECT
+        end
+      end
+
+      private
+      include AMF::Pure::WriteIOHelpers
+
+      def write_utf8_vr str, stream
+        if str == ''
+          stream << 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 initialize
+        @cache_index = 0
+        @store = {}
+      end
+
+      def [] obj
+        @store[object_key(obj)]
+      end
+
+      def []= obj, value
+        @store[object_key(obj)] = value
+      end
+
+      def add_obj obj
+        key = object_key obj
+        if @store[key].nil?
+          @store[key] = @cache_index
+          @cache_index += 1
+        end
+      end
+
+      private
+      def object_key obj
+        if obj.is_a?(String)
+          obj
+        else
+          obj.object_id
+        end
+      end
+    end
+  end
+end

data/lib/amf/pure.rb

@@ -0,0 +1,14 @@
+require 'amf/constants'
+require 'amf/pure/deserializer'
+require 'amf/pure/serializer'
+require 'amf/pure/remoting'
+
+module AMF
+  # This module holds all the modules/classes that implement AMF's
+  # functionality in pure ruby.
+  module Pure
+    $DEBUG and warn "Using pure library for AMF."
+  end
+
+  include AMF::Pure
+end

data/lib/amf/values/array_collection.rb

@@ -0,0 +1,9 @@
+module AMF
+  module Values #:nodoc:
+    class ArrayCollection
+      def externalized_data=(data)
+        @data = data
+      end
+    end
+  end
+end

data/lib/amf/values/messages.rb

@@ -0,0 +1,133 @@
+module AMF
+  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
+
+      def rand_uuid
+        [8,4,4,4,12].map {|n| rand_hex_3(n)}.join('-').to_s
+      end
+
+      private
+      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, exception
+        super message
+
+        @e = exception
+        @faultCode = @e.class.name
+        @faultDetail = @e.backtrace.join("\n")
+        @faultString = @e.message
+      end
+
+      def to_amf serializer
+        stream = ""
+        if serializer.version == 0
+          data = {
+            :faultCode => @faultCode,
+            :faultDetail => @faultDetail,
+            :faultString => @faultString
+          }
+          serializer.write_hash(data, stream)
+        else
+          serializer.write_object(self, stream)
+        end
+        stream
+      end
+    end
+  end
+end

data/lib/amf/values/typed_hash.rb

@@ -0,0 +1,13 @@
+module AMF
+  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/lib/amf/version.rb

@@ -0,0 +1,9 @@
+module AMF
+  # AMF version
+  VERSION         = '0.0.1'
+  VERSION_ARRAY   = VERSION.split(/\./).map { |x| x.to_i } # :nodoc:
+  VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
+  VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:
+  VERSION_BUILD   = VERSION_ARRAY[2] # :nodoc:
+  VARIANT_BINARY  = false
+end

data/lib/amf.rb

@@ -0,0 +1,17 @@
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+$:.unshift "#{File.expand_path(File.dirname(__FILE__))}/amf/"
+
+require 'rubygems'
+require 'amf/version'
+require 'amf/common'
+
+module AMF
+  begin
+    raise LoadError, 'C extensions not implemented'
+  rescue LoadError
+    require 'amf/pure'
+  end
+  require 'amf/class_mapping'
+
+  ClassMapper = AMF::ClassMapping.new
+end

data/lib/rack/amf/application.rb

@@ -0,0 +1,32 @@
+require 'rack/amf/request'
+require 'rack/amf/response'
+
+module Rack::AMF
+  class Application
+    def initialize app, mode
+      @app = app
+      @mode = mode
+    end
+
+    def call env
+      if env['CONTENT_TYPE'] != APPLICATION_AMF
+        return [200, {"Content-Type" => "text/plain"}, ["Hello From Rack::AMF"]]
+      end
+
+      # Wrap request and response
+      env['amf.request'] = Request.new(env)
+      env['amf.response'] = Response.new(env['amf.request'])
+
+      # Handle request
+      if @mode == :pass_through
+        @app.call env
+      elsif @mode == :internal
+        # Have the service manager handle it
+        Services.handle(env)
+      end
+
+      response = env['amf.response'].to_s
+      [200, {"Content-Type" => APPLICATION_AMF, 'Content-Length' => response.length.to_s}, [response]]
+    end
+  end
+end

data/lib/rack/amf/request.rb

@@ -0,0 +1,15 @@
+module Rack::AMF
+  class Request
+    attr_reader :raw_request
+
+    def initialize env
+      env['rack.input'].rewind
+      @raw_request = ::AMF::Request.new.populate_from_stream(env['rack.input'].read)
+    end
+
+    # Returns all messages in the request
+    def messages
+      @raw_request.messages
+    end
+  end
+end

data/lib/rack/amf/response.rb

@@ -0,0 +1,54 @@
+module Rack::AMF
+  class Response
+    attr_reader :raw_response
+
+    def initialize request
+      @request = request
+      @raw_response = ::AMF::Response.new
+    end
+
+    # Builds response, iterating over each method call and using the return value
+    # as the method call's return value
+    def each_method_call &block
+      @request.messages.each do |m|
+        target_uri = m.response_uri
+
+        rd = m.data
+        if rd.is_a?(::AMF::Values::CommandMessage)
+          if rd.operation == ::AMF::Values::CommandMessage::CLIENT_PING_OPERATION
+            data = ::AMF::Values::AcknowledgeMessage.new(rd)
+          else
+            data == ::AMF::Values::ErrorMessage.new(Exception.new("CommandMessage #{rd.operation} not implemented"), rd)
+          end
+        elsif rd.is_a?(::AMF::Values::RemotingMessage)
+          am = ::AMF::Values::AcknowledgeMessage.new(rd)
+          body = dispatch_call(rd.source+'.'+rd.operation, rd.body, rd, block)
+          if body.is_a?(::AMF::Values::ErrorMessage)
+            data = body
+          else
+            am.body = body
+            data = am
+          end
+        else
+          data = dispatch_call(m.target_uri, rd, m, block)
+        end
+
+        target_uri += data.is_a?(::AMF::Values::ErrorMessage) ? '/onStatus' : '/onResult'
+        @raw_response.messages << ::AMF::Message.new(target_uri, '', data)
+      end
+    end
+
+    def to_s
+      raw_response.serialize
+    end
+
+    private
+    def dispatch_call method, args, source_message, handler
+      begin
+        handler.call(method, args)
+      rescue Exception => e
+        ::AMF::Values::ErrorMessage.new(source_message, e)
+      end
+    end
+  end
+end

data/lib/rack/amf/service_manager.rb

@@ -0,0 +1,35 @@
+module Rack::AMF
+  class ServiceManager
+    def initialize
+      @services = {}
+    end
+
+    def register path, service
+      @services ||= {}
+      @services[path] = service
+    end
+
+    def handle env
+      env['amf.response'].each_method_call do |method, args|
+        handle_method method, args
+      end
+    end
+
+    private
+    def handle_method method, args
+      path = method.split('.')
+      method_name = path.pop
+      path = path.join('.')
+
+      if @services[path]
+        if @services[path].respond_to?(method_name)
+          @services[path].send(method_name, *args)
+        else
+          raise "Service #{path} does not respond to #{method_name}"
+        end
+      else
+        raise "Service #{path} does not exist"
+      end
+    end
+  end
+end

data/lib/rack/amf.rb

@@ -0,0 +1,17 @@
+require 'rack'
+require 'amf'
+
+require 'rack/amf/application'
+require 'rack/amf/service_manager'
+require 'rack/amf/request'
+require 'rack/amf/response'
+
+module Rack::AMF
+  APPLICATION_AMF = 'application/x-amf'.freeze
+
+  Services = Rack::AMF::ServiceManager.new
+
+  def self.new app, mode=:internal
+    Rack::AMF::Application.new(app, mode)
+  end
+end

data/spec/amf/class_mapping_set_spec.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+describe AMF::ClassMapping::MappingSet do
+  before :each do
+    @config = AMF::ClassMapping::MappingSet.new
+  end
+
+  it "should retrieve AS mapping for ruby class" do
+    @config.map :as => 'ASTest', :ruby => 'RubyTest'
+    @config.get_as_class_name('RubyTest').should == 'ASTest'
+    @config.get_as_class_name('BadClass').should be_nil
+  end
+
+  it "should retrive ruby class name mapping for AS class" do
+    @config.map :as => 'ASTest', :ruby => 'RubyTest'
+    @config.get_ruby_class_name('ASTest').should == 'RubyTest'
+    @config.get_ruby_class_name('BadClass').should be_nil
+  end
+
+  it "should map special classes by default" do
+    SPECIAL_CLASSES = [
+      'flex.messaging.messages.AcknowledgeMessage',
+      'flex.messaging.messages.ErrorMessage',
+      'flex.messaging.messages.CommandMessage',
+      'flex.messaging.messages.ErrorMessage',
+      'flex.messaging.messages.RemotingMessage',
+      'flex.messaging.io.ArrayCollection'
+    ]
+
+    SPECIAL_CLASSES.each do |as_class|
+      @config.get_ruby_class_name(as_class).should_not be_nil
+    end
+  end
+end