public void TestStashingAndUnstashing(RepoConfig repoCfg)
{
using var helper = Clone(repoCfg);
var file = helper.GetPath(@"src\files\changingFile.txt");
XAssert.FileExists(file);
TestOutput.WriteLine("Modifying file: " + file);
File.AppendAllText(file, "hi");
var modifiedContent = File.ReadAllText(file);
var result = helper.TrackPath(file);
XAssert.AreEqual(PathExistence.ExistsAsFile, result.Existence);
// stash changes, assert that 'Change' or 'Delete' USN entry was recorded
helper.Git("stash");
helper.SnapCheckPoint();
XAssert.AreNotEqual(modifiedContent, File.ReadAllText(file));
helper.AssertDeleteOrChangeFile(file);
// unfortunately, GVFS projection seems to change even though it probably shoudn't
// helper.AssertNoChange(helper.GetGvfsProjectionFilePath());
// must re-track the same path because now it could be a different physical file
helper.TrackPath(file);
// unstash changes, assert that 'Change' or 'Delete' USN entry was recorded and that GVFS projection hasn't changed
helper.Git("stash pop");
helper.SnapCheckPoint();
XAssert.AreEqual(modifiedContent, File.ReadAllText(file));
helper.AssertDeleteOrChangeFile(file);
// unfortunately, GVFS projection seems to change even though it probably shouldn't
// helper.AssertNoChange(helper.GetGvfsProjectionFilePath());
}
public void ChangeFile(RepoConfig repoCfg)
{
using var helper = Clone(repoCfg);
// track an existing file
var file = helper.GetPath(@"src\files\changingFile.txt");
XAssert.FileExists(file);
var oldContent = File.ReadAllText(file);
helper.TrackPath(file);
// switch to a new branch where that file is modified
using var reseter = helper.GitCheckout("changingFile1");
// snap USN entries before doing any checks (because they can modify the journal too)
helper.SnapCheckPoint();
// assert that the file exists and has different content in the new branch
XAssert.FileExists(file);
XAssert.AreNotEqual(oldContent, File.ReadAllText(file));
// assert that the journal recorded a change
// (it doesn't matter to us whether that change is 'Delete' or 'Change')
helper.AssertDeleteOrChangeFile(file);
}
string CalcTargetBranch()
{
var repository = Branch.Repository;
RepoConfig repoConfig = repository.RepoConfig;
return(repoConfig?.TargetBranch);
}
public void TestAbsentFileAndDir(RepoConfig repoCfg)
{
using var helper = Clone(repoCfg);
// track a file that doesn't exist
var dir = helper.GetPath(@"src\files");
var absentDir = helper.GetPath(@"src\files\newSubfolder");
var absentFile = helper.GetPath(@"src\files\newSubfolder\newSubfolderFile.txt");
var dirResult = helper.TrackDir(dir);
var absentDirResult = helper.TrackDir(absentDir);
var absentFileResult = helper.TrackPath(absentFile);
XAssert.AreEqual(PathExistence.ExistsAsDirectory, dirResult.Existence);
XAssert.AreEqual(PathExistence.Nonexistent, absentDirResult.Existence);
XAssert.AreEqual(PathExistence.Nonexistent, absentFileResult.Existence);
// switch to a new branch where that file does exist
using var reseter = helper.GitCheckout("newFileInNewSubfolder");
// immediately snap changes
helper.SnapCheckPoint();
XAssert.FileExists(absentFile);
XAssert.DirectoryExists(absentDir);
// assert directory membership changes
helper.AssertAnyChange(dir, PathChanges.MembershipChanged);
helper.AssertAnyChange(absentDir, PathChanges.NewlyPresentAsDirectory);
helper.AssertAnyChange(absentFile, PathChanges.NewlyPresentAsFile);
}
public void TestFileBecomesFolder(RepoConfig repoCfg)
{
using var helper = Clone(repoCfg);
// track a folder and a file
var dir = helper.GetPath(@"src\files\subfolder");
var file = helper.GetPath(@"src\files\subfolder\newFile.txt");
var dirResult = helper.TrackDir(dir);
var fileResult = helper.TrackPath(file);
XAssert.AreEqual(PathExistence.ExistsAsDirectory, dirResult.Existence);
XAssert.AreEqual(PathExistence.ExistsAsFile, fileResult.Existence);
// switch to a new branch where that file is now a folder
using var reseter = helper.GitCheckout("fileBecomesFolder");
// immediately snap changes
helper.SnapCheckPoint();
XAssert.DirectoryExists(file);
// assert directory membership changes
helper.AssertAnyChange(dir, PathChanges.MembershipChanged);
helper.AssertAnyChange(file, PathChanges.Removed);
}
public void TestFolderBecomesFile(RepoConfig repoCfg)
{
using var helper = Clone(repoCfg);
// track two directories
var dir = helper.GetPath(@"src\files");
var subdir = helper.GetPath(@"src\files\subfolder");
var dirResult = helper.TrackDir(dir);
var subdirResult = helper.TrackDir(subdir);
XAssert.AreEqual(PathExistence.ExistsAsDirectory, dirResult.Existence);
XAssert.AreEqual(PathExistence.ExistsAsDirectory, subdirResult.Existence);
// switch to a new branch where the subdirectory is now a file
using var reseter = helper.GitCheckout("folderBecomesFile");
// immediately snap changes
helper.SnapCheckPoint();
XAssert.FileExists(subdir);
// assert directory membership changes
helper.AssertAnyChange(dir, PathChanges.MembershipChanged);
helper.AssertAnyChange(subdir, PathChanges.Removed);
}
public static RepoVersion Build(Patchalyzer patchalyzer, SemVersion version, string path, string name, string changelog = "", long releaseDate = -1)
{
RepoConfig config = patchalyzer.GetRepoConfig();
string repoPath = patchalyzer.GetRepoPath();
// If releaseDate is missing then set it to the current time.
if (releaseDate == -1)
{
releaseDate = DateTimeOffset.Now.ToUnixTimeSeconds();
}
RepoVersion repoVersion = new RepoVersion
{
Name = name,
ReleaseDate = releaseDate,
Changelog = changelog
};
bool isUpdate = false;
// Check if a previous version exists
if (config.LatestVersion != null && config.Versions.ContainsKey(config.LatestVersion))
{
SemVersion latestVersion;
if (SemVersion.TryParse(config.LatestVersion, out latestVersion))
{
isUpdate = (latestVersion < version);
}
}
repoVersion.Files = isUpdate ? AddFiles(repoPath, version, path, config.LatestVersion, config.Versions[config.LatestVersion]) : AddFiles(repoPath, version, path);
repoVersion.DeletedFiles = isUpdate ? GetDeletedFiles(repoVersion.Files, config.Versions[config.LatestVersion].Files) : new List <string>();
return(repoVersion);
}
private async Task <WebhookResponse> HandlePushOnPr(PushEvent payload, RepoConfig config)
{
var owner = payload.Repository.Owner.Login;
var repo = payload.Repository.Name;
var sha = payload.After;
var branch = payload.Ref;
var extraLogData = new { owner, repo, branch, sha };
var strippedBranchName = branch.Substring("refs/heads/".Length);
var mergeRequest = await mergeRequestRepository.GetByBranchName(owner, repo, strippedBranchName);
if (mergeRequest == null)
{
logger.WithExtraData(extraLogData).Information("Push on branch, does not exist in Miro DB, ignoring");
return(new WebhookResponse(false, "Push on branch, does not exist in Miro DB, ignoring"));
}
logger.WithMergeRequestData(mergeRequest).Information($"Push on branch found in DB, Clearing status checks and updating sha");
var updatedMergeRequest = await mergeRequestRepository.UpdateShaAndClearStatusChecks(mergeRequest.Owner, mergeRequest.Repo, mergeRequest.PrId, sha);
if (config.IsWhitelistStrict() && updatedMergeRequest.ReceivedMergeCommand)
{
logger.WithMergeRequestData(updatedMergeRequest).Information("Repository has a whitelist-strict merge policy, resolving miro check on PR");
await miroMergeCheck.ResolveMiroMergeCheck(updatedMergeRequest);
}
return(new WebhookResponse(true, $"Push on branch is a known PR, updated sha to {sha} and cleared status checks"));
}
public void ChangeFileWithMaterialization(RepoConfig repoCfg)
{
using var helper = Clone(repoCfg);
// track an existing file
var file = helper.GetPath(@"src\files\changingFile.txt");
var result = helper.TrackPath(file);
XAssert.AreEqual(PathExistence.ExistsAsFile, result.Existence);
var oldContent = File.ReadAllText(file);
// switch to a new branch where that file is modified
using var reseter = helper.GitCheckout("changingFile1");
// materialize the file (by probing it) before snapping USN entries
helper.AssertFileOnDisk(file);
helper.SnapCheckPoint();
// assert that the file exists and has different content in the new branch
XAssert.FileExists(file);
XAssert.AreNotEqual(oldContent, File.ReadAllText(file));
// assert that the journal recorded a change
// (it doesn't matter to us whether that change is 'Delete' or 'Change')
helper.AssertDeleteOrChangeFile(file);
}
static void Main()
{
UnitOfWork.Configure(RepoConfig.GetConfiguration());
ObjectFactory.Configure(c => c.AddRegistry <DefaultRegistry>());
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());
}
public void BuildTab(TabControl reposCatalogs, SelectRepo onSelectRepoEvent, RepoConfig repo)
{
var newTab = serviceProvider.GetService <TabReposControl>();
newTab.RepoConfiguration = repo;
newTab.BackColor = Color.White;
reposCatalogs.Controls.Add(newTab);
CheckForGitRepo(newTab, onSelectRepoEvent);
}
public void BuildTab(TabControl reposCatalogs, SelectRepo onSelectRepoEvent, string repoPath)
{
if (!Directory.Exists(repoPath))
{
MessageBox.Show($"Path {repoPath} is not valid.", "Invalid repo path", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
var config = new RepoConfig {
GitLookerPath = repoPath
};
appConfiguration.Add(config);
BuildTab(reposCatalogs, onSelectRepoEvent, config);
}
/// <summary>
/// Create a new Patchalyzer repo.
/// </summary>
/// <param name="repoPath">Path to create the repository in.</param>
/// <param name="projectName">Name of the project.</param>
/// <returns>The newly created Patchalyzer project.</returns>
public static Patchalyzer InitRepo(string repoPath, string projectName)
{
// If the repo already exists then return that
if (File.Exists(Path.Combine(Path.GetFullPath(repoPath), "patchalyzer.json")))
{
return(new Patchalyzer(repoPath));
}
RepoConfig config = new RepoConfig
{
Name = projectName,
ConfigVersion = 1
};
return(new Patchalyzer(repoPath, config));
}
public GitJournalHelper Clone(RepoConfig cfg)
{
bool useGvfs = cfg.RepoKind == RepoKind.Gvfs;
var helper = cfg.RepoInit == RepoInit.Clone
? GitJournalHelper.Clone(TestOutput, useGvfs)
: GitJournalHelper.InitializeWithExistingRepo(TestOutput, GitRepoLocation(useGvfs));
if (useGvfs)
{
// tracking GVFS_projection file so that we can assert that this file indeed changed
// whenever the actual file changes are not yet reflected in the filesystem
helper.TrackGvfsProjectionFile();
}
return(helper);
}
public void EditFile(RepoConfig repoCfg)
{
using var helper = Clone(repoCfg);
// track an existing file
var filePath = helper.GetPath(@"src\files\changingFile.txt");
var result = helper.TrackPath(filePath);
XAssert.AreEqual(PathExistence.ExistsAsFile, result.Existence);
// modify that file
File.AppendAllText(filePath, "new content");
// snap changes and assert that a 'ChangeFile' USN entry was recorded
helper.SnapCheckPoint();
helper.AssertChangeFile(filePath);
}
public void CreateFile(RepoConfig repoCfg)
{
using var helper = Clone(repoCfg);
// track an absent file
var filePath = helper.GetPath("a.txt");
var result = helper.TrackPath(filePath);
XAssert.AreEqual(PathExistence.Nonexistent, result.Existence);
// create that file
File.WriteAllText(filePath, "hi");
// snap entries and assert that a 'CreateFile' entry is found
helper.SnapCheckPoint();
helper.AssertCreateFile(filePath);
}
private async Task <bool> UpdateNextPrByStrategy(PushEvent payload, RepoConfig repoConfig)
{
var owner = payload.Repository.Owner.Login;
var repo = payload.Repository.Name;
logger.WithExtraData(new { owner, repo, strategy = repoConfig.UpdateBranchStrategy }).Information("Updating next PR by strategy");
List <MergeRequest> prsToUpdate = null;
switch (repoConfig.UpdateBranchStrategy)
{
case "oldest":
var singlePr = await mergeRequestRepository.GetOldestPr(owner, repo);
if (singlePr != null)
{
prsToUpdate = new List <MergeRequest> {
singlePr
}
}
;
break;
case "all":
var allPrs = await mergeRequestRepository.Get(owner, repo);
if (allPrs != null && allPrs.Any())
{
prsToUpdate = allPrs.Where(x => x.ReceivedMergeCommand).ToList();
}
break;
case "none":
default:
break;
}
if (prsToUpdate == null || !prsToUpdate.Any())
{
logger.WithExtraData(new { owner, repo }).Warning($"Could not find next PRs to update based on after PR was merged");
return(false);
}
var tasks = prsToUpdate.Select(pr => UpdateSinglePr(pr, repoConfig));
var completions = await Task.WhenAll(tasks);
return(completions.Any(x => x));
}
public Task <RepoConfig> Update(RepoConfig config)
{
config.UpdatedAt = DateTime.UtcNow;
var options = new FindOneAndUpdateOptions <RepoConfig>
{
IsUpsert = true
};
var update = Builders <RepoConfig> .Update
.Set(r => r.UpdatedAt, DateTime.UtcNow)
.Set(r => r.DeleteAfterMerge, config.DeleteAfterMerge)
.Set(r => r.MergePolicy, config.MergePolicy)
.Set(r => r.UpdateBranchStrategy, config.UpdateBranchStrategy)
.Set(r => r.DefaultBranch, config.DefaultBranch);
return(collection.FindOneAndUpdateAsync <RepoConfig>(r => r.Owner == config.Owner && r.Repo == config.Repo, update, options));
}
public void DeleteFile(RepoConfig repoCfg)
{
using var helper = Clone(repoCfg);
// track an existing file
var filePath = helper.GetPath(@"src\files\changingFile.txt");
var result = helper.TrackPath(filePath);
XAssert.AreEqual(PathExistence.ExistsAsFile, result.Existence);
// delete that file
File.Delete(filePath);
// snap changes and assert that a 'DeleteFile' USN entry was recorded
helper.SnapCheckPoint();
helper.AssertDeleteFile(filePath);
XAssert.FileDoesNotExist(filePath);
}
void GenerateRepoConfig(string branch, string taskName, string watchTaskName, string defaultService, bool allowTesting = false, string[] testConfigs = null)
{
RepoConfig config = new RepoConfig()
{
Name = branch,
FarmTaskName = watchTaskName,
FarmSyncTaskName = taskName,
DefaultServiceName = defaultService,
SupportsTesting = allowTesting,
};
SharpSerializerXmlSettings settings = new SharpSerializerXmlSettings();
settings.IncludeAssemblyVersionInTypeName = false;
settings.IncludePublicKeyTokenInTypeName = false;
SharpSerializer serializer = new SharpSerializer(settings);
serializer.Serialize(config, @"z:\gitconfig.config");
}
public void TestDirMembership(RepoConfig repoCfg)
{
using var helper = Clone(repoCfg);
// track a file that doesn't exist
var dir = helper.GetPath(@"src\files\subfolder");
var result = helper.TrackDir(dir);
XAssert.AreEqual(PathExistence.ExistsAsDirectory, result.Existence);
// switch to a new branch where that file does exist
using var reseter = helper.GitCheckout("newFileInSubfolder");
// immediately snap changes
helper.SnapCheckPoint();
// assert directory membership changes
helper.AssertAnyChange(dir, PathChanges.MembershipChanged);
}
private async Task <bool> UpdateSinglePr(MergeRequest pullRequest, RepoConfig config)
{
var branch = pullRequest.Branch;
var prId = pullRequest.PrId;
logger.WithMergeRequestData(pullRequest).Information($"updating branch on next PullRequest");
try
{
await prUpdater.UpdateBranch(pullRequest.Owner, pullRequest.Repo, branch);
return(true);
}
catch (Exception e)
{
logger.WithMergeRequestData(pullRequest).Warning(e, "Unable to update branch on next PR");
return(false);
}
}
public void NewFileWhenParentFolderIsNotMaterialzedBeforeOperation(RepoConfig repoCfg)
{
using var helper = Clone(repoCfg);
// track a file that doesn't exist
var file = helper.GetPath(@"src\files\subfolder\newfile2.txt");
var result = helper.TrackPath(file);
XAssert.AreEqual(PathExistence.Nonexistent, result.Existence);
// switch to a new branch where that file does exist
using var reseter = helper.GitCheckout("newFileInSubfolder");
// immediately snap changes
helper.SnapCheckPoint();
// assert that 'CreateFile' USN entry was recorded
helper.AssertCreateFile(file);
XAssert.FileExists(file);
}
public void ChangeFileNoMaterialization(RepoConfig repoCfg)
{
using var helper = Clone(repoCfg);
// track an existing file
var file = helper.GetPath(@"src\files\changingFile.txt");
var result = helper.TrackPath(file);
XAssert.AreEqual(PathExistence.ExistsAsFile, result.Existence);
// switch to a new branch where that file is modified
using var reseter = helper.GitCheckout("changingFile1");
// immediately snap changes
helper.SnapCheckPoint();
// assert that the journal recorded a change
// (it doesn't matter to us whether that change is 'Delete' or 'Change')
helper.AssertDeleteOrChangeFile(file);
}
public void NewFileWhenParentFolderIsMaterialzedBeforeOperation(RepoConfig repoCfg)
{
var helper = Clone(repoCfg);
// track a file that doesn't exist
var file = helper.GetPath(@"src\files\subfolder\newfile.txt");
var file2 = helper.GetPath(@"src\files\subfolder\newfile2.txt");
helper.TrackPath(file);
helper.TrackPath(file2);
// materialize files before git checkout
helper.AssertFileOnDisk(file);
helper.AssertFileOnDisk(file2, expectExists: false);
using var reseter = helper.GitCheckout("newFileInSubfolder");
// snap changes
helper.SnapCheckPoint();
helper.AssertCreateFile(file2);
XAssert.FileExists(file2);
}
public void NewFileWhenParentFolderIsMaterialzedAfterOperation(RepoConfig repoCfg)
{
using (var helper = Clone(repoCfg))
{
// track one existing and one absent file
var file = helper.GetPath(@"src\files\subfolder\newfile.txt");
var file2 = helper.GetPath(@"src\files\subfolder\newfile2.txt");
var existingFileResult = helper.TrackPath(file);
var absentFileResult = helper.TrackPath(file2);
XAssert.AreEqual(PathExistence.ExistsAsFile, existingFileResult.Existence);
XAssert.AreEqual(PathExistence.Nonexistent, absentFileResult.Existence);
// switch to a new branch where absent file exists
using var reseter = helper.GitCheckout("newFileInSubfolder");
// materialize files
helper.AssertFileOnDisk(file);
helper.AssertFileOnDisk(file2);
// the USN journal must be up to date at this point because of the previous materialization
helper.SnapCheckPoint();
helper.AssertCreateFile(file2);
}
}
public JsonRepository(RepoConfig config)
{
path = config.path;
}
public Task Create(RepoConfig config)
{
return(collection.InsertOneAsync(config));
}
private void LoadRepo(string repoPath, RepoConfig repoConfig)
{
RepoPath = repoPath;
Config = repoConfig;
}
/// <summary>
/// Load an existing Patchalyzer project from an already loaded RepoConfig instance.
/// </summary>
/// <param name="repoPath">Path to the repository</param>
/// <param name="repoConfig">Instance of the RepoConfig</param>
public Patchalyzer(string repoPath, RepoConfig repoConfig)
{
LoadRepo(repoPath, repoConfig);
}
