private static async Task CloneRemoteRepoAndDependencies(RemoteFactory remoteFactory, string reposFolder, string repoUri, string commit, bool includeToolset, ILogger logger)
{
IRemote rootRepoRemote = await remoteFactory.GetRemoteAsync(repoUri, logger);
IEnumerable <DependencyDetail> rootDependencies = await rootRepoRemote.GetDependenciesAsync(repoUri, commit);
rootDependencies = FilterToolsetDependencies(rootDependencies, includeToolset);
if (!rootDependencies.Any())
{
string repoPath = GetRepoDirectory(reposFolder, repoUri, commit);
if (Directory.Exists(repoPath))
{
logger.LogDebug($"Repo path {repoPath} already exists, assuming we cloned already and skipping");
}
else
{
logger.LogInformation($"Remote repo {repoUri}@{commit} has no dependencies. Cloning shallowly into {repoPath}");
IRemote repoRemote = await remoteFactory.GetRemoteAsync(repoUri, logger);
repoRemote.Clone(repoUri, commit, repoPath);
}
return;
}
DependencyGraphBuildOptions graphBuildOptions = new DependencyGraphBuildOptions()
{
IncludeToolset = includeToolset,
LookupBuilds = true,
NodeDiff = NodeDiff.None
};
logger.LogDebug($"Building depdendency graph for {repoUri}@{commit} with {rootDependencies.Count()} dependencies");
DependencyGraph graph = await DependencyGraph.BuildRemoteDependencyGraphAsync(
remoteFactory,
rootDependencies,
repoUri,
commit,
graphBuildOptions,
logger);
foreach (DependencyGraphNode repo in graph.Nodes)
{
string repoPath = GetRepoDirectory(reposFolder, repo.Repository, repo.Commit);
if (Directory.Exists(repoPath))
{
logger.LogDebug($"Repo path {repoPath} already exists, assuming we cloned already and skipping");
}
else
{
logger.LogInformation($"Cloning {repo.Repository}@{repo.Commit} into {repoPath}");
IRemote repoRemote = await remoteFactory.GetRemoteAsync(repo.Repository, logger);
repoRemote.Clone(repo.Repository, repo.Commit, repoPath);
}
}
}
private static async Task HandleMasterCopyAndCreateGitDir(RemoteFactory remoteFactory, string repoUrl, string masterGitRepoPath, string masterRepoGitDirPath, string gitDirRedirect, ILogger log)
{
log.LogDebug($"Master .gitdir {masterRepoGitDirPath} does not exist");
// The master folder also doesn't exist. Just clone and set everything up for the first time.
if (!Directory.Exists(masterGitRepoPath))
{
log.LogInformation($"Cloning master copy of {repoUrl} into {masterGitRepoPath} with .gitdir path {masterRepoGitDirPath}");
IRemote repoRemote = await remoteFactory.GetRemoteAsync(repoUrl, log);
repoRemote.Clone(repoUrl, null, masterGitRepoPath, masterRepoGitDirPath);
}
// The master folder already exists. We are probably resuming with a different --git-dir-parent setting, or the .gitdir parent was cleaned.
else
{
string masterRepoPossibleGitDirPath = Path.Combine(masterGitRepoPath, ".git");
// The master folder has a full .gitdir. Relocate it to the .gitdir parent directory and update to redirect to that.
if (Directory.Exists(masterRepoPossibleGitDirPath))
{
log.LogDebug($".gitdir {masterRepoPossibleGitDirPath} exists in {masterGitRepoPath}");
// Check if the .gitdir is already where we expect it to be first.
if (Path.GetFullPath(masterRepoPossibleGitDirPath) != Path.GetFullPath(masterRepoGitDirPath))
{
log.LogDebug($"Moving .gitdir {masterRepoPossibleGitDirPath} to expected location {masterRepoGitDirPath}");
Directory.Move(masterRepoPossibleGitDirPath, masterRepoGitDirPath);
File.WriteAllText(masterRepoPossibleGitDirPath, gitDirRedirect);
}
}
// The master folder has a .gitdir redirect. Relocate its .gitdir to where we expect and update the redirect.
else if (File.Exists(masterRepoPossibleGitDirPath))
{
log.LogDebug($"Master repo {masterGitRepoPath} has a .gitdir redirect");
string relocatedGitDirPath = File.ReadAllText(masterRepoPossibleGitDirPath).Substring(GitDirRedirectPrefix.Length);
if (Path.GetFullPath(relocatedGitDirPath) != Path.GetFullPath(masterRepoGitDirPath))
{
log.LogDebug($"Existing .gitdir redirect of {relocatedGitDirPath} does not match expected {masterRepoGitDirPath}, moving .gitdir and updating redirect");
Directory.Move(relocatedGitDirPath, masterRepoGitDirPath);
File.WriteAllText(masterRepoPossibleGitDirPath, gitDirRedirect);
}
}
// This repo is orphaned. Since it's supposed to be our master copy, adopt it.
else
{
log.LogDebug($"Master repo {masterGitRepoPath} is orphaned, adding .gitdir redirect");
File.WriteAllText(masterRepoPossibleGitDirPath, gitDirRedirect);
}
}
}
private static async Task HandleMasterCopyWithDefaultGitDir(RemoteFactory remoteFactory, string repoUrl, string masterGitRepoPath, string masterRepoGitDirPath, ILogger log)
{
log.LogDebug($"Starting master copy for {repoUrl} in {masterGitRepoPath} with default .gitdir");
// The master folder doesn't exist. Just clone and set everything up for the first time.
if (!Directory.Exists(masterGitRepoPath))
{
log.LogInformation($"Cloning master copy of {repoUrl} into {masterGitRepoPath}");
IRemote repoRemote = await remoteFactory.GetRemoteAsync(repoUrl, log);
repoRemote.Clone(repoUrl, null, masterGitRepoPath, masterRepoGitDirPath);
}
// The master folder already exists. We are probably resuming with a different --git-dir-parent setting, or the .gitdir parent was cleaned.
else
{
log.LogDebug($"Checking for existing .gitdir in {masterGitRepoPath}");
string masterRepoPossibleGitDirPath = Path.Combine(masterGitRepoPath, ".git");
// This repo is not in good shape for us. It needs to be deleted and recreated.
if (!Directory.Exists(masterRepoPossibleGitDirPath))
{
throw new InvalidOperationException($"Repo {masterGitRepoPath} does not have a .git folder, but no git-dir-parent was specified. Please fix the repo or specify a git-dir-parent.");
}
}
}
