bjj 1.0.3

data/install.rb

@@ -0,0 +1,214 @@
+#!/usr/bin/env ruby
+require 'rbconfig'
+require 'find'
+require 'ftools'
+require 'tempfile'
+include Config
+
+LIBDIR      = "lib"
+LIBDIR_MODE = 0644
+
+BINDIR      = "bin"
+BINDIR_MODE = 0755
+
+
+$srcdir            = CONFIG["srcdir"]
+$version           = CONFIG["MAJOR"]+"."+CONFIG["MINOR"]
+$libdir            = File.join(CONFIG["libdir"], "ruby", $version)
+$archdir           = File.join($libdir, CONFIG["arch"])
+$site_libdir       = $:.find {|x| x =~ /site_ruby$/}
+$bindir            = CONFIG["bindir"] || CONFIG['BINDIR']
+$ruby_install_name = CONFIG['ruby_install_name'] || CONFIG['RUBY_INSTALL_NAME'] || 'ruby'
+$ruby_ext          = CONFIG['EXEEXT'] || ''
+$ruby              = File.join($bindir, ($ruby_install_name + $ruby_ext))
+
+if !$site_libdir
+  $site_libdir = File.join($libdir, "site_ruby")
+elsif $site_libdir !~ %r/#{Regexp.quote($version)}/
+  $site_libdir = File.join($site_libdir, $version)
+end
+
+def install_rb(srcdir=nil, destdir=nil, mode=nil, bin=nil)
+#{{{
+  path   = []
+  dir    = []
+  Find.find(srcdir) do |f|
+    next unless FileTest.file?(f)
+    next if (f = f[srcdir.length+1..-1]) == nil
+    next if (/CVS$/ =~ File.dirname(f))
+    next if (/\.svn/ =~ File.dirname(f))
+    next if f =~ %r/\.lnk/
+    next if f =~ %r/\.svn/
+    next if f =~ %r/\.swp/
+    next if f =~ %r/\.svn/
+    path.push f
+    dir |= [File.dirname(f)]
+  end
+  for f in dir
+    next if f == "."
+    next if f == "CVS"
+    File::makedirs(File.join(destdir, f))
+  end
+  for f in path
+    next if (/\~$/ =~ f)
+    next if (/^\./ =~ File.basename(f))
+    unless bin
+      File::install(File.join(srcdir, f), File.join(destdir, f), mode, true)
+    else
+      from = File.join(srcdir, f)
+      to = File.join(destdir, f)
+      shebangify(from) do |sf|
+        $deferr.print from, " -> ", File::catname(from, to), "\n"
+        $deferr.printf "chmod %04o %s\n", mode, to 
+        File::install(sf, to, mode, false)
+      end
+    end
+  end
+#}}}
+end
+def shebangify f
+#{{{
+  open(f) do |fd|
+    buf = fd.read 42 
+    if buf =~ %r/^\s*#\s*!.*ruby/o
+      ftmp = Tempfile::new("#{ $$ }_#{ File::basename(f) }")
+      begin
+        fd.rewind
+        ftmp.puts "#!#{ $ruby  }"
+        while((buf = fd.read(8192)))
+          ftmp.write buf
+        end
+        ftmp.close
+        yield ftmp.path
+      ensure
+        ftmp.close!
+      end
+    else
+      yield f
+    end
+  end
+#}}}
+end
+def ARGV.switch
+#{{{
+  return nil if self.empty?
+  arg = self.shift
+  return nil if arg == '--'
+  if arg =~ /^-(.)(.*)/
+    return arg if $1 == '-'
+    raise 'unknown switch "-"' if $2.index('-')
+    self.unshift "-#{$2}" if $2.size > 0
+    "-#{$1}"
+  else
+    self.unshift arg
+    nil
+  end
+#}}}
+end
+def ARGV.req_arg
+#{{{
+  self.shift || raise('missing argument')
+#}}}
+end
+def linkify d, linked = []
+#--{{{
+  if test ?d, d
+    versioned = Dir[ File::join(d, "*-[0-9].[0-9].[0-9].rb") ]
+    versioned.each do |v| 
+      src, dst = v, v.gsub(%r/\-[\d\.]+\.rb$/, '.rb')
+      lnk = nil
+      begin
+        if test ?l, dst
+          lnk = "#{ dst }.lnk"
+          puts "#{ dst } -> #{ lnk }"
+          File::rename dst, lnk
+        end
+        unless test ?e, dst
+          puts "#{ src } -> #{ dst }"
+          File::copy src, dst 
+          linked << dst
+        end
+      ensure
+        if lnk
+          at_exit do
+            puts "#{ lnk } -> #{ dst }"
+            File::rename lnk, dst
+          end
+        end
+      end
+    end
+  end
+  linked
+#--}}}
+end
+
+
+#
+# main program
+#
+
+libdir = $site_libdir
+bindir = $bindir
+no_linkify = false
+linked = nil
+help = false
+
+usage = <<-usage
+  #{ File::basename $0 }
+    -d, --destdir    <destdir>
+    -l, --libdir     <libdir>
+    -b, --bindir     <bindir>
+    -r, --ruby       <ruby>
+    -n, --no_linkify
+    -s, --sudo
+    -h, --help
+usage
+
+begin
+  while switch = ARGV.switch
+    case switch
+    when '-d', '--destdir'
+      libdir = ARGV.req_arg
+    when '-l', '--libdir'
+      libdir = ARGV.req_arg
+    when '-b', '--bindir'
+      bindir = ARGV.req_arg
+    when '-r', '--ruby'
+      $ruby = ARGV.req_arg
+    when '-n', '--no_linkify'
+      no_linkify = true
+    when '-s', '--sudo'
+      sudo = 'sudo' 
+    when '-h', '--help'
+      help = true
+    else
+      raise "unknown switch #{switch.dump}"
+    end
+  end
+rescue
+  STDERR.puts $!.to_s
+  STDERR.puts usage
+  exit 1
+end    
+
+if help
+  STDOUT.puts usage
+  exit
+end
+
+system "#{ sudo } #{ $ruby } pre-install.rb" if test(?s, 'pre-install.rb')
+
+unless no_linkify
+  linked = linkify('lib') + linkify('bin')
+end
+
+system "#{ $ruby } extconf.rb && make && #{ sudo } make install" if test(?s, 'extconf.rb')
+
+install_rb(LIBDIR, libdir, LIBDIR_MODE)
+install_rb(BINDIR, bindir, BINDIR_MODE, bin=true)
+
+if linked
+  linked.each{|path| File::rm_f path}
+end
+
+system "#{ sudo } #{ $ruby } post-install.rb" if test(?s, 'post-install.rb')

data/lib/bj.rb

@@ -0,0 +1,87 @@
+unless defined? Bj 
+  class Bj 
+  #
+  # constants and associated attrs
+  #
+    Bj::VERSION = "1.0.2" #unless defined?(Bj::VERSION)
+    def self.version() Bj::VERSION end
+
+    Bj::LIBDIR = File.expand_path(File::join(File.dirname(__FILE__), "bj")) + File::SEPARATOR unless
+      defined? Bj::LIBDIR
+    def self.libdir(*value) 
+      unless value.empty?
+        File.join libdir, *value
+      else
+        Bj::LIBDIR 
+      end
+    end
+
+    module EXIT 
+      SUCCESS = 0
+      FAILURE = 1
+      WARNING = 42
+    end
+  #
+  # built-in
+  #
+    require "socket"
+    require "yaml"
+    require "thread"
+    require "rbconfig"
+    require "set"
+    require "erb"
+    require "tempfile"
+  #
+  # bootstrap rubygems 
+  #
+    begin
+      require "rubygems"
+    rescue LoadError
+      42
+    end
+  #
+  # rubyforge/remote
+  #
+    require "active_record"
+  #
+  # rubyforge/remote or local/lib 
+  #
+    #%w[ attributes systemu orderedhash ].each do |lib|
+    %w[ systemu orderedhash ].each do |lib|
+      begin
+        require lib
+      rescue
+        require libdir(lib)
+      end
+    end
+  #
+  # local 
+  #
+    load libdir("attributes.rb")
+    load libdir("stdext.rb")
+    load libdir("util.rb")
+    load libdir("errors.rb")
+    load libdir("logger.rb")
+    load libdir("bj.rb")
+    load libdir("joblist.rb")
+    load libdir("table.rb")
+    load libdir("runner.rb")
+    load libdir("api.rb")
+  #
+  # 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
+      returned = load __FILE__ rescue nil
+      Bj.runner.background = background if background
+      returned
+    end
+  end
+
+  BackgroundJob = Bj
+end

data/lib/bj/api.rb

@@ -0,0 +1,164 @@
+class Bj
+#
+# the api exposes nearly all the bj code you'll likely need, with the
+# exception of accessing the job table for searching, which is done using
+#
+# eg.
+#
+#   Bj.table.job.find :all
+#
+  module API
+  #
+  # submit jobs for background processing.  'jobs' can be a string or array of
+  # strings.  options are applied to each job in the 'jobs', and the list of
+  # submitted jobs is always returned.  options (string or symbol) can be
+  #
+  #   :rails_env => production|development|key_in_database_yml 
+  #                 when given this keyword causes bj to submit jobs to the
+  #                 specified database.  default is RAILS_ENV.
+  #
+  #   :priority => any number, including negative ones.  default is zero.
+  #
+  #   :tag => a tag added to the job.  simply makes searching easier.
+  #
+  #   :env => a hash specifying any additional environment vars the background
+  #           process should have.
+  #
+  #   :stdin => any stdin the background process should have.
+  #
+  # eg:
+  #
+  #   jobs = Bj.submit 'echo foobar', :tag => 'simple job'
+  #
+  #   jobs = Bj.submit '/bin/cat', :stdin => 'in the hat', :priority => 42
+  #
+  #   jobs = Bj.submit './script/runner ./scripts/a.rb', :rails_env => 'production'
+  #
+  #   jobs = Bj.submit './script/runner /dev/stdin', :stdin => 'p RAILS_ENV', :tag => 'dynamic ruby code'
+  #
+  #   jobs = Bj.submit array_of_commands, :priority => 451 
+  #
+  # when jobs are run, they are run in RAILS_ROOT.  various attributes are
+  # available *only* once the job has finished.  you can check whether or not
+  # a job is finished by using the #finished method, which simple does a
+  # reload and checks to see if the exit_status is non-nil.
+  #
+  # eg:
+  #
+  #   jobs = Bj.submit list_of_jobs, :tag => 'important'
+  #   ...
+  #   
+  #   jobs.each do |job|
+  #     if job.finished?
+  #       p job.exit_status
+  #       p job.stdout
+  #       p job.stderr
+  #     end
+  #   end
+  #
+  #
+    def submit jobs, options = {}, &block
+      options.to_options!
+      Bj.transaction(options) do
+        table.job.submit jobs, options, &block
+      end
+    ensure
+      Bj.runner.tickle unless options[:no_tickle]
+    end
+  #
+  # this method changes the context under which bj is operating.  a context is
+  # a RAILS_ENV.  the method accepts a block and it used to alter the
+  # behaviour of the bj lib on a global scale such that all operations,
+  # spawning of background runnner processes, etc, occur in that context.
+  #
+  # eg:
+  #
+  #  Bj.in :production do
+  #    Bj.submit './script/runner ./scripts/facebook_notification.rb'
+  #  end
+  #
+  #  Bj.in :development do
+  #    Bj.submit 'does_this_eat_memory.exe'
+  #  end
+  #
+    def in rails_env = Bj.rails_env, &block
+      transaction(:rails_env => rails_env.to_s, &block)
+    end
+  #
+  # 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
+  #
+  #
+  #
+    def run options = {}
+      runner.run options
+    end
+  #
+  # generate a migration and migrate a database (production/development/etc)
+  #
+    def setup options = {}
+      options.to_options!
+      chroot do
+        generate_migration options
+        migrate options
+      end
+    end
+  #
+  # generate_migration, suprisingly, generates the single migration needed for
+  # bj.  you'll notice the the migration is very short as the migration
+  # classes themselves are inner classes of the respective bj table class.
+  # see lib/bj/table.rb for details.
+  #
+    def generate_migration options = {}
+      options.to_options!
+      options[:verbose] = true
+      chroot do
+        before = Dir.glob "./db/migrate/*"
+        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
+          when 0
+            false
+          when 1
+            generated = candidates.first
+            open(generated, "w"){|fd| fd.puts Bj.table.migration_code(classname)}
+            Bj.logger.info{ "generated <#{ generated }>" }
+            generated
+          else
+            raise "ambiguous migration <#{ candidates.inspect }>"
+        end
+      end
+    end
+  #
+  # migrate a database (production|development|etc)
+  #
+    def migrate options = {}
+      options.to_options!
+      options[:verbose] = true
+      chroot do
+        util.spawn "#{ Bj.rake } RAILS_ENV=#{ Bj.rails_env } db:migrate", options
+      end
+    end
+  #
+  # install plugin into this rails app 
+  #
+    def plugin options = {}
+      options.to_options!
+      options[:verbose] = true
+      chroot do
+        util.spawn "#{ Bj.ruby } ./script/plugin install http://codeforpeople.rubyforge.org/svn/rails/plugins/bj --force", options
+      end
+    end
+  end
+  send :extend, API
+end