public async Task <IEnumerable <RepositorySettings> > GetRepositories(SourceControlServerSettings settings)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
switch (settings.Scope)
{
case ServerScope.Global:
_logger.Error($"{settings.Scope} not yet implemented");
throw new NotImplementedException();
case ServerScope.Organisation:
return(await FromOrganisation(settings.OrganisationName, settings));
case ServerScope.Repository:
return(await Task.FromResult(new List <RepositorySettings> {
settings.Repository
}.AsEnumerable()));
default:
_logger.Error($"Unknown Server Scope {settings.Scope}");
return(await Task.FromResult(Enumerable.Empty <RepositorySettings>()));
}
}
private async Task <int> DoTargetUpdates(
IGitDriver git, RepositoryData repository,
IReadOnlyCollection <PackageUpdateSet> targetUpdates,
NuGetSources sources,
SourceControlServerSettings settings)
{
if (targetUpdates.Count == 0)
{
_logger.Minimal("No updates can be applied. Exiting.");
return(0);
}
await _solutionsRestore.CheckRestore(targetUpdates, git.WorkingFolder, sources);
var updatesDone = await UpdateAllTargets(git, repository, targetUpdates, sources, settings);
if (updatesDone < targetUpdates.Count)
{
_logger.Minimal($"Attempted {targetUpdates.Count} updates and did {updatesDone}");
}
else
{
_logger.Normal($"Done {updatesDone} updates");
}
return(updatesDone);
}
public async Task <IEnumerable <RepositorySettings> > GetRepositories(SourceControlServerSettings settings)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
switch (settings.Scope)
{
case ServerScope.Global:
return(await ForAllOrgs(settings));
case ServerScope.Organisation:
return(await FromOrganisation(settings.OrganisationName, settings));
case ServerScope.Repository:
settings.Repository.RepositoryUri = PasswordReplacedRepositoryUri(settings.Repository.RepositoryUri);
return(new List <RepositorySettings> {
settings.Repository
}.AsEnumerable());
default:
_logger.Error($"Unknown Server Scope {settings.Scope}");
return(Enumerable.Empty <RepositorySettings>());
}
}
private async Task <IReadOnlyCollection <RepositorySettings> > ForAllOrgs(SourceControlServerSettings settings)
{
var allOrgs = await _collaborationPlatform.GetOrganizations();
var allRepos = new List <RepositorySettings>();
foreach (var org in allOrgs)
{
var repos = await FromOrganisation(org.Name, settings);
allRepos.AddRange(repos);
}
return(allRepos);
}
private async Task <IReadOnlyCollection <RepositorySettings> > ForAllOrgs(
IGitHub gitHub, SourceControlServerSettings settings)
{
var allOrgs = await gitHub.GetOrganizations();
var allRepos = new List <RepositorySettings>();
foreach (var org in allOrgs)
{
var repos = await FromOrganisation(gitHub, org.Name ?? org.Login, settings);
allRepos.AddRange(repos);
}
return(allRepos);
}
public async Task <IEnumerable <RepositorySettings> > GetRepositories(SourceControlServerSettings settings)
{
switch (settings.Scope)
{
case ServerScope.Global:
return(await ForAllOrgs(settings));
case ServerScope.Organisation:
return(await FromOrganisation(settings.OrganisationName, settings));
case ServerScope.Repository:
return(new[] { settings.Repository });
default:
_logger.Error($"Unknown Server Scope {settings.Scope}");
return(Enumerable.Empty <RepositorySettings>());
}
}
public async Task SuccessInRepoMode()
{
var settings = new SourceControlServerSettings
{
Repository = new RepositorySettings(),
Scope = ServerScope.Repository
};
var githubRepositoryDiscovery = MakeGithubRepositoryDiscovery();
var reposResponse = await githubRepositoryDiscovery.GetRepositories(settings);
var repos = reposResponse.ToList();
Assert.That(repos, Is.Not.Null);
Assert.That(repos.Count, Is.EqualTo(1));
Assert.That(repos[0], Is.EqualTo(settings.Repository));
}
public Task <IEnumerable <RepositorySettings> > GetRepositories(SourceControlServerSettings settings)
{
switch (settings.Scope)
{
case ServerScope.Global:
case ServerScope.Organisation:
_logger.Error($"{settings.Scope} not yet implemented");
throw new NotImplementedException();
case ServerScope.Repository:
IEnumerable <RepositorySettings> repositorySettings = new[] { settings.Repository };
return(Task.FromResult(repositorySettings));
default:
_logger.Error($"Unknown Server Scope {settings.Scope}");
throw new NotImplementedException();
}
}
private async Task <IReadOnlyCollection <RepositorySettings> > FromGroup(
string groupName, SourceControlServerSettings settings)
{
var allOrgRepos = await _collaborationPlatform.GetRepositoriesForOrganisation(groupName);
var usableRepos = allOrgRepos
.Where(r => MatchesIncludeExclude(r, settings))
.Where(RepoIsModifiable)
.ToList();
if (allOrgRepos.Count > usableRepos.Count)
{
_logger.Detailed($"Can pull from {usableRepos.Count} repos out of {allOrgRepos.Count}");
}
return(usableRepos
.Select(r => new RepositorySettings(r))
.ToList());
}
public async Task SuccessInRepoModeReplacesToken()
{
var settings = new SourceControlServerSettings
{
Repository = new RepositorySettings {
RepositoryUri = new Uri("https://*****:*****@repo/")
},
Scope = ServerScope.Repository
};
var githubRepositoryDiscovery = MakeGithubRepositoryDiscovery();
var reposResponse = await githubRepositoryDiscovery.GetRepositories(settings);
var repos = reposResponse.ToList();
Assert.That(repos, Is.Not.Null);
Assert.That(repos.Count, Is.EqualTo(1));
Assert.That(repos[0], Is.EqualTo(settings.Repository));
Assert.That(repos[0].RepositoryUri.ToString(), Is.EqualTo("https://*****:*****@repo/"));
}
public Task <IEnumerable <RepositorySettings> > GetRepositories(SourceControlServerSettings settings)
{
switch (settings.Scope)
{
case ServerScope.Global:
case ServerScope.Organisation:
_logger.Error($"{settings.Scope} not yet implemented");
throw new NotImplementedException();
case ServerScope.Repository:
//Workaround for https://github.com/libgit2/libgit2sharp/issues/1596
settings.Repository.RepositoryUri = new Uri(settings.Repository.RepositoryUri.ToString().Replace("--PasswordToReplace--", _token));
return(Task.FromResult(new List <RepositorySettings> {
settings.Repository
}.AsEnumerable()));
default:
_logger.Error($"Unknown Server Scope {settings.Scope}");
return(Task.FromResult(Enumerable.Empty <RepositorySettings>()));
}
}
private async Task <int> UpdateAllTargets(IGitDriver git,
RepositoryData repository,
IEnumerable <PackageUpdateSet> targetUpdates,
NuGetSources sources,
SourceControlServerSettings settings)
{
var updatesDone = 0;
foreach (var updateSet in targetUpdates)
{
var success = await _packageUpdater.MakeUpdatePullRequest(
git, repository, updateSet,
sources, settings);
if (success)
{
updatesDone++;
}
}
return(updatesDone);
}
public async Task <bool> MakeUpdatePullRequest(
IGitDriver git,
RepositoryData repository,
PackageUpdateSet updateSet,
NuGetSources sources,
SourceControlServerSettings serverSettings)
{
try
{
_logger.Minimal(UpdatesLogger.OldVersionsToBeUpdated(updateSet));
git.Checkout(repository.DefaultBranch);
// branch
var branchName = BranchNamer.MakeName(updateSet);
_logger.Detailed($"Using branch name: '{branchName}'");
git.CheckoutNewBranch(branchName);
await _updateRunner.Update(updateSet, sources);
var commitMessage = CommitWording.MakeCommitMessage(updateSet);
git.Commit(commitMessage);
git.Push("nukeeper_push", branchName);
var prTitle = CommitWording.MakePullRequestTitle(updateSet);
await MakeGitHubPullRequest(updateSet, repository, prTitle,
branchName, serverSettings.Labels);
git.Checkout(repository.DefaultBranch);
return(true);
}
catch (Exception ex)
{
_logger.Error("Update failed", ex);
return(false);
}
}
public async Task RepoModeIgnoresIncludesAndExcludes()
{
var settings = new SourceControlServerSettings
{
Repository = new RepositorySettings(RepositoryBuilder.MakeRepository(name: "foo")),
Scope = ServerScope.Repository,
IncludeRepos = new Regex("^foo"),
ExcludeRepos = new Regex("^foo")
};
var githubRepositoryDiscovery = MakeGithubRepositoryDiscovery();
var reposResponse = await githubRepositoryDiscovery.GetRepositories(settings);
var repos = reposResponse.ToList();
Assert.That(repos, Is.Not.Null);
Assert.That(repos.Count, Is.EqualTo(1));
var firstRepo = repos.First();
Assert.That(firstRepo.RepositoryName, Is.EqualTo("foo"));
}
public async Task <IEnumerable <RepositorySettings> > GetRepositories(SourceControlServerSettings settings)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
switch (settings.Scope)
{
case ServerScope.Global:
return(await ForAllOrgs(settings));
case ServerScope.Organisation:
return(await FromOrganisation(settings.OrganisationName, settings));
case ServerScope.Repository:
return(new[] { settings.Repository });
default:
_logger.Error($"Unknown Server Scope {settings.Scope}");
throw new NotImplementedException();
}
}
private static bool MatchesIncludeExclude(Abstractions.CollaborationModels.Repository repo, SourceControlServerSettings settings)
{
return(RegexMatch.IncludeExclude(repo.Name, settings.IncludeRepos, settings.ExcludeRepos));
}
private static bool MatchesIncludeExclude(Repository repo, SourceControlServerSettings settings)
{
return(RegexMatch.IncludeExclude(repo.Name, settings.IncludeRepos, settings.ExcludeRepos));
}
private async Task <IReadOnlyCollection <RepositorySettings> > FromOrganisation(string organisationName, SourceControlServerSettings settings)
{
var allOrgRepos = await _collaborationPlatform.GetRepositoriesForOrganisation(organisationName);
var usableRepos = allOrgRepos
.Where(r => MatchesIncludeExclude(r, settings))
.ToList();
if (allOrgRepos.Count > usableRepos.Count)
{
_logger.Detailed($"Can pull from {usableRepos.Count} repos out of {allOrgRepos.Count}");
}
return(usableRepos
.Select(r => new RepositorySettings
{
ApiUri = _setting.BaseApiUrl,
RepositoryUri = r.CloneUrl,
RepositoryName = r.Name,
RepositoryOwner = organisationName
}).ToList());
}
private static bool MatchesIncludeExclude(Repository repo, SourceControlServerSettings settings)
{
return
(MatchesInclude(settings.IncludeRepos, repo) &&
!MatchesExclude(settings.ExcludeRepos, repo));
}
