solutious-rudy 0.8.5 → 0.9.0

data/lib/rudy/routines/helpers/scripthelper.rb

@@ -1,197 +0,0 @@
-require 'tempfile'
-
-module Rudy; module Routines; 
-  #--
-  # TODO: Rename to ShellHelper
-  #++
-  module ScriptHelper
-    include Rudy::Routines::HelperBase  # TODO: use trap_rbox_errors
-    extend self
-
-    @@script_types = [:after, :before, :after_local, :before_local, :script, :script_local]
-    
-    
-    # TODO: refactor using this_method
-    
-    def before_local(routine, sconf, rbox, option=nil, argv=nil)
-      execute_command(:before_local, routine, sconf, 'localhost', rbox, option, argv)
-    end
-    def before_local?(routine)
-      # before_local generally doesn't take a user name like the remote
-      # before block so we add it here (unless the user did specify it)
-      routine[:before_local] = { 
-        Rudy.sysinfo.user.to_sym => routine.delete(:before_local) 
-      } if routine[:before_local].is_a?(Proc)
-      execute_command?(:before_local, routine)
-    end
-    def script_local(routine, sconf, rbox, option=nil, argv=nil)
-      execute_command(:script_local, routine, sconf, 'localhost', rbox, option, argv)
-    end
-    def script_local?(routine)
-      # before_local generally doesn't take a user name like the remote
-      # before block so we add it here (unless the user did specify it)
-      routine[:script_local] = { 
-        Rudy.sysinfo.user.to_sym => routine.delete(:script_local) 
-      } if routine[:script_local].is_a?(Proc)
-      execute_command?(:script_local, routine)
-    end
-    
-    def after_local(routine, sconf, rbox, option=nil, argv=nil)
-      execute_command(:after_local, routine, sconf, 'localhost', rbox, option, argv)
-    end
-    def after_local?(routine)
-      routine[:after_local] = {                 # See before_local note
-        Rudy.sysinfo.user.to_sym => routine.delete(:after_local) 
-      } if routine[:after_local].is_a?(Proc)
-      execute_command?(:after_local, routine)
-    end
-    
-    def before(routine, sconf, machine, rbox, option=nil, argv=nil)
-      raise "ScriptHelper: Not a Rudy::Machine" unless machine.is_a?(Rudy::Machine)
-      execute_command(:before, routine, sconf, machine.name, rbox, option, argv)
-    end
-    def before?(routine); execute_command?(:before, routine); end
-    
-    def after(routine, sconf, machine, rbox, option=nil, argv=nil)
-      raise "ScriptHelper: Not a Rudy::Machine" unless machine.is_a?(Rudy::Machine)
-      execute_command(:after, routine, sconf, machine.name, rbox, option, argv)
-    end
-    def after?(routine); execute_command?(:after, routine); end
-    
-    def script(routine, sconf, machine, rbox, option=nil, argv=nil)
-      raise "ScriptHelper: Not a Rudy::Machine" unless machine.is_a?(Rudy::Machine)
-      execute_command(:script, routine, sconf, machine.name, rbox, option, argv)
-    end
-    def script?(routine); execute_command?(:script, routine); end
-
-  
-  private  
-    
-    # Does the routine have the requested script type?
-    # * +timing+ is one of: after, before, after_local, before_local
-    # * +routine+ a single routine hash (startup, shutdown, etc...)
-    # Prints notice to STDERR if there's an empty conf hash
-    def execute_command?(timing, routine)
-      hasconf = (routine.is_a?(Caesars::Hash) && routine.has_key?(timing))
-      return false unless hasconf
-      unless routine[timing].kind_of?(Hash)
-        STDERR.puts "No user supplied for #{timing} block".color(:red)
-        choice = Annoy.get_user_input('(S)kip (A)bort: ') || ''
-         if choice.match(/\AS/i)
-           return
-         else
-           exit 12
-         end
-        return false
-      end
-      routine[timing].each_pair do |user,proc|
-        #p [timing, user, proc].join(', ')
-        if proc.nil? || !proc.is_a?(Proc)
-          STDERR.puts "Empty #{timing} config for #{user}"
-        else
-          return true
-        end
-      end
-      false
-    end
-    
-    # * +timing+ is one of: after, before, after_local, before_local
-    # * +routine+ a single routine hash (startup, shutdown, etc...)
-    # * +sconf+ is a config hash from machines config (ignored if nil)
-    # * +hostname+ machine hostname that we're working on
-    # * +rbox+ a Rye::Box instance for the machine we're working on
-    def execute_command(timing, routine, sconf, hostname, rbox, option=nil, argv=nil)
-      raise "ScriptHelper: Not a Rye::Box" unless rbox.is_a?(Rye::Box)
-      raise "ScriptHelper: #{timing}?" unless @@script_types.member?(timing)
-      
-      # Do we need to run this again? It's called in generic_routine_runner
-      ##if execute_command?(timing, routine) # i.e. before_local?
-
-        # We need to explicitly add the rm command for rbox so we
-        # can delete the script config file when we're done. This
-        # adds the method to this instance of rbox only.
-        # We give it a funny so we can delete it knowing we're not
-        # deleting a method added somewhere else. 
-        def rbox.rudy_tmp_rm(*args); cmd('rm', args); end
-        
-        original_user = rbox.user
-        user_blocks = routine[timing] || {}
-        users = user_blocks.keys
-        # Root stuff is always run first. 
-        users.unshift(users.delete(:root)) if users.member?(:root)
-        users.each do |user|
-          proc = user_blocks[user]
-          
-          begin
-            rbox.switch_user user # does nothing if it's the same user
-            rbox.connect(false)   # does nothing if already connected
-          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
-          
-          begin
-            # We define hooks so we can still print each command and its output
-            # when running the command blocks. NOTE: We only print this in
-            # verbosity mode. We intentionally set and unset the hooks 
-            # so the other commands (config file copy) don't get printed.
-            if @@global.verbose > 0
-              # This block gets called for every command method call.
-              rbox.pre_command_hook do |cmd, args, user, host|
-                puts command_separator(rbox.preview_command(cmd, args), user, host)
-              end
-            end
-            if @@global.verbose > 1
-              # And this one gets called after each command method call.
-              rbox.post_command_hook do |ret|
-                puts '  ' << ret.stdout.join("#{$/}  ") if !ret.stdout.empty?
-                print_response(ret)
-              end
-            end
-            
-            ### EXECUTE THE COMMANDS BLOCK
-            rbox.batch(option, argv, &proc)
-            
-          rescue Rye::CommandError => ex
-            print_response(ex)
-            choice = Annoy.get_user_input('(S)kip  (R)etry  (A)bort: ') || ''
-             if choice.match(/\AS/i)
-               return
-             elsif choice.match(/\AR/i)
-               retry
-             else
-               exit 12
-             end
-          rescue Rye::CommandNotFound => ex
-            STDERR.puts "  CommandNotFound: #{ex.message}".color(:red)
-            STDERR.puts ex.backtrace if Rudy.debug?
-            choice = Annoy.get_user_input('(S)kip  (R)etry  (A)bort: ') || ''
-             if choice.match(/\AS/i)
-               return
-             elsif choice.match(/\AR/i)
-               retry
-             else
-               exit 12
-             end
-          ensure
-            rbox.pre_command_hook = nil
-            rbox.post_command_hook = nil
-            rbox.enable_safe_mode  # In case it was disabled
-          end
-          
-          rbox.cd # reset to home dir
-        end
-        
-        # Return the borrowed rbox instance to the user it was provided with
-        rbox.switch_user original_user
-      
-      ##else
-      ##  puts "Nothing to do"
-      ##end
-      
-      
-    end
-  end
-  
-end;end

data/lib/rudy/routines/helpers/userhelper.rb

@@ -1,37 +0,0 @@
-
-module Rudy; module Routines; 
-  module UserHelper
-    include Rudy::Routines::HelperBase  # TODO: use trap_rbox_errors
-    extend self 
-    
-    def adduser?(routine)
-      (!routine.adduser.nil? && !routine.adduser.to_s.empty?)
-    end
-    def adduser(routine, machine, rbox)
-      
-      # On Solaris, the user's home directory needs to be specified
-      # explicitly so we do it for linux too for fun. 
-      homedir = rbox.guess_user_home(routine.adduser.to_s)
-      args = [:m, :d, homedir, :s, '/bin/bash', routine.adduser.to_s]
-      puts command_separator(rbox.preview_command(:useradd, args), rbox.user, rbox.host)
-      
-      # 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
-      trap_rbox_errors { rbox.useradd(args) }
-    end
-    
-    def authorize?(routine)
-      (!routine.authorize.nil? && !routine.authorize.to_s.empty?)
-    end
-    def authorize(routine, machine, rbox)
-      puts command_separator(:authorize_keys_remote, rbox.user, rbox.host)
-      trap_rbox_errors { rbox.authorize_keys_remote(routine.authorize) }
-    end
-    
-    
-  end
-  
-end; end  

data/support/rudy-ec2-startup

@@ -1,200 +0,0 @@
-#!/usr/bin/ruby
-
-# what: Rudy EC2 startup script
-#  who: delano@solutious.com
-# when: 2009-02-25 (rev: 4)
-
-# NOTE: This is a prototype version of this script. A cleaner version 
-# with better documentation is forthcoming.
-
-# Runs when an ec2 instance startups up.
-# Grabs configuration from the run time user data and stores it locally.
-# See Rudy::CLI::Machines#start_instance for the expected yaml format.
-
-# Put this in /etc/init.d. Then:
-#   * chmod 755 rudy-ec2-startup
-#   * cd /etc/rc3.d
-#   * ln -s ../init.d/rudy-ec2-startup S17rudy
-#   * cd /etc/rc4.d                    
-#   * ln -s ../init.d/rudy-ec2-startup S17rudy
-#   * cd /etc/rc5.d                    
-#   * ln -s ../init.d/rudy-ec2-startup S17rudy
-
-require 'yaml'
-require 'resolv'
-
-LOGFILE = '/var/log/rudy-ec2-startup'
-USERDATA = 'http://169.254.169.254/2008-02-01/user-data'
-METADATA = 'http://169.254.169.254/2008-02-01/meta-data'
-
-#LOGFILE = '/tmp/rudy-ec2-startup'
-#USERDATA = 'http://127.0.0.1/2008-02-01/user-data'
-#METADATA = 'http://127.0.0.1/2008-02-01/meta-data'
-
-METADATAPARAMS = ['instance-id', 'instance-type']
-
-Rudy::CONFIG_DIR=File.join('.rudy')
-Rudy::CONFIG_FILE=File.join('config')
-
-module Rudy
-  module EC2Startup
-    extend self
-    
-    VERSION = 4.freeze
-    
-    def process_config
-      begin
-        File.unlink(LOGFILE) if File.exists?(LOGFILE)
-        log "RUDY (rev#{VERSION}) is in the house"
-        
-        log "Grabing configuration..."
-        config_yaml = run("curl -s #{USERDATA}")
-  
-        log "Grabing meta-data..."
-        metadata = get_metadata
-        
-        log "Processing metadata..."
-        METADATAPARAMS.each do |name|
-          default = name.gsub('instance-', '')
-          value = (metadata[name] && !metadata[name].empty?) ? metadata[name] : default
-          log "  ---> #{name}: #{value}"
-          write_to_file("/etc/ec2/#{name}", value, "w")
-        end
-        
-        log "Processing userdata..."
-        
-        if !config_yaml || config_yaml.empty?
-          raise "Nothing to process (did you supply user-data when you created the instance)" 
-        end
-        
-        config = YAML::load(config_yaml)
-        config ||= {}
-        
-        # Print to STDOUT and NOT to the log. 
-        # We don't want sensitive config values available in the log
-        puts "CONFIG: " << config_yaml
-        
-        zone = config[:zone] ? config[:zone].to_s.downcase : "zone"
-        environment = config[:environment] ? config[:environment].to_s.downcase : "env"
-        role = config[:role] ? config[:role].to_s.downcase : "role"
-        position = config[:position] ? config[:position].to_s.downcase : "00"
-        
-        hostname = [zone, environment, role, position].join('-')
-        log "Setting hostname: #{hostname}"
-        `hostname #{hostname}`
-        
-        config[:hosts] ||= {}
-        config[:hosts][hostname] = '127.0.0.1'
-        
-        if config[:userdata] && config[:userdata].is_a?(Hash)
-          # TODO: How to we get the path to any user's home directory? 
-          # (when we're not running as that user.) 
-          config[:userdata].each_pair do |n,hash|
-            fileparts = (n == :root) ? ['/root'] : [user_home_dir(n)]
-            fileparts << Rudy::CONFIG_DIR
-            dirpath = File.join(fileparts)
-            filepath = File.join(dirpath, Rudy::CONFIG_FILE)
-            
-            # Backwards compatability
-            if !File.directory?(dirpath)
-              log "Deleting the deprecated #{dirpath} config"
-              File.unlink(dirpath) 
-            end
-            
-            unless File.exists?(dirpath)
-              log "Creating #{dirpath}"
-              Dir.mkdir(dirpath, 0700)
-            end
-            
-            log "Writing to #{filepath}"
-            user_data = {
-              :userdata => hash
-            }
-            write_to_file(filepath, user_data.to_yaml, "w")
-          end
-        end
-        
-        if config[:hosts] && config[:hosts].is_a?(Hash)
-          unless read_file('/etc/hosts') =~ /----- RUDY SAYS -----/
-            log "Updating /etc/hosts..."
-            write_to_file("/etc/hosts", "\n# ----- RUDY SAYS -----\n", :append)
-            config[:hosts].each_pair do |name, address|
-              # Respect existing entries
-              next if read_file('/etc/hosts') =~ /#{name}/
-      
-              ip_address = (address !~ /^\d.+/) ? Resolv.getaddress(address) : address
-      
-              log "  ---> #{name}: #{ip_address}"
-              write_to_file("/etc/hosts", "\n#{ip_address}\t#{name}\n", :append)
-            end
-          end
-        end
-        
-        log "Done!"
-  
-      rescue => ex
-        log "ERROR: #{ex.message}"
-      end
-    end
-    
-    
-    def get_metadata
-      metadata = {}
-
-      begin
-        METADATAPARAMS.each do |param|
-          log "  ---> #{param}"
-          metadata[param.to_s] = run("curl -s #{METADATA}/#{param}")
-          metadata[param.to_s] = nil if metadata[param.to_s].empty?
-        end
-      rescue => ex
-        log("Problem getting metadata: #{ex.message}")
-      end
-      metadata
-    end
-
-    def run(command, input='')
-      IO.popen(command, 'r+') do |io|
-        io.read
-      end
-    end  
-
-    def get_formatted_time
-      t = Time.now
-      t_out = t.strftime("%H:%M:%S%p (%m/%d/%Y)")
-    end
-
-    def write_to_file(filename, s, type)
-      type = (type == :append) ? 'a' : 'w'
-      f = File.open(filename,type)
-      f.puts s
-      f.close
-    end
-
-    def read_file(path)
-      read_file_to_array(path).join('')
-    end
-
-    def read_file_to_array(path)
-      contents = []
-      return contents unless File.exists?(path)
-      open(path, 'r') do |l|
-        contents = l.readlines
-      end
-      contents
-    end
-    
-    def user_home_dir(user)
-      (`su #{user} -c "echo \\$HOME"` || '').chomp
-    end
-    
-    def log(s)
-      msg = "#{get_formatted_time}: #{s}"
-      write_to_file(LOGFILE, msg, :append)
-      puts msg
-    end
-    
-  end
-end
-
-Rudy::EC2Startup.process_config