));
        gitInfo.disallowChanges();
        gitInfo.finalizeValueOnRead();

        revision = gitInfo.map(info -> info.getRevision() == null ? info.getRevision() : "master");
    }

    public Property<GitInfo> getGitInfo() {
        return gitInfo;
    }

    public Provider<String> getRevision() {
        return revision;
    }

        this.providerFactory = providerFactory;
    }

    @Override
    public void apply(Project project) {
        Provider<String> revision = project.getRootProject().getPlugins().apply(GitInfoPlugin.class).getRevision();
        Provider<String> licenseCommitProvider = providerFactory.provider(() ->
             isSnapshotVersion(project) ? revision.get() : "v" + project.getVersion().toString()
        );

                    spec.workingDir(checkoutDir);
                    spec.commandLine("git", "checkout", effectiveRefSpec);
                });

                String checkoutHash = GitInfo.gitInfo(checkoutDir).getRevision();
                logger.lifecycle("Checkout hash for {} is {}", project.getPath(), checkoutHash);
                writeFile(new File(project.getBuildDir(), "refspec"), checkoutHash);
            });
        });

        return Objects.hash(major, minor, revision, qualifier);
    }

    public int getMajor() {
        return major;
    }

    public int getMinor() {
        return minor;
    }

    public int getRevision() {
        return revision;
    }

    public boolean hasQualifier() {
        return qualifier != null;
    }

    public Qualifier getQualifier() {
        return qualifier;
    }

    private final String revision;
    private final String origin;

    private GitInfo(String revision, String origin) {
        this.revision = revision;
        this.origin = origin;
    }

    public String getRevision() {
        return revision;
    }

    public String getOrigin() {
        return origin;
    }

    public static GitInfo gitInfo(File rootDir) {
        try {
            /*

        }

        Map<Integer, List<Version>> releasedMajorGroupedByMinor = getReleasedMajorGroupedByMinor();

        if (version.getRevision() == 0) {
            List<Version> unreleasedStagedOrMinor = getUnreleased().stream().filter(v -> v.getRevision() == 0).collect(Collectors.toList());
            if (unreleasedStagedOrMinor.size() > 2) {

     */
    @VisibleForTesting
    static Stream<QualifiedVersion> findPreviousVersion(GitWrapper gitWrapper, QualifiedVersion version) {
        final int majorSeries = version.getMinor() == 0 && version.getRevision() == 0 ? version.getMajor() - 1 : version.getMajor();
        final String tagPattern = "v" + majorSeries + ".*";

        return gitWrapper.listVersions(tagPattern)
            .filter(v -> v.isBefore(version));
    }

            params.setMinimumRuntimeVersion(minimumRuntimeVersion);
            params.setGradleJavaVersion(Jvm.current().getJavaVersion());
            params.setGitRevision(gitInfo.getRevision());
            params.setGitOrigin(gitInfo.getOrigin());
            params.setBuildDate(ZonedDateTime.now(ZoneOffset.UTC));
            params.setTestSeed(getTestSeed());

        link 'Pull Request', System.getenv('ghprbPullLink')
      } else {
        value 'Git Commit ID', BuildParams.gitRevision
        link 'Source', "https://github.com/elastic/elasticsearch/tree/${BuildParams.gitRevision}"
      }
    } else {
      tag 'LOCAL'
    }
  }
}

subprojects {
  project.getPlugins().withType(TestRerunPlugin) {

        }

        public void setInFipsJvm(boolean inFipsJvm) {
            BuildParams.inFipsJvm = inFipsJvm;
        }

        public void setGitRevision(String gitRevision) {
            BuildParams.gitRevision = requireNonNull(gitRevision);
        }

        public void setGitOrigin(String gitOrigin) {
            BuildParams.gitOrigin = requireNonNull(gitOrigin);
        }