Java tutorial
/* * Copyright (C) 2008-2009, Google Inc. * Copyright (C) 2008, Marek Zawirski <marek.zawirski@gmail.com> * Copyright (C) 2008, Robin Rosenberg <robin.rosenberg@dewire.com> * Copyright (C) 2008, Shawn O. Pearce <spearce@spearce.org> * and other copyright owners as documented in the project's IP log. * * This program and the accompanying materials are made available * under the terms of the Eclipse Distribution License v1.0 which * accompanies this distribution, is reproduced below, and is * available at http://www.eclipse.org/org/documents/edl-v10.php * * All rights reserved. * * Redistribution and use in source and binary forms, with or * without modification, are permitted provided that the following * conditions are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * - Redistributions in binary form must reproduce the above * copyright notice, this list of conditions and the following * disclaimer in the documentation and/or other materials provided * with the distribution. * * - Neither the name of the Eclipse Foundation, Inc. nor the * names of its contributors may be used to endorse or promote * products derived from this software without specific prior * written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ package org.eclipse.jgit.transport; import static java.nio.charset.StandardCharsets.UTF_8; import static java.util.Objects.requireNonNull; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.OutputStream; import java.io.PrintStream; import java.lang.ref.WeakReference; import java.lang.reflect.Field; import java.lang.reflect.Modifier; import java.net.URISyntaxException; import java.net.URL; import java.text.MessageFormat; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.Enumeration; import java.util.LinkedHashSet; import java.util.LinkedList; import java.util.List; import java.util.Map; import java.util.Vector; import java.util.concurrent.CopyOnWriteArrayList; import org.eclipse.jgit.annotations.NonNull; import org.eclipse.jgit.api.errors.AbortedByHookException; import org.eclipse.jgit.errors.NotSupportedException; import org.eclipse.jgit.errors.TransportException; import org.eclipse.jgit.hooks.Hooks; import org.eclipse.jgit.hooks.PrePushHook; import org.eclipse.jgit.internal.JGitText; import org.eclipse.jgit.lib.Constants; import org.eclipse.jgit.lib.ObjectChecker; import org.eclipse.jgit.lib.ObjectId; import org.eclipse.jgit.lib.ProgressMonitor; import org.eclipse.jgit.lib.Ref; import org.eclipse.jgit.lib.Repository; import org.eclipse.jgit.storage.pack.PackConfig; /** * Connects two Git repositories together and copies objects between them. * <p> * A transport can be used for either fetching (copying objects into the * caller's repository from the remote repository) or pushing (copying objects * into the remote repository from the caller's repository). Each transport * implementation is responsible for the details associated with establishing * the network connection(s) necessary for the copy, as well as actually * shuffling data back and forth. * <p> * Transport instances and the connections they create are not thread-safe. * Callers must ensure a transport is accessed by only one thread at a time. */ public abstract class Transport implements AutoCloseable { /** Type of operation a Transport is being opened for. */ public enum Operation { /** Transport is to fetch objects locally. */ FETCH, /** Transport is to push objects remotely. */ PUSH; } private static final List<WeakReference<TransportProtocol>> protocols = new CopyOnWriteArrayList<>(); static { // Registration goes backwards in order of priority. register(TransportLocal.PROTO_LOCAL); register(TransportBundleFile.PROTO_BUNDLE); register(TransportAmazonS3.PROTO_S3); register(TransportGitAnon.PROTO_GIT); register(TransportSftp.PROTO_SFTP); register(TransportHttp.PROTO_FTP); register(TransportHttp.PROTO_HTTP); register(TransportGitSsh.PROTO_SSH); registerByService(); } private static void registerByService() { ClassLoader ldr = Thread.currentThread().getContextClassLoader(); if (ldr == null) ldr = Transport.class.getClassLoader(); Enumeration<URL> catalogs = catalogs(ldr); while (catalogs.hasMoreElements()) scan(ldr, catalogs.nextElement()); } private static Enumeration<URL> catalogs(ClassLoader ldr) { try { String prefix = "META-INF/services/"; //$NON-NLS-1$ String name = prefix + Transport.class.getName(); return ldr.getResources(name); } catch (IOException err) { return new Vector<URL>().elements(); } } private static void scan(ClassLoader ldr, URL url) { try (BufferedReader br = new BufferedReader(new InputStreamReader(url.openStream(), UTF_8))) { String line; while ((line = br.readLine()) != null) { line = line.trim(); if (line.length() == 0) continue; int comment = line.indexOf('#'); if (comment == 0) continue; if (comment != -1) line = line.substring(0, comment).trim(); load(ldr, line); } } catch (IOException e) { // Ignore errors } } private static void load(ClassLoader ldr, String cn) { Class<?> clazz; try { clazz = Class.forName(cn, false, ldr); } catch (ClassNotFoundException notBuiltin) { // Doesn't exist, even though the service entry is present. // return; } for (Field f : clazz.getDeclaredFields()) { if ((f.getModifiers() & Modifier.STATIC) == Modifier.STATIC && TransportProtocol.class.isAssignableFrom(f.getType())) { TransportProtocol proto; try { proto = (TransportProtocol) f.get(null); } catch (IllegalArgumentException | IllegalAccessException e) { // If we cannot access the field, don't. continue; } if (proto != null) register(proto); } } } /** * Register a TransportProtocol instance for use during open. * <p> * Protocol definitions are held by WeakReference, allowing them to be * garbage collected when the calling application drops all strongly held * references to the TransportProtocol. Therefore applications should use a * singleton pattern as described in * {@link org.eclipse.jgit.transport.TransportProtocol}'s class * documentation to ensure their protocol does not get disabled by garbage * collection earlier than expected. * <p> * The new protocol is registered in front of all earlier protocols, giving * it higher priority than the built-in protocol definitions. * * @param proto * the protocol definition. Must not be null. */ public static void register(TransportProtocol proto) { protocols.add(0, new WeakReference<>(proto)); } /** * Unregister a TransportProtocol instance. * <p> * Unregistering a protocol usually isn't necessary, as protocols are held * by weak references and will automatically clear when they are garbage * collected by the JVM. Matching is handled by reference equality, so the * exact reference given to {@link #register(TransportProtocol)} must be * used. * * @param proto * the exact object previously given to register. */ public static void unregister(TransportProtocol proto) { for (WeakReference<TransportProtocol> ref : protocols) { TransportProtocol refProto = ref.get(); if (refProto == null || refProto == proto) protocols.remove(ref); } } /** * Obtain a copy of the registered protocols. * * @return an immutable copy of the currently registered protocols. */ public static List<TransportProtocol> getTransportProtocols() { int cnt = protocols.size(); List<TransportProtocol> res = new ArrayList<>(cnt); for (WeakReference<TransportProtocol> ref : protocols) { TransportProtocol proto = ref.get(); if (proto != null) res.add(proto); else protocols.remove(ref); } return Collections.unmodifiableList(res); } /** * Open a new transport instance to connect two repositories. * <p> * This method assumes * {@link org.eclipse.jgit.transport.Transport.Operation#FETCH}. * * @param local * existing local repository. * @param remote * location of the remote repository - may be URI or remote * configuration name. * @return the new transport instance. Never null. In case of multiple URIs * in remote configuration, only the first is chosen. * @throws java.net.URISyntaxException * the location is not a remote defined in the configuration * file and is not a well-formed URL. * @throws org.eclipse.jgit.errors.NotSupportedException * the protocol specified is not supported. * @throws org.eclipse.jgit.errors.TransportException * the transport cannot open this URI. */ public static Transport open(Repository local, String remote) throws NotSupportedException, URISyntaxException, TransportException { return open(local, remote, Operation.FETCH); } /** * Open a new transport instance to connect two repositories. * * @param local * existing local repository. * @param remote * location of the remote repository - may be URI or remote * configuration name. * @param op * planned use of the returned Transport; the URI may differ * based on the type of connection desired. * @return the new transport instance. Never null. In case of multiple URIs * in remote configuration, only the first is chosen. * @throws java.net.URISyntaxException * the location is not a remote defined in the configuration * file and is not a well-formed URL. * @throws org.eclipse.jgit.errors.NotSupportedException * the protocol specified is not supported. * @throws org.eclipse.jgit.errors.TransportException * the transport cannot open this URI. */ public static Transport open(final Repository local, final String remote, final Operation op) throws NotSupportedException, URISyntaxException, TransportException { if (local != null) { final RemoteConfig cfg = new RemoteConfig(local.getConfig(), remote); if (doesNotExist(cfg)) { return open(local, new URIish(remote), null); } return open(local, cfg, op); } return open(new URIish(remote)); } /** * Open new transport instances to connect two repositories. * <p> * This method assumes * {@link org.eclipse.jgit.transport.Transport.Operation#FETCH}. * * @param local * existing local repository. * @param remote * location of the remote repository - may be URI or remote * configuration name. * @return the list of new transport instances for every URI in remote * configuration. * @throws java.net.URISyntaxException * the location is not a remote defined in the configuration * file and is not a well-formed URL. * @throws org.eclipse.jgit.errors.NotSupportedException * the protocol specified is not supported. * @throws org.eclipse.jgit.errors.TransportException * the transport cannot open this URI. */ public static List<Transport> openAll(final Repository local, final String remote) throws NotSupportedException, URISyntaxException, TransportException { return openAll(local, remote, Operation.FETCH); } /** * Open new transport instances to connect two repositories. * * @param local * existing local repository. * @param remote * location of the remote repository - may be URI or remote * configuration name. * @param op * planned use of the returned Transport; the URI may differ * based on the type of connection desired. * @return the list of new transport instances for every URI in remote * configuration. * @throws java.net.URISyntaxException * the location is not a remote defined in the configuration * file and is not a well-formed URL. * @throws org.eclipse.jgit.errors.NotSupportedException * the protocol specified is not supported. * @throws org.eclipse.jgit.errors.TransportException * the transport cannot open this URI. */ public static List<Transport> openAll(final Repository local, final String remote, final Operation op) throws NotSupportedException, URISyntaxException, TransportException { final RemoteConfig cfg = new RemoteConfig(local.getConfig(), remote); if (doesNotExist(cfg)) { final ArrayList<Transport> transports = new ArrayList<>(1); transports.add(open(local, new URIish(remote), null)); return transports; } return openAll(local, cfg, op); } /** * Open a new transport instance to connect two repositories. * <p> * This method assumes * {@link org.eclipse.jgit.transport.Transport.Operation#FETCH}. * * @param local * existing local repository. * @param cfg * configuration describing how to connect to the remote * repository. * @return the new transport instance. Never null. In case of multiple URIs * in remote configuration, only the first is chosen. * @throws org.eclipse.jgit.errors.NotSupportedException * the protocol specified is not supported. * @throws org.eclipse.jgit.errors.TransportException * the transport cannot open this URI. * @throws java.lang.IllegalArgumentException * if provided remote configuration doesn't have any URI * associated. */ public static Transport open(Repository local, RemoteConfig cfg) throws NotSupportedException, TransportException { return open(local, cfg, Operation.FETCH); } /** * Open a new transport instance to connect two repositories. * * @param local * existing local repository. * @param cfg * configuration describing how to connect to the remote * repository. * @param op * planned use of the returned Transport; the URI may differ * based on the type of connection desired. * @return the new transport instance. Never null. In case of multiple URIs * in remote configuration, only the first is chosen. * @throws org.eclipse.jgit.errors.NotSupportedException * the protocol specified is not supported. * @throws org.eclipse.jgit.errors.TransportException * the transport cannot open this URI. * @throws java.lang.IllegalArgumentException * if provided remote configuration doesn't have any URI * associated. */ public static Transport open(final Repository local, final RemoteConfig cfg, final Operation op) throws NotSupportedException, TransportException { final List<URIish> uris = getURIs(cfg, op); if (uris.isEmpty()) throw new IllegalArgumentException( MessageFormat.format(JGitText.get().remoteConfigHasNoURIAssociated, cfg.getName())); final Transport tn = open(local, uris.get(0), cfg.getName()); tn.applyConfig(cfg); return tn; } /** * Open new transport instances to connect two repositories. * <p> * This method assumes * {@link org.eclipse.jgit.transport.Transport.Operation#FETCH}. * * @param local * existing local repository. * @param cfg * configuration describing how to connect to the remote * repository. * @return the list of new transport instances for every URI in remote * configuration. * @throws org.eclipse.jgit.errors.NotSupportedException * the protocol specified is not supported. * @throws org.eclipse.jgit.errors.TransportException * the transport cannot open this URI. */ public static List<Transport> openAll(final Repository local, final RemoteConfig cfg) throws NotSupportedException, TransportException { return openAll(local, cfg, Operation.FETCH); } /** * Open new transport instances to connect two repositories. * * @param local * existing local repository. * @param cfg * configuration describing how to connect to the remote * repository. * @param op * planned use of the returned Transport; the URI may differ * based on the type of connection desired. * @return the list of new transport instances for every URI in remote * configuration. * @throws org.eclipse.jgit.errors.NotSupportedException * the protocol specified is not supported. * @throws org.eclipse.jgit.errors.TransportException * the transport cannot open this URI. */ public static List<Transport> openAll(final Repository local, final RemoteConfig cfg, final Operation op) throws NotSupportedException, TransportException { final List<URIish> uris = getURIs(cfg, op); final List<Transport> transports = new ArrayList<>(uris.size()); for (URIish uri : uris) { final Transport tn = open(local, uri, cfg.getName()); tn.applyConfig(cfg); transports.add(tn); } return transports; } private static List<URIish> getURIs(final RemoteConfig cfg, final Operation op) { switch (op) { case FETCH: return cfg.getURIs(); case PUSH: { List<URIish> uris = cfg.getPushURIs(); if (uris.isEmpty()) uris = cfg.getURIs(); return uris; } default: throw new IllegalArgumentException(op.toString()); } } private static boolean doesNotExist(RemoteConfig cfg) { return cfg.getURIs().isEmpty() && cfg.getPushURIs().isEmpty(); } /** * Open a new transport instance to connect two repositories. * * @param local * existing local repository. * @param uri * location of the remote repository. * @return the new transport instance. Never null. * @throws org.eclipse.jgit.errors.NotSupportedException * the protocol specified is not supported. * @throws org.eclipse.jgit.errors.TransportException * the transport cannot open this URI. */ public static Transport open(Repository local, URIish uri) throws NotSupportedException, TransportException { return open(local, uri, null); } /** * Open a new transport instance to connect two repositories. * * @param local * existing local repository. * @param uri * location of the remote repository. * @param remoteName * name of the remote, if the remote as configured in * {@code local}; otherwise null. * @return the new transport instance. Never null. * @throws org.eclipse.jgit.errors.NotSupportedException * the protocol specified is not supported. * @throws org.eclipse.jgit.errors.TransportException * the transport cannot open this URI. */ public static Transport open(Repository local, URIish uri, String remoteName) throws NotSupportedException, TransportException { for (WeakReference<TransportProtocol> ref : protocols) { TransportProtocol proto = ref.get(); if (proto == null) { protocols.remove(ref); continue; } if (proto.canHandle(uri, local, remoteName)) { Transport tn = proto.open(uri, local, remoteName); tn.prePush = Hooks.prePush(local, tn.hookOutRedirect); tn.prePush.setRemoteLocation(uri.toString()); tn.prePush.setRemoteName(remoteName); return tn; } } throw new NotSupportedException(MessageFormat.format(JGitText.get().URINotSupported, uri)); } /** * Open a new transport with no local repository. * <p> * Note that the resulting transport instance can not be used for fetching * or pushing, but only for reading remote refs. * * @param uri a {@link org.eclipse.jgit.transport.URIish} object. * @return new Transport instance * @throws org.eclipse.jgit.errors.NotSupportedException * @throws org.eclipse.jgit.errors.TransportException */ public static Transport open(URIish uri) throws NotSupportedException, TransportException { for (WeakReference<TransportProtocol> ref : protocols) { TransportProtocol proto = ref.get(); if (proto == null) { protocols.remove(ref); continue; } if (proto.canHandle(uri, null, null)) return proto.open(uri); } throw new NotSupportedException(MessageFormat.format(JGitText.get().URINotSupported, uri)); } /** * Convert push remote refs update specification from * {@link org.eclipse.jgit.transport.RefSpec} form to * {@link org.eclipse.jgit.transport.RemoteRefUpdate}. Conversion expands * wildcards by matching source part to local refs. expectedOldObjectId in * RemoteRefUpdate is set when specified in leases. Tracking branch is * configured if RefSpec destination matches source of any fetch ref spec * for this transport remote configuration. * * @param db * local database. * @param specs * collection of RefSpec to convert. * @param leases * map from ref to lease (containing expected old object id) * @param fetchSpecs * fetch specifications used for finding localtracking refs. May * be null or empty collection. * @return collection of set up * {@link org.eclipse.jgit.transport.RemoteRefUpdate}. * @throws java.io.IOException * when problem occurred during conversion or specification set * up: most probably, missing objects or refs. * @since 4.7 */ public static Collection<RemoteRefUpdate> findRemoteRefUpdatesFor(final Repository db, final Collection<RefSpec> specs, final Map<String, RefLeaseSpec> leases, Collection<RefSpec> fetchSpecs) throws IOException { if (fetchSpecs == null) fetchSpecs = Collections.emptyList(); final List<RemoteRefUpdate> result = new LinkedList<>(); final Collection<RefSpec> procRefs = expandPushWildcardsFor(db, specs); for (RefSpec spec : procRefs) { String srcSpec = spec.getSource(); final Ref srcRef = db.findRef(srcSpec); if (srcRef != null) srcSpec = srcRef.getName(); String destSpec = spec.getDestination(); if (destSpec == null) { // No destination (no-colon in ref-spec), DWIMery assumes src // destSpec = srcSpec; } if (srcRef != null && !destSpec.startsWith(Constants.R_REFS)) { // Assume the same kind of ref at the destination, e.g. // "refs/heads/foo:master", DWIMery assumes master is also // under "refs/heads/". // final String n = srcRef.getName(); final int kindEnd = n.indexOf('/', Constants.R_REFS.length()); destSpec = n.substring(0, kindEnd + 1) + destSpec; } final boolean forceUpdate = spec.isForceUpdate(); final String localName = findTrackingRefName(destSpec, fetchSpecs); final RefLeaseSpec leaseSpec = leases.get(destSpec); final ObjectId expected = leaseSpec == null ? null : db.resolve(leaseSpec.getExpected()); final RemoteRefUpdate rru = new RemoteRefUpdate(db, srcSpec, destSpec, forceUpdate, localName, expected); result.add(rru); } return result; } /** * Convert push remote refs update specification from * {@link org.eclipse.jgit.transport.RefSpec} form to * {@link org.eclipse.jgit.transport.RemoteRefUpdate}. Conversion expands * wildcards by matching source part to local refs. expectedOldObjectId in * RemoteRefUpdate is always set as null. Tracking branch is configured if * RefSpec destination matches source of any fetch ref spec for this * transport remote configuration. * * @param db * local database. * @param specs * collection of RefSpec to convert. * @param fetchSpecs * fetch specifications used for finding localtracking refs. May * be null or empty collection. * @return collection of set up * {@link org.eclipse.jgit.transport.RemoteRefUpdate}. * @throws java.io.IOException * when problem occurred during conversion or specification set * up: most probably, missing objects or refs. */ public static Collection<RemoteRefUpdate> findRemoteRefUpdatesFor(final Repository db, final Collection<RefSpec> specs, Collection<RefSpec> fetchSpecs) throws IOException { return findRemoteRefUpdatesFor(db, specs, Collections.emptyMap(), fetchSpecs); } private static Collection<RefSpec> expandPushWildcardsFor(final Repository db, final Collection<RefSpec> specs) throws IOException { final List<Ref> localRefs = db.getRefDatabase().getRefs(); final Collection<RefSpec> procRefs = new LinkedHashSet<>(); for (RefSpec spec : specs) { if (spec.isWildcard()) { for (Ref localRef : localRefs) { if (spec.matchSource(localRef)) procRefs.add(spec.expandFromSource(localRef)); } } else { procRefs.add(spec); } } return procRefs; } private static String findTrackingRefName(final String remoteName, final Collection<RefSpec> fetchSpecs) { // try to find matching tracking refs for (RefSpec fetchSpec : fetchSpecs) { if (fetchSpec.matchSource(remoteName)) { if (fetchSpec.isWildcard()) { return fetchSpec.expandFromSource(remoteName).getDestination(); } return fetchSpec.getDestination(); } } return null; } /** * Default setting for {@link #fetchThin} option. */ public static final boolean DEFAULT_FETCH_THIN = true; /** * Default setting for {@link #pushThin} option. */ public static final boolean DEFAULT_PUSH_THIN = false; /** * Specification for fetch or push operations, to fetch or push all tags. * Acts as --tags. */ public static final RefSpec REFSPEC_TAGS = new RefSpec("refs/tags/*:refs/tags/*"); //$NON-NLS-1$ /** * Specification for push operation, to push all refs under refs/heads. Acts * as --all. */ public static final RefSpec REFSPEC_PUSH_ALL = new RefSpec("refs/heads/*:refs/heads/*"); //$NON-NLS-1$ /** The repository this transport fetches into, or pushes out of. */ protected final Repository local; /** The URI used to create this transport. */ protected final URIish uri; /** Name of the upload pack program, if it must be executed. */ private String optionUploadPack = RemoteConfig.DEFAULT_UPLOAD_PACK; /** Specifications to apply during fetch. */ private List<RefSpec> fetch = Collections.emptyList(); /** * How {@link #fetch(ProgressMonitor, Collection)} should handle tags. * <p> * We default to {@link TagOpt#NO_TAGS} so as to avoid fetching annotated * tags during one-shot fetches used for later merges. This prevents * dragging down tags from repositories that we do not have established * tracking branches for. If we do not track the source repository, we most * likely do not care about any tags it publishes. */ private TagOpt tagopt = TagOpt.NO_TAGS; /** Should fetch request thin-pack if remote repository can produce it. */ private boolean fetchThin = DEFAULT_FETCH_THIN; /** Name of the receive pack program, if it must be executed. */ private String optionReceivePack = RemoteConfig.DEFAULT_RECEIVE_PACK; /** Specifications to apply during push. */ private List<RefSpec> push = Collections.emptyList(); /** Should push produce thin-pack when sending objects to remote repository. */ private boolean pushThin = DEFAULT_PUSH_THIN; /** Should push be all-or-nothing atomic behavior? */ private boolean pushAtomic; /** Should push just check for operation result, not really push. */ private boolean dryRun; /** Should an incoming (fetch) transfer validate objects? */ private ObjectChecker objectChecker; /** Should refs no longer on the source be pruned from the destination? */ private boolean removeDeletedRefs; private FilterSpec filterSpec = FilterSpec.NO_FILTER; /** Timeout in seconds to wait before aborting an IO read or write. */ private int timeout; /** Pack configuration used by this transport to make pack file. */ private PackConfig packConfig; /** Assists with authentication the connection. */ private CredentialsProvider credentialsProvider; /** The option strings associated with the push operation. */ private List<String> pushOptions; private PrintStream hookOutRedirect; private PrePushHook prePush; /** * Create a new transport instance. * * @param local * the repository this instance will fetch into, or push out of. * This must be the repository passed to * {@link #open(Repository, URIish)}. * @param uri * the URI used to access the remote repository. This must be the * URI passed to {@link #open(Repository, URIish)}. */ protected Transport(Repository local, URIish uri) { final TransferConfig tc = local.getConfig().get(TransferConfig.KEY); this.local = local; this.uri = uri; this.objectChecker = tc.newObjectChecker(); this.credentialsProvider = CredentialsProvider.getDefault(); prePush = Hooks.prePush(local, hookOutRedirect); } /** * Create a minimal transport instance not tied to a single repository. * * @param uri * a {@link org.eclipse.jgit.transport.URIish} object. */ protected Transport(URIish uri) { this.uri = uri; this.local = null; this.objectChecker = new ObjectChecker(); this.credentialsProvider = CredentialsProvider.getDefault(); } /** * Get the URI this transport connects to. * <p> * Each transport instance connects to at most one URI at any point in time. * * @return the URI describing the location of the remote repository. */ public URIish getURI() { return uri; } /** * Get the name of the remote executable providing upload-pack service. * * @return typically "git-upload-pack". */ public String getOptionUploadPack() { return optionUploadPack; } /** * Set the name of the remote executable providing upload-pack services. * * @param where * name of the executable. */ public void setOptionUploadPack(String where) { if (where != null && where.length() > 0) optionUploadPack = where; else optionUploadPack = RemoteConfig.DEFAULT_UPLOAD_PACK; } /** * Get the description of how annotated tags should be treated during fetch. * * @return option indicating the behavior of annotated tags in fetch. */ public TagOpt getTagOpt() { return tagopt; } /** * Set the description of how annotated tags should be treated on fetch. * * @param option * method to use when handling annotated tags. */ public void setTagOpt(TagOpt option) { tagopt = option != null ? option : TagOpt.AUTO_FOLLOW; } /** * Default setting is: {@link #DEFAULT_FETCH_THIN} * * @return true if fetch should request thin-pack when possible; false * otherwise * @see PackTransport */ public boolean isFetchThin() { return fetchThin; } /** * Set the thin-pack preference for fetch operation. Default setting is: * {@link #DEFAULT_FETCH_THIN} * * @param fetchThin * true when fetch should request thin-pack when possible; false * when it shouldn't * @see PackTransport */ public void setFetchThin(boolean fetchThin) { this.fetchThin = fetchThin; } /** * Whether fetch will verify if received objects are formatted correctly. * * @return true if fetch will verify received objects are formatted * correctly. Validating objects requires more CPU time on the * client side of the connection. */ public boolean isCheckFetchedObjects() { return getObjectChecker() != null; } /** * Configure if checking received objects is enabled * * @param check * true to enable checking received objects; false to assume all * received objects are valid. * @see #setObjectChecker(ObjectChecker) */ public void setCheckFetchedObjects(boolean check) { if (check && objectChecker == null) setObjectChecker(new ObjectChecker()); else if (!check && objectChecker != null) setObjectChecker(null); } /** * Get configured object checker for received objects * * @return configured object checker for received objects, or null. * @since 3.6 */ public ObjectChecker getObjectChecker() { return objectChecker; } /** * Set the object checker to verify each received object with * * @param impl * if non-null the object checking instance to verify each * received object with; null to disable object checking. * @since 3.6 */ public void setObjectChecker(ObjectChecker impl) { objectChecker = impl; } /** * Default setting is: * {@link org.eclipse.jgit.transport.RemoteConfig#DEFAULT_RECEIVE_PACK} * * @return remote executable providing receive-pack service for pack * transports. * @see PackTransport */ public String getOptionReceivePack() { return optionReceivePack; } /** * Set remote executable providing receive-pack service for pack transports. * Default setting is: * {@link org.eclipse.jgit.transport.RemoteConfig#DEFAULT_RECEIVE_PACK} * * @param optionReceivePack * remote executable, if null or empty default one is set; */ public void setOptionReceivePack(String optionReceivePack) { if (optionReceivePack != null && optionReceivePack.length() > 0) this.optionReceivePack = optionReceivePack; else this.optionReceivePack = RemoteConfig.DEFAULT_RECEIVE_PACK; } /** * Default setting is: {@value #DEFAULT_PUSH_THIN} * * @return true if push should produce thin-pack in pack transports * @see PackTransport */ public boolean isPushThin() { return pushThin; } /** * Set thin-pack preference for push operation. Default setting is: * {@value #DEFAULT_PUSH_THIN} * * @param pushThin * true when push should produce thin-pack in pack transports; * false when it shouldn't * @see PackTransport */ public void setPushThin(boolean pushThin) { this.pushThin = pushThin; } /** * Default setting is false. * * @return true if push requires all-or-nothing atomic behavior. * @since 4.2 */ public boolean isPushAtomic() { return pushAtomic; } /** * Request atomic push (all references succeed, or none do). * <p> * Server must also support atomic push. If the server does not support the * feature the push will abort without making changes. * * @param atomic * true when push should be an all-or-nothing operation. * @see PackTransport * @since 4.2 */ public void setPushAtomic(boolean atomic) { this.pushAtomic = atomic; } /** * Whether destination refs should be removed if they no longer exist at the * source repository. * * @return true if destination refs should be removed if they no longer * exist at the source repository. */ public boolean isRemoveDeletedRefs() { return removeDeletedRefs; } /** * Set whether or not to remove refs which no longer exist in the source. * <p> * If true, refs at the destination repository (local for fetch, remote for * push) are deleted if they no longer exist on the source side (remote for * fetch, local for push). * <p> * False by default, as this may cause data to become unreachable, and * eventually be deleted on the next GC. * * @param remove true to remove refs that no longer exist. */ public void setRemoveDeletedRefs(boolean remove) { removeDeletedRefs = remove; } /** * @return the blob limit value set with {@link #setFilterBlobLimit} or * {@link #setFilterSpec(FilterSpec)}, or -1 if no blob limit value * was set * @since 5.0 * @deprecated Use {@link #getFilterSpec()} instead */ @Deprecated public final long getFilterBlobLimit() { return filterSpec.getBlobLimit(); } /** * @param bytes exclude blobs of size greater than this * @since 5.0 * @deprecated Use {@link #setFilterSpec(FilterSpec)} instead */ @Deprecated public final void setFilterBlobLimit(long bytes) { setFilterSpec(FilterSpec.withBlobLimit(bytes)); } /** * @return the last filter spec set with {@link #setFilterSpec(FilterSpec)}, * or {@link FilterSpec#NO_FILTER} if it was never invoked. * @since 5.4 */ public final FilterSpec getFilterSpec() { return filterSpec; } /** * @param filter a new filter to use for this transport * @since 5.4 */ public final void setFilterSpec(@NonNull FilterSpec filter) { filterSpec = requireNonNull(filter); } /** * Apply provided remote configuration on this transport. * * @param cfg * configuration to apply on this transport. */ public void applyConfig(RemoteConfig cfg) { setOptionUploadPack(cfg.getUploadPack()); setOptionReceivePack(cfg.getReceivePack()); setTagOpt(cfg.getTagOpt()); fetch = cfg.getFetchRefSpecs(); push = cfg.getPushRefSpecs(); timeout = cfg.getTimeout(); } /** * Whether push operation should just check for possible result and not * really update remote refs * * @return true if push operation should just check for possible result and * not really update remote refs, false otherwise - when push should * act normally. */ public boolean isDryRun() { return dryRun; } /** * Set dry run option for push operation. * * @param dryRun * true if push operation should just check for possible result * and not really update remote refs, false otherwise - when push * should act normally. */ public void setDryRun(boolean dryRun) { this.dryRun = dryRun; } /** * Get timeout (in seconds) before aborting an IO operation. * * @return timeout (in seconds) before aborting an IO operation. */ public int getTimeout() { return timeout; } /** * Set the timeout before willing to abort an IO call. * * @param seconds * number of seconds to wait (with no data transfer occurring) * before aborting an IO read or write operation with this * remote. */ public void setTimeout(int seconds) { timeout = seconds; } /** * Get the configuration used by the pack generator to make packs. * * If {@link #setPackConfig(PackConfig)} was previously given null a new * PackConfig is created on demand by this method using the source * repository's settings. * * @return the pack configuration. Never null. */ public PackConfig getPackConfig() { if (packConfig == null) packConfig = new PackConfig(local); return packConfig; } /** * Set the configuration used by the pack generator. * * @param pc * configuration controlling packing parameters. If null the * source repository's settings will be used. */ public void setPackConfig(PackConfig pc) { packConfig = pc; } /** * A credentials provider to assist with authentication connections.. * * @param credentialsProvider * the credentials provider, or null if there is none */ public void setCredentialsProvider(CredentialsProvider credentialsProvider) { this.credentialsProvider = credentialsProvider; } /** * The configured credentials provider. * * @return the credentials provider, or null if no credentials provider is * associated with this transport. */ public CredentialsProvider getCredentialsProvider() { return credentialsProvider; } /** * Get the option strings associated with the push operation * * @return the option strings associated with the push operation * @since 4.5 */ public List<String> getPushOptions() { return pushOptions; } /** * Sets the option strings associated with the push operation. * * @param pushOptions * null if push options are unsupported * @since 4.5 */ public void setPushOptions(List<String> pushOptions) { this.pushOptions = pushOptions; } /** * Fetch objects and refs from the remote repository to the local one. * <p> * This is a utility function providing standard fetch behavior. Local * tracking refs associated with the remote repository are automatically * updated if this transport was created from a * {@link org.eclipse.jgit.transport.RemoteConfig} with fetch RefSpecs * defined. * * @param monitor * progress monitor to inform the user about our processing * activity. Must not be null. Use * {@link org.eclipse.jgit.lib.NullProgressMonitor} if progress * updates are not interesting or necessary. * @param toFetch * specification of refs to fetch locally. May be null or the * empty collection to use the specifications from the * RemoteConfig. Source for each RefSpec can't be null. * @return information describing the tracking refs updated. * @throws org.eclipse.jgit.errors.NotSupportedException * this transport implementation does not support fetching * objects. * @throws org.eclipse.jgit.errors.TransportException * the remote connection could not be established or object * copying (if necessary) failed or update specification was * incorrect. */ public FetchResult fetch(final ProgressMonitor monitor, Collection<RefSpec> toFetch) throws NotSupportedException, TransportException { if (toFetch == null || toFetch.isEmpty()) { // If the caller did not ask for anything use the defaults. // if (fetch.isEmpty()) throw new TransportException(JGitText.get().nothingToFetch); toFetch = fetch; } else if (!fetch.isEmpty()) { // If the caller asked for something specific without giving // us the local tracking branch see if we can update any of // the local tracking branches without incurring additional // object transfer overheads. // final Collection<RefSpec> tmp = new ArrayList<>(toFetch); for (RefSpec requested : toFetch) { final String reqSrc = requested.getSource(); for (RefSpec configured : fetch) { final String cfgSrc = configured.getSource(); final String cfgDst = configured.getDestination(); if (cfgSrc.equals(reqSrc) && cfgDst != null) { tmp.add(configured); break; } } } toFetch = tmp; } final FetchResult result = new FetchResult(); new FetchProcess(this, toFetch).execute(monitor, result); local.autoGC(monitor); return result; } /** * Push objects and refs from the local repository to the remote one. * <p> * This is a utility function providing standard push behavior. It updates * remote refs and send there necessary objects according to remote ref * update specification. After successful remote ref update, associated * locally stored tracking branch is updated if set up accordingly. Detailed * operation result is provided after execution. * <p> * For setting up remote ref update specification from ref spec, see helper * method {@link #findRemoteRefUpdatesFor(Collection)}, predefined refspecs * ({@link #REFSPEC_TAGS}, {@link #REFSPEC_PUSH_ALL}) or consider using * directly {@link org.eclipse.jgit.transport.RemoteRefUpdate} for more * possibilities. * <p> * When {@link #isDryRun()} is true, result of this operation is just * estimation of real operation result, no real action is performed. * * @see RemoteRefUpdate * @param monitor * progress monitor to inform the user about our processing * activity. Must not be null. Use * {@link org.eclipse.jgit.lib.NullProgressMonitor} if progress * updates are not interesting or necessary. * @param toPush * specification of refs to push. May be null or the empty * collection to use the specifications from the RemoteConfig * converted by {@link #findRemoteRefUpdatesFor(Collection)}. No * more than 1 RemoteRefUpdate with the same remoteName is * allowed. These objects are modified during this call. * @param out * output stream to write messages to * @return information about results of remote refs updates, tracking refs * updates and refs advertised by remote repository. * @throws org.eclipse.jgit.errors.NotSupportedException * this transport implementation does not support pushing * objects. * @throws org.eclipse.jgit.errors.TransportException * the remote connection could not be established or object * copying (if necessary) failed at I/O or protocol level or * update specification was incorrect. * @since 3.0 */ public PushResult push(final ProgressMonitor monitor, Collection<RemoteRefUpdate> toPush, OutputStream out) throws NotSupportedException, TransportException { if (toPush == null || toPush.isEmpty()) { // If the caller did not ask for anything use the defaults. try { toPush = findRemoteRefUpdatesFor(push); } catch (final IOException e) { throw new TransportException(MessageFormat .format(JGitText.get().problemWithResolvingPushRefSpecsLocally, e.getMessage()), e); } if (toPush.isEmpty()) throw new TransportException(JGitText.get().nothingToPush); } if (prePush != null) { try { prePush.setRefs(toPush); prePush.call(); } catch (AbortedByHookException | IOException e) { throw new TransportException(e.getMessage(), e); } } final PushProcess pushProcess = new PushProcess(this, toPush, out); return pushProcess.execute(monitor); } /** * Push objects and refs from the local repository to the remote one. * <p> * This is a utility function providing standard push behavior. It updates * remote refs and sends necessary objects according to remote ref update * specification. After successful remote ref update, associated locally * stored tracking branch is updated if set up accordingly. Detailed * operation result is provided after execution. * <p> * For setting up remote ref update specification from ref spec, see helper * method {@link #findRemoteRefUpdatesFor(Collection)}, predefined refspecs * ({@link #REFSPEC_TAGS}, {@link #REFSPEC_PUSH_ALL}) or consider using * directly {@link org.eclipse.jgit.transport.RemoteRefUpdate} for more * possibilities. * <p> * When {@link #isDryRun()} is true, result of this operation is just * estimation of real operation result, no real action is performed. * * @see RemoteRefUpdate * @param monitor * progress monitor to inform the user about our processing * activity. Must not be null. Use * {@link org.eclipse.jgit.lib.NullProgressMonitor} if progress * updates are not interesting or necessary. * @param toPush * specification of refs to push. May be null or the empty * collection to use the specifications from the RemoteConfig * converted by {@link #findRemoteRefUpdatesFor(Collection)}. No * more than 1 RemoteRefUpdate with the same remoteName is * allowed. These objects are modified during this call. * @return information about results of remote refs updates, tracking refs * updates and refs advertised by remote repository. * @throws org.eclipse.jgit.errors.NotSupportedException * this transport implementation does not support pushing * objects. * @throws org.eclipse.jgit.errors.TransportException * the remote connection could not be established or object * copying (if necessary) failed at I/O or protocol level or * update specification was incorrect. */ public PushResult push(final ProgressMonitor monitor, Collection<RemoteRefUpdate> toPush) throws NotSupportedException, TransportException { return push(monitor, toPush, null); } /** * Convert push remote refs update specification from * {@link org.eclipse.jgit.transport.RefSpec} form to * {@link org.eclipse.jgit.transport.RemoteRefUpdate}. Conversion expands * wildcards by matching source part to local refs. expectedOldObjectId in * RemoteRefUpdate is always set as null. Tracking branch is configured if * RefSpec destination matches source of any fetch ref spec for this * transport remote configuration. * <p> * Conversion is performed for context of this transport (database, fetch * specifications). * * @param specs * collection of RefSpec to convert. * @return collection of set up * {@link org.eclipse.jgit.transport.RemoteRefUpdate}. * @throws java.io.IOException * when problem occurred during conversion or specification set * up: most probably, missing objects or refs. */ public Collection<RemoteRefUpdate> findRemoteRefUpdatesFor(final Collection<RefSpec> specs) throws IOException { return findRemoteRefUpdatesFor(local, specs, Collections.emptyMap(), fetch); } /** * Convert push remote refs update specification from * {@link org.eclipse.jgit.transport.RefSpec} form to * {@link org.eclipse.jgit.transport.RemoteRefUpdate}. Conversion expands * wildcards by matching source part to local refs. expectedOldObjectId in * RemoteRefUpdate is set according to leases. Tracking branch is configured * if RefSpec destination matches source of any fetch ref spec for this * transport remote configuration. * <p> * Conversion is performed for context of this transport (database, fetch * specifications). * * @param specs * collection of RefSpec to convert. * @param leases * map from ref to lease (containing expected old object id) * @return collection of set up * {@link org.eclipse.jgit.transport.RemoteRefUpdate}. * @throws java.io.IOException * when problem occurred during conversion or specification set * up: most probably, missing objects or refs. * @since 4.7 */ public Collection<RemoteRefUpdate> findRemoteRefUpdatesFor(final Collection<RefSpec> specs, final Map<String, RefLeaseSpec> leases) throws IOException { return findRemoteRefUpdatesFor(local, specs, leases, fetch); } /** * Begins a new connection for fetching from the remote repository. * <p> * If the transport has no local repository, the fetch connection can only * be used for reading remote refs. * * @return a fresh connection to fetch from the remote repository. * @throws org.eclipse.jgit.errors.NotSupportedException * the implementation does not support fetching. * @throws org.eclipse.jgit.errors.TransportException * the remote connection could not be established. */ public abstract FetchConnection openFetch() throws NotSupportedException, TransportException; /** * Begins a new connection for pushing into the remote repository. * * @return a fresh connection to push into the remote repository. * @throws org.eclipse.jgit.errors.NotSupportedException * the implementation does not support pushing. * @throws org.eclipse.jgit.errors.TransportException * the remote connection could not be established */ public abstract PushConnection openPush() throws NotSupportedException, TransportException; /** * {@inheritDoc} * <p> * Close any resources used by this transport. * <p> * 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. * <p> * {@code AutoClosable.close()} declares that it throws {@link Exception}. * Implementers shouldn't throw checked exceptions. This override narrows * the signature to prevent them from doing so. */ @Override public abstract void close(); }