SciMed-bj 1.2.4

data/HISTORY

@@ -0,0 +1,83 @@
+  1.2.1 
+    - Vibes fix for Ruby 1.8.7 and new Rakefile to make building the gem easier
+
+  1.2.0
+    - fixes to docs
+    - added license
+    - factored out job running logic into job.run(), for testing
+    - added some specs.  gasp.
+
+  1.0.3
+    - env wasn't properly unpacked by runner, added YAML.load(job.env), thanks
+      Chris Wanstrath  
+    - made operations that generate migrations, etc, verbose - they dump
+      stdout and stderr to console when running
+
+  1.0.2:
+    - Bj now (should) auto detect the correct rake command on windows as
+      "rake.bat" not "rake".  see Bj.which_rake and Bj.rake for impl.
+
+  1.0.1:
+    - fixed name collision with 'record.attributes = hash' ar mass
+      assignment method (thx jon guymon)
+    - added new sponsor: http://igicom.com/
+
+  0.0.5:
+    - use full path to ruby for plugin mode
+    - plugin correctly installs bin -->> script
+    - plugin install uses --force
+    - properly quote paths in windows (spaces)
+    - switch win signal to ABRT (was INT)
+    - background job regrestration now uses ppid to pin the subprocess to a
+      parent
+    - use ppid to detect parent death and exit in event loop 
+    - don't use gem dependanices in plugin as they are broken when loading from
+      muliple gem repos
+    - added a small amount of drb magic that allows signals to work across
+      processes even on windows (see http://drawohara.com/post/22540307)
+  
+0.0.4:
+  - basic functionality in windows
+  - several small bug fixes
+
+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/LICENSE

@@ -0,0 +1 @@
+same as ruby's 

data/README

@@ -0,0 +1,318 @@
+NAME
+  bj
+
+SYNOPSIS
+  bj (migration_code|generate_migration|migrate|setup|plugin|run|submit|list|set|config|pid) [options]+
+
+DESCRIPTION
+  ________________________________
+  Overview
+  --------------------------------
+  
+  Backgroundjob (Bj) is a brain dead simple, zero admin, background priority
+  queue for Rails.  Bj is robust, platform independent (including winblows),
+  and supports internal or external manangement of the background runner
+  process.
+  
+  Jobs can be submitted to the queue directly using the api or from the command
+  line using the ./script/bj:
+  
+    api:
+      Bj.submit 'cat /etc/password'
+  
+    command line:
+      bj submit cat /etc/password
+  
+  Bj's priority queue lives in the database and is therefore durable - your
+  jobs will live across an app crash or machine reboot.  The job management is
+  comprehensive - capturing stdout, stderr, exit_status, and temporal
+  statistics about each job:
+  
+    jobs =
+      Bj.submit command_or_array_of_commands, :priority => 42
+  
+    ...
+  
+    jobs.each do |job|
+      if job.finished?
+        p job.stdout
+        p job.stderr
+        p job.exit_status
+        p job.started_at
+        p job.finished_at
+      end
+    end
+  
+  In addition the background runner process logs all commands run and their
+  exit_status to a log named using the following convention:
+  
+    rails_root/log/bj.#{ HOSTNAME }.#{ RAILS_ENV }.log
+  
+  Bj allows you to submit jobs to multiple databases; for instance, if your
+  application is running in development mode you may do:
+  
+    Bj.in :production do
+      Bj.submit 'my_job.exe'
+    end
+  
+  Bj manages the ever growing list of jobs ran by automatically archiving them
+  into another table (by default jobs > 24 hrs old are archived) to prevent the
+  jobs table from becoming bloated and huge.
+  
+  All Bj's tables are namespaced and accessible via the Bj module:
+  
+    Bj.table.job.find(:all)         # jobs table
+    Bj.table.job_archive.find(:all) # archived jobs
+    Bj.table.config.find(:all)      # configuration and runner state
+  
+  Bj always arranges for submitted jobs to run with a current working
+  directory of RAILS_ROOT and with the correct RAILS_ENV setting.  For
+  example, if you submit a job in production it will have ENV['RAILS_ENV'] ==
+  'production' when the job is ran.
+  
+  When Bj manages the background runner it will never outlive the rails
+  application - it is started and stopped on demand in parallel with the rails
+  app parent process.  This is also true for ./script/console - Bj will
+  automatically fire off the background runner to process jobs submitted using
+  the console iff needed.
+  
+  Bj starts *one process per server*.  For instance, if you are running 3
+  mongrels via mongrel cluster Bj will automatically fire up *one background
+  process* per mongrel.  This helps you scale background processes in a
+  relatively POLS fashion, but note that the number of background runners does
+  not *really* determine throughput - that is determined primarily by the
+  nature of the jobs themselves and how much work they perform per process,
+  though having more background processes can also help.
+  
+  
+  ________________________________
+  Architecture
+  --------------------------------
+  
+  If one ignores platform specific details the design of Bj is quite simple: the
+  main Rails application submits jobs to table, stored in the database.  The act
+  of submitting triggers exactly one of two things to occur:
+  
+    1) a new long running background runner to be started
+  
+    2) an existing background runner to be signaled
+  
+  The background runner refuses to run two copies of itself for a given
+  hostname/rails_env combination.  For example you may only have one background
+  runner processing jobs on localhost in development mode.
+  
+  The background runner, under normal circumstances, is managed by Bj itself -
+  you need do nothing to start, monitor, or stop it - it just works.  However,
+  some people will prefer manage their own background process, see 'External
+  Runner' section below for more on this.
+  
+  The runner simply processes each job in a highest priority oldest-in fashion,
+  capturing stdout, stderr, exit_status, etc. and storing the information back
+  into the database while logging it's actions.  When there are no jobs to run
+  the runner goes to sleep for 42 seconds; however this sleep is interuptable,
+  such as when the runner is signaled that a new job has been submitted so,
+  under normal circumstances there will be zero lag between job submission and
+  job running for an empty queue.
+  
+  
+  ________________________________
+  External Runner / Clustering
+  --------------------------------
+  
+  For the paranoid control freaks out there (myself included) it is quite
+  possible to manage and monitor the runner process manually.  This can be
+  desirable in production setups where monitoring software may kill leaking
+  rails apps periodically or in any case where you want to montior and control
+  the background process directly.
+  
+  Recalling that Bj will only allow one copy of itself to process jobs per
+  hostname/rails_env pair we can simply do something like this in cron
+  
+    cmd = bj run --forever \
+                 --rails_env=development \
+                 --rails_root=/Users/ahoward/rails_root
+  
+    */15 * * * * $cmd 
+  
+  this will simply attempt the start the background runner every 15 minutes if,
+  and only if, it's not *already* running.
+  
+  In addtion to this you'll want to tell Bj not to manage the runner itself
+  using
+  
+    Bj.config["production.no_tickle"] = true
+
+  For instance in ./config/initializer/bj.rb or ./config/environment.rb.
+  
+  Note that, for clusting setups, it's as simple as adding a crontab and
+  config entry like this for each host you app is running on.  Because Bj
+  throttles background runners per hostname this will allow one runner per
+  hostname - making it quite simple to cluster three nodes behind a besieged
+  rails application.
+  
+  
+  ________________________________
+  Designing Jobs
+  --------------------------------
+  
+  Bj runs it's jobs as command line applications.  It ensures that all jobs run
+  in RAILS_ROOT so it's quite natural to apply a pattern such as
+  
+    mkdir ./jobs
+    edit ./jobs/background_job_to_run
+  
+    ...
+  
+    Bj.submit "./jobs/background_job_to_run"
+  
+  If you need to run you jobs under an entire rails environment you'll need to
+  do this:
+  
+    Bj.submit "./script/runner ./jobs/background_job_to_run"
+  
+  Obviously "./script/runner" loads the rails environment for you.  It's worth
+  noting that this happens for each job and that this is by design: the reason
+  is that most rails applications leak memory like a sieve so, if one were to
+  spawn a long running process that used the application code base you'd have a
+  lovely doubling of memory usage on you app servers.  Although loading the
+  rails environment for each background job requires a little time, a little
+  cpu, and a lot less memory.  A future version of Bj will provide a way to load
+  the rails environment once and to process background jobs in this environment,
+  but anyone wanting to use this in production will be required to duct tape
+  their entire chest and have a team of oxen rip off the tape without screaming
+  to prove steelyness of spirit and profound understanding of the other side.
+  
+  Don't forget that you can submit jobs with command line arguments:
+  
+    Bj.submit "./jobs/a.rb 1 foobar --force" 
+  
+  and that you can do powerful things by passing stdin to a job that powers
+  through a list of work.  For instance, assume a "./jobs/bulkmail" job
+  resembling
+  
+    STDIN.each do |line|
+      address = line.strip
+      mail_message_to address
+    end
+    
+  then you could
+  
+    stdin = [
+      "foo@bar.com",
+      "bar@foo.com",
+      "ara.t.howard@codeforpeople.com",
+    ]
+  
+    Bj.submit "./script/runner ./jobs/bulkmail", :stdin => stdin
+  
+  and all those emails would be sent in the background.
+  
+  Bj's power is putting jobs in the background in a simple and robust fashion.
+  It's your task to build intelligent jobs that leverage batch processing, and
+  other, possibilities.  The upshot of building tasks this way is that they are
+  quite easy to test before submitting them from inside your application.
+  
+  
+  ________________________________
+  Install 
+  --------------------------------
+    
+    Bj can be installed two ways: as a plugin or via rubygems
+  
+      plugin:
+        1) ./script/plugin install http://codeforpeople.rubyforge.org/svn/rails/plugins/bj
+        2) ./script/bj setup
+  
+      gem:
+        1) $sudo gem install bj
+        2) add "require 'bj'" to config/environment.rb
+        3) bj setup
+  
+  ________________________________
+  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.  must respond_to
+              to_s
+    
+  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
+  
+  See lib/bj/api.rb for more details.
+  
+  ________________________________
+  Sponsors 
+  --------------------------------
+    http://quintess.com/
+    http://www.engineyard.com/
+    http://igicom.com/
+    http://eparklabs.com/
+  
+    http://your_company.com/      <<-- (targeted marketing aimed at *you*)
+  
+  ________________________________
+  Version
+  --------------------------------
+  1.0.1
+
+PARAMETERS
+  --rails_root=rails_root, -R (0 ~> rails_root=) 
+      the rails_root will be guessed unless you set this 
+  --rails_env=rails_env, -E (0 ~> rails_env=development) 
+      set the rails_env 
+  --log=log, -l (0 ~> log=STDERR) 
+      set the logfile 
+  --help, -h 
+
+AUTHOR
+  ara.t.howard@gmail.com
+
+URIS
+  http://codeforpeople.com/lib/ruby/
+  http://rubyforge.org/projects/codeforpeople/
+  http://codeforpeople.rubyforge.org/svn/rails/plugins/
+

data/Rakefile

@@ -0,0 +1,22 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "SciMed-bj"
+    gem.summary = %Q{Minor fork of ahoward/bj}
+    gem.description = %Q{Forked ahoward/bj because the way the bin/bj before_run method interacts with Main's logger= instance menthod breaks in Ruby 1.8.7. Forked again to add missing 'require logger'}
+    gem.email = ["josh.warchol@vibes.com", 'jk@jkraemer.net']
+    gem.homepage = "http://github.com/jkraemer/bj"
+    gem.authors = ["Ara T. Howard", "Joshua Warchol", "Jens Kraemer"]
+    gem.add_dependency 'main', '>= 2.6.0'
+    gem.add_dependency 'systemu', '>= 1.2.0'
+    gem.add_dependency 'orderedhash', '>= 0.0.3'
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Bj (or a dependency) not available."
+  puts $!
+end
+

data/SciMed-bj.gemspec

@@ -0,0 +1,77 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{SciMed-bj}
+  s.version = "1.2.4"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ara T. Howard", "Joshua Warchol", "Jens Kraemer"]
+  s.date = %q{2011-08-23}
+  s.default_executable = %q{bj}
+  s.description = %q{Forked ahoward/bj because the way the bin/bj before_run method interacts with Main's logger= instance menthod breaks in Ruby 1.8.7. Forked again to add missing 'require logger'}
+  s.email = ["josh.warchol@vibes.com", "jk@jkraemer.net"]
+  s.executables = ["bj"]
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README",
+    "TODO"
+  ]
+  s.files = [
+    "HISTORY",
+    "LICENSE",
+    "README",
+    "Rakefile",
+    "SciMed-bj.gemspec",
+    "TODO",
+    "VERSION",
+    "bin/bj",
+    "init.rb",
+    "install.rb",
+    "lib/bj.rb",
+    "lib/bj/api.rb",
+    "lib/bj/bj.rb",
+    "lib/bj/errors.rb",
+    "lib/bj/joblist.rb",
+    "lib/bj/logger.rb",
+    "lib/bj/runner.rb",
+    "lib/bj/stdext.rb",
+    "lib/bj/table.rb",
+    "lib/bj/util.rb",
+    "plugin/HISTORY",
+    "plugin/README",
+    "plugin/Rakefile",
+    "plugin/init.rb",
+    "plugin/install.rb",
+    "plugin/script/bj",
+    "plugin/tasks/bj_tasks.rake",
+    "plugin/test/bj_test.rb",
+    "plugin/uninstall.rb",
+    "todo.yml"
+  ]
+  s.homepage = %q{http://github.com/jkraemer/bj}
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.4.2}
+  s.summary = %q{Minor fork of ahoward/bj}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<main>, [">= 2.6.0"])
+      s.add_runtime_dependency(%q<systemu>, [">= 1.2.0"])
+      s.add_runtime_dependency(%q<orderedhash>, [">= 0.0.3"])
+    else
+      s.add_dependency(%q<main>, [">= 2.6.0"])
+      s.add_dependency(%q<systemu>, [">= 1.2.0"])
+      s.add_dependency(%q<orderedhash>, [">= 0.0.3"])
+    end
+  else
+    s.add_dependency(%q<main>, [">= 2.6.0"])
+    s.add_dependency(%q<systemu>, [">= 1.2.0"])
+    s.add_dependency(%q<orderedhash>, [">= 0.0.3"])
+  end
+end
+