solutious-rudy 0.8.5 → 0.9.0

data/lib/rudy/routines/handlers/group.rb

@@ -0,0 +1,42 @@
+
+module Rudy; module Routines; module Handlers;
+  module Group
+    include Rudy::Routines::Handlers::Base
+    extend self
+    
+    ##Rudy::Routines.add_handler :machines, self
+    
+    
+    def raise_early_exceptions(name=nil)
+      
+    end
+    
+    def create(name=nil)
+      name ||= current_group_name
+      return if exists? name
+      li "Creating group: #{name}"
+      Rudy::AWS::EC2::Groups.create name
+    end
+    
+    def authorize(name=nil, addresses=nil, ports=nil)
+      name ||= current_group_name
+      addresses ||= [Rudy::Utils::external_ip_address]
+      ports ||= [[22,22]]
+      li "Authorizing group: #{addresses.inspect} (#{ports.inspect})"
+      Rudy::AWS::EC2::Groups.authorize(name, addresses, ports)
+    end
+    
+    def exists?(name=nil)
+      name ||= current_group_name
+      Rudy::AWS::EC2::Groups.exists? name
+    end
+    
+    def destroy(name=nil)
+      name ||= current_group_name
+      return unless exists? name
+      li "Destroying group: #{name}"
+      Rudy::AWS::EC2::Groups.destroy name
+    end
+    
+  end
+end; end; end

data/lib/rudy/routines/handlers/host.rb

@@ -0,0 +1,72 @@
+
+module Rudy; module Routines; module Handlers;
+  module Host
+    include Rudy::Routines::Handlers::Base
+    extend self 
+    
+    ## NOTE: This handler doesn't use Rudy::Routines.add_handler
+    
+    def is_running?(rset)
+      raise NoMachines if rset.boxes.empty?
+      rset.batch(rset.parallel) do |parallel|
+        msg = "Starting #{self.nickname}..."
+        output = parallel ? nil : Rudy::Huxtable.logger 
+        Rudy::Utils.waiter(3, 120, output, msg, 0) {
+          inst = self.stash.get_instance
+          inst && inst.running?
+        }
+      end
+    end
+    
+    # Add instance info to machine and save it. This is really important
+    # for the initial startup so the metadata is updated right away. But
+    # it's also important to call here because if a routine was executed
+    # and an unexpected exception occurs before this update is executed
+    # the machine metadata won't contain the DNS information. Calling it
+    # here ensure that the metadata is always up-to-date.
+    # Each Rye:Box instance has a Rudy::Machine instance in its stash so
+    # self.stash.update == machine.update
+    def update_dns(rset)
+      raise NoMachines if rset.boxes.empty?
+      rset.batch do 
+        self.stash.refresh! 
+        self.host = self.stash.dns_public
+      end
+    end
+    
+    def is_available?(rset, port=22)
+      raise NoMachines if rset.boxes.empty?
+      rset.batch(rset.parallel, port) do |parallel,p|
+        # Windows machines do not have an SSH daemon
+        unless (self.stash.os || '').to_s == 'win32'
+          msg = parallel ? nil : "Waiting for SSH on port #{p}..."
+          Rudy::Utils.waiter(2, 30, STDOUT, msg, 0) {
+            Rudy::Utils.service_available?(self.stash.dns_public, p)
+          }
+        end
+      end
+    end
+    
+    def set_hostname(rset)
+      raise NoMachines if rset.boxes.empty?
+      original_user = rset.user
+      rset.add_key user_keypairpath('root')
+      rset.switch_user 'root'
+      # Set the hostname if specified in the machines config. 
+      # :rudy -> change to Rudy's machine name
+      # :default -> leave the hostname as it is
+      # Anything else other than nil -> change to that value
+      # NOTE: This will set hostname every time a routine is
+      # run so we may want to make this an explicit action.
+      type = current_machine_hostname || :rudy
+      rset.batch(type) do |hn|
+        if hn != :default
+          hn = self.stash.name if hn == :rudy
+          self.quietly { hostname(hn) }
+        end
+      end
+      rset.switch_user original_user
+    end
+    
+  end
+end; end; end

data/lib/rudy/routines/handlers/keypair.rb

@@ -0,0 +1,70 @@
+
+module Rudy; module Routines; module Handlers;
+  module Keypair
+    include Rudy::Routines::Handlers::Base
+    extend self
+    
+    ##Rudy::Routines.add_handler :machines, self
+    
+    
+    def raise_early_exceptions(name=:root)
+      keyname = user_keypairname name
+      kp_file = pkey name
+      if registered? keyname
+        # This means no keypair file can be found
+        raise PrivateKeyNotFound, keyname if kp_file.nil?
+        # This means we found a keypair in the config but we cannot find the private key file. 
+        raise PrivateKeyNotFound, kp_file if !File.exists?(kp_file)
+      else
+        raise PrivateKeyFileExists, kp_file if File.exists?(kp_file)
+      end 
+    end
+    
+    def create(name=:root)
+      keyname = user_keypairname name
+      kp_file = pkey name
+      kp = nil
+      if registered? keyname 
+        raise PrivateKeyNotFound, keyname if kp_file.nil?
+        raise PrivateKeyNotFound, kp_file if !File.exists?(kp_file)
+      else
+        raise PrivateKeyFileExists, kp_file if File.exists?(kp_file)
+        li "Creating keypair: #{keyname}"
+        kp = Rudy::AWS::EC2::Keypairs.create(keyname)
+        li "Saving #{kp_file}"
+        Rudy::Utils.write_to_file(kp_file, kp.private_key, 'w', 0600)
+      end
+      kp
+    end
+    
+    def unregister(name=:root)
+      keyname = user_keypairname name
+      raise "Keypair not registered: #{keyname}" unless registered?(name)
+      Rudy::AWS::EC2::Keypairs.destroy keyname
+    end
+    
+    def delete_pkey(name=:root)
+      kp_file = pkey name
+      raise PrivateKeyNotFound, kp_file unless pkey?(name)
+      File.unlink kp_file
+    end
+    
+    def exists?(name=:root)
+      registered?(name) && pkey?(name)
+    end
+    
+    def registered?(name=:root)
+      keyname = user_keypairname name
+      Rudy::AWS::EC2::Keypairs.exists?( keyname) rescue false
+    end
+    
+    def pkey(name=:root)
+      user_keypairpath name
+    end
+    
+    def pkey?(name=:root)
+      File.exists? pkey(name)
+    end
+    
+  end
+end; end; end

data/lib/rudy/routines/handlers/machines.rb

@@ -0,0 +1,15 @@
+
+module Rudy; module Routines; module Handlers;
+  module Machines
+    include Rudy::Routines::Handlers::Base
+    extend self
+    
+    ##Rudy::Routines.add_handler :machines, self
+    
+    
+    def raise_early_exceptions
+    end
+    
+    
+  end
+end; end; end

data/lib/rudy/routines/handlers/script.rb

@@ -0,0 +1,85 @@
+
+
+module Rudy; module Routines; module Handlers;
+  module Script
+    include Rudy::Routines::Handlers::Base 
+    extend self
+    
+    Rudy::Routines.add_handler :local,  self
+    Rudy::Routines.add_handler :remote, self
+    
+    Rudy::Routines.add_handler :xlocal,  self
+    Rudy::Routines.add_handler :xremote, self
+    
+    def raise_early_exceptions(type, batch, rset, lbox, argv=nil)
+      
+    end
+    
+    def execute(type, batch, rset, lbox, argv=nil)
+      if type.to_s =~ /\Ax/  
+        # do nothing
+        
+      # It's important this stay a regex rather than a literal comparison
+      elsif type.to_s =~ /local/   
+        lbox.cd Dir.pwd
+        batch = { lbox.user => batch } if batch.is_a?(Proc)
+        execute_command(batch, lbox, argv)
+      else
+        batch = { rset.user => batch } if batch.is_a?(Proc)
+        raise NoMachines if rset.boxes.empty?
+        execute_command(batch, rset, argv)
+      end
+    end
+
+    
+  private  
+
+    # * +batch+ a single routine hash (startup, shutdown, etc...)
+    # * +robj+ an instance of Rye::Set or Rye::Box 
+    # * +argv+ command line args
+    def execute_command(batch, robj, argv=nil)
+      
+      original_user = robj.user
+      original_dir = robj.current_working_directory
+
+      batch.each_pair do |user, proc|
+        
+        # The error doesn't apply to the local Rye::Box instance
+        if robj.is_a?(Rye::Set) && !File.exists?(user_keypairpath(user) || '')
+          le "Cannot find key for #{user}: #{user_keypairpath(user)}"
+        end
+        
+        if user.to_s != robj.user
+          begin
+            ld "Switching user to: #{user} (was: #{robj.user})"
+            ld "(key: #{user_keypairpath(user)})"
+            
+            robj.add_key user_keypairpath(user)
+            robj.switch_user user
+            
+          rescue Net::SSH::AuthenticationFailed, Net::SSH::HostKeyMismatch => ex  
+            STDERR.puts "Error connecting: #{ex.message}".color(:red)
+            STDERR.puts "Skipping user #{user}".color(:red)
+            next
+          end
+        end
+        
+        ### EXECUTE THE COMMANDS BLOCK
+        begin
+          robj.batch(argv, &proc)
+        ensure
+          robj.enable_safe_mode            # In case it was disabled
+          robj.switch_user original_user   # Return to the user it was provided with          
+          robj.cd                          # reset to home dir
+          robj.cd original_dir             # return to previous directory
+        end
+        
+      end
+      
+      
+      
+      
+    end
+  end
+  
+end;end;end

data/lib/rudy/routines/handlers/user.rb

@@ -0,0 +1,41 @@
+
+module Rudy; module Routines; module Handlers;
+  module User
+    include Rudy::Routines::Handlers::Base
+    extend self 
+    
+    Rudy::Routines.add_handler :adduser, self
+    Rudy::Routines.add_handler :authorize, self
+    
+    def raise_early_exceptions(type, user, rset, lbox, argv=nil)
+      
+    end
+    
+    def execute(type, user, rset, lbox, argv=nil)
+      raise NoMachines if rset.boxes.empty?
+      send(type, user, rset)
+    end
+    
+    def adduser(user, robj)
+      
+      # On Solaris, the user's home directory needs to be specified
+      # explicitly so we do it for linux too for fun. 
+      homedir = robj.guess_user_home(user.to_s)
+      args = [:m, :d, homedir, :s, '/bin/bash', user.to_s]
+      
+      # NOTE: We'll may to use platform specific code here. 
+      # Linux has adduser and useradd commands:
+      # adduser can prompt for info which we don't want. 
+      # useradd does not prompt (on Debian/Ubuntu at least). 
+      # We need to specify bash b/c the default is /bin/sh
+      robj.useradd(args)
+    end
+    
+    def authorize(user, robj)
+      robj.authorize_keys_remote(user.to_s)
+    end
+    
+    
+  end
+  
+end; end; end

data/lib/rudy/routines/passthrough.rb

@@ -1,36 +1,32 @@
 
-
 module Rudy; module Routines;
   class Passthrough < Rudy::Routines::Base
     
     def init(*args)
-      @routine = fetch_routine_config(@cmdname)
+      @machines = Rudy::Machines.list || []
+      @@rset = create_rye_set @machines unless defined?(@@rset)
     end
     
-    # * +each_mach+ is an optional block which is executed between 
-    # disk creation and the after scripts. The will receives two 
-    # arguments: instances of Rudy::Machine and Rye::Box.
-    def execute(&each_mach)
-      routine_separator(@cmdname)
-      machines = []
-      generic_machine_runner(:list) do |machine,rbox|
-        puts $/ #, "[routine: #{@cmdname}]"
-        machines << machine
-      end
-      machines
+    def execute
+      ld "Executing routine: #{@name}"
+      return @machines unless run?
+      Rudy::Routines::Handlers::Depends.execute_all @before
+      Rudy::Routines.runner(@routine, @@rset, @@lbox, @argv)
+      Rudy::Routines::Handlers::Depends.execute_all @after
+      @machines
     end
-
+    
     # Called by generic_machine_runner
     def raise_early_exceptions
-      raise Rudy::Error, "No routine name" unless @cmdname
-      raise NoRoutine, @cmdname unless @routine
-      # TODO: enable this for EC2 groups only
-      #raise Rudy::PrivateKeyNotFound, root_keypairpath unless has_keypair?(:root)
-      raise MachineGroupNotDefined, current_machine_group unless known_machine_group?
-      ##rmach = Rudy::Machines.new
-      ##if !@@global.offline && !rmach.running?
-      ##  raise MachineGroupNotRunning, current_machine_group
-      ##end
+      raise Rudy::Error, "No routine name" unless @name
+      raise NoRoutine, @name unless @routine
+      ##raise MachineGroupNotDefined, current_machine_group unless known_machine_group?
+      # Call raise_early_exceptions for each handler used in the routine
+      @routine.each_pair do |action,definition|
+        raise NoHandler, action unless Rudy::Routines.has_handler?(action)
+        handler = Rudy::Routines.get_handler action
+        handler.raise_early_exceptions(action, definition, @@rset, @@lbox, @argv)
+      end
     end
     
   end

data/lib/rudy/routines/reboot.rb

@@ -3,73 +3,104 @@
 module Rudy; module Routines;
   class Reboot < Rudy::Routines::Base
     
+    Rudy::Routines.add_routine :reboot, self
+    
+    @@allowed_actions = [:before, :disks, :adduser, :authorize,
+                         :before_local, :before_remote, 
+                         :local, :remote, :after]
+                         
     def init(*args)
-      @routine = fetch_routine_config(:reboot)
+      @routine ||= {}
     end
     
-    # * +each_mach+ is an optional block which is executed between 
-    # disk creation and the after scripts. The will receives two 
-    # arguments: instances of Rudy::Machine and Rye::Box.
-    def execute(&each_mach)
-      routine_separator(:reboot)
-      unless @routine
-        STDERR.puts "[this is a generic reboot routine]"
-        @routine = {}
+    # Startup routines run in the following order:
+    # * before_local (if present)
+    # * before_remote (if present)
+    # * Reboot instances
+    # * Set hostname
+    # * before dependencies
+    # * all other actions
+    # * after dependencies
+    def execute
+      ld "Executing routine: #{@name}"
+      ld "[this is a generic routine]" if @routine.empty?
+
+      
+      # If this is a testrun we won't create new instances
+      # we'll just grab the list of machines in this group. 
+      # NOTE: Expect errors if there are no machines.
+      @machines = run? ? Rudy::Machines.restart : Rudy::Machines.list
+      @@rset = create_rye_set @machines unless defined?(@@rset)
+      
+      if run?
+        if @routine.has_key? :before_local
+          handler = Rudy::Routines.get_handler :local
+          Rudy::Routines.rescue {
+            handler.execute(:local, @routine.delete(:before_local), nil, @@lbox, @argv)
+          }
+        end
+      
+        if @routine.has_key? :before_remote
+          handler = Rudy::Routines.get_handler :remote
+          Rudy::Routines.rescue {
+            handler.execute(:remote, @routine.delete(:before_remote), @@rset, @@lbox, @argv)
+          }
+        end
       end
-      machines = []
-      generic_machine_runner(:list) do |machine,rbox|
-        puts $/, "Rebooting...", $/
-        rbox.disconnect unless rbox.nil?
-        machine.restart
-        sleep 4
-        msg = preliminary_separator("Checking if instance is running...")
-        Rudy::Utils.waiter(3, 120, STDOUT, msg, 0) {
-          machine.running?
-        } 
       
-        # Add instance info to machine and save it. This is really important
-        # for the initial startup so the metadata is updated right away. But
-        # it's also important to call here because if a routine was executed
-        # and an unexpected exception occurs before this update is executed
-        # the machine metadata won't contain the DNS information. Calling it
-        # here ensure that the metadata is always up-to-date. 
-        machine.update 
-        
-        sleep 4
-        
-        msg = preliminary_separator("Waiting for SSH daemon...")
-        Rudy::Utils.waiter(3, 120, STDOUT, msg, 0) {
-          Rudy::Utils.service_available?(machine.dns_public, 22)
-        }
-        
-        # NOTE: THIS IS INCOMPLETE
-        
-        sleep 1  # Avoid IOError: closed stream on SSH
-        
+      Rudy::Routines.rescue {
+        if !Rudy::Routines::Handlers::Host.is_running? @@rset
+          a = @@rset.boxes.select { |box| !box.stash.running? }
+          raise GroupNotRunning, a
+        end
+      }
+      
+      # This is important b/c the machines will not 
+      # have DNS info until after they are running. 
+      Rudy::Routines.rescue { Rudy::Routines::Handlers::Host.update_dns @@rset }
       
-        if Rudy::Routines::DiskHelper.disks?(@routine)         # disk
-          task_separator("DISKS")
-          if rbox.ostype == "sunos"
-            puts "Sorry, Solaris is not supported yet!"
-          else
-            Rudy::Routines::DiskHelper.execute(@routine, machine, rbox)
-          end    
+      Rudy::Routines.rescue {
+        if !Rudy::Routines::Handlers::Host.is_available? @@rset
+          a = @@rset.boxes.select { |box| !box.stash.available? }
+          raise GroupNotAvailable, a
         end
-
-        machines << machine
+      }
+      Rudy::Routines.rescue {
+        Rudy::Routines::Handlers::Host.set_hostname @@rset      
+      }
+      
+      if run?
+        # This is the meat of the sandwich
+        Rudy::Routines.runner @routine, @@rset, @@lbox, @argv
+        
+        Rudy::Routines.rescue {
+          Rudy::Routines::Handlers::Depends.execute_all @after
+        }
       end
-      machines
+      
+      @machines
     end
 
     # Called by generic_machine_runner
     def raise_early_exceptions
-      rmach = Rudy::Machines.new
+      raise NoMachinesConfig unless @@config.machines
       # There's no keypair check here because Rudy::Machines will attempt 
       # to create one.
       raise MachineGroupNotDefined, current_machine_group unless known_machine_group?
-      raise MachineGroupNotRunning, current_machine_group unless rmach.running?
+      
+      # If this is a test run we don't care if the group is running
+      if run?
+        raise MachineGroupNotRunning, current_machine_group unless Rudy::Machines.running?
+      end
+      
+      if @routine
+        bad = @routine.keys - @@allowed_actions
+        raise UnsupportedActions.new(@name, bad) unless bad.empty?
+      end
     end
     
   end
 
-end; end
+end; end
+
+