sabat-rudy 0.8.0

data/Rudyfile

@@ -0,0 +1,184 @@
+# = Rudy -- Skeleton configuration
+# 
+# Rudy automatically looks for configuration files in the following 
+# locations (in this order):
+#
+#     ./.rudy/config
+#     ~/.rudy/config
+#
+#     ./Rudyfile
+#     ./machines.rb, ./routines.rb, ./commands.rb
+#     ./config/rudy/*.rb
+#     ./.rudy/*.rb
+#     /etc/rudy/*.rb
+#
+# When multuple files are found, the configuration is NOT OVERRIDDEN,
+# it's ADDED or APPENDED depending on context. This means you can split 
+# configuration across many files as you please. 
+#
+# There are four sections: accounts, defaults, machines, commands and routines.
+# 
+# By convention, accounts and defaults go in ~/.rudy/config or ./.rudy/config 
+# machines, commands and routines configuration go in ./Rudyfile or into 
+# separate files in ./.rudy or ./config/rudy (machines.rb, commands.rb, ...)
+#
+
+# ---------------------------------------------------------  MACHINES  --------
+# The machines block describes the "physical" characteristics of your machines. 
+machines do
+  
+  zone :"us-east-1b" do
+    ami 'ami-e348af8a'               # Alestic Debian 5.0, 32-bit (US)
+  end
+  zone :"eu-west-1b" do
+    ami 'ami-6ecde51a'               # Alestic Debian 5.0, 32-bit (EU)
+  end
+  
+  hostname :rudy                     # One of: :default, :rudy, "your-name"
+  
+  # We've defined an environment called "stage" with one role: "app". 
+  # The configuration inside the env block is available to all its 
+  # roles. The configuration inside the role blocks is available only
+  # to machines in that specific role. 
+  env :stage, :prod do
+    size 'm1.small'                  # EC2 machine type for all machines
+                                     # in the "stage" environment
+    role :app do
+      positions 1                    # Only 1 machine in stage-app
+      #addresses '11.22.33.44'       # Define an elastic IP to reuse
+      
+      disks do                       # Define EBS volumes 
+        path "/rudy/disk1" do        # The paths can be anything but
+          size 2                     # they must be unique. 
+          device "/dev/sdr"          # Devices must be unique too.
+        end
+      end
+    end
+    
+    role :db do                      # You can define as many roles
+    end                              # as you like. These are just 
+    role :balancer do                # a couple examples.
+    end
+    
+    users do                         # Specify existing private keys per user
+      #root do                       
+      #  keypair "/path/2/private-key"
+      #end
+    end
+    
+  end  
+
+  # The routines section below contains calls to local and remote
+  # scripts. The config contained in this block is made available
+  # those scripts in the form of a yaml file. The file is called
+  # rudy-config.yml. 
+  config do                 
+    dbmaster 'localhost'
+    newparam 573114
+  end
+end
+
+
+# ----------------------------------------------------------- COMMANDS --------
+# The commands block defines shell commands that can be used in routines. The
+# ones defined here are added to the default list defined by Rye::Cmd (Rudy 
+# executes all SSH commands via Rye). 
+#
+# Usage: 
+#
+# allow COMMAND-NAME
+# allow COMMAND-NAME, '/path/2/COMMAND'
+# allow COMMAND-NAME, '/path/2/COMMAND', 'default argument', 'another arg'
+#
+commands do
+  allow :make
+  allow :gem_install, "/usr/bin/gem", "install", :V, "--no-rdoc", "--no-ri"
+  allow :apt_get, "/usr/bin/apt-get", :y, :q
+end
+
+
+# ----------------------------------------------------------- ROUTINES --------
+# The routines block describes the repeatable processes for each machine group.
+# To run a routine, specify its name on the command-line: rudy startup
+routines do
+  
+  env :stage, :prod do               # We'll define routines for the stage-app
+    role :app do                     # and prod-app machine groups
+                                     
+      startup do                     # $ rudy startup
+        adduser :rudy                # Create a user called "rudy"
+        authorize :rudy              # Enable passwordless logins as rudy
+                                     #
+        disks do                     # Define EBS volume routines
+          create "/rudy/disk1"       # Create an EBS volume, attach it, give
+        end                          # it a filesystem, and mount it.
+                                     #
+        after :rudy do               # Run remote SSH commands after startup
+          mkdir :p, "great"          # $ mkdir -p great
+          touch "great/scott"        # $ touch great/scott
+          ls :l, :a                  # $ ls -l -a
+        end                          
+      end                            
+                                     
+      shutdown do                    # $ rudy shutdown
+        before :root do              # Run remote SSH commands before shutdown
+          uptime               
+        end                               
+        disks do                     
+          destroy "/rudy/disk1"      # Unmount and destroy the EBS volume
+        end                          
+      end                            
+      
+      reboot do                      # $ rudy reboot
+        before :root do              # Run any pre-reboot tasks like stopping
+          uptime                     # web servers and databases. 
+        end                          #
+        after :root do               # Run any startup tasks like starting
+          uptime                     # processes or initializing the filesystem
+        end
+      end
+      
+      backup do                      # $ rudy backup
+        disks do                     # A simple routine that creates an EBS
+          snapshot "/rudy/disk1"     # snapshot of the specified volume.
+        end
+      end
+      
+      restore_example do             # $ rudy restore_example
+        disks do                     # A contrived example of restoring a 
+          destroy "/rudy/disk1"      # disk from a backup. NOTE: You'll need
+          restore "/rudy/disk1"      # to run "rudy backup" at least once 
+        end                          # before otherise there are no backups
+      end                            # to restore from. 
+      
+    end                              
+  end                                
+  
+  # Define global routines available to all machine groups
+  # This routine will update a basic Debian machine and
+  # install essential libraries. 
+  # See examples/ for more.
+  sysupdate do                       # $ rudy sysupdate
+    before :root do                  
+      apt_get "update"               # Update debian / ubuntu 
+      apt_get "install", "build-essential", "sqlite3", "libsqlite3-dev"
+      apt_get "install", "apache2-prefork-dev", "libapr1-dev"
+      gem_install 'rudy'
+    end
+  end
+  
+  anything do                        # $ rudy anything
+    before :display_uptime           # Specify a dependency
+    script :rudy do                  # This is Ruby, so any valid syntax
+      ls :l                          # can be used in the definitions. 
+    end                              # See: SysInfo gem for more info.
+  end
+  
+  display_uptime do                  # $ rudy display-uptime
+    script :rudy do                  # NOTE: You can use 'dashes' on the
+      uptime                         # command-line instead of underscores
+    end
+  end
+  
+end
+

data/bin/ird

@@ -0,0 +1,153 @@
+#!/usr/bin/ruby
+
+# = Interactive Rudy (experimental)
+# 
+# === Not your granparent's deployment tool
+#
+#   See ird -h for usage
+#
+
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib') # Put our local lib in first place
+$:.unshift File.join(File.dirname(__FILE__), '..', 'vendor', 'highline-1.5.1', 'lib')
+%w{drydock caesars rye}.each { |dir| $:.unshift File.join(File.dirname(__FILE__), '..', '..', dir, 'lib') }
+require 'rubygems'
+
+# SEE: http://github.com/rubyspec/matzruby/blob/a34130eb7c4ecc164115a59aa1b76c643bd98202/lib/irb/xmp.rb
+# SEE: http://github.com/blackwinter/wirble/tree/master
+require "irb"
+require 'irb/completion'
+
+require 'rudy'
+require 'drydock'
+require 'rudy/cli'
+
+
+class RudyCLI_Interactive < Rudy::CLI::Base # :nodoc:all
+
+  include Readline
+
+  default :interactive
+  debug :off
+  about "An interactive REPL for Rudy."
+  usage "#{$0} [global options]"
+  command :interactive do |obj|
+  
+    @@rmach = Rudy::Machines.new(:global => obj.global)
+    @@rkey = Rudy::KeyPairs.new(:global => obj.global)
+    @@rgrp = Rudy::Groups.new(:global => obj.global)
+    @@rvol = Rudy::Volumes.new(:global => obj.global)
+    @@radd = Rudy::Addresses.new(:global => obj.global)
+  
+    puts Rudy::CLI.generate_header(@@rmach.global, @@rmach.config)
+    puts Rudy::Utils.without_indent(%Q`
+    ------------------------------------------------------------
+    Welcome Interactive Rudy! (EXPERIMENTAL)
+    ------------------------------------------------------------
+  
+    `)
+    h
+  
+    # What's the deal with this error message when defining a help method?
+    # => rb: warn: can't alias help from irb_help
+    if __FILE__ == $0
+      IRB.start(__FILE__)
+    else
+      # check -e option
+      if /^-e$/ =~ $0
+        IRB.start(__FILE__)
+      else
+        IRB.start(__FILE__)
+      end
+    end
+  
+  end
+  
+  
+  
+  
+  def h;
+    puts (%Q`
+  HELP
+
+    h             Help (this screen)
+    m             Rudy::Machines instance
+    g             Rudy::Groups instance
+    k             Rudy::KeyPairs instance
+    v             Rudy::Volumes instance
+    a             Rudy::Addresses instance
+    ssh [GROUP]   Connect to a machine
+    example       Start an EC2 instance from scratch.
+    `)
+  end
+  def example
+    puts (%Q`
+  EXAMPLE
+      Start an EC2 instance from scratch.
+
+      # Create a security group
+      >> g.create
+      => #<Rudy::AWS::EC2::Group @name="stage-app" ...>
+
+      # Create a keypair (used to login as root)
+      >> k.create
+      => #<Rudy::AWS::EC2::KeyPair @name="key-stage-app" ...>
+
+      # Start an EC2 machine instance:    
+      >> m.create
+      Instance: i-228def51
+      Waiting for the instance to startup
+      ........It's up!
+
+      # Login to the new instance
+      >> ssh 
+
+      All commands in Rudy refer to the global defaults unless
+      otherwise specified. "stage" is the default environment and 
+      "app" is the default role. You can change these with command 
+      line arguments or by modifying the defaults in your Rudy 
+      config file: #{@@rmach.config_dirname}
+
+      You can also specify your own names by providing
+      one as the first argument: g.create 'group5000'.
+
+      # List instances in stage-app
+      >> m.list :running
+      => [#<Rudy::AWS::EC2::Instance:0x18c5888 ...>]
+
+      # Print the instance in a human readable way
+      >> puts m.list.first.to_s
+
+      # Print instance system console output
+      >> puts m.console
+
+      # Destroy ALL INSTANCES in stage-app
+      >> m.destroy
+    `)
+  end
+
+  def m; @@rmach; end
+  def k; @@rkey; end
+  def g; @@rgrp; end
+  def v; @@rvol; end
+  def a; @@radd; end
+
+  # Change Group
+  #def cg(name); end
+
+  def ssh(*args)
+    @@rmach.switch_user :root
+    @@rmach.connect(*args)
+    @@rmach.switch_user # back to previous user
+    nil
+  end
+  
+  
+end
+
+#include RudyCLI_Interactive  # So we don't have to say CLI.example in the REPL. 
+
+
+__END__
+#@rbox = Rye::Box.new('ec2-174-129-173-3.compute-1.amazonaws.com', 'root')
+#@rbox2 = Rye::Box.new('ec2-174-129-173-3.compute-1.amazonaws.com', 'root')
+#@rbox.add_keys('/Users/delano/Projects/git/rudy/.rudy/key-test-app.private')

data/bin/rudy

@@ -0,0 +1,232 @@
+#!/usr/bin/ruby
+
+
+# = Rudy
+# 
+# === Not your granparent's deployment tool
+#
+#   See rudy -h for usage
+# 
+
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib') # Put our local lib in first place
+$:.unshift File.join(File.dirname(__FILE__), '..', '..', 'drydock', 'lib') 
+require 'rubygems'
+
+#$SAFE = 1   # require is unsafe in Ruby 1.9??
+
+require 'drydock'
+require 'rudy'
+require 'rudy/cli'
+
+# Command-line interface for /bin/rudy
+class RudyCLI < Rudy::CLI::Base
+  
+  debug :on
+  default :machines
+  trawler :passthrough
+  
+  # ------------------------------------------  RUDY GLOBALS  --------
+  # ------------------------------------------------------------------
+  
+  global :e, :environment, String, "Connect to the specified environment (ie: #{Rudy::DEFAULT_ENVIRONMENT})"
+  global :r, :role, String, "Connect to a machine with the specified role (ie: #{Rudy::DEFAULT_ROLE})"
+  global :p, :position, String, "Position in the machine in its group (ie: #{Rudy::DEFAULT_POSITION})"
+
+
+  # ------------------------------------------  RUDY OBJECTS  --------
+  # ------------------------------------------------------------------
+  
+  about "View Machines"
+  option :l, :all, "Display all machines"
+  action :W, :wash, "Wash machine metadata."
+  command :machines => Rudy::CLI::Machines
+  command_alias :machines, :m
+  
+  about "View Disks"
+  action :W, :wash, "Wash disk metadata."
+  option :b, :backups, "Display backups"
+  option :l, :all, "Display all disks"
+  command :disks => Rudy::CLI::Disks
+  command_alias :disks, :d
+  
+  about "Log in to a machine"
+  command :ssh => Rudy::CLI::Machines
+  
+  #about "Open the machine in your default browser (OSX only)"
+  #option :s, :https, "Use HTTPS"
+  #option :p, :port, Integer, "Port"
+  #command :open => Rudy::CLI::Candy
+  
+    
+  # -----------------------------------------  RUDY ROUTINES  --------
+  # ------------------------------------------------------------------
+  
+  # A "do nothing" routine. Passthrough simply executes a routine
+  # config block. Drydock's trawler uses this for unknown commands.
+  about "A skeleton routine"
+  command :passthrough => Rudy::CLI::Routines
+
+  about "Startup a machine group"
+  usage "rudy startup"
+  command :startup => Rudy::CLI::Routines
+
+  about "Shutdown a machine group"
+  usage "rudy shutdown"
+  command :shutdown => Rudy::CLI::Routines
+  
+  about "Reboot a machine group"
+  usage "rudy reboot"
+  command :reboot => Rudy::CLI::Routines
+  
+  about "Create a release"
+  usage "rudy release"
+  command :release => Rudy::CLI::Routines
+  command_alias :release, :rerelease
+  
+  #about "Update the release currently running in a machine group"
+  #command :rerelease => Rudy::CLI::Routines
+  #command_alias :rerelease, :rere
+
+  #about "Deploy disk snapshots from one machine to another"
+  #command :deploy => Rudy::CLI::Routines
+  
+
+  # ------------------------------------  RUDY MISCELLANEOUS  --------
+  # ------------------------------------------------------------------
+    
+  usage "rudy [-f config-file] config [param-name]"
+  about "Check Rudy configuration."
+  option :l, :all, "Display all configs for all machines"
+  option :commands, "Display commands configuration"
+  option :defaults, "Display defaults configuration"
+  option :machines, "Display machines configuration"
+  option :accounts, "Display accounts configuration"
+  option :routines, "Display routines configuration"
+  option :script, "Output configuration identical to what is provided to scripts called in routines"
+  option :project, "Output a skeleton Rudyfile"
+  #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::CLI::Config
+  
+  command :print_global => Rudy::CLI::Config
+  command_alias :print_global, :global
+  
+  about "Initialize Rudy configuration"
+  command :init do |obj|
+    
+    Rudy::Huxtable.update_config
+    
+    unless File.exists?(Rudy::CONFIG_FILE)
+      Rudy::Config.init_config_dir
+    end
+  
+    begin
+
+      unless Rudy::Huxtable.domain_exists?
+        puts "Creating SimpleDB domain #{Rudy::Huxtable.domain}"
+        Rudy::Huxtable.create_domain
+        puts "Initialized"
+      else
+        puts "Already Initialized"
+      end
+    
+    rescue Rudy::AWS::SDB::NoSecretKey, 
+           Rudy::AWS::SDB::NoAccessKey, 
+           Rudy::NoConfig => ex
+      puts "AWS credentials must be configured to continue."
+      puts "You can modify these in #{Rudy::CONFIG_FILE}"
+      exit 1
+    end
+  
+    obj.global.quiet = true  # don't print elapsed time
+  end
+
+  about "Display time (in UTC)"
+  option :l, :local, "Display local time"
+  command :time do |obj|
+    t = obj.option.local ? Time.now : Time.now.utc
+    puts '%s' % t.strftime("%Y-%m-%d %T %Z (%z)")
+  end
+
+  usage "rudy myaddress [-i] [-e]"
+  about "Displays you current internal and external IP addresses"
+  option :e, :external, "Display only external IP address"
+  option :i, :internal, "Display only internal IP address"
+  command :myaddress do |obj|
+    ea = Rudy::Utils::external_ip_address || '' 
+    ia = Rudy::Utils::internal_ip_address || ''
+    if obj.global.quiet
+      puts ia unless obj.option.external && !obj.option.internal
+      puts ea unless obj.option.internal && !obj.option.external
+    else
+      puts "%10s: %s" % ['Internal', ia] unless obj.option.external && !obj.option.internal
+      puts "%10s: %s" % ['External', ea] unless obj.option.internal && !obj.option.external
+    end
+    obj.global.quiet = true  # don't print elapsed time
+  end
+
+  usage "rudy [global options] annoy [-h -m -l] [-e]"
+  about "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
+    obj.global.quiet = true  # don't print elapsed time
+  end
+
+  about "Display the current Rudy slogan"
+  command :slogan do |obj|
+    puts "Rudy: Not your grandparent's deployment tool!"
+    obj.global.quiet = true  # don't print elapsed time
+  end
+
+  about "Generates a configuration template to #{Rudy::CONFIG_FILE}"
+  command :generate_config do |obj|
+    unless File.exists?(Rudy::CONFIG_FILE)
+      Rudy::Config.init_config_dir
+      puts "Add your AWS credentials to #{Rudy::CONFIG_FILE}"
+    else
+      puts "#{Rudy::CONFIG_FILE} already exists"
+    end
+  end
+  
+  
+  command :sysinfo do
+    puts Rudy.sysinfo.to_yaml
+  end
+end
+
+# We call Drydock specifically otherwise it will run at_exit. Rye also
+# uses at_exit for shutting down the ssh-agent. Ruby executes at_exit
+# blocks in reverse order so if Drydock is required first, it's block
+# will run after Rye shuts down the ssh-agent. 
+begin
+  Drydock.run!(ARGV, STDIN) if Drydock.run? && !Drydock.has_run?
+
+rescue Drydock::ArgError, Drydock::OptError => ex
+  STDERR.puts ex.message
+  STDERR.puts ex.usage
+rescue Drydock::InvalidArgument => ex
+  STDERR.puts ex.message  
+rescue Rudy::Error => ex
+  STDERR.puts ex.message
+  STDERR.puts ex.backtrace if Drydock.debug?
+rescue => ex
+  STDERR.puts "ERROR (#{ex.class.to_s}): #{ex.message}"
+  STDERR.puts ex.backtrace if Drydock.debug?
+rescue Interrupt
+  puts "#{$/}Exiting... "
+  exit 1
+rescue SystemExit
+  # Don't balk
+end