Class BasePackFetchConnection

    • Field Detail

      • MAX_HAVES

        private static final int MAX_HAVES
        Maximum number of 'have' lines to send before giving up.

        During negotiate(ProgressMonitor) we send at most this many commits to the remote peer as 'have' lines without an ACK response before we give up.

        See Also:
        Constant Field Values
      • MIN_CLIENT_BUFFER

        protected static final int MIN_CLIENT_BUFFER
        Amount of data the client sends before starting to read.

        Any output stream given to the client must be able to buffer this many bytes before the client will stop writing and start reading from the input stream. If the output stream blocks before this many bytes are in the send queue, the system will deadlock.

        See Also:
        Constant Field Values
      • OPTION_INCLUDE_TAG

        public static final java.lang.String OPTION_INCLUDE_TAG
        Include tags if we are also including the referenced objects.
        Since:
        2.0
        See Also:
        Constant Field Values
      • OPTION_MULTI_ACK

        public static final java.lang.String OPTION_MULTI_ACK
        Multi-ACK support for improved negotiation.
        Since:
        2.0
        See Also:
        Constant Field Values
      • OPTION_MULTI_ACK_DETAILED

        public static final java.lang.String OPTION_MULTI_ACK_DETAILED
        Multi-ACK detailed support for improved negotiation.
        Since:
        2.0
        See Also:
        Constant Field Values
      • OPTION_THIN_PACK

        public static final java.lang.String OPTION_THIN_PACK
        The client supports packs with deltas but not their bases.
        Since:
        2.0
        See Also:
        Constant Field Values
      • OPTION_SIDE_BAND

        public static final java.lang.String OPTION_SIDE_BAND
        The client supports using the side-band for progress messages.
        Since:
        2.0
        See Also:
        Constant Field Values
      • OPTION_SIDE_BAND_64K

        public static final java.lang.String OPTION_SIDE_BAND_64K
        The client supports using the 64K side-band for progress messages.
        Since:
        2.0
        See Also:
        Constant Field Values
      • OPTION_OFS_DELTA

        public static final java.lang.String OPTION_OFS_DELTA
        The client supports packs with OFS deltas.
        Since:
        2.0
        See Also:
        Constant Field Values
      • OPTION_SHALLOW

        public static final java.lang.String OPTION_SHALLOW
        The client supports shallow fetches.
        Since:
        2.0
        See Also:
        Constant Field Values
      • OPTION_NO_PROGRESS

        public static final java.lang.String OPTION_NO_PROGRESS
        The client does not want progress messages and will ignore them.
        Since:
        2.0
        See Also:
        Constant Field Values
      • OPTION_NO_DONE

        public static final java.lang.String OPTION_NO_DONE
        The client supports receiving a pack before it has sent "done".
        Since:
        2.0
        See Also:
        Constant Field Values
      • OPTION_ALLOW_TIP_SHA1_IN_WANT

        public static final java.lang.String OPTION_ALLOW_TIP_SHA1_IN_WANT
        The client supports fetching objects at the tip of any ref, even if not advertised.
        Since:
        3.1
        See Also:
        Constant Field Values
      • OPTION_ALLOW_REACHABLE_SHA1_IN_WANT

        public static final java.lang.String OPTION_ALLOW_REACHABLE_SHA1_IN_WANT
        The client supports fetching objects that are reachable from a tip of a ref that is allowed to fetch.
        Since:
        4.1
        See Also:
        Constant Field Values
      • OPTION_FILTER

        public static final java.lang.String OPTION_FILTER
        The client specified a filter expression.
        Since:
        5.0
        See Also:
        Constant Field Values
      • reachableCommits

        private RevCommitList<RevCommit> reachableCommits
        All commits that are immediately reachable by a local ref.
      • REACHABLE

        final RevFlag REACHABLE
        Marks an object as having all its dependencies.
      • COMMON

        final RevFlag COMMON
        Marks a commit known to both sides of the connection.
      • ADVERTISED

        final RevFlag ADVERTISED
        Marks a commit listed in the advertised refs.
      • thinPack

        private boolean thinPack
      • sideband

        private boolean sideband
      • includeTags

        private boolean includeTags
      • allowOfsDelta

        private boolean allowOfsDelta
      • noDone

        private boolean noDone
      • noProgress

        private boolean noProgress
      • lockMessage

        private java.lang.String lockMessage
      • maxHaves

        private int maxHaves
      • filterSpec

        private final FilterSpec filterSpec
        Either FilterSpec.NO_FILTER for a filter that doesn't filter anything, or a filter that indicates what and what not to send to the server.
    • Constructor Detail

      • BasePackFetchConnection

        public BasePackFetchConnection​(PackTransport packTransport)
        Create a new connection to fetch using the native git transport.
        Parameters:
        packTransport - the transport.
    • Method Detail

      • fetch

        public final void fetch​(ProgressMonitor monitor,
                                java.util.Collection<Ref> want,
                                java.util.Set<ObjectId> have)
                         throws TransportException
        Fetch objects we don't have but that are reachable from advertised refs.

        Only one call per connection is allowed. Subsequent calls will result in TransportException.

        Implementations are free to use network connections as necessary to efficiently (for both client and server) transfer objects from the remote repository into this repository. When possible implementations should avoid replacing/overwriting/duplicating an object already available in the local destination repository. Locally available objects and packs should always be preferred over remotely available objects and packs. Transport.isFetchThin() should be honored if applicable.

        Specified by:
        fetch in interface FetchConnection
        Parameters:
        monitor - progress monitor to inform the end-user about the amount of work completed, or to indicate cancellation. Implementations should poll the monitor at regular intervals to look for cancellation requests from the user.
        want - one or more refs advertised by this connection that the caller wants to store locally.
        have - additional objects known to exist in the destination repository, especially if they aren't yet reachable by the ref database. Connections should take this set as an addition to what is reachable through all Refs, not in replace of it.
        Throws:
        TransportException - objects could not be copied due to a network failure, protocol error, or error on remote side, or connection was already used for fetch.
      • fetch

        public final void fetch​(ProgressMonitor monitor,
                                java.util.Collection<Ref> want,
                                java.util.Set<ObjectId> have,
                                java.io.OutputStream outputStream)
                         throws TransportException
        Fetch objects we don't have but that are reachable from advertised refs.

        Only one call per connection is allowed. Subsequent calls will result in TransportException.

        Implementations are free to use network connections as necessary to efficiently (for both client and server) transfer objects from the remote repository into this repository. When possible implementations should avoid replacing/overwriting/duplicating an object already available in the local destination repository. Locally available objects and packs should always be preferred over remotely available objects and packs. Transport.isFetchThin() should be honored if applicable.

        Specified by:
        fetch in interface FetchConnection
        Parameters:
        monitor - progress monitor to inform the end-user about the amount of work completed, or to indicate cancellation. Implementations should poll the monitor at regular intervals to look for cancellation requests from the user.
        want - one or more refs advertised by this connection that the caller wants to store locally.
        have - additional objects known to exist in the destination repository, especially if they aren't yet reachable by the ref database. Connections should take this set as an addition to what is reachable through all Refs, not in replace of it.
        outputStream - OutputStream to write sideband messages to
        Throws:
        TransportException - objects could not be copied due to a network failure, protocol error, or error on remote side, or connection was already used for fetch.
      • didFetchIncludeTags

        public boolean didFetchIncludeTags()
        Did the last FetchConnection.fetch(ProgressMonitor, Collection, Set) get tags?

        Some Git aware transports are able to implicitly grab an annotated tag if TagOpt.AUTO_FOLLOW or TagOpt.FETCH_TAGS was selected and the object the tag peels to (references) was transferred as part of the last FetchConnection.fetch(ProgressMonitor, Collection, Set) call. If it is possible for such tags to have been included in the transfer this method returns true, allowing the caller to attempt tag discovery.

        By returning only true/false (and not the actual list of tags obtained) the transport itself does not need to be aware of whether or not tags were included in the transfer.

        Specified by:
        didFetchIncludeTags in interface FetchConnection
        Returns:
        true if the last fetch call implicitly included tag objects; false if tags were not implicitly obtained.
      • didFetchTestConnectivity

        public boolean didFetchTestConnectivity()
        Did the last FetchConnection.fetch(ProgressMonitor, Collection, Set) validate graph?

        Some transports walk the object graph on the client side, with the client looking for what objects it is missing and requesting them individually from the remote peer. By virtue of completing the fetch call the client implicitly tested the object connectivity, as every object in the graph was either already local or was requested successfully from the peer. In such transports this method returns true.

        Some transports assume the remote peer knows the Git object graph and is able to supply a fully connected graph to the client (although it may only be transferring the parts the client does not yet have). Its faster to assume such remote peers are well behaved and send the correct response to the client. In such transports this method returns false.

        Specified by:
        didFetchTestConnectivity in interface FetchConnection
        Returns:
        true if the last fetch had to perform a connectivity check on the client side in order to succeed; false if the last fetch assumed the remote peer supplied a complete graph.
      • doFetch

        protected void doFetch​(ProgressMonitor monitor,
                               java.util.Collection<Ref> want,
                               java.util.Set<ObjectId> have,
                               java.io.OutputStream outputStream)
                        throws TransportException
        Execute common ancestor negotiation and fetch the objects.
        Parameters:
        monitor - progress monitor to receive status updates. If the monitor is the NullProgressMonitor.INSTANCE, then the no-progress option enabled.
        want - the advertised remote references the caller wants to fetch.
        have - additional objects to assume that already exist locally. This will be added to the set of objects reachable from the destination repository's references.
        outputStream - ouputStream to write sideband messages to
        Throws:
        TransportException - if any exception occurs.
        Since:
        3.0
      • close

        public void close()

        Close any resources used by this connection.

        If the remote repository is contacted by a network socket this method must close that network socket, disconnecting the two peers. If the remote repository is actually local (same system) this method must close any open file handles used to read the "remote" repository.

        If additional messages were produced by the remote peer, these should still be retained in the connection instance for Connection.getMessages().

        AutoClosable.close() declares that it throws Exception. Implementers shouldn't throw checked exceptions. This override narrows the signature to prevent them from doing so.

        Specified by:
        close in interface java.lang.AutoCloseable
        Specified by:
        close in interface Connection
        Overrides:
        close in class BasePackConnection
      • maxTimeWanted

        private int maxTimeWanted​(java.util.Collection<Ref> wants)
      • markReachable

        private void markReachable​(java.util.Set<ObjectId> have,
                                   int maxTime)
                            throws java.io.IOException
        Throws:
        java.io.IOException
      • parseReachable

        private void parseReachable​(ObjectId id)
      • sendWants

        private boolean sendWants​(java.util.Collection<Ref> want)
                           throws java.io.IOException
        Throws:
        java.io.IOException
      • negotiateBegin

        private void negotiateBegin()
                             throws java.io.IOException
        Throws:
        java.io.IOException
      • markRefsAdvertised

        private void markRefsAdvertised()
      • markAdvertised

        private void markAdvertised​(AnyObjectId id)
      • receivePack

        private void receivePack​(ProgressMonitor monitor,
                                 java.io.OutputStream outputStream)
                          throws java.io.IOException
        Throws:
        java.io.IOException
      • onReceivePack

        protected void onReceivePack()
        Notification event delivered just before the pack is received from the network. This event can be used by RPC such as TransportHttp to disable its request magic and ensure the pack stream is read correctly.
        Since:
        2.0