class NebulousStomp::Request

Class to handle a request which returns a Message; the Question-Answer use case.

message   = NebulousStomp::Message.new(verb: "ping")
request   = NebulousStomp::Request.new(:target1, message)
response1 = request.send

This replaces the old NebRequest class; it’s much more clearly a wrapper for a Message, now.

Attributes

message[R]

The message we are sending (might not be the Message object you passed…)

redis_handler[W]
stomp_handler[R]

If you are testing you can write these with a test object like StompHandlerNull for example

target[R]

The Target object we are sending the request to

Public Class Methods

new(target, message) click to toggle source

Pass either a Target or a target name; and a Message (which has a verb)

# File lib/nebulous_stomp/request.rb, line 37
def initialize(target, message, logid="")
  @target  = parse_target(target)
  @message = parse_message(message, @target)
  @logid   = logid
  NebulousStomp.logger.debug(__FILE__) {log_helper "New Request for verb #{@message.verb}"}
end

Public Instance Methods

cache_timeout() click to toggle source

Returns the default cache timeout

# File lib/nebulous_stomp/request.rb, line 128
def cache_timeout
  Param.get(:cacheTimeout)
end
clear_cache → self click to toggle source

Clear the cache of responses to this request - just this request.

# File lib/nebulous_stomp/request.rb, line 109
def clear_cache
  return self unless NebulousStomp.redis_on?
  ensure_redis_connected
  redis_handler.del(@message.protocol_json)
  self
ensure
  redis_handler.quit
end
message_timeout() click to toggle source

Returns the default message timeout

# File lib/nebulous_stomp/request.rb, line 121
def message_timeout
  @target.message_timeout || Param.get(:messageTimeout)
end
send → (Message) click to toggle source
send(mTImeout) → (Message)
send(mtimeout,ctimeout) → (Message)

As send_nocache, but without not using the cache :)

Parameters:

* mtimeout -- Message timout in seconds; defaults to @mTimeout
* ctimeout -- Cache timout in seconds; defaults to @cTimeout

Raises ArgumentError, NebulousTimeout, NebulousError as necessary.

# File lib/nebulous_stomp/request.rb, line 88
def send(mtimeout=message_timeout, ctimeout=cache_timeout)
  return nil unless NebulousStomp.on?
  return send_no_cache(mtimeout) unless NebulousStomp.redis_on?
  ensure_redis_connected

  if (mess = cache_read).nil?
    mess = send_no_cache(mtimeout)
    cache_write(mess, ctimeout)
  end

  mess
ensure
  redis_handler.quit
end
send_no_cache → (Message) click to toggle source
send_no_cache(mtimeout) → (Message)

Send a request and return the response, without using the cache.

Parameters:

* mTimeout -- Message timout in seconds; defaults to #message_timeout

Raises ArgumentError, 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.

# File lib/nebulous_stomp/request.rb, line 64
def send_no_cache(mtimeout=message_timeout)
  return nil unless NebulousStomp.on?
  NebulousStomp.logger.info(__FILE__) {log_helper "Sending request to target #{@target.name}"}

  ensure_stomp_connected
  neb_qna(mtimeout)
ensure
  stomp_handler.stomp_disconnect(@logid)
end
stomp_handler=(handler) click to toggle source
# File lib/nebulous_stomp/request.rb, line 44
def stomp_handler=(handler)
  @stomp_handler = handler
  ensure_stomp_connected # so that we get a reply_id on the message ASAP.
end

Private Instance Methods

cache_read() click to toggle source

Read from the Redis cache

# File lib/nebulous_stomp/request.rb, line 203
def cache_read
  found = redis_handler.get(@message.protocol_json)
  found.nil? ? nil : Message.from_cache(found)
end
cache_write(response, timeout) click to toggle source

Write to the Redis cache

# File lib/nebulous_stomp/request.rb, line 211
def cache_write(response, timeout)
  redis_handler.set(@message.protocol_json, response.to_h.to_json, ex: timeout)
end
ensure_redis_connected() click to toggle source

Connect to Redis

# File lib/nebulous_stomp/request.rb, line 174
def ensure_redis_connected
  redis_handler.connect unless redis_handler.connected?
end
ensure_stomp_connected() click to toggle source

Connect to Stomp If we’ve lost the connection then reconnect but *keep replyID*

# File lib/nebulous_stomp/request.rb, line 166
def ensure_stomp_connected
  stomp_handler.stomp_connect(@logid) unless stomp_handler.connected?
  @message.reply_id = stomp_handler.calc_reply_id if @message.reply_id.nil? 
end
log_helper(message) click to toggle source
# File lib/nebulous_stomp/request.rb, line 217
def log_helper(message)
  "[#{@logid}|#{Thread.object_id}] #{message}"
end
neb_qna(mTimeout) click to toggle source

Send a message via STOMP and wait for a response

# File lib/nebulous_stomp/request.rb, line 181
def neb_qna(mTimeout)
  stomp_handler.send_message(@target.receive_queue, @message, @logid)

  NebulousStomp.logger.debug(__FILE__) {log_helper "Looking for #{@message.reply_id}"}

  response = nil
  stomp_handler.listen_with_timeout(@target.send_queue, mTimeout, @logid) do |msg|
    if @message.reply_id && msg.in_reply_to != @message.reply_id
      false
    else
      response = msg
      true
    end
  end
  NebulousStomp.logger.debug(__FILE__) {log_helper "Got response: #{response}"}

  response
end
parse_message(message, target) click to toggle source

Helper routine for initialize

# File lib/nebulous_stomp/request.rb, line 145
def parse_message(message, target)
  fail ArgumentError, "Message was not a Message"    unless message.is_a? Message
  fail ArgumentError, "Message does not have a verb" unless message.verb

  new_message = ->(h){ Message.new(message.to_h.merge h) }
  message.reply_to ? message : new_message.(replyTo: target.send_queue)
end
parse_target(target) click to toggle source

Helper routine for initialize

# File lib/nebulous_stomp/request.rb, line 156
def parse_target(target)
  t = target.is_a?(Target) ? target : Param.get_target(target)
  fail ArgumentError, "Target was not a Target or a target name" unless t
  t
end
redis_handler() click to toggle source
# File lib/nebulous_stomp/request.rb, line 138
def redis_handler
  @redis_handler ||= RedisHandler.new(Param.get :redisConnectHash)
end