Transport.java

  1. /*
  2.  * Copyright (C) 2008, 2009 Google Inc.
  3.  * Copyright (C) 2008, Marek Zawirski <marek.zawirski@gmail.com>
  4.  * Copyright (C) 2008, Robin Rosenberg <robin.rosenberg@dewire.com>
  5.  * Copyright (C) 2008, 2022 Shawn O. Pearce <spearce@spearce.org> and others
  6.  *
  7.  * This program and the accompanying materials are made available under the
  8.  * terms of the Eclipse Distribution License v. 1.0 which is available at
  9.  * https://www.eclipse.org/org/documents/edl-v10.php.
  10.  *
  11.  * SPDX-License-Identifier: BSD-3-Clause
  12.  */

  14. package org.eclipse.jgit.transport;

  16. import static java.nio.charset.StandardCharsets.UTF_8;
  17. import static java.util.Objects.requireNonNull;

  19. import java.io.BufferedReader;
  20. import java.io.IOException;
  21. import java.io.InputStreamReader;
  22. import java.io.OutputStream;
  23. import java.io.PrintStream;
  24. import java.lang.ref.WeakReference;
  25. import java.lang.reflect.Field;
  26. import java.lang.reflect.Modifier;
  27. import java.net.URISyntaxException;
  28. import java.net.URL;
  29. import java.text.MessageFormat;
  30. import java.time.Instant;
  31. import java.util.ArrayList;
  32. import java.util.Collection;
  33. import java.util.Collections;
  34. import java.util.Enumeration;
  35. import java.util.LinkedHashSet;
  36. import java.util.LinkedList;
  37. import java.util.List;
  38. import java.util.Map;
  39. import java.util.Vector;
  40. import java.util.concurrent.CopyOnWriteArrayList;

  42. import org.eclipse.jgit.annotations.NonNull;
  43. import org.eclipse.jgit.annotations.Nullable;
  44. import org.eclipse.jgit.errors.NotSupportedException;
  45. import org.eclipse.jgit.errors.TransportException;
  46. import org.eclipse.jgit.hooks.Hooks;
  47. import org.eclipse.jgit.hooks.PrePushHook;
  48. import org.eclipse.jgit.internal.JGitText;
  49. import org.eclipse.jgit.lib.Constants;
  50. import org.eclipse.jgit.lib.ObjectChecker;
  51. import org.eclipse.jgit.lib.ObjectId;
  52. import org.eclipse.jgit.lib.ProgressMonitor;
  53. import org.eclipse.jgit.lib.Ref;
  54. import org.eclipse.jgit.lib.Repository;
  55. import org.eclipse.jgit.storage.pack.PackConfig;

  57. /**
  58.  * Connects two Git repositories together and copies objects between them.
  59.  * <p>
  60.  * A transport can be used for either fetching (copying objects into the
  61.  * caller's repository from the remote repository) or pushing (copying objects
  62.  * into the remote repository from the caller's repository). Each transport
  63.  * implementation is responsible for the details associated with establishing
  64.  * the network connection(s) necessary for the copy, as well as actually
  65.  * shuffling data back and forth.
  66.  * <p>
  67.  * Transport instances and the connections they create are not thread-safe.
  68.  * Callers must ensure a transport is accessed by only one thread at a time.
  69.  */
  70. public abstract class Transport implements AutoCloseable {
  71.     /** Type of operation a Transport is being opened for. */
  72.     public enum Operation {
  73.         /** Transport is to fetch objects locally. */
  74.         FETCH,
  75.         /** Transport is to push objects remotely. */
  76.         PUSH;
  77.     }

  79.     private static final List<WeakReference<TransportProtocol>> protocols =
  80.         new CopyOnWriteArrayList<>();

  82.     static {
  83.         // Registration goes backwards in order of priority.
  84.         register(TransportLocal.PROTO_LOCAL);
  85.         register(TransportBundleFile.PROTO_BUNDLE);
  86.         register(TransportAmazonS3.PROTO_S3);
  87.         register(TransportGitAnon.PROTO_GIT);
  88.         register(TransportSftp.PROTO_SFTP);
  89.         register(TransportHttp.PROTO_FTP);
  90.         register(TransportHttp.PROTO_HTTP);
  91.         register(TransportGitSsh.PROTO_SSH);

  93.         registerByService();
  94.     }

  96.     private static void registerByService() {
  97.         ClassLoader ldr = Thread.currentThread().getContextClassLoader();
  98.         if (ldr == null)
  99.             ldr = Transport.class.getClassLoader();
  100.         Enumeration<URL> catalogs = catalogs(ldr);
  101.         while (catalogs.hasMoreElements())
  102.             scan(ldr, catalogs.nextElement());
  103.     }

  105.     private static Enumeration<URL> catalogs(ClassLoader ldr) {
  106.         try {
  107.             String prefix = "META-INF/services/"; //$NON-NLS-1$
  108.             String name = prefix + Transport.class.getName();
  109.             return ldr.getResources(name);
  110.         } catch (IOException err) {
  111.             return new Vector<URL>().elements();
  112.         }
  113.     }

  115.     private static void scan(ClassLoader ldr, URL url) {
  116.         try (BufferedReader br = new BufferedReader(
  117.                 new InputStreamReader(url.openStream(), UTF_8))) {
  118.             String line;
  119.             while ((line = br.readLine()) != null) {
  120.                 line = line.trim();
  121.                 if (line.length() == 0)
  122.                     continue;
  123.                 int comment = line.indexOf('#');
  124.                 if (comment == 0)
  125.                     continue;
  126.                 if (comment != -1)
  127.                     line = line.substring(0, comment).trim();
  128.                 load(ldr, line);
  129.             }
  130.         } catch (IOException e) {
  131.             // Ignore errors
  132.         }
  133.     }

  135.     private static void load(ClassLoader ldr, String cn) {
  136.         Class<?> clazz;
  137.         try {
  138.             clazz = Class.forName(cn, false, ldr);
  139.         } catch (ClassNotFoundException notBuiltin) {
  140.             // Doesn't exist, even though the service entry is present.
  141.             //
  142.             return;
  143.         }

  145.         for (Field f : clazz.getDeclaredFields()) {
  146.             if ((f.getModifiers() & Modifier.STATIC) == Modifier.STATIC
  147.                     && TransportProtocol.class.isAssignableFrom(f.getType())) {
  148.                 TransportProtocol proto;
  149.                 try {
  150.                     proto = (TransportProtocol) f.get(null);
  151.                 } catch (IllegalArgumentException | IllegalAccessException e) {
  152.                     // If we cannot access the field, don't.
  153.                     continue;
  154.                 }
  155.                 if (proto != null)
  156.                     register(proto);
  157.             }
  158.         }
  159.     }

  161.     /**
  162.      * Register a TransportProtocol instance for use during open.
  163.      * <p>
  164.      * Protocol definitions are held by WeakReference, allowing them to be
  165.      * garbage collected when the calling application drops all strongly held
  166.      * references to the TransportProtocol. Therefore applications should use a
  167.      * singleton pattern as described in
  168.      * {@link org.eclipse.jgit.transport.TransportProtocol}'s class
  169.      * documentation to ensure their protocol does not get disabled by garbage
  170.      * collection earlier than expected.
  171.      * <p>
  172.      * The new protocol is registered in front of all earlier protocols, giving
  173.      * it higher priority than the built-in protocol definitions.
  174.      *
  175.      * @param proto
  176.      *            the protocol definition. Must not be null.
  177.      */
  178.     public static void register(TransportProtocol proto) {
  179.         protocols.add(0, new WeakReference<>(proto));
  180.     }

  182.     /**
  183.      * Unregister a TransportProtocol instance.
  184.      * <p>
  185.      * Unregistering a protocol usually isn't necessary, as protocols are held
  186.      * by weak references and will automatically clear when they are garbage
  187.      * collected by the JVM. Matching is handled by reference equality, so the
  188.      * exact reference given to {@link #register(TransportProtocol)} must be
  189.      * used.
  190.      *
  191.      * @param proto
  192.      *            the exact object previously given to register.
  193.      */
  194.     public static void unregister(TransportProtocol proto) {
  195.         for (WeakReference<TransportProtocol> ref : protocols) {
  196.             TransportProtocol refProto = ref.get();
  197.             if (refProto == null || refProto == proto)
  198.                 protocols.remove(ref);
  199.         }
  200.     }

  202.     /**
  203.      * Obtain a copy of the registered protocols.
  204.      *
  205.      * @return an immutable copy of the currently registered protocols.
  206.      */
  207.     public static List<TransportProtocol> getTransportProtocols() {
  208.         int cnt = protocols.size();
  209.         List<TransportProtocol> res = new ArrayList<>(cnt);
  210.         for (WeakReference<TransportProtocol> ref : protocols) {
  211.             TransportProtocol proto = ref.get();
  212.             if (proto != null)
  213.                 res.add(proto);
  214.             else
  215.                 protocols.remove(ref);
  216.         }
  217.         return Collections.unmodifiableList(res);
  218.     }

  220.     /**
  221.      * Open a new transport instance to connect two repositories.
  222.      * <p>
  223.      * This method assumes
  224.      * {@link org.eclipse.jgit.transport.Transport.Operation#FETCH}.
  225.      *
  226.      * @param local
  227.      *            existing local repository.
  228.      * @param remote
  229.      *            location of the remote repository - may be URI or remote
  230.      *            configuration name.
  231.      * @return the new transport instance. Never null. In case of multiple URIs
  232.      *         in remote configuration, only the first is chosen.
  233.      * @throws java.net.URISyntaxException
  234.      *             the location is not a remote defined in the configuration
  235.      *             file and is not a well-formed URL.
  236.      * @throws org.eclipse.jgit.errors.NotSupportedException
  237.      *             the protocol specified is not supported.
  238.      * @throws org.eclipse.jgit.errors.TransportException
  239.      *             the transport cannot open this URI.
  240.      */
  241.     public static Transport open(Repository local, String remote)
  242.             throws NotSupportedException, URISyntaxException,
  243.             TransportException {
  244.         return open(local, remote, Operation.FETCH);
  245.     }

  247.     /**
  248.      * Open a new transport instance to connect two repositories.
  249.      *
  250.      * @param local
  251.      *            existing local repository.
  252.      * @param remote
  253.      *            location of the remote repository - may be URI or remote
  254.      *            configuration name.
  255.      * @param op
  256.      *            planned use of the returned Transport; the URI may differ
  257.      *            based on the type of connection desired.
  258.      * @return the new transport instance. Never null. In case of multiple URIs
  259.      *         in remote configuration, only the first is chosen.
  260.      * @throws java.net.URISyntaxException
  261.      *             the location is not a remote defined in the configuration
  262.      *             file and is not a well-formed URL.
  263.      * @throws org.eclipse.jgit.errors.NotSupportedException
  264.      *             the protocol specified is not supported.
  265.      * @throws org.eclipse.jgit.errors.TransportException
  266.      *             the transport cannot open this URI.
  267.      */
  268.     public static Transport open(final Repository local, final String remote,
  269.             final Operation op) throws NotSupportedException,
  270.             URISyntaxException, TransportException {
  271.         if (local != null) {
  272.             final RemoteConfig cfg = new RemoteConfig(local.getConfig(), remote);
  273.             if (doesNotExist(cfg)) {
  274.                 return open(local, new URIish(remote), null);
  275.             }
  276.             return open(local, cfg, op);
  277.         }
  278.         return open(new URIish(remote));

  280.     }

  282.     /**
  283.      * Open new transport instances to connect two repositories.
  284.      * <p>
  285.      * This method assumes
  286.      * {@link org.eclipse.jgit.transport.Transport.Operation#FETCH}.
  287.      *
  288.      * @param local
  289.      *            existing local repository.
  290.      * @param remote
  291.      *            location of the remote repository - may be URI or remote
  292.      *            configuration name.
  293.      * @return the list of new transport instances for every URI in remote
  294.      *         configuration.
  295.      * @throws java.net.URISyntaxException
  296.      *             the location is not a remote defined in the configuration
  297.      *             file and is not a well-formed URL.
  298.      * @throws org.eclipse.jgit.errors.NotSupportedException
  299.      *             the protocol specified is not supported.
  300.      * @throws org.eclipse.jgit.errors.TransportException
  301.      *             the transport cannot open this URI.
  302.      */
  303.     public static List<Transport> openAll(final Repository local,
  304.             final String remote) throws NotSupportedException,
  305.             URISyntaxException, TransportException {
  306.         return openAll(local, remote, Operation.FETCH);
  307.     }

  309.     /**
  310.      * Open new transport instances to connect two repositories.
  311.      *
  312.      * @param local
  313.      *            existing local repository.
  314.      * @param remote
  315.      *            location of the remote repository - may be URI or remote
  316.      *            configuration name.
  317.      * @param op
  318.      *            planned use of the returned Transport; the URI may differ
  319.      *            based on the type of connection desired.
  320.      * @return the list of new transport instances for every URI in remote
  321.      *         configuration.
  322.      * @throws java.net.URISyntaxException
  323.      *             the location is not a remote defined in the configuration
  324.      *             file and is not a well-formed URL.
  325.      * @throws org.eclipse.jgit.errors.NotSupportedException
  326.      *             the protocol specified is not supported.
  327.      * @throws org.eclipse.jgit.errors.TransportException
  328.      *             the transport cannot open this URI.
  329.      */
  330.     public static List<Transport> openAll(final Repository local,
  331.             final String remote, final Operation op)
  332.             throws NotSupportedException, URISyntaxException,
  333.             TransportException {
  334.         final RemoteConfig cfg = new RemoteConfig(local.getConfig(), remote);
  335.         if (doesNotExist(cfg)) {
  336.             final ArrayList<Transport> transports = new ArrayList<>(1);
  337.             transports.add(open(local, new URIish(remote), null));
  338.             return transports;
  339.         }
  340.         return openAll(local, cfg, op);
  341.     }

  343.     /**
  344.      * Open a new transport instance to connect two repositories.
  345.      * <p>
  346.      * This method assumes
  347.      * {@link org.eclipse.jgit.transport.Transport.Operation#FETCH}.
  348.      *
  349.      * @param local
  350.      *            existing local repository.
  351.      * @param cfg
  352.      *            configuration describing how to connect to the remote
  353.      *            repository.
  354.      * @return the new transport instance. Never null. In case of multiple URIs
  355.      *         in remote configuration, only the first is chosen.
  356.      * @throws org.eclipse.jgit.errors.NotSupportedException
  357.      *             the protocol specified is not supported.
  358.      * @throws org.eclipse.jgit.errors.TransportException
  359.      *             the transport cannot open this URI.
  360.      * @throws java.lang.IllegalArgumentException
  361.      *             if provided remote configuration doesn't have any URI
  362.      *             associated.
  363.      */
  364.     public static Transport open(Repository local, RemoteConfig cfg)
  365.             throws NotSupportedException, TransportException {
  366.         return open(local, cfg, Operation.FETCH);
  367.     }

  369.     /**
  370.      * Open a new transport instance to connect two repositories.
  371.      *
  372.      * @param local
  373.      *            existing local repository.
  374.      * @param cfg
  375.      *            configuration describing how to connect to the remote
  376.      *            repository.
  377.      * @param op
  378.      *            planned use of the returned Transport; the URI may differ
  379.      *            based on the type of connection desired.
  380.      * @return the new transport instance. Never null. In case of multiple URIs
  381.      *         in remote configuration, only the first is chosen.
  382.      * @throws org.eclipse.jgit.errors.NotSupportedException
  383.      *             the protocol specified is not supported.
  384.      * @throws org.eclipse.jgit.errors.TransportException
  385.      *             the transport cannot open this URI.
  386.      * @throws java.lang.IllegalArgumentException
  387.      *             if provided remote configuration doesn't have any URI
  388.      *             associated.
  389.      */
  390.     public static Transport open(final Repository local,
  391.             final RemoteConfig cfg, final Operation op)
  392.             throws NotSupportedException, TransportException {
  393.         final List<URIish> uris = getURIs(cfg, op);
  394.         if (uris.isEmpty())
  395.             throw new IllegalArgumentException(MessageFormat.format(
  396.                     JGitText.get().remoteConfigHasNoURIAssociated, cfg.getName()));
  397.         final Transport tn = open(local, uris.get(0), cfg.getName());
  398.         tn.applyConfig(cfg);
  399.         return tn;
  400.     }

  402.     /**
  403.      * Open new transport instances to connect two repositories.
  404.      * <p>
  405.      * This method assumes
  406.      * {@link org.eclipse.jgit.transport.Transport.Operation#FETCH}.
  407.      *
  408.      * @param local
  409.      *            existing local repository.
  410.      * @param cfg
  411.      *            configuration describing how to connect to the remote
  412.      *            repository.
  413.      * @return the list of new transport instances for every URI in remote
  414.      *         configuration.
  415.      * @throws org.eclipse.jgit.errors.NotSupportedException
  416.      *             the protocol specified is not supported.
  417.      * @throws org.eclipse.jgit.errors.TransportException
  418.      *             the transport cannot open this URI.
  419.      */
  420.     public static List<Transport> openAll(final Repository local,
  421.             final RemoteConfig cfg) throws NotSupportedException,
  422.             TransportException {
  423.         return openAll(local, cfg, Operation.FETCH);
  424.     }

  426.     /**
  427.      * Open new transport instances to connect two repositories.
  428.      *
  429.      * @param local
  430.      *            existing local repository.
  431.      * @param cfg
  432.      *            configuration describing how to connect to the remote
  433.      *            repository.
  434.      * @param op
  435.      *            planned use of the returned Transport; the URI may differ
  436.      *            based on the type of connection desired.
  437.      * @return the list of new transport instances for every URI in remote
  438.      *         configuration.
  439.      * @throws org.eclipse.jgit.errors.NotSupportedException
  440.      *             the protocol specified is not supported.
  441.      * @throws org.eclipse.jgit.errors.TransportException
  442.      *             the transport cannot open this URI.
  443.      */
  444.     public static List<Transport> openAll(final Repository local,
  445.             final RemoteConfig cfg, final Operation op)
  446.             throws NotSupportedException, TransportException {
  447.         final List<URIish> uris = getURIs(cfg, op);
  448.         final List<Transport> transports = new ArrayList<>(uris.size());
  449.         for (URIish uri : uris) {
  450.             final Transport tn = open(local, uri, cfg.getName());
  451.             tn.applyConfig(cfg);
  452.             transports.add(tn);
  453.         }
  454.         return transports;
  455.     }

  457.     private static List<URIish> getURIs(final RemoteConfig cfg,
  458.             final Operation op) {
  459.         switch (op) {
  460.         case FETCH:
  461.             return cfg.getURIs();
  462.         case PUSH: {
  463.             List<URIish> uris = cfg.getPushURIs();
  464.             if (uris.isEmpty())
  465.                 uris = cfg.getURIs();
  466.             return uris;
  467.         }
  468.         default:
  469.             throw new IllegalArgumentException(op.toString());
  470.         }
  471.     }

  473.     private static boolean doesNotExist(RemoteConfig cfg) {
  474.         return cfg.getURIs().isEmpty() && cfg.getPushURIs().isEmpty();
  475.     }

  477.     /**
  478.      * Open a new transport instance to connect two repositories.
  479.      *
  480.      * @param local
  481.      *            existing local repository.
  482.      * @param uri
  483.      *            location of the remote repository.
  484.      * @return the new transport instance. Never null.
  485.      * @throws org.eclipse.jgit.errors.NotSupportedException
  486.      *             the protocol specified is not supported.
  487.      * @throws org.eclipse.jgit.errors.TransportException
  488.      *             the transport cannot open this URI.
  489.      */
  490.     public static Transport open(Repository local, URIish uri)
  491.             throws NotSupportedException, TransportException {
  492.         return open(local, uri, null);
  493.     }

  495.     /**
  496.      * Open a new transport instance to connect two repositories.
  497.      *
  498.      * @param local
  499.      *            existing local repository.
  500.      * @param uri
  501.      *            location of the remote repository.
  502.      * @param remoteName
  503.      *            name of the remote, if the remote as configured in
  504.      *            {@code local}; otherwise null.
  505.      * @return the new transport instance. Never null.
  506.      * @throws org.eclipse.jgit.errors.NotSupportedException
  507.      *             the protocol specified is not supported.
  508.      * @throws org.eclipse.jgit.errors.TransportException
  509.      *             the transport cannot open this URI.
  510.      */
  511.     public static Transport open(Repository local, URIish uri, String remoteName)
  512.             throws NotSupportedException, TransportException {
  513.         for (WeakReference<TransportProtocol> ref : protocols) {
  514.             TransportProtocol proto = ref.get();
  515.             if (proto == null) {
  516.                 protocols.remove(ref);
  517.                 continue;
  518.             }

  520.             if (proto.canHandle(uri, local, remoteName)) {
  521.                 Transport tn = proto.open(uri, local, remoteName);
  522.                 tn.remoteName = remoteName;
  523.                 return tn;
  524.             }
  525.         }

  527.         throw new NotSupportedException(MessageFormat.format(JGitText.get().URINotSupported, uri));
  528.     }

  530.     /**
  531.      * Open a new transport with no local repository.
  532.      * <p>
  533.      * Note that the resulting transport instance can not be used for fetching
  534.      * or pushing, but only for reading remote refs.
  535.      *
  536.      * @param uri a {@link org.eclipse.jgit.transport.URIish} object.
  537.      * @return new Transport instance
  538.      * @throws org.eclipse.jgit.errors.NotSupportedException
  539.      * @throws org.eclipse.jgit.errors.TransportException
  540.      */
  541.     public static Transport open(URIish uri) throws NotSupportedException, TransportException {
  542.         for (WeakReference<TransportProtocol> ref : protocols) {
  543.             TransportProtocol proto = ref.get();
  544.             if (proto == null) {
  545.                 protocols.remove(ref);
  546.                 continue;
  547.             }

  549.             if (proto.canHandle(uri, null, null))
  550.                 return proto.open(uri);
  551.         }

  553.         throw new NotSupportedException(MessageFormat.format(JGitText.get().URINotSupported, uri));
  554.     }

  556.     /**
  557.      * Convert push remote refs update specification from
  558.      * {@link org.eclipse.jgit.transport.RefSpec} form to
  559.      * {@link org.eclipse.jgit.transport.RemoteRefUpdate}. Conversion expands
  560.      * wildcards by matching source part to local refs. expectedOldObjectId in
  561.      * RemoteRefUpdate is set when specified in leases. Tracking branch is
  562.      * configured if RefSpec destination matches source of any fetch ref spec
  563.      * for this transport remote configuration.
  564.      *
  565.      * @param db
  566.      *            local database.
  567.      * @param specs
  568.      *            collection of RefSpec to convert.
  569.      * @param leases
  570.      *            map from ref to lease (containing expected old object id)
  571.      * @param fetchSpecs
  572.      *            fetch specifications used for finding localtracking refs. May
  573.      *            be null or empty collection.
  574.      * @return collection of set up
  575.      *         {@link org.eclipse.jgit.transport.RemoteRefUpdate}.
  576.      * @throws java.io.IOException
  577.      *             when problem occurred during conversion or specification set
  578.      *             up: most probably, missing objects or refs.
  579.      * @since 4.7
  580.      */
  581.     public static Collection<RemoteRefUpdate> findRemoteRefUpdatesFor(
  582.             final Repository db, final Collection<RefSpec> specs,
  583.             final Map<String, RefLeaseSpec> leases,
  584.             Collection<RefSpec> fetchSpecs) throws IOException {
  585.         if (fetchSpecs == null)
  586.             fetchSpecs = Collections.emptyList();
  587.         final List<RemoteRefUpdate> result = new LinkedList<>();
  588.         final Collection<RefSpec> procRefs = expandPushWildcardsFor(db, specs);

  590.         for (RefSpec spec : procRefs) {
  591.             if (spec.isMatching()) {
  592.                 result.add(new RemoteRefUpdate(db, spec.isForceUpdate(),
  593.                         fetchSpecs));
  594.                 continue;
  595.             }
  596.             String srcSpec = spec.getSource();
  597.             final Ref srcRef = db.findRef(srcSpec);
  598.             if (srcRef != null)
  599.                 srcSpec = srcRef.getName();

  601.             String destSpec = spec.getDestination();
  602.             if (destSpec == null) {
  603.                 // No destination (no-colon in ref-spec), DWIMery assumes src
  604.                 //
  605.                 destSpec = srcSpec;
  606.             }

  608.             if (srcRef != null && !destSpec.startsWith(Constants.R_REFS)) {
  609.                 // Assume the same kind of ref at the destination, e.g.
  610.                 // "refs/heads/foo:master", DWIMery assumes master is also
  611.                 // under "refs/heads/".
  612.                 //
  613.                 final String n = srcRef.getName();
  614.                 final int kindEnd = n.indexOf('/', Constants.R_REFS.length());
  615.                 destSpec = n.substring(0, kindEnd + 1) + destSpec;
  616.             }

  618.             final boolean forceUpdate = spec.isForceUpdate();
  619.             final String localName = findTrackingRefName(destSpec, fetchSpecs);
  620.             final RefLeaseSpec leaseSpec = leases.get(destSpec);
  621.             final ObjectId expected = leaseSpec == null ? null :
  622.                 db.resolve(leaseSpec.getExpected());
  623.             final RemoteRefUpdate rru = new RemoteRefUpdate(db, srcSpec,
  624.                     destSpec, forceUpdate, localName, expected);
  625.             result.add(rru);
  626.         }
  627.         return result;
  628.     }

  630.     /**
  631.      * Convert push remote refs update specification from
  632.      * {@link org.eclipse.jgit.transport.RefSpec} form to
  633.      * {@link org.eclipse.jgit.transport.RemoteRefUpdate}. Conversion expands
  634.      * wildcards by matching source part to local refs. expectedOldObjectId in
  635.      * RemoteRefUpdate is always set as null. Tracking branch is configured if
  636.      * RefSpec destination matches source of any fetch ref spec for this
  637.      * transport remote configuration.
  638.      *
  639.      * @param db
  640.      *            local database.
  641.      * @param specs
  642.      *            collection of RefSpec to convert.
  643.      * @param fetchSpecs
  644.      *            fetch specifications used for finding localtracking refs. May
  645.      *            be null or empty collection.
  646.      * @return collection of set up
  647.      *         {@link org.eclipse.jgit.transport.RemoteRefUpdate}.
  648.      * @throws java.io.IOException
  649.      *             when problem occurred during conversion or specification set
  650.      *             up: most probably, missing objects or refs.
  651.      */
  652.     public static Collection<RemoteRefUpdate> findRemoteRefUpdatesFor(
  653.             final Repository db, final Collection<RefSpec> specs,
  654.             Collection<RefSpec> fetchSpecs) throws IOException {
  655.         return findRemoteRefUpdatesFor(db, specs, Collections.emptyMap(),
  656.                            fetchSpecs);
  657.     }

  659.     private static Collection<RefSpec> expandPushWildcardsFor(
  660.             final Repository db, final Collection<RefSpec> specs)
  661.             throws IOException {
  662.         final Collection<RefSpec> procRefs = new LinkedHashSet<>();

  664.         List<Ref> localRefs = null;
  665.         for (RefSpec spec : specs) {
  666.             if (!spec.isMatching() && spec.isWildcard()) {
  667.                 if (localRefs == null) {
  668.                     localRefs = db.getRefDatabase().getRefs();
  669.                 }
  670.                 for (Ref localRef : localRefs) {
  671.                     if (spec.matchSource(localRef)) {
  672.                         procRefs.add(spec.expandFromSource(localRef));
  673.                     }
  674.                 }
  675.             } else {
  676.                 procRefs.add(spec);
  677.             }
  678.         }
  679.         return procRefs;
  680.     }

  682.     static String findTrackingRefName(final String remoteName,
  683.             final Collection<RefSpec> fetchSpecs) {
  684.         // try to find matching tracking refs
  685.         for (RefSpec fetchSpec : fetchSpecs) {
  686.             if (fetchSpec.matchSource(remoteName)) {
  687.                 if (fetchSpec.isWildcard()) {
  688.                     return fetchSpec.expandFromSource(remoteName)
  689.                             .getDestination();
  690.                 }
  691.                 return fetchSpec.getDestination();
  692.             }
  693.         }
  694.         return null;
  695.     }

  697.     /**
  698.      * Default setting for {@link #fetchThin} option.
  699.      */
  700.     public static final boolean DEFAULT_FETCH_THIN = true;

  702.     /**
  703.      * Default setting for {@link #pushThin} option.
  704.      */
  705.     public static final boolean DEFAULT_PUSH_THIN = false;

  707.     /**
  708.      * Default setting for {@link #pushUseBitmaps} option.
  709.      *
  710.      * @since 6.4
  711.      */
  712.     public static final boolean DEFAULT_PUSH_USE_BITMAPS = true;

  714.     /**
  715.      * Specification for fetch or push operations, to fetch or push all tags.
  716.      * Acts as --tags.
  717.      */
  718.     public static final RefSpec REFSPEC_TAGS = new RefSpec(
  719.             "refs/tags/*:refs/tags/*"); //$NON-NLS-1$

  721.     /**
  722.      * Specification for push operation, to push all refs under refs/heads. Acts
  723.      * as --all.
  724.      */
  725.     public static final RefSpec REFSPEC_PUSH_ALL = new RefSpec(
  726.             "refs/heads/*:refs/heads/*"); //$NON-NLS-1$

  728.     /** The repository this transport fetches into, or pushes out of. */
  729.     protected final Repository local;

  731.     /** The URI used to create this transport. */
  732.     protected final URIish uri;

  734.     /** Name of the upload pack program, if it must be executed. */
  735.     private String optionUploadPack = RemoteConfig.DEFAULT_UPLOAD_PACK;

  737.     /** Specifications to apply during fetch. */
  738.     private List<RefSpec> fetch = Collections.emptyList();

  740.     /**
  741.      * How {@link #fetch(ProgressMonitor, Collection)} should handle tags.
  742.      * <p>
  743.      * We default to {@link TagOpt#NO_TAGS} so as to avoid fetching annotated
  744.      * tags during one-shot fetches used for later merges. This prevents
  745.      * dragging down tags from repositories that we do not have established
  746.      * tracking branches for. If we do not track the source repository, we most
  747.      * likely do not care about any tags it publishes.
  748.      */
  749.     private TagOpt tagopt = TagOpt.NO_TAGS;

  751.     /** Should fetch request thin-pack if remote repository can produce it. */
  752.     private boolean fetchThin = DEFAULT_FETCH_THIN;

  754.     /** Name of the receive pack program, if it must be executed. */
  755.     private String optionReceivePack = RemoteConfig.DEFAULT_RECEIVE_PACK;

  757.     /** Specifications to apply during push. */
  758.     private List<RefSpec> push = Collections.emptyList();

  760.     /** Should push produce thin-pack when sending objects to remote repository. */
  761.     private boolean pushThin = DEFAULT_PUSH_THIN;

  763.     /** Should push be all-or-nothing atomic behavior? */
  764.     private boolean pushAtomic;

  766.     /** Should push use bitmaps? */
  767.     private boolean pushUseBitmaps = DEFAULT_PUSH_USE_BITMAPS;

  769.     /** Should push just check for operation result, not really push. */
  770.     private boolean dryRun;

  772.     /** Should an incoming (fetch) transfer validate objects? */
  773.     private ObjectChecker objectChecker;

  775.     /** Should refs no longer on the source be pruned from the destination? */
  776.     private boolean removeDeletedRefs;

  778.     private FilterSpec filterSpec = FilterSpec.NO_FILTER;

  780.     /** Timeout in seconds to wait before aborting an IO read or write. */
  781.     private int timeout;

  783.     /** Pack configuration used by this transport to make pack file. */
  784.     private PackConfig packConfig;

  786.     /** Assists with authentication the connection. */
  787.     private CredentialsProvider credentialsProvider;

  789.     /** The option strings associated with the push operation. */
  790.     private List<String> pushOptions;

  792.     private PrintStream hookOutRedirect;

  794.     private PrintStream hookErrRedirect;

  796.     private String remoteName;

  798.     private Integer depth;

  800.     private Instant deepenSince;

  802.     private List<String> deepenNots = new ArrayList<>();

  804.     @Nullable
  805.     TransferConfig.ProtocolVersion protocol;

  807.     /**
  808.      * Create a new transport instance.
  809.      *
  810.      * @param local
  811.      *            the repository this instance will fetch into, or push out of.
  812.      *            This must be the repository passed to
  813.      *            {@link #open(Repository, URIish)}.
  814.      * @param uri
  815.      *            the URI used to access the remote repository. This must be the
  816.      *            URI passed to {@link #open(Repository, URIish)}.
  817.      */
  818.     protected Transport(Repository local, URIish uri) {
  819.         final TransferConfig tc = local.getConfig().get(TransferConfig.KEY);
  820.         this.local = local;
  821.         this.uri = uri;
  822.         this.protocol = tc.protocolVersion;
  823.         this.objectChecker = tc.newObjectChecker();
  824.         this.credentialsProvider = CredentialsProvider.getDefault();
  825.     }

  827.     /**
  828.      * Create a minimal transport instance not tied to a single repository.
  829.      *
  830.      * @param uri
  831.      *            a {@link org.eclipse.jgit.transport.URIish} object.
  832.      */
  833.     protected Transport(URIish uri) {
  834.         this.uri = uri;
  835.         this.local = null;
  836.         this.objectChecker = new ObjectChecker();
  837.         this.credentialsProvider = CredentialsProvider.getDefault();
  838.     }

  840.     /**
  841.      * Get the URI this transport connects to.
  842.      * <p>
  843.      * Each transport instance connects to at most one URI at any point in time.
  844.      *
  845.      * @return the URI describing the location of the remote repository.
  846.      */
  847.     public URIish getURI() {
  848.         return uri;
  849.     }

  851.     /**
  852.      * Get the name of the remote executable providing upload-pack service.
  853.      *
  854.      * @return typically "git-upload-pack".
  855.      */
  856.     public String getOptionUploadPack() {
  857.         return optionUploadPack;
  858.     }

  860.     /**
  861.      * Set the name of the remote executable providing upload-pack services.
  862.      *
  863.      * @param where
  864.      *            name of the executable.
  865.      */
  866.     public void setOptionUploadPack(String where) {
  867.         if (where != null && where.length() > 0)
  868.             optionUploadPack = where;
  869.         else
  870.             optionUploadPack = RemoteConfig.DEFAULT_UPLOAD_PACK;
  871.     }

  873.     /**
  874.      * Sets a {@link PrintStream} a {@link PrePushHook} may write its stdout to.
  875.      * If not set, {@link System#out} will be used.
  876.      *
  877.      * @param redirect
  878.      *            {@link PrintStream} to use; if {@code null},
  879.      *            {@link System#out} will be used
  880.      * @since 6.4
  881.      */
  882.     public void setHookOutputStream(PrintStream redirect) {
  883.         hookOutRedirect = redirect;
  884.     }

  886.     /**
  887.      * Sets a {@link PrintStream} a {@link PrePushHook} may write its stderr to.
  888.      * If not set, {@link System#err} will be used.
  889.      *
  890.      * @param redirect
  891.      *            {@link PrintStream} to use; if {@code null},
  892.      *            {@link System#err} will be used
  893.      * @since 6.4
  894.      */
  895.     public void setHookErrorStream(PrintStream redirect) {
  896.         hookErrRedirect = redirect;
  897.     }

  899.     /**
  900.      * Get the description of how annotated tags should be treated during fetch.
  901.      *
  902.      * @return option indicating the behavior of annotated tags in fetch.
  903.      */
  904.     public TagOpt getTagOpt() {
  905.         return tagopt;
  906.     }

  908.     /**
  909.      * Set the description of how annotated tags should be treated on fetch.
  910.      *
  911.      * @param option
  912.      *            method to use when handling annotated tags.
  913.      */
  914.     public void setTagOpt(TagOpt option) {
  915.         tagopt = option != null ? option : TagOpt.AUTO_FOLLOW;
  916.     }

  918.     /**
  919.      * Default setting is: {@link #DEFAULT_FETCH_THIN}
  920.      *
  921.      * @return true if fetch should request thin-pack when possible; false
  922.      *         otherwise
  923.      * @see PackTransport
  924.      */
  925.     public boolean isFetchThin() {
  926.         return fetchThin;
  927.     }

  929.     /**
  930.      * Set the thin-pack preference for fetch operation. Default setting is:
  931.      * {@link #DEFAULT_FETCH_THIN}
  932.      *
  933.      * @param fetchThin
  934.      *            true when fetch should request thin-pack when possible; false
  935.      *            when it shouldn't
  936.      * @see PackTransport
  937.      */
  938.     public void setFetchThin(boolean fetchThin) {
  939.         this.fetchThin = fetchThin;
  940.     }

  942.     /**
  943.      * Whether fetch will verify if received objects are formatted correctly.
  944.      *
  945.      * @return true if fetch will verify received objects are formatted
  946.      *         correctly. Validating objects requires more CPU time on the
  947.      *         client side of the connection.
  948.      */
  949.     public boolean isCheckFetchedObjects() {
  950.         return getObjectChecker() != null;
  951.     }

  953.     /**
  954.      * Configure if checking received objects is enabled
  955.      *
  956.      * @param check
  957.      *            true to enable checking received objects; false to assume all
  958.      *            received objects are valid.
  959.      * @see #setObjectChecker(ObjectChecker)
  960.      */
  961.     public void setCheckFetchedObjects(boolean check) {
  962.         if (check && objectChecker == null)
  963.             setObjectChecker(new ObjectChecker());
  964.         else if (!check && objectChecker != null)
  965.             setObjectChecker(null);
  966.     }

  968.     /**
  969.      * Get configured object checker for received objects
  970.      *
  971.      * @return configured object checker for received objects, or null.
  972.      * @since 3.6
  973.      */
  974.     public ObjectChecker getObjectChecker() {
  975.         return objectChecker;
  976.     }

  978.     /**
  979.      * Set the object checker to verify each received object with
  980.      *
  981.      * @param impl
  982.      *            if non-null the object checking instance to verify each
  983.      *            received object with; null to disable object checking.
  984.      * @since 3.6
  985.      */
  986.     public void setObjectChecker(ObjectChecker impl) {
  987.         objectChecker = impl;
  988.     }

  990.     /**
  991.      * Default setting is:
  992.      * {@link org.eclipse.jgit.transport.RemoteConfig#DEFAULT_RECEIVE_PACK}
  993.      *
  994.      * @return remote executable providing receive-pack service for pack
  995.      *         transports.
  996.      * @see PackTransport
  997.      */
  998.     public String getOptionReceivePack() {
  999.         return optionReceivePack;
  1000.     }

  1002.     /**
  1003.      * Set remote executable providing receive-pack service for pack transports.
  1004.      * Default setting is:
  1005.      * {@link org.eclipse.jgit.transport.RemoteConfig#DEFAULT_RECEIVE_PACK}
  1006.      *
  1007.      * @param optionReceivePack
  1008.      *            remote executable, if null or empty default one is set;
  1009.      */
  1010.     public void setOptionReceivePack(String optionReceivePack) {
  1011.         if (optionReceivePack != null && optionReceivePack.length() > 0)
  1012.             this.optionReceivePack = optionReceivePack;
  1013.         else
  1014.             this.optionReceivePack = RemoteConfig.DEFAULT_RECEIVE_PACK;
  1015.     }

  1017.     /**
  1018.      * Default setting is: {@value #DEFAULT_PUSH_THIN}
  1019.      *
  1020.      * @return true if push should produce thin-pack in pack transports
  1021.      * @see PackTransport
  1022.      */
  1023.     public boolean isPushThin() {
  1024.         return pushThin;
  1025.     }

  1027.     /**
  1028.      * Set thin-pack preference for push operation. Default setting is:
  1029.      * {@value #DEFAULT_PUSH_THIN}
  1030.      *
  1031.      * @param pushThin
  1032.      *            true when push should produce thin-pack in pack transports;
  1033.      *            false when it shouldn't
  1034.      * @see PackTransport
  1035.      */
  1036.     public void setPushThin(boolean pushThin) {
  1037.         this.pushThin = pushThin;
  1038.     }

  1040.     /**
  1041.      * Default setting is false.
  1042.      *
  1043.      * @return true if push requires all-or-nothing atomic behavior.
  1044.      * @since 4.2
  1045.      */
  1046.     public boolean isPushAtomic() {
  1047.         return pushAtomic;
  1048.     }

  1050.     /**
  1051.      * Request atomic push (all references succeed, or none do).
  1052.      * <p>
  1053.      * Server must also support atomic push. If the server does not support the
  1054.      * feature the push will abort without making changes.
  1055.      *
  1056.      * @param atomic
  1057.      *            true when push should be an all-or-nothing operation.
  1058.      * @see PackTransport
  1059.      * @since 4.2
  1060.      */
  1061.     public void setPushAtomic(boolean atomic) {
  1062.         this.pushAtomic = atomic;
  1063.     }

  1065.     /**
  1066.      * Default setting is: {@value #DEFAULT_PUSH_USE_BITMAPS}
  1067.      *
  1068.      * @return true if push use bitmaps.
  1069.      * @since 6.4
  1070.      */
  1071.     public boolean isPushUseBitmaps() {
  1072.         return pushUseBitmaps;
  1073.     }

  1075.     /**
  1076.      * Set whether to use bitmaps for push. Default setting is:
  1077.      * {@value #DEFAULT_PUSH_USE_BITMAPS}
  1078.      *
  1079.      * @param useBitmaps
  1080.      *            false to disable use of bitmaps for push, true otherwise.
  1081.      * @since 6.4
  1082.      */
  1083.     public void setPushUseBitmaps(boolean useBitmaps) {
  1084.         this.pushUseBitmaps = useBitmaps;
  1085.     }

  1087.     /**
  1088.      * Whether destination refs should be removed if they no longer exist at the
  1089.      * source repository.
  1090.      *
  1091.      * @return true if destination refs should be removed if they no longer
  1092.      *         exist at the source repository.
  1093.      */
  1094.     public boolean isRemoveDeletedRefs() {
  1095.         return removeDeletedRefs;
  1096.     }

  1098.     /**
  1099.      * Set whether or not to remove refs which no longer exist in the source.
  1100.      * <p>
  1101.      * If true, refs at the destination repository (local for fetch, remote for
  1102.      * push) are deleted if they no longer exist on the source side (remote for
  1103.      * fetch, local for push).
  1104.      * <p>
  1105.      * False by default, as this may cause data to become unreachable, and
  1106.      * eventually be deleted on the next GC.
  1107.      *
  1108.      * @param remove true to remove refs that no longer exist.
  1109.      */
  1110.     public void setRemoveDeletedRefs(boolean remove) {
  1111.         removeDeletedRefs = remove;
  1112.     }

  1114.     /**
  1115.      * @return the blob limit value set with {@link #setFilterBlobLimit} or
  1116.      *         {@link #setFilterSpec(FilterSpec)}, or -1 if no blob limit value
  1117.      *         was set
  1118.      * @since 5.0
  1119.      * @deprecated Use {@link #getFilterSpec()} instead
  1120.      */
  1121.     @Deprecated
  1122.     public final long getFilterBlobLimit() {
  1123.         return filterSpec.getBlobLimit();
  1124.     }

  1126.     /**
  1127.      * @param bytes exclude blobs of size greater than this
  1128.      * @since 5.0
  1129.      * @deprecated Use {@link #setFilterSpec(FilterSpec)} instead
  1130.      */
  1131.     @Deprecated
  1132.     public final void setFilterBlobLimit(long bytes) {
  1133.         setFilterSpec(FilterSpec.withBlobLimit(bytes));
  1134.     }

  1136.     /**
  1137.      * @return the last filter spec set with {@link #setFilterSpec(FilterSpec)},
  1138.      *         or {@link FilterSpec#NO_FILTER} if it was never invoked.
  1139.      * @since 5.4
  1140.      */
  1141.     public final FilterSpec getFilterSpec() {
  1142.         return filterSpec;
  1143.     }

  1145.     /**
  1146.      * @param filter a new filter to use for this transport
  1147.      * @since 5.4
  1148.      */
  1149.     public final void setFilterSpec(@NonNull FilterSpec filter) {
  1150.         filterSpec = requireNonNull(filter);
  1151.     }


  1154.     /**
  1155.      * Retrieves the depth for a shallow clone.
  1156.      *
  1157.      * @return the depth, or {@code null} if none set
  1158.      * @since 6.3
  1159.      */
  1160.     public final Integer getDepth() {
  1161.         return depth;
  1162.     }

  1164.     /**
  1165.      * Limits fetching to the specified number of commits from the tip of each
  1166.      * remote branch history.
  1167.      *
  1168.      * @param depth
  1169.      *            the depth
  1170.      * @since 6.3
  1171.      */
  1172.     public final void setDepth(int depth) {
  1173.         if (depth < 1) {
  1174.             throw new IllegalArgumentException(JGitText.get().depthMustBeAt1);
  1175.         }
  1176.         this.depth = Integer.valueOf(depth);
  1177.     }

  1179.     /**
  1180.      * Limits fetching to the specified number of commits from the tip of each
  1181.      * remote branch history.
  1182.      *
  1183.      * @param depth
  1184.      *            the depth, or {@code null} to unset the depth
  1185.      * @since 6.3
  1186.      */
  1187.     public final void setDepth(Integer depth) {
  1188.         if (depth != null && depth.intValue() < 1) {
  1189.             throw new IllegalArgumentException(JGitText.get().depthMustBeAt1);
  1190.         }
  1191.         this.depth = depth;
  1192.     }

  1194.     /**
  1195.      * @return the deepen-since for a shallow clone
  1196.      * @since 6.3
  1197.      */
  1198.     public final Instant getDeepenSince() {
  1199.         return deepenSince;
  1200.     }

  1202.     /**
  1203.      * Deepen or shorten the history of a shallow repository to include all reachable commits after a specified time.
  1204.      *
  1205.      * @param deepenSince the deepen-since. Must not be {@code null}
  1206.      * @since 6.3
  1207.      */
  1208.     public final void setDeepenSince(@NonNull Instant deepenSince) {
  1209.         this.deepenSince = deepenSince;
  1210.     }

  1212.     /**
  1213.      * @return the deepen-not for a shallow clone
  1214.      * @since 6.3
  1215.      */
  1216.     public final List<String> getDeepenNots() {
  1217.         return deepenNots;
  1218.     }

  1220.     /**
  1221.      * Deepen or shorten the history of a shallow repository to exclude commits reachable from a specified remote branch or tag.
  1222.      *
  1223.      * @param deepenNots the deepen-not. Must not be {@code null}
  1224.      * @since 6.3
  1225.      */
  1226.     public final void setDeepenNots(@NonNull List<String> deepenNots) {
  1227.         this.deepenNots = deepenNots;
  1228.     }

  1230.     /**
  1231.      * Apply provided remote configuration on this transport.
  1232.      *
  1233.      * @param cfg
  1234.      *            configuration to apply on this transport.
  1235.      */
  1236.     public void applyConfig(RemoteConfig cfg) {
  1237.         setOptionUploadPack(cfg.getUploadPack());
  1238.         setOptionReceivePack(cfg.getReceivePack());
  1239.         setTagOpt(cfg.getTagOpt());
  1240.         fetch = cfg.getFetchRefSpecs();
  1241.         push = cfg.getPushRefSpecs();
  1242.         timeout = cfg.getTimeout();
  1243.     }

  1245.     /**
  1246.      * Whether push operation should just check for possible result and not
  1247.      * really update remote refs
  1248.      *
  1249.      * @return true if push operation should just check for possible result and
  1250.      *         not really update remote refs, false otherwise - when push should
  1251.      *         act normally.
  1252.      */
  1253.     public boolean isDryRun() {
  1254.         return dryRun;
  1255.     }

  1257.     /**
  1258.      * Set dry run option for push operation.
  1259.      *
  1260.      * @param dryRun
  1261.      *            true if push operation should just check for possible result
  1262.      *            and not really update remote refs, false otherwise - when push
  1263.      *            should act normally.
  1264.      */
  1265.     public void setDryRun(boolean dryRun) {
  1266.         this.dryRun = dryRun;
  1267.     }

  1269.     /**
  1270.      * Get timeout (in seconds) before aborting an IO operation.
  1271.      *
  1272.      * @return timeout (in seconds) before aborting an IO operation.
  1273.      */
  1274.     public int getTimeout() {
  1275.         return timeout;
  1276.     }

  1278.     /**
  1279.      * Set the timeout before willing to abort an IO call.
  1280.      *
  1281.      * @param seconds
  1282.      *            number of seconds to wait (with no data transfer occurring)
  1283.      *            before aborting an IO read or write operation with this
  1284.      *            remote.
  1285.      */
  1286.     public void setTimeout(int seconds) {
  1287.         timeout = seconds;
  1288.     }

  1290.     /**
  1291.      * Get the configuration used by the pack generator to make packs.
  1292.      *
  1293.      * If {@link #setPackConfig(PackConfig)} was previously given null a new
  1294.      * PackConfig is created on demand by this method using the source
  1295.      * repository's settings.
  1296.      *
  1297.      * @return the pack configuration. Never null.
  1298.      */
  1299.     public PackConfig getPackConfig() {
  1300.         if (packConfig == null)
  1301.             packConfig = new PackConfig(local);
  1302.         return packConfig;
  1303.     }

  1305.     /**
  1306.      * Set the configuration used by the pack generator.
  1307.      *
  1308.      * @param pc
  1309.      *            configuration controlling packing parameters. If null the
  1310.      *            source repository's settings will be used.
  1311.      */
  1312.     public void setPackConfig(PackConfig pc) {
  1313.         packConfig = pc;
  1314.     }

  1316.     /**
  1317.      * A credentials provider to assist with authentication connections..
  1318.      *
  1319.      * @param credentialsProvider
  1320.      *            the credentials provider, or null if there is none
  1321.      */
  1322.     public void setCredentialsProvider(CredentialsProvider credentialsProvider) {
  1323.         this.credentialsProvider = credentialsProvider;
  1324.     }

  1326.     /**
  1327.      * The configured credentials provider.
  1328.      *
  1329.      * @return the credentials provider, or null if no credentials provider is
  1330.      *         associated with this transport.
  1331.      */
  1332.     public CredentialsProvider getCredentialsProvider() {
  1333.         return credentialsProvider;
  1334.     }

  1336.     /**
  1337.      * Get the option strings associated with the push operation
  1338.      *
  1339.      * @return the option strings associated with the push operation
  1340.      * @since 4.5
  1341.      */
  1342.     public List<String> getPushOptions() {
  1343.         return pushOptions;
  1344.     }

  1346.     /**
  1347.      * Sets the option strings associated with the push operation.
  1348.      *
  1349.      * @param pushOptions
  1350.      *            null if push options are unsupported
  1351.      * @since 4.5
  1352.      */
  1353.     public void setPushOptions(List<String> pushOptions) {
  1354.         this.pushOptions = pushOptions;
  1355.     }

  1357.     /**
  1358.      * Fetch objects and refs from the remote repository to the local one.
  1359.      * <p>
  1360.      * This is a utility function providing standard fetch behavior. Local
  1361.      * tracking refs associated with the remote repository are automatically
  1362.      * updated if this transport was created from a
  1363.      * {@link org.eclipse.jgit.transport.RemoteConfig} with fetch RefSpecs
  1364.      * defined.
  1365.      *
  1366.      * @param monitor
  1367.      *            progress monitor to inform the user about our processing
  1368.      *            activity. Must not be null. Use
  1369.      *            {@link org.eclipse.jgit.lib.NullProgressMonitor} if progress
  1370.      *            updates are not interesting or necessary.
  1371.      * @param toFetch
  1372.      *            specification of refs to fetch locally. May be null or the
  1373.      *            empty collection to use the specifications from the
  1374.      *            RemoteConfig. May contains regular and negative
  1375.      *            {@link RefSpec}s. Source for each regular RefSpec can't
  1376.      *            be null.
  1377.      * @return information describing the tracking refs updated.
  1378.      * @throws org.eclipse.jgit.errors.NotSupportedException
  1379.      *             this transport implementation does not support fetching
  1380.      *             objects.
  1381.      * @throws org.eclipse.jgit.errors.TransportException
  1382.      *             the remote connection could not be established or object
  1383.      *             copying (if necessary) failed or update specification was
  1384.      *             incorrect.
  1385.      * @since 5.11
  1386.      */
  1387.     public FetchResult fetch(final ProgressMonitor monitor,
  1388.             Collection<RefSpec> toFetch)
  1389.             throws NotSupportedException, TransportException {
  1390.         return fetch(monitor, toFetch, null);
  1391.     }

  1393.     /**
  1394.      * Fetch objects and refs from the remote repository to the local one.
  1395.      * <p>
  1396.      * This is a utility function providing standard fetch behavior. Local
  1397.      * tracking refs associated with the remote repository are automatically
  1398.      * updated if this transport was created from a
  1399.      * {@link org.eclipse.jgit.transport.RemoteConfig} with fetch RefSpecs
  1400.      * defined.
  1401.      *
  1402.      * @param monitor
  1403.      *            progress monitor to inform the user about our processing
  1404.      *            activity. Must not be null. Use
  1405.      *            {@link org.eclipse.jgit.lib.NullProgressMonitor} if progress
  1406.      *            updates are not interesting or necessary.
  1407.      * @param toFetch
  1408.      *            specification of refs to fetch locally. May be null or the
  1409.      *            empty collection to use the specifications from the
  1410.      *            RemoteConfig. May contain regular and negative
  1411.      *            {@link RefSpec}s. Source for each regular RefSpec can't
  1412.      *            be null.
  1413.      * @param branch
  1414.      *            the initial branch to check out when cloning the repository.
  1415.      *            Can be specified as ref name (<code>refs/heads/master</code>),
  1416.      *            branch name (<code>master</code>) or tag name
  1417.      *            (<code>v1.2.3</code>). The default is to use the branch
  1418.      *            pointed to by the cloned repository's HEAD and can be
  1419.      *            requested by passing {@code null} or <code>HEAD</code>.
  1420.      * @return information describing the tracking refs updated.
  1421.      * @throws org.eclipse.jgit.errors.NotSupportedException
  1422.      *             this transport implementation does not support fetching
  1423.      *             objects.
  1424.      * @throws org.eclipse.jgit.errors.TransportException
  1425.      *             the remote connection could not be established or object
  1426.      *             copying (if necessary) failed or update specification was
  1427.      *             incorrect.
  1428.      * @since 5.11
  1429.      */
  1430.     public FetchResult fetch(final ProgressMonitor monitor,
  1431.             Collection<RefSpec> toFetch, String branch)
  1432.             throws NotSupportedException,
  1433.             TransportException {
  1434.         if (toFetch == null || toFetch.isEmpty()) {
  1435.             // If the caller did not ask for anything use the defaults.
  1436.             //
  1437.             if (fetch.isEmpty())
  1438.                 throw new TransportException(JGitText.get().nothingToFetch);
  1439.             toFetch = fetch;
  1440.         } else if (!fetch.isEmpty()) {
  1441.             // If the caller asked for something specific without giving
  1442.             // us the local tracking branch see if we can update any of
  1443.             // the local tracking branches without incurring additional
  1444.             // object transfer overheads.
  1445.             //
  1446.             final Collection<RefSpec> tmp = new ArrayList<>(toFetch);
  1447.             for (RefSpec requested : toFetch) {
  1448.                 final String reqSrc = requested.getSource();
  1449.                 for (RefSpec configured : fetch) {
  1450.                     final String cfgSrc = configured.getSource();
  1451.                     final String cfgDst = configured.getDestination();
  1452.                     if (cfgSrc.equals(reqSrc) && cfgDst != null) {
  1453.                         tmp.add(configured);
  1454.                         break;
  1455.                     }
  1456.                 }
  1457.             }
  1458.             toFetch = tmp;
  1459.         }

  1461.         final FetchResult result = new FetchResult();
  1462.         new FetchProcess(this, toFetch).execute(monitor, result, branch);

  1464.         local.autoGC(monitor);

  1466.         return result;
  1467.     }

  1469.     /**
  1470.      * Push objects and refs from the local repository to the remote one.
  1471.      * <p>
  1472.      * This is a utility function providing standard push behavior. It updates
  1473.      * remote refs and send there necessary objects according to remote ref
  1474.      * update specification. After successful remote ref update, associated
  1475.      * locally stored tracking branch is updated if set up accordingly. Detailed
  1476.      * operation result is provided after execution.
  1477.      * <p>
  1478.      * For setting up remote ref update specification from ref spec, see helper
  1479.      * method {@link #findRemoteRefUpdatesFor(Collection)}, predefined refspecs
  1480.      * ({@link #REFSPEC_TAGS}, {@link #REFSPEC_PUSH_ALL}) or consider using
  1481.      * directly {@link org.eclipse.jgit.transport.RemoteRefUpdate} for more
  1482.      * possibilities.
  1483.      * <p>
  1484.      * When {@link #isDryRun()} is true, result of this operation is just
  1485.      * estimation of real operation result, no real action is performed.
  1486.      *
  1487.      * @see RemoteRefUpdate
  1488.      * @param monitor
  1489.      *            progress monitor to inform the user about our processing
  1490.      *            activity. Must not be null. Use
  1491.      *            {@link org.eclipse.jgit.lib.NullProgressMonitor} if progress
  1492.      *            updates are not interesting or necessary.
  1493.      * @param toPush
  1494.      *            specification of refs to push. May be null or the empty
  1495.      *            collection to use the specifications from the RemoteConfig
  1496.      *            converted by {@link #findRemoteRefUpdatesFor(Collection)}. No
  1497.      *            more than 1 RemoteRefUpdate with the same remoteName is
  1498.      *            allowed. These objects are modified during this call.
  1499.      * @param out
  1500.      *            output stream to write messages to
  1501.      * @return information about results of remote refs updates, tracking refs
  1502.      *         updates and refs advertised by remote repository.
  1503.      * @throws org.eclipse.jgit.errors.NotSupportedException
  1504.      *             this transport implementation does not support pushing
  1505.      *             objects.
  1506.      * @throws org.eclipse.jgit.errors.TransportException
  1507.      *             the remote connection could not be established or object
  1508.      *             copying (if necessary) failed at I/O or protocol level or
  1509.      *             update specification was incorrect.
  1510.      * @since 3.0
  1511.      */
  1512.     public PushResult push(final ProgressMonitor monitor,
  1513.             Collection<RemoteRefUpdate> toPush, OutputStream out)
  1514.             throws NotSupportedException,
  1515.             TransportException {
  1516.         if (toPush == null || toPush.isEmpty()) {
  1517.             // If the caller did not ask for anything use the defaults.
  1518.             try {
  1519.                 toPush = findRemoteRefUpdatesFor(push);
  1520.             } catch (final IOException e) {
  1521.                 throw new TransportException(MessageFormat.format(
  1522.                         JGitText.get().problemWithResolvingPushRefSpecsLocally, e.getMessage()), e);
  1523.             }
  1524.             if (toPush.isEmpty())
  1525.                 throw new TransportException(JGitText.get().nothingToPush);
  1526.         }

  1528.         PrePushHook prePush = null;
  1529.         if (local != null) {
  1530.             // Pushing will always have a local repository. But better safe than
  1531.             // sorry.
  1532.             prePush = Hooks.prePush(local, hookOutRedirect, hookErrRedirect);
  1533.             prePush.setRemoteLocation(uri.toString());
  1534.             prePush.setRemoteName(remoteName);
  1535.         }
  1536.         PushProcess pushProcess = new PushProcess(this, toPush, prePush, out);
  1537.         return pushProcess.execute(monitor);
  1538.     }

  1540.     /**
  1541.      * Push objects and refs from the local repository to the remote one.
  1542.      * <p>
  1543.      * This is a utility function providing standard push behavior. It updates
  1544.      * remote refs and sends necessary objects according to remote ref update
  1545.      * specification. After successful remote ref update, associated locally
  1546.      * stored tracking branch is updated if set up accordingly. Detailed
  1547.      * operation result is provided after execution.
  1548.      * <p>
  1549.      * For setting up remote ref update specification from ref spec, see helper
  1550.      * method {@link #findRemoteRefUpdatesFor(Collection)}, predefined refspecs
  1551.      * ({@link #REFSPEC_TAGS}, {@link #REFSPEC_PUSH_ALL}) or consider using
  1552.      * directly {@link org.eclipse.jgit.transport.RemoteRefUpdate} for more
  1553.      * possibilities.
  1554.      * <p>
  1555.      * When {@link #isDryRun()} is true, result of this operation is just
  1556.      * estimation of real operation result, no real action is performed.
  1557.      *
  1558.      * @see RemoteRefUpdate
  1559.      * @param monitor
  1560.      *            progress monitor to inform the user about our processing
  1561.      *            activity. Must not be null. Use
  1562.      *            {@link org.eclipse.jgit.lib.NullProgressMonitor} if progress
  1563.      *            updates are not interesting or necessary.
  1564.      * @param toPush
  1565.      *            specification of refs to push. May be null or the empty
  1566.      *            collection to use the specifications from the RemoteConfig
  1567.      *            converted by {@link #findRemoteRefUpdatesFor(Collection)}. No
  1568.      *            more than 1 RemoteRefUpdate with the same remoteName is
  1569.      *            allowed. These objects are modified during this call.
  1570.      * @return information about results of remote refs updates, tracking refs
  1571.      *         updates and refs advertised by remote repository.
  1572.      * @throws org.eclipse.jgit.errors.NotSupportedException
  1573.      *             this transport implementation does not support pushing
  1574.      *             objects.
  1575.      * @throws org.eclipse.jgit.errors.TransportException
  1576.      *             the remote connection could not be established or object
  1577.      *             copying (if necessary) failed at I/O or protocol level or
  1578.      *             update specification was incorrect.
  1579.      */
  1580.     public PushResult push(final ProgressMonitor monitor,
  1581.             Collection<RemoteRefUpdate> toPush) throws NotSupportedException,
  1582.             TransportException {
  1583.         return push(monitor, toPush, null);
  1584.     }

  1586.     /**
  1587.      * Convert push remote refs update specification from
  1588.      * {@link org.eclipse.jgit.transport.RefSpec} form to
  1589.      * {@link org.eclipse.jgit.transport.RemoteRefUpdate}. Conversion expands
  1590.      * wildcards by matching source part to local refs. expectedOldObjectId in
  1591.      * RemoteRefUpdate is always set as null. Tracking branch is configured if
  1592.      * RefSpec destination matches source of any fetch ref spec for this
  1593.      * transport remote configuration.
  1594.      * <p>
  1595.      * Conversion is performed for context of this transport (database, fetch
  1596.      * specifications).
  1597.      *
  1598.      * @param specs
  1599.      *            collection of RefSpec to convert.
  1600.      * @return collection of set up
  1601.      *         {@link org.eclipse.jgit.transport.RemoteRefUpdate}.
  1602.      * @throws java.io.IOException
  1603.      *             when problem occurred during conversion or specification set
  1604.      *             up: most probably, missing objects or refs.
  1605.      */
  1606.     public Collection<RemoteRefUpdate> findRemoteRefUpdatesFor(
  1607.             final Collection<RefSpec> specs) throws IOException {
  1608.         return findRemoteRefUpdatesFor(local, specs, Collections.emptyMap(),
  1609.                            fetch);
  1610.     }

  1612.     /**
  1613.      * Convert push remote refs update specification from
  1614.      * {@link org.eclipse.jgit.transport.RefSpec} form to
  1615.      * {@link org.eclipse.jgit.transport.RemoteRefUpdate}. Conversion expands
  1616.      * wildcards by matching source part to local refs. expectedOldObjectId in
  1617.      * RemoteRefUpdate is set according to leases. Tracking branch is configured
  1618.      * if RefSpec destination matches source of any fetch ref spec for this
  1619.      * transport remote configuration.
  1620.      * <p>
  1621.      * Conversion is performed for context of this transport (database, fetch
  1622.      * specifications).
  1623.      *
  1624.      * @param specs
  1625.      *            collection of RefSpec to convert.
  1626.      * @param leases
  1627.      *            map from ref to lease (containing expected old object id)
  1628.      * @return collection of set up
  1629.      *         {@link org.eclipse.jgit.transport.RemoteRefUpdate}.
  1630.      * @throws java.io.IOException
  1631.      *             when problem occurred during conversion or specification set
  1632.      *             up: most probably, missing objects or refs.
  1633.      * @since 4.7
  1634.      */
  1635.     public Collection<RemoteRefUpdate> findRemoteRefUpdatesFor(
  1636.             final Collection<RefSpec> specs,
  1637.             final Map<String, RefLeaseSpec> leases) throws IOException {
  1638.         return findRemoteRefUpdatesFor(local, specs, leases,
  1639.                            fetch);
  1640.     }

  1642.     /**
  1643.      * Begins a new connection for fetching from the remote repository.
  1644.      * <p>
  1645.      * If the transport has no local repository, the fetch connection can only
  1646.      * be used for reading remote refs.
  1647.      *
  1648.      * @return a fresh connection to fetch from the remote repository.
  1649.      * @throws org.eclipse.jgit.errors.NotSupportedException
  1650.      *             the implementation does not support fetching.
  1651.      * @throws org.eclipse.jgit.errors.TransportException
  1652.      *             the remote connection could not be established.
  1653.      */
  1654.     public abstract FetchConnection openFetch() throws NotSupportedException,
  1655.             TransportException;

  1657.     /**
  1658.      * Begins a new connection for fetching from the remote repository.
  1659.      * <p>
  1660.      * If the transport has no local repository, the fetch connection can only
  1661.      * be used for reading remote refs.
  1662.      * </p>
  1663.      * <p>
  1664.      * If the server supports git protocol V2, the {@link RefSpec}s and the
  1665.      * additional patterns, if any, are used to restrict the server's ref
  1666.      * advertisement to matching refs only.
  1667.      * </p>
  1668.      * <p>
  1669.      * Transports that want to support git protocol V2 <em>must</em> override
  1670.      * this; the default implementation ignores its arguments and calls
  1671.      * {@link #openFetch()}.
  1672.      * </p>
  1673.      *
  1674.      * @param refSpecs
  1675.      *            that will be fetched via
  1676.      *            {@link FetchConnection#fetch(ProgressMonitor, Collection, java.util.Set, OutputStream)} later
  1677.      * @param additionalPatterns
  1678.      *            that will be set as ref prefixes if the server supports git
  1679.      *            protocol V2; {@code null} values are ignored
  1680.      *
  1681.      * @return a fresh connection to fetch from the remote repository.
  1682.      * @throws org.eclipse.jgit.errors.NotSupportedException
  1683.      *             the implementation does not support fetching.
  1684.      * @throws org.eclipse.jgit.errors.TransportException
  1685.      *             the remote connection could not be established.
  1686.      * @since 5.11
  1687.      */
  1688.     public FetchConnection openFetch(Collection<RefSpec> refSpecs,
  1689.             String... additionalPatterns)
  1690.             throws NotSupportedException, TransportException {
  1691.         return openFetch();
  1692.     }

  1694.     /**
  1695.      * Begins a new connection for pushing into the remote repository.
  1696.      *
  1697.      * @return a fresh connection to push into the remote repository.
  1698.      * @throws org.eclipse.jgit.errors.NotSupportedException
  1699.      *             the implementation does not support pushing.
  1700.      * @throws org.eclipse.jgit.errors.TransportException
  1701.      *             the remote connection could not be established
  1702.      */
  1703.     public abstract PushConnection openPush() throws NotSupportedException,
  1704.             TransportException;

  1706.     /**
  1707.      * {@inheritDoc}
  1708.      * <p>
  1709.      * Close any resources used by this transport.
  1710.      * <p>
  1711.      * If the remote repository is contacted by a network socket this method
  1712.      * must close that network socket, disconnecting the two peers. If the
  1713.      * remote repository is actually local (same system) this method must close
  1714.      * any open file handles used to read the "remote" repository.
  1715.      * <p>
  1716.      * {@code AutoClosable.close()} declares that it throws {@link Exception}.
  1717.      * Implementers shouldn't throw checked exceptions. This override narrows
  1718.      * the signature to prevent them from doing so.
  1719.      */
  1720.     @Override
  1721.     public abstract void close();
  1722. }
Created with JaCoCo 0.8.7.202105040129