Class: NebulousStomp::Request

Inherits:
Object
  • Object
show all
Defined in:
lib/nebulous_stomp/request.rb

Overview

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.

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(target, message, logid = "") ⇒ Request

:call-seq:

Request.new(target, message)

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



37
38
39
40
41
42
 
# 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

Instance Attribute Details

#message ⇒ Object (readonly)

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



25
26
27
 
# File 'lib/nebulous_stomp/request.rb', line 25

def message
  @message
end

#redis_handler=(value) ⇒ Object

Sets the attribute redis_handler

Parameters:

  • value —

    the value to set the attribute redis_handler to.



29
30
31
 
# File 'lib/nebulous_stomp/request.rb', line 29

def redis_handler=(value)
  @redis_handler = value
end

#stomp_handler=(handler) ⇒ Object 



44
45
46
47
 
# 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

#target ⇒ Object (readonly)

The Target object we are sending the request to



22
23
24
 
# File 'lib/nebulous_stomp/request.rb', line 22

def target
  @target
end

Instance Method Details

#cache_timeout ⇒ Object

Returns the default cache timeout



128
129
130
 
# File 'lib/nebulous_stomp/request.rb', line 128

def cache_timeout
  Param.get(:cacheTimeout)
end

#clear_cache ⇒ Object

:call-seq:

request.clear_cache -> self

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



109
110
111
112
113
114
115
116
 
# 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 ⇒ Object

Returns the default message timeout



121
122
123
 
# File 'lib/nebulous_stomp/request.rb', line 121

def message_timeout
  @target.message_timeout || Param.get(:messageTimeout)
end

#send(mtimeout = message_timeout, ctimeout = cache_timeout) ⇒ Object

: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 -- Message timout in seconds; defaults to @mTimeout
* ctimeout -- Cache timout in seconds; defaults to @cTimeout

Raises ArgumentError, NebulousTimeout, NebulousError as necessary.



88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
# 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(mtimeout = message_timeout) ⇒ Object

: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 -- 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.



64
65
66
67
68
69
70
71
72
 
# 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