crazy_ivan 1.2.3 → 1.2.4

data/bin/crazy_ivan

@@ -3,11 +3,8 @@
 begin
   require 'crazy_ivan'
 rescue LoadError
-  # If people are not using gems, the load path must still
-  # be correct.
-  # TODO: Remove the begin / rescue block somehow
   $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
-  retry
+  require 'crazy_ivan'
 end
 
 require "optparse"
@@ -20,7 +17,7 @@ Signal.trap("INT") do
   CrazyIvan.interrupt_test
   ProcessManager.unlock
   puts
-  exit
+  exit(1)
 end
 
 def show_howto
@@ -68,19 +65,19 @@ ARGV.options do |opts|
   
   begin
     opts.parse!
-        
+    
     case ARGV[0]
     when /setup/
       CrazyIvan::setup
     when /\w+/  # a directory for test results
-      ProcessManager.acquire_lock do
-        Syslog.debug "Generating reports in #{ARGV[0]}"
+      begin
         CrazyIvan::generate_test_reports_in(ARGV[0])
+      rescue AlreadyRunningError
+        Process.kill('INT', 0)
       end
     else
       show_howto
       exit
     end
   end
-end
-
+end

data/lib/crazy_ivan.rb

@@ -1,13 +1,14 @@
 require 'syslog'
 require 'fileutils'
 require 'yaml'
+require 'crazy_ivan/vendor/json'
+require 'crazy_ivan/vendor/open4'
+require 'crazy_ivan/vendor/tmpdir'
+require 'crazy_ivan/vendor/lockfile'
 require 'crazy_ivan/process_manager'
 require 'crazy_ivan/report_assembler'
 require 'crazy_ivan/test_runner'
 require 'crazy_ivan/version'
-require 'crazy_ivan/vendor/json'
-require 'crazy_ivan/vendor/open4'
-require 'crazy_ivan/vendor/tmpdir'
 
 module CrazyIvan
   def self.setup
@@ -114,20 +115,28 @@ module CrazyIvan
     puts
   end
 
-  def self.generate_test_reports_in(output_directory)
+  def self.generate_test_reports_in(path)
     Syslog.open('crazy_ivan', Syslog::LOG_PID | Syslog::LOG_CONS) unless Syslog.opened?
-    FileUtils.mkdir_p(output_directory)
     
-    report = ReportAssembler.new(Dir.pwd, output_directory)
-    report.generate
+    output_path = File.expand_path(path)
+    
+    ProcessManager.acquire_lock! do
+      Syslog.debug "Generating reports in #{output_path}"
+      
+      FileUtils.mkdir_p(output_path)
+    
+      report = ReportAssembler.new(Dir.pwd, output_path)
+      report.generate
+    
+      # TODO indicate how many projects were tested
+      msg = "Ran CI on #{report.runners.size} projects"
+      
+      # REFACTOR to use a logger that spits out to both STDOUT and Syslog
+      Syslog.info(msg)
+      puts msg
+    end
     
-    # TODO this should really indicate how many projects were tested
-    msg = "Generated test reports for #{report.runners.size} projects"
-    Syslog.info(msg)
-    puts msg
-    # REFACTOR to use a logger that spits out to both STDOUT and Syslog
-  ensure
-    Syslog.close
+    Syslog.close if Syslog.opened?
   end
   
   def self.interrupt_test

data/lib/crazy_ivan/process_manager.rb

@@ -1,48 +1,34 @@
+require 'lockfile'
+
+class AlreadyRunningError < StandardError; end
+
 class ProcessManager
-  @@pidfile = '/tmp/crazy_ivan.pid'
+  @@lockfile = Lockfile.new('/tmp/crazy_ivan.lock', :retries => 1)
   
-  def self.pidfile=(file)
-    @@pidfile = file
+  def self.lockfilepath=(filepath)
+    @@lockfile = Lockfile.new(filepath, :retries => 1)
   end
   
-  def self.acquire_lock
-    lock_exclusively!
+  def self.acquire_lock!
+    lock
     yield
+  ensure
     unlock
   end
   
   def self.unlock
-    File.new(@@pidfile).flock(File::LOCK_UN)
-  end
-
-  def self.ci_already_running?
-    File.exists?(@@pidfile) && !File.new(@@pidfile).flock(File::LOCK_EX | File::LOCK_NB)
+    @@lockfile.unlock
+  rescue Lockfile::UnLockError
   end
   
-  def self.lock_exclusively!(options = {})
-    pid = Integer(File.read(@@pidfile)) if File.exists?(@@pidfile)
-    
+  def self.lock
     Syslog.debug "Acquiring lock"
-    
-    if options[:interrupt_existing_process]
-      File.open(@@pidfile, "w+") { |fp| fp << Process.pid }
-
-      if ci_already_running?
-        Process.kill("INT", pid)
-        Syslog.debug("Detected another running CI process #{pid}; interrupting it and starting myself")
-        File.new(@@pidfile).flock(File::LOCK_EX)
-      end
-    else
-      if ci_already_running?
-        msg = "Detected another running CI process #{pid} - interrupting and terminating myself"
-        Syslog.warning msg
-        puts msg
-        Process.kill("INT", 0)
-      else
-        Syslog.debug("Locked CI process pid file")
-        Syslog.debug("Writing to pid file with #{Process.pid}")
-        File.open(@@pidfile, "w+") { |fp| fp << Process.pid }
-      end
-    end
+    @@lockfile.lock
+    Syslog.debug("Locked CI process")
+  rescue Lockfile::LockError
+    msg = "Detected another running CI process - cannot start"
+    Syslog.warning msg
+    puts msg
+    raise AlreadyRunningError, msg
   end
 end

data/lib/crazy_ivan/report_assembler.rb

@@ -99,7 +99,6 @@ class ReportAssembler
   
   def update_currently_building(runner)
     project_path = File.expand_path(runner.project_name, @output_directory)
-    
     Dir.chdir(project_path) do
       File.open('currently_building.json', 'w+') do |f|
         f.puts runner.results.to_json

data/lib/crazy_ivan/templates/index.html

@@ -223,6 +223,15 @@
             }
           });
         });
+        
+        // Working here:
+        
+        // location.href will look like this
+        // http://ci.shopify.com/#shopify-ree-187-802d405d56410b3159dac66644846468d2d83ef8
+        
+        // Check it for which domId to make active and show, but only do this on the first full render
+        
+        // Also: add a loading screen
       }
       
       // listen to clicking of test result links

data/lib/crazy_ivan/vendor/lockfile-1.4.3/README

@@ -0,0 +1,227 @@
+URLS
+
+  http://rubyforge.org/projects/codeforpeople/
+  http://codeforpeople.com/lib/ruby/
+
+SYNOPSIS
+
+  lib/lockfile.rb : a ruby library for creating NFS safe lockfiles
+  
+  bin/rlock : ruby command line tool which uses this library to create lockfiles
+              and to run arbitrary commands while holding them. 
+
+              for example
+
+                rlock lockfile -- cp -r huge/ huge.bak/
+              
+              run 'rlock -h' for more info
+
+INSTALL
+
+  sudo ruby install.rb
+
+
+BASIC ALGORITHIM
+
+  * create a globally uniq filename in the same filesystem as the desired
+    lockfile - this can be nfs mounted
+
+  * link(2) this file to the desired lockfile, ignore all errors
+
+  * stat the uniq filename and desired lockfile to determine is they are the
+    same, use only stat.rdev and stat.ino - ignore stat.nlink as NFS can cause
+    this report incorrect values 
+
+  * iff same, you have lock.  either return or run optional code block with
+    optional refresher thread keeping lockfile fresh during execution of code
+    block, ensuring that the lockfile is removed..
+
+  * iff not same try again a few times in rapid succession (poll), then, iff
+    this fails, sleep using incremental backoff time.  optionally remove
+    lockfile if it is older than a certain time, timeout if more than a certain
+    amount of time has passed attempting to lock file.
+
+
+BASIC USAGE
+
+  1)
+    lockfile = Lockfile.new 'file.lock'
+    begin
+      lockfile.lock
+      p 42
+    ensure
+      lockfile.unlock
+    end
+
+
+  2)
+    require 'pstore'           # which is NOT nfs safe on it's own
+
+    opts = {                    # the keys can be symbols or strings
+
+      :retries        => nil,   # we will try forever to aquire the lock
+
+      :sleep_inc      => 2,     # we will sleep 2 seconds longer than the
+                                # previous sleep after each retry, cycling from
+                                # min_sleep upto max_sleep downto min_sleep upto
+                                # max_sleep, etc., etc.
+
+      :min_sleep      => 2,     # we will never sleep less than 2 seconds
+
+      :max_sleep      => 32,    # we will never sleep longer than 32 seconds
+
+      :max_age        => 3600,  # we will blow away any files found to be older
+                                # than this (lockfile.thief? #=> true)
+
+      :suspend        => 1800,  # iff we steal the lock from someone else - wait
+                                # this long to give them a chance to realize it
+
+      :refresh        => 8,     # we will spawn a bg thread that touches file
+                                # every 8 sec.  this thread also causes a
+                                # StolenLockError to be thrown if the lock
+                                # disappears from under us - note that the
+                                # 'detection' rate is limited to the refresh
+                                # interval - this is a race condition
+
+      :timeout        => nil,   # we will wait forever 
+
+      :poll_retries   => 16,    # the initial attempt to grab a lock is done in a
+                                # polling fashion, this number controls how many
+                                # times this is done - the total polling attempts
+                                # are considered ONE actual attempt (see retries
+                                # above)
+
+      :poll_max_sleep => 0.08,  # when polling a very brief sleep is issued
+                                # between attempts, this is the upper limit of
+                                # that sleep timeout 
+
+      :dont_clean     => false, # normally a finalizer is defined to clean up
+                                # after lockfiles, settin this to true prevents this 
+
+      :dont_sweep     => false, # normally locking causes a sweep to be made.  a
+                                # sweep removes any old tmp files created by
+                                # processes of this host only which are no
+                                # longer alive
+
+      :debug => true,           # trace execution step on stdout
+    }
+
+    pstore = PStore.new 'file.db'
+    lockfile = Lockfile.new 'file.db.lock', opts 
+    lockfile.lock do
+      pstore.transaction do
+        pstore[:last_update_time] = Time.now
+      end
+    end
+
+  3) same as 1 above - Lockfile.new takes a block and ensures unlock is called 
+
+    Lockfile.new('file.lock') do
+      p 42
+    end
+
+  4) watch locking algorithim in action (debugging only)
+
+      Lockfile.debug = true
+      Lockfile.new('file.lock') do
+        p 42
+      end
+
+    you can also set debugging via the ENV var LOCKFILE_DEBUG, eg.
+
+    ~ > LOCKFILE_DEBUG=true rlock lockfile
+
+  5) simplified interface : no lockfile object required
+
+      Lockfile('lock', :retries => 0) do
+        puts 'only one instance running!'
+      end
+
+
+SAMPLES
+
+  * see samples/a.rb
+  * see samples/nfsstore.rb
+  * see samples/lock.sh
+  * see bin/rlock
+
+AUTHOR
+
+  Ara T. Howard
+
+EMAIL
+
+  Ara.T.Howard@noaa.gov
+
+BUGS
+
+  bugno > 1 && bugno < 42
+
+HISTORY
+
+  1.4.3:
+    - fixed a small non-critical bug in the require gaurd
+
+  1.4.2:
+    - upped defaults for max_age to 3600 and suspend to 1800.
+    - tweaked a few things to play nice with rubygems
+
+  1.4.1:
+    - Mike Kasick <mkasick@club.cc.cmu.edu> reported a bug whereby false/nil
+      values for options were ignored.  patched to address this bug
+    - added Lockfile method for high level interface sans lockfile object
+    - updated rlock program to allow nil/true/false values passed on command
+      line.  eg
+
+        rlock --max_age=nil lockfile -- date --iso-8601=seconds
+
+  1.4.0:
+    - gem'd up
+    - added Lockfile::create method which atomically creates a file and opens
+      it: 
+
+        Lockfile::create("atomic_even_on_nfs", "r+") do |f|
+          f.puts 42
+        end
+
+      arguments are the same as those for File::open.  note that there is no way
+      to accomplish this otherwise since File::O_EXCL fails silently on nfs,
+      flock does not work on nfs, and posixlock (see raa) can only lock a file
+      after it is open so the open itself is still a race.
+
+  1.3.0:
+    - added sweep functionality.  hosts can clean up any tmp files left around
+      by other processes that may have been killed using -9 to prevent proper
+      clean up.  it is only possible to clean up after processes on the same
+      host as there is no other way to determine if the process that created the
+      file is alive.  in summary - hosts clean up after other processes on that
+      same host if needed.
+    - added attempt/try_again methods
+  1.2.0:
+    - fixed bug where stale locks not removed when retries == 0
+  1.1.0
+    - unfortunately i've forgotten
+  1.0.1:
+    - fixed bugette in sleep cycle where repeated locks with same lockfile would
+      not reset the cycle at the start of each lock
+  1.0.0:
+    - allow rertries to be nil, meaning to try forever
+    - default timeout is now nil - never timeout
+    - default refresh is now 8
+    - fixed bug where refresher thread was not actually touching lockfile! (ouch)
+    - added cycle method to timeouts
+        1-2-3-2-1-2-3-1...
+      pattern is constructed using min_sleep, sleep_inc, max_sleep
+  0.3.0:
+    - removed use of yaml in favour of hand parsing the lockfile contents, the
+      file as so small it just wasn't worth and i have had one core dump when yaml
+      failed to parse a (corrupt) file
+  0.2.0:
+    - added an initial polling style attempt to grab lock before entering normal
+      sleep/retry loop.  this has really helped performance when lock is under
+      heavy contention: i see almost no sleeping done by any of in the interested
+      processes
+  0.1.0:
+    - added ability of Lockfile.new to accept a block
+  0.0.0:
+    - initial version

data/lib/crazy_ivan/vendor/lockfile-1.4.3/bin/rlock

@@ -0,0 +1,360 @@
+#!/usr/bin/env ruby
+#
+# built-in
+#
+  require 'optparse'
+  require 'logger'
+#
+# http://raa.ruby-lang.org/project/lockfile/
+#
+  require 'lockfile-1.4.3'
+
+  class Main
+#--{{{
+    VERSION = Lockfile::VERSION 
+
+    USAGE = 
+#--{{{
+  <<-usage
+  NAME
+    rlock v#{ VERSION }
+
+  SYNOPSIS
+    rlock [options]+ lockfile [program [args]+ | -- program options+ [args]+]
+
+  DESCRIPTTION
+    rlock creates NFS safe lockfiles.  it can optionally run a program while
+    holding the lock, ensuring lockfile removal on program exit.  if a program
+    is specified to be run rlock will spawn a background thread to kept the
+    lockfile 'fresh' by touching it at a regular interval.  in this way a lease
+    is maintained on the lockfile and other processes attempting to obtain the
+    lock can determine that it is in use.  see the '--refresh' option for how to
+    control the touch interval.  any other process trying to obtain a lock will
+    automatically remove a stale lockfile; a stale lockfile is one that is older
+    than a certain age.  this age be controled via the '--max_age' option.
+
+  ENVIRONMENT
+    LOCKFILE_DEBUG=1 
+      causes internal actions of the library to be shown on STDERR 
+
+  DIAGNOSTICS
+   rlock attempts to exit with the status of 'program' except where it
+   cannot due to exceptional conditions.  in addition the message 
+
+    'RLOCK SUBCOMMAND FAILURE' 
+    
+    will be printed on STDERR if 'program' exits with non-zero status.
+
+   success => $? == 0
+   failure => $? != 0
+
+  AUTHOR
+   ara.t.howard@noaa.gov
+
+  BUGS
+    1 < bugno && bugno < 42
+
+  OPTIONS
+  usage
+#--}}}
+
+    EXAMPLES =
+#--{{{
+  <<-examples
+  EXAMPLES
+
+    0) simple usage - create lockfile in an atomic fashion (obtain a lock) 
+
+      ~ > rlock lockfile
+
+    1) safe usage - create a lockfile, execute a command, and remove lockfile
+
+      ~ > rlock lockfile ls lockfile
+
+    2) same as above, but logging verbose messages 
+
+      ~ > rlock -v4 lockfile ls lockfile
+   
+    3) same as above, but logging verbose messages and showing actions internal
+    to lockfile library
+
+      ~ > rlock -v4 -d lockfile ls lockfile
+
+    4) same as above
+
+      ~ > LOCKFILE_DEBUG=1 rlock -v4 lockfile ls lockfile
+
+    5) same as above
+
+      ~ > export LOCKFILE_DEBUG=1
+      ~ > rlock -v4 lockfile ls lockfile
+
+    6) you need to tell the option parser to stop parsing rlock options if you
+    intend to pass options to 'program' 
+
+      ~ > rlock -v4 -d lockfile -- ls -ltar lockfile
+
+       without the '--' rlock would consume the '-ltar' option as one of
+       it's own.
+
+    7) lock lockfile and exec 'program' - remove the lockfile if it is older
+    than 4242 seconds
+
+      ~ > rlock --max_age=4242 lockfile program 
+
+    8) lock lockfile and exec 'program' - remove the lockfile if it is older
+    than 4242 seconds, set the refresh rate to be 8 seconds.
+
+      ~ > rlock --max_age=4242 --refresh=8 lockfile program 
+
+    9) same as above, but fail if lockfile cannot be obtained within 1 minute
+
+      ~ > rlock --max_age=4242 --refresh=8 --timeout=60 lockfile program 
+
+    10) lockfile creation involves making some temporary files.  normally these
+    are cleaned up unless rlock is killed with 'kill -9'.  these temp files are
+    normally 'sweeped' - searched for and removed - unless the '--dont_sweep'
+    option is given.  note that sweeping can remove ONLY old temp files created
+    by the same host since there is otherwise no way to tell if the offending
+    process is still running.
+
+    lock lockfile and run program - do not do any sweeping
+
+      ~ > rlock --dont_sweep lockfile program 
+
+  examples
+#--}}}
+
+    EXIT_SUCCESS = 0
+    EXIT_FAILURE = 1
+
+    attr :argv
+    attr :op
+    attr :logger
+    attr :config
+
+    def initialize argv = ARGV
+#--{{{
+      @argv = mcp argv
+      parse_opts
+      if @opt_version
+        puts Main::VERSION
+        exit EXIT_SUCCESS
+      end
+      if @opt_help
+        usage
+        exit EXIT_SUCCESS
+      end
+      parse_argv
+      run
+#--}}}
+    end
+    def run
+#--{{{
+      init_logging
+
+      debug{ "lockpath <#{ @lockpath }>" }
+
+      opts = {}
+      options = 
+        %w(retries max_age sleep_inc min_sleep max_sleep suspend timeout refresh poll_retries poll_max_sleep)
+      options.each do |opt|
+        #if((val = eval("opt_#{ opt }")))
+        if(send("opt_#{ opt }?"))
+          val = send "opt_#{ opt }"
+          begin
+            val = (opts[opt] = String === val ? Integer(val) : val)
+            logger.debug{ "<#{ opt }> <#{ val.inspect }>" }
+          rescue
+            logger.fatal{ "illegal value <#{ val.inspect }> for opt <#{ opt }>" }
+            exit EXIT_FAILURE
+          end
+        end
+      end
+
+      opts['debug'] = true if opt_debug
+
+      begin
+        case @argv.size
+          when 0
+            opts['dont_clean'] = true
+            logger.debug{ "opts <#{ opts.inspect }>" }
+            logger.debug{ "aquiring lock <#{ @lockpath }>..." }
+          #
+          # simple usage - just create the lockfile with opts
+          #
+            lockfile = ::Lockfile.new @lockpath, opts
+            lockfile.lock
+
+            logger.debug{ "aquired lock <#{ @lockpath }>" }
+          else
+            logger.debug{ "opts <#{ opts.inspect }>" }
+            logger.debug{ "aquiring lock <#{ @lockpath }>..." }
+          #
+          # block usage - create the lockfile with opts, run block, rm lockfile
+          #
+            status = 1
+
+            lockfile = ::Lockfile.new @lockpath, opts
+
+            lockfile.lock do
+              logger.debug{ "aquired lock <#{ @lockpath }>" }
+              logger.debug{ "cmd <#{ @argv.join ' ' }>" }
+              v = nil
+              begin
+                v = $VERBOSE
+                $VERBOSE = nil 
+                STDOUT.flush
+                STDERR.flush
+                fork{ exec(*@argv) }
+                pid, status = Process::wait2
+              ensure
+                $VERBOSE = v
+              end
+              logger.debug{ "status <#{ $? }>" }
+            end
+
+            status = status.exitstatus
+            STDERR.puts "RLOCK SUBCOMMAND FAILURE" unless status == 0
+            exit status
+        end
+      rescue => e
+        logger.fatal{ e }
+        exit EXIT_FAILURE
+      end
+
+      exit EXIT_SUCCESS
+#--}}}
+    end
+    def parse_opts
+#--{{{
+      @op = OptionParser::new
+      @op.banner = ''
+      define_options
+      @op.parse! argv
+
+#--}}}
+    end
+    def parse_argv
+#--{{{
+      usage and exit EXIT_FAILURE if @argv.empty?
+      @lockpath = @argv.shift
+#--}}}
+    end
+    def define_options
+#--{{{
+      options = [
+        ['--retries=n','-r', "default(#{ Lockfile.retries.inspect }) - (nil => forever)"],
+        ['--max_age=n','-a', "default(#{ Lockfile.max_age.inspect })"],
+        ['--sleep_inc=n','-s', "default(#{ Lockfile.sleep_inc.inspect })"],
+        ['--max_sleep=n','-p', "default(#{ Lockfile.max_sleep.inspect })"],
+        ['--min_sleep=n','-P', "default(#{ Lockfile.min_sleep.inspect })"],
+        ['--suspend=n','-u', "default(#{ Lockfile.suspend.inspect })"],
+        ['--timeout=n','-t', "default(#{ Lockfile.timeout.inspect }) - (nil => never)"],
+        ['--refresh=n','-f', "default(#{ Lockfile.refresh.inspect })"],
+        ['--debug','-d', "default(#{ Lockfile.debug.inspect })"],
+        ['--poll_retries=n','-R', "default(#{ Lockfile.poll_retries.inspect })"],
+        ['--poll_max_sleep=n','-S', "default(#{ Lockfile.poll_max_sleep.inspect })"],
+        ['--dont_sweep','-w', "default(#{ Lockfile.dont_sweep.inspect })"],
+
+        ['--version'],
+        ['--verbosity=0-4|debug|info|warn|error|fatal','-v'],
+        ['--log=path','-l'],
+        ['--log_age=log_age'],
+        ['--log_size=log_size'],
+        ['--help','-h'],
+      ]
+      options.each do |option|
+        opt = option.first.gsub(%r/(?:--)|(?:=.*$)/o,'').strip
+        get, set = opt_attr opt
+        value4 = lambda do |v|
+          case v
+            when NilClass, %r/^t|true$/i
+              true
+            when %r/^f|false$/i
+              false
+            when %r/^nil|nul|null$/i
+              nil
+            else
+              v
+          end
+        end
+        @op.def_option(*option) do |v|
+          send set, value4[v]
+        end
+      end
+#--}}}
+    end
+    %w(debug info warn error fatal).each do |m|
+      eval "def #{ m }(*args,&block);@logger.#{ m }(*args,&block);end"
+    end
+    def init_logging
+#--{{{
+      if @opt_log_age
+        @opt_log_age = @opt_log_age.to_i if @opt_log_age =~ /\d/
+      end
+      if @opt_log_size
+        @opt_log_size = @opt_log_size.to_i if @opt_log_size =~ /\d/
+      end
+      $logger = @logger = Logger::new(@opt_log || STDERR, @opt_log_age, @opt_log_size)
+
+      level = nil
+      @opt_verbosity ||= 'info'
+      @opt_verbosity =
+        case @opt_verbosity
+          when /^\s*(?:4|d|debug)\s*$/io
+            level = 'Logging::DEBUG'
+            4
+          when /^\s*(?:3|i|info)\s*$/io
+            level = 'Logging::INFO'
+            3
+          when /^\s*(?:2|w|warn)\s*$/io
+            level = 'Logging::WARN'
+            2
+          when /^\s*(?:1|e|error)\s*$/io
+            level = 'Logging::ERROR'
+            1
+          when /^\s*(?:0|f|fatal)\s*$/io
+            level = 'Logging::FATAL'
+            0
+          else
+            abort "illegal verbosity setting <#{ @opt_verbosity }>" 
+        end
+      @logger.level = 2 - ((@opt_verbosity % 5) - 2) 
+#--}}}
+    end
+    def usage io = STDOUT
+#--{{{
+      io << USAGE
+      io << "\n"
+      io << @op
+      io << "\n"
+      io << EXAMPLES if defined? EXAMPLES
+      self
+#--}}}
+    end
+    def opt_attr opt
+#--{{{
+      query = "opt_#{ opt }?"
+      get = "opt_#{ opt }"
+      set = "#{ get }="
+      code = <<-code
+        class << self
+          def #{ query }; defined? @#{ get }; end
+          def #{ get }; defined?(@#{ get }) ? @#{ get } : nil; end
+          def #{ set } value; @#{ get } = value; end
+        end
+      code
+      instance_eval code 
+      [get, set]
+#--}}}
+    end
+    def mcp obj
+#--{{{
+      Marshal::load(Marshal::dump(obj))
+#--}}}
+    end
+#--}}}
+  end
+
+  Main::new