amp 0.5.2 → 0.5.3

data/lib/amp/repository/journal.rb

@@ -1,203 +0,0 @@
-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

@@ -1,207 +0,0 @@
-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

@@ -1,214 +0,0 @@
-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