amp 0.5.2 → 0.5.3

data/lib/amp/repository/mercurial/repo_format/journal.rb

@@ -0,0 +1,218 @@
+module Amp
+  class StandardErrorReporter
+    def self.report str
+      UI.err str
+    end
+  end
+  
+  module Mercurial
+    
+    ##
+    # Provides a journal interface so when a large number of transactions
+    # are occurring, and any one could fail, we can rollback the changes.
+    class Journal
+      DEFAULT_OPTS = {:reporter => StandardErrorReporter, :after_close => nil, :createmode => nil}
+      
+      attr_accessor :reporter, :journal, :after_close, :opener
+      
+      ##
+      # @return [Amp::Mercurial::Journal]
+      def self.start(file, opts={})
+        opts = DEFAULT_OPTS.merge(opts)
+        opts[:journal] = file
+        journal = Journal.new opts
+        
+        if block_given?
+          begin
+            yield journal
+          rescue
+            journal.delete
+          ensure
+            journal.close
+          end
+        end
+        
+        journal
+      end
+      
+      ##
+      # Initializes the journal to get ready for some transactions.
+      # 
+      # @param [#report] reporter an object that will keep track of any alerts
+      #   we have to send out. Must respond to #report.
+      # @param [String] journal the path to the journal file to use
+      # @param [Integer] createmode An octal number that sets the filemode
+      #   of the journal file we'll be using
+      # @param [Proc] after_close A proc to call (with no args) after we
+      #   close (finish) the transaction.
+      def initialize(opts = {}, &after_close)   
+        opts = DEFAULT_OPTS.merge(opts)
+        opts[:journal] ||= ".journal#{rand(10000)}"
+        @count = 1
+        @entries = []
+        @map = {}
+        @journal_file = opts[:journal]
+        self.reporter = opts[:reporter]
+        self.after_close = after_close
+        self.opener = opts[:opener]
+        
+        @file = Kernel::open(@journal_file, "w")
+        
+        FileUtils.chmod(createmode & 0666, @journal_file) unless opts[:createmode].nil?
+        
+        UI.status "opening journal"
+      end
+      
+      ##
+      # Kills the journal - used when shit goes down and we gotta give up
+      # on the transactions.
+      def delete
+        if @journal_file
+          abort if @entries.any?
+          @file.close
+          FileUtils.safe_unlink @journal_file
+        end
+      end
+      
+      ##
+      # Adds an entry to the journal. Since all our files are just being appended
+      # to all the time, all we really need is to keep track of how long the file
+      # was when we last knew it to be safe. In other words, if the file started
+      # off at 20 bytes, then an error happened, we just truncate it to 20 bytes.
+      # 
+      # All params should be contained in the array
+      # 
+      # @param h [Hash] a hash of the args
+      # @option h [String] :file the name of the file
+      # @option h [Integer] :offset the offset of :file at the last known good revision
+      # @option h [String] :data any extra data
+      def add_entry(h={})
+        return if @map[h[:file]]
+        @entries << {:file => h[:file], :offset => h[:offset], :data => h[:data]}
+        @map[h[:file]] = @entries.size - 1
+        
+        # tell the journal how to truncate this revision
+        @file.write "#{h[:file]}\0#{h[:offset]}\n"
+        @file.flush
+      end
+      
+      ##
+      # Alias for {add_entry}
+      alias :<< :add_entry
+      
+      ##
+      # Finds the entry for a given file's path
+      # 
+      # @param [String] file the path to the file
+      # @return [Hash] A hash with the values :file, :offset, and :data, as
+      #   they were when they were stored by {add_entry} or {update}
+      def find_file(file)
+        return @entries[@map[file]] if @map[file]
+        nil
+      end
+      
+      ##
+      # Alias for {find_file}
+      alias :find :find_file
+      
+      ##
+      # Updates an entry's data, based on the filename. The file must already
+      # have been journaled.
+      # 
+      # @param [String] file the file to update
+      # @param [Fixnum] offset the new offset to store
+      # @param [String] data the new data to store
+      def replace(file, offset, data=nil)
+        raise IndexError.new("journal lookup failed #{file}") unless @map[file]
+        index = @map[file]
+        @entries[index] = {:file => file, :offset => offset, :data => data}
+        @file.write("#{file}\0#{offset}\n")
+        @file.flush
+      end
+      
+      ##
+      # Alias for {replace}
+      alias :update :replace
+      
+      ##
+      # No godly idea what this is for
+      def nest
+        @count += 1
+        self
+      end
+      
+      ##
+      # Is the journal running right now?
+      def running?
+        @count > 0
+      end
+      
+      ##
+      # Closes up the journal. Will call the after_close proc passed
+      # during instantiation.
+      def close
+        UI::status "closing journal"
+        @count -= 1
+        return if @count != 0
+        @file.close
+        @entries = []
+        if @after_close
+          @after_close.call
+        else
+          FileUtils.safe_unlink(@journal_file)
+        end
+        @journal_file = nil
+      end
+      
+      ##
+      # Abort, abort! abandon ship! This rolls back any changes we've made
+      # during the current journalling session.
+      def abort
+        UI::status "aborting journal"
+        return unless @entries && @entries.any?
+        @reporter.report "transaction abort!\n"
+        @entries.each do |hash|
+          file, offset = hash[:file], hash[:offset]
+          begin
+            self.opener.open(file, "a") do |fp|
+              p "OPENED #{file} truncating to #{offset}"
+              fp.truncate offset
+            end
+          rescue
+            @reporter.report "Failed to truncate #{File.join(".hg","store",file)}\n"
+          end
+        end
+        @entries = []
+        @reporter.report "rollback completed\n"
+      end
+      
+      ##
+      # If we crashed during an abort, the journal file is gonna be sitting aorund
+      # somewhere. So, we should rollback any changes it left lying around.
+      # 
+      # @param [String] file the journal file to use during the rollback
+      def self.rollback(opener, file)
+        files = {}
+        File.open(file, "r") do |fp|
+          fp.each_line do |line|
+            file, offset = line.split("\0")
+            files[file] = offset.to_i
+          end
+        end
+        files.each do |file_to_truncate, offset|
+          if o > 0
+            opener.open(file_to_truncate, "a") do |fp|
+              fp.truncate o.to_i
+            end
+          else
+            opener.open(file_to_truncate, "a") do |fp|
+              fn = fp.path
+            end
+            FileUtils.safe_unlink fn
+          end
+        end
+        FileUtils.safe_unlink file
+      end
+    end
+  end
+end

data/lib/amp/repository/mercurial/repo_format/lock.rb

@@ -0,0 +1,210 @@
+module Amp
+  module Repositories
+    module Mercurial
+      
+      ##
+      # = Lock
+      # Manages a given lock file, indicating that the enclosing folder should not
+      # be modified. Typically used during destructive operations on a repo (such as
+      # a commit or push).
+      #
+      # We must be compatible with Mercurial's lock format, unfortunately. Doesn't life
+      # suck?
+      #####
+      ##### From Mercurial code, explaining their format:
+      #####
+      #
+      # lock is symlink on platforms that support it, file on others.
+      #
+      # symlink is used because create of directory entry and contents
+      # are atomic even over nfs.
+      #
+      # old-style lock: symlink to pid
+      # new-style lock: symlink to hostname:pid
+      class Lock
+        @@host = nil
+        
+        ##
+        # Initializes the lock to a given file name, and creates the lock, effectively
+        # locking the containing directory.
+        #
+        # @param [String] file the path to the the lock file to create
+        # @param [Hash<Symbol => Object>] opts the options to use when creating the lock
+        # @option [Integer] options :timeout (-1) the length of time to keep trying to create the lock.
+        #   defaults to -1 (indefinitely)
+        # @option [Proc, #call] options :release_fxn (nil) A proc to run when the
+        #   lock is released
+        # @option [String] options :desc (nil) A description of the lock
+        def initialize(file, opts={:timeout => -1})
+          @file = file
+          @held = false
+          @timeout = opts[:timeout]
+          @release_fxn = opts[:release_fxn]
+          @description = opts[:desc]
+          apply_lock
+        end
+        
+        ##
+        # Applies the lock. Will sleep the thread for +timeout+ time trying to apply the lock before
+        # giving up and raising an error.
+        def apply_lock
+          timeout = @timeout
+          while true do
+            begin
+              # try_lock will raise of there is already a lock.
+              try_lock
+              return true
+            rescue LockHeld => e
+              # We'll put up with this exception for @timeout times, then give up.
+              if timeout != 0
+                sleep(1)
+                timeout > 0 && timeout -= 1
+                next
+              end
+              # Timeout's up? Raise an exception.
+              raise LockHeld.new(Errno::ETIMEDOUT::Errno, e.filename, @desc, e.locker)
+            end
+          end
+        end
+        
+        ##
+        # Attempts to apply the lock. Raises if unsuccessful. Contains the logic for actually naming
+        # the lock.
+        def try_lock
+          if @@host.nil?
+            @@host = Socket.gethostname
+          end
+          lockname = "#{@@host}:#{Process.pid}"
+          while !@held
+            begin
+              make_a_lock(@file, lockname)
+              @held = true
+            rescue Errno::EEXIST
+              locker = test_lock
+              unless locker.nil?
+                raise LockHeld.new(Errno::EAGAIN::Errno, @file, @desc, locker)
+              end
+            rescue SystemCallError => e
+              raise LockUnavailable.new(e.errno, e.to_s, @file, @desc)
+            end
+          end
+        end
+        
+        ##
+        # Creates a lock at the given location, with info about the locking process. Uses
+        # a symlink if possible, because even over NFS, creating a symlink is atomic. Nice.
+        # Otherwise, it will call make_a_lock_in_file on inferior OS's (cough windows cough)
+        # and put the data in there.
+        #
+        # The symlink is actually a non-working symlink - it points the filename (such as "hglock")
+        # to the data, even though the data is not an actual file. So hglock -> "medgar:25043" is
+        # a sort-of possible lock this method would create.
+        #
+        # @param [String] file the filename of the lock
+        # @param [String] info the info to store in the lock
+        def make_a_lock(file, info)
+          begin
+            File.symlink(info, file)
+          rescue Errno::EEXIST
+            raise
+          rescue
+            make_a_lock_in_file(file, info)
+          end
+        end
+        
+        ##
+        # Creates a lock at the given location, storing the info about the locking process in
+        # an actual lock file. These locks are not preferred, because symlinks are atomic even
+        # over NFS. Anyway, very simple. Create the file, write in the info, close 'er up.
+        # That's 1 line in ruby, folks.
+        #
+        # @see make_a_lock
+        # @param [String] file the filename of the lock
+        # @param [String] info the info to store in the lock
+        def make_a_lock_in_file(file, info)
+          File.open(file, "w+") {|out| out.write info }
+        end
+        
+        ##
+        # Reads in the data associated with a lock file.
+        #
+        # @param [String] file the path to the lock file to read
+        # @return [String] the data in the lock. In the format "#{locking_host}:#{locking_pid}"
+        def read_lock(file)
+          begin
+            return File.readlink(file)
+          rescue Errno::EINVAL, Errno::ENOSYS
+            return File.read(file)
+          end
+        end
+        
+        ##
+        # Checks to see if there is a process running with id +pid+.
+        #
+        # @param [Fixnum] pid the process ID to look up
+        # @return [Boolean] is there a process with the given pid?
+        def test_pid(pid)
+          return true if Platform::OS == :vms
+          
+          begin
+            # Doesn't actually kill it
+            Process.kill(0, pid)
+            true
+          rescue Errno::ESRCH::Errno
+            true
+          rescue
+            false
+          end
+        end
+            
+        
+        ##
+        # Text from mercurial code:
+        #
+        # return id of locker if lock is valid, else None.
+        #
+        # If old-style lock, we cannot tell what machine locker is on.
+        # with new-style lock, if locker is on this machine, we can
+        # see if locker is alive.  If locker is on this machine but
+        # not alive, we can safely break lock.
+        #
+        # The lock file is only deleted when None is returned.
+        def test_lock
+          locker = read_lock(@file)
+          host, pid = locker.split(":", 1)
+          return locker if pid.nil? || host != @@host
+          
+          pid = pid.to_i
+          return locker if pid == 0
+          
+          return locker if test_pid pid
+          
+          # if locker dead, break lock.  must do this with another lock
+          # held, or can race and break valid lock.
+          begin
+            the_lock = Lock.new(@file + ".break")
+            the_lock.try_lock
+            File.unlink(@file)
+            the_lock.release
+          rescue LockError
+            return locker
+          end
+        end
+          
+        ##
+        # Releases the lock, signalling that it is now safe to modify the directory in which
+        # the lock is found.
+        def release
+          if @held
+            @held = false
+            @release_fxn.call if @release_fxn
+            
+            File.unlink(@file) rescue ""
+          end
+        end
+          
+        
+      end
+    end
+  end
+end

data/lib/amp/repository/mercurial/repo_format/merge_state.rb

@@ -0,0 +1,228 @@
+module Amp
+  module Merges
+    module Mercurial
+      
+      ##
+      # = MergeState
+      # MergeState handles the merge/ directory in the repository, in order
+      # to keep track of how well the current merge is progressing. There is
+      # a file called merge/state that lists all the files that need merging
+      # and a little info about whether it has beeen merged or not.
+      #
+      # You can add a file to the mergestate, iterate over all of them, quickly
+      # look up to see if a file is still dirty, and so on.
+      class MergeState
+        include Enumerable
+        
+        ##
+        # Initializes a new mergestate with the given repo, and reads in all the
+        # information from merge/state.
+        #
+        # @param repo the repository being inspected
+        def initialize(repo)
+          @repo = repo
+          read!
+        end
+        
+        ##
+        # Resets the merge status, by clearing all merge information and files
+        # 
+        # @param node the node we're working with? seems kinda useless
+        def reset(node = nil)
+          @state = {}
+          @local = node if node
+          FileUtils.rm_rf @repo.join("merge")
+        end
+        alias_method :reset!, :reset
+        
+        ##
+        # Returns whether the file is part of a merge or not
+        # 
+        # @return [Boolean] if the dirty file in our state and not nil?
+        def include?(dirty_file)
+          not @state[dirty_file].nil?
+        end
+        
+        ##
+        # Accesses the the given file's merge status - can be "u" for unmerged,
+        # or other stuff we haven't figured out yet.
+        #
+        # @param [String] dirty_file the path to the file for merging.
+        # @return [String] the status as a letter - so far "u" means unmerged or "r"
+        #   for resolved.
+        def [](dirty_file)
+          @state[dirty_file] ? @state[dirty_file][0, 1] : ""
+        end
+        
+        ##
+        # Adds a file to the mergestate, which creates a separate file
+        # in the merge directory with all the information. I don't know
+        # what these parameters are for yet.
+        def add(fcl, fco, fca, fd, flags)
+          hash = Digest::SHA1.new.update(fcl.path).hexdigest
+          @repo.open("merge/#{hash}", "w") do |file|
+            file.write fcl.data
+          end
+          @state[fd] = ["u", hash, fcl.path, fca.path, fca.file_node.hexlify,
+                        fco.path, flags]
+          save
+        end
+        
+        ##
+        # Returns all uncommitted merge files - everything tracked by the merge state.
+        #
+        # @todo come up with a better method name
+        #
+        # @return [Array<Array<String, Symbol>>] an array of String-Symbol pairs - the
+        #   filename is the first entry, the status of the merge is the second.
+        def uncommitted_merge_files
+          @state.map {|k, _| [k, status(k)] }
+        end
+        
+        ##
+        # Iterates over all the files that are involved in the current
+        # merging transaction.
+        #
+        # @yield each file, sorted by filename, that needs merging.
+        # @yieldparam file the filename that needs (or has been) merged.
+        # @yieldparam state all the information about the current merge with
+        #   this file.
+        def each(&block)
+          @state.each(&block)
+        end
+        
+        ##
+        # Marks the given file with a given state, which is 1 letter. "u" means
+        # unmerged, "r" means resolved.
+        #
+        # @param [String] dirty_file the file path for marking
+        # @param [String] state the state - "u" for unmerged, "r" for resolved.
+        def mark(dirty_file, state)
+          @state[dirty_file][0] = state
+          save
+        end
+        
+        ##
+        # Marks the given file as unresolved. Helper method to hide details of
+        # how the mergestate works. Silly leaky abstractions...
+        #
+        # @param [String] filename the file to mark unresolved
+        def mark_conflicted(filename)
+          mark(filename, "u")
+        end
+        
+        ##
+        # Marks the given file as resolved. Helper method to hide details of
+        # how the mergestate works. Silly leaky abstractions...
+        #
+        # @param [String] filename the file to mark unresolved
+        def mark_resolved(filename)
+          mark(filename, "r")
+        end
+        
+        ##
+        # Returns the status of a given file, or nil otherwise. Used for making this
+        # class more friendly to the outside world. It came to us from mercurial as
+        # one leaky fucking abstraction. Every class that used it had to know that "u"
+        # returned meant unresolved... ugh.
+        #
+        # @param [String] filename the file to inspect
+        # @return [Symbol] a symbol representing the status of the file, either
+        #   :untracked, :resolved, or :unresolved
+        def status(filename)
+          return :untracked unless filename
+          case self[filename]
+          when "r"
+            :resolved
+          when "u"
+            :unresolved
+          end
+        end
+        
+        ##
+        # Is the given file unresolved?
+        #
+        # @param [String] filename
+        def unresolved?(filename)
+          status(filename) == :unresolved
+        end
+        
+        ##
+        # Is the given file resolved?
+        #
+        # @param [String] filename
+        def resolved?(filename)
+          status(filename) == :resolved
+        end
+        
+        ##
+        # Resolves the given file for a merge between 2 changesets.
+        #
+        # @param dirty_file the path to the file for merging
+        # @param working_changeset the current changeset that is the destination
+        #   of the merge
+        # @param other_changeset the newer changeset, which we're merging to
+        def resolve(dirty_file, working_changeset, other_changeset)
+          return 0 if resolved?(dirty_file)
+          state, hash, lfile, afile, anode, ofile, flags = @state[dirty_file]
+          r = true
+          @repo.open("merge/#{hash}") do |file|
+            @repo.working_write(dirty_file, file.read, flags)
+            working_file  = working_changeset[dirty_file]
+            other_file    = other_changeset[ofile]
+            ancestor_file = @repo.versioned_file(afile, :file_id => anode)
+            r = MergeUI.file_merge(@repo, @local, lfile, working_file, other_file, ancestor_file)
+          end
+          
+          mark_resolved(dirty_file) if r.nil? || r == false
+          return r
+        end
+        
+        ##
+        # Public access to writing the file.
+        def save
+          write!
+        end
+        alias_method :save!, :save
+        
+        private
+        
+        ##
+        # Reads in the merge state and sets up all our instance variables.
+        #
+        def read!
+          @state = {}
+          ignore_missing_files do
+            local_node = nil
+            @repo.open("merge/state") do |file|
+              get_node = true
+              file.each_line do |line|
+                if get_node
+                  local_node = line.chomp
+                  get_node = false
+                else
+                  parts = line.chomp.split("\0")
+                  @state[parts[0]] = parts[1..-1]
+                end
+              end
+              @local = local_node.unhexlify
+            end
+          end
+        end
+        
+        ##
+        # Saves the merge state to disk.
+        #
+        def write!
+          @repo.open("merge/state","w") do |file|
+            file.write @local.hexlify + "\n"
+            @state.each do |key, val|
+              file.write "#{([key] + val).join("\0")}\n"
+            end
+          end
+        end
+        
+      end
+    end
+  end
+end