ambethia-bj 1.2.1

data/lib/bj/util.rb

@@ -0,0 +1,133 @@
+class Bj
+  module Util
+    module ModuleMethods
+      def constant_get const, &block
+        begin
+          ancestors = const.split(%r/::/)
+          parent = Object
+          while((child = ancestors.shift))
+            klass = parent.const_get child
+            parent = klass
+          end
+          klass
+        rescue
+          block ? block.call : raise
+        end
+      end
+
+      def const_or_env const, &block
+        constant_get(const){ ENV[const] || block.call }
+      end
+
+      def spawn cmd, options = {}
+        options.to_options!
+        logger = options.has_key?(:logger) ? options[:logger] : Bj.logger
+        verbose = options.has_key? :verbose
+        logger.info{ "cmd <#{ cmd }>" } if logger
+        status = systemu cmd, 1=>(stdout=""), 2=>(stderr="")
+        logger.info{ "status <#{ status.exitstatus }>" } if logger
+        if verbose
+          if logger
+            if stdout.empty?
+              logger.info{ "stdout <>" }
+            else
+              logger.info{ "stdout <" }
+              logger << stdout.strip.gsub(%r/^/, '  ')
+              logger << "\n>\n"
+            end
+            if stderr.empty?
+              logger.info{ "stderr <>" }
+            else
+              logger.info{ "stderr <" }
+              logger << stderr.strip.gsub(%r/^/, '  ')
+              logger << "\n>\n"
+            end
+          else
+            STDOUT.puts stdout
+            STDERR.puts stderr
+          end
+        end
+        status.exitstatus.zero? or raise "#{ cmd.inspect } failed with #{ $?.inspect }"
+        [ 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 
+        Process::kill 0, pid
+        true
+      rescue Errno::ESRCH, Errno::EPERM
+        false
+      end
+      alias_method "alive?", "alive"
+
+      def which_ruby
+        c = ::Config::CONFIG
+        ruby = File::join(c['bindir'], c['ruby_install_name']) << c['EXEEXT']
+        raise "ruby @ #{ ruby } not executable!?" unless test(?e, ruby)
+        ruby
+      end
+
+      def which_rake 
+        tmp = Tempfile.new Process.pid
+        tmp.write "task(:foobar){ puts 42 }"
+        tmp.close
+        bat = spawn("rake.bat -f #{ tmp.path.inspect } foobar", :logger => false) rescue false
+        bat ? "rake.bat" : "rake"
+      ensure
+        tmp.close! rescue nil
+      end
+
+      def ipc_signals_supported
+        @ipc_signals_supported ||=
+          IO.popen 'ruby', 'r+' do |ruby|
+            pid = ruby.pid
+            begin
+              Process.kill 'TERM', pid
+              true
+            rescue Exception
+              false
+            end
+          end
+      end
+      alias_method "ipc_signals_supported?", "ipc_signals_supported"
+
+      def find_script basename
+        path = ENV["PATH"] || ENV["path"] || Bj.default_path
+        raise "no env PATH" unless path
+        path = path.split File::PATH_SEPARATOR
+        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))
+        end
+        raise "no #{ basename } found in #{ path.inspect }"
+      end
+
+      def valid_rails_root root = ".", expected = %w[ config script app ]
+        directories = expected.flatten.compact.map{|dir| dir.to_s}
+        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
+end

data/plugin/HISTORY

@@ -0,0 +1,3 @@
+
+2007-12-18T14:19:22.86-07:00
+  - corrected install libs

data/plugin/README

@@ -0,0 +1,142 @@
+NAME
+  bj
+
+SYNOPSIS
+  bj (migration_code|generate_migration|migrate|setup|run|submit|list|set|config|pid) [options]+
+
+DESCRIPTION
+  ________________________________
+  Overview
+  --------------------------------
+  
+    Backgroundjob (Bj) is a simple to use background priority queue for rails.
+    Although not yet tested on windows, the design of bj is such that operation
+    should be possible on any operating system, including M$.
+  
+    Jobs can be submitted to the queue directly using the api or from the
+    commandline using the 'bj' script.  For example
+  
+    code:
+        Bj.submit 'cat /etc/password'
+  
+      cli:
+        bj submit cat /etc/password
+  
+    When used from inside a rails application bj arranges that another process
+    will always be running in the background to process the jobs that you submit.
+    By using a separate process to run jobs bj does not impact the resource
+    utilization of your rails application at all and enables several very cool
+    features:
+  
+      1) Bj allows you to sumbit jobs to any of your configured databases and,
+      in each case, spawns a separate background process to run jobs from that
+      queue
+  
+        Bj.in :production do
+          Bj.submit 'production_job.exe'
+        end
+  
+        Bj.in :development do
+          Bj.submit 'development_job.exe'
+        end
+  
+      2) Although bj ensures that a process is always running to process
+      your jobs, you can start a proces manually.  This means that any machine
+      capable of seeing your RAILS_ROOT can run jobs for your application, allowing
+      one to setup a cluster of machines doing the work of a single front end rails
+      applicaiton.
+  
+  ________________________________
+  Install 
+  --------------------------------
+    
+    Bj can be installed two ways: as a gem or as a plugin.
+  
+      gem:
+        1) $sudo gem install bj
+        2) add "require 'bj'" to config/environment.rb
+        3) bj setup
+  
+      plugin:
+        1) ./script/plugin install http://codeforpeople.rubyforge.org/svn/rails/plugins/bj
+        2) ./script/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.
+    
+    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://www.engineyard.com/
+    http://quintess.com/
+    http://eparklabs.com/
+
+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/plugin/Rakefile

@@ -0,0 +1,22 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the bj plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the bj plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Bj'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/plugin/init.rb

@@ -0,0 +1,33 @@
+dirname, basename = File.split(File.expand_path(__FILE__))
+libdir = File.join dirname, "lib"
+
+$LOAD_PATH.unshift libdir
+begin
+  require "bj"
+ensure
+  $LOAD_PATH.shift
+end
+
+
+
+=begin
+require "rubygems"
+
+dir = Gem.dir
+path = Gem.path
+
+dirname, basename = File.split(File.expand_path(__FILE__))
+gem_home = File.join dirname, "gem_home"
+gem_path = [gem_home] #, *path]
+
+Gem.send :use_paths, gem_home, gem_path
+
+begin
+  %w[ attributes systemu orderedhash bj ].each do |lib|
+    gem lib
+    require lib
+  end
+ensure
+  Gem.send :use_paths, dir, path 
+end
+=end

data/plugin/install.rb

@@ -0,0 +1,95 @@
+#! /usr/bin/env ruby
+
+dirname, basename = File.split File.expand_path(__FILE__)
+
+libidr = 'lib'
+bindir = 'bin'
+gem_home = 'gem_home'
+
+rails_root = File.expand_path File.join(dirname, '../../../')
+bj = File.join rails_root, 'script', 'bj'
+
+gems = %w[ attributes arrayfields main systemu orderedhash bj ]
+
+# in the plugin dir... 
+Dir.chdir dirname do
+  puts "in #{ dirname }..."
+
+  # install gems locally
+  puts "installing #{ gems.join ' ' }..."
+  spawn "gem install #{ gems.join ' ' } --install-dir=#{ gem_home } --remote --force --include-dependencies --no-wrappers"
+  puts "."
+
+=begin
+=end
+  # copy libs over to libdir
+  glob = File.join gem_home, "gems/*/lib/*"
+  entries = Dir.glob glob
+  entries.each do |entry|
+    next if entry =~ %r/-\d+\.\d+\.\d+\.rb$/
+    src, dst = entry, libidr
+    puts "#{ src } -->> #{ dst }..."
+    FileUtils.cp_r src, dst 
+    puts "."
+  end
+
+  # copy bins over to bindir 
+  glob = File.join gem_home, "gems/*/bin/*"
+  entries = Dir.glob glob
+  entries.each do |entry|
+    next if entry =~ %r/-\d+\.\d+\.\d+\.rb$/
+    src, dst = entry, bindir
+    puts "#{ src } -->> #{ dst }..."
+    FileUtils.cp_r src, dst 
+    puts "."
+  end
+
+=begin
+  # copy gem_home/bj-x.x.x/bin/bj to rails_root/script/bj
+  glob = File.join gem_home, "gems/bj-*/bin/*"
+  srcs = Dir.glob glob
+  srcs.each do |src|
+    basename = File.basename src
+    dst = File.join rails_root, 'script', basename 
+    puts "#{ src } -->> #{ dst }..."
+    FileUtils.cp_r src, dst
+    File.chmod 0755, dst
+    puts "."
+  end
+=end
+
+  # install bin/bj to script/bj
+  src, dst = File.join(bindir, "bj"), File.join(rails_root, "script", "bj") 
+  puts "#{ src } -->> #{ dst }..."
+  FileUtils.cp src, dst
+  File.chmod 0755, dst
+  puts "."
+
+  # kill all the local gems
+  FileUtils.rm_rf gem_home
+
+  # dump help
+  puts("=" * 79)
+  ruby = which_ruby
+  system "#{ ruby } #{ bj.inspect } '--help'"
+end
+
+
+
+BEGIN {
+  require 'fileutils'
+  require 'rbconfig'
+
+  def spawn command
+    oe = `#{ command } 2>&1`
+    raise "command <#{ command }> failed with <#{ $?.inspect }>" unless $?.exitstatus == 0
+    oe
+  end
+
+  def which_ruby
+    c = ::Config::CONFIG
+    ruby = File::join(c['bindir'], c['ruby_install_name']) << c['EXEEXT']
+    raise "ruby @ #{ ruby } not executable!?" unless test(?e, ruby)
+    ruby
+  end
+}

data/plugin/script/bj

@@ -0,0 +1,55 @@
+#! /usr/bin/env ruby
+
+require 'main'
+require 'bj'
+
+Main {
+  option('rails_root', 'R'){
+    argument_required
+    default '.'
+  }
+
+  option('rails_env', 'E'){
+    argument_required
+    default 'development'
+  }
+
+  def run
+    help!
+  end
+
+  mode 'setup' do
+    def run
+      bj.setup!
+    end
+  end
+
+  mode 'test' do
+    def run 
+      Bj.boot!
+      y Bj
+    end
+  end
+
+  mode 'migration' do
+    #puts Bj.migration
+  end
+
+  mode 'configure' do
+  end
+
+  mode 'submit' do
+  end
+
+  mode 'list' do
+  end
+
+  def bj
+    return @bj if defined? @bj
+    options = %w[
+      rails_root
+      rails_env
+    ].inject(Hash.new){|h,k| h.update k => params[k].value}
+    @bj = Bj.new options.merge(:logger => logger)
+  end
+}