solutious-rudy 0.4.0 → 0.5.0

data/lib/rudy/metadata/machine.rb

@@ -0,0 +1,34 @@
+
+
+module Rudy
+  module MetaData
+    class Machine < Storable
+      
+      @@rtype = 'machine'
+      
+      field :rtype
+      field :awsid
+      
+      field :environment
+      field :role
+      field :path
+      field :position
+      
+      field :zone
+      field :region
+      
+      def initialize
+        @rtype = @@rtype.to_s
+      end
+      
+      def rtype
+        @@rtype.to_s
+      end
+      
+      def rtype=(val)
+      end
+      
+      
+    end
+  end
+end

data/lib/rudy/routines.rb

@@ -0,0 +1,54 @@
+
+
+module Rudy
+  module Routines
+    class Base
+      include Rudy::Huxtable
+    
+      # Examples:
+      #
+      # def before
+      # end
+      # def before_local
+      # end
+      # def svn
+      # end
+      #
+      
+      
+      #
+      #
+      def execute
+        raise "Override this method"
+      end
+      
+      
+      
+      # We grab the appropriate routines config and check the paths
+      # against those defined for the matching machine group. 
+      # Disks that appear in a routine but not the machine will be
+      # removed and a warning printed. Otherwise, the routines config
+      # is merged on top of the machine config and that's what we return.
+      def fetch_routine(action)
+        raise "No configuration" unless @config
+        raise "No globals" unless @global
+        
+        disk_definitions = @config.machines.find_deferred(@global.environment, @global.role, :disks)
+        routine = @config.routines.find(@global.environment, @global.role, action)
+        routine.disks.each_pair do |raction,disks|
+          disks.each_pair do |path, props|
+            routine.disks[raction][path] = disk_definitions[path].merge(props) if disk_definitions.has_key?(path)
+            unless disk_definitions.has_key?(path)
+              @logger.puts "#{path} is not defined. Check your #{action} routines config.".color(:red)
+              routine.disks[raction].delete(path) 
+            end
+          end
+        end
+        routine
+      end
+
+
+      
+    end
+  end
+end

data/lib/rudy/routines/disk_handler.rb

@@ -0,0 +1,190 @@
+
+
+module Rudy::Routines
+  class DiskHandler
+    include Rudy::Huxtable    # @config, @global come from here
+    
+    
+    # +machine+ is a Rudy::AWS::EC2::Instance object
+    # +routines+ is a Hash config contain the disk routines.
+    def execute(machine, routines)
+      
+      @logger.puts "Running DISK routines".bright
+      
+      
+      unless routines
+        @logger.puts "No #{action} disk routines."
+        return
+      end
+      
+      unless machine.awsid
+        @logger.puts "Machine given has no instance ID. Skipping disk routines."
+        return
+      end
+    
+      unless machine.dns_name_public
+        @logger.puts "Machine given has no DNS name: #{machine.awsid}. Skipping disk routines."
+        return
+      end
+      
+      # The order is important. We could be destroying and recreating
+      # a disk on the same machine. 
+      destroy(machine, routines.destroy) if routines.destroy
+      mount(machine, routines.mount) if routines.mount
+      restore(machine, routines.restore) if routines.restore
+      create(machine, routines.create) if routines.create
+    
+    end
+    
+    
+    def create(machine, disk_routine)
+      
+      disk_routine.each_pair do |path,props|
+  
+        begin 
+          puts "Creating disk for #{path}"
+          
+          disk = Rudy::MetaData::Disk.new
+          disk.path = path
+          [:region, :zone, :environment, :role, :position].each do |n|
+            disk.send("#{n}=", @global.send(n)) if @global.send(n)
+          end
+          [:device, :size].each do |n|
+            disk.send("#{n}=", props[n]) if props.has_key?(n)
+          end
+      
+                  
+          puts "Creating volume... (#{disk.size}GB in #{@global.zone})".bright
+          volume = @ec2.volumes.create(disk.size, @global.zone)
+      
+          puts "Attaching #{volume[:aws_id]} to #{machine.awsid}".bright
+          @ec2.volumes.attach(machine.awsid, volume[:aws_id], disk.device)
+          sleep 6
+          
+          puts "Creating the filesystem (mkfs.ext3 -F #{disk.device})".bright
+          ssh_command machine.dns_name_public, keypairpath, @global.user, "mkfs.ext3 -F #{disk.device}"
+          sleep 3
+          
+          puts "Mounting #{disk.device} to #{disk.path}".bright
+          ssh_command machine.dns_name_public, keypairpath, @global.user, "mkdir -p #{disk.path} && mount -t ext3 #{disk.device} #{disk.path}"
+        
+          puts "Creating disk metadata for #{disk.name}"
+          disk.awsid = volume[:aws_id]
+          Rudy::MetaData::Disk.save(@sdb, disk)
+        
+          sleep 1
+        rescue => ex
+          @logger.puts "There was an error creating #{path}: #{ex.message}".color(:red)
+          @logger.puts ex.backtrace
+          # NOTE: This isn't necessary right? B/c saving happens last so if there
+          # is an exception, the disk metadata would never be saved. 
+          #if disk
+          #  puts "Removing metadata for #{disk.name}"
+          #  Rudy::MetaData::Disk.destroy(@sdb, disk)
+          #end
+        end
+        puts
+      end
+    end
+    
+    
+    
+    def destroy(machine, disk_routine)
+      disk_paths = disk_routine.keys
+      
+      vols = @ec2.instances.volumes(machine.awsid) || []
+      puts "No volumes to destroy for (#{machine.awsid})" if vols.empty?
+      vols.each do |vol|
+        disk = Rudy::MetaData::Disk.find_from_volume(@sdb, vol[:aws_id])
+        if disk
+          this_path = disk.path
+        else
+          puts "No disk metadata for volume #{vol[:aws_id]}. Going old school..."
+          this_path = device_to_path(machine, vol[:aws_device])
+        end
+        
+        if disk_paths.member?(this_path) 
+        
+          
+          begin
+            puts "Unmounting #{this_path}..."
+            ssh_command machine.dns_name_public, keypairpath, @global.user, "umount #{this_path}"
+            sleep 3
+          rescue => ex
+            puts "Error while unmounting #{this_path}: #{ex.message}"
+            puts ex.backtrace if Drydock.debug?
+            puts "We'll keep going..."
+          end
+          
+          begin
+            
+            if @ec2.volumes.attached?(disk.awsid)
+              puts "Detaching #{vol[:aws_id]}"
+              @ec2.volumes.detach(vol[:aws_id])
+              sleep 3 # TODO: replace with something like wait_for_machine
+            end
+            
+            puts "Destroying #{this_path} (#{vol[:aws_id]})"
+            if @ec2.volumes.available?(disk.awsid)
+              @ec2.volumes.destroy(vol[:aws_id])
+            else
+              puts "Volume is still attached (maybe a web server of database is running?)"
+            end
+            
+            if disk
+              puts "Deleteing metadata for #{disk.name}"
+              Rudy::MetaData::Disk.destroy(@sdb, disk)
+            end
+          
+          rescue => ex
+            puts "Error while detaching volume #{vol[:aws_id]}: #{ex.message}"
+            puts ex.backtrace if Drydock.debug?
+            puts "Continuing..."
+          end
+          
+        end
+        puts
+        
+      end
+      
+    end
+    
+    
+    def mount(machine, disk_routine)
+      disk_paths = disk_routine.keys 
+      vols = @ec2.instances.volumes(machine.awsid) || []
+      puts "No volumes to mount for (#{machine.awsid})" if vols.empty?
+      vols.each do |vol|
+        disk = Rudy::MetaData::Disk.find_from_volume(@sdb, vol[:aws_id])
+        if disk
+          this_path = disk.path
+        else
+          puts "No disk metadata for volume #{vol[:aws_id]}. Going old school..."
+          this_path = device_to_path(machine, vol[:aws_device])
+        end
+        
+        next unless disk_paths.member?(this_path)
+        
+        begin
+          unless @ec2.instances.attached_volume?(machine.awsid, vol[:aws_device])
+            puts "Attaching #{vol[:aws_id]} to #{machine.awsid}".bright
+            @ec2.volumes.attach(machine.awsid, vol[:aws_id],vol[:aws_device])
+            sleep 3
+          end
+
+          puts "Mounting #{this_path} to #{vol[:aws_device]}".bright
+          ssh_command machine.dns_name_public, keypairpath, @global.user, "mkdir -p #{this_path} && mount -t ext3 #{vol[:aws_device]} #{this_path}"
+
+          sleep 1
+        rescue => ex
+          puts "There was an error mounting #{this_path}: #{ex.message}"
+          puts ex.backtrace if Drydock.debug?
+        end
+        puts 
+      end
+    end
+    
+    
+    
+  end
+end

data/lib/rudy/routines/release.rb

@@ -0,0 +1,15 @@
+module Rudy
+  module Routines
+    class Release < Rudy::Routines::Base
+      
+
+      def execute()
+        
+      end
+
+
+
+
+    end
+  end
+end

data/lib/rudy/routines/script_runner.rb

@@ -0,0 +1,65 @@
+
+require 'tempfile'
+
+module Rudy::Routines
+  class ScriptRunner
+    include Rudy::Huxtable
+    
+    def execute(instance, routine, before_or_after)
+      return false unless instance
+      
+      rscripts = @config.routines.find_deferred(@global.environment, @global.role, routine, before_or_after) || []
+      rscripts &&= [rscripts].flatten # Make sure it's an Array
+      if !rscripts || rscripts.empty?
+        @logger.puts "No scripts defined."
+        return
+      end
+      
+      # The config file will contain settings from ~/.rudy/config
+      script_config = @config.routines.find_deferred(@global.environment, @global.role, :config) || {}        
+      script_config[:global] = @global.marshal_dump
+      script_config[:global].reject! { |n,v| n == :cert || n == :privatekey }
+      script_config_filename = "#{routine}_config.yaml"
+      
+      tf = Tempfile.new(script_config_filename)
+      Rudy::Utils.write_to_file(tf.path, script_config.to_hash.to_yaml, 'w')
+
+      rscripts.each do |rscript|
+        user, script = rscript.shift
+        
+        @logger.puts "User: #{user} (#{user_keypairpath(user)})"
+        begin
+          Net::SCP.start(instance.dns_name_public, user, :keys => [user_keypairpath(user)]) do |scp|
+            scp.upload!(tf.path, "~/#{script_config_filename}") do |ch, name, sent, total|
+              "#{name}: #{sent}/#{total}"
+            end
+          end
+        rescue => ex
+          raise "Error transfering #{script_config_filename}: #{ex.message} "
+        end
+        
+        begin
+          Net::SSH.start(instance.dns_name_public, user, :keys => [user_keypairpath(user)]) do |session|
+
+            puts "Running #{script}...".bright
+            session.exec!("chmod 700 ~/#{script_config_filename}")
+            session.exec!("chmod 700 #{script}")
+            puts session.exec!("#{script}")
+      
+            puts "Removing remote copy of #{script_filename}..."
+            session.exec!("rm ~/#{script_config_filename}")
+          end
+        rescue => ex
+          raise "Error executing #{script}: #{ex.message}"
+        end
+      end
+    
+      
+      tf.delete     # remove local copy of config_file
+      #switch_user   # return to the requested user
+    end
+    
+
+    
+  end
+end

data/lib/rudy/routines/shutdown.rb

@@ -0,0 +1,42 @@
+
+
+module Rudy
+  module Routines
+    class Shutdown < Rudy::Routines::Base
+      
+      def shutdown
+        routine = fetch_routine(:shutdown)
+        rmach = Rudy::Instances.new(:config => @config, :global => @global)
+        rmach.destroy do
+          @logger.puts $/, "Running BEFORE scripts...", $/
+          #instances.each { |inst| @script_runner.execute(inst, :shutdown, :before) }
+
+          @logger.puts $/, "Running DISK routines...", $/
+          routine.disks.each_pair do |action,disks|
+
+            unless @rdisks.respond_to?(action)
+              @logger.puts("Skipping unknown action: #{action}").color(:blue)
+              next
+            end
+
+            disks.each_pair do |path,props|
+              props[:path] = path
+              begin
+                @rdisks.send(action, instance, props)
+              rescue => ex
+                @logger.puts ex.message
+                @logger.puts "Continuing..."
+                @logger.puts ex.backtrace if debug?
+              end
+            end
+            
+          end
+        end
+        
+      end
+      
+    end
+  end
+end
+
+      

data/lib/rudy/routines/startup.rb

@@ -0,0 +1,48 @@
+
+
+module Rudy
+  module Routines
+    class Startup < Rudy::Routines::Base
+      
+      
+      def startup(opts={})
+        
+        routine = fetch_routine(:startup)
+        rdisks = Rudy::Disks.new(:config => @config, :global => @global)
+        
+        
+        rmach = Rudy::Instances.new(:config => @config, :global => @global)
+        
+        # TODO: .list for debugging, .create for actual use
+        instances = rmach.list(opts) do |instance| # Rudy::AWS::EC2::Instance objects
+          puts '-'*60
+          puts "Instance: #{instance.awsid.bright} (AMI: #{instance.ami})"
+          puts instance.to_s
+        
+          @logger.puts("Running DISK routines")
+          routine.disks.each_pair do |action,disks|
+        
+            unless rdisks.respond_to?(action)
+              @logger.puts("Skipping unknown action: #{action}").color(:blue)
+              next
+            end
+        
+            disks.each_pair do |path,props|
+              props[:path] = path
+              puts path
+              begin
+                rdisks.send(action, instance, props)
+              rescue => ex
+                @logger.puts "Continuing..."
+              end
+            end
+          end
+        end
+                
+        instances
+      end
+
+
+    end
+  end
+end