amp 0.5.0

data/lib/amp/repository/journal.rb

@@ -0,0 +1,203 @@
+module Amp
+  class StandardErrorReporter
+    def self.report str
+      STDERR.puts str
+    end
+  end
+  
+  ##
+  # 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}
+    
+    attr_accessor :report, :journal, :after_close
+    
+    ##
+    # @return [Amp::Journal]
+    def self.start(file, opts=DEFAULT_OPTS)
+      journal = Journal.new opts[:reporter], file, &opts[:after_close]
+      
+      if block_given?
+        begin
+          yield journal
+        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(reporter=StandardErrorReporter, journal="journal#{rand(10000)}", createmode=nil, &after_close)      
+      @count = 1
+      @reporter = reporter
+      @after_close = after_close
+      @entries = []
+      @map = {}
+      @journal_file = journal
+      
+      @file = open(@journal_file, "w")
+      
+      FileUtils.chmod(createmode & 0666, @journal_file) unless createmode.nil?
+    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 file the name of the file we're modifying and need to track
+    # @param offset the length of the file we're storing
+    # @param data any extra data to hold onto
+    def add_entry(array)
+      file, offset, data = array[0], array[1], array[2]
+      return if @map[file]
+      @entries << {:file => file, :offset => offset, :data => data}
+      @map[file] = @entries.size - 1
+      
+      # tell the journal how to truncate this revision
+      @file.write("#{file}\0#{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
+      @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
+      return unless @entries && @entries.any?
+      @reporter.report "transaction abort!\n"
+      @entries.each do |hash|
+        file, offset = hash[:file], hash[:offset]
+        begin
+          fp = open(File.join(".hg","store",file), "a")
+          fp.truncate offset
+          fp.close
+        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(file)
+      files = {}
+      fp = open(file)
+      fp.each_line do |line|
+        file, offset = line.split("\0")
+        files[file] = offset.to_i
+      end
+      fp.close
+      files.each do |file, offset|
+        if o > 0
+          fp = open(file, "a")
+          fp.truncate o.to_i
+          fp.close
+        else
+          fp = open(f)
+          fn = fp.path
+          fp.close
+          FileUtils.safe_unlink fn
+        end
+      end
+      FileUtils.safe_unlink file
+    end
+  end
+end
+          

data/lib/amp/repository/lock.rb

@@ -0,0 +1,207 @@
+module Amp
+  module Repositories
+    ##
+    # = 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

data/lib/amp/repository/repositories/bundle_repository.rb

@@ -0,0 +1,214 @@
+module Amp
+  module Repositories
+    
+    ##
+    # = BundleRepository
+    # This class represents a read-only repository that combines both local
+    # repository data with a bundle file. The bundle file contains un-merged-in
+    # changesets - this is useful for, say, previewing the results of a pull
+    # action.
+    #
+    # A bundle is stored in the following manner:
+    #  - Changelog entries
+    #  - Manifest  entries
+    #  - Modified File entry #1
+    #  - Modified File entry #2
+    #  - ...
+    #  - Modified file entry #N
+    class BundleRepository < LocalRepository
+      def initialize(path="", config=nil, bundle_name="")
+        @temp_parent = nil
+        # Figure out what to do here - if there's no current local repository, that
+        # takes some special work.
+        begin
+          super(path, false, config) # don't create, just look for a repository
+        rescue
+          # Ok, no local repository. Let's make one really quickly.
+          @temp_parent = File.join(Dir.tmpdir, File.amp_make_tmpname("bundlerepo"))
+          File.mkdir(@temp_parent)
+          tmprepo = LocalRepository.new(@temp_parent, true, config) # true -> create
+          super(@temp_parent, false, config) # and proceed as scheduled!
+        end
+        
+        # Set up our URL variable, if anyone asks us what it is
+        if path
+          @url = "bundle:#{path}+#{bundle_name}"
+        else
+          @url = "bundle:#{bundle_name}"
+        end
+        
+        @temp_file = nil
+        @bundle_file = File.open(bundle_name, "r")
+        
+        @bundle_file.seek(0, IO::SEEK_END)
+        Amp::UI.debug "Bundle File Size: #{@bundle_file.tell}"
+        @bundle_file.seek(0, IO::SEEK_SET)
+        
+        # OK, now for the fun part - check the header to see if we're compressed.
+        header = @bundle_file.read(6)
+        # And switch based on that header
+        if !header.start_with?("HG")
+          # Not even an HG file. FML. Bail
+          raise abort("#{bundle_name}: not a Mercurial bundle file")
+        elsif not header.start_with?("HG10")
+          # Not a version we understand, bail
+          raise abort("#{bundle_name}: unknown bundle version")
+        elsif header == "HG10BZ" || header == "HG10GZ"
+          # Compressed! We'll have to save to a new file, because this could get messy.
+          temp_file = Tempfile.new("hg-bundle-hg10un", @root)
+          @temp_file_path = temp_file.path
+          # Are we BZip, or GZip?
+          case header
+          when "HG10BZ"
+            # fuck BZip. Seriously.
+            headerio = StringIO.new "BZ", (ruby_19? ? "w+:ASCII-8BIT" : "w+")
+            input = Amp::Support::MultiIO.new(headerio, @bundle_file)
+            decomp = BZ2::Reader.new(input)
+          when "HG10GZ"
+            # Gzip is much nicer.
+            decomp = Zlib::GzipReader.new(@bundle_file)
+          end
+          
+          # We're writing this in an uncompressed fashion, of course.
+          @temp_file.write("HG10UN")
+          # While we can uncompressed....
+          while !r.eof? do
+            # Write the uncompressed data to our new file!
+            @temp_file.write decomp.read(4096)
+          end
+          # and close 'er up
+          @temp_file.close
+          
+          # Close the compressed bundle file
+          @bundle_file.close
+          # And re-open the uncompressed bundle file!
+          @bundle_file = File.open(@temp_file_path, "r")
+          # Skip the header.
+          @bundle_file.seek(6)
+        elsif header == "HG10UN"
+          # uncompressed, do nothing
+        else
+          # We have no idae what's going on
+          raise abort("#{bundle_name}: unknown bundle compression type")
+        end
+        # This hash stores pairs of {filename => position_in_bundle_file_of_this_file} 
+        @bundle_files_positions = {}
+      end
+      
+      ##
+      # Gets the changelog of the repository. This is different from {LocalRepository#changelog}
+      # in that it uses a {BundleChangeLog}. Also, since the manifest is stored in the bundle
+      # directly after the changelog, by checking our position in the bundle file, we can save
+      # where the bundle_file is stored.
+      #
+      # @return [BundleChangeLog] the changelog for this repository.
+      def changelog
+        @changelog      ||= Bundles::BundleChangeLog.new(@store.opener, @bundle_file)
+        @manifest_start ||= @bundle_file.tell
+        @changelog
+      end
+      
+      ##
+      # Gets the manifest of the repository. This is different from {LocalRepository#manifest}
+      # in that it uses a {BundleManifest}. The file logs are stored in the bundle directly
+      # after the manifest, so once we load the manifest, we save where the file logs start
+      # when we are done loading the manifest.
+      #
+      # This has the side-effect of loading the changelog, if it hasn't been loaded already -#
+      # this is necessary because the manifest changesets are stored after the changelog changesets,
+      # and we must fully load the changelog changesets to know where to look for the manifest changesets.
+      #
+      # Don't look at me, I didn't design the file format.
+      #
+      # @return [BundleChangeLog] the changelog for this repository.
+      def manifest
+        return @manifest if @manifest
+        @bundle_file.seek manifest_start
+        @manifest   ||= Bundles::BundleManifest.new @store.opener, @bundle_file, proc {|n| changelog.rev(n) }
+        @file_start ||= @bundle_file.tell
+        @manifest
+      end
+      
+      ##
+      # Returns the position in the bundle file where the manifest changesets are located.
+      # This involves loading the changelog first - see {#manifest}
+      #
+      # @return [Integer] the position in the bundle file where we can find the manifest
+      #   changesets.
+      def manifest_start
+        changelog && @manifest_start
+      end
+      
+      ##
+      # Returns the position in the bundle file where the file log changesets are located.
+      # This involves loading the changelog and the manifest first - see {#manifest}.
+      #
+      # @return [Integer] the position in the bundle file where we can find the file-log
+      #   changesets.
+      def file_start
+        manifest && @file_start
+      end
+      
+      ##
+      # Gets the file-log for the given path, so we can look at an individual
+      # file's history, for example. However, we need to be cognizant of files that
+      # traverse the local repository's history as well as the bundle file.
+      # 
+      # @param [String] f the path to the file
+      # @return [FileLog] a filelog (a type of revision log) for the given file
+      def file(filename)
+        
+        # Load the file-log positions now - we didn't do this in the constructor for a reason
+        # (if they don't ask for them, don't load them!)
+        if @bundle_files_positions.empty?
+          # Jump to the file position
+          @bundle_file.seek file_start
+          while true
+            # get a changegroup chunk - it'll be the filename
+            chunk = RevlogSupport::ChangeGroup.get_chunk @bundle_file
+            # no filename? bail
+            break if chunk.nil? || chunk.empty?
+            
+            # Now that we've read the filename, we're at the start of the changelogs for that
+            # file. So let's save this position for later.
+            @bundle_files_positions[chunk] = @bundle_file.tell
+            # Then read chunks until we get to the next file!
+            RevlogSupport::ChangeGroup.each_chunk(@bundle_file) {|c|}
+          end
+        end
+        
+        # Remove leading slash
+        filename = filename.shift("/")
+        
+        # Does this file cross local history as well as the bundle?
+        if @bundle_files_positions[filename]
+          # If so, we'll need to make a BundleFileLog. Meh. 
+          @bundle_file.seek @bundle_files_positions[filename]
+          Bundles::BundleFileLog.new @store.opener, filename, @bundle_file, proc {|n| changelog.rev(n) }
+        else
+          # Nope? Make a normal FileLog!
+          FileLog.new(@store.opener, filename)
+        end
+      end  
+      
+      ##
+      # Gets the URL for this repository - unused, I believe.
+      #
+      # @return [String] the URL for the repository
+      def url; @url; end
+      
+      ##
+      # Closes the repository - in this case, it closes the bundle_file. Analogous to closing
+      # an SSHRepository's socket.
+      def close
+        @bundle_file.close
+      end
+      
+      # We can't copy files. Read-only.
+      def can_copy?; false; end
+      # Gets the current working directory. Not sure why we need this.
+      def get_cwd; Dir.pwd; end
+      
+    end
+  end
+end