revent 0.1 → 0.2

data/lib/revent/amf3/util/string.rb

@@ -0,0 +1,33 @@
+class String
+
+  def to_snake! # no one should change these unless they can benchmark and prove their way is faster. =)
+    @cached_snake_strings ||= {}
+    @cached_snake_strings[self] ||= (
+      while x = index(/([a-z\d])([A-Z])/) # unfortunately have to use regex for this one
+        y=x+1
+        self[x..y] = self[x..x]+"_"+self[y..y].downcase
+      end
+      self
+    )
+  end
+  
+  # Aryk: This might be a better way of writing it. I made a lightweight version to use in my modifications. Feel free to adapt this to the rest.
+  def to_camel! # no one should change these unless they can benchmark and prove their way is faster. =)
+    @cached_camel_strings ||= {}
+    @cached_camel_strings[self] ||= (
+      # new_string = self.dup # need to do this since sometimes the string is frozen
+      while x = index("_")
+        y=x+1
+        self[x..y] = self[y..y].capitalize # in my tests, it was faster than upcase
+      end
+      self
+    )
+  end
+  
+  def to_title
+   title = self.dup
+   title[0..0] = title[0..0].upcase
+   title
+  end
+  
+end

data/lib/revent/amf3/util/vo_helper.rb

@@ -0,0 +1,121 @@
+module RubyAMF
+  module VoHelper
+    class VoHash < Hash
+      attr_accessor :_explicitType
+    end
+
+    require "#{File.dirname(__FILE__)}/../app/configuration" # cant put this at the top because VoHash has to be instantiated for app/configuration to work
+    class VoUtil
+      
+      include RubyAMF::Configuration
+      include RubyAMF::Exceptions
+      
+      #moved logic here so AMF3 and AMF0 can use it
+      def self.get_vo_for_incoming(obj,action_class_name)
+        if (mapping = ClassMappings.get_vo_mapping_for_actionscript_class(action_class_name)) || ## if there is a map use, that class
+          (ruby_obj = ClassMappings.assume_types&&(action_class_name.constantize.new rescue false)) # if no map, and try to get the assumed type
+          if mapping #if there's a map, then we default to it's specification.
+            obj.reject!{|k,v| mapping[:ignore_fields][k]}
+            ruby_obj = mapping[:ruby].constantize.new
+          end            
+          if ruby_obj.is_a?(ActiveRecord::Base)        # put all the attributes fields into the attribute instance variable
+            attributes = {} # extract attributes
+            if mapping
+              obj.each_key do |field|
+                if ClassMappings.attribute_names[mapping[:ruby]][field]
+                  attributes[field] = obj.delete(field)
+                end
+              end
+            else # for assumed types when there is no mapping
+              attribs = (ruby_obj.attribute_names + ["id"]).inject({}){|hash, attr| hash[attr]=true ; hash}
+              obj.each_key do |field|
+                if attribs[field]
+                  attributes[field] = obj.delete(field)
+                end
+              end
+            end
+            attributes.delete("id") if attributes["id"]==0 # id attribute cannot be zero
+            ruby_obj.instance_variable_set("@attributes", attributes) # bypasses any overwriting of the attributes=(value) method  (also allows 'id' to be set)
+            ruby_obj.instance_variable_set("@new_record", false) if attributes["id"] # the record already exists in the database
+            obj.each_key do |field|
+              if reflection = ruby_obj.class.reflections[field.to_sym] # is it an association
+                value = obj.delete(field) # get rid of the field so it doesnt get added in the next loop
+                case reflection.macro  
+                when :has_one
+                  ruby_obj.send("set_#{field}_target", value)
+                when :belongs_to
+                  ruby_obj.send("#{field}=", value)
+                when :has_many, :has_many_and_belongs_to
+                  ruby_obj.send("#{field}").target = value
+                when :composed_of
+                  ruby_obj.send("#{field}=", value) # this sets the attributes to the corresponding values
+                end
+              end
+            end
+          end
+          obj.each do |field, value| # whatever is left, set them as instance variables in the object
+            ruby_obj.instance_variable_set("@#{field}", value)
+          end
+          ruby_obj
+        else # then we are still left with a normal hash, lets see if we need to change the type of the keys
+          case ClassMappings.hash_key_access
+          when :symbol      : obj.symbolize_keys!
+          when :string      : obj # by default the keys are a string type, so just return the obj
+          when :indifferent : HashWithIndifferentAccess.new(obj)
+          # else  # TODO: maybe add a raise FlexError since they somehow put the wrong value for this feature
+          end
+        end
+      end
+            
+      # Aryk: I tried to make this more efficent and clean.
+      def self.get_vo_hash_for_outgoing(obj)
+        new_object = VoHash.new #use VoHash because one day, we might do away with the class Object patching
+        instance_vars = obj.instance_variables
+        if map = ClassMappings.get_vo_mapping_for_ruby_class(obj.class.to_s)
+          if map[:type]=="active_record"
+            attributes_hash = obj.attributes
+            (map[:attributes]||attributes_hash.keys).each do |attr| # need to use dup because sometimes the attr is frozen from the AR attributes hash
+              attr_name = attr
+              attr_name = attr_name.dup.to_camel! if ClassMappings.translate_case # need to do it this way because the string might be frozen if it came from the attributes_hash.keys
+              new_object[attr_name] = attributes_hash[attr]
+            end
+            instance_vars = [] # reset the instance_vars for the associations, this way no unwanted instance variables (ie @new_record, @read_only) can get through
+            # Note: if you did not specify associations, it will not show up even if you eager loaded them.
+            if map[:associations] # Aryk: if they opted for assocations, make sure that they are loaded in. This is great for composed_of, since it cannot be included on a find
+              map[:associations].each do |assoc|
+                instance_vars << ("@"+assoc) if obj.send(assoc) # this will make sure they are instantiated and only load it if they have a value.
+              end
+            elsif ClassMappings.check_for_associations
+              instance_vars = obj.instance_variables.reject{|assoc| ["@attributes","@new_record","@read_only"].include?(assoc)}
+            end
+          end
+          new_object._explicitType = map[:actionscript] # Aryk: This only works on the Hash because rubyAMF extended class Object to have this accessor, probably not the best idea, but its already there.   
+          # Tony: There's some duplication in here. Had trouble consolidating the logic though. Ruby skills failed.
+        elsif ClassMappings.assume_types
+          new_object._explicitType = obj.class.to_s
+          if obj.is_a?(ActiveRecord::Base)
+            obj.attributes.keys.each do |key|
+              attr_name = key
+              attr_name = attr_name.dup.to_camel! if ClassMappings.translate_case # need to do it this way because the string might be frozen if it came from the attributes_hash.keys
+              new_object[attr_name] = obj.attributes[key]
+            end
+            instance_vars = []
+            if ClassMappings.check_for_associations
+              instance_vars = obj.instance_variables.reject{|assoc| ["@attributes","@new_record","@read_only"].include?(assoc)}
+            end
+          end
+        end
+        instance_vars.each do |var| # this also picks up the eager loaded associations, because association called "has_many_assoc" has an instance variable called "@has_many_assoc"
+          attr_name = var[1..-1]
+          attr_name.to_camel! if ClassMappings.translate_case
+          new_object[attr_name] = obj.instance_variable_get(var)
+        end
+        new_object
+      rescue Exception => e
+        puts e.message
+        puts e.backtrace
+        raise RUBYAMFException.new(RUBYAMFException.VO_ERROR, e.message)
+      end
+    end
+  end
+end

data/lib/revent/as_r.rb

@@ -0,0 +1,178 @@
+require 'rubygems'
+require 'eventmachine'
+require "#{File.dirname(__FILE__)}/amf3/amf3"
+
+# AS clients are not reliable. For security, we close the connection immediately
+# if there is any error.
+module Revent
+  module ASRCon
+    # Called by Flash player
+    CMD_POLICY = '<policy-file-request/>' + "\0"
+
+    TYPE_CALL   = 0
+    TYPE_RESULT = 1
+    TYPE_ERROR  = 2
+
+    attr_writer :me
+    attr_accessor :property  # Something that you want to associate with this connection
+    attr_writer :cons
+
+    def post_init
+      @connected = true
+      @data = ''
+      @dec = RubyAMF::IO::AMFDeserializer.new
+      @enc = RubyAMF::IO::AMFSerializer.new
+    end
+
+    def receive_data(data)
+      @data << data
+      if @data == CMD_POLICY
+        send_data(@me.policy + "\0")
+        close_connection_after_writing
+        return
+      end
+
+      if @data.size > @me.max_cmd_length
+        close_connection
+        return
+      end
+
+      while true
+        @dec.reset
+        @dec.stream = @data
+        o = @dec.read_amf3
+        break if o.nil?
+
+        process(o)
+
+        last_size = @data.size
+        @data.slice!(0, @dec.stream_position)
+        break if last_size == @dec.stream_position
+      end
+    rescue
+      close_connection
+    end
+
+    def process(o)
+      type  = o[0]
+      cmd   = o[1]
+      value = o[2]
+
+      case type
+      when TYPE_CALL
+        @me.on_call(self, cmd, value)
+      when TYPE_RESULT
+        @me.on_result(self, cmd, value)
+      when TYPE_ERROR
+        @me.on_error(self, cmd, value)
+      end
+    rescue => e
+      @me.logger.error(e)
+      close_connection
+    end
+
+    def unbind
+      @connected = false
+      if @cons.nil?
+        @me.on_close
+      else
+        @me.on_close(self)
+        @cons.delete(self)
+      end
+    end
+
+  # ----------------------------------------------------------------------------
+
+    def send_amf3_data(data)
+      @enc.reset
+      @enc.write_amf3(data)
+      send_data(@enc.stream)
+      @enc.reset
+    end
+
+    def connected?
+      @connected
+    end
+
+    # IP of the container.
+    def remote_ip
+      peername = get_peername
+      return @last_ip if peername.nil?
+
+      a = get_peername[2,6].unpack("nC4")
+      a.delete_at(0)
+      @last_ip = a.join('.')
+    end
+
+    def call(cmd, value, close_connection_after_writing = false)
+      send_amf3_data([TYPE_CALL, cmd, value])
+      self.close_connection_after_writing if close_connection_after_writing
+    end
+
+    def result(cmd, value, close_connection_after_writing = false)
+      send_amf3_data([TYPE_RESULT, cmd, value])
+      self.close_connection_after_writing if close_connection_after_writing
+    rescue
+    end
+
+    def error(cmd, value, close_connection_after_writing = false)
+      send_amf3_data([TYPE_ERROR, cmd, value])
+      self.close_connection_after_writing if close_connection_after_writing
+    end
+  end
+
+  # To make your class a server, just include Revent::RRServer in it.
+  module ASRServer
+    # For security check, normally command cannot be too long
+    DEFAULT_MAX_CMD_LENGTH = 1024
+
+    attr_accessor :logger, :max_cmd_length, :policy
+
+    # Set logger, max_cmd_length, policy if you don't want the default values
+    # before calling this method.
+    def start_server(host, port)
+      @logger = Logger.new(STDOUT) if @logger.nil?
+      @max_cmd_length = DEFAULT_MAX_CMD_LENGTH if @max_cmd_length.nil?
+      if @policy.nil?
+        @policy = <<EOF
+<cross-domain-policy>
+<allow-access-from domain="*" to-ports="#{port}" />
+</cross-domain-policy>
+EOF
+      end
+
+      @revent_cons = []
+      EventMachine::start_server(host, port, ASRCon) do |con|
+        @revent_cons << con
+        con.me = self
+        con.cons = @revent_cons
+        on_connect(con)
+      end
+    end
+
+    # Utilities. You can call remote_ip, call, close directly on each "client", as
+    # if it is an instance of Revent::RRClient.
+    # ----------------------------------------------------------------------------
+
+    def clients
+      @revent_cons
+    end
+
+    # ----------------------------------------------------------------------------
+
+    def on_connect(client)
+    end
+
+    def on_close(client)
+    end
+
+    def on_call(client, cmd, value)
+    end
+
+    def on_result(client, cmd, value)
+    end
+
+    def on_error(client, cmd, value)
+    end
+  end
+end

data/lib/revent/r_r.rb

@@ -0,0 +1,176 @@
+require 'rubygems'
+require 'eventmachine'
+require 'stringio'
+
+module Revent
+  # Included by both Revent::RRServer and Revent::RRClient.
+  module RRCon
+    TYPE_CALL   = 0
+    TYPE_RESULT = 1
+    TYPE_ERROR  = 2
+
+    attr_writer :me
+    attr_accessor :property  # Something that you want to associate with this connection
+    attr_writer :cons  # Only used for Revent::RRServer
+
+    def post_init
+      @connected = true
+      @data = ''
+    end
+
+    def receive_data(data)
+      @data << data
+      while true
+        io = StringIO.new(@data)
+        o = Marshal.load(io)
+        @data.slice!(0, io.pos)
+        process(o)
+      end
+    rescue
+    end
+
+    def process(o)
+      type  = o[0]
+      cmd   = o[1]
+      value = o[2]
+
+      case type
+      when TYPE_CALL
+        value = @cons.nil? ? @me.on_call(cmd, value) : @me.on_call(self, cmd, value)
+        o = [TYPE_RESULT, cmd, value]
+        send_data(Marshal.dump(o))
+      when TYPE_RESULT
+        @cons.nil? ? @me.on_result(cmd, value) : @me.on_result(self, cmd, value)
+      when TYPE_ERROR
+        @cons.nil? ? @me.on_error(cmd, value) : @me.on_error(self, cmd, value)
+      end
+    rescue => e
+      o = [TYPE_ERROR, cmd, e]
+      send_data(Marshal.dump(o))
+    end
+
+    def unbind
+      @connected = false
+      if @cons.nil?
+        @me.on_close
+      else
+        @me.on_close(self)
+        @cons.delete(self)
+      end
+    end
+
+  # ----------------------------------------------------------------------------
+
+    def connected?
+      @connected
+    end
+
+    # IP of the container.
+    def remote_ip
+      peername = get_peername
+      return @last_ip if peername.nil?
+
+      a = get_peername[2,6].unpack("nC4")
+      a.delete_at(0)
+      @last_ip = a.join('.')
+    end
+
+    def call(cmd, value)
+      o = [TYPE_CALL, cmd, value]
+      send_data(Marshal.dump(o))
+    end
+  end
+
+
+  # To make your class a server, just include Revent::RRServer in it.
+  module RRServer
+    def start_server(host, port)
+      @revent_cons = []
+      EventMachine::start_server(host, port, RRCon) do |con|
+        @revent_cons << con
+        con.me = self
+        con.cons = @revent_cons
+        on_connect(con)
+      end
+    end
+
+    # Utilities. You can call remote_ip, call, close directly on each "client", as
+    # if it is an instance of Revent::RRClient.
+    # ----------------------------------------------------------------------------
+
+    def clients
+      @revent_cons
+    end
+
+    # ----------------------------------------------------------------------------
+
+    def on_connect(client)
+    end
+
+    def on_close(client)
+    end
+
+    def on_call(client, cmd, value)
+    end
+
+    def on_result(client, cmd, value)
+    end
+
+    def on_error(client, cmd, value)
+    end
+  end
+
+  # To make your class a client, just include Revent::RRClient in it.
+  module RRClient
+    def connect(host, port)
+      EventMachine::connect(host, port, RRCon) do |con|
+        @revent_con = con
+        con.me = self
+        on_connect
+      end
+    end
+
+    # Utilities ------------------------------------------------------------------
+
+    def property
+      @revent_con.property
+    end
+
+    def property=(value)
+      @revent_con.property = value
+    end
+
+    def remote_ip
+      @revent_con.remote_ip
+    end
+
+    def call(cmd, value)
+      @revent_con.call(cmd, value)
+    end
+
+    def close_connection
+      @revent_con.close_connection
+    end
+
+    def close_connection_after_writing
+      @revent_con.close_connection_after_writing
+    end
+
+   # ----------------------------------------------------------------------------
+
+    def on_connect
+    end
+
+    def on_close
+    end
+
+    def on_call(cmd, value)
+    end
+
+    def on_result(cmd, value)
+    end
+
+    def on_error(cmd, value)
+    end
+  end
+end