bj 0.0.2 → 0.0.3

data/HISTORY

@@ -1,2 +1,41 @@
+0.0.3:
+  - *many* small bug fixes
+
+  - plugin install should now pick up dependancies from plugin dir, last
+    release had LOAD_PATH/gem issues and was picking up globally installed
+    gems
+
+  - automatic management of the background processing can be turned off if you
+    want to manage your own processes 
+
+  - all jobs are automatically restartable unless submitted with 
+
+       :restartable => false
+
+    this means that, should a runner ever die, upon restart any jobs that were
+    mid-process will automatically be restarted
+
+  - signal based parent lifeline move out of thread and into even loop
+
+  - :lock => true added to a few AR finds to support true write serializable
+    transaction isolation when the db supports it
+
+  - all migrations now use :force => true and
+
+  - running 'bj setup' will always generate a new migration, even if you've
+    already run it before.  this allows easy version upgrades.
+
+  - a few command would blow up on windows because they weren't prefixed with
+    'ruby'.  gotta love the lack of #shebang line on windoze...
+
+  - ./script/bj is searched first before system path env var
+
+  - a default PATH is provided for whacky systems without one
+
+  - database.yml is filtered through ERB ala rails
+  
+0.0.2:
+  - path bug fixes
+
 0.0.1:
   - initial release

data/TODO

@@ -1,3 +1,35 @@
-* flesh out the cli interface - it's a test only at this point
-* test in windows
-* make sure database.yml is loaded via YAML::load(ERB.new(File.read * "config/database.yml").result)
+
+- need a new signal, or no signal on windows
+
+- ./script/console submission hangs on windows
+
+- ttl will be added. maxing it out will cause auto-resubmission (Steve Midgley)
+
+- is having the runner thread try forever to start the process the best thing?
+
+- allow easy way to run ruby code.  perhaps ./script/runner 'eval STDIN.read'
+  is good enough
+
+- allow easy way to run ruby code that persists
+
+- allow specification of runner on submit (--runner)
+
+- allow specification of tags a runner will consume (--tag)
+
+- flesh out the cli interface - it's a test only at this point
+
+- test in windows
+
+================================================================================
+
+X default PATH setting
+X install issues for dave? - gem_path...
+X main only loaded for (bin|script)/bj
+X make it possible to declare externally managed runners
+X restartable will be added. true by default (Steve Midgley)
+X do the lifeline inline with the loop
+X need to address the serialzable writer issue (:lock => true ??)
+X migrations use --force
+X i forget to add "#{ Bj.ruby } ... " to the generate command
+X ./script/bj must be found in path before c:/.....bin/bj
+X make sure database.yml is loaded via YAML::load(ERB.new(File.read * "config/database.yml").result)

data/bin/bj

@@ -1,5 +1,6 @@
 #! /usr/bin/env ruby
 
+require "main"
 require "bj"
 
 Main {
@@ -178,30 +179,55 @@ Main {
     description "generate a migration and migrate"
 
     def run
+      set_rails_env(argv.first) if argv.first
       Bj.setup
     end
   end
 
+  mode "plugin" do
+    description "dump the plugin into rails_root"
+
+    def run
+      Bj.plugin
+    end
+  end
+
   mode "run" do
     description "start a job runnner, possibly as a daemon"
 
     option("--forever"){}
-    option("--daemon"){}
     option("--ppid"){
       argument :required
       cast :integer
     }
+    option("--wait"){
+      argument :required
+      cast :integer
+    }
+    option("--limit"){
+      argument :required
+      cast :integer
+    }
     option("--redirect"){
       argument :required
     }
+    option("--daemon"){}
 
     def run
       options = {}
 
-      %w[ forever daemon ppid ].each do |key|
+=begin
+      %w[ forever ].each do |key|
         options[key.to_sym] = true if param[key].given?
       end
+=end
 
+      %w[ forever ppid wait limit ].each do |key|
+        options[key.to_sym] = param[key].value if param[key].given?
+      end
+
+#p options
+#exit
       if param["redirect"].given?
         open(param["redirect"].value, "a+") do |fd|
           STDERR.reopen fd 
@@ -318,23 +344,23 @@ Main {
   def before_run 
     self.logger = param["log"].value
     Bj.logger = logger
+    set_rails_root(param["rails_root"].value) if param["rails_root"].given?
+    set_rails_env(param["rails_env"].value) if param["rails_env"].given?
+  end
 
-    if param["rails_root"].given?
-      rails_root = param["rails_root"].value
-      ENV["RAILS_ROOT"] = rails_root 
-      ::Object.instance_eval do
-        remove_const :RAILS_ROOT
-        const_set :RAILS_ROOT, rails_root
-      end
+  def set_rails_root rails_root
+    ENV["RAILS_ROOT"] = rails_root 
+    ::Object.instance_eval do
+      remove_const :RAILS_ROOT
+      const_set :RAILS_ROOT, rails_root
     end
+  end
 
-    if param["rails_env"].given?
-      rails_env = param["rails_env"].value
-      ENV["RAILS_ENV"] = rails_env 
-      ::Object.instance_eval do
-        remove_const :RAILS_ENV
-        const_set :RAILS_ENV, rails_env
-      end
+  def set_rails_env rails_env
+    ENV["RAILS_ENV"] = rails_env 
+    ::Object.instance_eval do
+      remove_const :RAILS_ENV
+      const_set :RAILS_ENV, rails_env
     end
   end
 
@@ -392,19 +418,18 @@ BEGIN {
 #
 # see if we're running out of RAILS_ROOT/script/
 #
-unless defined? BJ_IS_SCRIPT  #{{{
+unless defined?(BJ_IS_SCRIPT)
   BJ_IS_SCRIPT =
     if %w[ script config app ].map{|d| test ?d, "#{ File.dirname __FILE__ }/../#{ d }"}.all?
       __FILE__
     else
       nil
     end
-end  #}}}
-
+end
 #
 # setup RAILS_ROOT
 #
-unless defined? RAILS_ROOT  #{{{
+unless defined?(RAILS_ROOT)
   ### grab env var first
   rails_root = ENV["RAILS_ROOT"]
 
@@ -429,12 +454,11 @@ unless defined? RAILS_ROOT  #{{{
 
   ### bootstrap 
   RAILS_ROOT = rails_root
-end  #}}}
-
+end
 #
 # setup RAILS_ENV
 #
-unless defined? RAILS_ENV  #{{{
+unless defined?(RAILS_ENV)
   ### grab env var first
   rails_env = ENV["RAILS_ENV"]
 
@@ -450,18 +474,19 @@ unless defined? RAILS_ENV  #{{{
 
   ### bootstrap 
   RAILS_ENV = rails_env
-end  #}}}
-
+end
 #
 # setup $LOAD_PATH to detect plugin - iff it is installed and running out of
 # RAILS_ROOT/script
 #
-if RAILS_ROOT  #{{{
-  if BJ_IS_SCRIPT and test(?d, "#{ RAILS_ROOT }/vendor/plugins/bj/lib")
+if RAILS_ROOT and BJ_IS_SCRIPT
+  if test(?d, "#{ RAILS_ROOT }/vendor/plugins/bj/lib")
     $LOAD_PATH.unshift "#{ RAILS_ROOT }/vendor/plugins/bj/lib"
   end
-end  #}}}
-
+  if test(?s, "#{ RAILS_ROOT }/vendor/plugins/bj/init.rb")
+    load "#{ RAILS_ROOT }/vendor/plugins/bj/init.rb"
+  end
+end
 #
 # ensure that rubygems is loaded
 #
@@ -470,7 +495,6 @@ end  #}}}
   rescue
     42
   end
-
 #
 # hack to_s of STDERR/STDOUT for nice help messages
 #

data/lib/bj.rb

@@ -29,6 +29,8 @@ unless defined? Bj
     require "yaml"
     require "thread"
     require "rbconfig"
+    require "set"
+    require "erb"
   #
   # bootstrap rubygems 
   #
@@ -44,7 +46,7 @@ unless defined? Bj
   #
   # rubyforge/remote or local/lib 
   #
-    %w[ attributes main systemu orderedhash ].each do |lib|
+    %w[ attributes systemu orderedhash ].each do |lib|
       begin
         require lib
       rescue
@@ -67,11 +69,15 @@ unless defined? Bj
   # an imperfect reloading hook - because neither rails' plugins nor gems provide one, sigh...
   #
     def self.reload!
+      background = nil
       ::Object.module_eval do
+        background = Bj.runner.background
         remove_const :Bj rescue nil
         remove_const :BackgroundJob rescue nil
       end
-      load __FILE__ rescue nil
+      returned = load __FILE__ rescue nil
+      Bj.runner.background = background if background
+      returned
     end
   end
 

data/lib/bj/api.rb

@@ -88,7 +88,9 @@ class Bj
   # list simply returns a list of all jobs in the job table
   #
     def list options = {}, &block
+      options.to_options!
       Bj.transaction(options) do
+        options.delete :rails_env
         table.job.find(:all, options)
       end
     end
@@ -118,7 +120,9 @@ class Bj
       options.to_options!
       chroot do
         before = Dir.glob "./db/migrate/*"
-        util.spawn "./script/generate migration BjMigration", options rescue nil
+        n = Dir.glob("./db/migrate/*_bj_*").size
+        classname = "BjMigration#{ n }"
+        util.spawn "#{ Bj.ruby } ./script/generate migration #{ classname }", options rescue nil
         after = Dir.glob "./db/migrate/*"
         candidates = after - before
         case candidates.size
@@ -126,7 +130,7 @@ class Bj
             false
           when 1
             generated = candidates.first
-            open(generated, "w"){|fd| fd.puts Bj.table.migration_code}
+            open(generated, "w"){|fd| fd.puts Bj.table.migration_code(classname)}
             Bj.logger.info{ "generated <#{ generated }>" }
             generated
           else
@@ -143,6 +147,15 @@ class Bj
         util.spawn "rake RAILS_ENV=#{ Bj.rails_env } db:migrate", options
       end
     end
+  #
+  # install plugin into this rails app 
+  #
+    def plugin options = {}
+      options.to_options!
+      chroot do
+        util.spawn "./script/plugin install http://codeforpeople.rubyforge.org/svn/rails/plugins/bj", options
+      end
+    end
   end
   send :extend, API
 end

data/lib/bj/bj.rb

@@ -3,7 +3,7 @@ class Bj
     attribute("rails_root"){ Util.const_or_env("RAILS_ROOT"){ "." } }
     attribute("rails_env"){ Util.const_or_env("RAILS_ENV"){ "development" } }
     attribute("database_yml"){ File.join rails_root, "config", "database.yml" }
-    attribute("configurations"){ YAML.load IO.read(database_yml) }
+    attribute("configurations"){ YAML::load(ERB.new(IO.read(database_yml)).result) }
     attribute("tables"){ Table.list }
     attribute("hostname"){ Socket.gethostname }
     attribute("logger"){ Bj::Logger.off STDERR }
@@ -15,71 +15,50 @@ class Bj
     attribute('util'){ Util }
     attribute('runner'){ Runner }
     attribute('joblist'){ Joblist }
+    attribute('default_path'){ %w'/bin /usr/bin /usr/local/bin /opt/local/bin'.join(File::PATH_SEPARATOR) }
 
     def transaction options = {}, &block
       options.to_options!
-      options.reverse_merge! :rails_env => Bj.rails_env
-      bj_rails_env = Bj.rails_env
-      begin
-        Bj.rails_env = options[:rails_env].to_s
-        connecting(options) do
-          ActiveRecord::Base.transaction do 
-            block.call ActiveRecord::Base.connection
-          end
-        end
-      ensure
-        Bj.rails_env = bj_rails_env 
-      end
-    end
 
-    def connecting options = {}, &block
-      options.to_options!
-      rails_env = (options[:rails_env] || Bj.rails_env).to_s
-      previous = ar_connection
-      ActiveRecord::Base.connection = connections[rails_env] unless ActiveRecord::Base.connection == connections[rails_env]
-      begin
-        block.call ActiveRecord::Base.connection
-      ensure
-        ActiveRecord::Base.connection = previous unless ActiveRecord::Base.connection == previous
-      end
-    end
+      cur_rails_env = Bj.rails_env.to_s
+      new_rails_env = options[:rails_env].to_s
 
-    def connections
-      @connections ||= Hash.new do |hash, rails_env|
-        rails_env = rails_env.to_s
-        ActiveRecord::Base.establish_connection configurations[rails_env]
-        hash[rails_env] = ActiveRecord::Base.connection
-      end.merge(ar_connections)
-      @connections
-    end
+      cur_spec = configurations[cur_rails_env]
+      table.establish_connection(cur_spec) unless table.connected?
 
-    def ar_connections
-      if defined?(RAILS_ENV)
-        { RAILS_ENV => ar_connection } 
+      if(new_rails_env.empty? or cur_rails_env == new_rails_env) 
+        table.transaction{ block.call(table.connection) }
       else
-        {}
-      end
-    end
-
-    def ar_connection
-      begin
-        ActiveRecord::Base.connection
-      rescue ActiveRecord::ConnectionNotEstablished 
-        ActiveRecord::Base.establish_connection configurations[rails_env] 
+        new_spec = configurations[new_rails_env]
+        table.establish_connection(new_spec)
+        Bj.rails_env = new_rails_env
+        begin
+          table.transaction{ block.call(table.connection) }
+        ensure
+          table.establish_connection(cur_spec)
+          Bj.rails_env = cur_rails_env
+        end
       end
     end
 
     def chroot options = {}, &block
       if defined? @chrooted and @chrooted
-        return block.call(@chrooted)
+        return(block ? block.call(@chrooted) : @chrooted)
       end
-      begin
-        Dir.chdir @chrooted = rails_root do |pwd|
-          raise RailsRoot, "<#{ pwd }> is not a rails root" unless Util.valid_rails_root?(pwd)
-          block.call(@chrooted)
+      if block
+        begin
+          chrooted = @chrooted
+          Dir.chdir(@chrooted = rails_root) do
+            raise RailsRoot, "<#{ Dir.pwd }> is not a rails root" unless Util.valid_rails_root?(Dir.pwd)
+            block.call(@chrooted)
+          end
+        ensure
+          @chrooted = chrooted 
         end
-      ensure
-        @chrooted = nil 
+      else
+        Dir.chdir(@chrooted = rails_root)
+        raise RailsRoot, "<#{ Dir.pwd }> is not a rails root" unless Util.valid_rails_root?(Dir.pwd)
+        @chrooted
       end
     end
 

data/lib/bj/runner.rb

@@ -33,7 +33,7 @@ class Bj
                 begin; Process.kill('SIGTERM', pid); rescue Exception; 42; end
               end
               at_exit &cleanup
-              pipe.each{|line|}
+              Process.wait
             end
 
             Bj.logger.error{ "#{ command } failed with #{ $?.inspect }" } unless
@@ -48,19 +48,35 @@ class Bj
     end
 
     module ClassMethods
+      attribute("thread"){ Thread.current }
+      attribute("signal"){ Signal.list.keys.index("HUP") ? "HUP" : "INT" }
+      attribute("signaled"){ true }
+
       def tickle
+        return nil if Bj.config[Runner.no_tickle_key]
         ping or start
       end
 
       def ping
         pid = Bj.config[Runner.key]
-        pid ? Util.ping(pid) : nil
+        return nil unless pid
+        pid = Integer pid
+        begin
+          Process.kill Runner.signal, pid
+          pid
+        rescue Exception 
+          false
+        end
       end
 
       def key
         "#{ Bj.rails_env }.pid"
       end
 
+      def no_tickle_key 
+        "#{ Bj.rails_env }.no_tickle"
+      end
+
       def start options = {}
         options.to_options!
         background.delete Bj.rails_env if options[:force]
@@ -71,8 +87,19 @@ class Bj
         @background ||= Hash.new
       end
 
+      def background= value
+        @background ||= value 
+      end
+
       def command
-        "#{ Bj.ruby } #{ Bj.script } run --forever --redirect=#{ log } --rails_env=#{ Bj.rails_env } --ppid=#{ Process.pid }"
+        %W[
+          #{ Bj.ruby } #{ Bj.script } run 
+          --forever 
+          --redirect=#{ log }
+          --ppid=#{ Process.pid }
+          --rails_env=#{ Bj.rails_env }
+          --rails_root=#{ Bj.rails_root }
+        ].join(" ")
       end
 
       def log
@@ -102,113 +129,148 @@ class Bj
         wait = options[:wait] || 42
         limit = options[:limit]
         forever = options[:forever]
-        ppid = options[:ppid]
 
         limit = false if forever
         wait = Integer wait
         loopno = 0
-        thread = new_lifeline(ppid) if ppid
 
-        Bj.chroot do
-          register or exit!(EXIT::WARNING)
-          Bj.logger.info{ "START" }
-          fill_morgue
-          install_signal_handlers
+        Runner.thread = Thread.current
+        Bj.chroot
 
-          loop do
-            loopno += 1
-            break if(limit and n > limit)
-
-            Bj.logger.debug{ "loopno #{ loopno }" }
-
-            sweep
-
-            catch :no_jobs do
-              loop do
-                job = thread = stdout = stderr = nil
-
-                Bj.transaction(options) do
-                  job = Bj::Table::Job.find :first,
-                                            :conditions => "state = 'pending'",
-                                            :order => "priority DESC, submitted_at ASC", 
-                                            :limit => 1
-                  throw :no_jobs unless job
-
-                  Bj.logger.info{ "running #{ job.id } (#{ job.command })" }
-
-                  command = job.command
-                  env = job.env || {}
-                  stdin = job.stdin || ''
-                  stdout = job.stdout || ''
-                  stderr = job.stderr || ''
-                  started_at = Time.now
-
-                  q = Queue.new
-                  thread = Thread.new do
-                    Thread.current.abort_on_exception = true
-                    systemu command, :cwd=>Bj.rails_root, :env=>env, :stdin=>stdin, :stdout=>stdout, :stderr=>stderr do |pid|
-                      q << pid
-                    end
-                  end
-                  pid = q.pop
-
-                  job.state = "running"
-                  job.runner = Bj.hostname
-                  job.pid = pid
-                  job.started_at = started_at 
-                  job.save!
-                  job.update
-                end
-
-                exit_status = thread.value
-                finished_at = Time.now
-
-                Bj.transaction(options) do
-                  job = Bj::Table::Job.find job.id 
-                  break unless job
-                  job.state = "finished"
-                  job.finished_at = finished_at 
-                  job.stdout = stdout
-                  job.stderr = stderr
-                  job.exit_status = exit_status
-                  job.save!
-                  job.update
-                  Bj.logger.info{ "exit_status #{ job.exit_status }" }
-                end
+        register or exit!(EXIT::WARNING)
+
+        Bj.logger.info{ "STARTED" }
+        at_exit{ Bj.logger.info{ "STOPPED" } }
+
+        fill_morgue
+        install_signal_handlers
+
+        loop do
+          ping_parent
+
+          loopno += 1
+          break if(limit and loopno > limit)
+
+          archive_jobs
+
+          catch :no_jobs do
+            loop do
+              job = thread = stdout = stderr = nil
+
+              Bj.transaction(options) do
+                now = Time.now
+
+                job = Bj::Table::Job.find :first,
+                                          :conditions => ["state = ? and submitted_at <= ?", "pending", now],
+                                          :order => "priority DESC, submitted_at ASC", 
+                                          :limit => 1,
+                                          :lock => true
+                throw :no_jobs unless job
+
+
+                Bj.logger.info{ "#{ job.title } - started" }
+
+                command = job.command
+                env = job.env || {}
+                stdin = job.stdin || ''
+                stdout = job.stdout || ''
+                stderr = job.stderr || ''
+                started_at = Time.now
+
+                thread = Util.start command, :cwd=>Bj.rails_root, :env=>env, :stdin=>stdin, :stdout=>stdout, :stderr=>stderr
+
+                job.state = "running"
+                job.runner = Bj.hostname
+                job.pid = thread.pid
+                job.started_at = started_at 
+                job.save!
+                job.reload
+              end
+
+              exit_status = thread.value
+              finished_at = Time.now
+
+              Bj.transaction(options) do
+                job = Bj::Table::Job.find job.id 
+                break unless job
+                job.state = "finished"
+                job.finished_at = finished_at 
+                job.stdout = stdout
+                job.stderr = stderr
+                job.exit_status = exit_status
+                job.save!
+                job.reload
+                Bj.logger.info{ "#{ job.title } - exit_status=#{ job.exit_status }" }
               end
             end
+          end
 
-            sleep wait
+          Runner.signaled false
+          wait.times do
+            sleep 1
+            break if Runner.signaled?
+          end 
+
+          break unless(limit or limit == false)
+        end
+      end
+
+      def ping_parent
+        ppid = options[:ppid]
+        return unless ppid 
+        begin
+          Process.kill 0, Integer(ppid)
+        rescue Errno::ESRCH
+          Kernel.exit 42
+        rescue Exception
+          42
+        end
+      end
 
-            break unless(limit or limit == false)
+      def install_signal_handlers
+        trap(Runner.signal) do
+          begin
+            Runner.signaled!
+          rescue Exception => e
+            Bj.logger.error{ e } 
           end
         end
+
+        trap("INT"){ exit } unless Runner.signal == "INT"
+      rescue Exception
+        42
       end
 
       def fill_morgue options = {}
-        Bj.logger.debug{ "filling the morgue..." }
         Bj.transaction(options) do
           now = Time.now
           jobs = Bj::Table::Job.find :all,
                                      :conditions => ["state = 'running' and runner = ?", Bj.hostname]
           jobs.each do |job|
-            Bj.logger.info{ "marking #{ job.id } (#{ job.command }) as dead." }
-            job.state = 'dead'
-            job.finished_at = now
+            if job.is_restartable?
+              Bj.logger.info{ "#{ job.title } - found dead and bloated but resubmitted" }
+              %w[ runner pid started_at finished_at stdout stderr exit_status ].each do |column|
+                job[column] = nil
+              end
+              job.state = 'pending'
+            else
+              Bj.logger.info{ "#{ job.title } - found dead and bloated" }
+              job.state = 'dead'
+              job.finished_at = now
+            end
             job.save!
           end
         end
       end
 
-      def sweep options = {}
-        Bj.logger.debug{ "sweeping..." }
+      def archive_jobs options = {}
         Bj.transaction(options) do
           now = Time.now
           too_old = now - Bj.ttl
           jobs = Bj::Table::Job.find :all,
                                      :conditions => ["(state = 'finished' or state = 'dead') and submitted_at < ?", too_old]
           jobs.each do |job|
-            Bj.logger.info{ "archiving #{ job.id } (#{ job.command })." }
+            Bj.logger.info{ "#{ job.title } - archived" }
             hash = job.to_hash.update(:archived_at => now)
             Bj::Table::JobArchive.create! hash 
             job.destroy
@@ -216,68 +278,25 @@ class Bj
         end
       end
 
-      def new_lifeline ppid
-        Thread.new do
-          loop do
-            begin
-              Process.kill 0, ppid
-            rescue Errno::ESRCH
-              STDERR.puts "parent #{ ppid } died"
-              Kernel.exit 42
-            end
-            sleep 42 
-          end
-        end
-      end
-
-      attribute 'sighup' => false
-
-      def install_signal_handlers
-        trap('SIGHUP') do
-          if sleeping?
-            Bj.logger.debug{ "woke up!" }
-            throw :wake_up
-          else
-            sighup true
-          end
-        end
-      end
-
-      def sleep seconds
-        if sighup
-          sighup false
-          return
-        end
-        Bj.logger.debug{ "sleeping #{ seconds }..." }
-        catch :wake_up do
-          begin
-            @sleeping = true
-            Kernel.sleep seconds
-          ensure
-            @sleeping = false
-          end
-        end
-      end
-
-      def sleeping?
-        @sleeping
-      end
-
       def register options = {}
         Bj.transaction(options) do
           pid = Bj.config[Runner.key]
-          if Util.alive?(pid)
-            return false
-          end
+          return false if Util.alive?(pid)
           Bj.config[Runner.key] = Process.pid
-          at_exit{ unregister }
         end
+        at_exit{ unregister }
+        true
+      rescue Exception
+        false
       end
 
       def unregister options = {}
         Bj.transaction(options) do
           Bj.config.delete Runner.key
         end
+        true
+      rescue Exception
+        false
       end
     end
     send :include, Instance_Methods

data/lib/bj/stdext.rb

@@ -31,6 +31,23 @@ class Hash
       replace reverse_merge(other)
     end
   end
+
+  begin
+    method "slice"
+  rescue
+    def slice(*keys)
+      allowed = Set.new(respond_to?(:convert_key) ? keys.map { |key| convert_key(key) } : keys)
+      reject { |key,| !allowed.include?(key) }
+    end
+  end
+
+  begin
+    method "slice!"
+  rescue
+    def slice!(*keys)
+      replace(slice(*keys))
+    end
+  end
 end
 
 class Object
@@ -54,17 +71,6 @@ class Object
   end
 end
 
-class Module 
-  Instance_Methods = instance_method "instance_methods" unless defined? Instance_Methods
-  def instance_methods &block
-    block ? module_eval(&block) : Instance_Methods.bind(self).call
-  end
-  def module_methods &block
-    block ? singleton_class(&block) : singleton_methods
-  end
-  alias_method "class_methods", "module_methods"
-end
-
 class String
   begin
     method 'underscore'

data/lib/bj/table.rb

@@ -7,26 +7,9 @@ class Bj
       attribute("list"){ Array.new }
       attribute("migration"){}
 
-      def generate_migration
-        before = Dir.glob "./db/migrate/*"
-        Util.spawn "./script/generate migration BjMigration"
-        after = Dir.glob "./db/migrate/*"
-        candidates = after - before
-        case candidates.size
-          when 0
-            false
-          when 1
-            generated = candidates.first
-            open(generated, "w"){|fd| fd.puts migration_code}
-            generated
-          else
-            raise "ambiguous migration <#{ candidates.inspect }>"
-        end
-      end
-
-      def migration_code
+      def migration_code classname = "BjMigration"
         <<-code
-          class BjMigration < ActiveRecord::Migration
+          class #{ classname } < ActiveRecord::Migration
             def self.up
               Bj::Table.each{|table| table.up}
             end
@@ -113,25 +96,26 @@ class Bj
       migration { 
         define_method :up do
           create_table table.table_name, :primary_key => table.primary_key, :force => true do |t|
-            t.column "command"      , :text
-
-            t.column "state"        , :text
-            t.column "priority"     , :integer
-            t.column "tag"          , :text
-
-            t.column "submitter"    , :text
-            t.column "runner"       , :text
-            t.column "pid"          , :integer
-
-            t.column "submitted_at" , :datetime
-            t.column "started_at"   , :datetime
-            t.column "finished_at"  , :datetime
-
-            t.column "env"          , :text
-            t.column "stdin"        , :text
-            t.column "stdout"       , :text
-            t.column "stderr"       , :text
-            t.column "exit_status"  , :integer
+            t.column "command"        , :text
+
+            t.column "state"          , :text
+            t.column "priority"       , :integer
+            t.column "tag"            , :text
+            t.column "is_restartable" , :integer
+
+            t.column "submitter"      , :text
+            t.column "runner"         , :text
+            t.column "pid"            , :integer
+
+            t.column "submitted_at"   , :datetime
+            t.column "started_at"     , :datetime
+            t.column "finished_at"    , :datetime
+
+            t.column "env"            , :text
+            t.column "stdin"          , :text
+            t.column "stdout"         , :text
+            t.column "stderr"         , :text
+            t.column "exit_status"    , :integer
           end
         end
 
@@ -159,6 +143,7 @@ class Bj
             :state => "pending",
             :priority => 0,
             :tag => "",
+            :is_restartable => true,
             :submitter => Bj.hostname,
             :submitted_at => Time.now, 
           }
@@ -167,6 +152,9 @@ class Bj
       send :extend, ClassMethods
 
       module InstanceMethods
+        def title
+          "job[#{ id }](#{ command })"
+        end
         def finished
           reload
           exit_status
@@ -183,26 +171,27 @@ class Bj
       migration {
         define_method(:up) do
           create_table table.table_name, :primary_key => table.primary_key, :force => true do |t|
-            t.column "command"      , :text
-
-            t.column "state"        , :text
-            t.column "priority"     , :integer
-            t.column "tag"          , :text
-
-            t.column "submitter"    , :text
-            t.column "runner"       , :text
-            t.column "pid"          , :integer
-
-            t.column "submitted_at" , :datetime
-            t.column "started_at"   , :datetime
-            t.column "finished_at"  , :datetime
-            t.column "archived_at"  , :datetime
-
-            t.column "env"          , :text
-            t.column "stdin"        , :text
-            t.column "stdout"       , :text
-            t.column "stderr"       , :text
-            t.column "exit_status"  , :integer
+            t.column "command"        , :text
+
+            t.column "state"          , :text
+            t.column "priority"       , :integer
+            t.column "tag"            , :text
+            t.column "is_restartable" , :integer
+
+            t.column "submitter"      , :text
+            t.column "runner"         , :text
+            t.column "pid"            , :integer
+
+            t.column "submitted_at"   , :datetime
+            t.column "started_at"     , :datetime
+            t.column "finished_at"    , :datetime
+            t.column "archived_at"    , :datetime
+
+            t.column "env"            , :text
+            t.column "stdin"          , :text
+            t.column "stdout"         , :text
+            t.column "stderr"         , :text
+            t.column "exit_status"    , :integer
           end
         end
 
@@ -277,7 +266,7 @@ class Bj
           transaction do
             options.to_options!
             hostname = options[:hostname] || Bj.hostname
-            record = find :first, :conditions => conditions(:key => key, :hostname => hostname) 
+            record = find :first, :conditions => conditions(:key => key, :hostname => hostname), :lock => true
             cast = options[:cast] || cast_for(value)
             key = key.to_s
             value = value.to_s
@@ -294,7 +283,7 @@ class Bj
 
         def delete key
           transaction do
-            record = find :first, :conditions => conditions(:key => key) 
+            record = find :first, :conditions => conditions(:key => key), :lock => true
             if record
               record.destroy
               record

data/lib/bj/util.rb

@@ -29,6 +29,17 @@ class Bj
         [ stdout, stderr ]
       end
 
+      def start *a 
+        q = Queue.new
+        thread = Thread.new do
+          Thread.current.abort_on_exception = true
+          systemu(*a){|pid| q << pid}
+        end
+        pid = q.pop
+        thread.singleton_class{ define_method(:pid){ pid } }
+        thread
+      end
+
       def alive pid
         return false unless pid 
         pid = Integer pid.to_s 
@@ -39,18 +50,6 @@ class Bj
       end
       alias_method "alive?", "alive"
 
-      def ping pid, options = {}
-        return false unless pid
-        pid = Integer pid
-        signal = options[:signal] || 'SIGHUP'
-        begin
-          Process::kill signal, pid
-          pid
-        rescue Exception 
-          false
-        end
-      end
-
       def which_ruby
         c = ::Config::CONFIG
         ruby = File::join(c['bindir'], c['ruby_install_name']) << c['EXEEXT']
@@ -59,10 +58,10 @@ class Bj
       end
 
       def find_script basename
-        path = ENV["PATH"] || ENV["path"]
+        path = ENV["PATH"] || ENV["path"] || Bj.default_path
         raise "no env PATH" unless path
         path = path.split File::PATH_SEPARATOR
-        path.push File.join(Bj.rails_root, "script")
+        path.unshift File.join(Bj.rails_root, "script")
         path.each do |directory|
           script = File.join directory, basename
           return File.expand_path(script) if(test(?s, script) and test(?r, script))
@@ -75,6 +74,13 @@ class Bj
         directories.all?{|dir| test(?d, File.join(root, dir))}
       end
       alias_method "valid_rails_root?", "valid_rails_root"
+
+      def emsg e
+        m = e.message rescue ""
+        c = e.class rescue Exception
+        b = e.backtrace.join("\n") rescue ""
+        "#{ m }(#{ c })\n#{ b }"
+      end
     end
     send :extend, ModuleMethods
   end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: bj
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
-date: 2007-12-12 00:00:00 -07:00
+  version: 0.0.3
+date: 2007-12-22 00:00:00 -07:00
 summary: bj
 require_paths: 
 - lib