rudy 0.2

data/CHANGES.txt

@@ -0,0 +1,21 @@
+RUDY, CHANGES
+
+#### 0.2 (2009-02-23) ###############################
+
+NOTE: This is a complete re-write from 0.1
+
+* UPGRADE: drydock 0.3.3
+* NEW: Commands: myaddress, addresses, images, instances, disks, connect release
+* NEW: Metadata storage to SimpleDB
+* NEW: Creates EBS volumes based on startup from metadata
+* NEW: Automated release process
+* NEW: Automated creation of machine images
+* NEW: Partial support for regions and zones
+* NEW: Manage system based on security groups. 
+* NEW: "rudy groups" overhaul. Display, creates, destroys groups. 
+* CHANGE: Added Environment variables
+
+
+#### 0.1 (2009-02-06) ###############################
+
+* Initial release

data/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2009 Solutious Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,32 @@
+= Rudy - v0.2 BETA!
+
+Rudy is a handy staging and deployment tool for EC2.
+
+NOTE: Rudy is not ready for general consumption. Come back in Q2 2009!
+
+== Installation
+
+# Soon!
+
+== More Info
+
+* GitHub[http://github.com/solutious/rudy]
+* RubyForge[http://rubyforge.org/projects/rudy]
+* Inspiration[http://www.youtube.com/watch?v=CgaiIW5Rzes]
+
+
+== Credits
+
+* Delano Mandelbaum (delano@solutious.com)
+* Keshia Knight Pulliam (rudy@solutious.com)
+
+
+== Thanks
+
+* The Rilli[http://rilli.com/] team, for the initial use case and support. 
+* Alicia Eyre Vasconcelos, for the name ("H-e-l-l-o R.U.D.Y")
+
+
+== License
+
+See: LICENSE.txt

data/Rakefile

@@ -0,0 +1,68 @@
+require 'rubygems'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'hanna/rdoctask'
+require 'fileutils'
+include FileUtils
+ 
+task :default => :package
+ 
+# SPECS ===============================================================
+ 
+# None-yet!
+
+# PACKAGE =============================================================
+
+name = "rudy"
+load "#{name}.gemspec"
+
+version = @spec.version
+
+Rake::GemPackageTask.new(@spec) do |p|
+  p.need_tar = true if RUBY_PLATFORM !~ /mswin/
+end
+
+task :release => [ :rdoc, :package ]
+
+task :install => [ :rdoc, :package ] do
+	sh %{sudo gem install pkg/#{name}-#{version}.gem}
+end
+
+task :uninstall => [ :clean ] do
+	sh %{sudo gem uninstall #{name}}
+end
+
+
+# Rubyforge Release / Publish Tasks ==================================
+
+desc 'Publish website to rubyforge'
+task 'publish:rdoc' => 'doc/index.html' do
+  sh "scp -rp doc/* rubyforge.org:/var/www/gforge-projects/#{name}/"
+end
+
+desc 'Public release to rubyforge'
+task 'publish:gem' => [:package] do |t|
+  sh <<-end
+    rubyforge add_release -o Any -a CHANGES.txt -f -n README.rdoc #{name} #{name} #{@spec.version} pkg/#{name}-#{@spec.version}.gem &&
+    rubyforge add_file -o Any -a CHANGES.txt -f -n README.rdoc #{name} #{name} #{@spec.version} pkg/#{name}-#{@spec.version}.tgz 
+  end
+end
+
+
+Rake::RDocTask.new do |t|
+	t.rdoc_dir = 'doc'
+	t.title    = @spec.summary
+	t.options << '--line-numbers' << '--inline-source' << '-A cattr_accessor=object'
+	t.options << '--charset' << 'utf-8'
+	t.rdoc_files.include('LICENSE.txt')
+	t.rdoc_files.include('README.rdoc')
+	t.rdoc_files.include('CHANGES.txt')
+	t.rdoc_files.include('bin/*')
+	t.rdoc_files.include('lib/*.rb')
+	t.rdoc_files.include('lib/**/*.rb')
+end
+
+CLEAN.include [ 'pkg', '*.gem', '.config', 'doc' ]
+
+
+

data/bin/rudy

@@ -0,0 +1,258 @@
+#!/usr/bin/ruby
+
+# Rudy -- Your friend in staging and deploying to EC2
+#
+#   See rudy -h for usage
+# 
+# AWS commands need the access identifiers. If you don't want
+# to include them as arguments, you can set the following variables
+# in your environment (replace **** with the literal value):
+#
+
+#
+# No Ruby 1.9.1 support. Only 1.8.x for now :[
+unless RUBY_VERSION < "1.9"
+  puts "Sorry! We're using the right_aws gem and it doesn't support Ruby 1.9 yet."
+  exit 1
+end
+
+RUDY_HOME = File.join(File.dirname(__FILE__))
+RUDY_LIB = File.join(RUDY_HOME, '..', 'lib')
+$:.unshift RUDY_LIB # Put our local lib in first place
+
+require 'rubygems'
+require 'openssl'
+
+require 'drydock'
+require 'rudy'
+extend Drydock
+
+debug :off
+
+default :commands
+
+
+global_usage "rudy [global options] COMMAND [command options]"
+global_option :A, :access_key, "AWS Access Key", String
+global_option :S, :secret_key, "AWS Secret Access Key", String
+
+global_option :p, :position, String, "Position in the machine in its group (default: 01)"
+global_option :u, :user, String, "Provide a username (default: rudy)"
+global_option :e, :environment, String, "Connect to the specified environment (default: stage)"
+global_option :r, :role, String, "Connect to a machine with the specified role (defalt: app)"
+
+global_option :V, :version, "Display version number" do
+  puts "Rudy version: #{Rudy::VERSION}"
+  exit 0
+end
+global_option :v, :verbose, "Increase verbosity of output (i.e. -v or -vv or -vvv)" do
+  @verbose ||= 0
+  @verbose += 1
+end
+
+command :commands do
+  puts "Rudy can do all of these things:", ""
+  command_names.sort.each do |cmd|
+    puts " %16s" % cmd
+  end
+  puts 
+  puts "Try: rudy -h OR rudy COMMAND -h"
+  puts
+end
+
+usage "rudy init"
+command :init => Rudy::Command::Metadata do |obj|
+  obj.setup
+end
+
+usage "rudy info"
+command :info => Rudy::Command::Metadata do |obj|
+  obj.info
+end
+
+option :D, :destroy, "Destroy all metadata stored in SimpleDB"
+option :u, :update, "Update the role or environment metadata for the given instance-IDs"
+usage "rudy [global options] metadata instance-ID"
+command :metadata => Rudy::Command::Metadata do |obj, argv|
+  obj.print_header
+  
+  if obj.update
+    raise "No instance ID!" if argv.empty?
+    raise "Nothing to change (see global options -r or -e)" unless obj.role || obj.environment
+    obj.update_metadata(argv.first)
+  elsif obj.destroy
+    exit unless you_are_sure?
+    obj.destroy_metadata
+  else
+    obj.print_metadata(argv.first)
+  end
+end
+
+
+option :i, :instance, String, "Instance ID to associate the id"
+option :A, :associate, "Associate an address to a running instance"
+usage "rudy [global options] addresses [-A -i instance ID] [address]"
+command :addresses => Rudy::Command::Addresses do |obj, argv|
+  obj.print_header
+  
+  if obj.associate
+    obj.associate_address(argv.first)
+  else
+    obj.print_addresses
+  end
+end
+
+
+
+option :p, :print, "Only print the SSH command, don't connect"
+usage "rudy [-e env] [-u user] connect [-p]"
+command :connect => Rudy::Command::Environment do |obj|
+  capture(:stderr) do
+    obj.print_header
+    obj.connect
+  end
+end
+
+
+
+option :all, "Display all disk definitions"
+option :p, :path, String, "The filesystem path to use as the mount point"
+option :d, :device, String, "The device id (default: /dev/sdh)"
+option :s, :size, Integer, "The size of disk (in GB)"
+option :C, :create, "Create a disk definition"
+option :D, :destroy, "Destroy a disk definition"
+option :A, :attach, "Attach a disk"
+usage "rudy [global options] disks [-C -p path -d device -s size] [-A] [-D] [disk name]"
+command :disks => Rudy::Command::Disks do |obj, argv|
+  #capture(:stderr) do
+  obj.print_header
+  if obj.create
+    raise "No filesystem path specified" unless obj.path
+    raise "No size specified" unless obj.size
+    obj.create_disk
+  elsif obj.destroy
+    raise "No disk specified" if argv.empty?
+    exit unless you_are_sure?
+    obj.destroy_disk(argv.first)
+  elsif obj.attach
+    raise "No disk specified" if argv.empty?
+    obj.attach_disk(argv.first)
+  else
+    obj.print_disks
+  end
+  obj.print_footer
+  #end
+end
+
+#command :volumes => Rudy::Command::Volumes do |obj|
+#  obj.print_volumes
+#end
+
+option :all, "Display all instances"
+option :a, :address, String, "Amazon elastic IP"
+option :i, :image, String, "Amazon machine image ID (ami)"
+option :v, :volume, String, "Amazon volume ID"
+option :D, :destroy, "Destroy the given instance IDs. All data will be lost!"
+option :S, :start, "Start an instance"
+usage "rudy [global options] instances [-D] [-S -i image ID] [instance ID OR group name]"
+command :instances => Rudy::Command::Instances do |obj, argv|
+  capture(:stderr) do
+  obj.print_header
+  if obj.destroy
+    exit unless you_are_sure?
+    obj.destroy_instances(argv.first)
+  elsif obj.start
+    exit unless you_are_sure?
+    obj.start_instance
+  else
+    obj.print_instances(argv.first)
+  end
+  obj.print_footer
+  end
+end
+
+
+option :e, :external, "Display only external IP address"
+option :i, :internal, "Display only internal IP address"
+usage "rudy myaddress [-i] [-e]"
+command :myaddress do |obj|
+  ea = Rudy::Utils::external_ip_address  
+  ia = Rudy::Utils::internal_ip_address
+  puts "%10s: %s" % ['Internal', ia] unless obj.external && !obj.internal
+  puts "%10s: %s" % ['External', ea] unless obj.internal && !obj.external
+end 
+
+option :a, :account, String, "Your Amazon Account Number"
+option :i, :image_name, String, "The name of the image"
+option :b, :bucket_name, String, "The name of the bucket that will store the image"
+option :C, :create, "Create an image"
+usage "rudy images [-C -i image -b bucket -a account]"
+command :images => Rudy::Command::Images do |obj|
+  if obj.create
+    puts "Make sure the machine is clean. I don't want archive no crud!"
+    exit unless you_are_sure?
+    obj.create_image
+  else
+    obj.print_images
+  end
+end
+
+command :release => Rudy::Command::Release do |obj| 
+  obj.print_header
+  
+  raise "No SCM defined. Set RUDY_SVN_BASE or RUDY_GIT_BASE." unless obj.scm
+  
+  #exit unless you_are_sure?
+  obj.create_release
+  
+end
+
+
+option :all, "Display all security groups"
+option :r, :protocols, Array, "Comma-separated list of protocols. One of: tcp (default), udp, icmp"
+option :p, :ports, Array, "List of comma-separated ports to authorize (default: 22,80,443)"
+option :a, :addresses, Array, "List of comma-separated IP addresses to authorize (default: your external IP)"
+option :C, :create, "Create a security group"
+option :D, :destroy, "Destroy a security group"
+option :M, :modify, "Modify a security group"
+usage "rudy [global options] groups [-C] [-a IP addresses] [-p ports] [group name]"
+command :groups => Rudy::Command::Groups do |obj, argv|
+  if obj.create
+    obj.create_group(argv.first)
+  
+  elsif obj.modify
+    obj.modify_group(argv.first)
+    
+  elsif obj.destroy
+    exit unless you_are_sure?
+    obj.destroy_group(argv.first)
+  
+  else
+    obj.print_groups(argv.first)
+  end
+end
+
+
+__END__
+
+# Create the SimpleDB domain for storing metadata. Check environment variables. 
+rudy init
+rudy create-group -a address -i ami-1111111 -v vol-2222222
+
+# Connect to stage-app-01 as root
+rudy --user root connect
+
+# Zone, environment, role and position are implied. 
+rudy disks -C -p /rilli/app -d /dev/sdh -s 100
+rudy disks -D disk-us-east-1b-stage-app-01-rilli-db222
+
+# Create an image from an existing instance
+rudy -e prod images -C -b rilli-ami-us -i rilli-app-32-r3
+
+# Create an instance 
+rudy -e prod instances -S -i ami-11111
+
+
+rudy release
+
+

data/lib/drydock.rb

@@ -0,0 +1,525 @@
+require 'optparse'
+require 'ostruct'
+
+#
+#
+module Drydock
+  # The base class for all command objects. There is an instance of this class
+  # for every command defined. Global and command-specific options are added
+  # as attributes to this class dynamically. 
+  # 
+  # i.e. "example -v date -f yaml"
+  #
+  #     global_option :v, :verbose, "I want mooooore!"
+  #     option :f, :format, String, "Long date format"
+  #     command :date do |obj|
+  #         puts obj.verbose  #=> true
+  #         puts obj.format  #=> "yaml"
+  #     end
+  #
+  # You can inherit from this class to create your own: EatFood < Drydock::Command.
+  # And then specific your class in the command definition:
+  #
+  #     command :eat => EatFood do |obj|; ...; end
+  #
+  class Command
+    attr_reader :cmd, :alias
+    attr_accessor :verbose
+    
+    # The default constructor sets the short name of the command
+    # and stores a reference to the block (if supplied).
+    # You don't need to override this method to add functionality 
+    # to your custom Command classes. Define an +init+ method instead.
+    # It will be called just before the block is executed. 
+    # +cmd+ is the short name of this command.
+    # +b+ is the block associated to this command.
+    def initialize(cmd, &b)
+      @cmd = (cmd.kind_of?(Symbol)) ? cmd : cmd.to_sym
+      @b = b
+      @verbose = 0
+    end
+    
+    # Execute the block.
+    # 
+    # Calls self.init before calling the block. Implement this method when 
+    #
+    # +cmd_str+ is the short name used to evoke this command. It will equal @cmd
+    # unless an alias was used used to evoke this command.
+    # +argv+ an array of unnamed arguments. If ignore :options was declared this
+    # will contain the arguments exactly as they were defined on the command-line.
+    # +stdin+ contains the output of stdin do; ...; end otherwise it's a STDIN IO handle.
+    # +global_options+ a hash of the global options specified on the command-line
+    # +options+ a hash of the command-specific options specific on the command-line.
+    def call(cmd_str=nil, argv=[], stdin=[], global_options={}, options={})
+      @alias = cmd_str.nil? ? @cmd : cmd_str
+      global_options.merge(options).each_pair do |n,v|
+        self.send("#{n}=", v)
+      end
+      
+      self.init if respond_to? :init
+      
+      block_args = [self, argv, stdin] # TODO: review order
+      @b.call(*block_args[0..(@b.arity-1)]) # send only as many args as defined
+    end
+    
+    # The name of the command
+    def to_s
+      @cmd.to_s
+    end
+  end
+end
+
+module Drydock
+  class UnknownCommand < RuntimeError
+    attr_reader :name
+    def initialize(name)
+      @name = name || :unknown
+    end
+    def message
+      "Unknown command: #{@name}"
+    end
+  end
+  class NoCommandsDefined < RuntimeError
+    def message
+      "No commands defined"
+    end
+  end
+  class InvalidArgument < RuntimeError
+    attr_accessor :args
+    def initialize(args)
+      @args = args || []
+    end
+    def message
+      "Unknown option: #{@args.join(", ")}"
+    end
+  end
+  class MissingArgument < InvalidArgument
+    def message
+      "Option requires a value: #{@args.join(", ")}"
+    end
+  end
+end
+
+# Drydock is a DSL for command-line apps. 
+# See bin/example for usage examples. 
+module Drydock
+  extend self
+  
+  VERSION = 0.3
+  
+ private
+  # Stolen from Sinatra!
+  #def delegate(*args)
+  #  args.each do |m|
+  #    eval(<<-end_eval, binding, "(__Drydock__)", __LINE__)
+  #      def #{m}(*args, &b)
+  #        Drydock.#{m}(*args, &b)
+  #      end
+  #    end_eval
+  #  end
+  #end
+  #
+  #delegate :before, :after, :alias_command, :desc
+  #delegate :global_option, :global_usage, :usage, :commands, :command
+  #delegate :debug, :option, :stdin, :default, :ignore, :command_alias
+  
+  @@debug = false
+  @@has_run = false
+  @@run = true
+  @@default_command = nil
+  
+ public
+  # Enable or disable debug output.
+  #
+  #    debug :on
+  #    debug :off
+  #
+  # Calling without :on or :off will toggle the value. 
+  #
+  def debug(toggle=false)
+    if toggle.is_a? Symbol
+      @@debug = true if toggle == :on
+      @@debug = false if toggle == :off
+    else
+      @@debug = (!@@debug)
+    end
+  end
+  # Returns true if debug output is enabled. 
+  def debug?
+    @@debug
+  end
+  
+  # Define a default command. 
+  #
+  #     default :task
+  #
+  def default(cmd)
+    @@default_command = canonize(cmd)
+  end
+  
+  # Provide a description for a method
+  def desc(txt)
+    @@command_descriptions ||= []
+    @@command_descriptions << txt
+  end
+  
+  # Define a block for processing STDIN before the command is called. 
+  # The command block receives the return value of this block in a named argument:
+  #
+  #     command :task do |obj, argv, stdin|; ...; end
+  #
+  # If a stdin block isn't defined, +stdin+ above will be the STDIN IO handle. 
+  def stdin(&b)
+    @@stdin_block = b
+  end
+  
+  # Define a block to be called before the command. 
+  # This is useful for opening database connections, etc...
+  def before(&b)
+    @@before_block = b
+  end
+  
+  # Define a block to be called after the command. 
+  # This is useful for stopping, closing, etc... the stuff in the before block. 
+  def after(&b)
+    @@after_block = b
+  end
+  
+  # Define the default global usage banner. This is displayed
+  # with "script -h". 
+  def global_usage(msg)
+    @@global_options ||= OpenStruct.new
+    global_opts_parser.banner = "USAGE: #{msg}"
+  end
+  
+  # Define a command-specific usage banner. This is displayed
+  # with "script command -h"
+  def usage(msg)
+    get_current_option_parser.banner = "USAGE: #{msg}"
+  end
+  
+  # Grab the options parser for the current command or create it if it doesn't exist.
+  def get_current_option_parser
+    @@command_opts_parser ||= []
+    @@command_index ||= 0
+    (@@command_opts_parser[@@command_index] ||= OptionParser.new)
+  end
+  
+  # Tell the Drydock parser to ignore something. 
+  # Drydock will currently only listen to you if you tell it to "ignore :options", 
+  # otherwise it will ignore you!
+  # 
+  # +what+ the thing to ignore. When it equals :options Drydock will not parse
+  # the command-specific arguments. It will pass the arguments directly to the
+  # Command object. This is useful when you want to parse the arguments in some a way
+  # that's too crazy, dangerous for Drydock to handle automatically.  
+  def ignore(what=:nothing)
+    @@command_opts_parser[@@command_index] = :ignore if what == :options || what == :all
+  end
+  
+  # Define a global option. See +option+ for more info. 
+  def global_option(*args, &b)
+    args.unshift(global_opts_parser)
+    global_option_names << option_parser(args, &b)
+  end
+  
+  # Define a command-specific option. 
+  # 
+  # +args+ is passed directly to OptionParser.on so it can contain anything
+  # that's valid to that method. Some examples:
+  # [:h, :help, "Displays this message"]
+  # [:m, :max, Integer, "Maximum threshold"]
+  # ['-l x,y,z', '--lang=x,y,z', Array, "Requested languages"]
+  # If a class is included, it will tell OptionParser to expect a value 
+  # otherwise it assumes a boolean value.
+  #
+  # All calls to +option+ must come before the command they're associated
+  # to. Example:
+  # 
+  #     option :l, :longname, String, "Description" do; ...; end
+  #     command :task do |obj|; ...; end
+  #
+  # When calling your script with a specific command-line option, the value
+  # is available via obj.longname inside the command block. 
+  #
+  def option(*args, &b)
+    args.unshift(get_current_option_parser)
+    current_command_option_names << option_parser(args, &b)
+  end
+  
+  # Define a command. 
+  # 
+  #     command :task do
+  #       ...
+  #     end
+  # 
+  # A custom command class can be specified using Hash syntax. The class
+  # must inherit from Drydock::Command (class CustomeClass < Drydock::Command)
+  #
+  #     command :task => CustomCommand do
+  #       ...
+  #     end
+  #
+  def command(*cmds, &b)
+    @@command_index ||= 0
+    @@command_opts_parser ||= []
+    @@command_option_names ||= []
+    cmds.each do |cmd| 
+      if cmd.is_a? Hash
+        c = cmd.values.first.new(cmd.keys.first, &b)
+      else
+        c = Drydock::Command.new(cmd, &b)
+      end
+      commands[c.cmd] = c
+      command_index_map[c.cmd] = @@command_index
+      @@command_index += 1
+    end
+    
+  end
+  
+  # Used to create an alias to a defined command. 
+  # Here's an example:
+  #
+  #    command :task do; ...; end
+  #    alias_command :pointer, :task
+  #
+  # Either name can be used on the command-line:
+  #
+  #    $ script task [options]
+  #    $ script pointer [options]
+  #
+  # Inside of the command definition, you have access to the
+  # command name that was used via obj.alias. 
+  def alias_command(aliaz, cmd)
+    return unless commands.has_key? cmd
+    commands[canonize(aliaz)] = commands[cmd]
+  end
+  
+  # Identical to +alias_command+ with reversed arguments. 
+  # For whatever reason I forget the order so Drydock supports both. 
+  # Tip: the argument order matches the method name. 
+  def command_alias(cmd, aliaz)
+    return unless commands.has_key? cmd
+    puts "#{canonize(aliaz)} to #{commands[cmd]}"
+    commands[canonize(aliaz)] = commands[cmd]
+  end
+  
+  # An array of the currently defined Drydock::Command objects
+  def commands
+    @@commands ||= {}
+    @@commands
+  end
+  
+  # An array of the currently defined commands names
+  def command_names
+    @@commands ||= {}
+    @@commands.keys.collect { |cmd| decanonize(cmd); }
+  end
+  
+  # Returns true if automatic execution is enabled. 
+  def run?
+    @@run
+  end
+  
+  # Disable automatic execution (enabled by default)
+  #
+  #     Drydock.run = false
+  def run=(v)
+    @@run = (v == true) ? true : false 
+  end
+  
+  # Return true if a command has been executed.
+  def has_run?
+    @@has_run
+  end
+  
+  # Execute the given command.
+  # By default, Drydock automatically executes itself and provides handlers for known errors.
+  # You can override this functionality by calling +Drydock.run!+ yourself. Drydock
+  # will only call +run!+ once. 
+  def run!(argv=[], stdin=STDIN)
+    return if has_run?
+    @@has_run = true
+    raise NoCommandsDefined.new if commands.empty?
+    @@global_options, cmd_name, @@command_options, argv = process_arguments(argv)
+    
+    cmd_name ||= default_command
+    
+    raise UnknownCommand.new(cmd_name) unless command?(cmd_name)
+    
+    stdin = (defined? @@stdin_block) ? @@stdin_block.call(stdin, []) : stdin
+    @@before_block.call if defined? @@before_block
+    
+    call_command(cmd_name, argv, stdin)
+    
+    @@after_block.call if defined? @@after_block
+    
+  rescue OptionParser::InvalidOption => ex
+    raise Drydock::InvalidArgument.new(ex.args)
+  rescue OptionParser::MissingArgument => ex
+    raise Drydock::MissingArgument.new(ex.args)
+  end
+  
+ private 
+  
+  # Executes the block associated to +cmd+
+  def call_command(cmd, argv=[], stdin=nil)
+    return unless command?(cmd)
+    get_command(cmd).call(cmd, argv, stdin, @@global_options || {}, @@command_options || {})
+  end
+  
+  # Returns the Drydock::Command object with the name +cmd+
+  def get_command(cmd)
+    return unless command?(cmd)
+    @@commands[canonize(cmd)]
+  end 
+  
+  # Returns true if a command with the name +cmd+ has been defined. 
+  def command?(cmd)
+    name = canonize(cmd)
+    (@@commands || {}).has_key? name
+  end
+  
+  # Canonizes a string (+cmd+) to the symbol for command names
+  # '-' is replaced with '_'
+  def canonize(cmd)
+    return unless cmd
+    return cmd if cmd.kind_of?(Symbol)
+    cmd.to_s.tr('-', '_').to_sym
+  end
+  
+  # Returns a string version of +cmd+, decanonized.
+  # Lowercase, '_' is replaced with '-'
+  def decanonize(cmd)
+    return unless cmd
+    cmd.to_s.tr('_', '-')
+  end
+  
+  # Processes calls to option and global_option. Symbols are converted into 
+  # OptionParser style strings (:h and :help become '-h' and '--help'). 
+  def option_parser(args=[], &b)
+    return if args.empty?
+    opts_parser = args.shift
+    
+    arg_name = ''
+    symbol_switches = []
+    args.each_with_index do |arg, index|
+      if arg.is_a? Symbol
+        arg_name = arg.to_s if arg.to_s.size > arg_name.size
+        args[index] = (arg.to_s.length == 1) ? "-#{arg.to_s}" : "--#{arg.to_s}"
+        symbol_switches << args[index]
+      elsif arg.kind_of?(Class)
+        symbol_switches.each do |arg|
+          arg << "=S"
+        end
+      end
+    end
+    
+    if args.size == 1
+      opts_parser.on(args.shift)
+    else
+      opts_parser.on(*args) do |v|
+        block_args = [v, opts_parser]
+        result = (b.nil?) ? v : b.call(*block_args[0..(b.arity-1)])
+      end
+    end
+    
+    arg_name
+  end
+  
+  
+  # Split the +argv+ array into global args and command args and 
+  # find the command name. 
+  # i.e. ./script -H push -f (-H is a global arg, push is the command, -f is a command arg)
+  # returns [global_options, cmd, command_options, argv]
+  def process_arguments(argv=[])
+    global_options = command_options = {}
+    cmd = nil     
+    
+    global_options = global_opts_parser.getopts(argv)
+          
+    cmd_name = (argv.empty?) ? @@default_command : argv.shift
+    raise UnknownCommand.new(cmd_name) unless command?(cmd_name)
+    
+    cmd = get_command(cmd_name) 
+    
+    command_parser = @@command_opts_parser[get_command_index(cmd.cmd)]
+    command_options = {}
+    
+    # We only need to parse the options out of the arguments when
+    # there are args available, there is a valid parser, and 
+    # we weren't requested to ignore the options. 
+    if !argv.empty? && command_parser && command_parser != :ignore
+      command_options = command_parser.getopts(argv)
+    end
+    
+    # Add accessors to the Drydock::Command object 
+    # for the global and command specific options
+    [global_option_names, (command_option_names[get_command_index(cmd_name)] || [])].flatten.each do |n|
+      unless cmd.respond_to?(n)
+        cmd.class.send(:define_method, n) do
+          instance_variable_get("@#{n}")
+        end
+      end
+      unless cmd.respond_to?("#{n}=")
+        cmd.class.send(:define_method, "#{n}=") do |val|
+          instance_variable_set("@#{n}", val)
+        end
+      end
+    end
+    
+    [global_options, cmd_name, command_options, argv]
+  end
+  
+  def global_option_names
+    @@global_option_names ||= []
+  end
+  
+  # Grab the current list of command-specific option names. This is a list of the
+  # long names. 
+  def current_command_option_names
+    @@command_option_names ||= []
+    @@command_index ||= 0
+    (@@command_option_names[@@command_index] ||= [])
+  end
+  
+  def command_index_map
+    @@command_index_map ||= {}
+  end
+  
+  def get_command_index(cmd)
+    command_index_map[canonize(cmd)] || -1
+  end
+  
+  def command_option_names
+    @@command_option_names ||= []
+  end
+  
+  def global_opts_parser
+    @@global_opts_parser ||= OptionParser.new
+  end
+  
+  def default_command
+    @@default_command ||= nil
+  end
+  
+end
+
+
+
+trap ("SIGINT") do
+  puts "#{$/}Exiting..."
+  exit 1
+end
+
+
+at_exit {
+  begin
+    Drydock.run!(ARGV, STDIN) if Drydock.run? && !Drydock.has_run?
+  rescue => ex
+    STDERR.puts "ERROR: #{ex.message}"
+    STDERR.puts ex.backtrace if Drydock.debug?
+  end
+}
+
+