nebulous_stomp 1.1.5

data/lib/nebulous/nebrequest.rb

@@ -0,0 +1,254 @@
+# coding: UTF-8
+
+require 'nebulous'
+
+require_relative 'stomp_handler'
+require_relative 'redis_handler'
+require_relative 'message'
+
+
+module Nebulous
+
+
+  ##
+  # Class to handle a request which returns a Message
+  #
+  # Note that this has changed since 0.1.0. The principal difference is we
+  # return a Nebulous::Message; the NebResponse class no longer exists.
+  #
+  class NebRequest
+
+    
+    # The target name as set up by call to Nebulous::add_target
+    attr_reader :target
+    
+    # The 'verb' part of the message
+    attr_reader :verb      
+    
+    # The 'parameters' part of the message
+    attr_reader :params    
+
+    # The 'description' part of the message
+    attr_reader :desc
+    
+    # The 'replyID' header to use in this message 
+    attr_reader :replyID
+
+    # Message timeout in seconds
+    attr_reader :mTimeout
+
+    # Cache timeout (fade and forget) in seconds
+    attr_reader :cTimeout
+
+    # The message
+    attr_reader :message
+
+    # The STOMP queue to send the request to
+    attr_reader :requestQ
+
+    # The STOMP queue to listen for responses on
+    attr_reader :responseQ
+
+
+    ##
+    # :call-seq:
+    #   NebRequest.new(target, verb) 
+    #   NebRequest.new(target, verb, params) 
+    #   NebRequest.new(target, verb, params, desc) 
+    #
+    # Create a new request. Raises Nebulous::NebulousError if anything goes
+    # wrong.
+    #
+    # Parameters:
+    #  target [Symbol] the target name to send the request to
+    #  verb   [String] the 'verb' part of the message
+    #  params [String] the 'parameters' part of the message
+    #  desc   [String] the 'description' part of the message
+    #  stompHandler    ONLY FOR TESTING
+    #  redisHandler    ONLY FOR TESTING
+    #
+    def initialize( target, 
+                    verb, 
+                    params=nil, 
+                    desc=nil, 
+                    stompHandler=nil, 
+                    redisHandler=nil )
+
+      Nebulous.logger.debug(__FILE__) {"New NebRequest for verb #{verb}"}
+
+      @target        = target.to_s
+      @verb          = verb.to_s
+      @params        = params.nil? ? nil : params.to_s
+      @desc          = desc.nil?   ? nil : desc.to_s
+      @stomp_handler = stompHandler 
+      @redis_handler = redisHandler 
+      @requestQ      = nil
+      @responseQ     = nil
+      @message       = nil
+      @replyID       = nil
+      @mTimeout      = 0
+      @cTimeout      = 0
+
+      @redis_handler ||= RedisHandler.new( Param.get(:redisConnectHash) )
+      @stomp_handler ||= StompHandler.new( Param.get(:stompConnectHash) )
+
+      neb_connect if nebulous_on?
+    end
+
+
+    ##
+    # :call-seq:
+    #     request.send_no_cache           -> (Message)
+    #     request.send_no_cache(mTimeout) -> (Message)
+    #
+    # Send a request and return the response, without using the cache.
+    #
+    # Parameters:
+    #  mTimeout [Fixnum] Message timout in seconds - defaults to @mTimeout
+    #
+    # Raises NebulousTimeout or NebulousError as necessary.
+    #
+    # Note that this routine completely ignores Redis. It doesn't just not
+    # check the cache; it also doesn't update it.
+    #
+    def send_no_cache(mTimeout=@mTimeout)
+      return nil unless nebulous_on?
+
+      # If we've lost the connection then reconnect but *keep replyID*
+      @stomp_handler.stomp_connect unless @stomp_handler.connected?
+      @replyID = @stomp_handler.calc_reply_id if @replyID.nil? 
+
+      neb_qna(mTimeout)
+
+    ensure
+      @stomp_handler.stomp_disconnect if @stomp_handler
+    end
+
+
+    ##
+    # ::call-seq::
+    #     request.send                    -> (Message)
+    #     request.send(mTimeout)          -> (Message)
+    #     request.send(mTimeout,cTimeout) -> (Message)
+    #
+    # As send_nocache, but without not using the cache :)
+    #
+    # Parameters:
+    #  mTimeout  [Fixnum] Message timout in seconds - defaults to @mTimeout
+    #  cTimeout  [Fixnum] Cache timout in seconds - defaults to @cTimeout
+    #
+    # Raises NebulousTimeout, NebulousError as necessary.
+    #
+    # We use Redis for the cache. This is possibly like using a sledgehammer
+    # to crack a nut, but it certainly makes things very simple.
+    #
+    def send(mTimeout=@mTimeout, cTimeout=@cTimeout)
+      return nil unless nebulous_on?
+      return send_no_cache(mTimeout) unless redis_on?
+
+      @redis_handler.connect unless @redis_handler.connected?
+
+      found = @redis_handler.get(@message.protocol_json)
+      return Message.from_cache(found) unless found.nil?
+
+      # No answer in Redis -- ask Nebulous
+      nebMess = send_no_cache(mTimeout)
+      @redis_handler.set(@message.protocol_json, nebMess.to_cache, ex: cTimeout)
+
+      nebMess
+
+    ensure
+      @redis_handler.quit if @redis_handler
+    end
+
+
+    ##
+    # :call-seq:
+    #   request.clear_cache -> self
+    #
+    # Clear the cache of responses to this request - just this request.
+    #
+    def clear_cache
+      return self unless redis_on?
+      @redis_handler.connect unless @redis_handler.connected?
+      @redis_handler.del(@message.protocol_json)
+
+      self
+
+    ensure
+      @redis_handler.quit if @redis_handler
+    end
+
+
+    ##
+    # :call-seq:
+    #   request.redis_on? -> (boolean)
+    #
+    # Return true if Redis is turned on in the *config*
+    #
+    # (If you want to know if we are conected to Redis, try
+    # `@redis_handler.connected?`)
+    #
+    def redis_on?
+      @redis_handler && @redis_handler.redis_on?
+    end
+
+
+    ##
+    # :call-seq:
+    #   request.nebulous_on? -> (boolean)
+    #
+    # Return true if Nebulous is turned on in the *config*
+    #
+    def nebulous_on?
+      @stomp_handler && @stomp_handler.nebulous_on?
+    end
+
+
+    private
+
+
+    ##
+    # Connect to STOMP etc and do initial setup
+    # Called automatically by initialize, if Nebulous is 'on' in the config.
+    #
+    def neb_connect
+      targetHash = Param.get_target(@target)
+      raise NebulousError, "Unknown target #{target}" if targetHash.nil?
+
+      @cTimeout  = Param.get(:cacheTimeout)
+      @mTimeout  = targetHash[:messageTimeout] || Param.get(:messageTimeout)
+      @requestQ  = targetHash[:sendQueue]
+      @responseQ = targetHash[:receiveQueue]
+      @message   = Message.from_parts(@responseQ, nil, verb, params, desc)
+
+      @stomp_handler.stomp_connect
+      @replyID = @stomp_handler.calc_reply_id
+
+      self
+    end
+
+    
+    ##
+    # Send a message via STOMP and wait for a response
+    #
+    # Note: this used to return a Stomp::Message, but now it returns a
+    # Nebulous::Message.
+    #
+    def neb_qna(mTimeout)
+      @stomp_handler.send_message(@requestQ, @message)
+
+      response = nil
+      @stomp_handler.listen_with_timeout(@responseQ, mTimeout) do |msg|
+        response = msg
+      end
+
+      response
+    end
+
+
+  end # of NebRequest
+
+
+end
+

data/lib/nebulous/nebrequest_null.rb

@@ -0,0 +1,39 @@
+# coding: UTF-8
+
+require 'nebulous'
+
+require_relative 'nebrequest'
+require_relative 'stomp_handler_null'
+require_relative 'redis_handler_null'
+
+
+module Nebulous
+
+
+  ## 
+  # Class to fake a NebRequest
+  #
+  class NebRequestNull < NebRequest
+
+    def initialize( target, verb, params=nil, desc=nil )
+      sh = StompHandlerNull.new( Param.get(:stompConnectHash) )
+      rh = RedisHandlerNull.new( Param.get(:redisConnectHash) )
+      super(target, verb, params, desc, sh, rh)
+    end
+
+
+    def insert_fake_stomp(message)
+      @stomp_handler.insert_fake(message)
+    end
+
+
+    def insert_fake_redis(key, value)
+      @redis_handler.insert_fake(key, value)
+    end
+
+
+  end 
+
+
+end
+

data/lib/nebulous/param.rb

@@ -0,0 +1,139 @@
+# coding: UTF-8
+
+
+module Nebulous
+
+
+  ##
+  # 'Singleton' 'object' that stores parameters.
+  #
+  module Param
+    extend self
+
+
+    # Default parameters hash
+    ParamDefaults = { stompConnectHash: {},
+                      redisConnectHash: {},
+                      messageTimeout:   10,
+                      cacheTimeout:     120,
+                      logger:           nil,
+                      targets:          {} }
+
+    # Default hash for each target
+    TargetDefaults = { sendQueue:      nil,
+                       receiveQueue:   nil,
+                       messageTimeout: nil }
+
+
+    ##
+    # Set the initial parameter string. This also has the effect of resetting
+    # everything. 
+    #
+    # Parameters default to Param::ParamDefaults. keys passed in parameter p to
+    # ovveride those defaults must match, or a NebulousError will result.
+    #
+    # This method is only called by Nebulous::init().
+    #
+    def set(p={})
+      raise NebulousError, "Invalid initialisation hash" unless p.kind_of?(Hash)
+
+      validate(ParamDefaults, p, "Unknown initialisation hash")
+
+      @params = ParamDefaults.merge(p)
+    end
+
+
+    ##
+    # Add a Nebulous target.  Raises NebulousError if anything looks screwy.
+    #
+    # Parameters:
+    #  n -- target name
+    #  t -- hash, which must follow the pattern set by Param::TargetDefaults
+    #
+    # Used only by Nebulous::init
+    #
+    def add_target(n, t)
+      raise NebulousError, "Invalid target hash" unless t.kind_of?(Hash)
+
+      validate(TargetDefaults, t, "Unknown target hash")
+
+      raise NebulousError, "Config Problem - Target missing 'send'" \
+        if t[:sendQueue].nil?
+
+      raise NebulousError, "Config Problem - Target missing 'receive'" \
+        if t[:receiveQueue].nil?
+
+      @params ||= ParamDefaults
+      @params[:targets][n.to_sym] = TargetDefaults.merge(t)
+    end
+
+
+
+    ##
+    # Set a logger instance
+    #
+    def set_logger(lg)
+      raise NebulousError unless lg.kind_of?(Logger) || lg.nil?
+      @logger = lg
+    end
+
+
+    ##
+    # Get the logger instance
+    #
+    def get_logger; @logger; end
+
+
+    ##
+    # Get the whole parameter hash. Probably only useful for testing.
+    #
+    def get_all()
+      @params
+    end
+
+
+    ##
+    # Get a the value of the parameter with the key p.
+    #
+    def get(p)
+      @params ||= ParamDefaults
+      @params[p.to_sym]
+    end
+
+
+    ##
+    # Given a target name, return the corresponding target hash 
+    #
+    def get_target(name)
+      t = Param.get(:targets)
+      x = (t && t.kind_of?(Hash)) ? t[name.to_sym] : nil
+
+      raise NebulousError, "Config problem - unknown target #{name}" if x.nil?
+      return x
+    end
+
+
+    ##
+    # Raise an exception if a hash has any keys not found in an exemplar
+    #
+    # (Private method, only called within Param)
+    #
+    def validate(exemplar, hash, message)
+      hash.each_key do |k|
+        raise NebulousError, "#{message} key '#{k}'" unless exemplar.include?(k)
+      end
+    end
+
+
+    ##
+    # reset all parameters -- probably only useful for testing
+    #
+    def reset
+      @params = nil
+      @logger = nil
+    end
+
+
+  end
+end
+

data/lib/nebulous/redis_handler.rb

@@ -0,0 +1,103 @@
+# coding: UTF-8
+
+require 'redis'
+
+
+module Nebulous
+
+
+  ##
+  # A class to deal with talking to Redis via the Redis gem
+  # 
+  class RedisHandler
+
+    # This is most likely useless to anything except spec/redis_handler_spec --
+    # at least, I hope so...
+    attr_reader :redis
+
+
+    ##
+    # Initialise an instance of the handler by passing it the connection hash
+    #
+    # We use the optional testRedis parameter to mock connections to Redis, for
+    # testing. It's probably of no use to anyone else.
+    #
+    def initialize(connectHash, testRedis=nil)
+      @redis_hash = connectHash ? connectHash.dup : nil
+      @test_redis = testRedis 
+      @redis      = nil
+    end
+
+
+    ##
+    # Connect to the Redis key/value store. Raise Nebulous error if connection
+    # fails. 
+    #
+    def connect
+      @redis = @test_redis || Redis.new(@redis_hash.dup)
+
+      @redis.client.connect
+      raise ConnectionError, "Redis Connection failed" unless @redis.connected?
+
+      self
+
+    rescue => err
+      raise ConnectionError, err.to_s
+    end
+
+
+    ##
+    # :call-seq:
+    #   handler.connected? -> (boolean)
+    #
+    # Call @redis.quit if appropriate; raise nothing if we are not connected etc
+    #
+    def quit
+      @redis.quit if connected?
+      @redis = nil
+      self
+    end
+
+    
+    ##
+    # return whether we are connected to Redis.
+    #
+    def connected?
+      @redis && @redis.connected?
+    end
+
+
+    ##
+    # :call-seq:
+    #   handler.redis_on? -> (boolean)
+    #
+    # Return whether the Redis is turned "on" in the connect hash, the config
+    # file.
+    #
+    # The rest of nebulous should just let RedisHandler worry about this
+    # detail.
+    #
+    def redis_on?
+      @redis_hash && !@redis_hash.empty?
+    end
+
+
+
+    ##
+    # Cover all the other methods on @redis that we are basically forwarding to
+    # it. I could use Forwardable here -- except that would not allow us to
+    # raise Nebulous::ConnectionError if @redis.nil?
+    #
+    def method_missing(meth, *args)
+      super unless [:set,:get,:del].include?(meth)
+
+      raise ConnectionError, "Redis not connected, sent #{meth}" \
+        unless connected?
+
+      @redis.__send__(meth, *args)
+    end
+
+  end 
+
+  
+end

data/lib/nebulous/redis_handler_null.rb

@@ -0,0 +1,61 @@
+# coding: UTF-8
+
+require 'redis'
+require 'json'
+
+require_relative 'redis_handler'
+
+
+module Nebulous
+
+
+  ##
+  # Behaves just like RedisHandler, except, does nothing and expects no
+  # connection to Redis.
+  #
+  # This is hopefully useful for testing -- if only for testing of Nebulous.
+  # 
+  class RedisHandlerNull < RedisHandler
+
+    attr_reader :fake_pair
+
+
+    def initialize(connectHash={})
+      super
+      @fake_pair = {}
+    end
+
+
+    def insert_fake(key, value)
+      @fake_pair = { key => value }
+    end
+
+
+    def connect
+      @redis = true
+      self
+    end
+
+
+    def quit
+      @redis = nil
+      self
+    end
+
+    
+    def connected?
+      @fake_pair != {}
+    end
+
+
+    def set(key, value, hash=nil); insert_fake(key, value); end
+
+    def del(key); @fake_pair = {}; end
+
+    def get(key); @fake_pair.values.first; end
+
+
+  end 
+
+  
+end