[JENKINS-64383] combined refrepo became our bottleneck, support a fanout location too

src/main/java/hudson/plugins/git/GitAPI.java

@@ -175,6 +175,12 @@
         return Git.USE_CLI ? super.subGit(subdir) : jgit.subGit(subdir);
     }
 
+    /** {@inheritDoc} */
+    @Override
+    public GitClient newGit(String somedir) {
+        return Git.USE_CLI ? super.newGit(somedir) : jgit.newGit(somedir);
+    }
+
     /** {@inheritDoc} */
     @Override
     public void setRemoteUrl(String name, String url) throws GitException, InterruptedException {

src/main/java/org/jenkinsci/plugins/gitclient/CliGitAPIImpl.java

@@ -351,6 +351,12 @@
         return new CliGitAPIImpl(gitExe, new File(workspace, subdir), listener, environment);
     }
 
+    /** {@inheritDoc} */
+    @Override
+    public GitClient newGit(String somedir) {
+        return new CliGitAPIImpl(gitExe, new File(somedir), listener, environment);
+    }
+
     /**
      * Initialize an empty repository for further git operations.
      *
@@ -837,670 +843,697 @@
                 }
 
                 if (reference != null && !reference.isEmpty()) {
-                    File referencePath = new File(reference);
-                    if (!referencePath.exists()) {
-                        listener.getLogger().println("[WARNING] Reference path does not exist: " + reference);
-                    } else if (!referencePath.isDirectory()) {
-                        listener.getLogger().println("[WARNING] Reference path is not a directory: " + reference);
+                    if (isParameterizedReferenceRepository(reference)) {
+                        // LegacyCompatibleGitAPIImpl.java has a logging trace, but not into build console via listener
+                        listener.getLogger()
+                                .println("[INFO] The git reference repository path '" + reference + "' "
+                                        + "is parameterized, it may take a few git queries logged "
+                                        + "below to resolve it into a particular directory name");
+                    }
+                    File referencePath = findParameterizedReferenceRepository(reference, url);
+                    if (referencePath == null) {
+                        listener.getLogger()
+                                .println("[ERROR] Could not make File object from reference path, "
+                                        + "skipping its use: " + reference);
                     } else {
-                        // reference path can either be a normal or a base repository
-                        File objectsPath = new File(referencePath, ".git/objects");
-                        if (!objectsPath.isDirectory()) {
-                            // reference path is bare repo
-                            objectsPath = new File(referencePath, "objects");
+                        if (!referencePath.getPath().equals(reference)) {
+                            // Note: both these logs are needed, they are used in selftest
+                            String msg = "Parameterized reference path ";
+                            msg += "'" + reference + "'";
+                            msg += " replaced with: ";
+                            msg += "'" + referencePath.getPath() + "'";
+                            if (referencePath.exists()) {
+                                listener.getLogger().println("[WARNING] " + msg);
+                            } else {
+                                listener.getLogger().println("[WARNING] " + msg + " does not exist");
+                            }
+                            reference = referencePath.getPath();
                         }
-                        if (!objectsPath.isDirectory()) {
-                            listener.getLogger()
-                                    .println(
-                                            "[WARNING] Reference path does not contain an objects directory (not a git repo?): "
-                                                    + objectsPath);
+
+                        if (!referencePath.exists()) {
+                            listener.getLogger().println("[WARNING] Reference path does not exist: " + reference);
+                        } else if (!referencePath.isDirectory()) {
+                            listener.getLogger().println("[WARNING] Reference path is not a directory: " + reference);
                         } else {
-                            File alternates = new File(workspace, ".git/objects/info/alternates");
-                            try (PrintWriter w = new PrintWriter(alternates, Charset.defaultCharset())) {
-                                String absoluteReference =
-                                        objectsPath.getAbsolutePath().replace('\\', '/');
-                                listener.getLogger().println("Using reference repository: " + reference);
-                                // git implementations on windows also use
-                                w.print(absoluteReference);
-                            } catch (IOException e) {
-                                listener.error("Failed to setup reference");
+                            File objectsPath = getObjectsFile(referencePath);
+                            if (objectsPath == null || !objectsPath.isDirectory()) {
+                                listener.getLogger()
+                                        .println("[WARNING] Reference path does not contain an objects directory "
+                                                + "(not a git repo?): " + objectsPath);
+                            } else {
+                                // Go behind git's back to write a meta file in new workspace
+                                File alternates = new File(workspace, ".git/objects/info/alternates");
+                                try (PrintWriter w = new PrintWriter(
+                                        alternates, Charset.defaultCharset().toString())) {
+                                    String absoluteReference =
+                                            objectsPath.getAbsolutePath().replace('\\', '/');
+                                    listener.getLogger().println("Using reference repository: " + reference);
+                                    // git implementations on windows also use
+                                    w.print(absoluteReference);
+                                } catch (UnsupportedEncodingException ex) {
+                                    listener.error("Default character set is an unsupported encoding");
+                                } catch (FileNotFoundException e) {
+                                    listener.error("Failed to setup reference");
+                                }
                             }
                         }
                     }
                 }
 
                 if (refspecs == null) {
                     refspecs = Collections.singletonList(new RefSpec("+refs/heads/*:refs/remotes/" + origin + "/*"));
                 }
                 fetch_().from(urIish, refspecs)
                         .shallow(shallow)
                         .depth(depth)
                         .timeout(timeout)
                         .tags(tags)
                         .execute();
                 setRemoteUrl(origin, url);
                 for (RefSpec refSpec : refspecs) {
                     launchCommand("config", "--add", "remote." + origin + ".fetch", refSpec.toString());
                 }
             }
         };
     }
 
     /**
      * merge.
      *
      * @return a {@link org.jenkinsci.plugins.gitclient.MergeCommand} object.
      */
     @Override
     public MergeCommand merge() {
         return new MergeCommand() {
             private ObjectId rev;
             private String comment;
             private String strategy;
             private String fastForwardMode;
             private boolean squash;
             private boolean commit = true;
 
             @Override
             public MergeCommand setRevisionToMerge(ObjectId rev) {
                 this.rev = rev;
                 return this;
             }
 
             @Override
             public MergeCommand setStrategy(MergeCommand.Strategy strategy) {
                 this.strategy = strategy.toString();
                 return this;
             }
 
             @Override
             public MergeCommand setGitPluginFastForwardMode(MergeCommand.GitPluginFastForwardMode fastForwardMode) {
                 this.fastForwardMode = fastForwardMode.toString();
                 return this;
             }
 
             @Override
             public MergeCommand setSquash(boolean squash) {
                 this.squash = squash;
                 return this;
             }
 
             @Override
             public MergeCommand setMessage(String comment) {
                 this.comment = comment;
                 return this;
             }
 
             @Override
             public MergeCommand setCommit(boolean commit) {
                 this.commit = commit;
                 return this;
             }
 
             @Override
             public void execute() throws GitException, InterruptedException {
                 ArgumentListBuilder args = new ArgumentListBuilder();
                 args.add("merge");
                 if (squash) {
                     args.add("--squash");
                 }
 
                 if (!commit) {
                     args.add("--no-commit");
                 }
 
                 if (comment != null && !comment.isEmpty()) {
                     args.add("-m");
                     args.add(comment);
                 }
 
                 if (strategy != null
                         && !strategy.isEmpty()
                         && !strategy.equals(MergeCommand.Strategy.DEFAULT.toString())) {
                     args.add("-s");
                     if (strategy.equals(MergeCommand.Strategy.RECURSIVE_THEIRS.toString())) {
                         args.add("recursive");
                         args.add("--strategy-option");
                         args.add("theirs");
                     } else {
                         args.add(strategy);
                     }
                 }
 
                 args.add(fastForwardMode);
                 if (rev == null) {
                     throw new GitException("MergeCommand requires a revision to merge");
                 }
                 args.add(rev.name());
 
                 /* See JENKINS-45228 */
                 /* Git merge requires authentication in LFS merges, plugin does not authenticate the git merge command */
                 String repoUrl = null;
                 try {
                     String defaultRemote = getDefaultRemote();
                     if (defaultRemote != null && !defaultRemote.isEmpty()) {
                         repoUrl = getRemoteUrl(defaultRemote);
                     }
                 } catch (GitException e) {
                     /* Nothing to do, just keeping repoUrl = null */
                 }
 
                 if (repoUrl != null) {
                     StandardCredentials cred = credentials.get(repoUrl);
                     if (cred == null) {
                         cred = defaultCredentials;
                     }
                     launchCommandWithCredentials(args, workspace, cred, repoUrl);
                 } else {
                     /* Merge is allowed even if a remote URL is not defined. */
                     /* If there is no remote URL, there is no need to use credentials in the merge. */
                     launchCommand(args);
                 }
             }
         };
     }
 
     /**
      * rebase.
      *
      * @return a {@link org.jenkinsci.plugins.gitclient.RebaseCommand} object.
      */
     @Override
     public RebaseCommand rebase() {
         return new RebaseCommand() {
             private String upstream;
 
             @Override
             public RebaseCommand setUpstream(String upstream) {
                 this.upstream = upstream;
                 return this;
             }
 
             @Override
             public void execute() throws GitException, InterruptedException {
                 try {
                     ArgumentListBuilder args = new ArgumentListBuilder();
                     args.add("rebase");
                     args.add(upstream);
                     launchCommand(args);
                 } catch (GitException e) {
                     launchCommand("rebase", "--abort");
                     throw new GitException("Could not rebase " + upstream, e);
                 }
             }
         };
     }
 
     /**
      * init_.
      *
      * @return a {@link org.jenkinsci.plugins.gitclient.InitCommand} object.
      */
     @Override
     public InitCommand init_() {
         return new InitCommand() {
 
             private String workspace;
             private boolean bare;
 
             @Override
             public InitCommand workspace(String workspace) {
                 this.workspace = workspace;
                 return this;
             }
 
             @Override
             public InitCommand bare(boolean bare) {
                 this.bare = bare;
                 return this;
             }
 
             @Override
             public void execute() throws GitException, InterruptedException {
                 /* Match JGit - create directory if it does not exist */
                 /* Multi-branch pipeline assumes init() creates directory */
                 File workspaceDir = new File(workspace);
                 if (!workspaceDir.exists()) {
                     boolean ok = workspaceDir.mkdirs();
                     if (!ok && !workspaceDir.exists()) {
                         throw new GitException("Could not create directory '" + workspaceDir.getAbsolutePath() + "'");
                     }
                 }
 
                 ArgumentListBuilder args = new ArgumentListBuilder();
                 args.add("init", workspace);
 
                 if (bare) {
                     args.add("--bare");
                 }
 
                 warnIfWindowsTemporaryDirNameHasSpaces();
 
                 try {
                     launchCommand(args);
                 } catch (GitException e) {
                     throw new GitException("Could not init " + workspace, e);
                 }
             }
         };
     }
 
     /**
      * Remove untracked files and directories, including files listed
      * in the ignore rules.
      *
      * @param cleanSubmodule flag to add extra -f
      * @throws hudson.plugins.git.GitException if underlying git operation fails.
      * @throws java.lang.InterruptedException if interrupted.
      */
     @Override
     public void clean(boolean cleanSubmodule) throws GitException, InterruptedException {
         reset(true);
         String cmd = "-fdx";
         if (cleanSubmodule) {
             cmd = "-ffdx";
         }
 
         launchCommand("clean", cmd);
     }
 
     /**
      * Remove untracked files and directories, including files listed
      * in the ignore rules.
      *
      * @throws hudson.plugins.git.GitException if underlying git operation fails.
      * @throws java.lang.InterruptedException if interrupted.
      */
     @Override
     public void clean() throws GitException, InterruptedException {
         this.clean(false);
     }
 
     /** {@inheritDoc} */
     @Override
     public ObjectId revParse(String revName) throws GitException, InterruptedException {
 
         String arg = sanitize(revName + "^{commit}");
         String result = launchCommand("rev-parse", arg);
         String line = StringUtils.trimToNull(result);
         if (line == null) {
             throw new GitException("rev-parse no content returned for " + revName);
         }
         return ObjectId.fromString(line);
     }
 
     /**
      * On Windows command prompt, '^' is an escape character (https://en.wikipedia.org/wiki/Escape_character#Windows_Command_Prompt)
      * This isn't a problem if 'git' we are executing is git.exe, because '^' is a special character only for the command processor,
      * but if 'git' we are executing is git.cmd (which is the case of msysgit), then the arguments we pass in here ends up getting
      * processed by the command processor, and so 'xyz^{commit}' becomes 'xyz{commit}' and fails.
      * <p>
      * We work around this problem by surrounding this with double-quote on Windows.
      * Unlike POSIX, where the arguments of a process is modeled as String[], Win32 API models the
      * arguments of a process as a single string (see CreateProcess). When we surround one argument with a quote,
      * java.lang.ProcessImpl on Windows preserve as-is and generate a single string like the following to pass to CreateProcess:
      * <pre>
      *     git rev-parse "tag^{commit}"
      * </pre>
      * If we invoke git.exe, MSVCRT startup code in git.exe will handle escape and executes it as we expect.
      * If we invoke git.cmd, cmd.exe will not eats this ^ that's in double-quote. So it works on both cases.
      * <p>
      * Note that this is a borderline-buggy behaviour arguably. If I were implementing ProcessImpl for Windows
      * in JDK, My passing a string with double-quotes around it to be expanded to the following:
      * <pre>
      *    git rev-parse "\"tag^{commit}\""
      * </pre>
      * So this work around that we are doing for Windows relies on the assumption that Java runtime will not
      * change this behaviour.
      * <p>
      * Also note that on Unix we cannot do this. Similarly, other ways of quoting (like using '^^' instead of '^'
      * that you do on interactive command prompt) do not work either, because MSVCRT startup won't handle
      * those in the same way cmd.exe does.
      *
      * See JENKINS-13007 where this blew up on Windows users.
      * See https://github.com/msysgit/msysgit/issues/36 where I filed this as a bug to msysgit.
      **/
     private String sanitize(String arg) {
         if (isWindows()) {
             arg = '"' + arg + '"';
         }
         return arg;
     }
 
     /**
      * validateRevision.
      *
      * @param revName a {@link java.lang.String} object.
      * @return a {@link org.eclipse.jgit.lib.ObjectId} object.
      * @throws hudson.plugins.git.GitException if underlying git operation fails.
      * @throws java.lang.InterruptedException if interrupted.
      */
     public ObjectId validateRevision(String revName) throws GitException, InterruptedException {
         String result = launchCommand("rev-parse", "--verify", revName);
         String line = StringUtils.trimToNull(result);
         if (line == null) {
             throw new GitException("null result from rev-parse(" + revName + ")");
         }
         return ObjectId.fromString(line);
     }
 
     /** {@inheritDoc} */
     @Override
     public String describe(String commitIsh) throws GitException, InterruptedException {
         String result = launchCommand("describe", "--tags", commitIsh);
         String line = firstLine(result);
         if (line == null) {
             throw new GitException("null first line from describe(" + commitIsh + ")");
         }
         return line.trim();
     }
 
     /** {@inheritDoc} */
     @Override
     public void prune(RemoteConfig repository) throws GitException, InterruptedException {
         String repoName = repository.getName();
         String repoUrl = getRemoteUrl(repoName);
         if (repoUrl != null && !repoUrl.isEmpty()) {
             ArgumentListBuilder args = new ArgumentListBuilder();
             args.add("remote", "prune", repoName);
 
             StandardCredentials cred = credentials.get(repoUrl);
             if (cred == null) {
                 cred = defaultCredentials;
             }
 
             try {
                 launchCommandWithCredentials(args, workspace, cred, new URIish(repoUrl));
             } catch (URISyntaxException ex) {
                 throw new GitException("Invalid URL " + repoUrl, ex);
             }
         }
     }
 
     @SuppressFBWarnings(
             value = "RV_DONT_JUST_NULL_CHECK_READLINE",
             justification = "Only needs first line, exception if multiple detected")
     private @CheckForNull String firstLine(String result) throws GitException {
         BufferedReader reader = new BufferedReader(new StringReader(result));
         String line;
         try {
             line = reader.readLine();
             if (line == null) {
                 return null;
             }
             if (reader.readLine() != null) {
                 throw new GitException("Result has multiple lines");
             }
         } catch (IOException e) {
             throw new GitException("Error parsing result", e);
         }
 
         return line;
     }
 
     /**
      * changelog.
      *
      * @return a {@link org.jenkinsci.plugins.gitclient.ChangelogCommand} object.
      */
     @Override
     public ChangelogCommand changelog() {
         return new ChangelogCommand() {
 
             /** Equivalent to the git-log raw format but using ISO 8601 date format - also prevent to depend on git CLI future changes */
             public static final String RAW =
                     "commit %H%ntree %T%nparent %P%nauthor %aN <%aE> %ai%ncommitter %cN <%cE> %ci%n%n%w(0,4,4)%B";
 
             private final List<String> revs = new ArrayList<>();
 
             private Integer n = null;
             private Writer out = null;
 
             @Override
             public ChangelogCommand excludes(String rev) {
                 revs.add(sanitize('^' + rev));
                 return this;
             }
 
             @Override
             public ChangelogCommand excludes(ObjectId rev) {
                 return excludes(rev.name());
             }
 
             @Override
             public ChangelogCommand includes(String rev) {
                 revs.add(rev);
                 return this;
             }
 
             @Override
             public ChangelogCommand includes(ObjectId rev) {
                 return includes(rev.name());
             }
 
             @Override
             public ChangelogCommand to(Writer w) {
                 this.out = w;
                 return this;
             }
 
             @Override
             public ChangelogCommand max(int n) {
                 this.n = n;
                 return this;
             }
 
             @Override
             public void abort() {
                 /* No cleanup needed to abort the CliGitAPIImpl ChangelogCommand */
             }
 
             @Override
             public void execute() throws GitException, InterruptedException {
                 ArgumentListBuilder args = new ArgumentListBuilder(gitExe, "whatchanged", "--no-abbrev", "-M");
                 if (isAtLeastVersion(1, 8, 3, 0)) {
                     args.add("--format=" + RAW);
                 } else {
                     /* Ancient git versions don't support the required format string, use 'raw' and hope it works */
                     args.add("--format=raw");
                 }
                 if (n != null) {
                     args.add("-n").add(n);
                 }
                 for (String rev : this.revs) {
                     args.add(rev);
                 }
 
                 if (out == null) {
                     throw new IllegalStateException();
                 }
 
                 // "git whatchanged" std output gives us byte stream of data
                 // Commit messages in that byte stream are UTF-8 encoded.
                 // We want to decode bytestream to strings using UTF-8 encoding.
                 try (WriterOutputStream w = new WriterOutputStream(out, StandardCharsets.UTF_8)) {
                     if (launcher.launch()
                                     .cmds(args)
                                     .envs(environment)
                                     .stdout(w)
                                     .stderr(listener.getLogger())
                                     .pwd(workspace)
                                     .join()
                             != 0) {
                         throw new GitException("Error: " + args + " in " + workspace);
                     }
                 } catch (IOException e) {
                     throw new GitException("Error: " + args + " in " + workspace, e);
                 }
             }
         };
     }
 
     /** {@inheritDoc} */
     @Override
     public List<String> showRevision(ObjectId from, ObjectId to) throws GitException, InterruptedException {
         return showRevision(from, to, true);
     }
 
     /** {@inheritDoc} */
     @Override
     public List<String> showRevision(ObjectId from, ObjectId to, Boolean useRawOutput)
             throws GitException, InterruptedException {
         ArgumentListBuilder args =
                 new ArgumentListBuilder("log", "--full-history", "--no-abbrev", "--format=raw", "-M", "-m");
         if (useRawOutput) {
             args.add("--raw");
         }
 
         if (from != null) {
             args.add(from.name() + ".." + to.name());
         } else {
             args.add("-1", to.name());
         }
 
         StringWriter writer = new StringWriter();
         writer.write(launchCommand(args));
         return new ArrayList<>(Arrays.asList(writer.toString().split("\\n")));
     }
 
     /**
      * submoduleInit.
      *
      * @throws hudson.plugins.git.GitException if underlying git operation fails.
      * @throws java.lang.InterruptedException if interrupted.
      */
     @Override
     public void submoduleInit() throws GitException, InterruptedException {
         launchCommand("submodule", "init");
     }
 
     /** {@inheritDoc} */
     @Override
     public void addSubmodule(String remoteURL, String subdir) throws GitException, InterruptedException {
         launchCommand("submodule", "add", remoteURL, subdir);
     }
 
     /**
      * Sync submodule URLs
      *
      * @throws hudson.plugins.git.GitException if underlying git operation fails.
      * @throws java.lang.InterruptedException if interrupted.
      */
     @Override
     public void submoduleSync() throws GitException, InterruptedException {
         // Check if git submodule has sync support.
         // Only available in git 1.6.1 and above
         launchCommand("submodule", "sync");
     }
 
     /**
      * Update submodules.
      *
      * @return a {@link org.jenkinsci.plugins.gitclient.SubmoduleUpdateCommand} object.
      */
     @Override
     public SubmoduleUpdateCommand submoduleUpdate() {
         return new SubmoduleUpdateCommand() {
             private boolean recursive = false;
             private boolean remoteTracking = false;
             private boolean parentCredentials = false;
             private boolean shallow = false;
             private String ref = null;
             private Map<String, String> submodBranch = new HashMap<>();
             private Integer timeout;
             private Integer depth = 1;
             private int threads = 1;
 
             @Override
             public SubmoduleUpdateCommand recursive(boolean recursive) {
                 this.recursive = recursive;
                 return this;
             }
 
             @Override
             public SubmoduleUpdateCommand remoteTracking(boolean remoteTracking) {
                 this.remoteTracking = remoteTracking;
                 return this;
             }
 
             @Override
             public SubmoduleUpdateCommand parentCredentials(boolean parentCredentials) {
                 this.parentCredentials = parentCredentials;
                 return this;
             }
 
             @Override
             public SubmoduleUpdateCommand ref(String ref) {
                 this.ref = ref;
                 return this;
             }
 
             @Override
             public SubmoduleUpdateCommand useBranch(String submodule, String branchname) {
                 this.submodBranch.put(submodule, branchname);
                 return this;
             }
 
             @Override
             public SubmoduleUpdateCommand timeout(Integer timeout) {
                 this.timeout = timeout;
                 return this;
             }
 
             @Override
             public SubmoduleUpdateCommand shallow(boolean shallow) {
                 this.shallow = shallow;
                 return this;
             }
 
             @Override
             public SubmoduleUpdateCommand depth(Integer depth) {
                 this.depth = depth;
                 return this;
             }
 
             @Override
             public SubmoduleUpdateCommand threads(int threads) {
                 this.threads = threads;
                 return this;
             }
 
             /**
              * @throws GitException if executing the Git command fails
              * @throws InterruptedException if called methods throw same exception
              */
             @Override
             public void execute() throws GitException, InterruptedException {
                 // Initialize the submodules to ensure that the git config
                 // contains the URLs from .gitmodules.
                 submoduleInit();
 
                 ArgumentListBuilder args = new ArgumentListBuilder();
                 args.add("submodule", "update");
                 if (recursive) {
                     args.add("--init", "--recursive");
                 }
                 if (remoteTracking && isAtLeastVersion(1, 8, 2, 0)) {
                     args.add("--remote");
 
                     for (Map.Entry<String, String> entry : submodBranch.entrySet()) {
                         launchCommand(
                                 "config",
                                 "-f",
                                 ".gitmodules",
                                 "submodule." + entry.getKey() + ".branch",
                                 entry.getValue());
                     }
                 }
                 if ((ref != null) && !ref.isEmpty()) {
-                    File referencePath = new File(ref);
-                    if (!referencePath.exists()) {
-                        listener.getLogger().println("[WARNING] Reference path does not exist: " + ref);
-                    } else if (!referencePath.isDirectory()) {
-                        listener.getLogger().println("[WARNING] Reference path is not a directory: " + ref);
-                    } else {
-                        args.add("--reference", ref);
-                    }
+                    if (!isParameterizedReferenceRepository(ref)) {
+                        File referencePath = new File(ref);
+                        if (!referencePath.exists()) {
+                            listener.getLogger().println("[WARNING] Reference path does not exist: " + ref);
+                        } else if (!referencePath.isDirectory()) {
+                            listener.getLogger().println("[WARNING] Reference path is not a directory: " + ref);
+                        } else {
+                            args.add("--reference", ref);
+                        }
+                    } // else handled below in per-module loop
                 }
                 if (shallow) {
                     if (depth == null) {
@@ -1549,9 +1582,34 @@
                         listener.error("Invalid repository for " + sModuleName);
                         throw new GitException("Invalid repository for " + sModuleName);
                     }
+                    String strURIish = urIish.toPrivateString();
+
+                    if (isParameterizedReferenceRepository(ref)) {
+                        File referencePath = findParameterizedReferenceRepository(ref, strURIish);
+                        if (referencePath == null) {
+                            listener.getLogger()
+                                    .println("[ERROR] Could not make File object from reference path, "
+                                            + "skipping its use: " + ref);
+                        } else {
+                            String expRef = null;
+                            if (referencePath.getPath().equals(ref)) {
+                                expRef = ref;
+                            } else {
+                                expRef = referencePath.getPath();
+                                expRef += " (expanded from " + ref + ")";
+                            }
+                            if (!referencePath.exists()) {
+                                listener.getLogger().println("[WARNING] Reference path does not exist: " + expRef);
+                            } else if (!referencePath.isDirectory()) {
+                                listener.getLogger().println("[WARNING] Reference path is not a directory: " + expRef);
+                            } else {
+                                args.add("--reference", referencePath.getPath());
+                            }
+                        }
+                    }
 
                     // Find credentials for this URL
-                    StandardCredentials cred = credentials.get(urIish.toPrivateString());
+                    StandardCredentials cred = credentials.get(strURIish);
                     if (parentCredentials) {
                         String parentUrl = getRemoteUrl(getDefaultRemote());
                         URIish parentUri = null;
@@ -1661,6 +1719,62 @@
         return StringUtils.trim(firstLine(result));
     }
 
+    /** {@inheritDoc} */
+    @Override
+    public @CheckForNull Map<String, String> getRemoteUrls() throws GitException, InterruptedException {
+        String result = launchCommand("config", "--local", "--list");
+        Map<String, String> uriNames = new HashMap<>();
+        for (String line : result.split("\\R+")) {
+            line = StringUtils.trim(line);
+            if (!line.startsWith("remote.") || !line.contains(".url=")) {
+                continue;
+            }
+
+            String remoteName = StringUtils.substringBetween(line, "remote.", ".url=");
+            String remoteUri = StringUtils.substringAfter(line, ".url=");
+
+            // If uri String values end up identical, Map only stores one entry
+            uriNames.put(remoteUri, remoteName);
+
+            try {
+                URI u = new URI(remoteUri);
+                uriNames.put(u.toASCIIString(), remoteName);
+                URI uSafe = new URI(u.getScheme(), u.getHost(), u.getPath(), u.getFragment());
+                uriNames.put(uSafe.toString(), remoteName);
+                uriNames.put(uSafe.toASCIIString(), remoteName);
+            } catch (URISyntaxException ue) {
+            } // ignore, move along
+        }
+        return uriNames;
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    public @CheckForNull Map<String, String> getRemotePushUrls() throws GitException, InterruptedException {
+        String result = launchCommand("config", "--local", "--list");
+        Map<String, String> uriNames = new HashMap<>();
+        for (String line : result.split("\\R+")) {
+            line = StringUtils.trim(line);
+            if (!line.startsWith("remote.") || !line.contains(".pushurl=")) {
+                continue;
+            }
+
+            String remoteName = StringUtils.substringBetween(line, "remote.", ".pushurl=");
+            String remoteUri = StringUtils.substringAfter(line, ".pushurl=");
+            uriNames.put(remoteUri, remoteName);
+
+            try {
+                URI u = new URI(remoteUri);
+                uriNames.put(u.toASCIIString(), remoteName);
+                URI uSafe = new URI(u.getScheme(), u.getHost(), u.getPath(), u.getFragment());
+                uriNames.put(uSafe.toString(), remoteName);
+                uriNames.put(uSafe.toASCIIString(), remoteName);
+            } catch (URISyntaxException ue) {
+            } // ignore, move along
+        }
+        return uriNames;
+    }
+
     /** {@inheritDoc} */
     @Override
     public void setRemoteUrl(String name, String url) throws GitException, InterruptedException {
@@ -2849,8 +2963,16 @@
             }
 
             if (status != 0) {
-                throw new GitException("Command \"" + command + "\" returned status code " + status + ":\nstdout: "
-                        + stdout + "\nstderr: " + stderr);
+                if (workDir == null)
+                    workDir = java.nio.file.Paths.get(".")
+                            .toAbsolutePath()
+                            .normalize()
+                            .toFile();
+                throw new GitException("Command \"" + command
+                        + "\" executed in workdir \"" + workDir.toString()
+                        + "\" returned status code " + status
+                        + ":\nstdout: " + stdout
+                        + "\nstderr: " + stderr);
             }
 
             return stdout;

src/main/java/org/jenkinsci/plugins/gitclient/GitClient.java

@@ -221,6 +221,28 @@ public interface GitClient {
      */
     String getRemoteUrl(String name) throws GitException, InterruptedException;
 
+    /**
+     * getRemoteUrls.
+     *
+     * @return a Map where String keys represent URIs (with and
+     *         without passwords, if any; ASCII or not, if
+     *         applicable) for all remotes configured in this
+     *         repository/workspace, and values represent names.
+     *         There may be several URIs corresponding to same name.
+     */
+    public Map<String, String> getRemoteUrls() throws GitException, InterruptedException;
+
+    /**
+     * getRemotePushUrls.
+     *
+     * @return a Map where String keys represent push-only URIs
+     *         (with and without passwords, if any; ASCII or not,
+     *         if applicable) for all remotes configured in this
+     *         repository/workspace, and values represent names.
+     *         There may be several URIs corresponding to same name.
+     */
+    public Map<String, String> getRemotePushUrls() throws GitException, InterruptedException;
+
     /**
      * For a given repository, set a remote's URL
      *
@@ -696,12 +718,23 @@ Map<String, String> getRemoteSymbolicReferences(String remoteRepoUrl, String pat
      */
     List<ObjectId> revList(String ref) throws GitException, InterruptedException;
 
+    // --- new instance of same applied class
+
+    /**
+     * newGit.
+     *
+     * @return an {@link IGitAPI} implementation to manage another git repository
+     *   with same general settings and implementation as the current one.
+     * @param somedir a {@link java.lang.String} object.
+     */
+    GitClient newGit(String somedir);
+
     // --- submodules
 
     /**
      * subGit.
      *
-     * @return a IGitAPI implementation to manage git submodule repository
+     * @return an {@link IGitAPI} implementation to manage git submodule repository
      * @param subdir a {@link java.lang.String} object.
      */
     GitClient subGit(String subdir);