solutious-rudy 0.5.1 → 0.6.0

data/lib/rudy/metadata/disk.rb

@@ -1,149 +0,0 @@
-
-
-module Rudy
-  module MetaData
-    class Disk < Storable
-      include Rudy::Huxtable
-      
-        # This is a flag used internally to specify that a volume has been
-        # created for this disk, but not yet formated. 
-      attr_accessor :raw_volume
-      
-      field :rtype
-      field :awsid
-      
-      field :environment
-      field :role
-      field :path
-      field :position
-      
-      field :zone
-      field :region
-      field :device
-      #field :backups => Array
-      field :size
-      
-      def initialize
-        @backups = []
-        @raw_volume = false
-        @rtype = Disk.rtype
-      end
-      
-      def self.rtype
-        'disk'
-      end
-      
-      def name
-        Disk.generate_name(@zone, @environment, @role, @position, @path)
-      end
-      
-      def Disk.generate_name(zon, env, rol, pos, pat, sep=File::SEPARATOR)
-        pos = pos.to_s.rjust 2, '0'
-        dirs = pat.split sep if pat
-        dirs.shift while dirs && (dirs[0].nil? || dirs[0].empty?)
-        ["disk", zon, env, rol, pos, *dirs].join(RUDY_DELIM)
-      end
-      
-      def valid?
-        @zone && @environment && @role && @position && @path && @size && @device
-      end
-      
-      def to_query(more=[], remove=[])
-        criteria = [:rtype, :zone, :environment, :role, :position, :path, *more]
-        criteria -= [*remove].flatten
-        query = []
-        criteria.each do |n|
-          val = self.send(n.to_sym)
-          query << "['#{n}' = '#{self.send(n.to_sym)}'] " if val # Only add attributes with values
-        end
-        query.join(" intersection ")
-      end
-      
-      def to_select
-        
-      end
-      
-      def save
-        @@sdb.store(RUDY_DOMAIN, name, self.to_hash, :replace) # Always returns nil
-        true
-      end
-      
-      def destroy
-        @@sdb.destroy(RUDY_DOMAIN, name)
-        true
-      end
-      
-      def refresh
-        h = @@sdb.get(RUDY_DOMAIN, name) || {}
-        from_hash(h)
-      end
-      
-      def Disk.get(dname)
-        h = @@sdb.get(RUDY_DOMAIN, dname) || {}
-        from_hash(h)
-      end
-      
-      def is_mounted?
-        
-      end
-      
-      
-      def format(instance)
-        raise "No instance supplied" unless instance
-        raise "Disk not valid" unless self.valid?
-
-        begin
-          puts "Creating the filesystem (mkfs.ext3 -F #{disk.device})".bright
-          ssh_command instance.dns_name_public, current_user_keypairpath, @global.user, "mkfs.ext3 -F #{disk.device}"
-          sleep 1
-        rescue => ex
-          @logger.puts ex.backtrace if debug?
-          raise "Error formatting #{disk.path}: #{ex.message}"
-        end
-        true
-      end
-      def mount(instance)
-        raise "No instance supplied" unless instance
-        disk = find_disk(opts[:disk] || opts[:path])
-        raise "Disk #{opts[:disk] || opts[:path]} cannot be found" unless disk
-        switch_user(:root)
-        begin
-          puts "Mounting #{disk.device} to #{disk.path}".bright
-          ssh_command instance.dns_name_public, current_user_keypairpath, @global.user, "mkdir -p #{disk.path} && mount -t ext3 #{disk.device} #{disk.path}"
-        rescue => ex
-          @logger.puts ex.backtrace if debug?
-          raise "Error mounting #{disk.path}: #{ex.message}"
-        end
-        true
-      end
-
-      def unmount(instance)
-        raise "No instance supplied" unless instance
-        disk = find_disk(opts[:disk] || opts[:path])
-        raise "Disk #{opts[:disk] || opts[:path]} cannot be found" unless disk
-        switch_user(:root)
-        begin
-          puts "Unmounting #{disk.path}...".bright
-          ssh_command instance.dns_name_public, current_user_keypairpath, global.user, "umount #{disk.path}"
-          sleep 1
-        rescue => ex
-          @logger.puts ex.backtrace if debug?
-          raise "Error unmounting #{disk.path}: #{ex.message}"
-        end
-        true
-      end
-      
-      def to_s
-        str = ""
-        field_names.each do |key|
-          str << sprintf(" %22s: %s#{$/}", key, self.send(key.to_sym))
-        end
-        str
-      end
-       
-      
-    end
-    
-  end
-
-end

data/lib/rudy/metadata/machine.rb

@@ -1,34 +0,0 @@
-
-
-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/disk_handler.rb

@@ -1,190 +0,0 @@
-
-
-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/script_runner.rb

@@ -1,65 +0,0 @@
-
-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/test/50_commands/00_setup_test.rb

@@ -1,11 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'helper')
-
-module Rudy::Test
-  class Case_50_Commands < Test::Unit::TestCase
-    include Rudy::AWS  
-    
-    @@logger = StringIO.new
-    
-
-  end
-end

data/test/50_commands/10_keypairs_test.rb

@@ -1,79 +0,0 @@
-
-module Rudy::Test
-  class Case_50_Commands
-    
-
-    context "#{name}_10 KeyPairs" do
-      setup do
-        @rkey = Rudy::KeyPairs.new(:logger => @@logger)
-        # So we can test with and without user specified keypairs
-        # (stage should have keypairs configured in ./.rudy/config or Rudyfile)
-        @rkey.global.environment = :test
-        stop_test !@rkey.is_a?(Rudy::KeyPairs), "We need Rudy::KeyPairs (#{@rkey})"
-      end
-      
-      teardown do
-        #if @@logger && @@logger.is_a?(StringIO)
-        #  @@logger.rewind
-        #  puts @@logger.read
-        #end
-      end
-      
-      should "(10) create a keypair" do
-        stop_test @rkey.any?, "Delete existing keypairs"
-        kp = @rkey.create
-        assert kp.is_a?(Rudy::AWS::EC2::KeyPair)
-        assert @rkey.exists?(kp.name), "KeyPair not registered with Amazon"
-        assert File.exists?(@rkey.path), "No private key: #{@rkey.path}"
-        assert File.exists?(@rkey.public_path), "No public key: #{@rkey.public_path}"
-      end
-      
-      should "(11) create a keypair with an arbitrary name" do
-        n = "test-%s" % Rudy::Utils.strand
-        kp = @rkey.create(n)
-        assert kp.is_a?(Rudy::AWS::EC2::KeyPair)
-        assert @rkey.exists?(kp.name), "KeyPair not registered with Amazon"
-        assert File.exists?(@rkey.path(n)), "No private key: #{@rkey.path(n)}"
-        assert File.exists?(@rkey.public_path(n)), "No public key: #{@rkey.public_path(n)}"
-      end
-      
-      should "(12) not create keypair if one exists" do
-        assert @rkey.exists?, "No #{@rkey.name} KeyPair"
-        begin; kp = @rkey.create; rescue; end # Quiet, you!
-        assert kp.nil?, "Keypair was still created"
-      end
-      
-      should "(13) not create keypair if a root keypair is defined in config" do
-        assert_equal (@rkey.global.environment = :keypairtest), :keypairtest # stage needs keypairs configured
-        assert @rkey.has_root_keypair?, "No root keypair path defined in config"
-        begin; kp = @rkey.create; rescue => ex; end
-        assert kp.nil?, "Keypair was still created"
-      end
-      
-      should "(20) list keypairs" do
-        # We assume we've created more than one keypair before this point
-        assert @rkey.any?, "No keypairs"
-        assert (kp_list = @rkey.list).is_a?(Array), "List not an Array"
-        assert kp_list.size > 1, "List not greater than 1 (#{kp_list.size})"
-        assert (kp_hash = @rkey.list_as_hash).is_a?(Hash), "List not a Hash"
-      end
-      
-      should "(30) find existing keypair for current machine group" do
-        assert !(test_kp = @rkey.user_keypairpath(:root)).nil?, "Test keypair is nil"
-        @rkey.global.environment = :keypairtest # user_keypairpath will now look at the stage
-        assert !(stage_kp = @rkey.user_keypairpath(:root)).nil?, "keypairtest keypair is nil"
-        assert test_kp != stage_kp, "Test and Stage keypairs are the same (#{test_kp}, #{stage_kp})"
-      end
-      
-      should "(99) destroy keypairs" do
-        assert @rkey.any?, "No keypairs registered"
-        @rkey.list.each { |kp| assert @rkey.destroy(kp.name), "Not destroyed #{kp.name}" }
-        assert !File.exists?(@rkey.path), "Still exists: #{@rkey.path}"
-        assert !File.exists?(@rkey.public_path), "Still exists: #{@rkey.public_path}"
-      end
-      
-      
-    end
-  
-  end
-end

data/test/50_commands/20_groups_test.rb

@@ -1,77 +0,0 @@
-
-module Rudy::Test
-  class Case_50_Commands
-    
-
-    context "#{name}_20 Groups" do
-      setup do
-        @rgroup = Rudy::Groups.new(:logger => @@logger)
-        stop_test !@rgroup.is_a?(Rudy::Groups), "We need Rudy::Groups (#{@rgroup})"
-      end
-      
-      teardown do
-        #if @@logger && @@logger.is_a?(StringIO)
-        #  @@logger.rewind
-        #  puts @@logger.read
-        #end
-      end
-      
-      should "(10) create a group" do
-        stop_test @rgroup.any?, "Delete existing Groups"
-        group = @rgroup.create
-        assert group.is_a?(Rudy::AWS::EC2::Group)
-        assert @rgroup.exists?(group.name), "Group not registered with Amazon"
-        assert_equal group.name, @rgroup.name
-        # We don't check the rules because we do that in the lower
-        # level tests for Rudy::AWS::EC2::Groups. 
-      end
-      
-      should "(11) create a group with an arbitrary name" do
-        n = "test-%s" % Rudy::Utils.strand
-        group = @rgroup.create(n)
-
-        assert group.is_a?(Rudy::AWS::EC2::Group)
-        assert @rgroup.exists?(group.name), "Group #{group.name} not registered with Amazon"
-        assert_equal group.name, n
-      end
-      
-      
-      should "(20) list groups" do
-        assert @rgroup.any?, "No groups"
-        assert @rgroup.exists?, "No #{@rgroup.name} group"
-        
-        kp_list = @rgroup.list
-        assert kp_list.is_a?(Array), "List not an Array"
-        
-        kp_hash = @rgroup.list_as_hash
-        assert kp_hash.is_a?(Hash), "List not a Hash"
-      end
-      
-      should "(30) not create group if one exists" do
-        assert @rgroup.exists?, "No #{@rgroup.name} Group"
-        begin
-          group = @rgroup.create
-        rescue # Quiet, you!
-        end
-        assert group.nil?, "Group was still created"
-      end
-      
-      xshould "(40) modify group rules" do
-        
-      end
-      
-      should "(99) destroy groups" do
-        assert @rgroup.exists?, "Group #{@rgroup.name} doesn't exist"
-        @rgroup.list.each do |group|
-          next if group.name == 'default'
-          assert @rgroup.destroy(group.name), "Did not destroy #{group.name}"
-        end
-        assert !@rgroup.exists?, "Group #{@rgroup.name} still exists"
-      end
-      
-      
-    end
-  
-  
-  end
-end

data/test/50_commands/40_volumes_test.rb

@@ -1,55 +0,0 @@
-
-
-module Rudy::Test
-  class Case_50_Commands
-    
-    context "#{name}_40 Volumes" do
-      
-      setup do
-        @rvol = Rudy::Volumes.new(:logger => @@logger)
-        stop_test !@rvol.is_a?(Rudy::Volumes), "We need Rudy::Volumes (#{@rvol})"
-      end
-      
-      should "(10) create a volume" do
-        volume_size = 2
-        #stop_test @rvol.any?(:available), "Destroy existing volumes"
-        volume = @rvol.create(volume_size)
-        assert volume.is_a?(Rudy::AWS::EC2::Volume), "Not a Volume"
-        # Should use the global zone by default
-        assert_equal @rvol.global.zone.to_s, volume.zone, "Zone incorrect: #{volume.zone}"
-        assert_equal volume_size.to_i, volume.size.to_i, "Size incorrect: #{volume.size}"
-        # Rudy::Volume should wait until the volume is available before returning
-        assert volume.available?, "Volume not available (#{volume.status})"
-      end
-      
-      should "(11) list a volume as available" do
-        
-      end
-      
-      should "(20) list volumes" do
-         volume_list = @rvol.list
-         assert volume_list.is_a?(Array), "Not an Array"
-         assert volume_list.size > 0, "No Volumes in Array"
-
-         volume_hash = @rvol.list_as_hash
-         assert volume_hash.is_a?(Hash), "Not a Hash"
-         assert volume_hash.keys.size > 0, "No Volumes in Hash"
-
-         assert_equal volume_list.size.to_i, volume_hash.keys.size.to_i, "Hash and Array not equal size"
-       end
-       
-      should "(90) destroy volumes" do
-        assert @rvol.any?, "No volumes"
-        volume_list = @rvol.list
-        volume_list.each do |vol|
-          next unless vol.available?
-          ret = @rvol.destroy(vol.awsid)
-          assert ret, "Not destroyed (#{ret} for #{vol.awsid})"
-          assert @rvol.deleting?(vol.awsid), "Volume not in deleting state (#{vol.awsid}: #{vol.state})"
-        end
-      end
-    end
-    
-  end
-end
-