From 26059aa44b8168d31095da76854650fe11422deb Mon Sep 17 00:00:00 2001 From: Jim Klimov Date: Wed, 14 Jun 2023 23:47:02 +0200 Subject: [PATCH] LegacyCompatibleGitAPIImpl, etc: reconcile code style with changes in the PR #644 (by @markewaite) and fix some --- .../plugins/gitclient/CliGitAPIImpl.java | 14 +- .../gitclient/LegacyCompatibleGitAPIImpl.java | 423 ++++++++++++------ 2 files changed, 296 insertions(+), 141 deletions(-) diff --git a/src/main/java/org/jenkinsci/plugins/gitclient/CliGitAPIImpl.java b/src/main/java/org/jenkinsci/plugins/gitclient/CliGitAPIImpl.java index c872332ea5..b3f8446eff 100644 --- a/src/main/java/org/jenkinsci/plugins/gitclient/CliGitAPIImpl.java +++ b/src/main/java/org/jenkinsci/plugins/gitclient/CliGitAPIImpl.java @@ -2963,11 +2963,15 @@ private String launchCommandIn(ArgumentListBuilder args, File workDir, EnvVars e if (status != 0) { 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); + 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; diff --git a/src/main/java/org/jenkinsci/plugins/gitclient/LegacyCompatibleGitAPIImpl.java b/src/main/java/org/jenkinsci/plugins/gitclient/LegacyCompatibleGitAPIImpl.java index 77f0cfa989..b979e82090 100644 --- a/src/main/java/org/jenkinsci/plugins/gitclient/LegacyCompatibleGitAPIImpl.java +++ b/src/main/java/org/jenkinsci/plugins/gitclient/LegacyCompatibleGitAPIImpl.java @@ -219,11 +219,13 @@ public static File getObjectsFile(File reference) { return reference; } - if (!reference.exists()) + if (!reference.exists()) { return null; + } - if (!reference.isDirectory()) + if (!reference.isDirectory()) { return null; + } File fGit = new File(reference, ".git"); // workspace - file, dir or symlink to those File objects = null; @@ -231,13 +233,15 @@ public static File getObjectsFile(File reference) { if (fGit.exists()) { if (fGit.isDirectory()) { objects = new File(fGit, "objects"); // this might not exist or not be a dir - checked below -/* + /* if (objects == null) { // spotbugs dislikes this, since "new File()" should not return null return objects; // Some Java error, could not make object from the paths involved } -*/ - LOGGER.log(Level.FINEST, "getObjectsFile(): found an fGit '" + - fGit.getAbsolutePath().toString() + "' which is a directory"); + */ + LOGGER.log( + Level.FINEST, + "getObjectsFile(): found an fGit '" + + fGit.getAbsolutePath().toString() + "' which is a directory"); } else { // If ".git" FS object exists and is a not-empty file (and // is not a dir), then its content may point to some other @@ -246,24 +250,27 @@ public static File getObjectsFile(File reference) { // to the index and other metadata stored in its "parent" // repository's directory: // "gitdir: ../.git/modules/childRepoName" - LOGGER.log(Level.FINEST, "getObjectsFile(): found an fGit '" + - fGit.getAbsolutePath().toString() + "' which is NOT a directory"); + LOGGER.log( + Level.FINEST, + "getObjectsFile(): found an fGit '" + + fGit.getAbsolutePath().toString() + "' which is NOT a directory"); BufferedReader reader = null; try { String line; reader = new BufferedReader(new InputStreamReader(new FileInputStream(fGit), "UTF-8")); - while ((line = reader.readLine()) != null) - { + while ((line = reader.readLine()) != null) { String[] parts = line.split(":", 2); - if (parts.length >= 2) - { + if (parts.length >= 2) { String key = parts[0].trim(); String value = parts[1].trim(); if (key.equals("gitdir")) { objects = new File(reference, value); - LOGGER.log(Level.FINE, "getObjectsFile(): while looking for 'gitdir:' in '" + - fGit.getAbsolutePath().toString() + "', found reference to objects " + - "which should be at: '" + objects.getAbsolutePath().toString() + "'"); + LOGGER.log( + Level.FINE, + "getObjectsFile(): while looking for 'gitdir:' in '" + + fGit.getAbsolutePath().toString() + + "', found reference to objects which should be at: '" + + objects.getAbsolutePath().toString() + "'"); // Note: we don't use getCanonicalPath() here to avoid further filesystem // access and possible exceptions (the getAbsolutePath() is about string // processing), but callers might benefit from canonicising and ensuring @@ -274,15 +281,23 @@ public static File getObjectsFile(File reference) { // prefixes for the contexts the callers would define for themselves. break; } - LOGGER.log(Level.FINEST, "getObjectsFile(): while looking for 'gitdir:' in '" + - fGit.getAbsolutePath().toString() + "', ignoring line: " + line); + LOGGER.log( + Level.FINEST, + "getObjectsFile(): while looking for 'gitdir:' in '" + + fGit.getAbsolutePath().toString() + "', ignoring line: " + line); } } if (objects == null) { - LOGGER.log(Level.WARNING, "getObjectsFile(): failed to parse '" + fGit.getAbsolutePath().toString() + "': did not contain a 'gitdir:' entry"); + LOGGER.log( + Level.WARNING, + "getObjectsFile(): failed to parse '" + + fGit.getAbsolutePath().toString() + "': did not contain a 'gitdir:' entry"); } } catch (IOException e) { - LOGGER.log(Level.SEVERE, "getObjectsFile(): failed to parse '" + fGit.getAbsolutePath().toString() + "': " + e.toString()); + LOGGER.log( + Level.SEVERE, + "getObjectsFile(): failed to parse '" + + fGit.getAbsolutePath().toString() + "': " + e.toString()); objects = null; } try { @@ -290,43 +305,56 @@ public static File getObjectsFile(File reference) { reader.close(); } } catch (IOException e) { - LOGGER.log(Level.SEVERE, "getObjectsFile(): failed to close file after parsing '" + fGit.getAbsolutePath().toString() + "': " + e.toString()); + LOGGER.log( + Level.SEVERE, + "getObjectsFile(): failed to close file after parsing '" + + fGit.getAbsolutePath().toString() + "': " + e.toString()); } } } else { - LOGGER.log(Level.FINEST, "getObjectsFile(): did not find any checked-out '" + - fGit.getAbsolutePath().toString() + "'"); + LOGGER.log( + Level.FINEST, + "getObjectsFile(): did not find any checked-out '" + + fGit.getAbsolutePath().toString() + "'"); } if (objects == null || !objects.isDirectory()) { // either reference path is bare repo (no ".git" inside), // or we have failed interpreting ".git" contents above objects = new File(reference, "objects"); // bare -/* + /* if (objects == null) { return objects; // Some Java error, could not make object from the paths involved } -*/ + */ // This clause below is redundant for production, but useful for troubleshooting if (objects.exists()) { if (objects.isDirectory()) { - LOGGER.log(Level.FINEST, "getObjectsFile(): found a bare '" + - objects.getAbsolutePath().toString() + "' which is a directory"); + LOGGER.log( + Level.FINEST, + "getObjectsFile(): found a bare '" + + objects.getAbsolutePath().toString() + "' which is a directory"); } else { - LOGGER.log(Level.FINEST, "getObjectsFile(): found a bare '" + - objects.getAbsolutePath().toString() + "' which is NOT a directory"); + LOGGER.log( + Level.FINEST, + "getObjectsFile(): found a bare '" + + objects.getAbsolutePath().toString() + "' which is NOT a directory"); } } else { - LOGGER.log(Level.FINEST, "getObjectsFile(): did not find any bare '" + - objects.getAbsolutePath().toString() + "'"); + LOGGER.log( + Level.FINEST, + "getObjectsFile(): did not find any bare '" + + objects.getAbsolutePath().toString() + "'"); } } - if (!objects.exists()) + if (!objects.exists()) { return null; + } - if (!objects.isDirectory()) + if (!objects.isDirectory()) { return null; + } // If we get here, we have a non-null File referencing a // "(.git/)objects" subdir under original referencePath @@ -381,15 +409,13 @@ public static Boolean isParameterizedReferenceRepository(String reference) { * using the same access protocol. This routine converts the "url" string * in a way that helps us confirm whether two spellings mean same thing. */ - @SuppressFBWarnings(value = "DMI_HARDCODED_ABSOLUTE_FILENAME", - justification = "Path operations below intentionally use absolute '/' in some cases" - ) + @SuppressFBWarnings( + value = "DMI_HARDCODED_ABSOLUTE_FILENAME", + justification = "Path operations below intentionally use absolute '/' in some cases") public static String normalizeGitUrl(String url, Boolean checkLocalPaths) { String urlNormalized = url.replaceAll("/*$", "").replaceAll(".git$", "").toLowerCase(); if (!url.contains("://")) { - if (!url.startsWith("/") && - !url.startsWith(".") - ) { + if (!url.startsWith("/") && !url.startsWith(".")) { // Not an URL with schema, not an absolute or relative pathname if (checkLocalPaths) { File urlPath = new File(url); @@ -397,16 +423,30 @@ public static String normalizeGitUrl(String url, Boolean checkLocalPaths) { try { // Check if the string in urlNormalized is a valid // relative path (subdir) in current working directory - urlNormalized = "file://" + Paths.get( Paths.get("").toAbsolutePath().toString() + "/" + urlNormalized ).normalize().toString(); + urlNormalized = "file://" + + Paths.get(Paths.get("").toAbsolutePath().toString() + "/" + urlNormalized) + .normalize() + .toString(); } catch (java.nio.file.InvalidPathException ipe1) { - // e.g. Illegal char <:> at index 30: C:\jenkins\git-client-plugin/c:\jenkins\git-client-plugin\target\clone + // e.g. Illegal char <:> at index 30: + // C:\jenkins\git-client-plugin/c:\jenkins\git-client-plugin\target\clone try { // Re-check in another manner - urlNormalized = "file://" + Paths.get( Paths.get("", urlNormalized).toAbsolutePath().toString() ).normalize().toString(); + urlNormalized = "file://" + + Paths.get(Paths.get("", urlNormalized) + .toAbsolutePath() + .toString()) + .normalize() + .toString(); } catch (java.nio.file.InvalidPathException ipe2) { // Finally, fall back to checking the originally // fully-qualified path - urlNormalized = "file://" + Paths.get( Paths.get("/", urlNormalized).toAbsolutePath().toString() ).normalize().toString(); + urlNormalized = "file://" + + Paths.get(Paths.get("/", urlNormalized) + .toAbsolutePath() + .toString()) + .normalize() + .toString(); } } } else { @@ -422,12 +462,17 @@ public static String normalizeGitUrl(String url, Boolean checkLocalPaths) { if (url.startsWith("/")) { urlNormalized = "file://" + urlNormalized; } else { - urlNormalized = "file://" + Paths.get( Paths.get("").toAbsolutePath().toString() + "/" + urlNormalized ).normalize().toString();; + urlNormalized = "file://" + + Paths.get(Paths.get("").toAbsolutePath().toString() + "/" + urlNormalized) + .normalize() + .toString(); } } } - LOGGER.log(Level.FINEST, "normalizeGitUrl('" + url + "', " + checkLocalPaths.toString() + ") => " + urlNormalized); + LOGGER.log( + Level.FINEST, + "normalizeGitUrl('" + url + "', " + checkLocalPaths.toString() + ") => " + urlNormalized); return urlNormalized; } @@ -471,7 +516,8 @@ public static String normalizeGitUrl(String url, Boolean checkLocalPaths) { * when recursing, since this directory was checked already * as part of parent directory inspection. */ - public SimpleEntry> getSubmodulesUrls(String referenceBaseDir, String needle, Boolean checkRemotesInReferenceBaseDir) { + public SimpleEntry> getSubmodulesUrls( + String referenceBaseDir, String needle, Boolean checkRemotesInReferenceBaseDir) { // Keep track of where we've already looked in the "result" Set, to // avoid looking in same places (different strategies below) twice. // And eventually return this Set or part of it as the answer. @@ -484,13 +530,19 @@ public SimpleEntry> getSubmodulesUrls(String re // We want to hit same dirs only once, so canonicize paths below String referenceBaseDirAbs; try { - referenceBaseDirAbs = new File(referenceBaseDir).getAbsoluteFile().getCanonicalPath().toString(); + referenceBaseDirAbs = new File(referenceBaseDir) + .getAbsoluteFile() + .getCanonicalPath() + .toString(); } catch (IOException e) { // Access error while dereferencing some parent?.. referenceBaseDirAbs = new File(referenceBaseDir).getAbsoluteFile().toString(); - LOGGER.log(Level.SEVERE, "getSubmodulesUrls(): failed to canonicize '" + - referenceBaseDir + "' => '" + referenceBaseDirAbs + "': " + e.toString()); - //return new SimpleEntry<>(false, result); + LOGGER.log( + Level.SEVERE, + "getSubmodulesUrls(): failed to canonicize '" + + referenceBaseDir + "' => '" + referenceBaseDirAbs + "': " + + e.toString()); + // return new SimpleEntry<>(false, result); } // "this" during a checkout typically represents the job workspace, @@ -500,7 +552,7 @@ public SimpleEntry> getSubmodulesUrls(String re Boolean isBare = false; try { - isBare = ((hudson.plugins.git.IGitAPI)referenceGit).isBareRepository(); + isBare = ((hudson.plugins.git.IGitAPI) referenceGit).isBareRepository(); } catch (InterruptedException | GitException e) { // Proposed base directory whose subdirs contain refrepos might // itself be not a repo. Shouldn't be per reference scripts, but... @@ -517,9 +569,11 @@ public SimpleEntry> getSubmodulesUrls(String re isBare = false; } - LOGGER.log(Level.SEVERE, "getSubmodulesUrls(): failed to determine " + - "isBareRepository() in '" + referenceBaseDirAbs + "'; " + - "assuming '" + isBare + "': " + e.toString()); + LOGGER.log( + Level.SEVERE, + "getSubmodulesUrls(): failed to determine isBareRepository() in '" + + referenceBaseDirAbs + "'; " + "assuming '" + isBare + "': " + + e.toString()); } // Simplify checks below by stating a useless needle is null @@ -583,36 +637,57 @@ public SimpleEntry> getSubmodulesUrls(String re arrDirnames.add(referenceBaseDirAbs + "/" + needleSha); arrDirnames.add(referenceBaseDirAbs + "/" + needleSha + ".git"); - LOGGER.log(Level.FINE, "getSubmodulesUrls(): looking at basename-like subdirs under base refrepo '" + referenceBaseDirAbs + "', per arrDirnames: " + arrDirnames.toString()); + LOGGER.log( + Level.FINE, + "getSubmodulesUrls(): looking at basename-like subdirs under base refrepo '" + + referenceBaseDirAbs + "', per arrDirnames: " + arrDirnames.toString()); for (String dirname : arrDirnames) { f = new File(dirname); - LOGGER.log(Level.FINEST, "getSubmodulesUrls(): probing dir at abs pathname '" + dirname + "' if it exists"); + LOGGER.log( + Level.FINEST, + "getSubmodulesUrls(): probing dir at abs pathname '" + dirname + "' if it exists"); if (getObjectsFile(f) != null) { try { - LOGGER.log(Level.FINE, "getSubmodulesUrls(): looking for submodule URL needle='" + needle + "' in existing refrepo subdir '" + dirname + "'"); + LOGGER.log( + Level.FINE, + "getSubmodulesUrls(): looking for submodule URL needle='" + needle + + "' in existing refrepo subdir '" + dirname + "'"); GitClient g = referenceGit.subGit(dirname); - LOGGER.log(Level.FINE, "getSubmodulesUrls(): checking git workspace in dir '" + g.getWorkTree().absolutize().toString() + "'"); - Map uriNames = g.getRemoteUrls(); - LOGGER.log(Level.FINEST, "getSubmodulesUrls(): sub-git getRemoteUrls() returned this Map uriNames: " + uriNames.toString()); + LOGGER.log( + Level.FINE, + "getSubmodulesUrls(): checking git workspace in dir '" + + g.getWorkTree().absolutize().toString() + "'"); + Map uriNames = g.getRemoteUrls(); + LOGGER.log( + Level.FINEST, + "getSubmodulesUrls(): sub-git getRemoteUrls() returned this Map uriNames: " + + uriNames.toString()); for (Map.Entry pair : uriNames.entrySet()) { String remoteName = pair.getValue(); // whatever the git workspace config calls it String uri = pair.getKey(); String uriNorm = normalizeGitUrl(uri, true); - LOGGER.log(Level.FINE, "getSubmodulesUrls(): checking uri='" + uri + "' (uriNorm='" + uriNorm + "') vs needle"); + LOGGER.log( + Level.FINE, + "getSubmodulesUrls(): checking uri='" + uri + + "' (uriNorm='" + uriNorm + "') vs needle"); if (needleNorm.equals(uriNorm) || needle.equals(uri)) { result = new LinkedHashSet<>(); - result.add(new String[]{dirname, uri, uriNorm, remoteName}); + result.add(new String[] {dirname, uri, uriNorm, remoteName}); return new SimpleEntry<>(true, result); } // Cache the finding to avoid the dirname later, if we // get to that; but no checks are needed in this loop // which by construct looks at different dirs so far. - result.add(new String[]{dirname, uri, uriNorm, remoteName}); + result.add(new String[] {dirname, uri, uriNorm, remoteName}); } } catch (Throwable t) { // ignore, go to next slide - LOGGER.log(Level.FINE, "getSubmodulesUrls(): probing dir '" + dirname + "' resulted in an exception or error (will go to next item):\n" + t.toString()); + LOGGER.log( + Level.FINE, + "getSubmodulesUrls(): probing dir '" + dirname + + "' resulted in an exception or error (will go to next item):\n" + + t.toString()); } } } @@ -641,13 +716,13 @@ public SimpleEntry> getSubmodulesUrls(String re checkedDirs.add(resultEntry[0]); } -/* -// TBD: Needs a way to list submodules in given workspace and convert -// that into (relative) subdirs, possibly buried some levels deep, for -// cases where the submodule is defined in parent with the needle URL. -// Maybe merge with current "if isBare" below, to optionally seed -// same arrDirnames with different values and check remotes listed -// in those repos. + /* + // TBD: Needs a way to list submodules in given workspace and convert + // that into (relative) subdirs, possibly buried some levels deep, for + // cases where the submodule is defined in parent with the needle URL. + // Maybe merge with current "if isBare" below, to optionally seed + // same arrDirnames with different values and check remotes listed + // in those repos. // If current repo *is NOT* bare - check its submodules // (the .gitmodules => submodule.MODNAME.{url,path} mapping) // but this essentially does not look into any subdirectory. @@ -669,14 +744,13 @@ public SimpleEntry> getSubmodulesUrls(String re // over time or in different branches a "leaf" project could // reference different subs? // getRemoteUrls() => Map -// arrDirnames.clear(); + //// arrDirnames.clear(); // TODO: Check subdirs that are git workspaces, and remove "|| true" above -// LinkedHashSet checkedDirs = new LinkedHashSet<>(); -// for (String[] resultEntry : result) { -// checkedDirs.add(resultEntry[0]); -// } - + //// LinkedHashSet checkedDirs = new LinkedHashSet<>(); + //// for (String[] resultEntry : result) { + //// checkedDirs.add(resultEntry[0]); + //// } LOGGER.log(Level.FINE, "getSubmodulesUrls(): looking for submodule URL needle='" + needle + "' in submodules of refrepo, if any"); Map uriNames = referenceGit.getRemoteUrls(); @@ -699,7 +773,7 @@ public SimpleEntry> getSubmodulesUrls(String re // ignore, go to next slide } } -*/ + */ // If current repo *is* bare (can't have proper submodules), or if the // end-users just cloned or linked some more repos into this container, @@ -733,34 +807,55 @@ public SimpleEntry> getSubmodulesUrls(String re } } - LOGGER.log(Level.FINE, "getSubmodulesUrls(): looking at " + - ((isBare ? "" : "submodules first, then ")) + - "all subdirs that have a .git, under refrepo '" + referenceBaseDirAbs + - "' per absolute arrDirnames: " + arrDirnames.toString()); + LOGGER.log( + Level.FINE, + "getSubmodulesUrls(): looking at " + + ((isBare ? "" : "submodules first, then ")) + + "all subdirs that have a .git, under refrepo '" + + referenceBaseDirAbs + "' per absolute arrDirnames: " + + arrDirnames.toString()); for (String dirname : arrDirnames) { // Note that here dirnames deal in absolutes f = new File(dirname); - LOGGER.log(Level.FINEST, "getSubmodulesUrls(): probing dir '" + dirname + "' if it exists"); + LOGGER.log( + Level.FINEST, + "getSubmodulesUrls(): probing dir '" + dirname + "' if it exists"); if (f.exists() && f.isDirectory()) { // No checks for ".git" or "objects" this time, already checked above // by getObjectsFile(). Probably should not check exists/dir either, // but better be on the safe side :) if (!checkedDirs.contains(dirname)) { try { - LOGGER.log(Level.FINE, "getSubmodulesUrls(): looking " + ((needle == null) ? "" : "for submodule URL needle='" + needle + "' ") + "in existing refrepo dir '" + dirname + "'"); + LOGGER.log( + Level.FINE, + "getSubmodulesUrls(): looking " + + ((needle == null) ? "" : "for submodule URL needle='" + needle + "' ") + + "in existing refrepo dir '" + dirname + "'"); GitClient g = this.newGit(dirname); - LOGGER.log(Level.FINE, "getSubmodulesUrls(): checking git workspace in dir '" + g.getWorkTree().absolutize().toString() + "'"); - Map uriNames = g.getRemoteUrls(); - LOGGER.log(Level.FINEST, "getSubmodulesUrls(): sub-git getRemoteUrls() returned this Map uriNames: " + uriNames.toString()); + LOGGER.log( + Level.FINE, + "getSubmodulesUrls(): checking git workspace in dir '" + + g.getWorkTree().absolutize().toString() + "'"); + Map uriNames = g.getRemoteUrls(); + LOGGER.log( + Level.FINEST, + "getSubmodulesUrls(): sub-git getRemoteUrls() returned this Map uriNames: " + + uriNames.toString()); for (Map.Entry pair : uriNames.entrySet()) { String remoteName = pair.getValue(); // whatever the git workspace config calls it String uri = pair.getKey(); String uriNorm = normalizeGitUrl(uri, true); - LOGGER.log(Level.FINE, "getSubmodulesUrls(): checking uri='" + uri + "' (uriNorm='" + uriNorm + "') vs needle"); - if (needle != null && needleNorm != null && (needleNorm.equals(uriNorm) || needle.equals(uri)) ) { + LOGGER.log( + Level.FINE, + "getSubmodulesUrls(): checking uri='" + uri + + "' (uriNorm='" + uriNorm + "') vs needle"); + if (needle != null + && needleNorm != null + && (needleNorm.equals(uriNorm) || needle.equals(uri)) + ) { result = new LinkedHashSet<>(); - result.add(new String[]{dirname, uri, uriNorm, remoteName}); + result.add(new String[] {dirname, uri, uriNorm, remoteName}); return new SimpleEntry<>(true, result); } // Cache the finding to return eventually, for each remote: @@ -768,26 +863,39 @@ public SimpleEntry> getSubmodulesUrls(String re // * original remote URI from that workspace's config // * normalized remote URI // * name of the remote from that workspace's config ("origin" etc) - result.add(new String[]{dirname, uri, uriNorm, remoteName}); + result.add(new String[] {dirname, uri, uriNorm, remoteName}); } } catch (Throwable t) { // ignore, go to next slide - LOGGER.log(Level.FINE, "getSubmodulesUrls(): probing dir '" + dirname + "' resulted in an exception or error (will go to next item):\n" + t.toString()); + LOGGER.log( + Level.FINE, + "getSubmodulesUrls(): probing dir '" + dirname + + "' resulted in an exception or error (will go to next item):\n" + + t.toString()); } } // Here is a good spot to recurse this routine into a // subdir that is already a known git workspace, to // add its data to list and/or return a found needle. - LOGGER.log(Level.FINE, "getSubmodulesUrls(): recursing into dir '" + dirname + "'..."); - SimpleEntry > subEntriesRet = getSubmodulesUrls(dirname, needle, false); + LOGGER.log( + Level.FINE, + "getSubmodulesUrls(): recursing into dir '" + dirname + "'..."); + SimpleEntry> subEntriesRet = + getSubmodulesUrls(dirname, needle, false); Boolean subEntriesExactMatched = subEntriesRet.getKey(); LinkedHashSet subEntries = subEntriesRet.getValue(); - LOGGER.log(Level.FINE, "getSubmodulesUrls(): returned from recursing into dir '" + dirname + "' with " + subEntries.size() + " found mappings"); + LOGGER.log( + Level.FINE, + "getSubmodulesUrls(): returned from recursing into dir '" + dirname + + "' with " + subEntries.size() + " found mappings"); if (!subEntries.isEmpty()) { if (needle != null && subEntriesExactMatched) { // We found nothing... until now! Bubble it up! - LOGGER.log(Level.FINE, "getSubmodulesUrls(): got an exact needle match from recursing into dir '" + dirname + "': " + subEntries.iterator().next()[0]); + LOGGER.log( + Level.FINE, + "getSubmodulesUrls(): got an exact needle match from recursing into dir '" + + dirname + "': " + subEntries.iterator().next()[0]); return subEntriesRet; } // ...else collect results to inspect and/or propagate later @@ -809,13 +917,13 @@ public SimpleEntry> getSubmodulesUrls(String re // results looks like it is related to the needle. LinkedHashSet resultFiltered = new LinkedHashSet<>(); -/* + /* if (!checkRemotesInReferenceBaseDir) { // Overload the flag's meaning to only parse results once, // in the parent dir? return new SimpleEntry<>(false, resultFiltered); } -*/ + */ // Separate lists by suggestion priority: // 1) URI basename similarity @@ -956,20 +1064,25 @@ public File findParameterizedReferenceRepository(String reference, String url) { // Note: Initially we expect the reference to be a realistic dirname // with a special suffix to substitute after the logic below, so the // referencePath for that verbatim funny string should not exist now: - if (!referencePath.exists() && - isParameterizedReferenceRepository(reference) && - url != null && !url.isEmpty() + if (!referencePath.exists() + && isParameterizedReferenceRepository(reference) + && url != null + && !url.isEmpty() ) { // Drop the trailing keyword to know the root refrepo dirname String referenceBaseDir = reference.replaceAll("/\\$\\{GIT_[^\\}]*\\}$", ""); File referenceBaseDirFile = new File(referenceBaseDir); if (!referenceBaseDirFile.exists()) { - LOGGER.log(Level.WARNING, "Base Git reference directory " + referenceBaseDir + " does not exist"); + LOGGER.log( + Level.WARNING, + "Base Git reference directory " + referenceBaseDir + " does not exist"); return null; } if (!referenceBaseDirFile.isDirectory()) { - LOGGER.log(Level.WARNING, "Base Git reference directory " + referenceBaseDir + " is not a directory"); + LOGGER.log( + Level.WARNING, + "Base Git reference directory " + referenceBaseDir + " is not a directory"); return null; } @@ -984,31 +1097,39 @@ public File findParameterizedReferenceRepository(String reference, String url) { String urlNormalized = normalizeGitUrl(url, true); // Note: currently unit-tests expect this markup on stderr: - System.err.println("reference='" + reference + "'\n" + - "url='" + url + "'\n" + - "urlNormalized='" + urlNormalized + "'\n"); + System.err.println("reference='" + reference + "'\n" + + "url='" + url + "'\n" + + "urlNormalized='" + urlNormalized + "'\n"); // Let users know why there are many "git config --list" lines in their build log: - LOGGER.log(Level.INFO, "Trying to resolve parameterized Git reference repository '" + - reference + "' into a specific (sub-)directory to use for URL '" + url + "' ..."); + LOGGER.log( + Level.INFO, + "Trying to resolve parameterized Git reference repository '" + reference + + "' into a specific (sub-)directory to use for URL '" + url + "' ..."); String referenceExpanded = null; if (reference.endsWith("/${GIT_URL_SHA256}")) { // This may be the more portable solution with regard to filesystems - referenceExpanded = reference.replaceAll("\\$\\{GIT_URL_SHA256\\}$", - DigestUtils.sha256Hex(urlNormalized)); + referenceExpanded = reference.replaceAll( + "\\$\\{GIT_URL_SHA256\\}$", + DigestUtils.sha256Hex(urlNormalized)); } else if (reference.endsWith("/${GIT_URL_SHA256_FALLBACK}")) { // The safest option - fall back to parent directory if // the expanded one does not have git repo data right now: // it allows to gradually convert a big combined reference // repository into smaller chunks without breaking builds. - referenceExpanded = reference.replaceAll("\\$\\{GIT_URL_SHA256_FALLBACK\\}$", - DigestUtils.sha256Hex(urlNormalized)); - if (getObjectsFile(referenceExpanded) == null && getObjectsFile(referenceExpanded + ".git") == null) { + referenceExpanded = reference.replaceAll( + "\\$\\{GIT_URL_SHA256_FALLBACK\\}$", + DigestUtils.sha256Hex(urlNormalized)); + if (getObjectsFile(referenceExpanded) == null + && getObjectsFile(referenceExpanded + ".git") == null + ) { // chop it off, use main directory referenceExpanded = referenceBaseDir; } - } else if (reference.endsWith("/${GIT_URL_BASENAME}") || reference.endsWith("/${GIT_URL_BASENAME_FALLBACK}")) { + } else if (reference.endsWith("/${GIT_URL_BASENAME}") + || reference.endsWith("/${GIT_URL_BASENAME_FALLBACK}") + ) { // This may be the more portable solution with regard to filesystems // First try with original user-provided casing of the URL (if local // dirs were cloned manually) @@ -1022,18 +1143,26 @@ public File findParameterizedReferenceRepository(String reference, String url) { needleBasename = needleBasename.replaceAll(".git$", ""); if (reference.endsWith("/${GIT_URL_BASENAME}")) { - referenceExpanded = reference.replaceAll("\\$\\{GIT_URL_BASENAME\\}$", - needleBasename); + referenceExpanded = reference.replaceAll( + "\\$\\{GIT_URL_BASENAME\\}$", + needleBasename); } else { // if (reference.endsWith("/${GIT_URL_BASENAME_FALLBACK}")) { - referenceExpanded = reference.replaceAll("\\$\\{GIT_URL_BASENAME_FALLBACK\\}$", - needleBasename); - if (url.equals(urlNormalized) && getObjectsFile(referenceExpanded) == null && getObjectsFile(referenceExpanded + ".git") == null) { + referenceExpanded = reference.replaceAll( + "\\$\\{GIT_URL_BASENAME_FALLBACK\\}$", + needleBasename); + if (url.equals(urlNormalized) + && getObjectsFile(referenceExpanded) == null + && getObjectsFile(referenceExpanded + ".git") == null + ) { // chop it off, use main directory (only if we do not check urlNormalized separately below) referenceExpanded = referenceBaseDir; } } - if (!url.equals(urlNormalized) && getObjectsFile(referenceExpanded) == null && getObjectsFile(referenceExpanded + ".git") == null) { + if (!url.equals(urlNormalized) + && getObjectsFile(referenceExpanded) == null + && getObjectsFile(referenceExpanded + ".git") == null + ) { // Retry with automation-ready normalized URL sep = urlNormalized.lastIndexOf("/"); if (sep < 0) { @@ -1044,18 +1173,24 @@ public File findParameterizedReferenceRepository(String reference, String url) { needleBasename = needleBasename.replaceAll(".git$", ""); if (reference.endsWith("/${GIT_URL_BASENAME}")) { - referenceExpanded = reference.replaceAll("\\$\\{GIT_URL_BASENAME\\}$", - needleBasename); + referenceExpanded = reference.replaceAll( + "\\$\\{GIT_URL_BASENAME\\}$", + needleBasename); } else { // if (reference.endsWith("/${GIT_URL_BASENAME_FALLBACK}")) { - referenceExpanded = reference.replaceAll("\\$\\{GIT_URL_BASENAME_FALLBACK\\}$", - needleBasename); - if (getObjectsFile(referenceExpanded) == null && getObjectsFile(referenceExpanded + ".git") == null) { + referenceExpanded = reference.replaceAll( + "\\$\\{GIT_URL_BASENAME_FALLBACK\\}$", + needleBasename); + if (getObjectsFile(referenceExpanded) == null + && getObjectsFile(referenceExpanded + ".git") == null + ) { // chop it off, use main directory referenceExpanded = referenceBaseDir; } } } - } else if (reference.endsWith("/${GIT_SUBMODULES}") || reference.endsWith("/${GIT_SUBMODULES_FALLBACK}") ) { + } else if (reference.endsWith("/${GIT_SUBMODULES}") + || reference.endsWith("/${GIT_SUBMODULES_FALLBACK}") + ) { // Here we employ git submodules - so we can reliably match // remote URLs (easily multiple) to particular modules, and // yet keep separate git index directories per module with @@ -1076,7 +1211,8 @@ public File findParameterizedReferenceRepository(String reference, String url) { // Note: we pass the unmodified "url" value here, the routine // differentiates original spelling vs. normalization while // looking for its needle in the haystack. - SimpleEntry > subEntriesRet = getSubmodulesUrls(referenceBaseDir, url, true); + SimpleEntry> subEntriesRet = + getSubmodulesUrls(referenceBaseDir, url, true); Boolean subEntriesExactMatched = subEntriesRet.getKey(); LinkedHashSet subEntries = subEntriesRet.getValue(); if (!subEntries.isEmpty()) { @@ -1096,13 +1232,21 @@ public File findParameterizedReferenceRepository(String reference, String url) { if (referenceExpanded == null) { referenceExpanded = subEntries.iterator().next()[0]; } - LOGGER.log(Level.FINE, "findParameterizedReferenceRepository(): got referenceExpanded='" + referenceExpanded + "' from subEntries"); - if (reference.endsWith("/${GIT_SUBMODULES_FALLBACK}") && getObjectsFile(referenceExpanded) == null && getObjectsFile(referenceExpanded + ".git") == null) { + LOGGER.log( + Level.FINE, + "findParameterizedReferenceRepository(): got referenceExpanded='" + + referenceExpanded + "' from subEntries"); + if (reference.endsWith("/${GIT_SUBMODULES_FALLBACK}") + && getObjectsFile(referenceExpanded) == null + && getObjectsFile(referenceExpanded + ".git") == null + ) { // chop it off, use main directory referenceExpanded = referenceBaseDir; } } else { - LOGGER.log(Level.FINE, "findParameterizedReferenceRepository(): got no subEntries"); + LOGGER.log( + Level.FINE, + "findParameterizedReferenceRepository(): got no subEntries"); // If there is no hit, the non-fallback mode suggests a new // directory name to host the submodule (same rules as for // the refrepo forks' co-hosting friendly basename search), @@ -1117,13 +1261,18 @@ public File findParameterizedReferenceRepository(String reference, String url) { needleBasename = needleBasename.replaceAll(".git$", ""); if (reference.endsWith("/${GIT_SUBMODULES}")) { - referenceExpanded = reference.replaceAll("\\$\\{GIT_SUBMODULES\\}$", - needleBasename); + referenceExpanded = reference.replaceAll( + "\\$\\{GIT_SUBMODULES\\}$", + needleBasename); } else { // if (reference.endsWith("/${GIT_SUBMODULES_FALLBACK}")) { - referenceExpanded = reference.replaceAll("\\$\\{GIT_SUBMODULES\\}$", - needleBasename); - if (reference.endsWith("/${GIT_SUBMODULES_FALLBACK}") && getObjectsFile(referenceExpanded) == null && getObjectsFile(referenceExpanded + ".git") == null) { + referenceExpanded = reference.replaceAll( + "\\$\\{GIT_SUBMODULES\\}$", + needleBasename); + if (reference.endsWith("/${GIT_SUBMODULES_FALLBACK}") + && getObjectsFile(referenceExpanded) == null + && getObjectsFile(referenceExpanded + ".git") == null + ) { // chop it off, use main directory referenceExpanded = referenceBaseDir; } @@ -1140,8 +1289,10 @@ public File findParameterizedReferenceRepository(String reference, String url) { // Note: currently unit-tests expect this markup on stderr: System.err.println("reference after='" + reference + "'\n"); - LOGGER.log(Level.INFO, "After resolving the parameterized Git reference repository, " + - "decided to use '" + reference + "' directory for URL '" + url + "'"); + LOGGER.log( + Level.INFO, + "After resolving the parameterized Git reference repository, " + + "decided to use '" + reference + "' directory for URL '" + url + "'"); } // if referencePath is the replaceable token and not existing directory if (!referencePath.exists() && !reference.endsWith(".git")) {