haredo 2.0.9 → 3.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5ef93eb2e7a62a3b82fc6b2861f5206bcad851dd
-  data.tar.gz: 2c9cc2406ff56d8ea45a191150b686a890a2b7ff
+  metadata.gz: 3ef90f8c4b3c742587932fa39460612e48d394d9
+  data.tar.gz: e83d8563ce838be478d7c3be168e591370c44f89
 SHA512:
-  metadata.gz: 4b6ba3bb814cf315c7ea136a26e71b8d0bc1d227e37e14f4230dc05e400a4be5e219cac97f0ad03a18bdfc514e8a166fb22fd25f5d3cafc55700f4afd2a043e5
-  data.tar.gz: 4115af63f74e1e41cff1c0e0986ae96ce7415d0814e26f952bd9e7053ae9d0df19b852cd84efb01876237d0496ed91900a01019e9c2fab3793f5bc59a5e54b1a
+  metadata.gz: 10a9b48836ea8291b7fc7f92d3be421157392d73f87d73cf7490f24fe2141e60e3e0bf80a556328a1fef2b0d97d65610fa95660fc87c42ca11b1de0f56284f89
+  data.tar.gz: 183c7a614608a0ee93bbe18f489706e38201694f3397fcf33f9894ff3e3eb5fbab05de345d46962729b586777db65148a5f5365e77482bbf4cc476797272bedf

data/CHANGES.md

@@ -0,0 +1,68 @@
+# Change Log
+
+## Version 3.0
+
+### `Peer`
+
+`@queue_name` has been removed. This is replaced by optional argument in
+`Peer::listen()`.
+
+`@name` attribute added. Taken from constructor. This is a convenience variable
+for generic identification. It is not used for anything.
+
+### `Peer::listen(args={})`:
+
+No longer creates a new queue by default. It will use the default private
+queue. If you provide a `queue` argument, then it will create a new queue and
+keep track of it as a listen queue internally which will be destroyed on
+`disconnect()`. Also takes an optional `exchange` argument. If provided, it will
+bind the new queue to that exchange.
+
+For example say you want to create a service which listens on its private
+queue. Furthermore you want to receive messages on the default AMQP Fanout
+queue. Here's a working example:
+
+```ruby
+#!/usr/bin/env ruby
+
+require 'haredo/peer'
+
+$mq_host     = 'localhost'
+$mq_username = 'guest'
+$mq_password = 'guest'
+$queue       = 'doesntmatter'
+
+class Service < HareDo::Peer
+
+  def initialize(name)
+    super name
+    connect( :host      => $mq_host,
+             :user      => $mq_username, 
+             :password  => $mq_password,
+             :vhost     => '' )    
+
+    @queue.bind('amq.fanout')
+  end
+
+  def serve(msg)
+    dump_message msg
+  end
+  
+end
+
+service = Service.new('service')
+service.listen({:blocking=>false})
+
+# Client
+
+client = HareDo::Peer.new()
+client.connect(:user=>$mq_username, :password=>$mq_password, :host=>$mq_host)
+
+client.exchange = client.channel.fanout('amq.fanout')
+client.send($queue, :headers => { :testing => 1 })
+
+# Cleanup
+
+client.disconnect()
+service.disconnect()
+```

data/README.md

@@ -2,8 +2,25 @@
 
 ## About
 
-This is an easy-to-use framework for creating peer-to-peer applications in Ruby
-via [RabbitMQ](http://www.rabbitmq.com/). Built atop the [Bunny AMQP
+I'll bet that most people don't realize that when they use RabbitMQ they are
+actually using the core software that runs big-freaking telecom systems (OTP --
+Open Telecom Platform). That in itself is reason enough to consider RabbitMQ.
+
+But RabbitMQ uses both an elegant but also somewhat elaborate model called AMQP
+0-9-1. Notice the 0-9-1. This is important. Versions later than this are
+crap. 0-9-1 is a work of pure genius and art which was later utterly mauled by
+committees. Fortunately enough for you, RabbitMQ is and most likely always will
+be AMQP 0-9-1. Hurray!
+
+But the bottom line is this: You might be one of those pragmatic people that
+doesn't want to have to know everything about AMQP. You want just want that
+fancy telecom thing-a-majigger software to pump massive volumes of your messages
+from one place to another using Ruby and give you 5 9's doing it.
+
+If that's true for you then you've come to the right place.
+
+Haredo is an easy-to-use framework for creating peer-to-peer applications in
+Ruby via [RabbitMQ](http://www.rabbitmq.com/). Built atop the [Bunny AMQP
 client](http://rubybunny.info/), it uses a small subset of RabbitMQ's
 capabilities to provide an intuitive client/server framework for implementing
 network services and simple peer to peer applications. It is specifically
@@ -40,6 +57,8 @@ this below).
 ```ruby
 #!/usr/bin/env ruby
 
+require 'haredo/peer'
+
 $mq_host     = 'localhost'
 $mq_username = 'guest'
 $mq_password = 'guest'
@@ -53,6 +72,7 @@ class Service < HareDo::Peer
   end
 
   def serve(msg)
+    #dump_message msg
     data = msg.headers['i'].to_i + 1
     reply(msg, :data => data.to_s)
   end
@@ -60,14 +80,14 @@ class Service < HareDo::Peer
 end
 
 service = Service.new($queue)
-service.listen(:blocking => false)
+service.listen(:queue => $queue, :blocking => false)
 
 client = HareDo::Peer.new()
 client.connect(:user=>$mq_username, :password=>$mq_password, :host=>$mq_host)
 
 1.upto(10) do |i|
-  client.send($queue, :headers => { :i => i })
-  msg = @client.receive()
+  id = client.send($queue, :headers => { :i => i })
+  msg = client.receive(id)
       
   puts msg.data.to_i == i + 1
 end
@@ -134,6 +154,10 @@ class Service < HareDo::Peer
     connect(:user=>$mq_username, :password=>$mq_password, :host=>$mq_host)
   end
 
+  def listen()
+    super :queue => @name
+  end
+
   def serve(msg)
     # Log the message somewhere
   end
@@ -187,13 +211,17 @@ class Service < HareDo::Peer
     connect(:user=>$mq_username, :password=>$mq_password, :host=>$mq_host)
   end
 
+  def listen()
+    super :queue => @name, :blocking => false
+  end
+
   def serve(msg)
     # Log the data somewhere
   end
 
 end
 
-Service.new('logger').listen(:blocking=>false)
+Service.new('logger').listen()
 
 client = HareDo::Peer.new()
 client.connect(:user=>$mq_username, :password=>$mq_password, :host=>$mq_host)
@@ -206,10 +234,13 @@ client.disconnect()
 ### Send/Receive
 
 The send/receive pattern is illustrated in the initial example -- the client
-sends out ten integers and wait for the response. While the responses come back
-in the correct order, there is no guarantee that this will happen every time. So
-technically, the client example could break here. What the client needs here is
-to correlate the response with the request. This is the RPC pattern.
+sends out ten integers and wait for the response. Each time is calls send() it
+gets a correlation ID as the return value. It passed this ID into receive()
+which then looks for a return message with that correlation ID. This is how you
+ensure you get back the message you are looking for (as opposed to some other
+message that happened to arrive). While the responses come back in the correct
+order in this example, there is no guarantee that this will happen every
+time. This is why the correlation ID is important.
 
 ### Remote Procedure Call
 
@@ -240,7 +271,7 @@ class Service < HareDo::Peer
 end
 
 service = Service.new('rpc')
-service.listen(:blocking => false)
+service.listen(:queue => service.name, :blocking => false)
 
 client = HareDo::Peer.new()
 client.connect(:user=>$mq_username, :password=>$mq_password, :host=>$mq_host)
@@ -326,7 +357,7 @@ class Service < HareDo::Peer
   end
 end
 
-Service.new('rpc').listen()
+Service.new('rpc').listen(queue => service.name)
 service.disconnect()
 ```
 
@@ -389,13 +420,15 @@ Now I can implement my service and call it as follows:
 ```ruby
 #!/usr/bin/env ruby
 
-service = HareDo::Peer.new('myservice')
+$queue = 'myservice'
+
+service = HareDo::Peer.new($queue)
 service.plugins.load('echo')
-service.listen(:blocking => false)
+service.listen(queue => service.name, :blocking => false)
 
 client = HareDo::Peer.new()
 client.connect(:user=>$mq_username, :password=>$mq_password, :host=>$mq_host)
-response = @client.call('myservice', headers=>{:uuid=>'echo'}, :data=>'jujifruit')
+response = @client.call($queue, headers=>{:uuid=>'echo'}, :data=>'jujifruit')
 
 client.disconnect()
 service.disconnect()
@@ -453,7 +486,9 @@ For example:
 ```ruby
 #!/usr/bin/env ruby
 
-service = HareDo::Peer.new('myservice')
+$queue = 'myservice'
+
+service = HareDo::Peer.new($queue)
 
 # Load modules from configuration
 config = {
@@ -463,11 +498,11 @@ config = {
 }
 
 service.plugins.loadConfig(config)
-service.listen(:blocking => false)
+service.listen(:queue => $queue, :blocking => false)
 
 client = HareDo::Peer.new()
 client.connect(:user=>$mq_username, :password=>$mq_password, :host=>$mq_host)
-response = @client.call('myservice', headers=>{:uuid=>'example'}, :data => 'jujifruit')
+response = @client.call($queue, headers=>{:uuid=>'example'}, :data => 'jujifruit')
 
 service.disconnect()
 client.disconnect()

data/src/lib/haredo/peer.rb

@@ -2,9 +2,14 @@ require 'syslog'
 require 'bunny'
 require 'haredo/version'
 
-def dump_message(msg, name)
+def dump_message(msg, name=nil)
   puts name if name
 
+  if msg.nil?
+    puts 'Message is nil'
+    return
+  end
+
   if msg.properties != nil
     puts '  Headers:'
     msg.properties.each do |k,v|
@@ -157,8 +162,8 @@ end # module Plugins
 
 class Peer
 
-  attr_reader :queue, :plugins, :mid
-  attr_accessor :timeout, :sleep_interval
+  attr_reader :queue, :plugins, :mid, :name
+  attr_accessor :timeout, :sleep_interval, :channel, :exchange
   attr_accessor :trace
 
   def initialize(name=nil)
@@ -171,16 +176,14 @@ class Peer
     @receive_queue  = {}
     @trace          = false
 
-    # Server attributes
-    # The queue name used for listen()
-    @queue_name = name
-
     @listen_queues = []
 
     # The number of messages to prefecth from Rabbit
     @prefetch = 10
 
     @plugins = Plugins::Manager.new(self)
+
+    @name = name
   end
 
   # Connect to RabbitMQ
@@ -206,19 +209,38 @@ class Peer
     port         = args[:port]       || '5672'
     vhost        = args[:vhost]      || ''
     queue_props  = args[:queue]      || queue_args
+    exchange     = args[:exchange]   || ''
+    exclusive    = args[:exclusive]  || true
     ssl          = args[:ssl]        || {}
-    tls_cert     = ssl['tls_cert']   || ''
-    tls_key      = ssl['tls_key']    || ''
-    tls_ca_certs = [ssl['tls_ca']]
+    tls_cert     = ssl['tls_cert']   || nil
+    tls_key      = ssl['tls_key']    || nil
+    tls_ca_certs = nil
 
+    if ssl['tls_cert']
+      tls_cert = ssl['tls_cert']
+    end
+
+    if ssl['tls_key']
+      tls_key = ssl['tls_key']
+    end
+
+    if ssl['tls_ca']
+      tls_ca_certs = [ssl['tls_ca']]
+    end
+        
     use_ssl = false
     if ssl.size > 0 and ssl['enable'] == true
       use_ssl = true
       port = ssl['port'] || '5671'
     end
 
+    if vhost == '/'
+      vhost = ''
+    end
+
     if use_ssl == true
       @cnx = Bunny.new( "amqps://#{user}:#{password}@#{host}:#{port}#{vhost}",
+                        :log_file => '/dev/null',
                         :tls_cert => tls_cert,
                         :tls_key => tls_key,
                         :tls_ca_certificates => tls_ca_certs)
@@ -230,16 +252,18 @@ class Peer
 
     @channel = @cnx.create_channel()
 
+    @channel.prefetch(@prefetch)
+
     @queue = @channel.queue( '', 
                              :auto_delete => true, 
-                             :exclusive => true,
-                             :arguments => queue_props )
+                             :exclusive   => exclusive,
+                             :arguments   => queue_props )
 
     @exchange = @channel.default_exchange()
 
     return true
   end
-
+ 
   # Disconnect from RabbitMQ
   def disconnect()
 
@@ -407,27 +431,50 @@ class Peer
 
   # Defined the queue this service will listen on. Assumes a single-instance
   # service therefore declares queue as exclusive.
-  def createQueue()
-    return @channel.queue(@queue_name, :auto_delete => true, :exclusive => true)
+  def createQueue(args={})
+
+    queue_args = { 
+      #'x-expires'     => 30000
+      #'x-message-ttl' => 1000
+    }
+
+    queue_name   = args[:queue]
+    queue_props  = args[:properties]  || queue_args
+    auto_delete  = args[:auto_delete] || true
+    exclusive    = true
+    
+    if args.has_key?(:exclusive)
+      exclusive = args[:exclusive] 
+    end
+
+    return @channel.queue( queue_name, 
+                           :auto_delete => true, 
+                           :exclusive   => exclusive )
   end
 
   # Causes the service to listen for incoming messages.
   #
   # @param :blocking If this is set to true, will go into indefinite blocking
   # loop processing incoming messages.
-
+  #
   # @returns Returns nil if non-blocking. Never returns if blocking.
 
-  def listen(args)
-    listen_queue = createQueue()
+  def listen(args={})
 
-    @listen_queues << listen_queue
+    queue = @queue
 
-    @exchange = @channel.default_exchange()
+    if args.has_key?(:queue)
+      listen_queue = createQueue(args)
+      @listen_queues << listen_queue
 
-    block = args[:blocking] || false
+      if args.has_key?(:exchange)
+        listen_queue.bind(args[:exchange])
+      end
 
-    @channel.prefetch(@prefetch)
+      queue = listen_queue
+    end
+
+    block = args[:blocking] || false
 
     if $syslog.nil?
       Syslog.open( "haredo #{@name}", Syslog::LOG_PID,
@@ -438,7 +485,7 @@ class Peer
 
     Syslog.notice('listen()')
     
-    listen_queue.subscribe(:block => block, :manual_ack => true) do |info, props, data|
+    queue.subscribe(:block => block, :manual_ack => true) do |info, props, data|
       @channel.acknowledge(info.delivery_tag, false)
       if serve(RabbitMQ::Message.new(info, props, data)) == false
         exit 0

data/src/lib/haredo/plugin.rb

@@ -17,4 +17,4 @@ class Plugin
 
 end # class Plugin
 
-end # module Sonar
+end # module Haredo

data/src/lib/haredo/service/config.rb

@@ -14,7 +14,7 @@ module Config
   # @return Returns PID of running daemon if it corresponds to a running
   # process. Returns nil otherwise.
   def daemonPid()
-    pid = File.open(@pid_file).read().strip.chomp
+    pid = File.open(@pid_file, 'a+').read().strip.chomp
     
     return nil if pid.size == 0
 

data/src/lib/haredo/service/daemon.rb

@@ -1,18 +1,6 @@
 require 'syslog'
 require 'haredo/service/config'
 
-def dump_message(msg)
-  if msg.properties != nil
-    puts '  Headers:'
-    msg.properties.each do |k,v|
-      puts "    #{k}: #{v}"
-    end
-  end
-  
-  puts "  Data: #{msg.data}"
-  puts
-end
-
 module HareDo
 module Service
 

data/src/lib/haredo/version.rb

@@ -1,11 +1,11 @@
 # Version information. Auto-generated by CMake.
 module HareDo
 
-VERSION_MAJ  = '2'
+VERSION_MAJ  = '3'
 VERSION_MIN  = '0'
 VERSION_CL   = ''
-VERSION_PL   = '9'
-VERSION      = '2.0.9-1'
-RELEASE_DATE = 'Wed, 11 Mar 2015 14:46:11 -0500'
+VERSION_PL   = '2'
+VERSION      = '3.0.2-1'
+RELEASE_DATE = 'Wed, 01 Aug 2018 17:30:02 -0500'
 
 end # module HareDo

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: haredo
 version: !ruby/object:Gem::Version
-  version: 2.0.9
+  version: 3.0.2
 platform: ruby
 authors:
 - Mike Owens
 autorequire: 
 bindir: src/bin
 cert_chain: []
-date: 2015-03-11 00:00:00.000000000 Z
+date: 2018-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny
@@ -31,7 +31,9 @@ executables:
 extensions: []
 extra_rdoc_files:
 - README.md
+- CHANGES.md
 files:
+- CHANGES.md
 - README.md
 - src/bin/haredo
 - src/lib/haredo/admin/config.rb
@@ -65,7 +67,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.5.2.1
 signing_key: 
 specification_version: 4
 summary: A simple client/server framework using RabbitMQ