donkey 0.1.0

data/lib/ass/client.rb

@@ -0,0 +1,19 @@
+class ASS::Client
+  def initialize(opts={})
+    @rpc_opts = opts
+  end
+  
+  def rpc
+    # should lazy start the RPC server
+    @rpc ||= ASS.rpc(@rpc_opts)
+  end
+
+  def cast(name,method,data,opts={},meta=nil)
+    ASS.cast(name,method,data,opts,meta)
+  end
+
+  # makes synchronized call through ASS::RPC
+  def call(name,method,data,opts={},meta=nil)
+    rpc.call(name,method,data,opts,meta)
+  end
+end

data/lib/ass/peeper.rb

@@ -0,0 +1,38 @@
+# TODO should prolly have the option of using
+# non auto-delete queues. This would be useful
+# for logger. Maybe if a peeper name is given,
+# then create queues with options.
+class Peeper
+  include Callback
+  attr_reader :server_name
+  def initialize(server_name,callback)
+    @server_name = server_name
+    @clients = {}
+    @callback = build_callback(callback)
+    
+    uid = "#{@server_name}.peeper.#{rand 999_999_999_999}"
+    q = MQ.queue uid, :auto_delete => true
+    q.bind(@server_name) # messages to the server would be duplicated here.
+    q.subscribe { |info,payload|
+      payload = ::Marshal.load(payload)
+      # sets context, but doesn't make the call
+      obj = prepare_callback(@callback,info,payload)
+      # there is a specific method we want to call.
+      obj.server(payload[:method],payload[:data])
+
+      # bind to peep client message queue if we've not seen it before.
+      unless @clients.has_key? info.routing_key
+        @clients[info.routing_key] = true
+        client_q = MQ.queue "#{uid}--#{info.routing_key}",
+        :auto_delete => true
+        # messages to the client would be duplicated here.
+        client_q.bind("#{server_name}--", :routing_key => info.routing_key) 
+        client_q.subscribe { |info,payload|
+          payload = ::Marshal.load(payload)
+          obj = prepare_callback(@callback,info,payload)
+          obj.client(payload[:method],payload[:data])
+        }
+      end
+    }
+  end
+end

data/lib/ass/rpc.rb

@@ -0,0 +1,180 @@
+# A RPC client is a transient entity that dies
+# with the process that created it. Its purpose
+# is only to provide a synchronized interface to
+# the asynchronous services.
+require 'thread'
+require 'monitor'
+class ASS::RPC
+  # stolen from nanite
+  def self.random_id
+      values = [
+        rand(0x0010000),
+        rand(0x0010000),
+        rand(0x0010000),
+        rand(0x0010000),
+        rand(0x0010000),
+        rand(0x1000000),
+        rand(0x1000000),
+      ]
+      "%04x%04x%04x%04x%04x%06x%06x" % values
+  end
+  
+  class Future
+    # TODO set meta
+    attr_reader :message_id
+    attr_accessor :header, :data, :method, :meta
+    attr_accessor :timeout
+    def initialize(rpc,message_id)
+      @message_id = message_id
+      @rpc = rpc
+      @timeout = false
+      @done = false
+    end
+    
+    def wait(timeout=nil,&block)
+      @rpc.wait(self,timeout,&block) # synchronous call that will block
+    end
+
+    def done!
+      @done = true
+    end
+
+    def done?
+      @done
+    end
+
+    def timeout?
+      @timeout
+    end
+
+    def inspect
+      "#<#{self.class} #{message_id}>"
+    end
+  end
+
+  attr_reader :name
+  attr_reader :buffer, :futures, :ready
+  def initialize(opts={})
+    raise "can't run rpc client in the same thread as eventmachine" if EM.reactor_thread?
+    self.extend(MonitorMixin)
+    @seq = 0
+    # queue is used be used to synchronize RPC
+    # user thread and the AMQP eventmachine thread.
+    @buffer = Queue.new
+    @ready = {} # the ready results not yet waited
+    @futures = {} # all futures not yet waited for.
+    # Creates an exclusive queue to serve the RPC client.
+    @rpc_id = ASS::RPC.random_id.to_s
+    buffer = @buffer # closure binding for reactor
+    exchange = ASS.mq.direct("__rpc__")
+    @name = "__rpc__#{@rpc_id}"
+    queue = ASS.mq.queue(@name,
+                         :exclusive => true,
+                         :auto_delete => true)
+    queue.bind("__rpc__",:routing_key => @rpc_id)
+    queue.subscribe { |header,payload|
+      payload = ::Marshal.load(payload)
+      buffer << [header,payload]
+    }
+  end
+
+  def call(server_name,method,data=nil,opts={},meta=nil)
+    self.synchronize do
+      message_id = @seq.to_s # message gotta be unique for this RPC client.
+      # by default route message to the exchange @name@, with routing key @name@
+      ASS.call(server_name,
+               method,
+               data,
+               # can't override these options
+               opts.merge(:message_id => message_id,
+                          :reply_to => "__rpc__",
+                          :key => @rpc_id),
+               meta)
+      @seq += 1
+      @futures[message_id] = Future.new(self,message_id)
+    end
+  end
+
+  # the idea is to block on a synchronized queue
+  # until we get the future we want.
+  #
+  # WARNING: blocks forever if the thread
+  # calling wait is the same as the EventMachine
+  # thread.
+  #
+  # It is safe (btw) to use the RPC client within
+  # an ASS server/actor, because the wait is in an
+  # EM worker thread, rather than the EM thread
+  # itself. The EM thread is still free to process
+  # the queue. CAVEAT: you could run out of EM
+  # worker threads.
+  def wait(future,timeout=nil)
+    return future.data if future.done? # future was waited before
+    # we can have more fine grained synchronization later.
+    ## easiest thing to do (later) is use threadsafe hash for @futures and @ready.
+    ### But it's actually trickier than
+    ### that. Before each @buffer.pop, a thread
+    ### has to check again if it sees the result
+    ### in @ready.
+    self.synchronize do
+      timer = nil
+      if timeout
+        timer = EM.add_timer(timeout) {
+          @buffer << [:timeout,future.message_id]
+        }
+      end
+      ready_future = nil
+      if @ready.has_key? future.message_id
+        @ready.delete future.message_id
+        ready_future = future
+      else
+        while true
+          header,payload = @buffer.pop # synchronize. like erlang's mailbox select.
+          if header == :timeout # timeout the future we are waiting for.
+            message_id = payload
+            # if we got a timeout from previous wait. throw it away.
+            next if future.message_id != message_id 
+            future.timeout = true
+            future.done!
+            @futures.delete future.message_id
+            return yield # return the value of timeout block
+          end
+          data = payload["data"]
+          some_future = @futures[header.message_id]
+          # If we didn't find the future among the
+          # future, it must have timedout. Just
+          # throw result away and keep processing.
+          next unless some_future
+          some_future.timeout = false
+          some_future.header = header
+          some_future.data = data
+          some_future.method = payload["method"]
+          some_future.meta = payload["meta"]
+          if some_future == future
+            # The future we are waiting for
+            EM.cancel_timer(timer) if timer
+            ready_future = future
+            break
+          else
+            # Ready, but we are not waiting for it. Save for later.
+            @ready[some_future.message_id] = some_future
+          end
+        end
+      end
+      ready_future.done!
+      @futures.delete ready_future.message_id
+      return ready_future.data
+    end
+    
+  end
+
+  def waitall
+    @futures.values.map { |k,v|
+      wait(v)
+    }
+  end
+
+  def inspect
+    "#<#{self.class} #{self.name}>"
+  end
+end

data/lib/ass/serializers.rb

@@ -0,0 +1,26 @@
+module ASS
+  module JSON
+    require 'json'
+    def self.load(raw)
+      JSON.parse(raw)
+    end
+
+    def self.dump(obj)
+      obj.to_json
+    end
+  end
+
+  module Marshal
+    def self.load(raw)
+      ::Marshal.load(raw)
+    end
+
+    def self.dump(obj)
+      ::Marshal.dump(obj)
+    end
+  end
+
+  # mongodb BSON
+  module BSON
+  end
+end

data/lib/ass/server.rb

@@ -0,0 +1,181 @@
+class ASS::Server
+  attr_reader :name
+  
+  def initialize(name,opts={})
+    @name = name
+    # the server is a fanout (ignores routing key)
+    @exchange = ASS.mq.fanout(name,opts)
+  end
+
+  def exchange
+    @exchange
+  end
+
+  def queue(opts={})
+    unless @queue
+      @queue ||= ASS.mq.queue(self.name,opts)
+      @queue.bind(self.exchange)
+    end
+    self
+  end
+
+  # takes options available to MQ::Queue# takes options available to MQ::Queue#subscribe
+  def react(_callback=nil,_opts=nil,&_block)
+    if _block
+      _opts = _callback
+      _callback = _block
+    end
+    _opts = {} if _opts.nil?
+    
+    # second call would just swap out the callback.
+    @factory = ASS::CallbackFactory.new(_callback)
+    
+    return(self) if @subscribed
+    @subscribed = true
+    @ack = _opts[:ack]
+    self.queue unless @queue
+
+    # yikes!! potential for scary bugs
+    @queue.subscribe(_opts) do |info,payload|
+      payload = ASS.serializer.load(payload)
+      #p [info,payload]
+      callback_object = @factory.callback_for(self,info,payload)
+      proc { #|callback_object=prepare_callback(@callback,info,payload)|
+        operation = proc {
+          with_handlers do
+            callback_object.send(:on_call,payload["data"])
+          end
+        }
+        done = proc { |result|
+          # the client MUST exist, otherwise it's an error.
+          ## FIXME it's bad if the server dies b/c
+          ## the client isn't there. It's bad that
+          ## this can cause the server to fail.
+          ##
+          ## I am not sure what happens if message
+          ## is unroutable. I think it's just
+          ## silently dropped unless the mandatory
+          ## option is given.
+          case status = result[0]
+          when :ok
+            if info.reply_to
+              data = result[1]
+              # respond with cast (we don't want
+              # to get a response to our response,
+              # then respond to the response of
+              # this response, and so on.)
+              ASS.cast(info.reply_to,
+                       payload["method"],
+                       data, {
+                         :routing_key => info.routing_key,
+                         :message_id => info.message_id},
+                       payload["meta"])
+            end
+            info.ack if @ack
+          when :resend
+            # resend the same message
+            ASS.call(self.name,
+                     payload["method"],
+                     payload["data"], {
+                       :reply_to => info.reply_to, # this could be nil for cast
+                       :routing_key => info.routing_key,
+                       :message_id => info.message_id},
+                     payload["meta"])
+            info.ack if @ack
+          when :discard
+            # no response back to client
+            info.ack if @ack
+          when :error
+            # programmatic error. don't ack
+            error = result[1]
+            if callback_object.respond_to?(:on_error)
+              begin
+                callback_object.on_error(error,payload["data"])
+                info.ack if @ack # successful error handling
+              rescue => more_error
+                $stderr.puts more_error
+                $stderr.puts more_error.backtrace
+                ASS.stop
+              end
+            else
+              # unhandled error
+              $stderr.puts error
+              $stderr.puts error.backtrace
+              ASS.stop
+            end
+            # don't ack.
+          end
+        }
+        EM.defer operation, done
+      }.call
+
+      
+    end
+    self
+  end
+
+  # unsuscribe from the queue
+  def stop(&block) # allows callback
+    if block
+      @queue.unsubscribe(&block)
+    else
+      @queue.unsubscribe
+    end
+    @subscribed = false
+  end
+
+  def call(name,method,data,opts={},meta=nil)
+    reply_to = opts[:reply_to] || self.name
+    ASS.call(name,
+             method,
+             data,
+             opts.merge(:reply_to => reply_to),
+             meta)
+    
+  end
+
+  def cast(name,method,data,opts={},meta=nil)
+    reply_to = nil # the remote server will not reply
+    ASS.call(name,
+             method,
+             data,
+             opts.merge(:reply_to => nil),
+             meta)
+  end
+
+  def inspect
+    "#<#{self.class} #{self.name}>"
+  end
+
+  private
+
+  def with_handlers
+    not_discarded = false
+    not_resent = false
+    not_raised = false
+    result = nil
+    error = nil
+    catch(:__ass_discard) do
+      catch(:__ass_resend) do
+        begin
+          result = yield
+          not_raised = true
+        rescue => e
+          error = e
+        end
+        not_resent = true
+      end
+      not_discarded = true
+    end
+
+    if not_discarded && not_resent && not_raised
+      [:ok,result]
+    elsif not_discarded == false
+      [:discard]
+    elsif not_resent == false
+      [:resend] # resend original payload
+    elsif not_raised == false
+      [:error,error]
+    end
+  end
+end

data/lib/ass/topic.rb

@@ -0,0 +1,90 @@
+class ASS::Topic
+  class << self
+    def tunnel(name,opts={})
+      MQ.topic(name,opts)
+    end
+
+    def event(name,key,data,opts={})
+      ASS.dummy_exchange(name).publish(ASS.serializer.dump(data),
+                                       opts.merge(:routing_key => key))
+    end
+
+    def funnel(tunnel_name,funnel_name,key_matcher,&block)
+      # actor should respond to on_event(key,data)
+      funnel = Funnel.new(tunnel_name,funnel_name,key_matcher)
+      if block
+        funnel.react(&block)
+      end
+      funnel
+    end
+  end
+
+  class Funnel
+    def initialize(tunnel_name,funnel_name,key_matcher)
+      @funnel_name = funnel_name
+      @exchange = ASS.dummy_exchange(tunnel_name)
+      @matcher = key_matcher
+    end
+    
+    def queue(opts={})
+      unless @queue
+        @queue = MQ.queue(@funnel_name,opts)
+        @queue.bind(@exchange.name,
+                    opts.merge({ :key => @matcher }))
+      end
+      @queue
+    end
+
+    def react(callback=nil,opts={},&block)
+      callback = build_callback(callback || block)
+      me = self
+      self.queue.subscribe(opts) do |info,payload|
+        data = ASS.serializer.load(payload)
+        handler = callback.new
+        work = lambda {
+          begin
+            handler.send(:on_event,info.routing_key,data)
+          rescue => e
+            me.unhandled_error(e)
+          end
+        }
+        done = lambda { |_|
+          # nothing left to do
+        }
+        EM.defer work, done
+      end
+    end
+
+    def unhandled_error(e)
+      $stderr.puts e
+      $stderr.puts e.backtrace
+      ASS.stop
+      raise e
+    end
+
+    def build_callback(callback)
+      c = case callback
+          when Proc
+            Class.new &callback
+          when Class
+            callback
+          when Module
+            Class.new { include callback }
+          else
+            raise "can build topic callback from one of Proc, Class, Module"
+          end
+      raise "must react to on_event" unless c.public_method_defined?(:on_event)
+      c
+    end
+  end
+
+  
+  # def initialize(name,opts={})
+#     @exchange = MQ.topic(name,opts)
+#   end
+
+#   def publish(key,payload,opts={})
+#     @exchange.publish(::Marshal.dump(payload),opts.merge(:routing_key => key))
+#   end
+  
+end