magent 0.6.2 → 0.7.0

data/examples/comm/run.rb

@@ -1,22 +0,0 @@
-#!/usr/bin/env ruby
-
-$:.unshift File.dirname(__FILE__)+"/../../lib/"
-require 'magent'
-
-id = "#{rand(16)}#{rand(16)}#{rand(16)}#{rand(16)}"
-
-values = (1..5).to_a.map { rand(10) }
-puts values.join(" + ")
-Magent.push("workers", :sum, id, *values)
-
-channel = Magent::GenericChannel.new("+#{id}")
-
-loop do
-  v = channel.dequeue;
-  if v
-    $stdout.puts v.inspect
-    break
-  end
-  sleep 0.1
-end
-

data/examples/comm/worker.rb

@@ -1,30 +0,0 @@
-$:.unshift File.dirname(__FILE__)+"/../../lib/"
-require 'magent'
-
-# Use: magent /path/to/this/file
-
-class Worker
-  include Magent::Actor
-  channel_name "workers"
-  expose :sum
-
-  def sum(payload)
-    id, *args = payload
-
-    s = args.inject(0) { |v, a| a += v }
-    send_to_client(id, {:method => :sum, :result => s})
-  end
-
-  private
-  def send_to_client(id, message)
-    c = Magent::GenericChannel.new("+#{id}")
-    c.enqueue(message)
-  end
-end
-
-Magent.register(Worker.new)
-
-if $0 == __FILE__
-  Magent::Processor.new(Worker.channel).run!
-end
-

data/examples/error/error.rb

@@ -1,33 +0,0 @@
-$:.unshift File.dirname(__FILE__)+"/../../lib/"
-require 'magent'
-
-Magent.push("errors", :fail, "this is a fail")
-
-class Error
-  include Magent::Actor
-
-  channel_name "errors"
-  expose :fail
-
-  def fail(payload)
-    @count ||= 0
-    errors = self.class.channel.errors
-
-    errors.each do |error|
-      @count += 1
-      $stderr.puts "Retrying: #{error["method"]}(#{error["payload"].inspect})"
-      self.class.channel.retry_error(error)
-    end
-
-    if @count == 0
-      raise payload.inspect
-    end
-  end
-end
-
-Magent.register(Error.new)
-
-if $0 == __FILE__
-  Magent::Processor.new(Error.channel).run!
-end
-

data/examples/mongomapper/async.rb

@@ -1,41 +0,0 @@
-$:.unshift File.dirname(__FILE__)+"/../../lib/"
-require 'rubygems'
-require 'magent'
-require 'mongo_mapper'
-
-
-MongoMapper.database = "test"
-Magent.database = "test"
-
-class Thing
-  include MongoMapper::Document
-  include Magent::Async
-
-  key :_id, String
-  key :name
-
-  def process_something(arg)
-    puts "Processing: #{arg}"
-  end
-
-  def process_nothing
-    puts "Processing..."
-  end
-
-  def self.foo
-    puts "MAX PRIORITY"
-  end
-end
-
-
-thing = Thing.create(:_id => "foo")
-
-# 3 messages
-thing.async.process_something("testing").commit!
-thing.async.process_nothing.commit!
-Thing.async.find(thing.id).process_something("testing2").commit!
-Thing.async.foo.commit!(1)
-
-Magent::Processor.new(Magent::AsyncChannel.new(:default)).run!
-
-

data/examples/simple/bot.rb

@@ -1,38 +0,0 @@
-$:.unshift File.dirname(__FILE__)+"/../../lib/"
-require 'rubygems'
-require 'magent'
-
-# Use: magent /path/to/this/file
-
-Magent.push("bots", :echo, "hello, world")
-Magent.push("bots", :do_task, "File", :exist?, "/etc/passwd")
-Magent.push("bots", :echo, "Press ctrl+c to close")
-Magent.push("bots", :do_not_exist, "you should not see this message")
-
-class Bot
-  include Magent::Actor
-  channel_name "bots"
-  expose :echo, :do_task
-
-  def echo(payload)
-    $stderr.puts payload.inspect
-  end
-
-  def do_task(payload)
-    klass, *args = payload
-
-    result = Object.module_eval(klass).send(*args)
-    $stderr.puts "RESULT: #{result}"
-  end
-
-  at_least_every 15 do
-    puts "Hi there!, you'll see this message again in ~15 seconds"
-  end
-end
-
-Magent.register(Bot.new)
-
-if $0 == __FILE__
-  Magent::Processor.new(Bot.channel).run!
-end
-

data/examples/stats/stats.rb

@@ -1,27 +0,0 @@
-$:.unshift File.dirname(__FILE__)+"/../../lib/"
-require 'magent'
-
-Magent.push("stats", :calc)
-Magent.push("stats", :calc)
-Magent.push("stats", :calc)
-Magent.push("stats", :calc)
-
-class Stats
-  include Magent::Actor
-
-  channel_name "stats"
-  expose :calc
-
-  def calc(payload)
-    $stderr.puts "messages in queue: #{self.class.channel.queue_count}"
-    $stderr.puts "total messages count: #{self.class.channel.message_count}"
-    $stderr.puts "total errors: #{self.class.channel.error_count}"
-  end
-end
-
-Magent.register(Stats.new)
-
-if $0 == __FILE__
-  Magent::Processor.new(Stats.channel).run!
-end
-

data/lib/magent/actor.rb

@@ -1,82 +0,0 @@
-module Magent
-  module Actor
-    def self.included(klass)
-      klass.class_eval do
-        extend Actor::ClassMethods
-        include Actor::InstanceMethods
-      end
-    end
-
-    module ClassMethods
-      def expose(*methods)
-        methods.each do |m|
-          actions << m.to_s
-        end
-      end
-
-      def channel_name(name = nil)
-        @channel_name ||= (name || Magent::Utils.underscore(self.name)).to_s
-      end
-
-      def actions
-        @actions ||= Set.new
-      end
-
-      def can_handle?(action)
-        actions.include?(action.to_s)
-      end
-
-      def channel
-        @channel ||= begin
-          ActorChannel.new(self.channel_name)
-        end
-      end
-
-      def tasks
-        @tasks ||= []
-      end
-
-      def at_least_every(seconds, &block)
-        tasks << {:every => seconds, :last_time => Time.now, :block => block}
-      end
-    end
-
-    module InstanceMethods
-      def _run_tasks
-        tasks = self.class.tasks
-
-        return false if tasks.empty?
-        performed = false
-
-        tasks.each do |task|
-          delta = Time.now - task[:last_time]
-
-          if delta >= task[:every]
-            task[:last_time] = Time.now
-            begin
-              instance_eval(&task[:block])
-            rescue Exception => e
-              $stderr.puts "Failed periodical task: #{e.message}"
-              $stderr.puts e.backtrace.join("\n\t")
-            end
-            performed = true
-          end
-        end
-
-        performed
-      end
-    end
-  end # Actor
-
-  def self.register(actor)
-    @current_actor = actor
-  end
-
-  def self.current_actor
-    @current_actor
-  end
-
-  def self.current_channel
-    self.current_actor.channel
-  end
-end

data/lib/magent/actor_channel.rb

@@ -1,34 +0,0 @@
-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/push.rb

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

data/lib/magent/web_socket_channel.rb

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

data/lib/magent/web_socket_server.rb

@@ -1,107 +0,0 @@
-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
-        setup
-
-        EM.run do
-          EventMachine.add_periodic_timer(options.delete(:interval)||10) do
-            while message = Magent::WebSocketChannel.dequeue
-              if (channel = @channels[message["channel_id"]])
-                channel.push(message.to_json)
-              end
-            end
-          end
-        end
-
-        EventMachine::WebSocket.start(options) do |ws|
-          ws.onopen do
-            ws.onmessage do |msg|
-              data = JSON.parse(msg) rescue {}
-
-              if !handle_message(ws, data)
-                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)
-                    send(:on_ack, ws, channel_id) if respond_to?(:on_ack)
-                  else
-                    ws.close_connection
-                  end
-                when 'chatmessage'
-                  key = data["key"]
-                  return invalid_key(ws) if key.blank? || @sids[key].blank?
-
-                  channel_id = @channel_ids[key]
-
-                  if channel_id
-                    chat_message = {:id => 'chatmessage', :from => user_name(key, @sids[key]), :message => data["message"]}
-
-                    @channels[channel_id].push(validate_chat_message(channel_id, chat_message).to_json)
-                  else
-                    ws.send({:id => 'announcement', :type => "error", :message => "cannot find the channel"}.to_json)
-                  end
-                end
-              end # if
-            end
-          end
-        end # EM::WebSocket
-      end
-    end
-
-    def self.start(options = {})
-      self.new(options)
-    end
-
-    def setup
-      @channel = EM::Channel.new
-      @channels = {}
-      @channel_ids = {}
-      @sids = {}
-    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)
-      false
-    end
-
-    def validate_chat_message(channel_id, chat_message)
-      chat_message
-    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