ASS 0.1.0

data/lib/ass/amqp.rb

@@ -0,0 +1,19 @@
+
+# monkey patch to the amqp gem that adds :no_declare => true option for new 
+# Exchange objects. This allows us to send messeages to exchanges that are
+# declared by the mappers and that we have no configuration priviledges on.
+# temporary until we get this into amqp proper
+MQ::Exchange.class_eval do
+  def initialize mq, type, name, opts = {}
+    @mq = mq
+    @type, @name, @opts = type, name, opts
+    @mq.exchanges[@name = name] ||= self
+    @key = opts[:key]
+
+    @mq.callback{
+      @mq.send AMQP::Protocol::Exchange::Declare.new({ :exchange => name,
+                                                 :type => type,
+                                                 :nowait => true }.merge(opts))
+    } unless name == "amq.#{type}" or name == ''  or opts[:no_declare]
+  end
+end

data/lib/ass/callback_factory.rb

@@ -0,0 +1,95 @@
+class ASS::CallbackFactory
+
+  module ServiceMethods
+    def resend
+      throw(:__ass_resend)
+    end
+    
+    def discard
+      throw(:__ass_discard)
+    end
+    
+    def header
+      @__header__
+    end
+
+    def payload
+      @__payload__
+    end
+
+    def method
+      @__method__
+    end
+
+    def data
+      @__data__
+    end
+
+    def meta
+      @__meta__
+    end
+
+    def version
+      @__version__
+    end
+
+    def call(name,method,data=nil,opts={},meta=nil)
+      @__service__.call(name,method,data,opts,meta)
+    end
+
+    def cast(name,method,data=nil,opts={},meta=nil)
+      @__service__.cast(name,method,data,opts,meta)
+    end
+  end
+  
+  def initialize(callback)
+    @factory = build_factory(callback)
+  end
+
+  def callback_for(server,header,payload)
+    # method,data
+    if @factory.is_a? Class
+      if @factory.respond_to? :version
+        klass = @factory.get_version(payload[:version])
+      else
+        klass = @factory
+      end
+      obj = klass.new
+    else
+      obj = @factory
+    end
+    obj.instance_variable_set("@__service__",server)
+    obj.instance_variable_set("@__header__",header)
+    obj.instance_variable_set("@__payload__",payload)
+    obj.instance_variable_set("@__method__",payload[:method])
+    obj.instance_variable_set("@__data__",payload[:data])
+    obj.instance_variable_set("@__meta__",payload[:meta])
+    obj.instance_variable_set("@__version__",payload[:version])
+    obj
+  end
+
+  private
+
+  def build_factory(callback)
+    c = case callback
+        when Proc
+          Class.new &callback
+        when Class
+          callback
+        when Module
+          Class.new { include callback }
+        else
+          raise "can build factory from one of Proc, Class, Module"
+        end
+    case c
+    when Class
+      c.instance_eval { include ServiceMethods }
+    else
+      c.extend ServiceMethods
+    end
+    c
+  end
+  
+
+  
+end

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/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 = ::Marshal.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