rudy 0.3.0 → 0.3.2

data/bin/rudy

@@ -27,7 +27,7 @@ require 'drydock'
 require 'rudy'
 extend Drydock
 
-debug :off
+
 
 default :commands
 
@@ -35,11 +35,17 @@ 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 :R, :region, String, "Connect to a specific EC2 region (default: #{Rudy::DEFAULT_REGION})"
+
+#global_option :z, :zone, String, "Connect to a specific EC2 zone (default: #{Rudy::DEFAULT_ZONE})"
+global_option :e, :environment, String, "Connect to the specified environment (default: #{Rudy::DEFAULT_ENVIRONMENT})"
+global_option :r, :role, String, "Connect to a machine with the specified role (defalt: #{Rudy::DEFAULT_ROLE})"
+global_option :p, :position, String, "Position in the machine in its group (default: #{Rudy::DEFAULT_POSITION})"
+
+global_option :u, :user, String, "Provide a username (default: #{Rudy::DEFAULT_USER})"
+
+#global_option :c, :config, String, "Specify the config file to read (default: #{Rudy::RUDY_CONFIG})"
 
-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}"
@@ -49,8 +55,11 @@ global_option :v, :verbose, "Increase verbosity of output (i.e. -v or -vv or -vv
   @verbose ||= 0
   @verbose += 1
 end
+global_option :q, :quiet, "Run with less output"
 
-command :commands do
+command :commands => Rudy::Command::Metadata do |obj|
+  obj.print_header
+  
   puts "Rudy can do all of these things:", ""
   command_names.sort.each do |cmd|
     puts " %16s" % cmd
@@ -60,6 +69,8 @@ command :commands do
   puts
 end
 
+debug :off
+
 usage "rudy init"
 command :init => Rudy::Command::Metadata do |obj|
   obj.setup
@@ -70,6 +81,13 @@ command :info => Rudy::Command::Metadata do |obj|
   obj.info
 end
 
+option :a, :all, "Display config settings for all machines"
+option :d, :defaults, "Display the default value for the supplied parameter"
+usage "rudy [-f config-file] config [param-name]"
+command :config => Rudy::Command::Environment do |obj, argv|
+  obj.config(argv.first)
+end
+
 
 option :e, :external, "Display only external IP address"
 option :i, :internal, "Display only internal IP address"
@@ -172,7 +190,8 @@ command :disks => Rudy::Command::Disks do |obj, argv|
   end
 end
 
-
+option :s, :snapshot, String, "Create a backup entry from an existing snapshot"
+option :Z, :synchronize, "Check for and delete backup metadata with no snapshot. DOES NOT delete snapshots."
 #option :T, :tidy, "Tidy existing backups"
 option :D, :destroy, "Destroy a backup"
 option :C, :create, "Create a backup"
@@ -181,7 +200,13 @@ command :backups => Rudy::Command::Disks do |obj, argv|
   capture(:stderr) do
     obj.print_header
     if obj.create
-      obj.create_backup
+      obj.create_backup(argv.first)
+    elsif obj.synchronize
+      unless argv.empty?
+        puts "The disk you specified will be ignored."
+        argv.clear
+      end
+      obj.sync_backups
     elsif obj.destroy
       raise "No backup specified" if argv.empty?
       #exit unless are_you_sure?
@@ -235,7 +260,7 @@ 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"
-option :D, :destroy, "Deregister an image"
+option :D, :destroy, "Deregister an image (currently _does not_ remove images files from S3)"
 usage "rudy images [-C -i name -b bucket -a account] [-D AMI-ID]"
 command :images => Rudy::Command::Images do |obj, argv|
   capture(:stderr) do
@@ -245,14 +270,19 @@ command :images => Rudy::Command::Images do |obj, argv|
     puts "Make sure the machine is clean. I don't want archive no crud!"
     exit unless are_you_sure?
     obj.create_image
+    
   elsif obj.destroy
     obj.deregister(argv.first)
+    
   else
     obj.print_images
   end
+  
 end
 end
 
+
+
 command :stage => Rudy::Command::Stage do |obj| 
   capture(:stderr) do
   obj.print_header

data/lib/rudy.rb

@@ -7,6 +7,65 @@ require 'yaml'
 require 'console'
 require 'storable'
 
+module Rudy #:nodoc:
+  RUDY_DOMAIN = ENV['RUDY_DOMAIN'] || "rudy_state"
+  RUDY_DELIM  = ENV['RUDY_DELIM'] || '-'
+  RUDY_CONFIG = File.join(ENV['HOME'] || ENV['USERPROFILE'], '.rudy')
+  
+  DEFAULT_REGION = ENV['EC2_DEFAULT_REGION'] || 'us-east-1'
+  DEFAULT_ZONE = ENV['EC2_DEFAULT_ZONE'] || 'us-east-1b'
+  DEFAULT_ENVIRONMENT = ENV['EC2_DEFAULT_ENVIRONMENT'] || 'stage'
+  DEFAULT_ROLE = ENV['EC2_DEFAULT_ROLE'] || 'app'
+  DEFAULT_POSITION = ENV['EC2_DEFAULT_POSITION'] || '01'
+  
+  DEFAULT_USER = ENV['EC2_DEFAULT_USER'] || 'rudy'
+  
+  module VERSION #:nodoc:
+    MAJOR = 0.freeze unless defined? MAJOR
+    MINOR = 3.freeze unless defined? MINOR
+    TINY  = 2.freeze unless defined? TINY
+    def self.to_s
+      [MAJOR, MINOR, TINY].join('.')
+    end
+    def self.to_f
+      self.to_s.to_f
+    end
+  end
+  
+  # Determine if we're running directly on EC2 or
+  # "some other machine". We do this by checking if
+  # the file /etc/ec2/instance-id exists. This
+  # 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?
+    File.exists?('/etc/ec2/instance-id')
+  end
+  
+  class Config < Storable
+    
+    attr_accessor :path
+    
+    field :userdata => Hash
+
+    def initialize(args={:path => nil})
+      @path = args[:path] || RUDY_CONFIG
+      @userdata = {
+        'default' => {
+        }
+      }
+    end
+
+    def get(name)
+
+    end
+
+    def exists?
+      File.exists?(@path)
+    end
+  end
+end
+
 require 'rudy/aws'
 require 'rudy/metadata'
 require 'rudy/scm/svn'
@@ -26,26 +85,6 @@ rescue LoadError => ex
   exit 1
 end
 
-module Rudy #:nodoc:
-  RUDY_DOMAIN = ENV['RUDY_DOMAIN'] || "rudy_state"
-  RUDY_DELIM = ENV['RUDY_DELIM'] || '-'
-  DEFAULT_REGION = ENV['EC2_DEFAULT_REGION'] || 'us-east-1'
-  DEFAULT_ZONE = ENV['EC2_DEFAULT_ZONE'] || 'us-east-1b'
-  
-  module VERSION #:nodoc:
-    MAJOR = 0.freeze unless defined? MAJOR
-    MINOR = 3.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
-    end
-  end
-end
-
-
 
 # Capture STDOUT or STDERR to prevent it from being printed. 
 #

data/lib/rudy/aws/ec2.rb

@@ -2,6 +2,10 @@
 module Rudy::AWS
   
   class EC2
+    class UserData
+      
+    end
+    
     class Images
       include Rudy::AWS::ObjectBase
       

data/lib/rudy/command/base.rb

@@ -31,6 +31,8 @@ module Rudy
       attr_reader :domains
       attr_reader :machine_images
       
+      attr_reader :config
+      
       def init
         @access_key = ENV['AWS_ACCESS_KEY'] unless @access_key
         @secret_key = ENV['AWS_SECRET_KEY'] unless @secret_key
@@ -42,14 +44,16 @@ module Rudy
         if ENV['RUDY_SVN_BASE']
           @scm = Rudy::SCM::SVN.new(ENV['RUDY_SVN_BASE'])
         end
+
+        @config = File.exists?(RUDY_CONFIG) ? Rudy::Config.from_file(RUDY_CONFIG) : Rudy::Config.new
         
-        @user ||= 'rudy'
-        @environment ||= 'stage'
-        @role ||= 'app'
-        @position ||= '01'
-        
-        @zone ||= DEFAULT_ZONE
         @region ||= DEFAULT_REGION
+        @zone ||= DEFAULT_ZONE
+        @environment ||= DEFAULT_ENVIRONMENT
+        @role ||= DEFAULT_ROLE
+        @position ||= DEFAULT_POSITION
+        
+        @user ||= DEFAULT_USER
         
         @keypairs = {}
         ENV.keys.select { |key| key.match /EC2_KEYPAIR/i }.each do |key|
@@ -81,12 +85,15 @@ module Rudy
           end
         end
         
-        @ec2 = Rudy::AWS::EC2.new(@access_key, @secret_key)
-        # RightAws::SdbInterface is on thin ice. No select support! Or sort!
-        @sdb = Rudy::AWS::SimpleDB.new(@access_key, @secret_key)
-        #@s3 = Rudy::AWS::SimpleDB.new(@access_key, @secret_key)
+        if @access_key && @secret_key
+          @ec2 = Rudy::AWS::EC2.new(@access_key, @secret_key)
+          # RightAws::SdbInterface is on thin ice. No select support! Or sort!
+          @sdb = Rudy::AWS::SimpleDB.new(@access_key, @secret_key)
+          #@s3 = Rudy::AWS::SimpleDB.new(@access_key, @secret_key)
+        end
       end
       
+      
       # Raises exceptions if the requested user does 
       # not have a valid keypair configured. (See: EC2_KEYPAIR_*)
       def check_keys
@@ -119,8 +126,9 @@ module Rudy
         @machine_images[machine_group]
       end
       
+      # TODO: fix machine_group to include zone
       def machine_name
-        [machine_group, @position].join(RUDY_DELIM)
+        [@zone, machine_group, @position].join(RUDY_DELIM)
       end
       
       def keypairname
@@ -213,8 +221,13 @@ module Rudy
 !!!!!!!!!   YOU ARE PLAYING WITH PRODUCTION   !!!!!!!!!
 =======================================================
 =======================================================)
-          puts msg.color(:bright, :red, :bg_white)
-          puts
+          puts msg.color(:bright, :red, :bg_white), $/  unless @quiet
+          
+        end
+        
+        if Rudy.in_situ?
+          msg = %q(============ THIS IS EC2 ============)
+          puts msg.color(:bright, :blue, :bg_white), $/ unless @quiet
         end
         
       end

data/lib/rudy/command/disks.rb

@@ -13,6 +13,43 @@ module Rudy
         end
       end
       
+      # Check for backups pointing to snapshots that don't exist. 
+      def sync_backups
+        criteria = [@zone]
+        criteria += [@environment, @role] unless @all
+        
+        puts "Looking for backup metadata with delinquent snapshots..."
+        to_be_deleted = {} # snap-id => backup
+        Rudy::MetaData::Backup.list(@sdb, *criteria).each do |backup|
+          to_be_deleted[backup.awsid] = backup unless @ec2.snapshots.exists?(backup.awsid)
+        end
+        
+        if to_be_deleted.empty?
+          puts "All backups are in-sync with snapshots. Nothing to do."
+          return
+        end
+        
+        puts
+        puts "These backup metadata will be deleted:"
+        to_be_deleted.each do |snap_id, backup|
+          puts "%s: %s" % [snap_id, backup.name]
+        end
+        
+        puts
+        are_you_sure?
+        
+        puts 
+        puts "Deleting..."
+        to_be_deleted.each do |snap_id, backup|
+          print " -> #{backup.name}... "
+          @sdb.destroy(RUDY_DOMAIN, backup.name)
+          puts "done"
+        end
+        
+        puts "Done!"
+      end
+      
+      
       def destroy_backup(name)
         puts "Destroying #{name}"
         begin
@@ -36,53 +73,90 @@ module Rudy
         puts "Done."
       end
       
-      def create_backup
+      def create_backup(diskname=nil)
         machine = find_current_machine
-        disks = Rudy::MetaData::Disk.list(@sdb, machine[:aws_availability_zone], @environment, @role, @position)
-        volumes = @ec2.instances.volumes(machine[:aws_instance_id])
-        
-        puts "Machine: #{machine_name}"
         
+        disks = Rudy::MetaData::Disk.list(@sdb, machine[:aws_availability_zone], @environment, @role, @position)
         raise "The machine #{machine_name} does not have any disk metadata" if disks.empty?
-        raise "The machine #{machine_name} does not have any volumes attached." if volumes.empty?
         
-        puts "#{disks.size} Disk(s) defined with #{volumes.size} Volume(s) running"
+        puts "Machine: #{machine_name}"
         
-        volumes.each do |volume|
-          print "Volume #{volume[:aws_id]}... "
-          disk = Rudy::MetaData::Disk.from_volume(@sdb, volume[:aws_id])
-          backup = Rudy::MetaData::Backup.new
-          
-          # TODO: Look for the disk based on the machine
-          raise "No disk associated to volume #{volume[:aws_id]}" unless disk 
+        if @snapshot
+          raise "You must supply a diskname when using an existing snapshot" unless diskname
+          raise "The snapshot #{@snapshot} does not exist" unless @ec2.snapshots.exists?(@snapshot)
+          disk = Rudy::MetaData::Disk.get(@sdb, diskname)
           
+          raise "The disk #{diskname} does not exist" unless disk
+          backup = Rudy::MetaData::Backup.new
+          backup.awsid = @snapshot
           backup.time_stamp
-          backup.volume = volume[:aws_id]
-          
+            
           # Populate machine infos
           [:zone, :environment, :role, :position].each do |n|
             val = instance_variable_get("@#{n}")
             backup.send("#{n}=", val) if val
           end
-          
+        
           # Populate disk infos
           [:path, :size].each do |n|
             backup.send("#{n}=", disk.send(n)) if disk.send(n)
           end
           
-          snap = @ec2.snapshots.create(volume[:aws_id])
-          
-          if !snap || !snap.is_a?(Hash)
-            puts "There was an unknown problem creating #{backup.name}. Continuing..."
-            next
-          end
-          
-          backup.awsid = snap[:aws_id]
           
           Rudy::MetaData::Backup.save(@sdb, backup)
           
           puts backup.name
+          
+        else
+          volumes = @ec2.instances.volumes(machine[:aws_instance_id])
+          raise "The machine #{machine_name} does not have any volumes attached." if volumes.empty?
+          
+          puts "#{disks.size} Disk(s) defined with #{volumes.size} Volume(s) running"
+        
+          volumes.each do |volume|
+            print "Volume #{volume[:aws_id]}... "
+            disk = Rudy::MetaData::Disk.from_volume(@sdb, volume[:aws_id])
+            backup = Rudy::MetaData::Backup.new
+          
+            # TODO: Look for the disk based on the machine
+            raise "No disk associated to volume #{volume[:aws_id]}" unless disk 
+          
+            backup.volume = volume[:aws_id]
+          
+            snap = @ec2.snapshots.create(volume[:aws_id])
+          
+            backup.awsid = snap[:aws_id]
+            
+            if !snap || !snap.is_a?(Hash)
+              puts "There was an unknown problem creating #{backup.name}. Continuing with the next volume..."
+              next
+            end
+            
+            backup.time_stamp
+
+            # Populate machine infos
+            [:zone, :environment, :role, :position].each do |n|
+              val = instance_variable_get("@#{n}")
+              backup.send("#{n}=", val) if val
+            end
+
+            # Populate disk infos
+            [:path, :size].each do |n|
+              backup.send("#{n}=", disk.send(n)) if disk.send(n)
+            end
+
+
+            Rudy::MetaData::Backup.save(@sdb, backup)
+
+            puts backup.name
+            
+          end
+
         end
+
+          
+
+          
       end
       
       
@@ -101,7 +175,8 @@ module Rudy
         
         print_disks
       end
-
+      
+      
       def print_disks
         criteria = [@zone]
         criteria += [@environment, @role] unless @all

data/lib/rudy/command/environment.rb

@@ -14,7 +14,58 @@ module Rudy
   module Command
     class Environment < Rudy::Command::Base
       
+      
+      # Display configuration from the local user data file (~/.rudy).
+      # This config contains user data which is sent to each EC2 when 
+      # it's created. 
+      #
+      # The primary purpose of this command is to give other apps a way
+      # to check various configuration values. (This is probably mostly
+      # useful on an instance itself).
+      #
+      #    # Display the default value.
+      #    $ rudy config -d param-name
+      #
+      #    # Display the value for a specific machine.
+      #    $ rudy -e prod -r db config param-name
+      #
+      #    # Display all configuration
+      #    $ rudy config --all
+      #
+      def config(name=nil)
+        return unless @config.exists?
+        puts "Config: #{@config.path}" if @verbose > 0
 
+        
+        which = @defaults ? @user : machine_name
+        puts "Machine: #{which}" if @verbose > 0
+        
+        return unless @config.userdata && @config.userdata.is_a?(Hash)
+        #return unless @config.userdata[which] && @config.userdata[which].is_a?(Hash)
+        
+        # The .rudy config files have a different structure.
+        # There's no userdata -> which. Just the config settings. 
+        if Rudy.in_situ?
+          if name && @config.userdata.has_key?(name)
+            puts @config.userdata[name]
+          else
+            puts @config.to_yaml
+          end
+        else
+          if name && @config.userdata.has_key?(which) 
+            value = @config.userdata[which][name.to_s]
+            puts value if value
+          elsif @all
+            puts @config.to_yaml
+          else
+            value = @config.userdata[which] 
+            puts value.to_yaml if value
+          end
+        end
+        
+      end
+        
+        
       def connect
         check_keys
         machine = find_current_machine
@@ -33,64 +84,7 @@ module Rudy
       end
       
       
-      # Start EC2 instances to run the stage. 
-      # Returns a hash in the same format as +instances+
-      def build_stage
-        
-        rig = running_instance_groups(@app_group)
-        raise "You already have a stage: #{rig.join(', ')}" unless rig.empty?
-        
-        root_keypair_name = File.basename(@app_root_keypair)
-        
-        # This is read by the Rudy start up script /etc/init.d/rudy-ec2-startup
-        user_data = {
-          :dbmaster => "localhost",
-          :role => "FE",
-          :env => "stage"
-        }
-        
-        ret = @ec2.run_instances(@app_ami, 1, 1, [@app_group], root_keypair_name, user_data.to_yaml, 'public')
-        puts "The instance has started. Please wait while it boots..."
-        puts "Check '#{$0} state' for aws_state 'running'."
-        puts "Then run '#{$0} stage --start"
-        associate_address
-        ret
-      end
-      
-      
-      # Start (rake bootstrap, etc...) the rails app on the stage
-      def start_stage
-        
-        rig = running_instance_groups(@app_group)
-        raise "There is no stage start!" if rig.empty?
-        cmds =[]
-        cmds.each do |cmd|
-          puts cmd
-          `#{cmd}`
-        end
-        
-      end
-      
-      # Shutdown all instances in the stage security group
-      def destroy_stage
-         
-        rig = running_instance_groups(@app_group)
-        raise "There is no stage to destroy!" if rig.empty?
-        stopped = []
-        rig.each do |inst|
-          stopped << inst[:aws_instance_id]
-        end
-        destroy_instances(stopped)
-      end
 
-      #def svn_tag_exists?(rtag, prefix)
-      #  return false if rtag.empty?
-      #  `svn info tag/`
-      #end
-      
-      def tag_release
-        
-      end
       
     end
   end

data/lib/rudy/command/instances.rb

@@ -50,14 +50,36 @@ module Rudy
         raise "No SSH key provided for #{keypairname}!" unless has_keypair?(keypairname)
         raise "SSH key provided but cannot be found! (#{keypairpath})" unless File.exists?(keypairpath)
         
-        user_data = {
-          :dbmaster => "localhost",
+        
+        machine_data = {
+          # Give the machine an identity
+          :zone => @zone,
+          :environment => @environment,
           :role => @role,
-          :env => @environment
+          :position => @position,
+          
+          # Add hosts to the /etc/hosts file
+          :hosts => {
+            :dbmaster => "127.0.0.1",
+          },
+          
+          :userdata => {}
         } 
         
+        # Populate userdata with settings from ~/.rudy
+        if @config.userdata.is_a?(Hash) && !@config.userdata.empty?
+          # Build a set of parameters for each user on the requested
+          # machine. Set default values first and overwrite. (TODO)
+          @config.userdata.each_pair do |n,hash|
+            user = n # TODO: should be prepared to parse "us-east-1b-stage-app-rudy" and "us-east-1b-stage-app-01-rudy"
+            machine_data[:userdata][user] = hash
+          end
+        end
+        
         puts "Starting an instance in #{machine_group}"
-        instances = @ec2.instances.create(@image, machine_group.to_s, File.basename(keypairpath), user_data.to_yaml, @zone)
+        puts "with userdata:", machine_data.to_yaml
+        
+        instances = @ec2.instances.create(@image, machine_group.to_s, File.basename(keypairpath), machine_data.to_yaml, @zone)
         inst = instances.first
         id, state = inst[:aws_instance_id], inst[:aws_state]
         

data/lib/rudy/metadata/config.rb

@@ -0,0 +1,8 @@
+
+
+
+module Rudy
+  module MetaData
+
+  end
+end

data/lib/storable.rb

@@ -86,8 +86,9 @@ class Storable
   end
   
   # Create a new instance of the object using data from file. 
-  def self.from_file(file_path=nil, format=nil)
+  def self.from_file(file_path, format='yaml')
     raise "Cannot read file (#{file_path})" unless File.exists?(file_path)
+    raise "#{self} doesn't support from_#{format}" unless self.respond_to?("from_#{format}")
     format = format || File.extname(file_path).tr('.', '')
     me = send("from_#{format}", read_file_to_array(file_path))
     me.format = format
@@ -116,6 +117,8 @@ class Storable
       
       if field_types[index] == Array
         ((value ||= []) << stored_value).flatten 
+      elsif field_types[index] == Hash
+        value = stored_value
       else
         # SimpleDB stores attribute shit as lists of values
         value = stored_value.first if stored_value.is_a?(Array) && stored_value.size == 1

data/rudy.gemspec

@@ -1,6 +1,6 @@
 @spec = Gem::Specification.new do |s|
 	s.name = "rudy"
-	s.version = "0.3.0"
+	s.version = "0.3.2"
 	s.summary = "Rudy is a handy staging and deployment tool for Amazon EC2."
 	s.description = "Rudy is a handy staging and deployment tool for Amazon EC2."
 	s.author = "Delano Mandelbaum"
@@ -27,7 +27,6 @@
   lib/rudy/aws/simpledb.rb
   lib/rudy/command/addresses.rb
   lib/rudy/command/base.rb
-  lib/rudy/command/commit.rb
   lib/rudy/command/disks.rb
   lib/rudy/command/environment.rb
   lib/rudy/command/groups.rb
@@ -38,8 +37,8 @@
   lib/rudy/command/volumes.rb
   lib/rudy/metadata.rb
   lib/rudy/metadata/backup.rb
+  lib/rudy/metadata/config.rb
   lib/rudy/metadata/disk.rb
-  lib/rudy/metadata/ec2startup.rb
   lib/rudy/metadata/environment.rb
   lib/rudy/scm/svn.rb
   lib/rudy/utils.rb

data/support/rudy-ec2-startup

@@ -2,17 +2,14 @@
 
 # what: Rudy EC2 startup script
 #  who: delano@solutious.com
-# when: 2009-02-20 (rev: 3)
+# when: 2009-02-25 (rev: 4)
+
+# NOTE: This is a prototype version of this script. A cleaner version 
+# with better documentation is forthcoming.
 
 # Runs when an ec2 instance startups up.
 # Grabs configuration from the run time user data and stores it locally.
-# Expects message data in the yaml format:
-#
-# :dbmaster: IP ADDRESS or LOCAL HOSTNAME (default: localhost)
-# :role: app, db, etc... (default: app)
-# :env: stage, prod (default: stage)
-# :access_key: amazon access key
-# :secret_key: amazon secret key
+# See Rudy::Command::Instances#start_instance for the expected yaml format.
 
 # Put this in /etc/init.d. Then:
 #   * chmod 755 rudy-ec2-startup
@@ -23,145 +20,155 @@
 #   * cd /etc/rc5.d                    
 #   * ln -s ../init.d/rudy-ec2-startup S17rudy
 
-# NOTE: This is a prototype version of this script. A cleaner version 
-# with better documentation is forthcoming.
-
-
 require 'yaml'
 require 'resolv'
 
 LOGFILE = '/var/log/rudy-ec2-startup'
 USERDATA = 'http://169.254.169.254/2008-02-01/user-data'
 METADATA = 'http://169.254.169.254/2008-02-01/meta-data'
-METADATAPARAMS = ['instance-id', 'instance-type']
 
+#LOGFILE = '/tmp/rudy-ec2-startup'
+#USERDATA = 'http://127.0.0.1/2008-02-01/user-data'
+#METADATA = 'http://127.0.0.1/2008-02-01/meta-data'
 
-def get_metadata
-  metadata = {}
-  
-  begin
-    METADATAPARAMS.each do |param|
-      log "  ---> #{param}"
-      metadata[param.to_s] = run("curl -s #{METADATA}/#{param}")
-    end
-  rescue => ex
-    log("Problem getting metadata: #{ex.message}")
-  end
-  metadata
-end
+METADATAPARAMS = ['instance-id', 'instance-type']
 
-def run(command, input='')
-  IO.popen(command, 'r+') do |io|
-    #io.puts input
-    #io.close_write
-    return io.read
-  end
-end  
+RUDY_CONFIG_FILE='.rudy'
 
-def get_formatted_time
-  t = Time.now
-  t_out = t.strftime("%H:%M:%S%p (%m/%d/%Y)")
-end
+module Rudy
+  module EC2Startup
+    extend self
+    
+    VERSION = 4.freeze
+    
+    def process_config
+      begin
+        File.unlink(LOGFILE) if File.exists?(LOGFILE)
+        log "RUDY (rev#{VERSION}) is in the house"
+        
+        log "Grabing configuration..."
+        config_yaml = run("curl -s #{USERDATA}")
+  
+        log "Grabing meta-data..."
+        metadata = get_metadata
+        
+        log "Processing metadata..."
+        METADATAPARAMS.each do |name|
+          default = name.gsub('instance-', '')
+          value = (metadata[name] && !metadata[name].empty?) ? metadata[name] : default
+          log "  ---> #{name}: #{value}"
+          write_to_file("/etc/ec2/#{name}", value, "w")
+        end
+        
+        log "Processing userdata..."
+        
+        if !config_yaml || config_yaml.empty?
+          raise "Nothing to process (did you supply user-data when you created the instance)" 
+        end
+        
+        config = YAML::load(config_yaml)
+        config ||= {}
+  
+        zone = config[:zone] ? config[:zone].downcase : "zone"
+        environment = config[:environment] ? config[:environment].downcase : "env"
+        role = config[:role] ? config[:role].downcase : "role"
+        position = config[:position] ? config[:position].downcase : "00"
+        
+        hostname = [zone, environment, role, position].join('-')
+        log "Setting hostname: #{hostname}"
+        `hostname #{hostname}`
+        
+        config[:hosts] ||= {}
+        config[:hosts][hostname] = '127.0.0.1'
+        
+        if config[:userdata] && config[:userdata].is_a?(Hash)
+          # TODO: How to we get the path to any user's home directory? 
+          # (when we're not running as that user.) 
+          config[:userdata].each_pair do |n,hash|
+            fileparts = (n === "root") ? ['/root'] : ['/home', n]
+            fileparts << RUDY_CONFIG_FILE
+            filepath = File.join(fileparts)
+            log "Writing to #{filepath}"
+            user_data = {
+              :userdata => hash
+            }
+            write_to_file(filepath, user_data.to_yaml, "w")
+          end
+        end
+        
+        if config[:hosts] && config[:hosts].is_a?(Hash)
+          log "Updating /etc/hosts..."
+          config[:hosts].each_pair do |name, address|
+            # Respect existing entries
+            next if read_file('/etc/hosts') =~ /#{name}/
+      
+            ip_address = (address !~ /^\d.+/) ? Resolv.getaddress(address) : address
+      
+            log "  ---> #{name}: #{ip_address}"
+            write_to_file("/etc/hosts", "\n#{ip_address}\t#{name}\n")
+          end
+        end
+        
+        log "Done!"
+  
+      rescue => ex
+        log "ERROR: #{ex.message}"
+      end
+    end
+    
+    
+    def get_metadata
+      metadata = {}
+
+      begin
+        METADATAPARAMS.each do |param|
+          log "  ---> #{param}"
+          metadata[param.to_s] = run("curl -s #{METADATA}/#{param}")
+          metadata[param.to_s] = nil if metadata[param.to_s].empty?
+        end
+      rescue => ex
+        log("Problem getting metadata: #{ex.message}")
+      end
+      metadata
+    end
 
-def write_to_file (filename, s, type='a')
-  f = File.open(filename,type)
-  f.puts s
-  f.close
-end
+    def run(command, input='')
+      IO.popen(command, 'r+') do |io|
+        io.read
+      end
+    end  
 
-def read_file(path)
-  read_file_to_array(path).join('')
-end
+    def get_formatted_time
+      t = Time.now
+      t_out = t.strftime("%H:%M:%S%p (%m/%d/%Y)")
+    end
 
-def read_file_to_array(path)
-  contents = []
-  return contents unless File.exists?(path)
-  open(path, 'r') do |l|
-    contents = l.readlines
-  end
-  contents
-end
+    def write_to_file (filename, s, type='a')
+      f = File.open(filename,type)
+      f.puts s
+      f.close
+    end
 
-def log(s)
-  msg = "#{get_formatted_time}: #{s}"
-  write_to_file(LOGFILE, msg)
-  puts msg
-end
+    def read_file(path)
+      read_file_to_array(path).join('')
+    end
 
-begin
-  File.unlink(LOGFILE) if File.exists?(LOGFILE)
-  log "Deleted previous logfile (#{LOGFILE})"
-  log "Grabing configuration..."
-  config_yaml = run("curl -s #{USERDATA}")
-  
-  log "Grabing meta-data..."
-  metadata = get_metadata
-  
-  raise "Ooooooops, no configuration" if !config_yaml || config_yaml.empty?
-  
-  config = YAML::load(config_yaml)
-  
-  if config && config[:role]
-    myrole = config[:role].downcase
-    
-  else
-    myrole = "app"
-  end
-  
-  log "My role is: #{myrole}"
-  
-  env = config && config[:env] ? config[:env] : "stage"
-  
-  unless read_file('/etc/hosts') =~ /dbmaster/
-    if config && config[:dbmaster]
-      log "Updating dbmaster in /etc/hosts..."
-    
-      case config[:dbmaster]
-      when /^\d.+/
-        ip_address = config[:dbmaster]
-      else    
-        ip_address = Resolv.getaddress(config[:dbmaster])
+    def read_file_to_array(path)
+      contents = []
+      return contents unless File.exists?(path)
+      open(path, 'r') do |l|
+        contents = l.readlines
       end
-    
-      log "The IP address for my dbmaster is: #{ip_address}"
-      write_to_file("/etc/hosts", "\n#{ip_address}\tdbmaster\n")
-      
-    else
-      write_to_file("/etc/hosts", "\n127.0.0.1\tdbmaster\n")
+      contents
     end
-  end
-  
 
-  hostname = ""
-  myid = "default-"
-  if metadata['instance-id']
-    myid = metadata['instance-id'][2..metadata['instance-id'].length]
-    log "My ID: #{myid}"
-    write_to_file("/etc/instance-id", myid, "w")   
-  end
-  
-  mytype = "unknown"
-  if metadata['instance-type']
-    mytype = metadata['instance-type']
-    log "My instance type: #{metadata['instance-type']}"
-    write_to_file("/etc/instance-type", metadata['instance-type'], "w")
-  end
-  
-  
-  hostname = "#{env}-#{myrole}-#{mytype.gsub('.', '')}-#{myid}" 
-  log "Setting hostname to #{hostname}"
-  `hostname #{hostname}`
-  
-  unless read_file('/etc/hosts') =~ /#{hostname}/
-    log "Adding an entry to /etc/hosts for: #{hostname}"
-    write_to_file("/etc/hosts", "\n127.0.0.1\t#{hostname}")
+    def log(s)
+      msg = "#{get_formatted_time}: #{s}"
+      write_to_file(LOGFILE, msg)
+      puts msg
+    end
+    
   end
-  
-  log "Done!"
-  
-rescue => ex
-  log ex.message
 end
-  
-
 
+Rudy::EC2Startup.process_config

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rudy
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
+  version: 0.3.2
 platform: ruby
 authors: 
 - Delano Mandelbaum
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-25 00:00:00 -05:00
+date: 2009-02-26 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -40,7 +40,6 @@ files:
 - lib/rudy/aws/simpledb.rb
 - lib/rudy/command/addresses.rb
 - lib/rudy/command/base.rb
-- lib/rudy/command/commit.rb
 - lib/rudy/command/disks.rb
 - lib/rudy/command/environment.rb
 - lib/rudy/command/groups.rb
@@ -51,8 +50,8 @@ files:
 - lib/rudy/command/volumes.rb
 - lib/rudy/metadata.rb
 - lib/rudy/metadata/backup.rb
+- lib/rudy/metadata/config.rb
 - lib/rudy/metadata/disk.rb
-- lib/rudy/metadata/ec2startup.rb
 - lib/rudy/metadata/environment.rb
 - lib/rudy/scm/svn.rb
 - lib/rudy/utils.rb

data/lib/rudy/command/commit.rb

@@ -1,10 +0,0 @@
-
-
-module Rudy
-  module Command
-    class Commit < Rudy::Command::Base
-      
-    end
-  end
-end
-

data/lib/rudy/metadata/ec2startup.rb

@@ -1,2 +0,0 @@
-
-