rudy 0.3.2 → 0.4.0

data/lib/rudy/command/environment.rb

@@ -1,86 +1,64 @@
 
 
 
-
-
-# :role:
-# :env:
-# :access_key:
-# :secret_key:
-# :dbmachine:
-
-
 module Rudy
   module Command
     class Environment < Rudy::Command::Base
       
+      #---
+      # TODO: http://net-ssh.rubyforge.org/ssh/v1/chapter-4.html
+      #+++
       
-      # 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
+      
+      def connect
+        check_keys
+        machine = find_current_machine
+        if @argv.cmd
+          cmd = @argv.cmd.is_a?(Array) ? @argv.cmd.join(' ') : @argv.cmd
         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
+          cmd = false
         end
         
-      end
+        puts ssh_command(machine[:dns_name], keypairpath, @global.user, cmd, @option.print)
         
-        
-      def connect
+      end
+      
+      def copy_valid?
         check_keys
-        machine = find_current_machine
-        ssh machine[:dns_name], keypairpath, user, false, false, false, @print
+        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(paths)
-        check_keys
+      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
         
-        paths = paths.flatten
-        to_path = paths.pop
+        @option.remote = true if @alias == 'download'
+        @option.remote = false if @alias == 'upload'
         
-        scp machine[:dns_name], keypairpath, user, paths, to_path, @remote, false, @print
+        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
       
       

data/lib/rudy/command/groups.rb

@@ -5,51 +5,53 @@ module Rudy
   module Command
     class Groups < Rudy::Command::Base
       
-      def print_groups(name=nil)
-        name = machine_group if name.nil? && !@all
+      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_group(name=nil)
-        name = machine_group if name.nil?
+      def create_groups(name=@argv.first)
+        name ||= machine_group
+        puts "Creating group #{name}"
         raise "The group #{name} already exists" if @ec2.groups.exists?(name)
 
-        puts "Creating group #{name}"
         @ec2.groups.create(name)
         
-        modify_group name
+        modify_groups name
       end
       
-      def modify_group(name=nil)
-        name = machine_group if name.nil?
+      def modify_groups(name=@argv.first)
+        name ||= machine_group
         raise "The group #{name} does not exist" unless @ec2.groups.exists?(name)
         
-        @addresses = [Rudy::Utils::external_ip_address] if @addresses.nil?
-        @ports = [22,80,443] if @ports.nil?
-        @protocols = ["tcp"] if @protocols.nil?
+        @option.addresses ||= [Rudy::Utils::external_ip_address]
+        @option.ports ||= [22,80,443]
+        @option.protocols ||= ["tcp"]
         
         # Make sure the IP addresses have ranges
-        @addresses.collect! { |ip| (ip.match /\/\d+/) ? ip : "#{ip}/32"  }
+        @option.addresses.collect! { |ip| (ip.match /\/\d+/) ? ip : "#{ip}/32"  }
         
-        @protocols.each do |protocol|
-          puts "Adding ports #{@ports.join(',')} (#{protocol}) for #{@addresses.join(', ')}"
-          @addresses.each do |address|
-            @ports.each do |port|
+        @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
         
-        print_groups name
+        groups name
       end
       
-      def destroy_group(name=nil)
+      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?
         
-        puts "Destroying group #{name}"
         @ec2.groups.destroy(name)
         
       end

data/lib/rudy/command/images.rb

@@ -5,18 +5,32 @@ module Rudy
     class Images < Rudy::Command::Base
       
 
-      def print_images
+      def images
         @ec2.images.list.each do |img|
           print_image img
         end
       end
       
-      def create_image
+      def create_images_valid?
+        puts "Make sure the machine is clean. I don't want archive no crud!"
+        exit unless are_you_sure?
+        true
+      end
+      
+      
+      def prepare_images
+        # TODO: Avail hooks for clean an instance
+        # Clean off Rudy specific crap. 
+      end
+      
+      
+      def create_images
         
-        if @user != "root"
-          puts "This command will be run as root"
-          @user = "root" # We need to be root for this operation!
-        end
+        switch_user("root")
+        
+        puts "TODO: clean transient rudy crap off of instance before making image!!!"
+        # ~/.rudy, /etc/motd, history -c, /etc/hosts, /var/log/rudy*
+        exit
         
         raise "No EC2 .pem keys provided" unless has_pem_keys?
         raise "No SSH key provided for #{keypairname}!" unless has_keypair?(keypairname)
@@ -30,33 +44,34 @@ module Rudy
         
         puts "The new image will be based on #{machine_group}_01"
         
-        @account ||= @account_num
+        @option.account ||= @global.account_num
         
-        unless @account
+        unless @global.account
           puts "Enter your 12 digit Amazon account number:"
-          @account = gets.chomp
+          @global.account = gets.chomp
         end
         
-        unless @image_name
+        unless @option.image_name
           puts "Enter the image name:"
-          @image_name = gets.chomp
+          @option.image_name = gets.chomp
         end
         
-        unless @bucket_name
+        unless @option.bucket_name
           puts "Enter the S3 bucket that will store the image:"
-          @bucket_name = gets.chomp
+          @option.bucket_name = gets.chomp
         end
         
-        scp machine[:dns_name], keypairpath, user, @ec2_cert, "/mnt/"
-        scp machine[:dns_name], keypairpath, user, @ec2_private_key, "/mnt/"
+        scp_command machine[:dns_name], keypairpath, @global.user, @global.cert, "/mnt/"
+        scp_command machine[:dns_name], keypairpath, @global.user, @global.privatekey, "/mnt/"
         
-        ssh machine[:dns_name], keypairpath, user, "ec2-bundle-vol -r i386 -p #{@image_name} -k /mnt/pk-*pem -c /mnt/cert*pem -u #{@account}"
-        ssh machine[:dns_name], keypairpath, user, "ec2-upload-bundle -b #{@bucket_name} -m /tmp/#{@image_name}.manifest.xml -a #{@access_key} -s #{@secret_key}"
+        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}"
+        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}"
         
-        @ec2.images.register("#{@bucket_name}/#{@image_name}.manifest.xml")
+        @ec2.images.register("#{@option.bucket_name}/#{@option.image_name}.manifest.xml")
       end
       
-      def deregister(ami)
+      def deregister
+        ami = @argv.first
         raise "You must supply an AMI ID (ami-XXXXXXX)" unless ami
         puts "Deregistering AMI: #{ami}"
         

data/lib/rudy/command/instances.rb

@@ -1,11 +1,42 @@
-
+# 
+# 
+# 
+# 
+# 
+# 
+# 
+# 
+# 
+# 
+# 
 
 module Rudy
   module Command
     class Instances < Rudy::Command::Base
       
-      def print_instances(filter=nil)
-        filter = machine_group if filter.nil? && !@all
+      def restart_instances_valid?
+        raise "No instance ID provided" if @argv.filter.nil?
+        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)
+        
+        
+        @list = @ec2.instances.list(machine_group)
+        raise "#{@argv.filter} is not in the current machine group" unless @list.has_key?(@argv.filter)
+        
+        raise "I will not help you destroy production!" if @global.environment == "prod" # TODO: use_caution?, locked?
+        
+        exit unless are_you_sure?(5)
+        true
+      end
+      def restart_instances
+        puts "Restarting #{@argv.filter}!"
+        @ec2.instances.restart @argv.filter
+      end
+      
+      def instances
+        filter = @argv.first
+        filter = machine_group if filter.nil? && !@option.all
         if instance_id?(filter)
           inst = @ec2.instances.get(filter)
           raise "The instance #{filter} does not exist" if inst.empty?
@@ -26,9 +57,17 @@ module Rudy
         
       end
       
-      def destroy_instances(filter=nil)
-        raise "No instance ID or group name provided" if filter.nil?
-        raise "I will not help you destroy production!" if @environment == "prod" || filter =~ /^prod/
+      def destroy_instances_valid?
+        filter = argv.first
+        raise "No instance ID provided" if filter.nil?
+        raise "I will not help you destroy production!" if @global.environment == "prod" || filter =~ /^prod/
+        exit unless are_you_sure?
+        true
+      end
+        
+      def destroy_instances
+        filter = argv.first
+
         if @ec2.groups.exists?(filter)
           list = @ec2.instances.list(filter)
           raise "The group #{filter} has no running instances" if list.empty?
@@ -39,92 +78,7 @@ module Rudy
         puts "Destroying #{instance}!"
         @ec2.instances.destroy instance
       end
-      
-      def start_instance
-        @image ||= machine_image
-        
-        @user = "root"
-        
-        rig = @ec2.instances.list(machine_group)
-        raise "There is already an instance running in #{machine_group}" unless rig.empty?
-        raise "No SSH key provided for #{keypairname}!" unless has_keypair?(keypairname)
-        raise "SSH key provided but cannot be found! (#{keypairpath})" unless File.exists?(keypairpath)
-        
-        
-        machine_data = {
-          # Give the machine an identity
-          :zone => @zone,
-          :environment => @environment,
-          :role => @role,
-          :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}"
-        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]
-        
-        if @address
-          puts "Associating #{@address} to #{id}"
-          @ec2.addresses.associate(id, @address)
-        end
-        
-        print "Waiting for #{id} to become available"
-        
-        while @ec2.instances.pending?(id)
-          sleep 2
-          print '.'
-          STDOUT.flush
-        end
-        
-        machine = @ec2.instances.get(id)
-        
-        puts " It's up!"
-        print "Waiting for SSH daemon at #{machine[:dns_name]}"
-        while !Rudy::Utils.service_available?(machine[:dns_name], 22)
-          print '.'
-          STDOUT.flush
-        end
-        puts " It's up!"
-        
-        print "Looking for disk metadata for #{machine[:aws_availability_zone]}... "
-        disks = Rudy::MetaData::Disk.list(@sdb, machine[:aws_availability_zone], @environment, @role, @position)
-        
-        if disks.empty?
-          puts "None"
-        else
-          puts "#{disks.size} disk(s)."
-          disks.each do |disk|
-            
-            do_dirty_disk_volume_deeds(disk, machine)
-          end
-        end
-        
-        puts
-        ssh machine[:dns_name], keypairpath, user, "df -h" # Display current mounts
-        puts 
-        puts "Done!"
-      end
-      
+
     end
   end
 end

data/lib/rudy/command/machines.rb

@@ -0,0 +1,161 @@
+
+
+module Rudy
+  module Command
+    class Machines < Rudy::Command::Base
+      
+
+      def shutdown_valid?
+        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)
+        
+        @list = @ec2.instances.list(machine_group)
+        raise "No machines running in #{machine_group}" unless @list && !@list.empty?
+        
+        raise "I will not help you ruin production!" if @global.environment == "prod" # TODO: use_caution?, locked?
+        
+        true
+      end
+      
+      
+      def shutdown
+        puts "Shutting down #{machine_group}: #{@list.keys.join(', ')}".att(:bright)
+        switch_user("root")
+        puts "This command also affects the volumes attached to the instances! (according to your routines config)"
+        exit unless are_you_sure?(5)
+        
+        execute_routines(@list.values, :shutdown, :before)
+        
+        execute_disk_routines(@list.values, :shutdown)
+        
+        puts "Terminating instances..."
+        @ec2.instances.destroy @list.keys
+        sleep 5
+        
+        execute_routines(@list.values, :shutdown, :after)
+        
+        puts "Done!"
+      end
+      
+      def startup_valid?
+        rig = @ec2.instances.list(machine_group)
+        raise "There is already an instance running in #{machine_group}" if rig && !rig.empty?
+        raise "No SSH key provided for #{keypairname}!" unless has_keypair?
+        true
+      end
+      def startup
+        puts "Starting a machine in #{machine_group}".att(:bright)
+        switch_user("root")
+        exit unless are_you_sure?(3)
+        
+        #execute_routines([], :startup, :before_local)
+        
+        @option.image ||= machine_image
+        
+        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]}"
+          @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, :startup)
+        execute_routines(inst, :startup, :after)
+        
+        puts "Done!"
+      end
+
+      def restart_valid?
+        shutdown_valid?
+      end
+      def restart
+        puts "Restarting #{machine_group}: #{@list.keys.join(', ')}".att(:bright)
+        switch_user("root")
+        exit unless are_you_sure?(5)
+        
+        @list.each do |id, inst|
+          execute_routines(@list.values, :restart, :before)
+        end
+        
+        puts "Restarting instances: #{@list.keys.join(', ')}".att(:bright)
+        @ec2.instances.restart @list.keys
+        sleep 10 # Wait for state to change and SSH to shutdown
+        
+        @list.keys.each do |id|
+          wait_for_machine(id)
+        end
+        
+        execute_disk_routines(@list.values, :restart)
+        
+        @list.each do |id, inst|
+          execute_routines(@list.values, :restart, :after)
+        end
+        
+        puts "Done!"
+      end
+      
+      
+      def status_valid?
+        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)
+        
+        @list = @ec2.instances.list(machine_group)
+        raise "No machines running in #{machine_group}" unless @list
+        true
+      end
+      def status
+        puts "There are no machines running in #{machine_group}" if @list.empty?
+        @list.each_pair do |id, inst|
+          print_instance inst
+        end
+      end
+      
+      
+      #def update_valid?
+      #  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)
+      #  
+      #  @script = File.join(RUDY_HOME, 'support', 'rudy-ec2-startup')
+      #  
+      #  raise "Cannot find startup script" unless File.exists?(@script)
+      #  
+      #  
+      #  true
+      #end
+      #
+      #
+      #def update
+      #  puts "Updating Rudy "
+      #  switch_user("root")
+      #  
+      #  exit unless are_you_sure?
+      #  scp do |scp|
+      #    puts "Updating Rudy startup script (#{@script})"
+      #    scp.upload!(@script, "/etc/init.d/") do |ch, name, sent, total|
+      #      puts "#{name}: #{sent}/#{total}"
+      #    end
+      #  end
+      #  
+      #  ssh do |session|
+      #    session.exec!("chmod 700 /etc/init.d/rudy-ec2-startup")
+      #    puts "Installing Rudy (#{Rudy::VERSION})"
+      #    puts session.exec!("gem sources -a http://gems.github.com")
+      #    puts session.exec!("gem install --no-ri --no-rdoc solutious-rudy -v #{Rudy::VERSION}")
+      #  end
+      #end
+      
+      
+    end
+  end
+end
+
+