dyoder-hive 0.1

data/lib/scheduler.rb

@@ -0,0 +1,70 @@
+require 'rubygems'
+require 'facets/duration' unless 1.respond_to? :minute
+
+module Hive
+  
+  class Scheduler < Hive::Worker
+  
+    def stop_tasks
+      threads = Thread.list.select { |t| t.alive? && t != Thread.current }
+      until threads.empty?
+        logger.info "#{threads.count} threads still running ... "
+        threads.each { |t| t.kill && t != Thread.current }
+        threads = threads.select { |t| t.alive? }
+      end
+      logger.info "All threads are finished."
+    end
+    
+    private 
+    
+    def schedule( method, options )
+      raise ArgumentError.new( "Invalid schedule for task #{method}.") unless valid?(options)
+      logger.info "Scheduling task #{method} ..."
+      Thread.new do
+        t = Time.now
+        loop do
+          t += 60
+          sleep( ( options[:interval] || ( t - Time.now ) ).to_i )
+          if match( t, options )
+            if self.respond_to?( method )
+              Thread.new do
+                logger.info "Running task #{method} ..."
+                self.send( method ) 
+                logger.info "Task #{method} complete."
+              end
+            else
+              logger.warn "Task #{method} scheduled but not defined."
+            end
+          end
+        end
+      end
+    end
+    
+    def valid?( options )
+      ! ( options.keys & [ :minute, :hour, :day, :weekday, :month, :interval] ).empty?
+    end
+    
+    def match( t, options )
+      options[:interval] ||
+        (( match_item( options[:minute], t.min )) &&
+         ( match_item( options[:hour], t.hour )) &&
+         ( match_item( options[:day], t.day )) &&
+         ( match_item( options[:weekday], t.wday )) &&
+         ( match_item( options[:month], t.month )))
+    end
+    
+    def match_item( x, y )
+      case x
+      when nil then true
+      when Array then x.include? y
+      when Range then x.include? y
+      when Integer then x == y
+      else 
+        logger.warn "Value #{x.inspect} will never be matched"
+        false
+      end
+    end
+    
+  end
+
+end

data/lib/worker.rb

@@ -0,0 +1,103 @@
+module Kernel
+  def safe_trap(*signals)
+    signals.each { |s| trap(s) { yield } }
+    Thread.new { loop { sleep 1 } } if RUBY_PLATFORM =~ /mswin32/
+  end   
+end
+
+module Hive
+  
+  # "Workers" are just dedicated processes. Managers, Servers, and Monitors are all
+  # examples of Workers. This class just encapsulates the common features across all
+  # Workers: daemonization, signal traps, console support, logging, only-ness, etc.
+  
+  class Worker
+    
+    def self.run( options = {} )
+      @instance ||= new( options )
+      @instance.start
+    end
+    
+    # make this the one-and-only
+    def self.instance ; @instance ; end
+    class << self ; private :new, :allocate ; end
+    private :dup, :clone
+    
+    attr_accessor :logger, :options
+    
+    def initialize( options )
+      @options = options
+    end
+    
+    # returns the PID of the new process
+    def start
+      pid = daemonize if options[ :daemon ]
+      puts "#{self.class.name} process #{pid} started ..." if pid
+      return pid if pid
+      begin
+        # from here on in, we're in the daemon
+        start_logger ; logger.info "#{self.class} starting ..."
+        start_debugger if options[:debug] # unless Kernel.engine == 'jruby'
+        # various ways to talk to a worker
+        set_traps ; start_console ; start_drb
+        start_tasks.join
+      rescue Exception => e
+        logger.error e.to_s
+      end
+    end
+    
+    def stop
+      logger.info "#{self.class} shutting down ..."
+      @console.stop if @console
+      stop_tasks
+    end
+    
+    def restart ; stop ; start ; end
+        
+    def daemonize
+      pwd = Dir.pwd ; pid = fork ; return pid if pid ; Dir.chdir( pwd )
+      File.umask 0000 ; STDIN.reopen( '/dev/null') ; 
+      STDOUT.reopen( '/dev/null', 'a' ) ; STDERR.reopen( STDOUT )
+      nil # return nil for child process, just like fork does
+    end
+    
+    def set_traps
+      safe_trap( 'HUP' ) { restart }
+      safe_trap( 'TERM','INT' ) { stop }
+    end
+    
+    def start_console
+      # TODO: add live console support
+    end
+    
+    def start_drb
+      # TODO: add DRb support
+    end
+    
+    def start_debugger
+      require 'ruby-debug' ; Debugger.start
+      Debugger.settings[:autoeval] = true if Debugger.respond_to?(:settings)
+      logger.info "ruby-debug enabled"
+    end
+    
+    def start_logger
+      if options[ :logger ]
+        @logger = options[ :logger ]
+      else
+        require 'logger'
+        @logger = Logger.new( 'log.out' )
+      end
+    end
+    
+    protected 
+    
+    # workers should override these methods
+    def start_tasks
+    end
+
+    def stop_tasks
+    end
+        
+  end
+  
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification 
+name: dyoder-hive
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- Dan Yoder
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-01 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: faces/duration
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "1.0"
+    version: 
+description: 
+email: dan@zeraweb.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/scheduler.rb
+- lib/worker.rb
+has_rdoc: true
+homepage: http://github.com/dyoder/hive
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.7
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Open-source Ruby framework for background processing.
+test_files: []
+