homeq 1.1.4

data/lib/homeq/sobs/foreman.rb

@@ -0,0 +1,237 @@
+#############################################################################
+#
+# $Id: foreman.rb 40 2008-10-23 14:20:06Z colin $
+#
+# Author:: Colin Steele (colin@colinsteele.org)
+# Homepage::  
+# 
+# TODO: info 
+#
+#----------------------------------------------------------------------------
+#
+#      Copyright (C) 2008 by Colin Steele. All Rights Reserved.
+#                        colin@colinsteele.org
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either: 1) the GNU General Public License
+# as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version; or 2) Ruby's License.
+# 
+# See the file COPYING for complete licensing information.
+#
+#---------------------------------------------------------------------------
+#
+# 
+#############################################################################
+
+module HomeQ
+  
+  module SOBS
+
+    ######################################################################
+    # Job Manager
+    ######################################################################
+
+    class Foreman
+
+      MAX_JOBS_TO_DOLE_OUT_PER_TICK = 100
+      
+      include Base::Logging
+
+      attr :server, true
+      attr :jobs, true
+      
+      def initialize(server)
+        @serial_number = 0
+        @server = server
+        @jobs = {}  # Each element is a [job, job_state, time] tuple
+        @states = {
+          :start => HomeQ::OHash.new,
+          :ready => HomeQ::OHash.new,
+          :deleted => HomeQ::OHash.new,
+          :delayed => HomeQ::OHash.new,
+          :reserved => HomeQ::OHash.new,
+          :buried => HomeQ::OHash.new,
+        }
+        @jobs_created 	= 0
+        @jobs_deleted 	= 0
+        @jobs_doled_out = 0
+        @histo          = HomeQ::Histogram.new(0,10,0.5)
+        dole_out_jobs
+      end
+
+      def create_job(message, connection)
+        @jobs_created += 1
+        j = ServerJob.new(message, connection)
+        j.add_observer(self)
+        j.run
+      end
+      
+      def update(job, state)
+        track_job_by_state(job, state) if job.job_id
+        case state
+        when :start
+          job.job_id = unique_job_id
+          @jobs[job.job_id] = [job, state, Time.now]
+          # call now b/c we now have a job_id
+          track_job_by_state(job, state)
+          job.queue.inserted(job.job_id, job.message.args[3])
+        when :deleted
+          @histo << (Time.now - @jobs[job.job_id][2])
+          @jobs.delete(job.job_id)
+          remove_job_from_all_states(job)
+          job.delete_observer(self)
+          job.recycle
+          @jobs_deleted += 1
+        when :ready
+          dole_out_jobs
+        when :delayed
+        when :reserved
+        when :buried
+        else
+          Base::System.instance.die("Unknown job state #{state}")
+        end
+      end
+
+      def release_job(conn, job_id, priority, delay)
+        j = job_id_in_state?(job_id, :reserved)
+        if !j
+          conn.not_found(job_id)
+          return
+        end
+        if delay.to_i > 0
+          j.release_with_delay(priority.to_i, delay.to_i)
+        else
+          j.release
+        end
+        conn.released(job_id)
+      end
+
+      def delete_job(conn, job_id)
+        [:buried, :reserved].each { |state|
+          j = job_id_in_state?(job_id, state)
+          if j
+            j.delete(conn)
+            return
+          end
+        }
+        conn.not_found(job_id)
+      end
+      
+      def bury_job(conn, job_id)
+        j = job_id_in_state?(job_id, :reserved)
+        if j
+          j.bury(conn)
+          return
+        end
+        conn.not_found(job_id)
+      end
+
+      def kick(conn, max_jobs)
+        kicked = []
+        0.upto(max_jobs.to_i - 1) { |i|
+          kicked << @states[:buried].shift
+        }
+        conn.kicked(kicked.length)
+        kicked.each { |jid,j|
+          @jobs[jid][0].kick
+        }
+      end
+      
+      def dole_out_jobs
+        # To give the reactor (EM) loop a chance to actually run, we
+        # only send out a few jobs at a time.      
+        1.upto(MAX_JOBS_TO_DOLE_OUT_PER_TICK) do
+          return unless ready_jobs?
+          c = find_waiting_connection
+          return unless c
+          j = get_next_ready_job
+          @jobs_doled_out += 1
+          j.reserve(c)
+        end
+        EventMachine::next_tick {
+          dole_out_jobs
+        }
+      end
+
+      def to_s
+        str = "#{self.class} "
+        str << "Pool size: #{ServerJob.pool.size}\n"
+        str << "created: #{@jobs_created} deleted: #{@jobs_deleted} "
+        str << "doled out: #{@jobs_doled_out}\n"
+        @states.each { |state, oh|
+          str << "#{state.to_s.capitalize} jobs: #{oh.length}\n" if oh.length>0
+        }
+        str << @histo.report
+        str
+      end
+
+      protected
+
+      def ready_jobs?
+        @states[:ready].length > 0
+      end
+      
+      def get_next_ready_job
+        if @states[:ready] && (@states[:ready].length > 0)
+          jid, j = @states[:ready].shift # pull it from the front of the dict
+          if j != @jobs[jid][0]
+            Base::System.instance.die("Foreman corrupted, bye.")
+          end
+          return j
+        end
+      end
+
+      def job_id_in_state?(jid, state)
+        jid = jid.to_sym
+        return false unless @jobs[jid][0]
+        if @states[state].length > 0
+          if @states[state].has_key?(jid)
+            return @jobs[jid][0]
+          end
+        end
+        false
+      end
+
+      def find_waiting_connection
+        waiters = @server.connections.find_all { |c|
+          c.server_state.state == :waiting_for_job
+        }
+        if waiters.any?
+          waiters[rand(waiters.length)]
+        end
+      end
+
+      def track_job_by_state(job, new_state)
+        remove_job_from_old_state(job)
+        @jobs[job.job_id][1] = new_state
+        @states[new_state].push(job.job_id, job)
+      end
+
+      def remove_job_from_old_state(job)
+        old_state = @jobs[job.job_id][1]
+        @states[old_state].delete(job.job_id)
+      end
+
+      def remove_job_from_all_states(job)
+        @states.each { |state_name,dict|
+          dict.delete(job.job_id) if dict.has_key?(job.job_id)
+        }
+      end
+
+      # Get a job id unique to this foreman
+      def unique_job_id
+        loop do
+          # This was the old way
+          # jid = UUID.timestamp_create.to_s.to_sym
+          jid = "#{@serial_number}".to_sym
+          @serial_number += 1
+          return jid if !@jobs.include?(jid)
+        end
+      end
+      
+    end # Foreman
+
+  end # SOBS
+
+end # HomeQ

data/lib/homeq/sobs/job.rb

@@ -0,0 +1,66 @@
+#############################################################################
+#
+# $Id: job.rb 40 2008-10-23 14:20:06Z colin $
+#
+# Author:: Colin Steele (colin@colinsteele.org)
+# Homepage::  
+# 
+# TODO: info 
+#
+#----------------------------------------------------------------------------
+#
+#      Copyright (C) 2008 by Colin Steele. All Rights Reserved.
+#                        colin@colinsteele.org
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either: 1) the GNU General Public License
+# as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version; or 2) Ruby's License.
+# 
+# See the file COPYING for complete licensing information.
+#
+#---------------------------------------------------------------------------
+#
+# 
+#############################################################################
+
+module HomeQ
+  
+  module SOBS
+    
+    class Job
+      
+      include Base::Options
+      include Base::Configuration
+      include Base::Logging
+      
+      attr :message, true
+      attr :queue, true
+      attr :job_id, true
+      
+      def initialize(message, queue)
+        @queue   = queue
+        @message = message
+        @job_id  = @message.job_id
+      end
+
+      def payload
+        @message.payload
+      end
+
+      # Override here, and call super
+      def run
+        complete
+      end
+
+      protected
+
+      def complete
+        @queue.release_job(self) if @queue
+      end
+
+    end # Job
+    
+  end # SOBS
+
+end # HomeQ

data/lib/homeq/sobs/message.rb

@@ -0,0 +1,49 @@
+#############################################################################
+#
+# $Id: message.rb 40 2008-10-23 14:20:06Z colin $
+#
+# Author:: Colin Steele (colin@colinsteele.org)
+# Homepage::  
+# 
+# TODO: info 
+#
+#----------------------------------------------------------------------------
+#
+#      Copyright (C) 2008 by Colin Steele. All Rights Reserved.
+#                        colin@colinsteele.org
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either: 1) the GNU General Public License
+# as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version; or 2) Ruby's License.
+# 
+# See the file COPYING for complete licensing information.
+#
+#---------------------------------------------------------------------------
+#
+# 
+#############################################################################
+
+module HomeQ
+
+  module SOBS
+    
+    class Message
+      
+      attr :type, true
+      attr :job_id, true
+      attr :payload, true
+      attr :args, true
+      
+      def initialize(message_type=nil, job_id=nil, payload=nil, args=nil)
+        @type = message_type
+        @job_id = job_id
+        @payload = payload
+        @args = args
+      end
+      
+    end # Message
+  
+  end # SOBS
+
+end # HomeQ

data/lib/homeq/sobs/queue.rb

@@ -0,0 +1,224 @@
+#############################################################################
+#
+# $Id: queue.rb 48 2008-11-19 05:11:59Z colin $
+#
+# Author:: Colin Steele (colin@colinsteele.org)
+# Homepage::  
+# 
+# TODO: info 
+#
+#----------------------------------------------------------------------------
+#
+#      Copyright (C) 2008 by Colin Steele. All Rights Reserved.
+#                        colin@colinsteele.org
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either: 1) the GNU General Public License
+# as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version; or 2) Ruby's License.
+# 
+# See the file COPYING for complete licensing information.
+#
+#---------------------------------------------------------------------------
+#
+# 
+#############################################################################
+
+require 'observer'
+
+module HomeQ
+
+  module SOBS
+
+    class Queue
+
+      include Observable
+      include Base::Logging
+      include Base::Configuration
+      include HomeQ
+
+      READ_ONLY  = 'r'
+      WRITE_ONLY = 'w'
+      READ_WRITE = 'w+'
+      MODES = [READ_ONLY, WRITE_ONLY, READ_WRITE]
+
+      attr :queue_name, true
+      attr :host, true
+      attr :port, true
+      attr :mode, true
+      attr :args, true
+      attr :handler, true
+
+      # Make our config available
+      module HomeQ::Base::Commando::InstanceMethods
+        config_accessor :queue_retry
+        document_command "queue_retry [int]", "Get/set reconnect interval"
+      end
+      
+      def self.[](queue_name)
+        sys.queues.find { |q|
+          q.queue_name == queue_name
+        }
+      end
+      
+      def self.send(queue_name, data, app_data=nil, &block)
+        dest = Queue[queue_name]
+        unless dest
+          raise HomeQ::Base::UnknownQueue.new("Can't find queue #{queue_name}") 
+        end
+        raise HomeQ::Base::ReadOnlyQueue unless dest.writeable?
+        dest.send(data, app_data, block)
+      end
+
+      def self.create_queues_from_topology(queuename)
+        config = HomeQ::Base::Configuration::Configuration.instance
+        q, host, port, hostname = config.topology[queuename]
+        config.topology.connections(q).each { |peer,mode,threshold|
+          raise "No config for queue '#{peer}'." unless config.topology[peer]
+          q, host, port = config.topology[peer]
+          queue = HomeQ::SOBS::Queue.new(q, host, port, mode, threshold)
+          Base::System.instance.queues << queue
+        }
+      end
+      
+      def initialize(*args)
+        @queue_name, @host, @port, @mode, @threshold, @args = args
+        raise "Nil queue_name, probably a config error" unless @queue_name
+
+        @conn                                   = nil
+        @retry_timer                            = config.queue_retry || 5
+        @acks                                   = {}
+        
+        # stats
+        
+        @concurrent_outstanding_jobs            = 0
+        @concurrent_outstanding_jobs_highwater  = 0
+        @jobs_received                          = 0
+
+      end
+
+      def start
+        logger.info {
+          "Initiating connection to queue '#{@queue_name}' " +
+            "at #{@host}:#{@port}, mode '#{@mode}', " +
+            "handler #{(@handler || Job)}."
+        }
+        Client.connect(host, port, config.queue_retry || 5, nil, self)
+      end
+
+      def closed
+        if @conn
+          logger.info {
+            "Disconnected from queue '#{queue_name}' " +
+              "on #{@conn.remote_endpoint}."
+          }
+          @started_at = nil
+          @conn = nil
+        end
+        broadcast_change
+      end
+
+      def opened(conn)
+        @conn = conn
+        @conn.refuse_send_threshold = @threshold if @threshold
+        @started_at = Time.now
+        logger.info {
+          "Connected to '#{queue_name}' on #{conn.remote_endpoint}."
+        }
+        broadcast_change
+      end
+
+      def stop
+        @conn.close_connection_after_writing if @conn
+      end
+
+      def release_job(job)
+        @conn.delete(job.job_id)
+        @concurrent_outstanding_jobs -= 1
+      end
+
+      def ack(message)
+        app_data = message.args[1]
+        if @acks[app_data.to_sym]
+          @acks[app_data.to_sym].call(app_data)
+          @acks.delete(app_data.to_sym)
+        end
+      end
+
+      def deleted(message)
+      end
+
+      def create_job(message)
+        @jobs_received               += 1
+        @concurrent_outstanding_jobs += 1
+        if @concurrent_outstanding_jobs > 100
+          logger.warn {
+            "Outstanding jobs: #{@concurrent_outstanding_jobs}"
+          }
+        end
+        set_jobs_highwater
+        j = (@handler || Job).new(message, self)
+        j.run if j.respond_to?(:run)
+      end
+
+      def set_jobs_highwater
+        @concurrent_outstanding_jobs_highwater = [
+          @concurrent_outstanding_jobs_highwater,
+          @concurrent_outstanding_jobs
+        ].max
+      end
+
+      def send(data, app_data=nil, proc=nil)
+        return if !@conn || @conn.state.state != :open
+        app_data ||= generate_app_data
+        @acks[app_data.to_s.to_sym] = proc if proc
+        @conn.put(:body=>data, :app_data=>app_data)
+      end
+
+      def writeable?
+        mode != READ_ONLY
+      end
+
+      def readable?
+        mode != WRITE_ONLY
+      end
+
+      def connected?
+        @conn ? true : false
+      end
+
+      protected
+      
+      # A unique id
+      def generate_app_data
+        UUID.timestamp_create.to_sym
+      end
+        
+      # Tell folks something.
+      def broadcast_change
+        changed
+        notify_observers(self)
+      end
+
+      # String representation of queue
+      def to_s
+        str = ''
+        str << "Queuename: #{@queue_name}"
+        str << " on #{@host}:#{@port}" if @host || @port
+        str << " mode #{@mode}"
+        str << " handler #{(@handler || Job)}"
+        str << "\n"
+        str << "Jobs rcvd: #{@jobs_received}, "
+        str << " highwater: #{@concurrent_outstanding_jobs_highwater}"
+        str << "\n"
+        if connected?
+          str << @conn.to_s
+        end
+        str
+      end
+
+    end # Queue
+  
+  end  # SOBS
+
+end # HomeQ