haredo 0.0.5 → 2.0.0

data/src/bin/haredo

@@ -0,0 +1,115 @@
+#!/usr/bin/ruby
+
+require 'optparse'
+require 'haredo/version'
+require 'haredo/admin/config'
+require 'haredo/service/admin/daemon'
+require 'haredo/service/daemon'
+
+$config_dir = '/etc/haredo/config.yaml'
+
+class CommandLine
+
+  def initialize()
+    @commands = {}    
+    
+    # Default is global service
+    @service = 'haredo'
+  end
+
+  def load(interface)
+    @commands[interface.name] = interface
+  end
+
+  def daemonize()
+
+    daemon = HareDo::Service::Daemon::new(@service)
+    daemon.run()
+
+    daemon.shutdown()
+
+    puts 'Daemon exiting'
+  end
+
+  def parse()
+    @daemonize = false
+
+    opts = OptionParser.new do |opts|
+      opts.banner = "HareDo #{HareDo::VERSION} (#{HareDo::RELEASE_DATE})\n\n"
+      opts.separator "Usage: haredo <global options> <command> <command_options>\n\n"
+
+      opts.separator 'Global options:'
+      
+      opts.on('-c', '--config [val]', String, 'Use specific config file (default /etc/haredo/system.yml)') do |file|
+        @configfile = file
+      end
+      
+      opts.on('-d', '--daemonize', String, 'Run in daemon mode') do
+        @daemonize = true
+      end
+
+      opts.on('-s', '--service [val]', String, 'Service to run') do |service|
+        @service = service
+      end
+      
+      opts.on_tail("-h", "--help", "Display help") do
+        puts opts
+        puts
+        printHelp()
+
+        exit
+      end
+    end    
+    
+    opts.parse!(ARGV)
+
+    daemonize() if @daemonize == true
+  end
+
+  def printHelp()
+    
+    puts "Available commands:\n"
+    
+    @commands.keys.sort.each do |key|
+      desc = @commands[key].description
+      puts "  %-10s %-25s " % [key, desc]
+    end
+    
+    puts 
+    puts "For a specific command's options, type: haredo <command> -h "
+    puts    
+  end
+
+  def run()
+    command = ARGV[0]
+
+    if @commands.has_key?(command)
+      remaining = @commands[command].parse(ARGV[1..-1])
+    else
+
+      # HAAAAAAAAAAACK. These are shortcuts in case user forgets to type 'daemon
+      # start' or 'daemon {command}'
+
+      if command == 'start'
+        @commands['daemon'].parse(ARGV[0..-1])
+      end
+
+      if command == 'stop'
+        @commands['daemon'].parse(ARGV[0..-1])
+      end
+
+      if command == 'status'
+        @commands['daemon'].parse(ARGV[0..-1])
+      end
+
+      if parse() == false
+        printHelp()
+      end
+    end
+  end    
+end
+
+program = CommandLine.new()
+program.load(HareDo::Admin::Config::Interface.new())
+program.load(HareDo::Admin::Daemon::Interface.new())
+program.run()

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

@@ -0,0 +1,178 @@
+require 'haredo/admin/interface'
+
+module HareDo
+module Admin
+module Config
+
+# The class implements to command line interface for configuration module
+class Interface < Admin::Interface
+
+  def initialize()
+    super('config', 'Modify configuration')
+
+    @commands = {}
+
+    # Configure/test database connection settings
+    @commands['db'] = lambda do | name |
+
+      # Write changes to configuration file
+      if @write == true
+
+        loadConfig()
+
+        settings = {}
+        password = ENV['PGPASSWORD']
+
+        settings['host']     = @host if @host
+        settings['user']     = @username if @username
+        settings['password'] = password if password
+        settings['port']     = @port if @port
+        settings['name']     = @vhost if @vhost
+        settings['ssl']      = true if @ssl
+
+        @config['system']['db'] = settings
+
+        saveConfig()
+      end
+
+    end
+
+    # Configure/test RabbitMQ connection settings
+    @commands['broker'] = lambda do | name |
+
+      if @test == true
+        connected = false
+        params = {
+          :user     => @username, 
+          :password => ENV['RBQPASSWORD'], 
+          :port     => @port, 
+          :vhost    => @vhost,
+          :host     => @host,
+          :ssl      => @ssl
+        }
+
+        puts params
+
+        client = HareDo::Peer.new()
+
+        begin
+          connected = client.connect(params)
+        rescue
+          exit 1
+        end
+
+        if connected == true
+          puts 'succeeded'
+          client.disconnect()          
+          exit 0        
+        end
+        
+        puts 'failed'
+        exit 1
+      end    
+
+      if @write == true
+        # Write changes to configuration file
+
+        loadConfig()
+
+        settings = {}
+        password = ENV['RBQPASSWORD']
+
+        settings['host']     = @host if @host
+        settings['user']     = @username if @username
+        settings['password'] = password if password
+        settings['port']     = @port if @port
+        settings['vhost']    = @vhost if @vhost
+        settings['ssl']      = true if @ssl
+
+        @config['system']['broker'] = settings
+
+        saveConfig()
+      end
+    end
+  end
+
+  def help(opts)
+    puts opts
+  end
+
+  def parse(args)
+    $dir = nil   
+    $count = 1
+    
+    @ssl = false
+
+    opts = OptionParser.new do |opts|
+      opts.separator ''
+      opts.banner   = "Test/update configuration and connection settings\n\n"
+      opts.banner  += "Usage: config [options] {db | broker}"
+
+      opts.separator 'Available options:'
+
+      opts.on('-c', '--config [val]', String, 'Use specific config file (default /etc/haredo/system.yml)') do |file|
+        @configfile = file
+        $count += 1
+      end
+
+      opts.on_tail("-t", "--test", "Test connection settings") do
+        @test = true
+      end
+            
+      opts.on_tail("-h", "--help", "Display help") do
+        puts opts
+        exit
+      end
+
+      opts.on_tail("-u", "--user [val]", String, "Username to use for connection") do |user|
+        @username = user
+        $count += 1
+      end
+
+      opts.on_tail("-s", "--server-host [val]", String, "Host") do |host|
+        @host = host
+        $count += 1
+      end
+
+      opts.on_tail("-e", "--encryption [val]", String, "Host to use for connection") do |ssl|
+        if ssl == 'true'
+          @ssl = true
+        end
+          
+        $count += 1
+      end
+
+      opts.on_tail("-n", "--name [val]", String, "Name (Database name of RabbitMQ VHost)") do |name|
+        @vhost = name
+        $count += 1
+      end
+
+      opts.on_tail("-p", "--port [val]", String, "Port to use for connection)") do |port|
+        @port = port
+        $count += 1
+      end
+
+      opts.on_tail("-w", "--write-changed", "Write account setting to configuration file")  do
+        @write = true
+      end
+
+    end
+    
+    opts.parse!(args[0..-1])
+        
+    command = args[0].chomp
+    
+    if not @commands.has_key?(command)
+      help opts
+
+      return
+    end
+    
+    @commands[command].call(command)
+  end
+  
+end # class
+
+end # module Daemon
+end # module Admin
+end # module HareDo

data/src/lib/haredo/admin/interface.rb

@@ -0,0 +1,25 @@
+require 'haredo/peer'
+require 'haredo/config'
+
+module HareDo
+module Admin
+
+class Interface
+
+  attr_reader :name, :description
+
+  include HareDo::Config
+
+  def initialize(name, desc)
+    @name        = name
+    @description = desc
+  end
+
+  def parse(args)
+    # Derived class implements
+  end
+  
+end # class Interface
+
+end # module Admin
+end # module HareDo

data/src/lib/haredo/config.rb

@@ -0,0 +1,54 @@
+require 'yaml'
+require 'haredo/peer'
+
+class Time
+  def isoDate()
+    return self.strftime("%Y-%m-%d %H:%M:%S")
+  end
+end
+
+module HareDo
+module Config
+
+  def loadConfig()
+    @config_file = '/etc/haredo/haredo.conf'
+    @config      = []    
+    @config      = YAML.load_file(@config_file)
+    @pid_file    = '/var/run/haredo.pid'
+  end
+
+  def saveConfig()
+    file = File.open(@config_file, 'w')
+    file.write(YAML::dump(@config))
+    file.close()
+  end
+
+  # Connect to the RabbitMQ broker
+  #
+  # @return Return a client instance if connection was successful, nil otherwise
+  def connectBroker()
+
+    account = @config['system']['broker']
+
+    params = {
+      :user     => account['user'],
+      :password => account['password'],
+      :host     => account['host'],
+      :port     => account['port'], 
+      :vhost    => account['vhost'],
+      :ssl      => account['ssl']
+    }
+
+    peer = HareDo::Peer.new()
+    
+    begin
+      connected = peer.connect(params)
+    rescue
+      return nil
+    end
+
+    return peer
+  end
+
+end # module Config
+end # module HareDo

data/src/lib/haredo/peer.rb

@@ -1,7 +1,20 @@
-require "bunny"
+require 'syslog'
+require 'bunny'
 require 'haredo/version'
 
-module HareDo
+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 RabbitMQ
 
 # This is a simple class that represents a message delivered from a queue. The
 # attributes are as follows:
@@ -13,7 +26,7 @@ module HareDo
 
 class Message
 
-  attr_reader :info, :properties, :headers, :data
+  attr_accessor :info, :properties, :headers, :data
 
   def initialize(info=nil, properties=nil, data=nil)
     @info       = info
@@ -30,14 +43,137 @@ class Message
 
 end
 
-# This is an abstract base class used for both Client and Service.
+end # module RabbitMQ
 
-class Node
+module HareDo
+
+#-------------------------------------------------------------------------------
+# For managing plugins 
+#-------------------------------------------------------------------------------
+
+module Plugins
 
-  attr_reader :queue
+class Instance
 
-  def initialize()
+  def initialize(path)
+    
+    # 1. Create an empty, anonymous module
+    @module = Module.new()
+    
+    # 2. Get it's binding
+    @binding = @module.instance_eval 'binding'
     
+    # 3. Eval the desired file with the module's binding as
+    # context. Everything global in the module will be restricted to the
+    # module's namespace.
+    Kernel::eval(File.open(path).read(), @binding, path)
+  end
+  
+  # Return a top-level object within the module
+  def get(object)
+    return @module.instance_eval object
+  end
+end
+
+# This class loads Ruby files/modules into private namespaces. That is, they are
+# not globally visible.
+#
+# Example:
+#
+#    instance = Plugins::Manager.load("#{@path}/plugin")
+#    mod = instance.get('Sonar')
+#    plugin = mod::Plugin.new(@config)
+#
+#    plugins[plugin.uuid] = plugin
+
+class Manager
+
+  attr_reader :loaded
+  attr_accessor :module_path_prefix
+
+  def initialize(peer)
+    @peer    = peer
+    @loaded  = {}
+    @config  = {}
+
+    @module_path_prefix = 'haredo/plugins'
+  end
+
+  def [](name)
+    return @loaded[name]
+  end
+
+  def loadConfig(config)
+    @config.merge! config
+
+    config.each do |plugin_name, value|
+      load(plugin_name)
+    end
+  end
+
+  def load(plugin_name, base=@module_path_prefix)
+    
+    # Iterate through the RUBY_PATH looking for a match
+    $:.each do |dir|
+      path = "#{dir}/#{base}/#{plugin_name}.rb"
+      if File.exists? path
+        instance = Instance.new(path)
+        cls = instance.get('Plugin')
+        plugin = cls.new(@peer, @config[cls::UUID])
+        @loaded[plugin.uuid] = plugin
+        $stderr.puts "Loaded plugin #{path}"
+
+        return
+      end
+    end
+  end
+
+  # Process a message. Looks up module by given by UUID in headers. If found,
+  # passes message off to it.
+  def process(msg)
+    uuid = msg.headers['uuid']
+
+    if @loaded.has_key?(uuid)
+      @loaded[uuid].process(msg)
+    end
+  end
+
+  def shutdown()
+    @loaded.each do|uuid, plugin|
+      plugin.finalize()
+    end
+  end
+
+end # class Manager
+
+end # module Plugins
+
+# This is an abstract base class used for both Client and Service.
+
+class Peer
+
+  attr_reader :queue, :plugins
+  attr_accessor :timeout, :sleep_interval
+
+  def initialize(name=nil)
+    # Message identifier
+    @mid = 0
+
+    # Client attributes
+    @timeout        = 1.0
+    @sleep_interval = 0.001
+    @receive_queue  = {}
+
+    # 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)
   end
 
   # Connect to RabbitMQ
@@ -72,82 +208,38 @@ class Node
 
     @channel = @cnx.create_channel()
 
+    @queue = @channel.queue( '', :auto_delete => true, 
+                             :arguments => { "x-message-ttl" => 1000 } )
+
+    @exchange = @channel.default_exchange()
+
     return true
   end
 
   # Disconnect from RabbitMQ
   def disconnect()
-    @cnx.close()
-  end
 
-  # Sends a message.
-  # @param to The to address
-  # @param :data Message data
-  # @param :headers Message headers
-  # @param :headers Message from address
-  # @param :properties Message properties
-
-  def send(to, args)
-
-    data       = args[:data]       || ''
-    from       = args[:from]
-    headers    = args[:headers]    || {}
-    properties = args[:properties] || {}
-
-    properties[:routing_key] = to
-    properties[:headers]     = headers
-
-    if not from.nil?
-      properties[:reply_to] = from 
-    else
-      properties[:reply_to] = @queue.name if @queue
+    if @queue != nil
+      @queue.delete() 
+      @queue = nil
     end
 
-    properties[:message_id] = @mid
-
-    @exchange.publish(data, properties) 
-  end
-
-end # class Node
-
-# Implements a basic client designed for sending messages asynchronously and
-# blocking while receiving replies.
-
-class Client < Node
-
-  attr_reader :queue
-  attr_accessor :timeout, :sleep_interval
-
-  def initialize()
-    super
-
-    @timeout        = 1.0
-    @sleep_interval = 0.001
-    @receive_queue  = {}
-
-    # Message identifier
-    @mid = 0
-  end
-
-  def connect(args)
-    ret = super
-
-    if ret == true
-      @queue = @channel.queue( '', :auto_delete => true, 
-                               :arguments => { "x-message-ttl" => 1000 } )
-
-      @exchange = @channel.default_exchange()
+    @listen_queues.each do |listen_queue|
+      listen_queue.delete() 
+      listen_queue = nil
     end
+    
+    @listen_queues = {}
 
-    return ret
-  end
+    if @cnx != nil
+      @cnx.close()
+      @cnx = nil
+    end
 
-  # Disconnect from RabbitMQ
-  def disconnect()
-    @queue.delete() if @queue
-    super
+    @plugins.shutdown()
   end
 
+  # Sends a message.
   # Sends a message. Adds the @mid as message_id in message properties.
   # @param to The to address
   # @param :data Message data
@@ -164,13 +256,21 @@ class Client < Node
     headers    = args[:headers]    || {}
     properties = args[:properties] || {}
 
-    properties[:message_id] = @mid
-
-    super to, :data => data, :headers => headers, :properties => properties, :from => from
+    properties[:routing_key] = to
+    properties[:headers]     = headers
+    properties[:message_id]  = @mid
 
     rc = @mid
     @mid += 1
 
+    if not from.nil?
+      properties[:reply_to] = from 
+    else
+      properties[:reply_to] = @queue.name if @queue
+    end
+
+    @exchange.publish(data, properties) 
+
     return rc
   end
 
@@ -216,7 +316,7 @@ class Client < Node
       delivery_info, properties, payload = @queue.pop()
       
       if delivery_info != nil
-        msg = Message.new(delivery_info, properties, payload)
+        msg = RabbitMQ::Message.new(delivery_info, properties, payload)
         
         if msg.headers.has_key?('id')
           if mid != nil 
@@ -246,20 +346,24 @@ class Client < Node
     end    
   end
 
-end # class Client
-
-# Represents a basic service class.
-
-class Service < Node
+  # You should use this method to reply back to a peer. It sets the reply header
+  # which tells the remote that this message is a response (as opposed to a
+  # message originating from another source which just happens to have the same
+  # message_id).
+  def reply(msg, args)
 
-  # @param name The name of the queue the service will attempt to bind to.
-  def initialize(name)
-    super()
+    data    = args[:data]    || ''
+    headers = args[:headers] || {}
 
-    @queue_name = name
+    id = msg.properties.message_id.to_i
+    to = msg.properties.reply_to
 
-    # The number of messages to prefecth from Rabbit
-    @prefetch = 10
+    # Set the reply flag to indicate that this is a response to a message
+    # sent. The message_id should already be set in the headers.
+    headers[:reply] = 1
+    headers[:id]    = id.to_i
+    
+    send(to, :headers => headers, :data => data)
   end
 
   # Defined the queue this service will listen on. Assumes a single-instance
@@ -275,40 +379,36 @@ class Service < Node
 
   # @returns Returns nil if non-blocking. Never returns if blocking.
 
-  def run(args)
-    @queue    = createQueue()
+  def listen(args)
+    listen_queue = createQueue()
+
+    @listen_queues << listen_queue
+
     @exchange = @channel.default_exchange()
 
     block = args[:blocking] || false
 
     @channel.prefetch(@prefetch)
 
-    queue.subscribe(:block => block, :ack => true) do |info, props, data|
-      @channel.acknowledge(info.delivery_tag, false)
-      serve Message.new(info, props, data)
+    if $syslog.nil?
+      Syslog.open( "haredo #{@name}", Syslog::LOG_PID,
+                   Syslog::LOG_DAEMON | Syslog::LOG_LOCAL7 )
+    
+      $syslog = true
     end
-  end
 
-  # You should use this method to reply back to a peer. It sets the reply header
-  # which tells the remote that this message is a response (as opposed to a
-  # message originating from another source which just happens to have the same
-  # message_id).
-  def reply(msg, args)
-
-    data    = args[:data]    || ''
-    headers = args[:headers] || {}
-
-    id = msg.properties.message_id.to_i
-    to = msg.properties.reply_to
-
-    # Set the reply flag to indicate that this is a response to a message
-    # sent. The message_id should already be set in the headers.
-    headers[:reply] = 1
-    headers[:id]    = id.to_i
+    Syslog.notice('listen()')
     
-    send(to, :headers => headers, :data => data)
+    listen_queue.subscribe(:block => block, :ack => true) do |info, props, data|
+      @channel.acknowledge(info.delivery_tag, false)
+      serve RabbitMQ::Message.new(info, props, data)
+    end
   end
-
-end # class Service
+  
+  def serve(msg)
+    @plugins.process(msg)
+  end
+    
+end # class Peer
 
 end # module HareDo