rudy 0.3.2 → 0.4.0

data/lib/rudy/command/metadata.rb

@@ -5,52 +5,36 @@ module Rudy
     class Metadata < Rudy::Command::Base
       
       
-      # Update Rudy's metadata for a running instance
-      def update_metadata(instances)
-        attributes = {
-          'role' => role,
-          'environment' => environment,
-          'instances' => instances
-        }
-        puts "Putting #{instances.join(', ')} into #{machine_group}"
-        
-        @sdb.store(RUDY_DOMAIN, "group_#{machine_group}", attributes)
-        
-        p group_metadata
+      # Print Rudy's metadata to STDOUT
+      def metadata
+        group_metadata.each_pair do |n,h|
+          puts n.att(:bright)
+          puts h.inspect, ""
+        end
       end
       
-      # Print Rudy's metadata to STDOUT
-      def print_metadata(instances=[])
-        p group_metadata
-        #query = "['instances' = '#{instances.first}'] union ['group' = '#{machine}']"
-        #
-        # p @sdb.get_attributes(RUDY_DOMAIN, "instances_#{machine}")
-        # p @sdb.query(RUDY_DOMAIN, query)
+      def destroy_metadata_valid?
+        false
       end
       
       def destroy_metadata
         @sdb.domains.destroy(RUDY_DOMAIN)
       end
       
-      def setup
-        puts "Checking environment..."
-        check_environment
-        
-        puts "Creating SimpleDB domain called #{RUDY_DOMAIN}"
-        @sdb.domains.create(RUDY_DOMAIN)
-      end
       
-      def info 
+      
+      def info
         domains = @sdb.domains.list[:domains]
         puts "Domains: #{domains.join(", ")}"
       end
-    
+      
+    private
       def check_environment
         raise "No Amazon keys provided!" unless has_keys?
-        raise "No SSH keypairs provided!" unless has_keypairs?
+        raise "No SSH keypairs provided!" unless has_keypair?
         true
       end
-        
+      
     end
   end
 end

data/lib/rudy/command/release.rb

@@ -0,0 +1,174 @@
+
+
+module Rudy
+  module Command
+    class Release < Rudy::Command::Base
+      
+      
+
+      
+      def release_valid?
+        
+        relroutine = @config.routines.find_deferred(@global.environment, @global.role, :release)
+        raise "No release routines defined for #{machine_group}" if relroutine.nil?
+        
+        raise "No EC2 .pem keys provided" unless has_pem_keys?
+        raise "No SSH key provided for #{@global.user} in #{machine_group}!" unless has_keypair?
+        raise "No SSH key provided for root in #{machine_group}!" unless has_keypair?(:root)
+        
+        @list = @ec2.instances.list(machine_group)
+        unless @list.empty?
+          msg = "#{machine_group} is in use, probably with another release. #{$/}"
+          msg << 'Sort it out and run "rudy shutdown" before continuing.' 
+          raise msg
+        end
+        
+        @scm, @scm_params = find_scm(:release)
+        
+        raise "No SCM defined for release routine" unless @scm        
+        raise "#{Dir.pwd} is not a working copy" unless @scm.working_copy?(Dir.pwd)
+        raise "There are local changes. Please revert or check them in." unless @scm.everything_checked_in?
+        raise "Invalid base URI (#{@scm_params[:base]})." unless @scm.valid_uri?(@scm_params[:base])
+        
+        true
+      end
+      
+      
+      
+      def rerelease_valid?
+        relroutine = @config.routines.find_deferred(@global.environment, @global.role, :rerelease)
+        raise "No rerelease routines defined for #{machine_group}" if relroutine.nil?
+        
+        raise "No EC2 .pem keys provided" unless has_pem_keys?
+        raise "No SSH key provided for #{@global.user} in #{machine_group}!" unless has_keypair?
+        raise "No SSH key provided for root in #{machine_group}!" unless has_keypair?(:root)
+        
+        @list = @ec2.instances.list(machine_group)
+        if @list.empty?
+          msg = "There are no machines running in #{machine_group}. #{$/}"
+          msg << 'You must run "rudy release" before you can rerelease.' 
+          raise msg
+        end
+        
+        @scm, @scm_params = find_scm(:rerelease)
+        
+        raise "No SCM defined for release routine" unless @scm        
+        raise "#{Dir.pwd} is not a working copy" unless @scm.working_copy?(Dir.pwd)
+        raise "There are local changes. Please revert or check them in." unless @scm.everything_checked_in?
+        raise "Invalid base URI (#{@scm_params[:base]})." unless @scm.valid_uri?(@scm_params[:base])
+        
+        true
+      end
+      
+      def rerelease
+        puts "Updating release from working copy".att(:bright)
+
+        tag, revision = @scm.local_info
+        puts "tag: #{tag}"
+        puts "rev: #{revision}"
+        
+        execute_disk_routines(@list.values, :rerelease)
+        
+        if @scm
+          
+          puts "Running SCM command".att(:bright)
+          ssh do |session|
+            cmd = "svn #{@scm_params[:command]}"
+            puts "#{cmd}"
+            session.exec!("cd #{@scm_params[:path]}")
+            session.exec!(cmd)
+            puts "#{@scm_params[:command]} complete"
+          end
+          
+        end
+        
+        execute_routines(@list.values, :rerelease, :after)
+        
+      end
+      
+      # <li>Creates a release tag based on the working copy on your machine</li>
+      # <li>Starts a new stage instance</li>
+      # <li>Executes release routines</li>
+      def release
+        # TODO: store metadata about release with local username and hostname
+        puts "Creating release from working copy".att(:bright)
+
+        exit unless are_you_sure?
+
+        tag = @scm.create_release(@global.local_user, @option.msg)        
+        puts "Done! (#{tag})"
+        
+        if @option.switch
+          puts "Switching working copy to new tag".att(:bright)
+          @scm.switch_working_copy(tag)
+        end
+        
+        @option.image ||= machine_image
+        
+        switch_user("root")
+        
+        puts "Starting #{machine_group}".att(:bright)
+        
+        instances = @ec2.instances.create(@option.image, machine_group.to_s, File.basename(keypairpath), machine_data.to_yaml, @global.zone)
+        inst = instances.first
+        
+        if @option.address ||= machine_address
+          puts "Associating #{@option.address} to #{inst[:aws_instance_id]}".att(:bright)
+          @ec2.addresses.associate(inst[:aws_instance_id], @option.address)
+        end
+        
+        wait_for_machine(inst[:aws_instance_id])
+        inst = @ec2.instances.get(inst[:aws_instance_id])
+        
+        #inst = @ec2.instances.list(machine_group).values
+        
+        
+        execute_disk_routines(inst, :release)
+        
+        if @scm
+          
+          puts "Running SCM command".att(:bright)
+          ssh do |session|
+            cmd = "svn #{@scm_params[:command]} #{tag} #{@scm_params[:path]}"
+            puts "#{cmd}"
+            session.exec!(cmd)
+            puts "#{@scm_params[:command]} complete"
+          end
+          
+        end
+        
+        execute_routines(inst, :release, :after)
+        
+        print_instance inst
+        
+        puts "Done!"
+      end
+      
+      
+      def find_scm(routine)
+        env, rol, att = @global.environment, @global.role
+        
+        # Look for the source control engine, checking all known scm values.
+        # The available one will look like [environment][role][release][svn]
+        params = nil
+        scm_name = nil
+        SUPPORTED_SCM_NAMES.each do |v|
+          scm_name = v
+          params = @config.routines.find(env, rol, routine, scm_name)
+          break if params
+        end
+        
+        if params
+          klass = eval "Rudy::SCM::#{scm_name.to_s.upcase}"
+          scm = klass.new(:base => params[:base])
+        end
+        
+        [scm, params]
+        
+      end
+      private :find_scm
+      
+    end
+  end
+end
+

data/lib/rudy/command/volumes.rb

@@ -4,24 +4,40 @@ module Rudy
   module Command
     class Volumes < Rudy::Command::Base
       
-      def destroy_volume(id)
+      def destroy_volumes_valid?        
+        id = @argv.first
         raise "No volume ID provided" unless id
-        raise "I will not help you destroy production!" if @environment == "prod"
+        raise "I will not help you destroy production!" if @global.environment == "prod"
         raise "The volume #{id} doesn't exist!" unless @ec2.volumes.exists?(id)
-        disk = Rudy::MetaData::Disk.from_volume(@sdb, id)
+        exit unless are_you_sure? 4
+        true
+      end
         
-        puts "Destroying #{id}!"
-        @ec2.volumes.destroy id
+      def destroy_volumes
+        id = @argv.first
+        disk = Rudy::MetaData::Disk.find_from_volume(@sdb, id)
+
+        begin
+          puts "Detaching #{id}"
+          @ec2.volumes.detach(id)
+          sleep 3
         
-        if disk
-          disk.awsid = nil
+          puts "Destroying #{id}"
+          @ec2.volumes.destroy(id)
+          
+          if disk
+            puts "Deleteing metadata for #{disk.name}"
+            Rudy::MetaData::Disk.destroy(@sdb, disk)
+          end
+          
+        rescue => ex
+          puts "Error while detaching volume #{id}: #{ex.message}"
         end
         
-        Rudy::MetaData::Disk.save(@sdb, disk)
         
       end
       
-      def print_volumes
+      def volumes
         machines = {}
         volumes = @ec2.volumes.list
         @ec2.volumes.list.each do |volume|
@@ -38,7 +54,7 @@ module Rudy
           env = (machine[:aws_groups]) ? machine[:aws_groups] : "Not-attached"
           puts "Environment: #{env}"
           hash[:volumes].each do |vol|
-            disk = Rudy::MetaData::Disk.from_volume(@sdb, vol[:aws_id])
+            disk = Rudy::MetaData::Disk.find_from_volume(@sdb, vol[:aws_id])
             print_volume(vol, disk)
           end
         end

data/lib/rudy/config.rb

@@ -0,0 +1,93 @@
+
+
+module Rudy
+  require 'caesars'
+
+  class AWSInfo < Caesars
+    def valid?
+      (!account.nil? && !accesskey.nil? && !secretkey.nil?) &&
+      (!account.empty? && !accesskey.empty? && !secretkey.empty?) 
+    end
+  end
+
+  class Defaults < Caesars
+  end
+  
+  
+  class Routines < Caesars
+    
+    def create(*args, &b)
+      hash_handler(:create, *args, &b)
+    end
+    def destroy(*args, &b)
+      hash_handler(:destroy, *args, &b)
+    end
+    def restore(*args, &b)
+      hash_handler(:restore, *args, &b)
+    end
+    def mount(*args, &b)
+      hash_handler(:mount, *args, &b)
+    end
+    
+    #
+    # Force the specified keyword to always be treated as a hash. 
+    # Example:
+    #
+    #     startup do
+    #       disks do
+    #         create "/path/2"         # Available as hash: [action][disks][create][/path/2] == {}
+    #         create "/path/4" do      # Available as hash: [action][disks][create][/path/4] == {size => 14}
+    #           size 14
+    #         end
+    #       end
+    #     end
+    #
+    def hash_handler(caesars_meth, *args, &b)
+      # TODO: Move to caesars
+      return @caesars_properties[caesars_meth] if @caesars_properties.has_key?(caesars_meth) && args.empty? && b.nil?
+      return nil if args.empty? && b.nil?
+      return method_missing(caesars_meth, *args, &b) if args.empty?
+      
+      caesars_name = args.shift
+      
+      prev = @caesars_pointer
+      @caesars_pointer[caesars_meth] ||= Caesars::Hash.new
+      hash = Caesars::Hash.new
+      @caesars_pointer = hash
+      b.call if b
+      @caesars_pointer = prev
+      @caesars_pointer[caesars_meth][caesars_name] = hash 
+      @caesars_pointer = prev
+    end
+  end
+  
+  class Machines < Caesars
+  end
+  
+  class Config < Caesars::Config
+    dsl Rudy::AWSInfo::DSL
+    dsl Rudy::Defaults::DSL
+    dsl Rudy::Routines::DSL
+    dsl Rudy::Machines::DSL
+    
+    def postprocess
+      # TODO: give caesar attributes setter methods
+      self.awsinfo.cert &&= File.expand_path(self.awsinfo.cert)
+      self.awsinfo.privatekey &&= File.expand_path(self.awsinfo.privatekey)
+      
+    end
+    
+    def look_and_load
+      cwd = Dir.pwd
+      # Rudy looks for configs in all these locations
+      @paths += Dir.glob(File.join('/etc', 'rudy', '*.rb')) || []
+      @paths += Dir.glob(File.join(cwd, 'config', 'rudy', '*.rb')) || []
+      @paths += Dir.glob(File.join(cwd, '.rudy', '*.rb')) || []
+      refresh
+    end
+    
+    
+  end
+end
+
+

data/lib/rudy/metadata/backup.rb

@@ -50,7 +50,7 @@ module Rudy
       end
       
       def valid?
-        @zone && @environment && @role && @position && @path && @date && @time && @sec
+        @zone && @environment && @role && @position && @path && @date && @time && @second
       end
       
       def time_stamp

data/lib/rudy/metadata/disk.rb

@@ -26,9 +26,6 @@ module Rudy
       field :size
       
       def initialize
-        @device = "/dev/sdh"
-        @zone = DEFAULT_ZONE
-        @region = DEFAULT_REGION
         @backups = []
         @rtype = @@rtype.to_s
         @raw_volume = false
@@ -46,7 +43,7 @@ module Rudy
       end
       
       def valid?
-        @zone && @environment && @role && @position && @path 
+        @zone && @environment && @role && @position && @path && @size && @device
       end
       
       def to_query(more=[], remove=[])
@@ -76,14 +73,14 @@ module Rudy
       
       def Disk.get(sdb, name)
         disk = sdb.get_attributes(RUDY_DOMAIN, name)
-        
-        raise "Disk #{name} does not exist!" unless disk && disk.has_key?(:attributes)
+        return nil unless disk && disk.has_key?(:attributes) && !disk[:attributes].empty?
+#        raise "Disk #{name} does not exist!" unless 
         Rudy::MetaData::Disk.from_hash(disk[:attributes])
       end
       
-      def Disk.destroy(sdb, name)
-        disk = Disk.get(sdb, name) # get raises an exception if the disk doesn't exist
-        sdb.destroy(RUDY_DOMAIN, name)
+      def Disk.destroy(sdb, disk)
+        disk = Disk.get(sdb, disk) if disk.is_a?(String) # get raises an exception if the disk doesn't exist
+        sdb.destroy(RUDY_DOMAIN, disk.name)
         true # wtf: RightAws::SimpleDB doesn't tell us whether it succeeds. We'll assume!
       end
       
@@ -98,7 +95,7 @@ module Rudy
         !sdb.query_with_attributes(RUDY_DOMAIN, query).empty?
       end
       
-      def Disk.from_volume(sdb, vol_id)
+      def Disk.find_from_volume(sdb, vol_id)
         query = "['awsid' = '#{vol_id}']"
         res = sdb.query_with_attributes(RUDY_DOMAIN, query)
         if res.empty?
@@ -108,47 +105,15 @@ module Rudy
         end
       end
       
-      def Disk.update_volume(sdb, ec2, disk, machine)
-        
-        disk = Disk.get(sdb, disk) if disk.is_a?(String)
-        raise "You must provide a disk name or obect" unless disk.is_a?(Rudy::MetaData::Disk)
-        
-        
-        # Make sure the volume is still running
-        disk.awsid = nil if disk.awsid && !ec2.volumes.exists?(disk.awsid)
-        
-        
-        # Otherwise we need to start one
-        unless disk.awsid
-          puts "No active EBS volume found for #{disk.name}"
-          
-          # TODO: pull actual backups
-          backups = Rudy::MetaData::Backup.for_disk(sdb, disk, 2)
-          
-          if backups.is_a?(Array) && !backups.empty?
-            backup = backups.first
-            if ec2.snapshots.exists?(backup.awsid)
-              puts "We'll use the most recent backup (#{backup.awsid})..."
-              volume = ec2.volumes.create(disk.zone, disk.size, backup.awsid)
-            else
-              puts "The backup refers to a snapshot that doesn't exist."
-              puts backup.name, backup.awsid
-              puts "You need to delete this backup metadata before continuing."
-              exit 1
-            end
-          else
-            puts "We'll create one from scratch..."
-            volume = ec2.volumes.create(disk.zone, disk.size, nil)
-            disk.raw_volume = true
-          end
-          
-          puts "Saving disk metadata"
-          disk.awsid = volume[:aws_id]
-          Disk.save(sdb, disk)
-          puts ""
+      
+      def Disk.find_from_path(sdb, path)
+        query = "['path' = '#{path}']"
+        res = sdb.query_with_attributes(RUDY_DOMAIN, query)
+        if res.empty?
+          nil
+        else
+          disk = Rudy::MetaData::Disk.from_hash(res.values.first)
         end
-        
-        disk
       end
       
       def Disk.list(sdb, zon, env=nil, rol=nil, pos=nil)