rudy 0.6.8 → 0.7.0

data/lib/rudy/cli/machines.rb

@@ -6,11 +6,23 @@ module Rudy
       
       
       def machines
+        # Rudy::Machines.list takes two optional args for adding or 
+        # removing metadata attributes to modify the select query. 
+        # When all is specified we want to find machines in every
+        # environment and role to we remove these attributes from
+        # the select. 
+        more, less = nil, nil
+        less = [:environment, :role] if @option.all
+        
         rmach = Rudy::Machines.new
-        mlist = rmach.list || []
+        mlist = rmach.list(more, less) || []
         if mlist.empty?
-          puts "No machines running in #{current_machine_group}" 
-          puts "Try: #{$0} startup"
+          if @option.all
+            puts "No machines running"
+          else
+            puts "No machines running in #{current_machine_group}" 
+            puts "Try: rudy machines --all"
+          end
         end
         mlist.each do |m|
           puts @@global.verbose > 0 ? m.inspect : m.dump(@@global.format)
@@ -25,8 +37,8 @@ module Rudy
           return
         end
         
-        puts "The following machine metadata will be deleted:"
-        puts dirt.collect {|m| m.name }
+        puts "The following machine metadata will be deleted:".bright
+        puts dirt.collect {|m| m.name.bright }
         execute_check(:medium)
         
         dirt.each do |m|
@@ -44,7 +56,7 @@ module Rudy
         end
         
         # Options to be sent to Net::SSH
-        ssh_opts = { :user => @@global.user || Rudy.sysinfo.user, :debug => nil  }
+        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
@@ -66,18 +78,26 @@ module Rudy
 
         checked = false
         rudy = Rudy::Machines.new
-        lt = rudy.list do |machine|
+        lt = rudy.list 
+        unless lt
+          puts "No machines running in #{rudy.current_machine_group}"
+          exit
+        end
+        lt.each do |machine|
+          machine.update  # make sure we have the latest DNS info
+          
           # 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})"
+            puts machine_separator(machine.name, machine.awsid)
+            puts "Connecting #{ssh_opts[:user].to_s.bright}@#{machine.dns_public} "
+            puts
           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"
+            execute_check(:low) if ssh_opts[:user] == "root"
             checked = true
           end
           

data/lib/rudy/cli/routines.rb

@@ -2,10 +2,15 @@
 
 module Rudy; module CLI;
   class Routines < Rudy::CLI::CommandBase
-  
+    
+    def startup_valid?
+      @rr = Rudy::Routines::Startup.new
+      @rr.raise_early_exceptions
+      true
+    end
     def startup
-      rr = Rudy::Routines::Startup.new
-      rr.execute
+
+      @rr.execute
       
       puts $/, "The following machines are now available:"
       rmach = Rudy::Machines.new
@@ -15,40 +20,83 @@ module Rudy; module CLI;
       
       if @@global.environment == @@config.defaults.environment && 
          @@global.role == @@config.defaults.role
-         puts
-         puts "Try: #{$0} -u root ssh"
+         #puts
+         #puts "Login with: rudy -u root ssh"
       end
       
     end
     
+    def release_valid?
+      @rr = Rudy::Routines::Release.new
+      @rr.raise_early_exceptions
+      true
+    end
     def release
-      rr = Rudy::Routines::Release.new
-      rmach = Rudy::Machines.new
-      startup unless rmach.running?
-      rr.execute
+      machines = @rr.execute
+      
+      unless machines.empty?
+        puts $/, "The following machines were processed:"
+        machines.each do |machine|
+          puts machine.to_s
+        end
+      end
+    end
+    
+    def passthrough_valid?
+      @rr = Rudy::Routines::Passthrough.new(@alias)
+      @rr.raise_early_exceptions
+      true
+    end
+    
+    # All unknown commands are sent here (using Drydock's trawler). 
+    # By default, the generic passthrough routine is executed which
+    # does nothing other than execute the routine config block that
+    # matches +@alias+ (the name used on the command-line). Calling
+    #
+    #     $ rudy unknown
+    #
+    # would end up here because it's an unknown command. Passthrough
+    # then looks for a routine config in the current environment and
+    # role called "unknown". If found, it's executed otherwise it'll
+    # raise an exception.
+    #
+    def passthrough
+      machines = @rr.execute
+      
+      unless machines.empty?
+        puts $/, "The following machines were processed:"
+        machines.each do |machine|
+          puts @@global.verbose > 0 ? machine.inspect : machine.dump(@@global.format)
+        end
+      end
+      
     end
     
+    def shutdown_valid?
+      @rr = Rudy::Routines::Shutdown.new
+      @rr.raise_early_exceptions
+      true
+    end
     def shutdown
-      rr = Rudy::Routines::Shutdown.new
       routine = fetch_routine_config(:shutdown)
-
-      puts "All machines in #{current_machine_group} will be shutdown and"
+      
+      puts "All machines in #{current_machine_group} will be shutdown".bright
       if routine && routine.disks
         if routine.disks.destroy
-          puts "the following filesystems will be destroyed:".color(:red)
+          puts "The following filesystems will be destroyed:".bright
           puts routine.disks.destroy.keys.join($/).bright
         end
       end
       
       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)
+      machines = @rr.execute
+      puts $/, "The following instances have been destroyed:"
+      machines.each do |machine|
+        puts '%s %s ' % [machine.name.bright, machine.awsid]
       end
-      puts "No instances running" if !lt || lt.empty?
+      
+      
     end
     
 

data/lib/rudy/config.rb

@@ -5,19 +5,28 @@ module Rudy
   class Config < Caesars::Config
     require 'rudy/config/objects'
     
-    dsl Rudy::Config::Accounts::DSL
-    dsl Rudy::Config::Defaults::DSL
-    dsl Rudy::Config::Routines::DSL
-    dsl Rudy::Config::Machines::DSL
-    dsl Rudy::Config::Networks::DSL
+    dsl Rudy::Config::Accounts::DSL    
+    dsl Rudy::Config::Defaults::DSL    
+    dsl Rudy::Config::Routines::DSL    # Organized processes
+    dsl Rudy::Config::Machines::DSL    # Organized instances
+    dsl Rudy::Config::Commands::DSL    # Custom SSH commands
+    #dsl Rudy::Config::Networks::DSL    # Network design
+    #dsl Rudy::Config::Controls::DSL    # Network access
+    #dsl Rudy::Config::Services::DSL    # Stuff running on ports
     
-    # TODO: auto-generate in caesars
-    def accounts?; self.respond_to?(:accounts) && !self[:accounts].nil?; end
-    def defaults?; self.respond_to?(:defaults) && !self[:defaults].nil?; end
-    def machines?; self.respond_to?(:machines) && !self[:machines].nil?; end
-    def routines?; self.respond_to?(:routines) && !self[:routines].nil?; end
-    def networks?; self.respond_to?(:networks) && !self[:networks].nil?; end
+    def accounts?; self.respond_to?(:accounts) && !self[:accounts].nil?; end #a
+    def defaults?; self.respond_to?(:defaults) && !self[:defaults].nil?; end #u
+    def machines?; self.respond_to?(:machines) && !self[:machines].nil?; end #t
+    def routines?; self.respond_to?(:routines) && !self[:routines].nil?; end #o
+    def networks?; self.respond_to?(:networks) && !self[:networks].nil?; end #g
+    def controls?; self.respond_to?(:controls) && !self[:controls].nil?; end #e
+    def commands?; self.respond_to?(:commands) && !self[:commands].nil?; end #n
+    def services?; self.respond_to?(:services) && !self[:services].nil?; end #!
     
+    # This method is called by Caesars::Config.refresh for every DSL 
+    # file that is loaded and parsed. If we want to run processing
+    # for a particular config (machines, @routines, etc...) we can
+    # do it here. Just wait until the instance variable is not nil.
     def postprocess
       #raise "There is no AWS info configured" if self.accounts.nil?
       
@@ -26,6 +35,15 @@ module Rudy
       #  self.accounts.aws.cert &&= File.expand_path(self.accounts.aws.cert) 
       #  self.accounts.aws.privatekey &&= File.expand_path(self.accounts.aws.privatekey)
       #end
+      
+      # The commands config modifies the way the routines configs
+      # should be parsed. This happens in the postprocess method
+      # we call here. We can't guarantee this will run before the
+      # routines config is loaded so this postprocess method will
+      # raise a Caesars::Config::ForceRefresh exception if that's
+      # the case. Rudy::Config::Commands knows to only raise the
+      # exception one time (using a boolean flag in a class var).
+      @commands.postprocess if @commands
     end
     
     def look_and_load(adhoc_path=nil)
@@ -77,8 +95,7 @@ module Rudy
             end
           end
           
-          # Global Defaults 
-          # Define the values to use unless otherwise specified on the command-line. 
+          # Global Defaults
           defaults do
             region :"us-east-1" 
             zone :"us-east-1b"

data/lib/rudy/config/objects.rb

@@ -1,29 +1,154 @@
 
 
 class Rudy::Config
-  class Machines < Caesars
+  class Error < Rudy::Error
+    def initialize(ctype, obj)
+      @ctype, @obj = ctype, obj
+    end
+    def message; "Error in #{@ctype}: #{@obj}"; end
+  end
+  class Machines < Caesars; end
+  class Defaults < Caesars; end
+  class Networks < Caesars; end
+  class Controls < Caesars; end
+  class Services < Caesars; end
+  # Modify the SSH command available in routines. The default
+  # set of commands is defined by Rye::Cmd (Rudy executes all
+  # SSH commands via Rye). 
+  #
+  # NOTE: We allow people to define their own keywords. It is
+  # important that new keywords do not conflict with existing
+  # Rudy keywords. Strange things may happen!
+  class Commands < Caesars
+    class PathNotString < Rudy::Config::Error
+      def message; super << " (path must be a String)"; end
+    end
+    class ReservedKeyword < Rudy::Config::Error
+      def message;  "%s (reserved keyword)" % [super]; end
+    end
+    class BadArg < Rudy::Config::Error
+      def message; "Arguments for #{cmd} must be: Symbols, Strings only"; end
+    end
+      
+    @@processed = false
+    forced_array :allow
+    forced_array :deny
+    def init
+      # We can't process the Rye::Cmd commands here because the
+      # DSL hasn't been parsed yet so Rudy::Config.postprocess
+      # called the following postprocess method after parsing.
+    end
+    # Process the directives specified in the commands config.
+    # NOTE: This affects the processing of the routines config
+    # which only works if commands is parsed first. This works
+    # naturally if each config has its own file b/c Rudy loads
+    # files via a glob (globs are alphabetized and "commands"
+    # comes before "routines"). 
+    #
+    # That's obviously not good enough but for now commands
+    # configuration MUST be put before routines. 
+    def postprocess
+      return false if @@processed
+      @@processed = true  # Make sure this runs only once
+      # Parses:
+      # commands do
+      #   allow :kill 
+      #   allow :custom_script, '/full/path/2/custom_script'
+      #   allow :git_clone, "/usr/bin/git", "clone"
+      # end
+      # 
+      # * Tells Routines to force_array on the command name.
+      # This is important b/c of the way we parse commands 
+      self.allow.each do |cmd|
+        cmd, path, *args = *cmd
+        
+        # If no path was specified, we can assume cmd is in the remote path so
+        # when we add the method to Rye::Cmd, we'll it the path is "cmd".
+        path ||= cmd.to_s
+        
+        # We cannot allow new commands to be defined that conflict use known
+        # routines keywords. This is based on keywords in the current config.
+        # NOTE: We can't check for this right now b/c the routines config
+        # won't necessarily have been parsed yet. TODO: Figure it out!
+        #if Caesars.known_symbol_by_glass?(:routines, cmd)
+        #  raise ReservedKeyword.new(:commands, cmd)
+        #end
+        
+        # We can allow existing commands to be overridden but we
+        # print a message to STDERR so the user knows what's up.
+        STDERR.puts "Redefined #{cmd}" if Rye::Cmd.can?(cmd)
+        
+        # The second argument if supplied must be a filesystem path
+        raise PathNotString.new(:commands, cmd) if path && !path.is_a?(String)        
+        
+        # Insert hardcoded arguments if any were supplied. These will
+        # be sent automatically with every call to the new command.
+        # This loop prepares the hardcoded args to be passed to eval.
+        args.collect! do |arg| 
+          klass = [Symbol, String] & [arg.class]
+          raise BadArg.new(:commands, cmd) if klass.empty?
+          # Symbols sent as Symbols, Strings as Strings
+          arg.is_a?(Symbol) ? ":#{arg}" : "'#{arg}'"
+        end
+        hard_args = args.empty? ? "*args" : "#{args.join(', ')}, *args"
+        
+        # Command keywords must be parsed with forced_array. See ScriptHelper.
+        Rudy::Config::Routines.forced_array cmd
+        Rye::Cmd.module_eval %Q{
+          def #{cmd}(*args); cmd(:'#{path}', #{hard_args}); end
+        }
+      end
+      # We deny commands by telling routines to not parse the given keywords
+      self.deny.each do |cmd|
+        Rudy::Config::Routines.forced_ignore cmd.first # cmd is a forced array
+        # We don't remove the method from Rye:Cmd because we 
+        # may need elsewhere in Rudy. Forced ignore ensures
+        # the config is not stored anyhow.
+      end
+      raise Caesars::Config::ForceRefresh.new(:routines)
+    end
   end
-  
   
   class Accounts < Caesars
     def valid?
       (!aws.nil? && !aws.accesskey.nil? && !aws.secretkey.nil?) &&
-      (!aws.account.empty? && !aws.accesskey.empty? && !aws.secretkey.empty?) 
+      (!aws.account.empty? && !aws.accesskey.empty? && !aws.secretkey.empty?)
     end
   end
-
-  class Defaults < Caesars
-  end
-
-  class Networks < Caesars
-  end
   
   class Routines < Caesars
     
+    # Disk routines
     forced_hash :create
     forced_hash :destroy
     forced_hash :restore
     forced_hash :mount
-
+    
+    # Remote scripts
+    forced_hash :before
+    forced_hash :before_local
+    forced_hash :after
+    forced_hash :after_local
+    
+    # Version control systems
+    forced_hash :git
+    forced_hash :svn
+    
+    def init
+      
+    end
+    
+    # Add remote shell commands to the DSL as forced Arrays. 
+    # Example:
+    #     ls :a, :l, "/tmp"  # => :ls => [[:a, :l, "/tmp"]]
+    #     ls :o              # => :ls => [[:a, :l, "/tmp"], [:o]]
+    # NOTE: Beware of namespace conflicts in other areas of the DSL,
+    # specifically shell commands that have the same name as a keyword
+    # we want to use in the DSL. This includes commands that were added
+    # to Rye::Cmd before Rudy is 'require'd. 
+    Rye::Cmd.instance_methods.sort.each do |cmd|
+      forced_array cmd
+    end
+    
   end
 end

data/lib/rudy/disks.rb

@@ -46,7 +46,8 @@ class Disk < Storable
   
   def to_s(with_titles=true)
     update
-    mtd = @mounted ? "mounted" : @status
+    puts "FUCK" if @mounted
+    mtd = @mounted == true ? "mounted" : @status
     "%s; %3sGB; %s; %s" % [liner_note, @size, @device, mtd]
   end
   
@@ -103,12 +104,16 @@ class Disk < Storable
   end
   
   def update
-    return false unless @awsid
-    @volume = @rvol.get(@awsid) 
+    @awsid = nil if @awsid && @awsid.empty?
+    @volume = @rvol.get(@awsid) if @awsid
     if @volume.is_a?(Rudy::AWS::EC2::Volume)
       @status = @volume.status
       @instid = @volume.instid
       save
+    else
+      @awsid, @status, @instid = nil, nil, nil
+      @mounted = false # I don't like having to set this
+      # Don't save it  b/c it's possible the EC2 server is just down
     end
   end
   
@@ -197,52 +202,3 @@ class Disks
 end
 end
 
-
-
-
-__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_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_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_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