rudy 0.6.8 → 0.7.0

data/lib/rudy/routines/release.rb

@@ -1,34 +1,50 @@
 
+
 module Rudy; module Routines;
   class Release < Rudy::Routines::Base
-
-    def execute
-      p find_scm(:release)
-    end
     
+    def init(*args)
+      @routine_name = args.first || :release # :release or :rerelease
+      @routine = fetch_routine_config(@routine_name)
+    end
     
-  private
-    def find_scm(routine)
-      env, rol, att = @@global.environment, @@global.role
+    def execute()
+      routine_separator(@routine_name)
 
-      # Look for the source control engine, checking all known scm values.
-      # The available one will look like [environment][role][release][svn]
-      params = nil
-      scm_name = nil
-      SUPPORTED_SCM_NAMES.each do |v|
-        scm_name = v
-        params = @@config.routines.find(env, rol, routine, scm_name)
-        break if params
+      vlist = []
+      
+      # Some early version control system failing
+      if Rudy::Routines::SCMHelper.scm?(@routine)
+        vlist = Rudy::Routines::SCMHelper.create_scm_objects(@routine)
+        puts task_separator("CREATING RELEASE TAG#{'S' if vlist.size > 1}")
+        vlist.each do |scm|
+          scm.create_release(Rudy.sysinfo.user)
+          puts scm.liner_note
+        end
       end
-
-      if params
-        klass = eval "Rudy::SCM::#{scm_name.to_s.upcase}"
-        scm = klass.new(:base => params[:base])
+      
+      machines = []
+      generic_machine_runner(:list) do |machine,rbox|
+        vlist.each do |scm|
+          puts task_separator("CREATING REMOTE #{scm.engine.to_s.upcase} CHECKOUT")
+          scm.create_remote_checkout(rbox)
+        end
+        machines << machine
       end
-
-      [scm, params]
-
+      
+      machines
+    end
+    
+    # Called by generic_machine_runner
+    def raise_early_exceptions
+      raise NoRoutine, :release unless @routine
+      rmach = Rudy::Machines.new
+      raise Rudy::PrivateKeyNotFound, root_keypairpath unless has_keypair?(:root)
+      raise MachineGroupNotDefined, current_machine_group unless known_machine_group?
+      raise MachineGroupNotRunning, current_machine_group unless rmach.running?
     end
     
+
+    
   end
 end;end

data/lib/rudy/routines/shutdown.rb

@@ -1,62 +1,33 @@
 
 
 module Rudy; module Routines;
-
   class Shutdown < Rudy::Routines::Base
     
+    def init(*args)
+      @routine = fetch_routine_config(:shutdown)
+    end
+    
     def execute
+      routine_separator(:shutdown)
+      unless @routine
+        STDERR.puts "[this is a generic shutdown routine]"
+        @routine = {}
+      end
+      machines = []
+      generic_machine_runner(:destroy) do |machine,rbox|
+        #puts task_separator("SHUTDOWN")
+        machines << machine
+      end
+      machines
+    end
+
+    # Called by generic_machine_runner
+    def raise_early_exceptions
       rmach = Rudy::Machines.new
       raise Rudy::PrivateKeyNotFound, root_keypairpath unless has_keypair?(:root)
-      raise MachineGroupNotDefined, current_machine_group unless known_machine_group?
       raise MachineGroupNotRunning, current_machine_group unless rmach.running?
-      
-      routine = fetch_routine_config(:shutdown)
-      rbox_local = Rye::Box.new('localhost')
-      sconf = fetch_script_config
-
-      # Runs "before_local" scripts of routines config. 
-      puts task_separator("BEFORE SCRIPTS (local)")
-      Rudy::Routines::ScriptHelper.before_local(routine, sconf, rbox_local)
-      
-      puts
-      
-      rmach.destroy do |machine|
-      #rmach.list do |machine|
-        
-        print "Waiting for instance..."
-        isup = Rudy::Utils.waiter(3, 120, STDOUT, "it's up!", 0) {
-          inst = machine.get_instance
-          inst && inst.running?
-        } 
-        machine.update # Add instance info to machine and save it
-        print "Waiting for SSH daemon..."
-        isup = Rudy::Utils.waiter(2, 60, STDOUT, "it's up!", 0) {
-          Rudy::Utils.service_available?(machine.dns_public, 22)
-        }
-        
-        opts = { :keys =>  root_keypairpath, :user => 'root', :debug => nil }
-        rbox = Rye::Box.new(machine.dns_public, opts)
-        
-        # Runs "before" scripts of routines config. 
-        puts task_separator("BEFORE SCRIPTS")
-        Rudy::Routines::ScriptHelper.before(routine, sconf, machine, rbox)
-                
-        # Runs "disk" portion of routines config
-        puts task_separator("DISK ROUTINES")
-        Rudy::Routines::DiskHelper.execute(routine, machine, rbox)
-        
-        puts machine_separator(machine.liner_note)
-      end
-      
-        
-      # Runs "after_local" scripts
-      # NOTE: There "after" (remote) scripts are not run b/c the machines
-      # are no longer running. 
-      puts task_separator("AFTER SCRIPTS (local)")
-      Rudy::Routines::ScriptHelper.after_local(routine, sconf, rbox_local)
-      
     end
-
+    
   end
 
 end; end

data/lib/rudy/routines/startup.rb

@@ -1,61 +1,34 @@
 
 
 module Rudy; module Routines;
-
   class Startup < Rudy::Routines::Base
+    
+    def init(*args)
+      @routine = fetch_routine_config(:startup)
+    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(:startup)
+      unless @routine
+        STDERR.puts "[this is a generic startup routine]"
+        @routine = {}
+      end
+      generic_machine_runner(:create) do |machine,rbox|
+      end
+    end
 
-    def execute
+    # Called by generic_machine_runner
+    def raise_early_exceptions
       rmach = Rudy::Machines.new
       # There's no keypair check here because Rudy::Machines will attempt 
       # to create one.
       raise MachineGroupNotDefined, current_machine_group unless known_machine_group?
       raise MachineGroupAlreadyRunning, current_machine_group if rmach.running?
-      
-      routine = fetch_routine_config(:startup)
-      rbox_local = Rye::Box.new('localhost')
-      sconf = fetch_script_config
-      
-      # Runs "before_local" scripts of routines config. 
-      # NOTE: Does not run "before" scripts b/c there are no remote machines
-      puts task_separator("BEFORE SCRIPTS (local)")
-      Rudy::Routines::ScriptHelper.before_local(routine, sconf, rbox_local)
-      
-      rmach.create do |machine|
-      #rmach.list do |machine|
-        puts machine_separator(machine.liner_note)
-        print "Waiting for instance..."
-        isup = Rudy::Utils.waiter(3, 120, STDOUT, "it's up!", 2) {
-          inst = machine.get_instance
-          inst && inst.running?
-        } 
-        machine.update # Add instance info to machine and save it
-        print "Waiting for SSH daemon..."
-        isup = Rudy::Utils.waiter(2, 60, STDOUT, "it's up!", 3) {
-          Rudy::Utils.service_available?(machine.dns_public, 22)
-        }
-        
-        opts = { :keys =>  root_keypairpath, :user => 'root', :debug => nil }
-        rbox = Rye::Box.new(machine.dns_public, opts)
-        
-        puts task_separator("DISK ROUTINES")
-        # Runs "disk" portion of routines config
-        Rudy::Routines::DiskHelper.execute(routine, machine, rbox)
-        
-        puts task_separator("AFTER SCRIPTS")
-        # Runs "after" scripts of routines config
-        Rudy::Routines::ScriptHelper.after(routine, sconf, machine, rbox)
-        
-        puts task_separator("INFO")
-        puts "Filesystem on #{machine.name}:"
-        puts "  " << rbox.df(:h).join("#{$/}  ")
-      end
-      
-      puts task_separator("AFTER SCRIPTS (local)")
-      # Runs "after_local" scripts of routines config
-      Rudy::Routines::ScriptHelper.after_local(routine, sconf, rbox_local)
-      
     end
-
+    
   end
 
 end; end

data/lib/rudy/scm.rb

@@ -0,0 +1,75 @@
+
+
+module Rudy
+  module SCM
+    
+    class NotAWorkingCopy < Rudy::Error
+      def message
+        "Not the root directory of a #{@obj} working copy"
+      end
+    end
+    class CannotCreateTag < Rudy::Error
+      def message
+        "There was an unknown problem creating a release tag (#{@obj})"
+      end
+    end
+    class DirtyWorkingCopy < Rudy::Error
+      def message
+        "Please commit local #{@obj} changes"
+      end
+    end
+    class RemoteError < Rudy::Error; end
+    class NoRemoteURI < Rudy::Error; end
+    class TooManyTags < Rudy::Error
+      def message; "Too many tag creation attempts!"; end
+    end
+    class NoRemotePath < Rudy::Error
+      def message 
+        "Add a path for #{@obj} in your routines config"
+      end
+    end
+    
+    
+    module ObjectBase
+      
+      
+      def raise_early_exceptions; raise "override raise_early_exceptions"; end
+      
+      # copied from routines/helper.rb
+      def execute_rbox_command(ret=nil, &command)
+        begin
+          ret = command.call
+          puts '  ' << ret.stdout.join("#{$/}  ") if !ret.stdout.empty?
+          print_response(ret)
+        rescue Rye::CommandError => ex
+          print_response(ex)
+          exit 12 unless keep_going?
+        rescue Rye::CommandNotFound => ex
+          STDERR.puts "  CommandNotFound: #{ex.message}".color(:red)
+          STDERR.puts ex.backtrace
+          exit 12 unless keep_going?
+        end
+
+        ret
+      end
+      
+      
+      private 
+        def keep_going?
+          Annoy.pose_question("  Keep going?\a ", /yes|y|ya|sure|you bet!/i, STDERR)
+        end
+      
+        def print_response(rap)
+          [:stderr].each do |sumpin|
+            next if rap.send(sumpin).empty?
+            STDERR.puts "  #{sumpin}: #{rap.send(sumpin).join("#{$/}  ")}".color(:red)
+          end
+          STDERR.puts "  Exit code: #{rap.exit_code}".color(:red) if rap.exit_code != 0
+        end
+        
+    end
+    
+  end
+end
+
+Rudy::Utils.require_glob(RUDY_LIB, 'rudy', 'scm', '*.rb')

data/lib/rudy/scm/git.rb

@@ -0,0 +1,215 @@
+
+require 'date'
+
+  
+module Rudy
+  module SCM
+    class GIT
+      require 'grit'
+      include Rudy::SCM::ObjectBase
+      include Grit
+      
+      attr_accessor :base_uri
+      attr_accessor :remote
+      attr_accessor :branch
+      attr_reader :repo
+      attr_reader :rbox
+      attr_reader :rtag
+      attr_reader :user
+      attr_reader :pkey
+      
+      # * +args+ a hash of params from the git block in the routines config
+      # 
+      def initialize(args={})
+        args = {
+          :privatekey => nil,
+          :remote => :origin,
+          :branch => :master,
+          :user => :root,
+          :path => nil
+        }.merge(args)
+        @remote, @branch, @path = args[:remote], args[:branch], args[:path]
+        @user, @pkey = args[:user], args[:privatekey]
+        @repo = Repo.new(Dir.pwd) if GIT.working_copy?
+      end
+      
+      def engine; :git; end
+      
+      def liner_note
+        "%-40s  (git:%s:%s)" % [@rtag, @remote, @branch]
+      end
+      
+      def create_release(username=nil, msg=nil)
+        @rtag = find_next_rtag(username)
+        msg ||= 'Another Release by Rudy!'
+        msg.tr!("'", "''")
+        ret = Rye.shell(:git, "tag", @rtag)  # Use annotated? -a -m '#{msg}' 
+        raise ret.stderr.join($/) if ret.exit_code > 0
+        ret = Rye.shell(:git, "push") if @remote
+        raise ret.stderr.join($/) if ret.exit_code > 0
+        ret = Rye.shell(:git, "push #{@remote} #{rtag}") if @remote
+        raise ret.stderr.join($/) if ret.exit_code > 0
+        @rtag
+      end
+      
+      # rel-2009-03-05-user-rev
+      def find_next_rtag(username=nil)
+        now = Time.now
+        mon = now.mon.to_s.rjust(2, '0')
+        day = now.day.to_s.rjust(2, '0')
+        rev = "01"
+        criteria = ['rel', now.year, mon, day, rev]
+        criteria.insert(-2, username) if username
+        rev.succ! while valid_rtag?(criteria.join(Rudy::DELIM)) && rev.to_i < 50
+        raise TooManyTags if rev.to_i >= 50
+        criteria.join(Rudy::DELIM)
+      end
+      
+      def delete_rtag(rtag=nil)
+        rtag ||= @rtag
+        ret = execute_rbox_command { Rye.shell(:git, 'tag', :d, rtag) }
+        raise ret.stderr.join($/) if ret.exit_code > 0 # TODO: retest
+        # Equivalent to: "git push origin :tag-name" which deletes a remote tag
+        ret = execute_rbox_command { Rye.shell(:git, "push #{@remote} :#{rtag}") } if @remote
+        raise ret.stderr.join($/) if ret.exit_code > 0
+        true
+      end
+      
+      def create_remote_checkout(rbox)
+        
+        # Make sure the directory above the clone path exists 
+        # and that it's owned by the request user. 
+        rbox.mkdir(:p, File.dirname(@path)) 
+        rbox.chown(@user, File.dirname(@path)) 
+        
+        begin
+          original_user = rbox.user
+          rbox.switch_user(@user)
+          
+          if @pkey
+            # Try when debugging: ssh -vi path/2/pkey git@github.com
+            key = File.basename(@pkey)
+            homedir = rbox.getenv['HOME']
+            rbox.mkdir(:p, :m, '700', '.ssh') rescue nil # :p says keep quiet if it exists              
+            if rbox.file_exists?(".ssh/#{key}")
+              puts "  Remote private key #{key} already exists".colour(:red)
+            else
+              rbox.upload(@pkey, ".ssh/#{key}")
+            end
+            
+            # NOTE: The following are two attempts at telling git which 
+            # private key to use. Both fail. The only thing I could get
+            # to work is modifying the ~/.ssh/config file. 
+            #
+            # This runs fine, but "git clone" doesn't care. 
+            # git config --global --replace-all http.sslKey /home/delano/.ssh/id_rsa
+            # rbox.git('config', '--global', '--replace-all', 'http.sslKey', "#{homedir}/.ssh/#{key}")
+            
+            # "git clone" doesn't care about this either. Note that both these
+            # config attempts come directly from the git-config man page:
+            # http://www.kernel.org/pub/software/scm/git/docs/git-config.html
+            # export GIT_SSL_KEY=/home/delano/.ssh/id_rsa
+            # rbox.setenv("GIT_SSL_KEY", "#{homedir}/.ssh/#{key}")
+            
+            if rbox.file_exists?('.ssh/config')
+              rbox.cp('.ssh/config', ".ssh/config-previous")
+              ssh_config = rbox.download('.ssh/config')
+            end
+            
+            ssh_config ||= StringIO.new
+            ssh_config.puts $/, "IdentityFile #{homedir}/.ssh/#{key}"
+            puts "  Adding IdentityFile #{key} to #{homedir}/.ssh/config"
+            
+            rbox.upload(ssh_config, '.ssh/config')
+            rbox.chmod('0600', '.ssh/config')
+            
+          end
+          
+          # We need to add the host keys to the user's known_hosts file
+          # to prevent the git commands from failing when it raises the
+          # "Host key verification failed." messsage.
+          if rbox.file_exists?('.ssh/known_hosts')
+            rbox.cp('.ssh/known_hosts', ".ssh/known_hosts-previous")
+            known_hosts = rbox.download('.ssh/known_hosts')
+          end
+          known_hosts ||= StringIO.new
+          remote = get_remote_uri
+          host = URI.parse(remote).host rescue nil
+          host ||= remote.scan(/\A.+?@(.+?)\:/).flatten.first
+          known_hosts.puts $/, Rye.remote_host_keys(host)
+          puts "  Adding host key for #{host} to .ssh/known_hosts"
+
+          rbox.upload(known_hosts, '.ssh/known_hosts')
+          rbox.chmod('0600', '.ssh/known_hosts')
+
+          execute_rbox_command {
+            rbox.git('clone', get_remote_uri, @path)
+          }
+          rbox.cd(@path)
+          execute_rbox_command {
+            rbox.git('checkout', :b, @rtag)
+          }
+        rescue Rye::CommandError => ex
+          puts ex.message
+        ensure
+          # Return to the original user and directory
+          rbox.switch_user(original_user)
+          rbox.cd
+        end
+        
+      end
+      
+      
+      def get_remote_uri
+        ret = Rye.shell(:git, "config", "remote.#{@remote}.url")
+        ret.stdout.first
+      end
+      
+      # Check if the given remote is valid. 
+      #def has_remote?(remote)
+      #  success = false
+      #  (@repo.remotes || []).each do |r|
+      #  end
+      #  success
+      #end
+      
+      def valid_rtag?(tag)
+        # git tag -l tagname returns a 0 exit code and stdout is empty
+        # when a tag does not exit. When it does exist, the exit code
+        # is 0 and stdout contains the tagname. 
+        ret = Rye.shell(:git, 'tag', :l, tag)  
+        # change :l to :d for quick deleting above and return true
+        # OR: just change to :d to always recreate the same tag
+        (ret.exit_code == 0 && ret.stdout.to_s == tag)
+      end
+      
+      # Are all local changes committed?
+      def self.clean_working_copy?(path=Dir.pwd)
+        Rye.shell(:git, 'diff').stdout == []
+      end
+      def clean_working_copy?; GIT.clean_working_copy?; end
+      
+      def self.working_copy?(path=Dir.pwd)
+        (File.exists?(File.join(path, '.git')))
+      end
+      def working_copy?; GIT.working_copy?; end
+      
+      def raise_early_exceptions
+        raise NotAWorkingCopy, :git unless working_copy?
+        #raise DirtyWorkingCopy, :git unless clean_working_copy?
+        raise NoRemoteURI, "remote.#{@remote}.url not set" if get_remote_uri.nil?
+        raise NoRemotePath, :git if @path.nil?
+        raise PrivateKeyNotFound, @pkey if @pkey && !File.exists?(@pkey)
+        find_next_rtag # will raise exception is there's a problem
+        
+        # We can't check stuff that requires access to the machine b/c the 
+        # machine may not be running yet. These include:
+        # * Remote checkout path already exists
+        # * No git available
+        # ...
+        # If create_remote_checkout should fail, it should print a message
+        # about the release that was created and how to install it manually
+      end
+    end
+  end
+end