Class DfsReader

java.lang.Object
org.eclipse.jgit.lib.ObjectReader
org.eclipse.jgit.internal.storage.dfs.DfsReader
All Implemented Interfaces:
AutoCloseable, ObjectReuseAsIs

public class DfsReader extends ObjectReader implements ObjectReuseAsIs
Reader to access repository content through.

See the base ObjectReader documentation for details. Notably, a reader is not thread safe.

  • Constructor Details

    • DfsReader

      protected DfsReader(DfsObjDatabase db)
      Initialize a new DfsReader
      Parameters:
      db - parent DfsObjDatabase.
  • Method Details

    • newReader

      public ObjectReader newReader()
      Description copied from class: ObjectReader
      Construct a new reader from the same data.

      Applications can use this method to build a new reader from the same data source, but for an different thread.

      Specified by:
      newReader in class ObjectReader
      Returns:
      a brand new reader, using the same data source.
    • setAvoidUnreachableObjects

      public void setAvoidUnreachableObjects(boolean avoid)
      Description copied from class: ObjectReader
      Advise the reader to avoid unreachable objects.

      While enabled the reader will skip over anything previously proven to be unreachable. This may be dangerous in the face of concurrent writes.

      Overrides:
      setAvoidUnreachableObjects in class ObjectReader
      Parameters:
      avoid - true to avoid unreachable objects.
    • getBitmapIndex

      public BitmapIndex getBitmapIndex() throws IOException
      Description copied from class: ObjectReader
      An index that can be used to speed up ObjectWalks.
      Overrides:
      getBitmapIndex in class ObjectReader
      Returns:
      the index or null if one does not exist.
      Throws:
      IOException - when the index fails to load
    • getCommitGraph

      public Optional<CommitGraph> getCommitGraph() throws IOException
      Description copied from class: ObjectReader
      Get the commit-graph for this repository if available.

      The commit graph can be created/modified/deleted while the repository is open and specific implementations decide when to refresh it.

      Overrides:
      getCommitGraph in class ObjectReader
      Returns:
      the commit-graph or empty if the commit-graph does not exist or is invalid; always returns empty when core.commitGraph is false (default is false).
      Throws:
      IOException - if it cannot open any of the underlying commit graph.
    • getCachedPacksAndUpdate

      public Collection<CachedPack> getCachedPacksAndUpdate(BitmapIndex.BitmapBuilder needBitmap) throws IOException
      Description copied from interface: ObjectReuseAsIs
      Obtain the available cached packs that match the bitmap and update the bitmap by removing the items that are in the CachedPack.

      A cached pack has known starting points and may be sent entirely as-is, with almost no effort on the sender's part.

      Specified by:
      getCachedPacksAndUpdate in interface ObjectReuseAsIs
      Parameters:
      needBitmap - the bitmap that contains all of the objects the client wants.
      Returns:
      the available cached packs.
      Throws:
      IOException - the cached packs cannot be listed from the repository. Callers may choose to ignore this and continue as-if there were no cached packs.
    • resolve

      public Collection<ObjectId> resolve(AbbreviatedObjectId id) throws IOException
      Description copied from class: ObjectReader
      Resolve an abbreviated ObjectId to its full form. This method searches for an ObjectId that begins with the abbreviation, and returns at least some matching candidates. If the returned collection is empty, no objects start with this abbreviation. The abbreviation doesn't belong to this repository, or the repository lacks the necessary objects to complete it. If the collection contains exactly one member, the abbreviation is (currently) unique within this database. There is a reasonably high probability that the returned id is what was previously abbreviated. If the collection contains 2 or more members, the abbreviation is not unique. In this case the implementation is only required to return at least 2 candidates to signal the abbreviation has conflicts. User friendly implementations should return as many candidates as reasonably possible, as the caller may be able to disambiguate further based on context. However since databases can be very large (e.g. 10 million objects) returning 625,000 candidates for the abbreviation "0" is simply unreasonable, so implementors should draw the line at around 256 matches.
      Specified by:
      resolve in class ObjectReader
      Parameters:
      id - abbreviated id to resolve to a complete identity. The abbreviation must have a length of at least 2.
      Returns:
      candidates that begin with the abbreviated identity.
      Throws:
      IOException - the object store cannot be read.
    • has

      public boolean has(AnyObjectId objectId) throws IOException
      Description copied from class: ObjectReader
      Does the requested object exist in this database?
      Overrides:
      has in class ObjectReader
      Parameters:
      objectId - identity of the object to test for existence of.
      Returns:
      true if the specified object is stored in this database.
      Throws:
      IOException - the object store cannot be accessed.
    • open

      Description copied from class: ObjectReader
      Open an object from this database.
      Specified by:
      open in class ObjectReader
      Parameters:
      objectId - identity of the object to open.
      typeHint - hint about the type of object being requested, e.g. Constants.OBJ_BLOB; ObjectReader.OBJ_ANY if the object type is not known, or does not matter to the caller.
      Returns:
      a ObjectLoader for accessing the object.
      Throws:
      MissingObjectException - the object does not exist.
      IncorrectObjectTypeException - typeHint was not OBJ_ANY, and the object's actual type does not match typeHint.
      IOException - the object store cannot be accessed.
    • getShallowCommits

      public Set<ObjectId> getShallowCommits()
      Description copied from class: ObjectReader
      Returns IDs for those commits which should be considered as shallow.
      Specified by:
      getShallowCommits in class ObjectReader
      Returns:
      IDs of shallow commits
    • open

      public <T extends ObjectId> AsyncObjectLoaderQueue<T> open(Iterable<T> objectIds, boolean reportMissing)
      Description copied from class: ObjectReader
      Asynchronous object opening.
      Overrides:
      open in class ObjectReader
      Type Parameters:
      T - type of ObjectId
      Parameters:
      objectIds - objects to open from the object store. The supplied collection must not be modified until the queue has finished.
      reportMissing - if true missing objects are reported by calling failure with a MissingObjectException. This may be more expensive for the implementation to guarantee. If false the implementation may choose to report MissingObjectException, or silently skip over the object with no warning.
      Returns:
      queue to read the objects from.
    • getObjectSize

      public <T extends ObjectId> AsyncObjectSizeQueue<T> getObjectSize(Iterable<T> objectIds, boolean reportMissing)
      Description copied from class: ObjectReader
      Asynchronous object size lookup.
      Overrides:
      getObjectSize in class ObjectReader
      Type Parameters:
      T - type of ObjectId
      Parameters:
      objectIds - objects to get the size of from the object store. The supplied collection must not be modified until the queue has finished.
      reportMissing - if true missing objects are reported by calling failure with a MissingObjectException. This may be more expensive for the implementation to guarantee. If false the implementation may choose to report MissingObjectException, or silently skip over the object with no warning.
      Returns:
      queue to read object sizes from.
    • getObjectSize

      public long getObjectSize(AnyObjectId objectId, int typeHint) throws MissingObjectException, IncorrectObjectTypeException, IOException
      Description copied from class: ObjectReader
      Get only the size of an object.

      The default implementation of this method opens an ObjectLoader. Databases are encouraged to override this if a faster access method is available to them.

      Overrides:
      getObjectSize in class ObjectReader
      Parameters:
      objectId - identity of the object to open.
      typeHint - hint about the type of object being requested, e.g. Constants.OBJ_BLOB; ObjectReader.OBJ_ANY if the object type is not known, or does not matter to the caller.
      Returns:
      size of object in bytes.
      Throws:
      MissingObjectException - the object does not exist.
      IncorrectObjectTypeException - typeHint was not OBJ_ANY, and the object's actual type does not match typeHint.
      IOException - the object store cannot be accessed.
    • isNotLargerThan

      public boolean isNotLargerThan(AnyObjectId objectId, int typeHint, long limit) throws MissingObjectException, IncorrectObjectTypeException, IOException
      Description copied from class: ObjectReader
      Check if the object size is less or equal than certain value By default, it reads the object from storage to get the size. Subclasses can implement more efficient lookups.
      Overrides:
      isNotLargerThan in class ObjectReader
      Parameters:
      objectId - identity of the object to open.
      typeHint - hint about the type of object being requested, e.g. Constants.OBJ_BLOB; ObjectReader.OBJ_ANY if the object type is not known, or does not matter to the caller.
      limit - threshold value for the size of the object in bytes.
      Returns:
      true if the object size is equal or smaller than the threshold value
      Throws:
      MissingObjectException - the object does not exist.
      IncorrectObjectTypeException - typeHint was not OBJ_ANY, and the object's actual type does not match typeHint.
      IOException - the object store cannot be accessed.
    • newObjectToPack

      public org.eclipse.jgit.internal.storage.dfs.DfsObjectToPack newObjectToPack(AnyObjectId objectId, int type)
      Description copied from interface: ObjectReuseAsIs
      Allocate a new PackWriter state structure for an object.

      PackWriter allocates these objects to keep track of the per-object state, and how to load the objects efficiently into the generated stream. Implementers may subclass this type with additional object state, such as to remember what file and offset contains the object's pack encoded data.

      Specified by:
      newObjectToPack in interface ObjectReuseAsIs
      Parameters:
      objectId - the id of the object that will be packed.
      type - the Git type of the object that will be packed.
      Returns:
      a new instance for this object.
    • selectObjectRepresentation

      public void selectObjectRepresentation(PackWriter packer, ProgressMonitor monitor, Iterable<ObjectToPack> objects) throws IOException, MissingObjectException
      Description copied from interface: ObjectReuseAsIs
      Select the best object representation for a packer.

      Implementations should iterate through all available representations of an object, and pass them in turn to the PackWriter though PackWriter.select(ObjectToPack, StoredObjectRepresentation) so the writer can select the most suitable representation to reuse into the output stream.

      If the implementation returns CachedPack from ObjectReuseAsIs.getCachedPacksAndUpdate(BitmapBuilder) it must consider the representation of any object that is stored in any of the offered CachedPacks. PackWriter relies on this behavior to prune duplicate objects out of the pack stream when it selects a CachedPack and the object was also reached through the thin-pack enumeration.

      The implementation may choose to consider multiple objects at once on concurrent threads, but must evaluate all representations of an object within the same thread.

      Specified by:
      selectObjectRepresentation in interface ObjectReuseAsIs
      Parameters:
      packer - the packer that will write the object in the near future.
      monitor - progress monitor, implementation should update the monitor once for each item in the iteration when selection is done.
      objects - the objects that are being packed.
      Throws:
      MissingObjectException - there is no representation available for the object, as it is no longer in the repository. Packing will abort.
      IOException - the repository cannot be accessed. Packing will abort.
    • copyObjectAsIs

      public void copyObjectAsIs(PackOutputStream out, ObjectToPack otp, boolean validate) throws IOException, StoredObjectRepresentationNotAvailableException
      Description copied from interface: ObjectReuseAsIs
      Output a previously selected representation.

      PackWriter invokes this method only if a representation previously given to it by selectObjectRepresentation was chosen for reuse into the output stream. The otp argument is an instance created by this reader's own newObjectToPack, and the representation data saved within it also originated from this reader.

      Implementors must write the object header before copying the raw data to the output stream. The typical implementation is like:

       MyToPack mtp = (MyToPack) otp;
       byte[] raw;
       if (validate)
               raw = validate(mtp); // throw SORNAE here, if at all
       else
               raw = readFast(mtp);
       out.writeHeader(mtp, mtp.inflatedSize);
       out.write(raw);
       
      Specified by:
      copyObjectAsIs in interface ObjectReuseAsIs
      Parameters:
      out - stream the object should be written to.
      otp - the object's saved representation information.
      validate - if true the representation must be validated and not be corrupt before being reused. If false, validation may be skipped as it will be performed elsewhere in the processing pipeline.
      Throws:
      IOException - the stream's write method threw an exception. Packing will abort.
      StoredObjectRepresentationNotAvailableException - the previously selected representation is no longer available. If thrown before out.writeHeader the pack writer will try to find another representation, and write that one instead. If throw after out.writeHeader, packing will abort.
    • writeObjects

      public void writeObjects(PackOutputStream out, List<ObjectToPack> list) throws IOException
      Description copied from interface: ObjectReuseAsIs
      Write objects to the pack stream in roughly the order given. PackWriter invokes this method to write out one or more objects, in approximately the order specified by the iteration over the list. A simple implementation of this method would just iterate the list and output each object:
       for (ObjectToPack obj : list)
         out.writeObject(obj)
       
      However more sophisticated implementors may try to perform some (small) reordering to access objects that are stored close to each other at roughly the same time. Implementations may choose to write objects out of order, but this may increase pack file size due to using a larger header format to reach a delta base that is later in the stream. It may also reduce data locality for the reader, slowing down data access. Invoking PackOutputStream.writeObject(ObjectToPack) will cause ObjectReuseAsIs.copyObjectAsIs(PackOutputStream, ObjectToPack, boolean) to be invoked recursively on this if the current object is scheduled for reuse.
      Specified by:
      writeObjects in interface ObjectReuseAsIs
      Parameters:
      out - the stream to write each object to.
      list - the list of objects to write. Objects should be written in approximately this order. Implementors may resort the list elements in-place during writing if desired.
      Throws:
      IOException - the stream cannot be written to, or one or more required objects cannot be accessed from the object database.
    • copyPackAsIs

      public void copyPackAsIs(PackOutputStream out, CachedPack pack) throws IOException
      Description copied from interface: ObjectReuseAsIs
      Append an entire pack's contents onto the output stream.

      The entire pack, excluding its header and trailing footer is sent.

      Specified by:
      copyPackAsIs in interface ObjectReuseAsIs
      Parameters:
      out - stream to append the pack onto.
      pack - the cached pack to send.
      Throws:
      IOException - the pack cannot be read, or stream did not accept a write.
    • getIoStats

      public DfsReaderIoStats getIoStats()
      Get IO statistics accumulated by this reader.
      Returns:
      IO statistics accumulated by this reader.
    • addPackLoadListener

      protected void addPackLoadListener(DfsReader.PackLoadListener listener)
      Add listener to record loads by this reader
      Parameters:
      listener - a listener
    • close

      public void close()

      Release any resources used by this reader.

      A reader that has been released can be used again, but may need to be released after the subsequent usage.

      Release the current window cursor.

      Specified by:
      close in interface AutoCloseable
      Specified by:
      close in class ObjectReader