rudy 0.3.2 → 0.4.0

data/bin/rudy-ec2

@@ -0,0 +1,107 @@
+#!/usr/bin/ruby
+
+# Rudy -- Your friend in staging and deploying to EC2
+#
+#   See rudy -h for usage
+# 
+
+#
+# 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
+else
+ require 'rubygems'
+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 'drydock'
+extend Drydock
+
+project "Rudy"  # This also runs require 'ruby'
+
+debug :on
+
+capture :stderr       
+
+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 (default: #{Rudy::DEFAULT_REGION})"
+global :z, :zone, String, "Connect to a specific EC2 zone (default: #{Rudy::DEFAULT_ZONE})"
+global :q, :quiet, "Run with less output"
+global :v, :verbose, "Increase verbosity of output (i.e. -v or -vv or -vvv)" do
+  @verbose ||= 0
+  @verbose += 1
+end
+global :V, :version, "Display version number" do
+  puts "Rudy version: #{Rudy::VERSION}"
+  exit 0
+end
+
+
+
+
+
+# -----------------------------------  AMAZON EC2 COMMANDS  --------
+# ------------------------------------------------------------------
+
+usage "rudy [global options] addresses [-A address instance ID]"
+desc "Manage Amazon Elastic IP addresses"
+argv :address, :instanceid
+action :A, :associate, "Associate an address to a running instance"
+command :addresses => Rudy::Command::Addresses
+command_alias :addresses, :address
+
+
+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"
+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::Command::Images
+command_alias :images, :image
+
+
+desc "Manage EC2 Volumes"
+action :D, :destroy, "Destroy a volume"
+argv :vol
+command :volumes => Rudy::Command::Volumes
+command_alias :volumes, :volume
+
+
+usage "rudy [global options] instances [-D] [-S -i image ID] [instance ID OR group name]"
+desc "Manage EC2 Instances"
+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"
+action :D, :destroy, "Destroy the given instance IDs. All data will be lost!"
+#action :S, :start, "Start an instance"
+#action :R, :restart, "Restart an instance"
+argv :filter
+command :instances => Rudy::Command::Instances
+command_alias :instances, :instance
+
+
+usage "rudy [global options] groups [-C] [-a IP addresses] [-p ports] [group name]"
+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 ports to authorize (default: 22,80,443)"
+option :a, :addresses, Array, "List of comma-separated IP addresses to authorize (default: your external IP)"
+action :C, :create, "Create a security group"
+action :D, :destroy, "Destroy a security group"
+action :M, :modify, "Modify a security group"
+argv :group
+command :groups => Rudy::Command::Groups
+command_alias :groups, :group
+
+
+

data/lib/console.rb

@@ -1,341 +1,385 @@
-
+#---
 # Adapted from: http://github.com/oneup/ruby-console/tree/tput
+# See: http://tldp.org/HOWTO/Bash-Prompt-HOWTO/x405.html
+# See: man terminfo
+#+++
 
-if __FILE__ == $0
-  puts "This is a module, don't run it from the command line."
-  exit
-end
 
 class String
-  def color(*arg)                         # colorize a string
-    Console.color(arg) +
+  
+  # +col+, +bgcol+, and +attribute+ are symbols corresponding
+  # to Console::COLOURS, Console::BGCOLOURS, and Console::ATTRIBUTES.
+  # Returns the string in the format attributes + string + defaults.
+  #
+  #     "MONKEY_JUNK".colour(:blue, :white, :blink)  # => "\e[34;47;5mMONKEY_JUNK\e[39;49;0m"
+  #
+  def colour(col, bgcol = nil, attribute = nil)
+    Console.style(col, bgcol, attribute) +
     self +
-    Console.color(:default)
+    Console.style(:default, :default, :default)
   end
-  def printAt(*arg)
-    row = 0
-    col = 0
-    if not arg.is_a?(Array)
-      arg = [arg]
-    end
-    if arg.length > 0
-      row = arg[0]
-    end
-    if arg.length > 1
-      col = arg[1]
-    end
-    Cursor.save
-    Cursor.position = row, col
-    print self
-    Cursor.restore
+  alias :color :colour
+  
+  # See colour
+  def bgcolour(bgcol = :default)
+    Console.style(nil, bgcol, nil) +
+    self +
+    Console.style(nil, :default, nil)
   end
-end
-
-class Console
-  def self.clear
-    system "tput clear"
+  alias :bgcolor :bgcolour
+  
+  # See colour
+  def att(a = :default)
+    Console.style(nil, nil, a) +
+    self +
+    Console.style(nil, nil, :default)
   end
-
-  def self.reset
-    system "tput reset"
+  
+  
+  # Print the string at +x+ +y+. When +minus+ is any true value
+  # the length of the string is subtracted from the value of x
+  # before printing. 
+  def print_at(x=nil, y=nil, minus=false)
+    args = {:minus=>minus}
+    args[:x] &&= x
+    args[:y] &&= y
+    Console.print_at(self, args)
   end
   
-  def self.color(*arg)                         # colorize a string
-    if arg[0].is_a?(Array)
-      arg = arg[0]
-    end
-    if arg.length == 0
-      arg = :default, :red, :bg_default
-    end
-    attribute = {         # mapper for the attributes
-      :normal     => 0,
-      :bright     => 1,
-      :dim        => 2,
-      :underscore => 4,
-      :blink      => 5,
-      :reverse    => 7,
-      :hidden     => 8,
-      :default    => 0
-    }
-    fg_color = {          # mapper for the foreground color
-      :black   => 30,
-      :red     => 31,
-      :green   => 32,
-      :yellow  => 33,
-      :blue    => 34,
-      :magenta => 35,
-      :cyan    => 36,
-      :white   => 37,
-      :default => 39
-    }
-    bg_color = {          # mapper for the background color
-      :bg_black   => 40,
-      :bg_red     => 41,
-      :bg_green   => 42,
-      :bg_yellow  => 43,
-      :bg_blue    => 44,
-      :bg_magenta => 45,
-      :bg_cyan    => 46,
-      :bg_white   => 47,
-      :bg_default => 49
-    }
-    if arg.length > 0                 # turn symbols into numbers
-      arg[0] = attribute[arg[0]]      # attributes
-    end
-    if arg.length > 1
-      arg[1] = fg_color[arg[1]]       # foreground color
-    end
-    if arg.length > 2
-      arg[2] = bg_color[arg[2]]       # background color
-    end
-    "\e[#{arg.join(";")}m"   # magic ansi escape sequence
+  # Returns the string with escape code attributes removed.
+  # NOTE: The non-printable attributes count towards the string size. 
+  # You can use this method to get the "visible" size:
+  #
+  #     "\e[34;47;5mMONKEY_JUNK\e[39;49;0m".noatt.size      # => 11
+  #     "\e[34;47;5mMONKEY_JUNK\e[39;49;0m".size            # => 31
+  #
+  def noatt
+    gsub(/\e\[[\d;]*m/, '')
   end
+end
 
-  def self.color=(arg)
-    if not arg.is_a?(Array)
-      arg = [arg]
-    end
-    if arg.length == 0
-      arg = :default, :red, :bg_default
-    end
-    print self.color(arg)
-  end
+class Object
 
-  def self.width
-    `tput cols`.chomp.to_i
+  # Executes tput +capnam+ with +args+. Returns true if tcap gives
+  # 0 exit status and false otherwise. 
+  # 
+  #     tput :cup, 1, 4
+  #     $ tput cup 1 4
+  #
+  def tput(capnam, *args)
+    system("tput #{capnam} #{args.flatten.join(' ')}")
   end
-
-  def self.height
-    `tput lines`.chomp.to_i
+  
+  # Executes tput +capnam+ with +args+. Returns the output of tput.
+  # 
+  #     tput_val :cols  # => 16
+  #     $ tput cols     # => 16
+  #
+  def tput_val(capnam, *args)
+    `tput #{capnam} #{args.flatten.join(' ')}`.chomp
   end
 end
 
-class Cursor
-  def self.position
-    row = ""
-    col = ""
-    c = ""
-
-    termsettings = `stty -g`
-    system("stty raw -echo")
-    print "\e[6n"
-    while (c = STDIN.getc.chr) != ";"
-      if c == "\e" or c == "["
-        next
-      else
-        row += c
-      end
-    end
-    while (c = STDIN.getc.chr) != "R"
-      col += c
-    end
-    system("stty #{termsettings}")
-
-    [row, col]
-  end
 
-  def self.position=(arg)
-    row = 0
-    col = 0
-    if not arg.is_a?(Array)
-      arg = [arg]
-    end
-    if arg.length > 0
-      row = arg[0]
-    end
-    if arg.length > 1
-      col = arg[1]
-    end
-    system "tput cup #{row} #{col}"
-  end
 
-  def self.up(*arg)
-    if arg.length == 0
-      arg[0] == 1
+module Console
+  extend self
+  require 'timeout'
+  require 'thread'
+  
+  # ANSI escape sequence numbers for text attributes
+  ATTRIBUTES = {
+    :normal     => 0,
+    :bright     => 1,
+    :dim        => 2,
+    :underline  => 4,
+    :blink      => 5,
+    :reverse    => 7,
+    :hidden     => 8,
+    :default    => 0,
+  }.freeze unless defined? ATTRIBUTES
+  
+  # ANSI escape sequence numbers for text colours
+  COLOURS = {
+    :black   => 30,
+    :red     => 31,
+    :green   => 32,
+    :yellow  => 33,
+    :blue    => 34,
+    :magenta => 35,
+    :cyan    => 36,
+    :white   => 37,
+    :default => 39,
+    :random  => 30 + rand(10).to_i
+  }.freeze unless defined? COLOURS
+  
+  # ANSI escape sequence numbers for background colours
+  BGCOLOURS = {
+    :black   => 40,
+    :red     => 41,
+    :green   => 42,
+    :yellow  => 43,
+    :blue    => 44,
+    :magenta => 45,
+    :cyan    => 46,
+    :white   => 47,
+    :default => 49,
+    :random  => 40 + rand(10).to_i
+  }.freeze unless defined? BGCOLOURS
+  
+  
+  def print_left(str, props={})
+    props[:x] ||= 0
+    props[:y] ||= Cursor.y
+#    print_at("x:#{props[:x]} y:#{props[:y]}", {:x => 0, :y => 10})
+    print_at(str, props)
+  end
+  def print_right(str, props={})
+    props[:x] ||= width
+    props[:y] ||= Cursor.y
+    props[:minus] = true unless props.has_key?(:minus)
+    print_at(str, props)  
+  end
+  def print_spaced(*args)
+    props = (args.last.is_a? Hash) ? args.pop : {}
+    props[:y] = Cursor.y
+    chunk_width = (width / args.flatten.size).to_i
+    chunk_at = 0
+    args.each do |chunk|
+      props[:x] = chunk_at
+      print_at(chunk.to_s[0, chunk_width], props)
+      chunk_at += chunk_width
     end
-    print "\e[#{arg[0]}A"
+    puts
+  end
+  def print_center(str, props={})
+    props[:x] = ((width - str.noatt.length) / 2).to_i-1
+    props[:y] ||= height
+    print_at(str, props)
+  end
+  def print_at(str, props={})
+    print_at_lamb = lambda {
+      #props[:x] ||= 0
+      #props[:y] ||= 0
+      props[:minus] = false unless props.has_key?(:minus)
+      props[:x] = props[:x]-str.noatt.size if props[:x] && props[:minus] # Subtract the str length from the position
+      Cursor.save
+      Cursor.move = 0
+      print str
+      Cursor.restore
+    }
+    RUBY_VERSION =~ /1.9/ ? Thread.exclusive(&print_at_lamb) : print_at_lamb.call
   end
-
-  def self.down(*arg)
-    if arg.length == 0
-      arg[0] == 1
-    end
-    print "\e[#{arg[0]}B"
+  
+  def self.style(col, bgcol=nil, att=nil)
+    valdor = []
+    valdor << COLOURS[col] if COLOURS.has_key?(col)
+    valdor << BGCOLOURS[bgcol] if BGCOLOURS.has_key?(bgcol)
+    valdor << ATTRIBUTES[att] if ATTRIBUTES.has_key?(att)
+    "\e[#{valdor.join(";")}m"   # => \e[8;34;42m  
   end
-
-  def self.right(*arg)
-    if arg.length == 0
-      arg[0] == 1
-    end
-    system "tput cuf #{arg[0]}"
+  
+  def self.clear
+    tput :clear
   end
 
-  def self.left(*arg)
-    if arg.length == 0
-      arg[0] == 1
-    end
-    system "tput cub #{arg[0]}"
+  def reset
+    tput :reset
   end
-
-  def self.save
-    system "tput sc"
+  
+  def width
+    tput_val(:cols).to_i
   end
 
-  def self.restore
-    system "tput rc"
+  def height
+    tput_val(:lines).to_i
   end
 end
 
-class Win
-  def initialize
-    @row = 1
-    @col = 1
-    @width = 10
-    @height = 5
-    @text = ""
-    @border = :single
-    @fg = :default
-    @bg = :bg_default
-    @bordercolor = :default
+module Cursor
+  extend self
+  
+  # Returns [x,y] for the current cursor position.
+  def position
+    yx = [0,0]
+    
+    position_lamb = lambda {
+      begin
+        # NOTE: Can we get cursor position from tput?
+        termsettings = `stty -g`
+      
+        # DEBUGGING: The following code works in Ruby 1.9 but not 1.8.
+      
+        system("stty raw -echo")
+        print "\e[6n"  # Forces output of: \e[49;1R  (\e is not printable)
+        c = ''
+        (pos ||= '') << c while (c = STDIN.getc) != 'R'# NOTE: There must be a better way!
+        yx = pos.scan(/(\d+);(\d+)/).flatten
+        yx[0] = yx[0].to_i - 1  # It returns 1 for the first column, but we want 0
+        yx[1] = yx[1].to_i - 1
+      ensure
+        system("stty #{termsettings}") # Get out of raw mode
+      end
+    }
+    
+    RUBY_VERSION =~ /1.9/ ? Thread.exclusive(&position_lamb) : position_lamb.call
+    yx.reverse
   end
 
-  def width=(width)
-    @width = width
-  end
+  def x; position[0]; end
+  def y; position[1]; end
 
-  def width
-    @width
+  def move=(*args)
+    x,y = *args.flatten
+    tput(:cup, y, x) # "tput cup" takes y before x
   end
 
-  def height=(height)
-    @height = height
+  def up(n=1)
+    tput :cuu, n
   end
 
-  def height
-    @height
+  def down(n=1)
+    tput :cud, n
   end
 
-  def text=(text)
-    @text = text
+  def right(x=1)
+    tput :cuf, x
   end
 
-  def text
-    @text
+  def left(x=1)
+    tput :cub, x
   end
-
-  def border=(arg)
-    if not arg.is_a?(Array)
-      arg = [arg]
-    end
-    if arg.length > 0
-      @border = arg[0]
-    end
-    if arg.length > 1
-      @bordercolor = arg[1]
-    end
+  
+  def line(n=1)
+    tput :il, n
   end
-
-  def border
-    [@border, @bordercolor]
+  
+  def save
+    tput :sc
   end
 
-  def position=(arg)
-    if not arg.is_a?(Array)
-      arg = [arg]
-    end
-    if arg.length > 0
-      @row = arg[0]
-    end
-    if arg.length > 1
-      @col = arg[1]
-    end
+  def restore
+    tput :rc
   end
-
-  def position
-    [@row, @col]
+  
+  def clear_line
+    tput :el
   end
+  
+  # TODO: replace methods with this kinda thing
+  #@@capnames = {
+  #  :restore => [:rc],
+  #  :save => [:sc],
+  #  :clear_line => [:el],
+  #  :line => [:il, 1, 1],
+  #  
+  #  :up => [:cuu, 1, 1],
+  #  :down => [:cud, 1, 1],
+  #  :right => [:cuf, 1, 1],
+  #  :left => [:cub, 1, 1],
+  #  
+  #  :move => [:cup, 2, 0, 0]
+  #}
+  #
+  #@@capnames.each_pair do |meth, cap|
+  #  module_eval <<-RUBY
+  #    def #{meth}(*args)
+  #      tput '#{cap[0]}'
+  #    end
+  #  RUBY
+  #end
+  
+end
 
-  def fg=(fg)
-    @fg = fg
+class Window
+  attr_accessor :row, :col, :width, :height, :text, :fg, :bg
+  attr_reader :threads
+  
+  def initialize(*args)
+    @row = 1
+    @col = 1
+    @width = 10
+    @height = 5
+    @text = ""
+    @fg = :default
+    @bg = :default
+    @threads = []
   end
 
-  def fg
-    @fg
+  def position=(x,y=nil)
+    @x = x
+    @y = y if y
   end
 
-  def bg=(bg)
-    @bg = bg
+  def position
+    [@row, @col]
   end
-
-  def bg
-    @bg
+  
+  def self.bar(len, unit='=')
+    unit*len
   end
 
-  def drawBorder
-    single = {
-      :upper_left  => "\u250C",
-      :upper_right => "\u2510",
-      :lower_left  => "\u2514",
-      :lower_right => "\u2518",
-      :horizontal  => "\u2500",
-      :vertical    => "\u2502"
-    }
-    bold = {
-      :upper_left  => "\u250D",
-      :upper_right => "\u2511",
-      :lower_left  => "\u2515",
-      :lower_right => "\u2519",
-      :horizontal  => "\u2501",
-      :vertical    => "\u2503"
-    }
-    double = {
-      :upper_left  => "\u2554",
-      :upper_right => "\u2557",
-      :lower_left  => "\u255A",
-      :lower_right => "\u255D",
-      :horizontal  => "\u2550",
-      :vertical    => "\u2551"
-    }
-    round = {
-      :upper_left  => "\u256D",
-      :upper_right => "\u256E",
-      :lower_left  => "\u2570",
-      :lower_right => "\u256F",
-      :horizontal  => "\u2500",
-      :vertical    => "\u2502"
-    }
-    mapper = case @border
-      when :single then single
-      when :bold   then bold
-      when :double then double
-      when :round  then round
-      else single
-    end
-    (mapper[:upper_left] + mapper[:horizontal] * (@width - 2) + mapper[:upper_right]).color(:normal, @bordercolor, @bg).printAt @row, @col
-    (mapper[:lower_left] + mapper[:horizontal] * (@width - 2) + mapper[:lower_right]).color(:normal, @bordercolor, @bg).printAt @row + @height - 1, @col
-    0.upto(@height - 3) do |i|
-      (mapper[:vertical] + " " * (@width - 2) + mapper[:vertical]).color(:normal, @bordercolor, @bg).printAt @row + i + 1, @col
+  
+  # Execute the given block every +n+ seconds in a separate thread.
+  # The lower limit for +n+ is 1 second. 
+  # Returns a Thread object.
+  def every_n_seconds(n)
+    #n = 1 if n < 1
+    thread = Thread.new do
+      
+      begin
+        while true
+          before = Time.now
+          yield
+          interval = n - (Time.now - before)
+          sleep(interval) if interval > 0
+        end
+      rescue Interrupt
+        break
+      ensure
+        thread
+      end
     end
   end
-
-  def draw
-    text = @text.split("\n")
-    0.upto(text.length - 1) do |i|
-      if @border != :none
-        text[i] = text[i][0, @width - 2]
-      else
-        text[i] = text[i][0, @width]
-      end
+  
+  # Print text to the screen via +type+ every +refresh+ seconds. 
+  # Print the return value of the block to the screen using the
+  # print_+type+ method. +refresh+ is number of seconds to wait
+  # +props+ is the hash sent to print_+type+. 
+  # Returns a Thread object.
+  #
+  #     # Print the time in the upper right corner every second
+  #     thread1 = Console.static(:right, 1, {:y => 0}) do 
+  #       Time.now.utc.strftime("%Y-%m-%d %H:%M:%S").colour(:blue, :white, :underline)
+  #     end
+  #
+  def static(type, refresh=2, props={}, &b)
+    meth = "print_#{type}"
+    raise "#{meth} is not supported" unless Console.respond_to?(meth)
+    
+    refresh ||= 0
+    refreh = refresh.to_s.to_i
+    
+    thread = every_n_seconds(refresh) do 
+      Console.send(meth, b.call, props.clone) 
     end
-    if @border == :none
-      0.upto((text.length > @height ? @height : text.length) - 1) do |i|
-        text[i].color(:normal, @fg, @bg).printAt @row + i , @col
+    
+    @threads << thread
+    
+    thread
+  end
+  
+  def join_threads
+    begin
+      @threads.each do |t|
+        t.join
       end
-    else
-      drawBorder
-      0.upto(@text.length > @height - 3 ? @height - 3 : text.length) do |i|
-        text[i].to_s.color(:normal, @fg, @bg).printAt @row + i + 1, @col + 1
+    rescue Interrupt
+    ensure
+      @threads.each do |t|
+        t.kill
       end
     end
   end
+  
 end