solutious-rudy 0.4.0

data/lib/rudy/command/config.rb

@@ -0,0 +1,77 @@
+
+
+module Rudy
+  module Command
+    class Config < Rudy::Command::Base
+      
+      # We force the Command::Base#print_header to be quiet
+      def print_header
+        @global.quiet = true
+        super
+      end
+      
+      
+      # Display configuration from the local user data file (~/.rudy/config).
+      # 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 mostly useful for
+      # debugging and checking configuration on an instance itself).
+      #
+      # It will return the most specific configuration available. If the 
+      # attribute isn'e found it will check each parent for the same attribute. 
+      # i.e. if [prod][app][ami] is not available, it will check [prod][ami]
+      # and then [ami]. 
+      #
+      #     # Display the value for a specific machine.
+      #     $ rudy -e prod -r db config param-name
+      #
+      #     # Display all configuration
+      #     $ rudy config --all
+      #
+      def config
+        return if @config.nil? 
+        puts "Config: #{@config.paths}" if @global.verbose > 0
+        
+        which = @option.defaults ? @global.user : machine_name
+        puts "Machine: #{which}" if @global.verbose > 0
+        puts "User: #{@global.user}" if @global.verbose > 0
+        
+        return if @config.empty?
+        
+        # We need to check whether we're running on a human's computer
+        # or within EC2 (we call that running "in-situ"). The userdata
+        # available when running in-situ is in a different format.
+        if Rudy.in_situ?
+          
+          
+        else
+          
+          if @option.all
+            y @config.machines.to_hash
+            y @config.routines.to_hash
+          elsif @option.defaults
+            y @config.defaults.to_hash
+          else
+            env, rol, usr, att = @global.environment, @global.role, @global.user, @argv.name
+            val = @config.machines.find_deferred(env, rol, usr, att) || ''
+            puts (val.is_a?(String)) ? val : val.to_hash.to_yaml
+          end
+          
+          #name = @argv.first
+          #if name && @config.userdata.has_key?(which) 
+          #  value = @config.userdata[which][name.to_s]
+          #  puts value if value
+          #elsif @option.all
+          #  puts @config.to_yaml
+          #else
+          #  value = @config.userdata[which] 
+          #  puts value.to_yaml if value
+          #end
+        end
+        
+      end
+    end
+  end
+end

data/lib/rudy/command/deploy.rb

@@ -0,0 +1,12 @@
+
+
+
+
+module Rudy
+  module Command
+    class Deploy < Rudy::Command::Base
+      
+    end
+  end
+end
+  

data/lib/rudy/command/disks.rb

@@ -0,0 +1,213 @@
+
+
+module Rudy
+  module Command
+    class Disks < Rudy::Command::Base
+      
+      def disk
+        criteria = [@global.zone]
+        criteria += [@global.environment, @global.role] unless @option.all
+        Rudy::MetaData::Disk.list(@sdb, *criteria).each do |disk|
+          backups = Rudy::MetaData::Backup.for_disk(@sdb, disk, 2)
+          print_disk(disk, backups)
+        end
+      end
+
+      def create_disk_valid?
+        raise "No filesystem path specified" unless @option.path
+        raise "No size specified" unless @option.size
+        @instances = @ec2.instances.list(machine_group)
+        raise "There are no instances running in #{machine_group}" if !@instances || @instances.empty?
+        true
+      end
+      
+      def create_disk
+        puts "Creating #{@option.path} for #{machine_group}"
+        switch_user("root")
+        exit unless are_you_sure?(2) 
+        machine = @instances.values.first # NOTE: DANGER! Should handle position.
+        
+        disk = Rudy::MetaData::Disk.new
+        [:region, :zone, :environment, :role, :position].each do |n|
+          disk.send("#{n}=", @global.send(n)) if @global.send(n)
+        end
+        [:path, :device, :size].each do |n|
+          disk.send("#{n}=", @option.send(n)) if @option.send(n)
+        end
+        
+        raise "Not enough info was provided to define a disk (#{disk.name})" unless disk.valid?
+        raise "The device #{disk.device} is already in use on that machine" if Rudy::MetaData::Disk.is_defined?(@sdb, disk)
+        # TODO: Check disk path
+        puts "Creating disk metadata for #{disk.name}"
+        
+        
+        
+        puts "Creating volume... (#{disk.size}GB in #{@global.zone})"
+        volume = @ec2.volumes.create(@global.zone, disk.size)
+        sleep 3
+        
+        disk.awsid = volume[:aws_id]
+        disk.raw_volume = true    # This value is not saved. 
+        Rudy::MetaData::Disk.save(@sdb, disk)
+        
+        execute_attach_disk(disk, machine)
+        
+        print_disk(disk)
+      end
+      
+      
+      def destroy_disk_valid?
+        raise "No disk specified" if argv.empty?
+        
+        if @argv.diskname =~ /^disk-/          
+          @disk = Rudy::MetaData::Disk.get(@sdb, @argv.diskname)
+        else
+          disk = Rudy::MetaData::Disk.new
+          [:zone, :environment, :role, :position].each do |n|
+            disk.send("#{n}=", @global.send(n)) if @global.send(n)
+          end
+          disk.path = @argv.diskname
+          @disk = Rudy::MetaData::Disk.get(@sdb, disk.name)
+        end
+
+        raise "No such disk: #{@argv.diskname}" unless @disk
+        raise "The disk is in another machine environment" unless @global.environment.to_s == @disk.environment.to_s
+        raise "The disk is in another machine role" unless @global.role.to_s == @disk.role.to_s
+        @instances = @ec2.instances.list(machine_group)
+        true
+      end
+      
+      def destroy_disk
+        puts "Destroying #{@disk.name} and #{@disk.awsid}"
+        switch_user("root")
+        exit unless are_you_sure?(5)
+        
+        machine = @instances.values.first # NOTE: DANGER! Should handle position. 
+        
+        execute_unattach_disk(@disk, machine)
+        execute_destroy_disk(@disk, machine)
+        
+        puts "Done."
+      end
+
+      def attach_disk_valid?
+        destroy_disk_valid?
+        raise "There are no instances running in #{machine_group}" if !@instances || @instances.empty?
+        true
+      end
+      
+      def attach_disk
+        puts "Attaching #{name}"
+        switch_user("root")
+        are_you_sure?(4)
+  
+        machine = @instances.values.first  # AK! Assumes single machine
+        
+        execute_attach_disk(@disk, machine)
+
+        puts
+        ssh_command machine[:dns_name], keypairpath, @global.user, "df -h" # Display current mounts
+        puts 
+
+        puts "Done!"
+      end
+
+
+
+
+       def unattach_disk_valid?
+         destroy_disk_valid?
+         true
+       end
+
+       def unattach_disk
+         puts "Unattaching #{@disk.name} from #{machine_group}"
+         switch_user("root")
+         are_you_sure?(4)
+         
+         machine = @instances.values.first
+
+         execute_unattach_disk(@disk, machine)
+
+         puts "Done!"
+       end
+
+
+
+      def execute_unattach_disk(disk, machine)
+        begin
+          
+          if machine
+            puts "Unmounting #{disk.path}...".att(:bright)
+            ssh_command machine[:dns_name], keypairpath, global.user, "umount #{disk.path}"
+            sleep 1
+          end
+          
+          if @ec2.volumes.attached?(disk.awsid)
+            puts "Unattaching #{disk.awsid}".att(:bright)
+            @ec2.volumes.detach(disk.awsid)
+            sleep 5
+          end
+          
+        rescue => ex
+          puts "Error while unattaching volume #{disk.awsid}: #{ex.message}"
+          puts ex.backtrace if Drydock.debug?
+        end
+      end
+      
+      def execute_destroy_disk(disk, machine)
+        begin
+          
+          if disk
+            
+            if disk.awsid && @ec2.volumes.available?(disk.awsid)
+              puts "Destroying #{disk.path} (#{disk.awsid})".att(:bright)
+              @ec2.volumes.destroy(disk.awsid)
+            end
+            
+          end
+          
+        rescue => ex
+          puts "Error while destroying volume #{disk.awsid}: #{ex.message}"
+          puts ex.backtrace if Drydock.debug?
+        ensure
+          puts "Deleteing metadata for #{disk.name}".att(:bright)
+          Rudy::MetaData::Disk.destroy(@sdb, disk)
+        end
+      end
+      
+      def execute_attach_disk(disk, machine)
+        begin
+          unless @ec2.instances.attached_volume?(machine[:aws_instance_id], disk.device)
+            puts "Attaching #{disk.awsid} to #{machine[:aws_instance_id]}".att(:bright)
+            @ec2.volumes.attach(machine[:aws_instance_id], disk.awsid, disk.device)
+            sleep 3
+          end
+          
+          if disk.raw_volume
+            puts "Creating the filesystem (mkfs.ext3 -F #{disk.device})".att(:bright)
+            ssh_command machine[:dns_name], keypairpath, @global.user, "mkfs.ext3 -F #{disk.device}"
+            sleep 1
+          end
+          
+          puts "Mounting #{disk.path} to #{disk.device}".att(:bright)
+          ssh_command machine[:dns_name], keypairpath, @global.user, "mkdir -p #{disk.path} && mount -t ext3 #{disk.device} #{disk.path}"
+
+          sleep 1
+        rescue => ex
+          puts "There was an error attaching #{disk.name}: #{ex.message}"
+          puts ex.backtrace if Drydock.debug?
+        end
+      end
+      
+    end
+  end
+end
+
+
+__END__
+
+    
+
+
+

data/lib/rudy/command/environment.rb

@@ -0,0 +1,74 @@
+
+
+
+module Rudy
+  module Command
+    class Environment < Rudy::Command::Base
+      
+      #---
+      # TODO: http://net-ssh.rubyforge.org/ssh/v1/chapter-4.html
+      #+++
+      
+      
+      def connect
+        check_keys
+        machine = find_current_machine
+        if @argv.cmd
+          cmd = @argv.cmd.is_a?(Array) ? @argv.cmd.join(' ') : @argv.cmd
+        else
+          cmd = false
+        end
+        
+        ret = ssh_command(machine[:dns_name], keypairpath, @global.user, cmd, @option.print)
+        puts ret if ret  # ssh command returns false with "ssh_exchange_identification: Connection closed by remote host"
+        
+      end
+      
+      def copy_valid?
+        check_keys
+        raise "No path specified (rudy copy FROM-PATH [FROM-PATH ...] TO-PATH)" unless argv.size >= 2
+        true
+      end
+      
+      # +paths+ an array of paths to copy. The last element is the "to" path. 
+      def copy
+        machine = find_current_machine
+
+        paths = @argv
+        dest_path = paths.pop
+        
+        if @option.print
+          scp_command machine[:dns_name], keypairpath, @global.user, paths, dest_path, @option.remote, false, @option.print
+          return
+        end
+        
+        @option.remote = true if @alias == 'download'
+        @option.remote = false if @alias == 'upload'
+        
+        if @alias == 'scp' || @alias == 'copy'
+          @alias = 'download' if @option.remote
+          @alias = 'upload' unless @option.remote
+        end
+        
+        scp do |scp|
+          transfers = paths.collect { |path| 
+            scp.send(@alias, path, dest_path) do |ch, name, sent, total|
+               #TODO: Nice printing in place
+                #puts "#{name}: #{sent}/#{total}"
+            end
+            
+          }
+          transfers.each { |trans| trans.wait }
+        end
+      end
+      
+      
+
+      
+    end
+  end
+end
+
+__END__
+
+

data/lib/rudy/command/groups.rb

@@ -0,0 +1,61 @@
+
+
+
+module Rudy
+  module Command
+    class Groups < Rudy::Command::Base
+      
+      def groups(name=@argv.first)
+        name = machine_group if name.nil? && !@option.all
+        @ec2.groups.list(name).each do |grp|
+          print_group grp
+        end
+      end
+      
+      def create_groups(name=@argv.first)
+        name ||= machine_group
+        puts "Creating group #{name}"
+        raise "The group #{name} already exists" if @ec2.groups.exists?(name)
+
+        @ec2.groups.create(name)
+        
+        modify_groups name
+      end
+      
+      def modify_groups(name=@argv.first)
+        name ||= machine_group
+        raise "The group #{name} does not exist" unless @ec2.groups.exists?(name)
+        
+        @option.addresses ||= [Rudy::Utils::external_ip_address]
+        @option.ports ||= [22,80,443]
+        @option.protocols ||= ["tcp"]
+        
+        # Make sure the IP addresses have ranges
+        @option.addresses.collect! { |ip| (ip.match /\/\d+/) ? ip : "#{ip}/32"  }
+        
+        @option.protocols.each do |protocol|
+          puts "Adding ports #{@option.ports.join(',')} (#{protocol}) for #{@option.addresses.join(', ')}"
+          @option.addresses.each do |address|
+            @option.ports.each do |port|
+              @ec2.groups.modify(name, port, port, protocol, address)
+            end
+          end
+        end
+        
+        groups name
+      end
+      
+      def destroy_groups(name=@argv.first)
+        name ||= machine_group
+        puts "Destroying group #{name}"
+        name = machine_group if name.nil?
+        raise "The group #{name} does not exist" unless @ec2.groups.exists?(name)
+        exit unless are_you_sure?
+        
+        @ec2.groups.destroy(name)
+        
+      end
+    end
+  end
+end
+

data/lib/rudy/command/images.rb

@@ -0,0 +1,99 @@
+
+
+module Rudy
+  module Command
+    class Images < Rudy::Command::Base
+      
+
+      def images
+        @ec2.images.list.each do |img|
+          print_image img
+        end
+      end
+      
+      def create_images_valid?
+        puts "Make sure the machine is clean. I don't want archive no crud!"
+        switch_user("root")
+        
+          raise "No EC2 .pem keys provided" unless has_pem_keys?
+          raise "No SSH key provided for #{@global.user}!" unless has_keypair?
+          raise "No SSH key provided for root!" unless has_keypair?(:root)
+        true
+      end
+      
+      
+      def prepare_images
+        # TODO: Avail hooks for clean an instance
+        # Clean off Rudy specific crap. 
+      end
+      
+      
+      def create_images
+        puts "Creating image from #{machine_group}"
+        
+        # ~/.rudy, /etc/motd, history -c, /etc/hosts, /var/log/rudy*
+        
+        are_you_sure?(2)
+        
+        
+        machine_list = @ec2.instances.list(machine_group)
+        machine = machine_list.values.first  # NOTE: Only one machine per group, for now...
+
+        raise "There's no machine running in #{machine_group}" unless machine
+        raise "The primary machine in #{machine_group} is not in a running state" unless machine[:aws_state] == 'running'
+        
+        puts "The new image will be based on #{machine_group}_01"
+        
+        @option.account ||= @config.awsinfo.account
+        
+        unless @option.account
+          puts "Enter your 12 digit Amazon account number:"
+          @global.account = gets.chomp
+        end
+        
+        unless @option.image_name
+          puts "Enter the image name:"
+          @option.image_name = gets.chomp
+        end
+        
+        unless @option.bucket_name
+          puts "Enter the S3 bucket that will store the image:"
+          @option.bucket_name = gets.chomp
+        end
+        
+        unless @option.print
+          puts "Copying .pem keys to /mnt (they will not be included in the AMI)"
+          scp_command machine[:dns_name], keypairpath, @global.user, @global.cert, "/mnt/"
+          scp_command machine[:dns_name], keypairpath, @global.user, @global.privatekey, "/mnt/"
+        end
+        
+        ssh do |session|
+          session.exec!("touch /root/firstrun")
+        end
+        
+        puts "Starting bundling process...".att(:bright)
+        puts ssh_command(machine[:dns_name], keypairpath, @global.user, "ec2-bundle-vol -r i386 -p #{@option.image_name} -k /mnt/pk-*pem -c /mnt/cert*pem -u #{@option.account}", @option.print)
+        puts ssh_command(machine[:dns_name], keypairpath, @global.user, "ec2-upload-bundle -b #{@option.bucket_name} -m /tmp/#{@option.image_name}.manifest.xml -a #{@global.accesskey} -s #{@global.secretkey}", @option.print)
+
+        @ec2.images.register("#{@option.bucket_name}/#{@option.image_name}.manifest.xml") unless @option.print
+      end
+      
+      def deregister
+        ami = @argv.first
+        raise "You must supply an AMI ID (ami-XXXXXXX)" unless ami
+        puts "Deregistering AMI: #{ami}"
+        
+        are_you_sure?
+        
+        if @ec2.images.deregister(ami)
+          puts "Done!"
+        else
+          puts "There was an unknown problem!"
+        end
+        
+      end
+      
+    end
+  end
+end
+