magent 0.4.2 → 0.5.0

data/lib/magent/actor.rb

@@ -28,7 +28,7 @@ module Magent
 
       def channel
         @channel ||= begin
-          Channel.new(self.channel_name)
+          ActorChannel.new(self.channel_name)
         end
       end
 
@@ -75,4 +75,8 @@ module Magent
   def self.current_actor
     @current_actor
   end
+
+  def self.current_channel
+    self.current_actor.channel
+  end
 end

data/lib/magent/actor_channel.rb

@@ -0,0 +1,34 @@
+module Magent
+  class ActorChannel < GenericChannel
+    def push(message, args)
+      enqueue([message, args])
+    end
+
+    def process!(message)
+      @actor = Magent.current_actor
+
+      @method, @payload = message
+      return false if @method.nil?
+
+      sucess = @actor._run_tasks
+
+      $stderr.puts "#{@actor.class}##{@method}(#{@payload.inspect})"
+      if @actor.class.can_handle?(@method)
+        @actor.send(@method, @payload)
+        return true
+      else
+        $stderr.puts "Unknown action: #{@method} (payload=#{@payload.inspect})"
+      end
+
+      @method, @payload = nil
+
+      sucess
+    end
+
+    def on_shutdown
+      if @method
+        self.enqueue(@method, @payload)
+      end
+    end
+  end # Channel
+end

data/lib/magent/async.rb

@@ -0,0 +1,65 @@
+# Example
+#     class Processor
+#       include Magent::Async
+#       [..snip..]
+#
+#       def process
+#         puts "Processing #{@params}"
+#       end
+#     end
+#
+#     async call:
+#         Processor.find(id).async(:my_queue).process.commit!(priority)
+#     chained methods:
+#         Processor.async(:my_queue, true).find(1).process.commit!(priority)
+#
+
+module Magent
+  module Async
+    def self.included(base)
+      base.class_eval do
+        include Methods
+        extend Methods
+      end
+    end
+
+    class Proxy
+      instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$|proxy_|^object_id$)/ }
+
+      def initialize(queue, target, test = false)
+        @queue = queue
+        @method_chain = []
+        @target = target
+        @test = test
+
+        @channel = Magent::AsyncChannel.new(@queue)
+      end
+
+      def commit!(priority = 3)
+        @channel.push(@target, @method_chain, priority)
+
+        if @test
+          target = @target
+          @method_chain.each do |c|
+            target = target.send(c[0], *c[1])
+          end
+
+          target
+        end
+      end
+
+      def method_missing(m, *args, &blk)
+        raise ArgumentError, "ruby blocks are not supported yet" if !blk.nil?
+        @method_chain << [m, args]
+        self
+      end
+    end
+
+    module Methods
+      # @question.async(:judge).on_view_question.commit!(1)
+      def async(queue = :default, test = false)
+        Magent::Async::Proxy.new(queue, self, test)
+      end
+    end
+  end # Async
+end

data/lib/magent/async_channel.rb

@@ -0,0 +1,38 @@
+module Magent
+  class AsyncChannel < GenericChannel
+    def push(target, method_chain, priority)
+      if target.kind_of?(Class)
+        enqueue([target.to_s, nil, method_chain], priority)
+      elsif target.class.respond_to?(:find) && target.respond_to?(:id)
+        enqueue([target.class.to_s, target.id, method_chain], priority)
+      else
+        raise ArgumentError, "I don't know how to handle #{target.inspect}"
+      end
+    end
+
+    def process!(message)
+      klass, id, method_chain = message
+
+      return false if method_chain.nil?
+
+      target = resolve_target(klass, id)
+
+      method_chain.each do |c|
+        target = target.send(c[0], *c[1])
+      end
+
+      true
+    end
+
+    private
+    def resolve_target(klass, id)
+      klass = Object.module_eval(klass) if klass.kind_of?(String)
+
+      if id
+        klass.find(id)
+      else
+        klass
+      end
+    end
+  end # AsyncChannel
+end

data/lib/magent/{channel.rb → failure.rb}

@@ -1,11 +1,7 @@
 module Magent
-  class Channel < GenericChannel
-    def enqueue(message, args)
-      super([message, args])
-    end
-
+  module Failure
     def failed(info)
-      error_collection.save(info.merge({:_id => generate_uid, :channel => @name, :created_at => Time.now.utc}))
+      error_collection.save(info.merge({:_id => generate_uid, :channel => @name, :channel_class => self.class.to_s, :created_at => Time.now.utc}))
     end
 
     def error_count
@@ -26,12 +22,12 @@ module Magent
     end
 
     def retry_error(error)
+      process!(error["message"])
       remove_error(error["_id"])
-      enqueue(error["method"], error["payload"])
     end
 
     def error_collection
-      @error_collection ||= Magent.database.collection("#{@name}-errors")
+      @error_collection ||= Magent.database.collection("#{@name}.errors")
     end
-  end # Channel
+  end
 end

data/lib/magent/generic_channel.rb

@@ -1,13 +1,15 @@
 module Magent
   class GenericChannel
+    include Magent::Failure
+
     attr_reader :name
 
     def initialize(name)
-      @name = name
+      @name = "magent.#{name}"
     end
 
-    def enqueue(message)
-      collection.save({:_id => generate_uid, :message => message, :priority => 3, :created_at => Time.now.to_i})
+    def enqueue(message, priority = 3)
+      collection.save({:_id => generate_uid, :message => message, :priority => priority, :created_at => Time.now.to_i})
     end
 
     def message_count
@@ -25,12 +27,8 @@ module Magent
     end
 
     def next_message
-      rec = Magent.database.command(BSON::OrderedHash[:findandmodify, @name,
-        :sort, [{:priority => -1}, {:created_at => 1}],
-        :remove, true
-      ]) rescue {}
-
-      rec["value"]
+      collection.find_and_modify(:sort => [[:priority, Mongo::ASCENDING], [:created_at, Mongo::DESCENDING]],
+                                 :remove => true) rescue {}
     end
 
     def collection

data/lib/magent/processor.rb

@@ -1,16 +1,14 @@
 module Magent
   class Processor
-    attr_reader :actor
-
-    def initialize(actor)
-      @actor = actor
+    def initialize(channel)
+      @channel = channel
       @shutdown = false
 
-      @actor.class.actions.each do |action|
-        if !@actor.respond_to?(action)
-          raise ArgumentError, "action '#{action}' is not defined"
-        end
-      end
+#       @actor.class.actions.each do |action|
+#         if !@actor.respond_to?(action)
+#           raise ArgumentError, "action '#{action}' is not defined"
+#         end
+#       end
     end
 
     def run!
@@ -23,46 +21,34 @@ module Magent
       loop do
         break if @shutdown
 
-        delay = 0 if @actor._run_tasks
-
-        @method, @payload = @actor.class.channel.dequeue
-
-        if @method.nil?
-          delay += 0.1 if delay <= 5
-        else
-          delay = 0
-          $stderr.puts "#{@actor.class}##{@method}(#{@payload.inspect})"
-          begin
-            if @actor.class.can_handle?(@method)
-              processed_messages += 1
-              @actor.send(@method, @payload)
-
-              if processed_messages > 20
-                processed_messages = 0
-                GC.start
-              end
-            else
-              $stderr.puts "Unknown action: #{@method} (payload=#{@payload.inspect})"
+        message = @channel.dequeue
+        begin
+          if message && @channel.process!(message)
+            puts "Processed #{message.inspect}"
+            delay = 0
+            processed_messages += 1
+            if processed_messages > 20
+              processed_messages = 0
+              GC.start
             end
-          rescue SystemExit
-          rescue Exception => e
-            $stderr.puts "Error while executing #{@method.inspect} #{@payload.inspect}"
-            $stderr.puts "#{e.to_s}\n#{e.backtrace.join("\t\n")}"
-            @actor.class.channel.failed(:message => e.message, :method => @method, :payload => @payload, :backtrace => e.backtrace, :date => Time.now.utc)
-          ensure
-            @method, @payload = nil
+          else
+            delay += 0.1 if delay <= 5
           end
+        rescue SystemExit
+        rescue Exception => e
+          $stderr.puts "Error processing #{message.inspect} => #{e.message}"
+          @channel.failed(:error => e.message, :message => message, :backtrace => e.backtrace, :date => Time.now.utc)
+        ensure
         end
+
         sleep delay
       end
     end
 
     def shutdown!
       @shutdown = true
+      @channel.on_shutdown if @channel.respond_to?(:on_shutdown)
       $stderr.puts "Shutting down..."
-      if @method
-        @actor.class.channel.enqueue(@method, @payload)
-      end
     end
   end #Processor
 end

data/lib/magent/push.rb

@@ -1,10 +1,10 @@
 module Magent
   def self.push(channel_name, method, *args)
-    self.channel(channel_name.to_s).enqueue(method, args)
+    self.channel(channel_name.to_s).push(method, args)
   end
 
   def self.channel(name)
-    self.channels[name] ||= Channel.new(name)
+    self.channels[name] ||= ActorChannel.new(name)
   end
 
   def self.channels

data/lib/magent/railtie.rb

@@ -0,0 +1,10 @@
+require 'magent'
+require 'rails'
+
+module MyPlugin
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load "tasks/magent.rake"
+    end
+  end
+end

data/lib/magent/web_socket_channel.rb

@@ -0,0 +1,18 @@
+module Magent
+  class WebSocketChannel < Magent::GenericChannel
+    def self.push(message)
+
+      self.instance.enqueue(message)
+
+      self.instance
+    end
+
+    def self.next_message
+      self.instance.next_message
+    end
+
+    def self.instance
+      @channel ||= self.new(Magent.config["websocket_channel"]||"magent.websocket")
+    end
+  end
+end

data/lib/magent/web_socket_server.rb

@@ -0,0 +1,95 @@
+require 'magent/web_socket_channel'
+module Magent
+  class WebSocketServer
+    def initialize(options = {})
+      options = {:host => "0.0.0.0", :port => 34567}.merge(options)
+
+      $stdout.puts ">> Server running and up! #{options}}" if options[:debug]
+
+      EventMachine.run do
+        @channel = EM::Channel.new
+        @channels = {}
+        @channel_ids = {}
+        @sids = {}
+
+        EventMachine.add_periodic_timer(options.delete(:interval)||10) do
+          while v = Magent::WebSocketChannel.next_message
+            message = v["message"]
+            if message && (channel = @channels[message["channel_id"]])
+              channel.push(message.to_json)
+            end
+          end
+        end
+
+        EventMachine::WebSocket.start(options) do |ws|
+          ws.onopen do
+            ws.onmessage do |msg|
+              data = JSON.parse(msg) rescue {}
+
+              case data["id"]
+              when 'start'
+                if data["channel_id"].present? && (channel_id = validate_channel_id(data["channel_id"]))
+                  key = generate_unique_key(data["key"])
+                  @channels[channel_id] ||= EM::Channel.new
+                  @channel_ids[key] = channel_id
+
+                  sid = @channels[channel_id].subscribe { |msg| ws.send(msg) }
+
+                  @sids[key] = sid
+                  ws.onclose do
+                    @channel_ids.delete(key)
+                    @channels[channel_id].unsubscribe(sid)
+                    @sids.delete(key)
+                  end
+
+                  ws.send({:id => "ack", :key => key}.to_json)
+                else
+                  ws.close_connection
+                end
+              when 'chatmessage'
+                key = data["key"]
+                return invalid_key if key.blank? || @sids[key].blank?
+
+                channel_id = @channel_ids[key]
+
+                if channel_id
+                  @channels[channel_id].push({:id => 'chatmessage', :from => user_name(key, @sids[key]), :message => data["message"]}.to_json)
+                else
+                  ws.send({:id => 'announcement', :type => "error", :message => "cannot find the channel"}.to_json)
+                end
+              else
+                handle_message(ws, data)
+              end
+            end
+          end
+        end # EM::WebSocket
+      end
+    end
+
+    def self.start(options = {})
+      self.new(options)
+    end
+
+    protected
+    def invalid_key(ws)
+      ws.send({:id => 'announcement', :type => "error", :message => "you must provide your unique key"}.to_json)
+    end
+
+    def handle_message(ws, data)
+      ws.send({:id => 'announcement', :type => "error", :message => "unhandled message: #{data.inspect}"}.to_json)
+    end
+
+    protected
+    def generate_unique_key(default = nil)
+      default || UUIDTools::UUID.random_create.hexdigest
+    end
+
+    def validate_channel_id(id)
+      return id if !id.blank?
+    end
+
+    def user_name(socket_key, sid)
+      "Guest #{sid}"
+    end
+  end # Class
+end