nebulous_stomp 2.0.2 → 3.0.0

data/lib/nebulous_stomp/msg/body.rb

@@ -0,0 +1,169 @@
+require 'json'
+
+require_relative '../stomp_handler'
+
+
+module NebulousStomp
+  module Msg
+
+
+    ## 
+    # A class to encapsulate a Nebulous message body - helper class for Message
+    #
+    class Body
+
+      # Might be nil: only caught on messages that came directly from STOMP.
+      attr_reader :stomp_body
+
+      # The Nebulous Protocol
+      attr_reader :verb, :params, :desc
+
+      # Will be a hash for messages that follow The Protocol; anything at all otherwise.
+      attr_reader :body
+
+      ##
+      # is_json should be a boolean, true if the body is JSON-encoded.
+      # If it is false then we assume that we are coded like STOMP headers, in lines of text.
+      #
+      def initialize(is_json, hash)
+        @is_json    = !!is_json
+        @stomp_body = hash[:stompBody]
+        @body       = hash[:body]
+        @verb       = hash[:verb]
+        @params     = hash[:parameters] || hash[:params] 
+        @desc       = hash[:description] || hash[:desc]
+
+        fill_from_stomp
+      end
+
+      ##
+      # Output a the body part of the hash for serialization to the cache.
+      #
+      # Since the body could be quite large we only set :body if there is no @stomp_body. We
+      # recreate the one from the other anyway.
+      #
+      def to_h
+        { stompBody: @stomp_body,
+          body:      @stomp_body ? nil : body,
+          verb:      @verb,
+          params:    @params.kind_of?(Enumerable) ? @params.dup : @params,
+          desc:      @desc }
+        
+      end
+
+      ##
+      # Return a body object for the Stomp gem
+      #
+      def body_for_stomp
+
+        case 
+          when @is_json
+            @body.to_json
+          when @body.is_a?(Hash)
+            @body.map{|k,v| "#{k}: #{v}" }.join("\n") << "\n\n"
+          else
+            @body.to_s
+        end
+
+      end
+
+      ##
+      # Return the message body formatted for The Protocol, in JSON.
+      #
+      # Raise an exception if the message body doesn't follow the protocol.
+      #
+      # (We use this as the key for the Redis cache)
+      #
+      def protocol_json
+        fail NebulousError, "no protocol in this message!" unless @verb
+        protocol_hash.to_json
+      end
+
+      private
+
+      ##
+      # Return The Protocol of the message as a hash.
+      #
+      def protocol_hash
+        { verb:        @verb,
+          parameters:  @params,
+          description: @desc   }.delete_if{|_,v| v.nil? }
+        
+      end
+
+      ##
+      # Fill all the other attributes, if we can.
+      #
+      # Note that we confusingly store @verb, @params, & @desc (The Protocol, which if present is
+      # the message body); @body (the message body); and @stomp_body (the original body from the
+      # stomp message if we were created from one). Any of these could be passed in the initialize
+      # hash.
+      #
+      # The rule is that we always prioritize them in that order. If we are passed a @verb, then
+      # the Protocol fields go into @body; otherwise if set we take @body as it stands; otherwise
+      # we try and decode @stomp_body and set that in @body.
+      #
+      # NB: We never overwrite @stomp_body. If not passed to us, it stays nil. It's only stored in
+      # case we can't decode it, as a fallback.
+      #
+      def fill_from_stomp
+
+        if @verb
+          @body = protocol_hash
+        elsif @body.nil? || @body.respond_to?(:empty?) && @body.empty?
+          @body = parse_stomp_body 
+        end
+
+        parse_body
+
+        # Assume that if verb is missing, the other two are just part of a
+        # response which has nothing to do with the protocol
+        @params = @desc = nil unless @verb
+
+        self
+      end
+
+      def parse_stomp_body
+        case
+          when @stomp_body.nil? then nil
+          when @is_json         then stomp_body_from_json
+          else 
+            stomp_body_from_text
+            
+        end
+      end
+
+      def stomp_body_from_json
+        JSON.parse(@stomp_body)
+      rescue JSON::ParserError, TypeError
+        # If we can't parse it, fine, take it as a text blob
+        @stomp_body.to_s
+      end
+
+      def stomp_body_from_text
+        lines = @stomp_body.to_s.split("\n").reject{|s| s =~ /^\s*$/ }
+        hash  = {}
+
+        lines.each do |line|
+          k,v = line.split(':', 2).each{|x| x.strip! }
+          hash[k] = v if line.include?(':')
+        end
+
+        # If there are any lines we could not parse, forget the whole thing and return a text blob
+        (lines.size > hash.keys.size) ? @stomp_body.to_s : hash
+      end
+
+      def parse_body
+        if @body.is_a?(Hash)
+          @verb   ||= @body["verb"]
+          @params ||= @body["parameters"]  || @body["params"]
+          @desc   ||= @body["description"] || @body["desc"]
+        end
+      end
+
+
+    end # Message::Body
+
+
+  end
+end

data/lib/nebulous_stomp/msg/header.rb

@@ -0,0 +1,98 @@
+require 'json'
+
+require_relative '../stomp_handler'
+
+
+module NebulousStomp
+  module Msg
+
+
+    ## 
+    # A class to encapsulate a Nebulous message header - a helper class for Message
+    #
+    class Header
+
+      # Might be nil: parsed from incoming messages; set by StompHandler on send
+      attr_accessor :reply_id
+
+      # Might be nil: only caught on messages that came directly from STOMP
+      attr_reader :stomp_headers
+      
+      # The content type of the message
+      attr_reader :content_type
+
+      # From The Nebulous Protocol
+      attr_reader :reply_to, :in_reply_to 
+
+      ##
+      #
+      def initialize(hash)
+        @stomp_headers = hash[:stompHeaders]
+        @reply_to      = hash[:replyTo]
+        @reply_id      = hash[:replyId]
+        @in_reply_to   = hash[:inReplyTo]
+        @content_type  = hash[:contentType]
+        
+        # If we have no stomp headers then we (probably correctly) assume that this is a user
+        # created message, and default the content type to JSON.
+        @content_type = 'application/json' if @stomp_headers.nil? && @content_type.nil?
+
+        fill_from_stomp
+      end
+
+      ##
+      # true if the content type appears to be JSON-y
+      #
+      def content_is_json?
+        @content_type =~ /json$/i ? true : false
+      end
+
+      ##
+      # Output a the header part of the hash for serialization to the cache.
+      #
+      def to_h
+        { stompHeaders: @stomp_headers,
+          replyTo:      @reply_to,
+          replyId:      @reply_id,
+          inReplyTo:    @in_reply_to,
+          contentType:  @content_type }
+
+      end
+
+      ##
+      # Return the hash of additional headers for the Stomp gem
+      #
+      def headers_for_stomp
+        { "content-type"    => @content_type, 
+          "neb-reply-id"    => @reply_id,
+          "neb-reply-to"    => @reply_to,
+          "neb-in-reply-to" => @in_reply_to }
+        
+      end
+
+      private
+
+      ##
+      # Fill all the other attributes, if you can, from @stomp_headers
+      #
+      def fill_from_stomp
+        return unless @stomp_headers
+
+        type = @stomp_headers["content-type"] || @stomp_headers[:'content-type'] \
+            || @stomp_headers["content_type"] || @stomp_headers[:content_type]   \
+            || @stomp_headers["contentType"]  || @stomp_headers[:contentType]
+        
+        @content_type ||= type
+        @reply_id     ||= @stomp_headers['neb-reply-id']
+        @reply_to     ||= @stomp_headers['neb-reply-to'] 
+        @in_reply_to  ||= @stomp_headers['neb-in-reply-to']
+
+        self
+      end
+
+    end # of Header
+
+
+  end
+end
+

data/lib/nebulous_stomp/param.rb

@@ -1,3 +1,6 @@
+require_relative 'target'
+
+
 module NebulousStomp
 
 
@@ -7,7 +10,6 @@ module NebulousStomp
   module Param
     extend self
 
-
     # Default parameters hash
     ParamDefaults = { stompConnectHash: {},
                       redisConnectHash: {},
@@ -21,66 +23,50 @@ module NebulousStomp
                        receiveQueue:   nil,
                        messageTimeout: nil }
 
-
     ##
-    # Set the initial parameter string. This also has the effect of resetting
-    # everything. 
+    # 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.
+    # Parameters default to Param::ParamDefaults. keys passed in parameter p to override 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)
+      fail 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
+    #    * t -- a Target
     #
     # 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?
+    def add_target(t)
+      fail NebulousError, "Invalid target" unless t.kind_of?(Target)
 
       @params ||= ParamDefaults
-      @params[:targets][n.to_sym] = TargetDefaults.merge(t)
+      @params[:targets][t.name.to_sym] = t
     end
 
-
-
     ##
     # Set a logger instance
     #
     def set_logger(lg)
-      raise NebulousError unless lg.kind_of?(Logger) || lg.nil?
+      fail 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.
     #
@@ -88,7 +74,6 @@ module NebulousStomp
       @params
     end
 
-
     ##
     # Get a the value of the parameter with the key p.
     #
@@ -97,18 +82,15 @@ module NebulousStomp
       @params[p.to_sym]
     end
 
-
     ##
-    # Given a target name, return the corresponding target hash 
+    # Given a target name, return the corresponding Target object
     #
     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
+      (t && t.kind_of?(Hash)) ? t[name.to_s.to_sym] : nil
     end
 
+    private
 
     ##
     # Raise an exception if a hash has any keys not found in an exemplar
@@ -117,11 +99,10 @@ module NebulousStomp
     #
     def validate(exemplar, hash, message)
       hash.each_key do |k|
-        raise NebulousError, "#{message} key '#{k}'" unless exemplar.include?(k)
+        fail NebulousError, "#{message} key '#{k}'" unless exemplar.include?(k)
       end
     end
 
-
     ##
     # reset all parameters -- probably only useful for testing
     #

data/lib/nebulous_stomp/redis_handler.rb

@@ -6,48 +6,44 @@ module NebulousStomp
 
   ##
   # A class to deal with talking to Redis via the Redis gem
+  #
+  # You shouldn't need to instantiate this yourself. If you want to use NebulousStomp to talk to
+  # redis directly, try NebulousStomp::RedisHelper.
   # 
   class RedisHandler
 
-    # This is most likely useless to anything except spec/redis_handler_spec --
-    # at least, I hope so...
+    # 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
     #
     # If no hash is passed, we try and get it from Nebulous::Params
     #
-    # We use the optional testRedis parameter to mock connections to Redis, for
-    # testing. It's probably of no use to anyone else.
+    # 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=nil, testRedis=nil)
-      @redis_hash   = connectHash ? connectHash.dup : nil
-      @redis_hash ||= Param.get(:redisConnectHash)
-
+      @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. 
+    # 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?
+      fail ConnectionError, "Redis Connection failed" unless @redis.connected?
 
       self
-
     rescue => err
       raise ConnectionError, err.to_s
     end
 
-
     ##
     # :call-seq:
     #   handler.connected? -> (boolean)
@@ -60,7 +56,6 @@ module NebulousStomp
       self
     end
 
-    
     ##
     # return whether we are connected to Redis.
     #
@@ -68,38 +63,33 @@ module NebulousStomp
       @redis && @redis.connected?
     end
 
-
     ##
     # :call-seq:
     #   handler.redis_on? -> (boolean)
     #
-    # Return whether the Redis is turned "on" in the connect hash, the config
-    # file.
+    # 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.
+    # 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?
+    # 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?
+    #
+    # Possible candidates for future inclusion: exists, expire, ping
     #
     def method_missing(meth, *args)
       super unless [:set,:get,:del].include?(meth)
-
-      raise ConnectionError, "Redis not connected, sent #{meth}" \
-        unless connected?
+      fail ConnectionError, "Redis not connected, sent #{meth}" unless connected?
 
       @redis.__send__(meth, *args)
     end
 
-  end 
+  end # RedisHandler
 
   
 end

data/lib/nebulous_stomp/redis_handler_null.rb

@@ -6,7 +6,6 @@ require_relative 'redis_handler'
 
 module NebulousStomp
 
-
   ##
   # Behaves just like RedisHandler, except, does nothing and expects no
   # connection to Redis.
@@ -17,41 +16,43 @@ module NebulousStomp
 
     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)
+      "OK"
+    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
+    def del(key)
+      x = @fake_pair.empty? ? 0 : 1
+      @fake_pair = {}
+      x
+    end
 
+    def get(key)
+      @fake_pair.values.first
+    end
 
   end 
 

data/lib/nebulous_stomp/redis_helper.rb

@@ -0,0 +1,110 @@
+require 'json'
+
+require_relative '../nebulous_stomp'
+
+
+module NebulousStomp
+
+
+  ##
+  # A class to help out users who want to talk to Redis themselves; the "Redis use case".
+  #
+  #    redis = NebulousStomp::RedisHelper.new
+  #    
+  #    redis.set(:thing, "thingy")
+  #    redes.set(:gone_in_30_seconds, "thingy", 30)
+  #    
+  #    value = redis.get(:thing)
+  #    
+  #    redis.del(:thing)
+  # 
+  class RedisHelper
+
+    # For testing only
+    attr_writer :redis_handler
+
+    ##
+    # :call-seq:
+    # RedisHelper.new -> (helper)
+    #
+    def initialize
+      @param_hash = Param.get(:redisConnectHash)
+
+      fail NebulousError, "NebulousStomp.init has not been called or Redis not configured" \
+        if @param_hash.nil? || @param_hash.empty?
+
+    end
+
+    ##
+    # :call-seq: 
+    # redis.set(key, value)
+    # redis.set(key, value, timeout)
+    #
+    # Set a value in the store.
+    #
+    def set(key, value, timeout=nil)
+      rtimeout = (Integer(timeout.to_s, 10) rescue nil)
+      rvalue   = value_to_json(value)
+      fail ArgumentError, "Timeout must be a number" if timeout && rtimeout.nil?
+      ensure_connected
+
+      if timeout
+        redis_handler.set(key.to_s, rvalue, ex: rtimeout)
+      else
+        redis_handler.set(key.to_s, rvalue)
+      end
+
+      self
+    end
+
+    ##
+    # :call-seq: 
+    # redis.get(key) -> value
+    #
+    # Get a string value from the store. Return nil if there is none.
+    #
+    def get(key)
+      ensure_connected
+      json_to_value(redis_handler.get key.to_s)
+    end
+
+    ##
+    # :call-seq: 
+    # redis.del(key)
+    #
+    # Remove a value from the store. Raise an exception if there is none.
+    #
+    def del(key)
+      ensure_connected
+      num = redis_handler.del(key.to_s)
+      fail ArgumentError, "Unknown key, cannot delete" if num == 0
+    end
+
+    private
+
+    def redis_handler
+      @redis_handler ||= RedisHandler.new(Param.get :redisConnectHash)
+    end
+
+    def ensure_connected
+      redis_handler.connect unless redis_handler.connected?
+    end
+
+    def value_to_json(value)
+      { value: value}.to_json
+    end
+
+    def json_to_value(json)
+      return nil if json.nil?
+      hash = JSON.parse(json, symbolize_names: true)
+
+      hash.is_a?(Hash) ? hash[:value] : nil
+    rescue JSON::ParserError
+      return nil
+    end
+
+  end # RedisHelper
+
+
+end
+