solutious-rudy 0.4.0 → 0.5.0

data/lib/aws_sdb/service.rb

@@ -8,7 +8,7 @@ require 'openssl'
 require 'rexml/document'
 require 'rexml/xpath'
 
-module AwsSdb
+module AwsSdb #:nodoc:all
 
   class Service
     def initialize(options={})

data/lib/console.rb

@@ -6,6 +6,11 @@
 
 
 class String
+  @@print_with_attributes = true
+  def String.disable_colour; @@print_with_attributes = false; end
+  def String.disable_color;  @@print_with_attributes = false; end
+  def String.enable_colour;  @@print_with_attributes = true;  end
+  def String.enable_color;   @@print_with_attributes = true;  end
   
   # +col+, +bgcol+, and +attribute+ are symbols corresponding
   # to Console::COLOURS, Console::BGCOLOURS, and Console::ATTRIBUTES.
@@ -14,6 +19,7 @@ class String
   #     "MONKEY_JUNK".colour(:blue, :white, :blink)  # => "\e[34;47;5mMONKEY_JUNK\e[39;49;0m"
   #
   def colour(col, bgcol = nil, attribute = nil)
+    return self unless @@print_with_attributes
     Console.style(col, bgcol, attribute) +
     self +
     Console.style(:default, :default, :default)
@@ -22,6 +28,7 @@ class String
   
   # See colour
   def bgcolour(bgcol = :default)
+    return self unless @@print_with_attributes
     Console.style(nil, bgcol, nil) +
     self +
     Console.style(nil, :default, nil)
@@ -30,11 +37,16 @@ class String
   
   # See colour
   def att(a = :default)
+    return self unless @@print_with_attributes
     Console.style(nil, nil, a) +
     self +
     Console.style(nil, nil, :default)
   end
   
+  # Shortcut for att(:bright)
+  def bright
+    att(:bright)
+  end
   
   # Print the string at +x+ +y+. When +minus+ is any true value
   # the length of the string is subtracted from the value of x
@@ -58,7 +70,7 @@ class String
   end
 end
 
-class Object
+class Object #:nodoc:all
 
   # Executes tput +capnam+ with +args+. Returns true if tcap gives
   # 0 exit status and false otherwise. 
@@ -82,7 +94,7 @@ end
 
 
 
-module Console
+module Console #:nodoc:all
   extend self
   require 'timeout'
   require 'thread'
@@ -127,6 +139,10 @@ module Console
     :random  => 40 + rand(10).to_i
   }.freeze unless defined? BGCOLOURS
   
+  def valid_colour?(colour)
+    COLOURS.has_key? colour
+  end
+  alias :valid_color? :valid_colour? 
   
   def print_left(str, props={})
     props[:x] ||= 0
@@ -196,7 +212,7 @@ module Console
   end
 end
 
-module Cursor
+module Cursor #:nodoc:all
   extend self
   
   # Returns [x,y] for the current cursor position.
@@ -291,7 +307,7 @@ module Cursor
   
 end
 
-class Window
+class Window #:nodoc:all
   attr_accessor :row, :col, :width, :height, :text, :fg, :bg
   attr_reader :threads
   

data/lib/escape.rb

@@ -0,0 +1,305 @@
+# escape.rb - escape/unescape library for several formats
+#
+# Copyright (C) 2006,2007 Tanaka Akira  <akr@fsij.org>
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+#  1. Redistributions of source code must retain the above copyright notice, this
+#     list of conditions and the following disclaimer.
+#  2. Redistributions in binary form must reproduce the above copyright notice,
+#     this list of conditions and the following disclaimer in the documentation
+#     and/or other materials provided with the distribution.
+#  3. The name of the author may not be used to endorse or promote products
+#     derived from this software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+# WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+# EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+# OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+# IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+# OF SUCH DAMAGE.
+
+# Escape module provides several escape functions.
+# * URI
+# * HTML
+# * shell command
+module Escape #:nodoc:all
+  module_function
+
+  class StringWrapper
+    class << self
+      alias new_no_dup new
+      def new(str)
+        new_no_dup(str.dup)
+      end
+    end
+
+    def initialize(str)
+      @str = str
+    end
+
+    def to_s
+      @str.dup
+    end
+
+    def inspect
+      "\#<#{self.class}: #{@str}>"
+    end
+
+    def ==(other)
+      other.class == self.class && @str == other.instance_variable_get(:@str)
+    end
+    alias eql? ==
+
+    def hash
+      @str.hash
+    end
+  end
+
+  class ShellEscaped < StringWrapper
+  end
+
+  # Escape.shell_command composes
+  # a sequence of words to
+  # a single shell command line.
+  # All shell meta characters are quoted and
+  # the words are concatenated with interleaving space.
+  # It returns an instance of ShellEscaped.
+  #
+  #  Escape.shell_command(["ls", "/"]) #=> #<Escape::ShellEscaped: ls />
+  #  Escape.shell_command(["echo", "*"]) #=> #<Escape::ShellEscaped: echo '*'>
+  #
+  # Note that system(*command) and
+  # system(Escape.shell_command(command)) is roughly same.
+  # There are two exception as follows.
+  # * The first is that the later may invokes /bin/sh.
+  # * The second is an interpretation of an array with only one element: 
+  #   the element is parsed by the shell with the former but
+  #   it is recognized as single word with the later.
+  #   For example, system(*["echo foo"]) invokes echo command with an argument "foo".
+  #   But system(Escape.shell_command(["echo foo"])) invokes "echo foo" command without arguments (and it probably fails).
+  def shell_command(*command)
+    command = [command].flatten.compact # Delano
+    s = command.map {|word| shell_single_word(word) }.join(' ')
+    ShellEscaped.new_no_dup(s)
+  end
+
+  # Escape.shell_single_word quotes shell meta characters.
+  # It returns an instance of ShellEscaped.
+  #
+  # The result string is always single shell word, even if
+  # the argument is "".
+  # Escape.shell_single_word("") returns #<Escape::ShellEscaped: ''>.
+  #
+  #  Escape.shell_single_word("") #=> #<Escape::ShellEscaped: ''>
+  #  Escape.shell_single_word("foo") #=> #<Escape::ShellEscaped: foo>
+  #  Escape.shell_single_word("*") #=> #<Escape::ShellEscaped: '*'>
+  def shell_single_word(str)
+    return unless str
+    str &&= str.to_s # Delano fix
+    if str.empty?
+      ShellEscaped.new_no_dup("''")
+    elsif %r{\A[0-9A-Za-z+,./:=@_-]+\z} =~ str
+      ShellEscaped.new(str)
+    else
+      result = ''
+      str.scan(/('+)|[^']+/) {
+        if $1
+          result << %q{\'} * $1.length
+        else
+          result << "'#{$&}'"
+        end
+      }
+      ShellEscaped.new_no_dup(result)
+    end
+  end
+
+  class PercentEncoded < StringWrapper
+  end
+
+  # Escape.uri_segment escapes URI segment using percent-encoding.
+  # It returns an instance of PercentEncoded.
+  #
+  #  Escape.uri_segment("a/b") #=> #<Escape::PercentEncoded: a%2Fb>
+  #
+  # The segment is "/"-splitted element after authority before query in URI, as follows.
+  #
+  #   scheme://authority/segment1/segment2/.../segmentN?query#fragment
+  #
+  # See RFC 3986 for details of URI.
+  def uri_segment(str)
+    # pchar - pct-encoded = unreserved / sub-delims / ":" / "@"
+    # unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
+    # sub-delims = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
+    s = str.gsub(%r{[^A-Za-z0-9\-._~!$&'()*+,;=:@]}n) {
+      '%' + $&.unpack("H2")[0].upcase
+    }
+    PercentEncoded.new_no_dup(s)
+  end
+
+  # Escape.uri_path escapes URI path using percent-encoding.
+  # The given path should be a sequence of (non-escaped) segments separated by "/".
+  # The segments cannot contains "/".
+  # It returns an instance of PercentEncoded.
+  #
+  #  Escape.uri_path("a/b/c") #=> #<Escape::PercentEncoded: a/b/c>
+  #  Escape.uri_path("a?b/c?d/e?f") #=> #<Escape::PercentEncoded: a%3Fb/c%3Fd/e%3Ff>
+  #
+  # The path is the part after authority before query in URI, as follows.
+  #
+  #   scheme://authority/path#fragment
+  #
+  # See RFC 3986 for details of URI.
+  #
+  # Note that this function is not appropriate to convert OS path to URI.
+  def uri_path(str)
+    s = str.gsub(%r{[^/]+}n) { uri_segment($&) }
+    PercentEncoded.new_no_dup(s)
+  end
+
+  
+  def html_form_fast(pairs, sep='&')
+    s = pairs.map {|k, v|
+      # query-chars - pct-encoded - x-www-form-urlencoded-delimiters =
+      #   unreserved / "!" / "$" / "'" / "(" / ")" / "*" / "," / ":" / "@" / "/" / "?"
+      # query-char - pct-encoded = unreserved / sub-delims / ":" / "@" / "/" / "?"
+      # query-char = pchar / "/" / "?" = unreserved / pct-encoded / sub-delims / ":" / "@" / "/" / "?"
+      # unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
+      # sub-delims = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
+      # x-www-form-urlencoded-delimiters = "&" / "+" / ";" / "="
+      k = k.gsub(%r{[^0-9A-Za-z\-\._~:/?@!\$'()*,]}n) {
+        '%' + $&.unpack("H2")[0].upcase
+      }
+      v = v.gsub(%r{[^0-9A-Za-z\-\._~:/?@!\$'()*,]}n) {
+        '%' + $&.unpack("H2")[0].upcase
+      }
+      "#{k}=#{v}"
+    }.join(sep)
+    PercentEncoded.new_no_dup(s)
+  end
+  
+
+  # Escape.html_form composes HTML form key-value pairs as a x-www-form-urlencoded encoded string.
+  # It returns an instance of PercentEncoded.
+  #
+  # Escape.html_form takes an array of pair of strings or
+  # an hash from string to string.
+  #
+  #  Escape.html_form([["a","b"], ["c","d"]]) #=> #<Escape::PercentEncoded: a=b&c=d>
+  #  Escape.html_form({"a"=>"b", "c"=>"d"}) #=> #<Escape::PercentEncoded: a=b&c=d>
+  #
+  # In the array form, it is possible to use same key more than once.
+  # (It is required for a HTML form which contains
+  # checkboxes and select element with multiple attribute.)
+  #
+  #  Escape.html_form([["k","1"], ["k","2"]]) #=> #<Escape::PercentEncoded: k=1&k=2>
+  #
+  # If the strings contains characters which must be escaped in x-www-form-urlencoded,
+  # they are escaped using %-encoding.
+  #
+  #  Escape.html_form([["k=","&;="]]) #=> #<Escape::PercentEncoded: k%3D=%26%3B%3D>
+  #
+  # The separator can be specified by the optional second argument.
+  #
+  #  Escape.html_form([["a","b"], ["c","d"]], ";") #=> #<Escape::PercentEncoded: a=b;c=d>
+  #
+  # See HTML 4.01 for details.
+  def html_form(pairs, sep='&')
+    r = ''
+    first = true
+    pairs.each {|k, v|
+      # query-chars - pct-encoded - x-www-form-urlencoded-delimiters =
+      #   unreserved / "!" / "$" / "'" / "(" / ")" / "*" / "," / ":" / "@" / "/" / "?"
+      # query-char - pct-encoded = unreserved / sub-delims / ":" / "@" / "/" / "?"
+      # query-char = pchar / "/" / "?" = unreserved / pct-encoded / sub-delims / ":" / "@" / "/" / "?"
+      # unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
+      # sub-delims = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
+      # x-www-form-urlencoded-delimiters = "&" / "+" / ";" / "="
+      r << sep if !first
+      first = false
+      k.each_byte {|byte|
+        ch = byte.chr
+        if %r{[^0-9A-Za-z\-\._~:/?@!\$'()*,]}n =~ ch
+          r << "%" << ch.unpack("H2")[0].upcase
+        else
+          r << ch
+        end
+      }
+      r << '='
+      v.each_byte {|byte|
+        ch = byte.chr
+        if %r{[^0-9A-Za-z\-\._~:/?@!\$'()*,]}n =~ ch
+          r << "%" << ch.unpack("H2")[0].upcase
+        else
+          r << ch
+        end
+      }
+    }
+    PercentEncoded.new_no_dup(r)
+  end
+
+  class HTMLEscaped < StringWrapper
+  end
+
+  
+  HTML_TEXT_ESCAPE_HASH = {
+    '&' => '&amp;',
+    '<' => '&lt;',
+    '>' => '&gt;',
+  }
+  
+
+  # Escape.html_text escapes a string appropriate for HTML text using character references.
+  # It returns an instance of HTMLEscaped.
+  #
+  # It escapes 3 characters:
+  # * '&' to '&amp;'
+  # * '<' to '&lt;'
+  # * '>' to '&gt;'
+  #
+  #  Escape.html_text("abc") #=> #<Escape::HTMLEscaped: abc>
+  #  Escape.html_text("a & b < c > d") #=> #<Escape::HTMLEscaped: a &amp; b &lt; c &gt; d>
+  #
+  # This function is not appropriate for escaping HTML element attribute
+  # because quotes are not escaped.
+  def html_text(str)
+    s = str.gsub(/[&<>]/) {|ch| HTML_TEXT_ESCAPE_HASH[ch] }
+    HTMLEscaped.new_no_dup(s)
+  end
+
+  
+  HTML_ATTR_ESCAPE_HASH = {
+    '&' => '&amp;',
+    '<' => '&lt;',
+    '>' => '&gt;',
+    '"' => '&quot;',
+  }
+  
+
+  class HTMLAttrValue < StringWrapper
+  end
+
+  # Escape.html_attr_value encodes a string as a double-quoted HTML attribute using character references.
+  # It returns an instance of HTMLAttrValue.
+  #
+  #  Escape.html_attr_value("abc") #=> #<Escape::HTMLAttrValue: "abc">
+  #  Escape.html_attr_value("a&b") #=> #<Escape::HTMLAttrValue: "a&amp;b">
+  #  Escape.html_attr_value("ab&<>\"c") #=> #<Escape::HTMLAttrValue: "ab&amp;&lt;&gt;&quot;c">
+  #  Escape.html_attr_value("a'c") #=> #<Escape::HTMLAttrValue: "a'c">
+  #
+  # It escapes 4 characters:
+  # * '&' to '&amp;'
+  # * '<' to '&lt;'
+  # * '>' to '&gt;'
+  # * '"' to '&quot;'
+  #
+  def html_attr_value(str)
+    s = '"' + str.gsub(/[&<>"]/) {|ch| HTML_ATTR_ESCAPE_HASH[ch] } + '"'
+    HTMLAttrValue.new_no_dup(s)
+  end
+end

data/lib/rudy.rb

@@ -1,64 +1,123 @@
 
-#
-# 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 (md5 error)."
-  exit 1
+unless defined?(RUDY_HOME)
+  RUDY_HOME = File.join(File.dirname(__FILE__), '..') 
+  RUDY_LIB = File.join(File.dirname(__FILE__), '..', 'lib')
 end
 
 
-begin
-  require 'digest/md5'
-  require 'right_aws'
-  require 'stringio'
-  require 'ostruct'
-  require 'yaml'
-  require 'socket'
-  require 'tempfile'
-
-  require 'console'
-  require 'storable'
-
-  require 'net/ssh'
-  require 'net/ssh/gateway'
-  require 'net/ssh/multi'
-  require 'net/scp'
-  
-rescue LoadError => ex
-  puts "Problem requiring: #{ex.message}"
-  exit 1
-end
+require 'digest/md5'
+require 'stringio'
+require 'ostruct'
+require 'yaml'
+require 'socket'
+require 'timeout'
+require 'tempfile'
+
+require 'storable'
+require 'console'
+require 'sysinfo'
+require 'annoy'
+
+require 'rye'
 
+require 'net/ssh'
+require 'net/scp'
+require 'net/ssh/multi'
+require 'net/ssh/gateway'
 
 
-module Rudy #:nodoc:
-  RUDY_DOMAIN = "rudy_state"
-  RUDY_DELIM  = '-'
+
+# = Rudy
+#
+# == About
+#
+# Rudy is a development and deployment tool for the Amazon Elastic Compute Cloud
+# (EC2). There are two interfaces: a command-line executable and a Ruby library.
+# You can use Rudy as a development tool to simply the management of instances, 
+# security groups, etc... on an ad-hoc basic. You can also define complex machine 
+# environments using a simple domain specific language (DSL) and use Rudy to build
+# and deploy these environments. 
+#
+#
+# == Status: Alpha
+# 
+# The current release (0.5) is not ready for general production use. Use it for 
+# exploring EC2 and operating your development / ad-hoc instances. We've put in 
+# a lot of effort to make sure Rudy plays safe, but it's possible we missed
+# something. That's why we consider it alpha code. 
+#
+# To get started right away, try:
+#
+#     $ rudy -h
+#     $ rudy show-commands
+#
+# And if you're feeling particularly saucey, try Rudy's REPL interface:
+#
+#     $ ird
+# 
+# == Next Release (0.6): May 2009.
+#
+#     $ rudy slogan
+#     Rudy: Not your grandparent's deployment tool! 
+#
+#
+module Rudy
+  extend self
+  
+  unless defined?(RUDY_DOMAIN) # We can assume all constants are defined
+    # SimpleDB accepts dashes in the domain name on creation and with the query syntax. 
+    # However, with select syntax it says: "The specified query expression syntax is not valid"
+    RUDY_DOMAIN = "rudy_state".freeze
+    RUDY_DELIM  = '-'.freeze
   
-  RUDY_CONFIG_DIR = File.join(ENV['HOME'] || ENV['USERPROFILE'], '.rudy')
-  RUDY_CONFIG_FILE = File.join(RUDY_CONFIG_DIR, 'config')
+    RUDY_CONFIG_DIR = File.join(ENV['HOME'] || ENV['USERPROFILE'], '.rudy').freeze
+    RUDY_CONFIG_FILE = File.join(RUDY_CONFIG_DIR, 'config').freeze
   
-  DEFAULT_REGION = 'us-east-1'
-  DEFAULT_ZONE = 'us-east-1b'
-  DEFAULT_ENVIRONMENT = 'stage'
-  DEFAULT_ROLE = 'app'
-  DEFAULT_POSITION = '01'
+    DEFAULT_REGION = 'us-east-1'.freeze 
+    DEFAULT_ZONE = 'us-east-1b'.freeze 
+    DEFAULT_ENVIRONMENT = 'stage'.freeze
+    DEFAULT_ROLE = 'app'.freeze
+    DEFAULT_POSITION = '01'.freeze
+                                 
+    DEFAULT_USER = 'rudy'.freeze
   
-  DEFAULT_USER = 'rudy'
+    SUPPORTED_SCM_NAMES = [:svn, :git].freeze
   
-  SUPPORTED_SCM_NAMES = [:svn, :git]
+    ID_MAP = {
+      :instance => 'i',
+      :disk => 'disk',
+      :backup => 'back',
+      :volume => 'vol',
+      :snapshot => 'snap',
+      :kernel => 'aki',
+      :image => 'ami',
+      :ram => 'ari',
+      :log => 'log',
+      :key => 'key',
+      :pk => 'pk',
+      :cert => 'cert',
+      :reservation => 'r'
+    }.freeze
+    
+    @@sysinfo = SystemInfo.new.freeze
+  end
   
   module VERSION #:nodoc:
-    MAJOR = 0.freeze unless defined? MAJOR
-    MINOR = 4.freeze unless defined? MINOR
-    TINY  = 0.freeze unless defined? TINY
-    def self.to_s
-      [MAJOR, MINOR, TINY].join('.')
-    end
-    def self.to_f
-      self.to_s.to_f
+    unless defined?(MAJOR)
+      MAJOR = 0.freeze
+      MINOR = 5.freeze
+      TINY  = 0.freeze
     end
+    def self.to_s; [MAJOR, MINOR, TINY].join('.'); end
+    def self.to_f; self.to_s.to_f; end
   end
+
+  @@quiet = false
+  def Rudy.enable_quiet; @@quiet = true; end
+  def Rudy.disable_quiet; @@quiet = false; end
+    
+  def Rudy.sysinfo; @@sysinfo; end
+  def sysinfo; @@sysinfo;  end
   
   # Determine if we're running directly on EC2 or
   # "some other machine". We do this by checking if
@@ -66,21 +125,170 @@ module Rudy #:nodoc:
   # file is written by /etc/init.d/rudy-ec2-startup. 
   # NOTE: Is there a way to know definitively that this is EC2?
   # We could make a request to the metadata IP addresses. 
-  def self.in_situ?
+  def Rudy.in_situ?
     File.exists?('/etc/ec2/instance-id')
   end
+  
+  
+  # Wait for something to happen. 
+  # * +duration+ seconds to wait between tries (default: 2).
+  # * +max+ maximum time to wait (default: 120). Throws an exception when exceeded.
+  # * +logger+ IO object to print +dot+ to.
+  # * +dot+ the character to print after each attempt (default: .). 
+  # Set to nil or false to keep the waiter silent.
+  # The block must return false while waiting. Once it returns true
+  # the waiter will return true too.
+  def Rudy.waiter(duration=2, max=120, logger=STDOUT, dot='.', &check)
+    # TODO: Move to Drydock
+    raise "The waiter needs a block!" unless check
+    duration = 1 if duration < 1
+    max = duration*2 if max < duration
+    success = false
+    begin
+      success = Timeout::timeout(max) do
+        while !check.call
+          logger.print dot if dot && logger.respond_to?(:print)
+          logger.flush if logger.respond_to?(:flush)
+          sleep duration
+        end
+      end
+    rescue Timeout::Error => ex
+      retry if Annoy.pose_question(" Keep waiting?\a ", /yes|y|ya|sure|you bet!/i, logger)
+      raise ex # We won't get here unless the question fails
+    end
+    success
+  end
+  
+  # Make a terminal bell chime
+  def Rudy.bell(chimes=1, logger=nil)
+    return if @@quiet
+    chimed = chimes.to_i
+    logger.print "\a"*chimes if logger
+    true # be like Rudy.bug()
+  end
+  
+  # Have you seen that episode of The Cosby Show where Dizzy Gillespie... ah nevermind.
+  def Rudy.bug(bugid, logger=STDERR)
+    logger.puts "You have found a bug! If you want, you can email".color(:red)
+    logger.puts 'rudy@solutious.com'.color(:red).bright << " about it. It's bug ##{bugid}.".color(:red)          
+    logger.puts "Continuing...".color(:red)
+    true # so we can string it together like: bug('1') && next if ...
+  end
+
+  # Is the given string +str+ an ID of type +identifier+? 
+  # * +identifier+ is expected to be a key from ID_MAP
+  # * +str+ is a string you're investigating
+  def Rudy.is_id?(identifier, str)
+    return false unless identifier && str && Rudy.known_type?(identifier)
+    identifier &&= identifier.to_sym
+    str &&= str.to_s.strip
+    str.split('-').first == Rudy::ID_MAP[identifier].to_s
+  end
+  
+  # Returns the object type associated to +str+ or nil if unknown. 
+  # * +str+ is a string you're investigating
+  def Rudy.id_type(str)
+    return false unless str
+    str &&= str.to_s.strip
+    (Rudy::ID_MAP.detect { |n,v| v == str.split('-').first } || []).first
+  end
+  
+  # Is the given +key+ a known type of object?
+  def Rudy.known_type?(key)
+    return false unless key
+    key &&= key.to_s.to_sym
+    Rudy::ID_MAP.has_key?(key)
+  end
+  
+  # Returns the string identifier associated to this +key+
+  def Rudy.identifier(key)
+    key &&= key.to_sym
+    return unless Rudy::ID_MAP.has_key?(key)
+    Rudy::ID_MAP[key]
+  end
+  
+  # Return a string ID without the identifier. i.e. key-stage-app-root => stage-app-root
+  def Rudy.strip_identifier(str)
+    el = str.split('-')
+    el.shift
+    el.join('-')
+  end
+    
+  # +msg+ The message to return as a banner
+  # +size+ One of: :normal (default), :huge
+  # +colour+ a valid 
+  # Returns a string with styling applying
+  def Rudy.banner(msg, size = :normal, colour = :black)
+    return unless msg
+    banners = {
+      :huge => Rudy::Utils.without_indent(%Q(
+      =======================================================
+      =======================================================
+      !!!!!!!!!   %s   !!!!!!!!!
+      =======================================================
+      =======================================================)),
+      :normal => %Q(============  %s  ============)
+    }
+    size = :normal unless banners.has_key?(size)
+    colour = :black unless Console.valid_colour?(colour)
+    size, colour = size.to_sym, colour.to_sym
+    sprintf(banners[size], msg).colour(colour).bgcolour(:white).bright
+  end
+  
+  # Run a block and trap common, known errors. 
+  # * +default+ A default response value
+  # * +request+ A block which contains the AWS request
+  # Returns the return value from the request is returned untouched
+  # or the default value on error or if the request returned nil. 
+  def trap_known_errors(default=nil, &request)
+    raise "No block provided" unless request
+    response = nil
+    begin
+      response = request.call
+    rescue => ex
+      STDERR.puts ex.message
+    ensure
+      response ||= default
+    end
+    response
+  end
+  
+  
+  class NoConfig < RuntimeError
+    def message
+      "No AWS credentials. Check your configs!"
+    end
+  end
+  class NoMachineImage < RuntimeError
+    def initialize(group)
+      @group = group
+    end
+    def message
+      "There is no AMI configured for #{@group}"
+    end
+  end
 end
 
 require 'rudy/aws'
-require 'rudy/config'
-require 'rudy/metadata'
-require 'rudy/utils'
-require 'rudy/command/base'
+require 'rudy/utils'               # The
+require 'rudy/config'              # order
+require 'rudy/huxtable'            # of
+require 'rudy/command/addresses'   # require
+require 'rudy/command/keypairs'
+require 'rudy/command/instances'   # statements
+require 'rudy/command/manager'     # is
+require 'rudy/command/domains'
+require 'rudy/command/backups'     # important.
+require 'rudy/command/volumes'
+require 'rudy/command/groups'
+require 'rudy/command/disks'
+require 'rudy/routines'    
+
 
-# Require Command, MetaData, and SCM classes
+# Require MetaData, Routines, and SCM classes
 begin
   # TODO: Use autoload
-  Dir.glob(File.join(RUDY_LIB, 'rudy', '{command,metadata,scm}', "*.rb")).each do |path|
+  Dir.glob(File.join(RUDY_LIB, 'rudy', '{metadata,routines,scm}', "*.rb")).each do |path|
     require path
   end
 rescue LoadError => ex
@@ -89,68 +297,10 @@ rescue LoadError => ex
 end
 
 
-# Capture STDOUT or STDERR to prevent it from being printed. 
-#
-#    capture(:stdout) do
-#      ...
-#    end
-#
-def capture(stream)
-  #raise "We can only capture STDOUT or STDERR" unless stream == :stdout || stream == :stderr
-  
-  # I'm using this to trap the annoying right_aws "peer certificate" warning.
-  # TODO: discover source of annoying right_aws warning and give it a hiding.
-  begin
-    stream = stream.to_s
-    eval "$#{stream} = StringIO.new"
-    yield
-    result = eval("$#{stream}").read
-  ensure
-    eval("$#{stream} = #{stream.upcase}")
-  end
-
-  result
-end
-
 
-def write_to_file(filename, content, type)
-  type = (type == :append) ? 'a' : 'w'
-  f = File.open(filename,type)
-  f.puts content
-  f.close
-end
-
-def are_you_sure?(len=3)
-  if Drydock.debug?
-    puts 'DEBUG: skipping "are you sure" check'
-    return true 
-  end
-  
-  if STDIN.tty? # Only ask a question if there's a human 
-    challenge = strand len
-    STDOUT.print "Are you sure? To continue type \"#{challenge}\": "
-    STDOUT.flush
-    if ((STDIN.gets || "").gsub(/["']/, '') =~ /^#{challenge}$/)
-      true
-    else
-      puts "Nothing changed"
-      exit 0
-    end
-  else
-    true
-  end
-end
-    
-# 
-# Generates a string of random alphanumeric characters
-# These are used as IDs throughout the system
-def strand( len=8, safe=true )
-   chars = ("a".."z").to_a + ("0".."9").to_a
-   chars = [("a".."h").to_a, "j", "k", "m", "n", ("p".."z").to_a, ("2".."9").to_a].flatten if safe
-   newpass = ""
-   1.upto(len) { |i| newpass << chars[rand(chars.size-1)] }
-   newpass
-end
+# ---
+# TODO: Find a home for these poor guys:
+# +++
 
 def sh(command, chdir=false, verbose=false)
   prevdir = Dir.pwd
@@ -160,6 +310,7 @@ def sh(command, chdir=false, verbose=false)
   Dir.chdir prevdir if chdir
 end
 
+
 def ssh_command(host, keypair, user, command=false, printonly=false, verbose=false)
   #puts "CONNECTING TO #{host}..."
   cmd = "ssh -i #{keypair} #{user}@#{host} "
@@ -197,14 +348,3 @@ def scp_command(host, keypair, user, paths, to_path, to_local=false, verbose=fal
   printonly ? (puts cmd) : system(cmd)
 end
 
-
-# Returns +str+ with the average leading indentation removed. 
-# Useful for keeping inline codeblocks spaced with code. 
-def without_indent(str)
-  lines = str.split($/)
-  lspaces = (lines.inject(0) {|total,line| total += (line.scan(/^\s+/).first || '').size } / lines.size) + 1
-  lines.collect { |line| line.gsub(/^\s{#{lspaces}}/, '') }.join($/)
-end
-
-
-