solutious-rudy 0.5.1 → 0.6.0

data/lib/rudy/cli/disks.rb

@@ -2,124 +2,34 @@
 
 module Rudy
   module CLI
-    class Disks < Rudy::CLI::Base
+    class Disks < Rudy::CLI::CommandBase
 
-      def disk
-        puts "Disks".bright
-        opts = {}
-        [:all, :path, :device, :size].each do |v| 
-          opts[v] = @option.send(v) if @option.respond_to?(v)
-        end
-        if @argv.diskname
-          key = @argv.diskname =~ /^disk-/ ? :name : :path
-          opts[key] = @argv.diskname
-        end
-
-        rdisks = Rudy::Disks.new(:config => @config, :global => @global)
-        disks = rdisks.list(opts)
-        raise "No disks." unless disks
-        #rbacks = Rudy::Backups.new(:config => @config, :global => @global)
-        disks.each_pair do |diskid, disk|
-          #backups = rbacks.list_by_disk(disk, 2)
-          print_disk(disk)
-        end
-      end
-      
-      def print_disk(disk, backups=[])
-        return unless disk
-        puts '-'*60
-        puts "Disk: #{disk.name.bright}"
-        puts disk.to_s
-        puts "#{backups.size} most recent backups:", backups.collect { |back| "#{back.nice_time} (#{back.awsid})" }
-        puts
-      end
-      
-      def create_disk_valid?
-        raise "No filesystem path specified" unless @option.path
-        raise "No size specified" unless @option.size
-        raise "No device specified" unless @option.device
-        true
-      end
       
-      def create_disk
-        puts "Creating Disk".bright
-        exit unless Annoy.are_you_sure?(:low)
-        opts = {}
-        [:path, :device, :size, :group].each do |v| 
-          opts[v] = @option.send(v) if @option.respond_to?(v)
-        end
-        opts[:id] = @option.awsid if @option.awsid
-        opts[:id] &&= [opts[:id]].flatten
-        
-        @global.debug = true
-        rmachines = Rudy::Instances.new(:config => @config, :global => @global)
-        rmachines.list(opts).each_pair do |id,machine|
-          rdisks = Rudy::Disks.new(:config => @config, :global => @global)
-          disk = rdisks.create(machine, opts)
-          print_disk(disk) if disk
+      def disks
+        rdisk = Rudy::Disks.new
+        rdisk.list do |d|
+          puts @@global.verbose > 0 ? d.inspect : d.dump(@@global.format)
         end
       end
       
-      
-      def destroy_disk_valid?
-        raise "No disk specified" unless @argv.diskname
-
-        true
-      end
-      
-      def destroy_disk
-        puts "Destroying Disk".bright
-        exit unless Annoy.are_you_sure?(:medium)
-        opts = {}
-        if @argv.diskname
-          key = @argv.diskname =~ /^disk-/ ? :name : :path
-          opts[key] = @argv.diskname
-        end
-        
-        # TODO: This is fucked! Store the machine info with the disk metadata.
-        # Get all disks that match the request and destroy them.
-        rmachines = Rudy::Instances.new(:config => @config, :global => @global)
-        rmachines.list(opts).each_pair do |id,machine|
-          rdisks = Rudy::Disks.new(:config => @config, :global => @global)
-          rdisks.destroy(machine, opts)
+      def disks_wash
+        rdisk = Rudy::Disks.new
+        dirt = (rdisk.list || [])#.select { |d| d.available? }
+        if dirt.empty?
+          puts "Nothing to wash in #{rdisk.current_machine_group}"
+          return
         end
         
-        puts "Done."
-      end
+        puts "The following disk metadata will be deleted:"
+        puts dirt.collect {|d| d.name }
+        execute_check(:medium)
 
-      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")
-        exit unless Annoy.are_you_sure?(:medium)
-  
-        machine = @instances.values.first  # AK! Assumes single machine
+        dirt.each do |d|
+          d.destroy(:force)
+        end
         
-        execute_attach_disk(@disk, machine)
-
-        puts
-        ssh_command machine[:dns_name], keypairpath, @global.user, "df -h" # Display current mounts
-        puts 
-
-        puts "Done!"
       end
-
-
-
       
     end
   end
-end
-
-
-__END__
-
-    
-
-
-
+end

data/lib/rudy/cli/machines.rb

@@ -0,0 +1,94 @@
+
+
+module Rudy
+  module CLI
+    class Machines < Rudy::CLI::CommandBase
+      
+      
+      def machines
+        rmach = Rudy::Machines.new
+        mlist = rmach.list || []
+        if mlist.empty?
+          puts "No machines running in #{current_machine_group}" 
+          puts "Try: #{$0} startup"
+        end
+        mlist.each do |m|
+          puts @@global.verbose > 0 ? m.inspect : m.dump(@@global.format)
+        end
+      end
+      
+      def machines_wash
+        rmach = Rudy::Machines.new
+        dirt = (rmach.list || []).select { |m| !m.running? }
+        if dirt.empty?
+          puts "Nothing to wash in #{rmach.current_machine_group}"
+          return
+        end
+        
+        puts "The following machine metadata will be deleted:"
+        puts dirt.collect {|m| m.name }
+        execute_check(:medium)
+        
+        dirt.each do |m|
+          m.destroy
+        end
+        
+      end
+      
+      
+      def ssh
+        # TODO: Give this methos a good look over
+        pkey = user_keypairpath(@@global.user)
+        unless pkey
+          puts "No private key configured for #{@@global.user} in #{current_machine_group}"
+        end
+        
+        # Options to be sent to Net::SSH
+        ssh_opts = { :user => @@global.user || Rudy.sysinfo.user, :debug => nil  }
+        if pkey 
+          raise "Cannot find file #{pkey}" unless File.exists?(pkey)
+          raise InsecureKeyPermissions, @pkey unless File.stat(pkey).mode == 33152
+          ssh_opts[:keys] = pkey 
+        end
+
+
+        # The user specified a command to run. We won't create an interactive
+        # session so we need to prepare the command and its arguments
+        if @argv.first
+          command, command_args = @argv.shift, @argv || []
+          puts "#{command} #{command_args.join(' ')}" if @@global.verbose > 1
+
+        # otherwise, we'll open an ssh session or print command
+        else
+          command, command_args = :interactive_ssh, @option.print.nil?
+        end
+
+
+        checked = false
+        rudy = Rudy::Machines.new
+        lt = rudy.list do |machine|
+          # Print header
+          if @@global.quiet
+            print "You are #{ssh_opts[:user].to_s.bright}. " if !checked # only the 1st
+          else
+            print "Connecting #{ssh_opts[:user].to_s.bright}@#{machine.dns_public} "
+            puts "#{machine.name} (#{machine.awsid})"
+          end
+
+          # Make sure we want to run this command on all instances
+          if !checked && command != :interactive_ssh 
+            execute_check(:medium) if ssh_opts[:user] == "root"
+            checked = true
+          end
+          
+          # Open the connection and run the command
+          rbox = Rye::Box.new(machine.dns_public, ssh_opts)
+          ret = rbox.send(command, command_args)
+          puts ret unless command == :interactive_ssh
+        end
+      end
+
+
+    end
+  end
+end

data/lib/rudy/cli/routines.rb

@@ -1,80 +1,57 @@
 
-module Rudy
-  module CLI
-    class Routines < Rudy::CLI::Base
 
-    
-    
-      def startup_valid?
-        true
-      end
-      def startup
-        puts "Starting a machine group".bright
-        opts = {}
-        opts[:ami] = @option.image if @option.image
-        opts[:group] = @option.group if @option.group
-        #exit unless Annoy.are_you_sure?
-
-        rroutine = Rudy::Routines::Startup.new(:config => @config, :global => @global)
-        instances = rroutine.startup(opts)
-
-        puts "Done!"
+module Rudy; module CLI;
+  class Routines < Rudy::CLI::CommandBase
+  
+    def startup
+      rr = Rudy::Routines::Startup.new
+      rr.execute
+      
+      puts $/, "The following machines are now available:"
+      rmach = Rudy::Machines.new
+      rmach.list do |machine|
+        puts machine.to_s
       end
-
-
-
-
-      def restart_valid?
-        shutdown_valid?
+      
+      if @@global.environment == @@config.default.environment && 
+         @@global.role == @@config.default.role
+         puts
+         puts "Try: #{$0} -u root ssh"
       end
-      def restart
-        puts "Restarting #{machine_group}: #{@list.keys.join(', ')}".bright
-        switch_user("root")
-        exit unless Annoy.are_you_sure?(:medium)
-
-        @list.each do |id, inst|
-          execute_routines(@list.values, :restart, :before)
-        end
-
-        puts "Restarting instances: #{@list.keys.join(', ')}".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
+    
+    def release
+      rr = Rudy::Routines::Release.new
+      rmach = Rudy::Machines.new
+      startup unless rmach.running?
+      rr.execute
+    end
+    
+    def shutdown
+      rr = Rudy::Routines::Shutdown.new
+      routine = fetch_routine_config(:shutdown)
+
+      puts "All machines in #{current_machine_group} will be shutdown and"
+      if routine && routine.disks
+        if routine.disks.destroy
+          puts "the following filesystems will be destroyed:".color(:red)
+          puts routine.disks.destroy.keys.join($/).bright
         end
-
-        puts "Done!"
       end
-
-
-
-
-
-      def shutdown_valid?
-        raise "Cannot specify both instance ID and group name" if @argv.awsid && @option.group
-        raise "I will not help you ruin production!" if @global.environment == "prod" # TODO: use_caution?, locked?
-        true
-      end
-      def shutdown
-        puts "Shutting down a machine group".bright
-        opts = {}
-        opts[:group] = @option.group if @option.group
-        opts[:id] = @argv.awsid if @argv.awsid
-        opts[:id] &&= [opts[:id]].flatten
       
-        msg = opts[:id] ? "instances: #{opts[:id].join(', ')}" : (opts[:group] ? "group: #{opts[:group]}" : '')
-        puts "This command also affects the disks on these machines! (according to your routines config)"
-        #exit unless Annoy.are_you_sure?(:medium)        # TODO: Check if instances are running before this
-        
-        puts "TBD"
+      execute_check :medium
+      
+      rr.execute
+      
+      rinst = Rudy::AWS::EC2::Instances.new(@@global.accesskey, @@global.secretkey, @@global.region)
+      lt = rinst.list_group(current_machine_group, :any) do |inst|
+        puts @@global.verbose > 0 ? inst.inspect : inst.dump(@@global.format)
       end
+      puts "No instances running" if !lt || lt.empty?
     end
+    
+
   end
-end
+end; end
+

data/lib/rudy/cli.rb

@@ -2,141 +2,156 @@
 require 'drydock'
 
 module Rudy
-  class UnknownInstance < RuntimeError #:nodoc
-  end
-end
-
-module Rudy
-  
+    
+  # = CLI
+  # 
+  # These classes provide the functionality for the Command
+  # line interfaces. See the bin/ files if you're interested. 
   # 
   module CLI
     class NoCred < RuntimeError #:nodoc
     end
     
-    class Base < Drydock::Command
-
+    class Output < Storable
+      # TODO: Use for all CLI responses
+      # Messages and errors should be in @@global.format
+      # Should print messages as they come
+    end
+    
+    class CommandBase < Drydock::Command
+      include Rudy::Huxtable
+      
       attr_reader :config
       
     protected
       def init
+
+        # The CLI wants output!
+        Rudy::Huxtable.update_logger STDOUT
         
-        # This is duplicated in Huxtable :[
-        String.disable_color if @global.nocolor
-        Rudy.enable_quiet if @global.quiet
-        
-        @config = Rudy::Config.new
-        @config.look_and_load(@global.config)
+        # Send The Huxtables the global values from the command-line
+        Rudy::Huxtable.update_global @global
         
-        unless !@config.empty? && @config.accounts? && @config.accounts.aws && @config.accounts.aws.accesskey
+        unless @@global.accesskey && @@global.secretkey
           STDERR.puts "No AWS credentials. Check your configs!"
-          STDERR.puts "Try: #{$0} init"
+          STDERR.puts "Try: rudy init"
           exit 1
         end
-                
-        # EVERYTHING BELOW THIS LINE IS ATROCIOUS 
-        
-        # These are here so we can print the machine group shit in the header. 
-        # The dupilcation annoys me (see Rudy::Huxtable#init_globals) and I'd
-        # like to find a cleaner solution. 
-        if @config.defaults
-          @global.region ||= @config.defaults.region 
-          @global.zone ||= @config.defaults.zone 
-          @global.environment ||= @config.defaults.environment
-          @global.role ||= @config.defaults.role 
-          @global.position ||= @config.defaults.position 
-          @global.user ||= @config.defaults.user
-        end
         
-        @global.region ||= DEFAULT_REGION
-        @global.zone ||= DEFAULT_ZONE
-        @global.environment ||= DEFAULT_ENVIRONMENT
-        @global.role ||= DEFAULT_ROLE
-        @global.position ||= DEFAULT_POSITION
-        @global.user ||= DEFAULT_USER
-        
-        
-        if @global.verbose > 1
-          puts "CONFIGS: ", @config.paths, $/
-          
-          puts "GLOBALS:"
-          @global.marshal_dump.each_pair do |n,v|
-            puts "#{n}: #{v}"
-          end
-          ["machines", "routines"].each do |type|
-            puts "#{$/*2}#{type.upcase}:"
-            val = @config.send(type).find_deferred(@global.environment, @global.role)
-            puts val.to_hash.to_yaml if val
-          end
-          puts
-        end
-        
-        if @global.environment =~ /^prod/ && Drydock.debug?
-          puts Rudy.banner("PRODUCTION ACCESS IS DISABLED IN DEBUG MODE")
+        if @@global.environment =~ /^prod/ && Drydock.debug?
+          puts Rudy::Utils.banner("PRODUCTION ACCESS IS DISABLED IN DEBUG MODE")
           exit 1
         end
-
-        
-        # TODO: enforce home directory permissions
-        #if File.exists?(RUDY_CONFIG_DIR)
-        #  puts "Checking #{check_environment} permissions..."
-        #end
         
       end
       
+      def execute_action(emsg="Failed", &action)
+        begin
+          ret = action.call
+          raise emsg unless ret
+          ret
+        rescue Rudy::AWS::EC2::NoAMI => ex
+          raise Drydock::OptError.new('-a', @alias)
+        end
+      end
+      
+      def execute_check(level=:medium)
+        ret = Annoy.are_you_sure?(level)
+        exit 0 unless ret
+        ret
+      end
       
       # Print a default header to the screen for every command.
       #
       def print_header
-        puts Rudy::CLI.generate_header(@global, @config)
-        unless @global.quiet
-          puts # a new line
-          
-          if @global.environment == "prod"
+        
+        # Send The Huxtables the global values again because they could be
+        # updated after initialization but before the command was executed
+        Rudy::Huxtable.update_global @global
+        
+        puts Rudy::CLI.generate_header(@@global, @@config) if @@global.print_header
+        
+        unless @@global.quiet
+          if @@global.environment == "prod"
             msg = "YOU ARE PLAYING WITH PRODUCTION"
-            puts Rudy.banner(msg, :huge, :red), $/
+            puts Rudy::Utils.banner(msg, :huge, :red), $/
           end
-        
-          puts Rudy.banner("THIS IS EC2"), $/ if Rudy.in_situ?
+          puts Rudy::Utils.banner("THIS IS EC2"), $/ if Rudy.in_situ?
         end
       end
       
-
     end
 
-
-
     def self.generate_header(global, config)
+      return "" if global.quiet
       header = StringIO.new
-      title = "RUDY v#{Rudy::VERSION}" unless global.quiet
+      title, name = "RUDY v#{Rudy::VERSION}", config.accounts.aws.name
       now_utc = Time.now.utc.strftime("%Y-%m-%d %H:%M:%S")
       criteria = []
-      [:zone, :environment, :role, :position].each do |n|
-        val = global.send(n)
+      [:region, :zone, :environment, :role, :position].each do |n|
+        key, val = n.to_s.slice(0,1).att, global.send(n) 
+        key = 'R' if n == :region
         next unless val
-        criteria << "#{n.to_s.slice(0,1).att :normal}:#{val.to_s.bright}"
+        criteria << "#{key.att}:#{val.to_s.bright}"
       end
       if config.accounts && config.accounts.aws
-        header.puts '%s -- %s -- %s UTC' % [title, config.accounts.aws.name, now_utc] unless global.quiet
-        header.puts '[%s]' % criteria.join("  ") unless global.quiet
+        if global.verbose > 0
+          header.puts '%s -- %s -- %s UTC' % [title, name, now_utc]
+        end
+        header.puts '[%s]' % [criteria.join("  ")], $/
       end
-      
       header.rewind
       header.read
     end
 
 
-  end
-end
+    # A base for all Drydock executables (bin/rudy etc...). 
+    class Base
+      extend Drydock
+      
+      before do |obj|
+        # Don't print Rudy header unless requested to
+        obj.global.print_header = false  if (obj.global.verbose == 0)
+        @start = Time.now
+      end
 
-# Require EC2, S3, Simple DB class
-begin
-  # TODO: Use autoload
-  Dir.glob(File.join(RUDY_LIB, 'rudy', 'cli', "*.rb")).each do |path|
-    require path
+      after do |obj|  
+        if obj.global.verbose > 0
+          puts
+          @elapsed = Time.now - @start
+          puts "Elapsed: %.2f seconds" % @elapsed.to_f if @elapsed > 0.1
+        end
+      end
+      
+      
+      # These globals are used by all bin/ executables
+      global :A, :accesskey, String, "AWS Access Key"
+      global :S, :secretkey, String, "AWS Secret Access Key"
+      global :R, :region, String, "Amazon service region (ie: #{Rudy::DEFAULT_REGION})"
+      global :z, :zone, String, "Amazon Availability zone (ie: #{Rudy::DEFAULT_ZONE})"
+      global :u, :user, String, "Provide a username (ie: #{Rudy::DEFAULT_USER})"
+      global :k, :pkey, String, "Path to the private SSH key"
+      global :f, :format, String, "Output format"
+      global :n, :nocolor, "Disable output colors"
+      global :C, :config, String, "Specify another configuration file to read (ie: #{Rudy::CONFIG_FILE})"
+      global :Y, :yes, "Assume a correct answer to confirmation questions"
+      global :q, :quiet, "Run with less output"
+      global :v, :verbose, "Increase verbosity of output (i.e. -v or -vv or -vvv)" do
+        @verbose ||= 0
+        @verbose += 1
+      end
+      global :V, :version, "Display version number" do
+        puts "Rudy version: #{Rudy::VERSION}"
+        exit 0
+      end
+      
+    end
+    
+    
   end
-rescue LoadError => ex
-  puts "Error: #{ex.message}"
-  exit 1
+
 end
 
+Rudy::Utils.require_glob(RUDY_LIB, 'rudy', 'cli', '**', '*.rb')
+
 

data/lib/rudy/config/objects.rb

@@ -19,49 +19,11 @@ class Rudy::Config
   end
   
   class Routines < Caesars
+    
+    forced_hash :create
+    forced_hash :destroy
+    forced_hash :restore
+    forced_hash :mount
 
-    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
 end