rq 3.1.0 → 3.3.0

data/Makefile

@@ -0,0 +1,6 @@
+all:
+	@ruby -e 42
+clean:
+	@ruby -e 42
+install:
+	@ruby -e 42

data/all/install.rb

@@ -113,7 +113,7 @@ class Installer
       system "{ #{ RUBY } extconf.rb && stat [mM]akefile && #{ MAKE } && #{ SUDO } #{ MAKE } install; } >#{ log } 2>&1"
   end
   def install_src_package log
-    #system "{ #{ MAKE } clean; } >/dev/null 2>&1"
+    system "{ #{ MAKE } clean; } >/dev/null 2>&1"
     system "{ ./configure --prefix=#{ PREFIX } && stat [mM]akefile && #{ MAKE } && #{ SUDO } #{ MAKE } install; } >#{ log } 2>&1"
   end
   def spawn cmd

data/all/install.sh

@@ -26,8 +26,7 @@
 #
 # sudo : set to "sudo" if you need this to install into prefix
 #
-  export sudo="" 
-  # export sudo="sudo"
+  export sudo="$SUDO"  # note that you can affect this var via 'export SUDO=sudo'
 #
 # full path of dir containing packages to be installed
 #
@@ -41,14 +40,18 @@
 # automatically determines if ruby needs to be installed.
 #
   install_ruby=`test -f ${bindir}/ruby && echo false || echo true`
+  echo "install_ruby: $install_ruby"
+  #install_ruby='false'
+
   install_gem=`test -f ${bindir}/gem && echo false || echo true`
+  echo "install_gem: $install_gem"
+  #install_gem='false'
 #
 # determine ruby tar ball - this just picks up latest version
 #
   ruby_tgz=`ls ${packagedir}/ruby-*gz|sort|tail -1`
 
 
-
 ###############################################################################
 #
 # INSTALL SECTION - DO **NOT** EDIT
@@ -75,6 +78,30 @@
     exit 1
   fi
 #
+# check/create incdir/libdir/bindir
+#
+  if [[ ! -d "$incdir" ]]; then
+    $sudo mkdir -p $incdir 
+  fi
+  if [[ ! -d "$incdir" ]]; then
+    "incdir <$incdir> does not exist and could not be created"
+    exit 1
+  fi
+  if [[ ! -d "$libdir" ]]; then
+    $sudo mkdir -p $libdir 
+  fi
+  if [[ ! -d "$libdir" ]]; then
+    "libdir <$libdir> does not exist and could not be created"
+    exit 1
+  fi
+  if [[ ! -d "$bindir" ]]; then
+    $sudo mkdir -p $bindir 
+  fi
+  if [[ ! -d "$bindir" ]]; then
+    "bindir <$bindir> does not exist and could not be created"
+    exit 1
+  fi
+#
 # info 
 #
   printf "\n$div\n"
@@ -92,15 +119,15 @@
 #
   export LD_RUN_PATH="${libdir}"
   export LD_LIBRARY_PATH="${libdir}"
-  export LDFLAGS="-L ${libdir}"
-  export CFLAGS="-I ${incdir}"
+  export LDFLAGS="-L${libdir}"
+  export CFLAGS="-I${incdir}"
   export PATH="${bindir}:$PATH"
 #
 # important aliases for proper complilation and installation
 #
   export make="env LD_RUN_PATH=${libdir} LD_LIBRARY_PATH=${libdir} make"
   export MAKE="env LD_RUN_PATH=${libdir} LD_LIBRARY_PATH=${libdir} make"
-  export ruby="${bindir}/ruby"
+  export ruby=ruby #"${bindir}/ruby"
 #
 # pre-install
 #
@@ -138,7 +165,7 @@
     cd "$cwd"
   fi
 #
-# bootstrap ruby to install everything else
+# use ruby to bootstrap everything else via ./install.rb
 #
   $ruby ./install.rb || exit 1
 #
@@ -158,6 +185,22 @@
   printf "    setenv PATH \"${bindir}:\$PATH\"\n"
   printf "    setenv LD_LIBRARY_PATH \"${libdir}\"\n"
   printf "\n"
+  printf "YOU CAN CREATE A QUEUE USING\n"
+  printf "  ${bindir}/rq ./q create\n"
+  printf "\n"
+  printf "YOU CAN SUBMIT A JOB TO THAT QUEUE USING\n"
+  printf "  ${bindir}/rq ./q submit echo 42\n"
+  printf "\n"
+  printf "YOU CAN RUN JOBS FROM THAT QUEUE IN THE FOREGROUND USING\n"
+  printf "  ${bindir}/rq ./q feed\n"
+  printf "\n"
+  printf "YOU CAN RUN JOBS FROM THAT QUEUE IN THE BACKGROUND AND FOREVER USING\n"
+  printf "  ${bindir}/rq ./q cronify\n"
+  printf "\n"
+  printf "FOR MORE INFORMATION TYPE\n"
+  printf "  ${bindir}/rq help\n"
+  printf "\n"
+  printf "\n"
 #
 # post-install 
 #

data/all/local_arch_install.rb

@@ -0,0 +1,120 @@
+(( Installer = Object.new )).instance_eval do
+
+  require 'yaml'
+  require 'rbconfig'
+  require 'fileutils'
+  $VERBOSE = nil
+
+  @prefix = ARGV.shift or abort "no prefix"
+
+  @this = File.expand_path __FILE__
+  @dirname = File.dirname @this
+  @packages = File.join @dirname, 'packages'
+  @build = File.join @dirname, 'build'
+
+  @prefix = File.expand_path @prefix 
+  @arch = Config::CONFIG['arch'] 
+  @archbindir = File.join @prefix, 'bin', @arch 
+  @archlibdir = File.join @prefix, 'lib', @arch 
+  @bindir = File.join @prefix, 'bin'
+  @libdir = File.join @prefix, 'lib'
+
+  def run 
+    y config
+    puts
+    puts 'right?'
+    gets
+
+    Dir.chdir @dirname
+    FileUtils.rm_rf @build
+    FileUtils.mkdir_p @build
+    FileUtils.mkdir_p @libdir
+    FileUtils.mkdir_p @archlibdir
+    FileUtils.mkdir_p @bindir
+    FileUtils.mkdir_p @archbindir
+
+    ENV['LD_LIBRARAY_PATH'] = [ @archlibdir, @libdir, ENV['LD_LIBRARAY_PATH'] ].flatten.compact.join ':'
+    ENV['LD_RUN_PATH'] = [ @archlibdir, @libdir, ENV['LD_RUN_PATH'] ].flatten.compact.join ':'
+    ENV['PATH'] = [ @archbindir, @bindir, ENV['PATH'] ].flatten.compact.join ':'
+
+    Dir.chdir @build do
+      #install_arrayfields
+      #install_lockfile
+      #install_main
+      #install_open4
+      #install_posixlock
+      install_sqlite
+    end
+  end
+
+  def config
+    h = Hash.new
+    instance_variables.each do |ivar|
+      h[ivar[1..-1]] = instance_variable_get(ivar)
+    end
+    h
+  end
+
+  def install_arrayfields
+    spawn "tar xvfz #{ @packages }/arrayfields*tgz >/dev/null 2>&1"
+    Dir["./arrayfields*/lib/arrayfields.rb"].each do |entry|
+      FileUtils.cp_r entry, @libdir
+      puts "#{ entry } -->> #{ @libdir }"
+    end
+  end
+
+  def install_lockfile
+    spawn "tar xvfz #{ @packages }/lockfile*tgz >/dev/null 2>&1"
+    Dir["./lockfile*/lib/lockfile.rb"].each do |entry|
+      FileUtils.cp_r entry, @libdir
+      puts "#{ entry } -->> #{ @libdir }"
+    end
+  end
+
+  def install_main
+    spawn "tar xvfz #{ @packages }/main*tgz >/dev/null 2>&1"
+    Dir["./main*/lib/main*"].each do |entry|
+      FileUtils.cp_r entry, @libdir
+      puts "#{ entry } -->> #{ @libdir }"
+    end
+  end
+
+  def install_open4
+    spawn "tar xvfz #{ @packages }/open4*tgz >/dev/null 2>&1"
+    Dir["./open4*/lib/open4.rb"].each do |entry|
+      FileUtils.cp_r entry, @libdir
+      puts "#{ entry } -->> #{ @libdir }"
+    end
+  end
+
+  def install_posixlock
+    spawn "tar xvfz #{ @packages }/posixlock*tgz >/dev/null 2>&1"
+    Dir.chdir Dir["./posixlock*"].first do
+      spawn "ruby extconf.rb && make >/dev/null 2>&1"
+      Dir["./*.{so,bundle,dll}"].each do |entry|
+        FileUtils.cp_r entry, @archlibdir
+        puts "#{ entry } -->> #{ @archlibdir }"
+      end
+    end
+  end
+
+  def install_sqlite
+    spawn "tar xvfz #{ @packages }/sqlite-2*gz"
+    Dir.chdir Dir["./sqlite-2*"].first do
+      spawn "./configure --prefix=`pwd`/prefix/ && make && make install >/dev/null 2>&1"
+      #FileUtils.cp_r "./prefix/lib/libsqlite.a" 
+      #puts "#{ entry } -->> #{ @archlibdir }"
+    end
+  end
+
+  def spawn cmd
+    system cmd or abort "cmd <#{ cmd }> failed"
+  end
+
+  def filelist glob
+    Dir.glob(glob).map{|path| File.expand_path path}.sort.uniq
+  end
+
+end
+
+Installer.run

data/all/packages/INSTALL

@@ -1,5 +1,7 @@
-sqlite-2.8.15.tar.gz
+sqlite-2.8.17.tar.gz
 sqlite-ruby-1.3.1.tar.gz
 posixlock-0.0.1.tgz
 lockfile-1.4.1.tgz
 arrayfields-3.6.0.tgz
+open4-0.9.3.tgz
+main-1.0.0.tgz

data/bin/rq

@@ -27,7 +27,13 @@
 # for the detailed instructions for each of the operation modes 
 # 
 
-  require 'rq-3.1.0'
+  begin
+    require 'rq'
+  rescue LoadError
+    # a guess really...
+    libdir = File.join(File.dirname(File.dirname(__FILE__)), 'lib')
+    require File.join(libdir, 'rq')
+  end
   module RQ
   #
   # the Main class is responsible for parsing command line paramters and
@@ -91,6 +97,10 @@
           '--stdin=[stdin]', '-s',
           'modes <submit, resubmit, update> : stdin'
         ],
+        [
+          '--data=data', '-d',
+          'modes <submit, resubmit, update> : data'
+        ],
 
         [
           '--quiet', '-q',
@@ -117,6 +127,10 @@
           '--max_sleep=max_sleep',
           'modes <feed> : specify max sleep'
         ],
+        [
+          '--loops=loops', '-L', 
+          'modes <feed> : specify how many times to loop (default forever)'
+        ],
         [
           '--exit=exit_code_map',
           'modes <status> : specify and exit code map'
@@ -134,7 +148,7 @@
           'editor command capable of opening multiple files at once = (default ENV["RQ_EDITOR"] || "vim -R -o")'
         ],
         [
-          '--verbosity=verbostiy', '-v', 
+          '--verbosity=[verbostiy]', '-v', 
           '0|fatal < 1|error < 2|warn < 3|info < 4|debug - (default info)'
         ],
         [
@@ -184,8 +198,10 @@
       attr :logger
       attr :argv
       attr :env
+      attr :program
       attr :stdin
       attr :job_stdin
+      attr :data
       attr :cmd
       attr :options
       attr :qpath
@@ -193,11 +209,13 @@
       attr :q
       attr :daemon
       attr :quiet
+      attr :loops
       attr :fields
       attr :dot_rq_dir
 
       alias_method 'stdin?', 'stdin'
       alias_method 'job_stdin?', 'job_stdin'
+      alias_method 'data?', 'data'
       alias_method 'quiet?', 'quiet'
 
     # given a command line and environment run the rq program
@@ -207,6 +225,7 @@
           @logger = Logger::new STDERR
           @argv = Util::mcp(argv.to_a)
           @env = Util::mcp(env.to_hash)
+          @program = $0
           @cmd = ([File::expand_path($0)] + ARGV).join(' ')
           @stdin = parse_stdin
 
@@ -245,6 +264,11 @@
             @fields.uniq!
           end
 
+          if(@options.has_key?('loops'))
+            @loops = @options['loops']
+            @loops = Integer @loops if @loops
+          end
+
           parse_argv
 
           setup_dot_rq_dir
@@ -804,7 +828,12 @@
         @logdev = @logger.logdev.dev 
         @logdev.sync = true
         level = nil
-        verbosity ||= 'info'
+        verbosity ||=
+          if @options.has_key? 'verbosity'
+            'debug'
+          else
+            'info'
+          end
         verbosity =
           case verbosity
             when /^\s*(?:4|d|debug)\s*$/io

data/bin/rqmailer

@@ -0,0 +1,846 @@
+#!  /opt/local/bin/ruby
+
+### built-in
+require 'openssl'
+require 'net/smtp'
+require 'io/wait'
+require 'erb'
+require 'socket'
+
+### rubyforge
+require 'rubygems'
+require 'main'
+require 'open4'
+#require 'mailfactory' # patched version inlined below
+
+Main {
+  option('config', 'c'){
+    argument_required
+  }
+
+  option('template', 't'){
+    argument_required
+  }
+
+  option('belch', 'b'){
+  }
+
+  option('send', 's'){
+  }
+
+  option('queue', 'q'){
+    argument_required
+  }
+
+  SMTP = {}
+
+  def run  #--{{{
+    indicating_that_rqmailer_failed do
+      setup
+      load_config
+      load_template
+      generate_cmd
+      run_cmd
+      expand_template
+      mail_message
+    end
+    exit @exit_status || 42 
+  end  #--}}}
+
+  def setup  #--{{{
+    @config = {}
+    @rq = ENV['RQ']
+    @rq_data = ENV['RQ_DATA']
+    @exit_status = 0
+    @exception = nil
+    @template_expander = TemplateExpander.instance
+    @stdin = @stdout = @stderr = nil
+    @belch = params['belch'].given?
+    @send = params['send'].given?
+    @hostname = Socket.gethostname rescue 'localhost.localdomain'
+    @mail = MailFactory.new
+  end  #--}}}
+
+  def load_config  #--{{{
+    if param['config'].given?
+      @config = YAML.load IO.read(param['config'].value)
+    else
+      if @rq_data
+        config = File.join @rq_data, 'config' 
+        @config = YAML.load IO.read(config)
+      else
+        abort 'no config'
+      end
+    end
+  end  #--}}}
+
+  def load_template  #--{{{
+    if param['template'].given?
+      @template = IO.read param['template'].value
+    else
+      if @rq_data
+        template = File.join @rq_data, 'template' 
+        @template = IO.read(template)
+      else
+        @template = DATA.read 
+      end
+    end
+  end  #--}}}
+
+  def generate_cmd  #--{{{
+    stdin = argv.first == '-' && argv.delete('-')
+    @cmd =
+      if stdin
+        STDIN.read
+      else
+        @config['command'] || @config['cmd'] || argv.join(' ')
+      end
+    abort 'no cmd' if @cmd.to_s.strip.empty?
+  end  #--}}}
+
+  def run_cmd  #--{{{
+    if @rq
+      @stdin = STDIN if STDIN.ready?
+      @stdout = STDOUT
+      @stderr = STDERR
+      STDOUT.flush; STDERR.flush
+      @exit_status = Open4.spawn @cmd, 0=>@stdin, 1=>@stdout, 2=>@stderr
+      STDOUT.flush; STDERR.flush
+    else
+      @stdin = STDIN if STDIN.ready?
+      @stdin = IO.read(@stdin) if @stdin
+      @stdout = '' 
+      @stderr = '' 
+      @exit_status = Open4.spawn @cmd, 0=>@stdin, 1=>@stdout, 2=>@stderr
+    end
+    update_config_with_cmd_info
+  end  #--}}}
+
+  def errmsg e  #--{{{
+    m, c, bt = e.message, e.class, (e.backtrace || []).join("\n")
+    "#{ m } (#{ c })\n#{ bt }"
+  end  #--}}}
+
+  def indicating_that_rqmailer_failed  #--{{{
+    begin
+      yield
+    rescue Exception => e
+      @exception = e 
+      STDERR.puts errmsg(e)
+      @exit_status = 42 
+    end
+  end  #--}}}
+
+  def update_config_with_cmd_info  #--{{{
+    if @rq
+      %w( stdin stdout stderr ).each do |iof|
+        path = instance_variable_get "@rq_#{ iof }"
+        buf = IO.read path rescue ''
+        @config[iof] = buf
+        @config["#{ iof }_path"] = path 
+      end
+    else
+      @config['stdin'] = @stdin
+      @config['stdin_path'] = '-' 
+      @config['stdout'] = @stdout
+      @config['stdout_path'] = '-' 
+      @config['stderr'] = @stderr
+      @config['stderr_path'] = '-' 
+    end
+
+    @config['cmd'] = @config['command'] = @cmd
+    @config['exit_status'] = @config['exitstatus'] = @exit_status
+  end  #--}}}
+
+  def expand_template  #--{{{
+    @template_expander.configure @config
+    @template_expander.configure 'mail' => @mail 
+    mconfig = @config['mail'] || {} 
+    @template_expander.configure mconfig 
+    @message = @template_expander.expand @template
+  end  #--}}}
+  
+  def mail_message  #--{{{
+    build_mail!
+
+    hash = @config['smtp'] || SMTP
+    server = hash['server']
+    port = Integer hash['port']
+    hostname = hash['hostname'] || @hostname || 'localhost.localdomain'
+    account = hash['account']
+    password = hash['password']
+    authtype = hash['authtype'] || :plain
+    tls = hash['tls'] ? true : false
+
+    if @belch
+      if @send
+        smtp = Net::SMTP.new server, port
+        smtp.set_debug_output STDERR 
+        smtp.start hostname, account, password, authtype, tls do |connection|
+          connection.send_message @mail, account, @mail.recipients 
+        end
+      end
+      STDOUT.puts @mail 
+    else
+      debug_output = open File.join(@rq_data, 'smtp'), 'w'
+      at_exit{ debug_output.close rescue nil }
+
+      smtp = Net::SMTP.new server, port
+      smtp.set_debug_output debug_output
+      smtp.start hostname, account, password, authtype, tls do |connection|
+        connection.send_message @mail, account, @mail.recipients 
+      end
+
+      if @rq
+        open(File.join(@rq_data, 'mail'), 'w'){|fd| fd.write @mail}
+      end
+
+      STDERR.puts @mail
+    end
+
+  end  #--}}}
+
+  def build_mail!  #--{{{
+    mconfig = @config['mail'] || @config
+
+    attributes = %w(
+      to
+      from
+      cc
+      bcc
+      subject
+    )
+    attributes.each do |attribute|
+      up, down = attribute.downcase.capitalize, attribute.downcase
+      [up, down].each do |attribute|
+        if mconfig.has_key?(attribute)
+          value = [mconfig[attribute]].flatten.join ','
+          @mail.send "#{ up }=", value 
+          @mail.send "#{ down }=", value 
+        end
+      end
+    end
+
+    methods = %w(
+      attach
+      attachment
+      attachments
+      Attach
+      Attachment
+      Attachments
+    )
+    methods.each do |method|
+      if mconfig.has_key?(method)
+        values = [mconfig[method]].flatten
+        values.each do |value|
+          @mail.attach value
+        end
+      end 
+    end
+
+    class << @mail
+      def recipients 
+        to.to_s.split %r/,/
+      end
+    end
+
+    @mail.subject ||= "rqmailer"
+    @mail.text = @message 
+    @mail
+  end  #--}}}
+
+  class TemplateExpander  #--{{{
+    alias_method "__instance_variable_set__", "instance_variable_set"
+    alias_method "__instance_eval__", "instance_eval"
+    instance_methods.each{|m| undef_method unless m[%r/__/]}
+    alias_method "instance_eval", "__instance_eval__"
+    alias_method "instance_variable_set", "__instance_variable_set__"
+
+    def self.new *a, &b
+      @instance ||= super
+    end
+    def self.instance *a, &b
+      new *a, &b
+    end
+    def self.const_missing c
+      msg = c.to_s.downcase
+      if @instance.respond_to? msg
+        @instance.send msg 
+      else
+        super
+      end
+    end
+    def singleton_class &b  #--{{{
+      @sc ||=
+        class << self
+          self
+        end
+      b ? @sc.module_eval(&b) : @sc
+    end  #--}}}
+    def set key, value  #--{{{
+      key = key.to_s.downcase
+      instance_variable_set "@#{ key }", value
+      singleton_class do 
+        define_method(key){ instance_variable_get "@#{ key }" }
+        define_method(key.capitalize){ instance_variable_get "@#{ key }" }
+      end
+    end  #--}}}
+    def configure hash  #--{{{
+      hash.each{|k,v| set k, v}
+    end  #--}}}
+    def expand message  #--{{{
+      ERB.new(message).result binding 
+    end  #--}}}
+    def lazy #--{{{
+      singleton_class{ define_method m, &b }
+    end  #--}}}
+    def method_missing m, *a, &b
+      super unless defined? @mail
+      @mail.send m, *a, &b
+    end
+  end  #--}}}
+}
+
+
+BEGIN { 
+
+### hacking in smtp tls support
+#--{{{
+# Original code believed public domain from ruby-talk or ruby-core email.
+# Modifications by Kyle Maxwell <kyle@kylemaxwell.com> used under MIT license.
+
+require "openssl"
+require "net/smtp"
+
+# :stopdoc:
+
+class Net::SMTP
+
+  class << self
+    send :remove_method, :start
+  end
+
+  def self.start( address, port = nil,
+                  helo = 'localhost.localdomain',
+                  user = nil, secret = nil, authtype = nil, use_tls = false,
+                  &block) # :yield: smtp
+    new(address, port).start(helo, user, secret, authtype, use_tls, &block)
+  end
+
+  alias tls_old_start start
+
+  def start( helo = 'localhost.localdomain',
+             user = nil, secret = nil, authtype = nil, use_tls = false ) # :yield: smtp
+    start_method = use_tls ? :do_tls_start : :do_start
+    if block_given?
+      begin
+        send start_method, helo, user, secret, authtype
+        return yield(self)
+      ensure
+        do_finish
+      end
+    else
+      send start_method, helo, user, secret, authtype
+      return self
+    end
+  end
+
+  private
+
+  def do_tls_start(helodomain, user, secret, authtype)
+    raise IOError, 'SMTP session already started' if @started
+    check_auth_args user, secret, authtype if user or secret
+
+    sock = timeout(@open_timeout) { TCPSocket.open(@address, @port) }
+    @socket = Net::InternetMessageIO.new(sock)
+    @socket.read_timeout = 60 #@read_timeout
+    @socket.debug_output = @debug_output
+
+    check_response(critical { recv_response() })
+    do_helo(helodomain)
+
+    raise 'openssl library not installed' unless defined?(OpenSSL)
+    starttls
+    ssl = OpenSSL::SSL::SSLSocket.new(sock)
+    ssl.sync_close = true
+    ssl.connect
+    @socket = Net::InternetMessageIO.new(ssl)
+    @socket.read_timeout = 60 #@read_timeout
+    @socket.debug_output = @debug_output
+    do_helo(helodomain)
+
+    authenticate user, secret, authtype if user
+    @started = true
+  ensure
+    unless @started
+      # authentication failed, cancel connection.
+        @socket.close if not @started and @socket and not @socket.closed?
+      @socket = nil
+    end
+  end
+
+  def do_helo(helodomain)
+     begin
+      if @esmtp
+        ehlo helodomain
+      else
+        helo helodomain
+      end
+    rescue Net::ProtocolError
+      if @esmtp
+        @esmtp = false
+        @error_occured = false
+        retry
+      end
+      raise
+    end
+  end
+
+  def starttls
+    getok('STARTTLS')
+  end
+
+  alias tls_old_quit quit
+
+  def quit
+    begin
+      getok('QUIT')
+    rescue EOFError
+    end
+  end
+
+end unless Net::SMTP.private_method_defined? :do_tls_start or
+           Net::SMTP.method_defined? :tls?
+#--}}}
+
+### inlining mailfactory
+#--{{{
+# = Overview:
+# A simple to use module for generating RFC compliant MIME mail
+# ---
+# = License:
+# Author:: David Powers
+# Copyright:: May, 2005
+# License:: Ruby License
+# ---
+# = Usage:
+# 	require 'net/smtp'
+# 	require 'rubygems'
+# 	require 'mailfactory'
+#
+#
+# 	mail = MailFactory.new()
+# 	mail.to = "test@test.com"
+# 	mail.from = "sender@sender.com"
+# 	mail.subject = "Here are some files for you!"
+# 	mail.text = "This is what people with plain text mail readers will see"
+# 	mail.html = "A little something <b>special</b> for people with HTML readers"
+# 	mail.attach("/etc/fstab")
+# 	mail.attach("/some/other/file")
+#
+# 	Net::SMTP.start('smtp1.testmailer.com', 25, 'mail.from.domain', fromaddress, password, :cram_md5) { |smtp|
+# 		mail.to = toaddress
+# 		smtp.send_message(mail.to_s(), fromaddress, toaddress)
+# 	}
+
+
+
+require 'base64'
+require 'pathname'
+
+# try to bring in the mime/types module, make a dummy module if it can't be found
+begin
+	begin
+		require 'rubygems'
+	rescue LoadError
+	end
+	require 'mime/types'
+rescue LoadError
+	module MIME
+		class Types
+			def Types::type_for(filename)
+				return('')
+			end
+		end
+	end
+end
+
+# An easy class for creating a mail message
+class MailFactory
+	
+	def initialize()
+		@headers = Array.new()
+		@attachments = Array.new()
+		@attachmentboundary = generate_boundary()
+		@bodyboundary = generate_boundary()
+		@html = nil
+		@text = nil
+	end
+	
+	
+	# adds a header to the bottom of the headers
+	def add_header(header, value)
+		@headers << "#{header}: #{value}"
+	end
+	
+	
+	# removes the named header - case insensitive
+	def remove_header(header)
+		@headers.each_index() { |i|
+			if(@headers[i] =~ /^#{Regexp.escape(header)}:/i)
+				@headers.delete_at(i)
+			end
+		}
+	end
+	
+	
+	# sets a header (removing any other versions of that header)
+	def set_header(header, value)
+		remove_header(header)
+		add_header(header, value)
+	end
+	
+	
+	def replyto=(newreplyto)
+		remove_header("Reply-To")
+		add_header("Reply-To", newreplyto)
+	end
+	
+	
+	def replyto()
+		return(get_header("Reply-To")[0])
+	end
+
+        def self.hattr h
+          h = h.to_s
+          module_eval <<-code
+            def #{ h.downcase }=(value)
+              remove_header("#{ h.downcase.capitalize }")
+              add_header("#{ h.downcase.capitalize }", value)
+            end
+            def #{ h.downcase }()
+              return(get_header("#{ h.downcase.capitalize }")[0])
+            end
+          code
+        end
+        %w( to from cc bcc subject ).each{|h| hattr h}
+	
+	
+	# sets the plain text body of the message
+	def text=(newtext)
+		@text = newtext
+	end
+	
+	
+	# sets the HTML body of the message. Only the body of the
+	# html should be provided
+	def html=(newhtml)
+		@html = "<html>\n<head>\n<meta content=\"text/html;charset=ISO-8859-1\" http-equiv=\"Content-Type\">\n</head>\n<body bgcolor=\"#ffffff\" text=\"#000000\">\n#{newhtml}\n</body>\n</html>"
+	end
+	
+	
+	# sets the HTML body of the message.  The entire HTML section should be provided
+	def rawhtml=(newhtml)
+		@html = newhtml
+	end
+	
+	
+	# implement method missing to provide helper methods for setting and getting headers.
+	# Headers with '-' characters may be set/gotten as 'x_mailer' or 'XMailer' (splitting
+	# will occur between capital letters or on '_' chracters)
+	def method_missing(methId, *args)
+		name = methId.id2name()
+		
+		# mangle the name if we have to
+		if(name =~ /_/)
+			name = name.gsub(/_/, '-')
+		elsif(name =~ /[A-Z]/)
+			name = name.gsub(/([a-zA-Z])([A-Z])/, '\1-\2')
+		end
+		
+		# determine if it sets or gets, and do the right thing
+		if(name =~ /=$/)
+			if(args.length != 1)
+				super(methId, args)
+			end
+			set_header(name[/^(.*)=$/, 1], args[0])			
+		else
+			if(args.length != 0)
+				super(methId, args)
+			end
+			headers = get_header(name)
+			return(get_header(name))
+		end
+	end
+
+	
+	# returns the value (or values) of the named header in an array
+	def get_header(header)
+		headers = Array.new()
+		headerregex = /^#{Regexp.escape(header)}:/i
+		@headers.each() { |h|
+			if(headerregex.match(h))
+				headers << h[/^[^:]+:(.*)/i, 1].strip()
+			end
+		}
+		
+		return(headers)
+	end
+	
+	
+	# returns true if the email is multipart
+	def multipart?()
+		if(@attachments.length > 0 or @html != nil)
+			return(true)
+		else
+			return(false)
+		end
+	end
+	
+
+	# builds an email and returns it as a string.  Takes the following options:
+	# <tt>:messageid</tt>:: Adds a message id to the message based on the from header (defaults to false)
+	# <tt>:date</tt>:: Adds a date to the message if one is not present (defaults to true)
+	def construct(options = Hash.new)
+		if(options[:date] == nil)
+			options[:date] = true
+		end
+		
+		if(options[:messageid])
+			# add a unique message-id
+			remove_header("Message-ID")
+			sendingdomain = get_header('from')[0].to_s()[/@([-a-zA-Z0-9._]+)/,1].to_s()
+			add_header("Message-ID", "<#{Time.now.to_f()}.#{Process.euid()}.#{String.new.object_id()}@#{sendingdomain}>")
+		end
+
+		if(options[:date])
+			if(get_header("Date").length == 0)
+				add_header("Date", Time.now.strftime("%a, %d %b %Y %H:%M:%S %z"))
+			end
+		end
+
+		# Add a mime header if we don't already have one and we have multiple parts
+		if(multipart?())
+			if(get_header("MIME-Version").length == 0)
+				add_header("MIME-Version", "1.0")
+			end
+			
+			if(get_header("Content-Type").length == 0)
+				if(@attachments.length == 0)
+					add_header("Content-Type", "multipart/alternative;boundary=\"#{@bodyboundary}\"")
+				else
+					add_header("Content-Type", "multipart/mixed; boundary=\"#{@attachmentboundary}\"")
+				end
+			end
+		end
+		
+		return("#{headers_to_s()}#{body_to_s()}")
+	end
+
+	
+	# returns a formatted email - equivalent to construct(:messageid => true) 
+	def to_s()
+		return(construct(:messageid => true))
+	end
+	
+	
+	# generates a unique boundary string
+	def generate_boundary()
+		randomstring = Array.new()
+		1.upto(25) {
+			whichglyph = rand(100)
+			if(whichglyph < 40)
+				randomstring << (rand(25) + 65).chr()
+			elsif(whichglyph < 70)
+				randomstring << (rand(25) + 97).chr()
+			elsif(whichglyph < 90)
+				randomstring << (rand(10) + 48).chr()
+			elsif(whichglyph < 95)
+				randomstring << '.'
+			else
+				randomstring << '_'
+			end
+		}
+		return("----=_NextPart_#{randomstring.join()}")
+	end
+	
+	
+	# adds an attachment to the mail.  Type may be given as a mime type.  If it
+	# is left off and the MIME::Types module is available it will be determined automagically.
+	# If the optional attachemntheaders is given, then they will be added to the attachment
+	# boundary in the email, which can be used to produce Content-ID markers.  attachmentheaders
+	# can be given as an Array or a String.
+	def add_attachment(filename, type=nil, attachmentheaders = nil)
+		attachment = Hash.new()
+		attachment['filename'] = Pathname.new(filename).basename
+		if(type == nil)
+			attachment['mimetype'] = MIME::Types.type_for(filename).to_s
+		else
+			attachment['mimetype'] = type
+		end	
+		
+		# Open in rb mode to handle Windows, which mangles binary files opened in a text mode
+		File.open(filename, "rb") { |fp|
+			attachment['attachment'] = file_encode(fp.read())
+		}
+
+		if(attachmentheaders != nil)
+			if(!attachmentheaders.kind_of?(Array))
+				attachmentheaders = attachmentheaders.split(/\r?\n/)
+			end
+			attachment['headers'] = attachmentheaders
+		end
+
+		@attachments << attachment
+	end
+	
+	
+	# adds an attachment to the mail as emailfilename.  Type may be given as a mime type.  If it
+	# is left off and the MIME::Types module is available it will be determined automagically.
+	# file may be given as an IO stream (which will be read until the end) or as a filename.
+	# If the optional attachemntheaders is given, then they will be added to the attachment
+	# boundary in the email, which can be used to produce Content-ID markers.  attachmentheaders
+	# can be given as an Array of a String.
+	def add_attachment_as(file, emailfilename, type=nil, attachmentheaders = nil)
+		attachment = Hash.new()
+		attachment['filename'] = emailfilename
+
+		if(type != nil)
+			attachment['mimetype'] = type.to_s()
+		elsif(file.kind_of?(String) or file.kind_of?(Pathname))
+			attachment['mimetype'] = MIME::Types.type_for(file.to_s()).to_s
+		else
+			attachment['mimetype'] = ''
+		end
+		
+		if(file.kind_of?(String) or file.kind_of?(Pathname))		
+			# Open in rb mode to handle Windows, which mangles binary files opened in a text mode
+			File.open(file.to_s(), "rb") { |fp|
+				attachment['attachment'] = file_encode(fp.read())
+			}
+		elsif(file.respond_to?(:read))
+			attachment['attachment'] = file_encode(file.read())
+		else
+			raise(Exception, "file is not a supported type (must be a String, Pathnamem, or support read method)")
+		end
+		
+		if(attachmentheaders != nil)
+			if(!attachmentheaders.kind_of?(Array))
+				attachmentheaders = attachmentheaders.split(/\r?\n/)
+			end
+			attachment['headers'] = attachmentheaders
+		end
+		
+		@attachments << attachment
+	end
+	
+	
+	alias attach add_attachment
+	alias attach_as add_attachment_as
+	
+protected
+	
+	# returns the @headers as a properly formatted string
+	def headers_to_s()
+		return("#{@headers.join("\r\n")}\r\n\r\n")
+	end
+	
+	
+	# returns the body as a properly formatted string
+	def body_to_s()
+		body = Array.new()
+		
+		# simple message with one part
+		if(!multipart?())
+			return(@text)
+		else
+			body << "This is a multi-part message in MIME format.\r\n\r\n--#{@attachmentboundary}\r\nContent-Type: multipart/alternative; boundary=\"#{@bodyboundary}\""
+			
+			if(@attachments.length > 0)
+				# text part
+				body << "#{buildbodyboundary('text/plain; charset=ISO-8859-1; format=flowed', '7bit')}\r\n\r\n#{@text}"
+				
+				# html part if one is provided
+				if @html
+					body << "#{buildbodyboundary('text/html; charset=ISO-8859-1', '7bit')}\r\n\r\n#{@html}"
+				end
+				
+				body << "--#{@bodyboundary}--"
+				
+				# and, the attachments
+				if(@attachments.length > 0)
+					@attachments.each() { |attachment|
+						body << "#{buildattachmentboundary(attachment)}\r\n\r\n#{attachment['attachment']}"
+					}
+					body << "\r\n--#{@attachmentboundary}--"
+				end
+			else
+				# text part
+				body << "#{buildbodyboundary('text/plain; charset=ISO-8859-1; format=flowed', '7bit')}\r\n\r\n#{@text}"
+				
+				# html part
+				body << "#{buildbodyboundary('text/html; charset=ISO-8859-1', '7bit')}\r\n\r\n#{@html}"
+				
+				body << "--#{@bodyboundary}--"
+			end
+			
+			return(body.join("\r\n\r\n"))
+		end
+	end
+	
+	
+	# builds a boundary string for including attachments in the body, expects an attachment hash as built by
+	# add_attachment and add_attachment_as
+	def buildattachmentboundary(attachment)
+		disposition = "Content-Disposition: inline; filename=\"#{attachment['filename']}\""
+		boundary = "--#{@attachmentboundary}\r\nContent-Type: #{attachment['mimetype']}; name=\"#{attachment['filename']}\"\r\nContent-Transfer-Encoding: base64\r\n#{disposition}"
+		if(attachment['headers'])
+			boundary = boundary + "\r\n#{attachment['headers'].join("\r\n")}"
+		end
+		
+		return(boundary)
+	end
+	
+	
+	# builds a boundary string for inclusion in the body of a message
+	def buildbodyboundary(type, encoding)
+		return("--#{@bodyboundary}\r\nContent-Type: #{type}\r\nContent-Transfer-Encoding: #{encoding}")
+	end
+
+
+  # returns a base64 encoded version of the contents of str
+  def file_encode(str)
+    collection = Array.new()
+    enc = Base64.encode64(str)
+#    while(enc.length > 60)
+#      collection << enc.slice!(0..59)
+#    end
+#    collection << enc
+#    return(collection.join("\n"))
+    return(enc)
+  end
+  
+end
+
+#--}}}
+
+}
+
+
+__END__
+### rqmailer
+
+CMD:
+<%= cmd %> 
+
+EXIT_STATUS:
+<%= exit_status %> 
+
+STDIN:
+<%= stdin %> 
+
+STDOUT:
+<%= stdout %> 
+
+STDERR:
+<%= stderr %>