solutious-rudy 0.4.0 → 0.5.0

data/bin/rudy

@@ -1,24 +1,32 @@
 #!/usr/bin/ruby
 
-# Rudy -- Your friend in staging and deploying to EC2
+# = Rudy
+# 
+# === Not your granparent's deployment tool
 #
 #   See rudy -h for usage
 # 
 
-RUDY_HOME = File.join(File.dirname(__FILE__), '..')
-RUDY_LIB = File.join(RUDY_HOME, 'lib')
-$:.unshift RUDY_LIB # Put our local lib in first place
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib') # Put our local lib in first place
 
-require 'rubygems' if RUBY_VERSION < "1.9"
+require 'rubygems' unless defined? Gem
 require 'date'
 require 'drydock'
+require 'rudy'
+require 'rudy/cli'
 extend Drydock
 
-project "Rudy"  # This also runs require 'ruby'
+# Is there a bug in Ruby 1.9 open-uri?
+#$ /usr/local/bin/ruby bin/rudy myaddress
+#/usr/local/lib/ruby/1.9.1/open-uri.rb:260:in `require': Insecure operation - require (SecurityError)
+#$SAFE = 2
+
+
 
 global :A, :accesskey, String, "AWS Access Key"
 global :S, :secretkey, String, "AWS Secret Access Key"
 #global :R, :region, String, "Connect to a specific EC2 region (ie: #{Rudy::DEFAULT_REGION})"
+global :n, :nocolor, "Disable output colors"
 global :f, :config, String, "Specify another configuration file to read (ie: #{Rudy::RUDY_CONFIG_FILE})"
 global :z, :zone, String, "Connect to a specific EC2 zone (ie: #{Rudy::DEFAULT_ZONE})"
 global :e, :environment, String, "Connect to the specified environment (ie: #{Rudy::DEFAULT_ENVIRONMENT})"
@@ -35,23 +43,141 @@ global :V, :version, "Display version number" do
   exit 0
 end
 
-#desc "Run this the first time you use Rudy (it's immutable so running it again does no harm)."
-#command :setup => Rudy::Command::Metadata
+
+# ---------------------------------  RUDY MACHINE COMMANDS  --------
+# ------------------------------------------------------------------
 
 
-# ------------------------------------  RUDY INFO COMMANDS  --------
+desc "Machine Status"
+usage "rudy [global options] status [-g group-name] [-s state] [--all] [instance-ID]"
+option :g, :group, String, "A security group name"
+option :s, :state, String, "Machine state. One of: running (default), pending, terminated"
+option :l, :all, "Show all machines in this group, regardless of state."
+argv :awsid
+command :status => Rudy::CLI::Instances
+
+usage "rudy [global options] connect [-g group-name] [-i instance-ID] [cmd]"
+desc "Open an SSH connection"
+option :print, "Only print the SSH command, don't connect"
+option :g, :group, String, "A security group name"
+option :i, :awsid, String, "An instance ID"
+argv :cmd
+command :connect => Rudy::CLI::Instances 
+command_alias :connect, :ssh
+
+usage "rudy [global options] copy [-p] [-r] source target"
+desc "Copy files to or from machines. NOTE: You must use quotes when using a tilda for your remote dir ('~/')."
+option :r, :recursive, "Recursively copy entire directories"
+option :p, :preserve, "Preserve atimes and ctimes."
+option :d, :download, "Download FROM the remote machine to the local machine"
+option :print, "Only print the SSH command, don't connect"
+option :g, :group, String, "A security group name"
+option :i, :awsid, String, "An instance ID"
+command :copy => Rudy::CLI::Instances
+command_alias :copy, :scp
+command_alias :copy, :upload
+command_alias :copy, :download
+
+
+
+# -----------------------------------  AMAZON EC2 COMMANDS  --------
 # ------------------------------------------------------------------
 
-#usage "rudy info"
-#desc "Displays info about the current Rudy configuration"
-#command :info => Rudy::Command::Metadata
+usage "rudy [global options] addresses [-A address instance ID]"
+desc "Manage Amazon Elastic IP addresses"
+argv :ipaddress, :instid
+action :A, :associate, "Associate an IP address to a running instance"
+action :C, :create, "Create an IP address"
+action :D, :destroy, "Destroy an IP address"
+command :addresses => Rudy::CLI::Addresses
+command_alias :addresses, :address
+
+usage "rudy [global options] groups [-C -R -A] [-a IP addresses] [-p ports] [group name]"
+usage "rudy groups -C               (create a group)"
+usage "rudy -e prod groups          (list groups in the prod environment)"
+usage "rudy groups -A -p 81,82,83   (open ports to a group from this machine)"
+desc "Manage EC2 Security Groups"
+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 port ranges in the form FROM:TO (default: 22,80,443)"
+option :a, :addresses, Array, "List of comma-separated IP addresses (default: your current external IP)"
+option :g, :group, String, "A group name to authorize or revoke network rule. Must also supply -o!"
+option :o, :owner, String, "A group owner ID (account number). Must also supply -g!"
+action :C, :create, "Create a security group"
+action :D, :destroy, "Destroy a security group"
+action :A, :authorize, "Authorize a rule for a security group"
+action :R, :revoke, "Revoke a rule for a security group"
+argv :name
+command :group => Rudy::CLI::Groups
+command_alias :group, :groups
+
+desc "Manage EC2 Volumes"
+usage "rudy volumes"
+usage "rudy volume -C -s size [-d device-path]"
+usage "rudy volume -A volume-id instance-id"
+usage "rudy volume -N volume-id"
+usage "rudy volume -D volume-id"
+option :s, :size, String, "Size (in GB)"
+option :d, :device, String, "Device path (default: /dev/sdh)"
+action :D, :destroy, "Destroy a volume"
+action :C, :create, "Create a volume"
+action :A, :attach, "Attach a volume to a running instance"
+action :N, :detach, "Detach a volume from an instance"
+argv :volid, :insid
+command :volume => Rudy::CLI::Volumes
+command_alias :volume, :volumes
+
+desc "Manage KeyPairs"
+usage "rudy keypairs [-C] [-D] [name]"
+action :D, :destroy, "Destroy KeyPair"
+action :C, :create, "Create KeyPair"
+argv :kpname
+command :keypair => Rudy::CLI::KeyPairs
+command_alias :keypair, :keypairs
+
+usage "rudy console [-g group] [instance ID]"
+desc "Displays system console output for given instance(s)"
+option :g, :group, String, "A group name to authorize or revoke network rule. Must also supply -o!"
+argv :awsid
+command :console => Rudy::CLI::Instances
+
+desc "Manage Machines"
+usage "rudy [global options] machines [-g group-name] [-s state] [instance-ID]"
+option :g, :group, String, "The security group name"
+option :i, :ami, String, "The machine image ID (ami-)"
+option :t, :itype, String, "The instance type (default: m1.small)"
+option :k, :keypair, String, "The SSH keypair to use for launch"
+option :a, :address, String, "The IP address to associate"
+action :C, :create, "Create a machine instance"
+action :D, :destroy, "Destroy a machine instance"
+argv :awsid
+command :instance => Rudy::CLI::Instances
+command_alias :instance, :instances
+
+#usage "rudy images [-C -i name [-b bucket -a account]] [-D AMI-ID]"
+#desc "Manage EC2 Machine Images (AMIs)"
+#option :a, :account, String, "Your Amazon Account Number"
+#option :i, :image_name, String, "The name of the image"     # TODO: change to --ami
+#option :p, :print, "Print-only (don't execute commands)"
+#option :b, :bucket_name, String, "The name of the bucket that will store the image"
+#action :C, :create, "Create an image"
+##action :P, :prepare, "Prepare a running instance to be used as an image"
+#action :D, :destroy, "Deregister an image (currently _does not_ remove images files from S3)"
+#argv :ami
+#command :images => Rudy::CLI::Images
+#command_alias :images, :image
+
+
+# --------------------------------  MISCELLANEOUS COMMANDS  --------
+# ------------------------------------------------------------------
 
 usage "rudy [-f config-file] config [param-name]"
 desc "Check Rudy configuration."
-option :l, :all, "Display config settings for all machines"
+option :l, :all, "Display configs for all machines"
 option :d, :defaults, "Display the default value for the supplied parameter"
+option :g, :group, String, "Display configuration for a specific group"
 argv :name
-command :config => Rudy::Command::Config
+command :config => Rudy::CLI::Config
 
 usage "rudy myaddress [-i] [-e]"
 desc "Displays you current internal and external IP addresses"
@@ -69,107 +195,175 @@ command :myaddress do |obj|
   end
 end
 
+usage "rudy [global options] annoy [-h -m -l] [-e]"
+desc "Play around with Rudy's annoying challenges"
+option :s, :string, "A numeric challenge"
+option :n, :numeric, "A numeric challenge"
+option :i, :insane, "Insane annoyance factor"
+option :h, :high, "High annoyance factor"
+option :m, :medium, "Medium annoyance factor"
+option :l, :low, "Low annoyance factor"
+option :r, :rand, "Random challenge type"
+command :annoy do |obj|
+  srand(Time.now.to_f)
+  flavor = [:numeric, :string, :rand].detect { |v| obj.option.send(v) } || :string
+  factor = [:insane, :high, :medium, :low].detect { |v| obj.option.send(v) } || :medium
+  success = Annoy.challenge?("Is this annoying?", factor, flavor)
+  puts (success ? "Correct!" : "WRONG!").bright
+end
 
+desc "Display the current Rudy slogan"
+command :slogan do
+  puts "Rudy: Not your grandparent's deployment tool!"
+end
 
-# -----------------------------  RUDY MAINTENANCE COMMANDS  --------
-# ------------------------------------------------------------------
-
-usage "#{$/} [global options] disks [-C -p path -d device -s size] [-A] [-D] [disk name]"
-desc "Manage Disks"
-option :l, :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)"
-action :C, :create, "Create a disk definition"
-action :D, :destroy, "Destroy a disk definition"
-action :A, :attach, "Attach a disk"
-action :N, :unattach, "Unattach a disk"
-argv :diskname
-command :disk => Rudy::Command::Disks
-
-
-usage "rudy [global options] backups [-C] [disk name]"
-desc "Manage Backups"
-option :s, :snapshot, String, "Create a backup entry from an existing snapshot"
-action :Z, :sync, "Check for and delete backup metadata with no snapshot. DOES NOT delete snapshots."
-#action :T, :tidy, "Tidy existing backups"
-action :D, :destroy, "Destroy a backup and DELETE its snapshots."
-action :C, :create, "Create a backup"
-argv :disk
-command :'backup' => Rudy::Command::Backups
-command_alias :backup, :bu
-
-
-usage "rudy [global options] metadata instance-ID"
-desc "Display Rudy metadata."
-command :metadata => Rudy::Command::Metadata
-command_alias :metadata, :md
-
+desc "Generates a configuration template to #{Rudy::RUDY_CONFIG_FILE}"
+command :generate_config do |obj|
+  unless File.exists?(Rudy::RUDY_CONFIG_FILE)
+    Rudy::Config.init_config_dir
+    puts "Add your AWS credentials to #{Rudy::RUDY_CONFIG_FILE}"
+  else
+    puts "#{Rudy::RUDY_CONFIG_FILE} already exists"
+  end
+end
 
-desc "Machine Group Status"
-command :status => Rudy::Command::Machines
 
+desc "Initialize Rudy configuration"
+command :init do |obj|
+  
+  unless File.exists?(Rudy::RUDY_CONFIG_FILE)
+    Rudy::Config.init_config_dir
+  end
+  
+  begin
+    rdom = Rudy::Domains.new(:global => obj.global)
+  
+    unless rdom.exists?
+      puts "Creating SimpleDB domain #{rdom.name}"
+      rdom.create
+      puts "Initialized"
+    else
+      puts "Already Initialized"
+    end
+    
+    
+    exit 0 # a quick hack to not print elapsed time
+    
+  rescue Rudy::NoConfig => ex
+    puts "AWS credentials must be configured to continue."
+    puts "You can modify these in #{Rudy::RUDY_CONFIG_FILE}"
+    exit 1
+  end
+  
 
-desc "Update a Machine Group with the current version of Rudy"
-command :update => Rudy::Command::Machines
+  
+end
 
+desc "Displays the SimpleDB domains associated to your account"
+command :domains => Rudy::CLI::Domains
 
-usage "rudy [-e env] [-u user] connect [-p] [cmd]"
-desc "Open an SSH connection"
-option :p, :print, "Only print the SSH command, don't connect"
-argv :cmd
-command :connect => Rudy::Command::Environment 
-command_alias :connect, :ssh
 
-usage "rudy [-e env] [-u user] copy [-p] -r [from path] [to path]"
-desc "Copy files to or from machines. NOTE: You must use quotes when using a tilda for your remote dir ('~/')."
-option :r, :remote, "Copy FROM the remote machine to the local machine"
-option :p, :print, "Only print the SSH command, don't connect"
-argv :from, :to
-command :copy => Rudy::Command::Environment
-command_alias :copy, :scp
-command_alias :copy, :upload
-command_alias :copy, :download
-
-
-# --------------------------------  RUDY ROUTINES COMMANDS  --------
+# ---------------------------------  RUDY MANAGER COMMANDS  --------
 # ------------------------------------------------------------------
 
-desc "Shutdown a Machine Group"
-command :shutdown => Rudy::Command::Machines
-
-desc "Start a Machine Group"
-option :i, :image, String, "EC2 image ID (AMI)"
-command :startup => Rudy::Command::Machines
-command_alias :startup, :start
-
-desc "Restart a Machine Group"
-command :restart => Rudy::Command::Machines
+#usage "rudy init"
+#desc "Run this the first time you use Rudy (it's immutable so running it again does no harm)."
+#command :create_domain => Rudy::CLI::Manager
+#
+#usage "rudy info"
+#desc "Displays info about the current Rudy configuration"
+#command :info => Rudy::CLI::Manager
+
+#desc "Update a Machine Group with the current version of Rudy"
+#option :g, :group, String, "A security group name"
+#command :update => Rudy::CLI::Manager
+
+
+#usage "#{$/} [global options] disks [-C -p path -d device -s size] [-A] [-D] [path]"
+#desc "Manage Disks"
+#option :l, :all, "Display all disk definitions"
+#option :i, :awsid, String, "EC2 Instance ID"
+#option :g, :group, String, "Machine group name"
+#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)"
+#action :C, :create, "Create a disk definition"
+#action :D, :destroy, "Destroy a disk definition"
+#action :A, :attach, "Attach a disk"
+#action :N, :unattach, "Unattach a disk"
+#argv :diskname
+#command :disk => Rudy::CLI::Disks
+#command_alias :disk, :disks
+
+
+#usage "rudy [global options] backups [-C] [disk name]"
+#desc "Manage Backups"
+#option :s, :snapshot, String, "Create a backup entry from an existing snapshot"
+#action :Z, :sync, "Check for and delete backup metadata with no snapshot. DOES NOT delete snapshots."
+##action :T, :tidy, "Tidy existing backups"
+#action :D, :destroy, "Destroy a backup and DELETE its snapshots."
+#action :C, :create, "Create a backup"
+#argv :disk
+#command :'backup' => Rudy::CLI::Backups
+#command_alias :backup, :bu
+
+#usage "rudy [global options] metadata instance-ID"
+#desc "Display Rudy metadata."
+#command :metadata => Rudy::CLI::Manager
+#command_alias :metadata, :md
+
+
+# --------------------------  RUDY RELEASE/DEPLOY COMMANDS  --------
+# ------------------------------------------------------------------
 
-desc "Release to a machine group"
-option :s, :switch, "Switch to the release branch/tag"
-option :m, :msg, String, "A short release note"
-command :release => Rudy::Command::Release
+#desc "Release to a Machine Group"
+#option :g, :group, String, "A security group name"
+#option :s, :switch, "Switch to the release branch/tag"
+#option :m, :msg, String, "A short release note"
+#command :release => Rudy::CLI::Release
 
-desc "Update the release currently running in a machine group"
-command :rerelease => Rudy::Command::Release
-command_alias :rerelease, :rere
+#desc "Update the release currently running in a machine group"
+#command :rerelease => Rudy::CLI::Release
+#command_alias :rerelease, :rere
 
 #desc "Deploy disk snapshots from one machine to another"
-#command :deploy => Rudy::Command::Deploy
+#command :deploy => Rudy::CLI::Deploy
 
 
+#desc "Shutdown a Machine Group"
+#usage "rudy [global options] shutdown [-g group-name] [instance-ID]"
+#option :g, :group, String, "A security group name"
+#argv :awsid
+#command :shutdown => Rudy::CLI::Routines
+#
+#
+#desc "Start a Machine Group"
+#usage "rudy [global options] startup [-g group-name] [-i image-ID]"
+#option :ami, String, "EC2 image ID (AMI)"
+#option :g, :group, String, "A security group name"
+#command :startup => Rudy::CLI::Routines
+#command_alias :startup, :start
+
+#desc "Restart a Machine Group"
+#option :g, :group, String, "A security group name"
+#argv :awsid
+#command :restart => Rudy::CLI::Routines
+#
+
 
 
 # -------------------------------------------  UGLY STUFFS  --------
 # ------------------------------------------------------------------
-debug :on
-capture :stderr       
+debug :off
+default :status
+#capture :stderr       
 before do
   @start = Time.now
 end
-after do
-  @elapsed = Time.now - @start
-  puts $/, "Elapsed: %.2f seconds" % @elapsed.to_f if @elapsed > 0.1
+after do |obj|
+  unless obj.global.quiet
+    @elapsed = Time.now - @start
+    puts $/, "Elapsed: %.2f seconds" % @elapsed.to_f if @elapsed > 0.1
+  end
 end
 

data/lib/annoy.rb

@@ -0,0 +1,227 @@
+
+require 'timeout'
+require 'sysinfo'
+
+
+# Annoy - your annoying friend that asks you questions all the time.
+#
+# TODO: Use Matrix to give a more accurate annoyance factor
+# TODO: Add trivia questions
+#
+class Annoy #:nodoc:all
+  
+  attr_accessor :factor
+  attr_accessor :flavor
+  attr_accessor :answer
+  attr_accessor :writer
+  attr_accessor :period
+  attr_accessor :system
+  
+  @@operators = {
+    :low      => %w(+ - *),
+    :medium   => %w(* % + -),
+    :high     => %w(* % + -),
+    :insane   => %w(** << | & *)
+  }.freeze
+  
+  @@strlen = {
+    :low      => 2,
+    :medium   => 3,
+    :high     => 4,
+    :insane   => 32
+  }.freeze
+  
+  @@randsize = {
+    :low      => 10,
+    :medium   => 100,
+    :high     => 1000,
+    :insane   => 1000
+  }.freeze
+  
+  @@period = 60.freeze    # max seconds to wait
+  
+  @@flavors = [:numeric, :string].freeze
+  
+  
+  # * +factor+ annoyance factor, one of :low (default), :medium, :high, :insane
+  # * +flavor+ annoyance flavor, one of :rand (default), :numeric, string
+  # * +writer+ an IO object to write to. Default: STDERR
+  # * +period+ the amount of time to wait in seconds. Default: 60
+  def initialize(opts={:factor=>:medium, :flavor=>:rand, :writer=>STDOUT, :period=>nil})
+    @factor = opts[:factor]
+    @flavor = Annoy.get_flavor(opts[:flavor])
+    @writer = opts[:writer]
+    @period = opts[:period] || @@period
+    unless Annoy.respond_to?("#{@flavor}_question")
+      raise "Hey, hey, hey. I don't know that flavor! (#{@flavor})" 
+    end
+  end
+  
+  # Generates and returns a question. The correct response is available
+  # as +@answer+.
+  def question
+    q, @answer =Annoy.question(@factor, @flavor)
+    q
+  end
+  
+  # A wrapper for string_question and numberic_question
+  def Annoy.question(factor=:medium, flavor=:rand)
+    raise "Come on, you ruined the flavor!" unless flavor
+    Annoy.send("#{flavor}_question", factor)
+  end
+  
+  # Generates a random string
+  def Annoy.string_question(factor=:medium)
+    # Strings don't need to be evaluated so the answer is the
+    # same as the question.
+    str = strand @@strlen[factor]
+    [str,str]
+  end
+  
+  # * Generates a rudimentary numeric equation in the form: (Integer OPERATOR Integer).
+  # * Returns [equation, answer]
+  def Annoy.numeric_question(factor=:medium)
+    equation = answer = 0
+    while answer < 10
+      vals = [rand(@@randsize[factor])+1, 
+              @@operators[factor][ rand(@@operators[factor].size) ],
+              rand(@@randsize[factor])+1 ]
+      equation = "(%d %s %d)" % vals
+      answer = eval(equation)
+    end
+    [equation, answer]
+  end
+  
+  # Prints a question to @writer and waits for a response on STDIN. 
+  # It checks whether STDIN is connected a tty so it doesn't block on gets.
+  # when there's no human around to annoy. It will return <b>TRUE</b> when
+  # STDIN is NOT connected to a tty.
+  # * +msg+ The message to print. Default: "Please confirm."
+  # Returns true when the answer is correct, otherwise false.
+  def Annoy.challenge?(msg="Please confirm.", factor=:medium, flavor=:rand, writer=STDOUT, period=nil)
+    return true unless STDIN.tty? # Humans only!
+    begin
+      success = Timeout::timeout(period || @@period) do
+        flavor = Annoy.get_flavor(flavor)
+        question, answer = Annoy.question(factor, flavor)
+        writer.print "#{msg} To continue, #{Annoy.verb(flavor)} #{question}: "
+        writer.print "(#{answer}) " if ![:high, :insane].member?(factor) && flavor == :numeric
+        writer.flush
+        response = Annoy.get_response(writer)
+        response = response.to_i if flavor == :numeric
+        (response == answer)
+      end
+    rescue Timeout::Error => ex
+      writer.puts $/, "Times up!"
+      false
+    end
+  end
+  
+  # Runs a challenge with the message, "Are you sure?"
+  # See: Annoy.challenge?
+  def Annoy.are_you_sure?(factor=:medium, flavor=:rand, writer=STDOUT)
+    Annoy.challenge?("Are you sure?", factor, flavor, writer)
+  end
+  
+  # See: Annoy.challenge?
+  # Uses the value of @flavor, @factor, and @writer
+  def challenge?(msg="Please confirm.")
+    Annoy.challenge?(msg, @factor, @flavor, @writer)
+  end
+  
+  # See: Annoy.pose_question
+  # Uses the value of @writer
+  def pose_question(msg, regexp)
+    Annoy.pose_question(msg, regexp, @writer)
+  end
+  
+  # Prints a question to writer and waits for a response on STDIN. 
+  # It checks whether STDIN is connected a tty so it doesn't block on gets.
+  # when there's no human around to annoy. It will return <b>TRUE</b> when
+  # STDIN is NOT connected to a tty.
+  # * +msg+ The question to pose to the user
+  # * +regexp+ The regular expression to match the answer. 
+  def Annoy.pose_question(msg, regexp, writer=STDOUT, period=nil)
+    return true unless STDIN.tty? # Only ask a question if there's a human
+    begin
+      success = Timeout::timeout(period || @@period) do
+        regexp &&= Regexp.new regexp
+        writer.print msg 
+        writer.flush if writer.respond_to?(:flush)
+        response = Annoy.get_response
+        regexp.match(response)
+      end
+    rescue Timeout::Error => ex
+      writer.puts $/, "Times up!"
+      false
+    end
+  end
+ 
+  
+ private 
+  def Annoy.get_response(writer=STDOUT)
+    return true unless STDIN.tty? # Humans only
+    # TODO: Count the number of keystrokes to prevent copy/paste
+    # We likely need to be more specific but this will do for now.
+    #if ::SystemInfo.new.os == :unix 
+    #  begin
+    #    response = []
+    #    char = nil
+    #    system("stty raw -echo") # Raw mode, no echo
+    #    while char != "\r" || response.size > 5
+    #      char = STDIN.getc.chr
+    #      writer.print char
+    #      writer.flush
+    #      response << char
+    #    end
+    #    writer.print "\n\r"
+    #    response = response.join('')
+    #  rescue => ex
+    #  ensure
+    #    system("stty -raw echo") # Reset terminal mode
+    #  end
+    #else
+      response = (STDIN.gets || "")
+    #end
+    response.chomp.gsub(/["']/, '')
+  end
+  # Returns a verb appropriate to the flavor.
+  # * :numeric => resolve
+  # * :string => type
+  def Annoy.verb(flavor)
+    case flavor
+    when :numeric then "resolve"
+    when :string then "type"
+    else
+      nil
+    end
+  end
+ 
+  # 
+  # Generates a string of random alphanumeric characters.
+  # * +len+ is the length, an Integer. Default: 8
+  # * +safe+ in safe-mode, ambiguous characters are removed (default: true):
+  #       i l o 1 0
+  def Annoy.strand( len=8, safe=true )
+     chars = ("a".."z").to_a + ("0".."9").to_a
+     chars.delete_if { |v| %w(i l o 1 0).member?(v) } if safe
+     str = ""
+     1.upto(len) { |i| str << chars[rand(chars.size-1)] }
+     str
+  end
+  
+  # * +f+ a prospective flavor name
+  def Annoy.get_flavor(f)
+    f.to_sym == :rand ? flavor_rand : f.to_sym
+  end
+  
+  # Return a random flavor
+  def Annoy.flavor_rand
+    @@flavors[rand(@@flavors.size)]
+  end
+
+  
+end
+
+
+