public void RegisterUser()
{
GitLabWrapper gitLabWrapper = new GitLabWrapper(TestCredentials.GitServer, TestCredentials.GitLabToken);
DXVcsWrapper vcsWrapper = new DXVcsWrapper(TestCredentials.VcsServer);
RegisteredUsers users = new RegisteredUsers(gitLabWrapper, vcsWrapper);
var user = users.GetUser("Barakhov");
}
public void SearchGitLabUser()
{
GitLabWrapper wrapper = new GitLabWrapper(TestCredentials.GitServer, TestCredentials.GitLabToken);
var dict = wrapper.GetUsers().ToDictionary(x => x.Username);
var user = dict["Litvinov"];
Assert.IsNotNull(user.Email);
}
public BranchViewModel(GitLabWrapper gitLabWrapper, RepositoryViewModel repository, string branch)
{
this.gitLabWrapper = gitLabWrapper;
Repository = repository;
Name = branch;
ForceBuildCommand = DelegateCommandFactory.Create(ForceBuild, CanForceBuild);
}
public RepositoryViewModel(string name, TrackRepository trackRepository, RepositoriesViewModel repositories)
{
TrackRepository = trackRepository;
GitLabWrapper = new GitLabWrapper(TrackRepository.Server, TrackRepository.Token);
HasAdminPrivileges = GitLabWrapper.IsAdmin();
GitReader = new GitReaderWrapper(trackRepository.LocalPath);
UpdateConfigs(trackRepository, repositories);
Repositories = repositories;
Origin = GitLabWrapper.FindProject(GitReader.GetOriginRepoPath());
Upstream = GitLabWrapper.FindProject(GitReader.GetUpstreamRepoPath());
Name = name;
Update();
}
public void SearchRegisteredUser()
{
GitLabWrapper gitLabWrapper = new GitLabWrapper(TestCredentials.GitServer, TestCredentials.GitLabToken);
DXVcsWrapper vcsWrapper = new DXVcsWrapper(TestCredentials.VcsServer);
RegisteredUsers users = new RegisteredUsers(gitLabWrapper, vcsWrapper);
var user = users.GetUser("litvinov");
Assert.IsNotNull(user);
Assert.IsTrue(user.IsRegistered);
var user2 = users.GetUser("Litvinov");
Assert.IsNotNull(user2);
Assert.IsTrue(user2.IsRegistered);
}
static int DoSyncWork(SyncOptions clo) {
string localGitDir = clo.LocalFolder != null && Path.IsPathRooted(clo.LocalFolder) ? clo.LocalFolder : Path.Combine(Environment.CurrentDirectory, clo.LocalFolder ?? repoPath);
EnsureGitDir(localGitDir);
string gitRepoPath = clo.Repo;
string username = clo.Login;
string password = clo.Password;
string gitlabauthtoken = clo.AuthToken;
string branchName = clo.Branch;
string trackerPath = clo.Tracker;
string gitServer = clo.Server;
DXVcsWrapper vcsWrapper = new DXVcsWrapper(vcsServer, username, password);
TrackBranch branch = FindBranch(branchName, trackerPath, vcsWrapper);
if (branch == null)
return 1;
string historyPath = GetVcsSyncHistory(vcsWrapper, branch.HistoryPath);
if (historyPath == null)
return 1;
SyncHistory history = SyncHistory.Deserialize(historyPath);
if (history == null)
return 1;
SyncHistoryWrapper syncHistory = new SyncHistoryWrapper(history, vcsWrapper, branch.HistoryPath, historyPath);
var head = syncHistory.GetHistoryHead();
if (head == null)
return 1;
GitLabWrapper gitLabWrapper = new GitLabWrapper(gitServer, gitlabauthtoken);
RegisteredUsers registeredUsers = new RegisteredUsers(gitLabWrapper, vcsWrapper);
User defaultUser = registeredUsers.GetUser(username);
if (!defaultUser.IsRegistered) {
Log.Error($"default user {username} is not registered in the active directory.");
return 1;
}
var checkMergeChangesResult = CheckChangesForMerging(gitLabWrapper, gitRepoPath, branchName, head, vcsWrapper, branch, syncHistory, defaultUser);
if (checkMergeChangesResult == CheckMergeChangesResult.NoChanges)
return 0;
if (checkMergeChangesResult == CheckMergeChangesResult.Error)
return 1;
GitWrapper gitWrapper = CreateGitWrapper(gitRepoPath, localGitDir, branch.Name, username, password);
if (gitWrapper == null)
return 1;
ProcessHistoryResult processHistoryResult = ProcessHistory(vcsWrapper, gitWrapper, registeredUsers, defaultUser, gitRepoPath, localGitDir, branch, clo.CommitsCount, syncHistory, true);
if (processHistoryResult == ProcessHistoryResult.NotEnough)
return 0;
if (processHistoryResult == ProcessHistoryResult.Failed)
return 1;
int result = ProcessMergeRequests(vcsWrapper, gitWrapper, gitLabWrapper, registeredUsers, defaultUser, gitRepoPath, localGitDir, clo.Branch, clo.Tracker, syncHistory, username);
if (result != 0)
return result;
return 0;
}
static int DoPatchWork(PatchOptions clo) {
string localGitDir = clo.LocalFolder != null && Path.IsPathRooted(clo.LocalFolder) ? clo.LocalFolder : Path.Combine(Environment.CurrentDirectory, clo.LocalFolder ?? repoPath);
string targetRepoPath = GetSimpleGitHttpPath(clo.Repo);
if (string.IsNullOrEmpty(targetRepoPath)) {
Log.Error($"Can`t parse repo path {clo.Repo}");
return 1;
}
string sourceRepoPath = GetSimpleGitHttpPath(clo.SourceRepo);
if (string.IsNullOrEmpty(sourceRepoPath)) {
Log.Error($"Can`t parse source repo path {clo.SourceRepo}");
return 1;
}
string username = clo.Login;
string password = clo.Password;
string gitlabauthtoken = clo.AuthToken;
string targetBranchName = clo.Branch;
string trackerPath = clo.Tracker;
string gitServer = clo.Server;
string sourceBranchName = clo.SourceBranch;
string patchdir = clo.PatchDir ?? localGitDir;
DXVcsWrapper vcsWrapper = new DXVcsWrapper(vcsServer, username, password);
TrackBranch trackBranch = FindBranch(targetBranchName, trackerPath, vcsWrapper);
if (trackBranch == null) {
return 1;
}
string historyPath = GetVcsSyncHistory(vcsWrapper, trackBranch.HistoryPath);
if (historyPath == null)
return 1;
SyncHistory history = SyncHistory.Deserialize(historyPath);
if (history == null)
return 1;
SyncHistoryWrapper syncHistory = new SyncHistoryWrapper(history, vcsWrapper, trackBranch.HistoryPath, historyPath);
var head = syncHistory.GetHistoryHead();
if (head == null)
return 1;
GitLabWrapper gitLabWrapper = new GitLabWrapper(gitServer, gitlabauthtoken);
Project targetProject = gitLabWrapper.FindProject(targetRepoPath);
if (targetProject == null) {
Log.Error($"Can`t find target project {targetRepoPath}.");
return 1;
}
Log.Message($"Target project url: {targetProject.HttpUrl}");
Branch targetBranch = gitLabWrapper.GetBranch(targetProject, targetBranchName);
if (targetBranch == null) {
Log.Error($"Can`t find targetBranch branch {targetBranchName}");
return 1;
}
Log.Message($"Target branch name: {targetBranch.Name}");
var sourceProject = gitLabWrapper.FindProjectFromAll(sourceRepoPath);
if (sourceProject == null) {
Log.Error($"Can`t find source project {sourceRepoPath}");
return 1;
}
Log.Message($"Source project url: {sourceProject.HttpUrl}");
var sourceBranch = gitLabWrapper.GetBranch(sourceProject, sourceBranchName);
if (sourceBranch == null) {
Log.Error($"Source branch {sourceBranchName} was not found.");
return 1;
}
Log.Message($"Target branch name: {sourceBranch.Name}");
MergeRequest mergeRequest = gitLabWrapper.GetMergeRequests(targetProject,
x => x.SourceBranch == sourceBranchName && x.TargetBranch == targetBranchName && x.SourceProjectId == sourceProject.Id).FirstOrDefault();
if (mergeRequest == null) {
Log.Error($"Can`t find merge request.");
return 1;
}
Log.Message($"Merge request id: {mergeRequest.Id}.");
Log.Message($"Merge request title: {mergeRequest.Title}.");
var comments = gitLabWrapper.GetComments(mergeRequest);
var mergeRequestSyncOptions = comments?.Where(x => IsXml(x.Note)).Where(x => {
var mr = MergeRequestOptions.ConvertFromString(x.Note);
return mr?.ActionType == MergeRequestActionType.sync;
}).Select(x => (MergeRequestSyncAction)MergeRequestOptions.ConvertFromString(x.Note).Action).LastOrDefault();
if (mergeRequest.Assignee?.Name != username || (!mergeRequestSyncOptions?.PerformTesting ?? false)) {
Log.Error($"Merge request is not assigned to service user {username} or doesn`t require testing.");
return 1;
}
GitWrapper gitWrapper = CreateGitWrapper(sourceRepoPath, localGitDir, sourceBranchName, username, password);
if (gitWrapper == null) {
Log.Error("Can`t create git wrapper.");
return 1;
}
var changes = gitLabWrapper
.GetMergeRequestChanges(mergeRequest)
.Where(x => trackBranch.TrackItems.FirstOrDefault(track => CheckItemForChangeSet(x, track)) != null)
.Select(x => new PatchItem() {
SyncAction = CalcSyncAction(x),
OldPath = x.OldPath,
NewPath = x.NewPath,
OldVcsPath = CalcVcsPath(trackBranch, x.OldPath),
NewVcsPath = CalcVcsPath(trackBranch, x.NewPath),
}).ToList();
var patch = new PatchInfo() { TimeStamp = DateTime.Now.Ticks, Items = changes };
var patchPath = Path.Combine(patchdir, patchZip);
using (Package zip = Package.Open(patchPath, FileMode.Create)) {
SavePatchInfo(patchdir, patch);
AddPart(zip, patchdir, "patch.info");
foreach (var path in CalcFilesForPatch(patch)) {
AddPart(zip, localGitDir, path);
}
}
Log.Message($"Patch.info generated at {patchPath}");
return 0;
}
static int DoProcessTestResultsWork(ProcessTestsOptions clo) {
Log.Message("process test results.");
string targetRepoPath = GetSimpleGitHttpPath(clo.Repo);
if (string.IsNullOrEmpty(targetRepoPath)) {
Log.Error($"Can`t parse repo path {clo.Repo}");
return 1;
}
string sourceRepoPath = GetSimpleGitHttpPath(clo.SourceRepo);
if (string.IsNullOrEmpty(sourceRepoPath)) {
Log.Error($"Can`t parse source repo path {clo.SourceRepo}");
return 1;
}
string gitlabauthtoken = clo.AuthToken;
string targetBranchName = clo.Branch;
string gitServer = clo.Server;
string sourceBranchName = clo.SourceBranch;
GitLabWrapper gitLabWrapper = new GitLabWrapper(gitServer, gitlabauthtoken);
Project targetProject = gitLabWrapper.FindProject(targetRepoPath);
if (targetProject == null) {
Log.Error($"Can`t find target project {targetRepoPath}.");
return 1;
}
Branch targetBranch = gitLabWrapper.GetBranch(targetProject, targetBranchName);
if (targetBranch == null) {
Log.Error($"Can`t find targetBranch branch {targetBranchName}");
return 1;
}
var sourceProject = gitLabWrapper.FindProjectFromAll(sourceRepoPath);
if (sourceProject == null) {
Log.Error($"Can`t find source project {sourceRepoPath}");
return 1;
}
var sourceBranch = gitLabWrapper.GetBranch(sourceProject, sourceBranchName);
if (sourceBranch == null) {
Log.Error($"Source branch {sourceBranchName} was not found.");
return 1;
}
MergeRequest mergeRequest = gitLabWrapper.GetMergeRequests(targetProject, x => x.SourceBranch == sourceBranchName && x.TargetBranch == targetBranchName).FirstOrDefault();
if (mergeRequest == null) {
Log.Error($"Can`t find merge request.");
return 1;
}
var comments = gitLabWrapper.GetComments(mergeRequest);
var mergeRequestSyncOptions = comments?.Where(x => IsXml(x.Note)).Where(x => {
var mr = MergeRequestOptions.ConvertFromString(x.Note);
return mr?.ActionType == MergeRequestActionType.sync;
}).Select(x => (MergeRequestSyncAction)MergeRequestOptions.ConvertFromString(x.Note).Action).LastOrDefault();
if (mergeRequestSyncOptions == null) {
Log.Message("Merge request sync options not found. Nothing to do.");
return 0;
}
if (!mergeRequestSyncOptions.PerformTesting) {
Log.Message("Testing is disabled in config.");
return 0;
}
Log.Message("Testing is enabled in config.");
var commit = gitLabWrapper.GetMergeRequestCommits(mergeRequest).FirstOrDefault();
if (commit == null) {
Log.Message("Merge request has no commits.");
return 0;
}
var mergeRequestBuild = gitLabWrapper.GetBuilds(mergeRequest, commit.Id).FirstOrDefault();
if (mergeRequestBuild == null) {
Log.Message("Merge request has no build.");
return 0;
}
Log.Message($"Build has {mergeRequestBuild.Status} status.");
if (mergeRequestBuild.Status == BuildStatus.success) {
if (mergeRequestSyncOptions.AssignToSyncService) {
gitLabWrapper.UpdateMergeRequestAssignee(mergeRequest, mergeRequestSyncOptions.SyncTask);
Log.Message($"Success tests. Assigning to sync service {mergeRequestSyncOptions.SyncTask}");
return 0;
}
else {
gitLabWrapper.UpdateMergeRequestAssignee(mergeRequest, mergeRequest.Author.Username);
Log.Message($"Success tests. Assigning to back to author {mergeRequest.Author.Username}");
return 0;
}
}
if (mergeRequestBuild.Status == BuildStatus.failed) {
Log.Message($"Failed tests.");
return 0;
}
Log.Message("Nothing happens.");
return 0;
}
static MergeRequestResult ProcessOpenedMergeRequest(DXVcsWrapper vcsWrapper, GitWrapper gitWrapper, GitLabWrapper gitLabWrapper, RegisteredUsers users, User defaultUser, string localGitDir, TrackBranch branch, MergeRequest mergeRequest, SyncHistoryWrapper syncHistory) {
string autoSyncToken = syncHistory.CreateNewToken();
var lastHistoryItem = syncHistory.GetHead();
Log.Message($"Start merging mergerequest {mergeRequest.Title}");
Log.ResetErrorsAccumulator();
var changes = gitLabWrapper.GetMergeRequestChanges(mergeRequest).ToList();
if (changes.Count >= MaxChangesCount) {
Log.Error($"Merge request contains more than {MaxChangesCount} changes and cannot be processed. Split it into smaller merge requests");
AssignBackConflictedMergeRequest(gitLabWrapper, users, mergeRequest, CalcCommentForFailedCheckoutMergeRequest(null));
return MergeRequestResult.Failed;
}
var genericChange = changes
.Where(x => branch.TrackItems.FirstOrDefault(track => CheckItemForChangeSet(x, track)) != null)
.Select(x => ProcessMergeRequestChanges(mergeRequest, x, localGitDir, branch, autoSyncToken)).ToList();
bool ignoreValidation = gitLabWrapper.ShouldIgnoreSharedFiles(mergeRequest);
if (!ValidateMergeRequestChanges(gitLabWrapper, mergeRequest, ignoreValidation) || !vcsWrapper.ProcessCheckout(genericChange, ignoreValidation, branch)) {
Log.Error("Merging merge request failed because failed validation.");
AssignBackConflictedMergeRequest(gitLabWrapper, users, mergeRequest, CalcCommentForFailedCheckoutMergeRequest(genericChange));
vcsWrapper.ProcessUndoCheckout(genericChange);
return MergeRequestResult.CheckoutFailed;
}
CommentWrapper comment = CalcComment(mergeRequest, branch, autoSyncToken);
mergeRequest = gitLabWrapper.ProcessMergeRequest(mergeRequest, comment.ToString());
if (mergeRequest.State == "merged") {
Log.Message("Merge request merged successfully.");
gitWrapper.Pull();
gitWrapper.LFSPull();
var gitCommit = gitWrapper.FindCommit(x => CommentWrapper.Parse(x.Message).Token == autoSyncToken);
long timeStamp = lastHistoryItem.VcsCommitTimeStamp;
if (gitCommit != null && vcsWrapper.ProcessCheckIn(genericChange, comment.ToString())) {
var checkinHistory = vcsWrapper.GenerateHistory(branch, new DateTime(timeStamp)).Where(x => x.ActionDate.Ticks > timeStamp);
var lastCommit = checkinHistory.OrderBy(x => x.ActionDate).LastOrDefault();
long newTimeStamp = lastCommit?.ActionDate.Ticks ?? timeStamp;
var mergeRequestResult = MergeRequestResult.Success;
if (!ValidateMergeRequest(vcsWrapper, branch, lastHistoryItem, defaultUser))
mergeRequestResult = MergeRequestResult.Mixed;
if (!ValidateChangeSet(genericChange))
mergeRequestResult = MergeRequestResult.Mixed;
syncHistory.Add(gitCommit.Sha, newTimeStamp, autoSyncToken, mergeRequestResult == MergeRequestResult.Success ? SyncHistoryStatus.Success : SyncHistoryStatus.Mixed);
syncHistory.Save();
Log.Message("Merge request checkin successfully.");
return mergeRequestResult;
}
Log.Error("Merge request checkin failed.");
if (gitCommit == null)
Log.Error($"Can`t find git commit with token {autoSyncToken}");
var failedHistory = vcsWrapper.GenerateHistory(branch, new DateTime(timeStamp));
var lastFailedCommit = failedHistory.OrderBy(x => x.ActionDate).LastOrDefault();
syncHistory.Add(gitCommit.Sha, lastFailedCommit?.ActionDate.Ticks ?? timeStamp, autoSyncToken, SyncHistoryStatus.Failed);
syncHistory.Save();
return MergeRequestResult.Failed;
}
Log.Message($"Merge request merging failed due conflicts. Resolve conflicts manually.");
vcsWrapper.ProcessUndoCheckout(genericChange);
AssignBackConflictedMergeRequest(gitLabWrapper, users, mergeRequest, CalcCommentForFailedCheckoutMergeRequest(genericChange));
return MergeRequestResult.Conflicts;
}
static bool ValidateMergeRequestChanges(GitLabWrapper gitLabWrapper, MergeRequest mergeRequest, bool ignoreValidation) {
if (ignoreValidation)
return true;
bool result = true;
var fileChanges = gitLabWrapper.GetFileChanges(mergeRequest);
foreach (var fileChange in fileChanges) {
if (!ValidateFileChange(fileChange)) {
Log.Error($"File {fileChange.OldPath} has nonwindows line endings. Only windows line endings allowed.");
result = false;
}
}
return result;
}
static void AssignBackConflictedMergeRequest(GitLabWrapper gitLabWrapper, RegisteredUsers users, MergeRequest mergeRequest, string comment) {
User author = users.GetUser(mergeRequest.Author.Username);
var mr = gitLabWrapper.UpdateMergeRequestAssignee(mergeRequest, author.UserName);
gitLabWrapper.AddCommentToMergeRequest(mr, comment);
}
static MergeRequestResult ProcessMergeRequest(DXVcsWrapper vcsWrapper, GitWrapper gitWrapper, GitLabWrapper gitLabWrapper, RegisteredUsers users, User defaultUser, string localGitDir, TrackBranch branch, MergeRequest mergeRequest, SyncHistoryWrapper syncHistory) {
switch (mergeRequest.State) {
case "reopened":
case "opened":
return ProcessOpenedMergeRequest(vcsWrapper, gitWrapper, gitLabWrapper, users, defaultUser, localGitDir, branch, mergeRequest, syncHistory);
}
return MergeRequestResult.InvalidState;
}
static int ProcessMergeRequests(DXVcsWrapper vcsWrapper, GitWrapper gitWrapper, GitLabWrapper gitLabWrapper, RegisteredUsers users, User defaultUser, string gitRepoPath, string localGitDir, string branchName, string tracker, SyncHistoryWrapper syncHistory, string userName) {
var project = gitLabWrapper.FindProject(gitRepoPath);
TrackBranch branch = GetBranch(branchName, tracker, vcsWrapper);
if (branch == null) {
Log.Error($"Specified branch {branchName} not found in track file.");
return 1;
}
var mergeRequests = GetMergeRequests(gitLabWrapper, branchName, userName, project);
if (!mergeRequests.Any()) {
Log.Message("Zero registered merge requests.");
return 0;
}
int result = 0;
foreach (var mergeRequest in mergeRequests) {
var mergeRequestResult = ProcessMergeRequest(vcsWrapper, gitWrapper, gitLabWrapper, users, defaultUser, localGitDir, branch, mergeRequest, syncHistory);
if (mergeRequestResult == MergeRequestResult.Failed)
return 1;
if (mergeRequestResult == MergeRequestResult.CheckoutFailed || mergeRequestResult == MergeRequestResult.Conflicts || mergeRequestResult == MergeRequestResult.InvalidState)
result = 1;
}
return result;
}
static List<MergeRequest> GetMergeRequests(GitLabWrapper gitLabWrapper, string branchName, string userName, Project project) {
return gitLabWrapper.GetMergeRequests(project, x => x.TargetBranch == branchName).Where(x => x.Assignee?.Name == userName).ToList();
}
public void GetMergeRequests()
{
GitLabWrapper wrapper = new GitLabWrapper(TestCredentials.GitServer, TestCredentials.GitLabToken);
var project = wrapper.FindProject("tester/testxpfall");
var requests = wrapper.GetMergeRequests(project, x => x.TargetBranch == "test2");
}
static int DoListenerWork(ListenerOptions clo) {
string gitServer = clo.Server;
string gitlabauthtoken = clo.AuthToken;
string sharedWebHookPath = clo.WebHook;
string taskName = clo.FarmTaskName;
string serviceUser = clo.Login;
bool supportsSendingMessages = !string.IsNullOrEmpty(taskName);
Stopwatch sw = Stopwatch.StartNew();
GitLabWrapper gitLabWrapper = new GitLabWrapper(gitServer, gitlabauthtoken);
FarmIntegrator.Start(null);
var projects = gitLabWrapper.GetAllProjects();
foreach (Project project in projects) {
var hooks = gitLabWrapper.GetProjectHooks(project);
foreach (ProjectHook hook in hooks) {
if (WebHookHelper.IsSameHost(hook.Url, IP) || !WebHookHelper.IsSharedHook(sharedWebHookPath, hook.Url))
continue;
Uri url = WebHookHelper.Replace(hook.Url, IP);
gitLabWrapper.UpdateProjectHook(project, hook, url, true, true, true);
Log.Message($"WebHook registered for project {project.Name} at {url}");
}
}
WebServer server = new WebServer(WebHookHelper.GetSharedHookUrl(IP, sharedWebHookPath));
server.Start();
while (sw.Elapsed.Minutes < clo.Timeout) {
Thread.Sleep(10);
var request = server.GetRequest();
if (request == null)
continue;
ProcessWebHook(gitLabWrapper, serviceUser, request, supportsSendingMessages, taskName);
}
return 0;
}
static void ForceSyncBuild(GitLabWrapper gitLabWrapper, MergeRequest mergeRequest, Project targetProject, MergeRequestHookClient hook) {
var xmlComments = gitLabWrapper.GetComments(mergeRequest).Where(x => IsXml(x.Note));
var options = xmlComments.Select(x => MergeRequestOptions.ConvertFromString(x.Note)).FirstOrDefault();
if (options != null && options.ActionType == MergeRequestActionType.sync) {
var action = (MergeRequestSyncAction)options.Action;
if (action.PerformTesting) {
Log.Message("Check build status before force build.");
var commit = gitLabWrapper.GetMergeRequestCommits(mergeRequest).FirstOrDefault();
var build = commit != null ? gitLabWrapper.GetBuilds(mergeRequest, commit.Id).FirstOrDefault() : null;
var buildStatus = build?.Status ?? BuildStatus.undefined;
Log.Message($"Build status = {buildStatus}.");
if (buildStatus == BuildStatus.success)
ForceBuild(action.SyncTask);
return;
}
Log.Message("Build forces without checking tests status.");
ForceBuild(action.SyncTask);
return;
}
string task = FarmIntegrator.FindTask($"{mergeRequest.TargetBranch}@{targetProject.PathWithNamespace}");
if (!string.IsNullOrEmpty(task)) {
Log.Message($"Sync task {task} found by heuristic.");
ForceBuild(task);
return;
}
Log.Message("Merge request can`t be merged because merge request notes has no farm config.");
Log.Message("");
}
static void ProcessMergeRequestHook(GitLabWrapper gitLabWrapper, string serviceUser, MergeRequestHookClient hook, bool supportSendingMessages, string farmTaskName) {
Log.Message($"Merge hook title: {hook.Attributes.Description}");
Log.Message($"Merge hook state: {hook.Attributes.State}");
var targetProject = gitLabWrapper.GetProject(hook.Attributes.TargetProjectId);
var mergeRequest = gitLabWrapper.GetMergeRequest(targetProject, hook.Attributes.Id);
if (supportSendingMessages)
SendMessage(serviceUser, hook.Json, farmTaskName);
if (!IsOpenedState(hook))
return;
Log.Message($"Merge hook action: {hook.Attributes.Action}");
Log.Message($"Merge hook merge status: {hook.Attributes.MergeStatus}");
Log.Message($"Merge hook author: {gitLabWrapper.GetUser(hook.Attributes.AuthorId).Name}.");
Log.Message($"Merge hook target branch: {hook.Attributes.TargetBranch}.");
Log.Message($"Merge hook sourceBranch branch: {hook.Attributes.SourceBranch}.");
if (ShouldForceSyncTask(mergeRequest, hook)) {
ForceSyncBuild(gitLabWrapper, mergeRequest, targetProject, hook);
return;
}
}
static MergeRequest CalcMergeRequest(GitLabWrapper gitLabWrapper, BuildHookClient hook, Project project) {
foreach (var checkProject in gitLabWrapper.GetProjects()) {
var mergeRequests = gitLabWrapper.GetMergeRequests(checkProject, x => x.SourceProjectId == project.Id);
var mergeRequest = mergeRequests.FirstOrDefault(x => x.SourceBranch == hook.Branch);
if (mergeRequest != null)
return mergeRequest;
}
return null;
}
static void ProcessBuildHook(GitLabWrapper gitLabWrapper, string serviceUser, BuildHookClient hook, bool supportSendingMessages, string farmTaskName) {
Log.Message($"Build hook title: {hook.BuildName}");
Log.Message($"Build hook status: {hook.Status}");
if (supportSendingMessages)
SendMessage(serviceUser, hook.Json, farmTaskName);
if (hook.Status == BuildStatus.success) {
Project project = gitLabWrapper.GetProject(hook.ProjectId);
if (project == null) {
Log.Message($"Can`t find project {hook.ProjectName}.");
return;
}
Log.Message($"Project: {project.PathWithNamespace}");
var mergeRequest = CalcMergeRequest(gitLabWrapper, hook, project);
if (mergeRequest == null) {
Log.Message("Can`t find merge request.");
return;
}
Log.Message($"Merge request: id = {mergeRequest.Id} title = {mergeRequest.Title}");
Log.Message($"Merge request state = {mergeRequest.State}");
if (mergeRequest.State == "opened" || mergeRequest.State == "reopened") {
var latestCommit = gitLabWrapper.GetMergeRequestCommits(mergeRequest).FirstOrDefault();
if (latestCommit == null) {
Log.Message("Wrong merge request found.");
return;
}
Log.Message($"Merge request latest commit sha = {latestCommit.Id}");
if (!latestCommit.Id.Equals(new Sha1(hook.Commit.Id))) {
Log.Message($"Additional commits has been added {hook.Commit.Id}");
return;
}
var xmlComments = gitLabWrapper.GetComments(mergeRequest).Where(x => IsXml(x.Note));
var options = xmlComments.Select(x => MergeRequestOptions.ConvertFromString(x.Note)).FirstOrDefault();
if (options?.ActionType == MergeRequestActionType.sync) {
Log.Message("Sync options found.");
var syncOptions = (MergeRequestSyncAction)options.Action;
Log.Message($"Sync options perform testing is {syncOptions.PerformTesting}");
Log.Message($"Sync options assign to service is {syncOptions.AssignToSyncService}");
Log.Message($"Sync options sync task is {syncOptions.SyncTask}");
Log.Message($"Sync options sync service is {syncOptions.SyncService}");
if (syncOptions.PerformTesting && syncOptions.AssignToSyncService) {
gitLabWrapper.UpdateMergeRequestAssignee(mergeRequest, syncOptions.SyncService);
ForceBuild(syncOptions.SyncTask);
}
return;
}
Log.Message("Sync options not found.");
}
}
}
static void ProcessWebHook(GitLabWrapper gitLabWrapper, string serviceUser, WebHookRequest request, bool supportSendingMessages, string farmTaskName) {
var hookType = ProjectHookClient.ParseHookType(request);
if (hookType == null)
return;
Log.Message($"Web hook received.");
Log.Message($"Web hook type: {hookType.HookType}.");
var hook = ProjectHookClient.ParseHook(hookType);
if (hook.HookType == ProjectHookType.push)
ProcessPushHook((PushHookClient)hook);
else if (hook.HookType == ProjectHookType.merge_request)
ProcessMergeRequestHook(gitLabWrapper, serviceUser, (MergeRequestHookClient)hook, supportSendingMessages, farmTaskName);
else if (hook.HookType == ProjectHookType.build)
ProcessBuildHook(gitLabWrapper, serviceUser, (BuildHookClient)hook, supportSendingMessages, farmTaskName);
}
public void GetProject()
{
GitLabWrapper wrapper = new GitLabWrapper(TestCredentials.GitServer, TestCredentials.GitLabToken);
var project = wrapper.FindProject("tester/testxpfall");
Assert.IsNotNull(project);
}
static CheckMergeChangesResult CheckChangesForMerging(GitLabWrapper gitLabWrapper, string gitRepoPath, string branchName, SyncHistoryItem head, DXVcsWrapper vcsWrapper, TrackBranch branch, SyncHistoryWrapper syncHistory, User defaultUser) {
var project = gitLabWrapper.FindProject(gitRepoPath);
if (project == null) {
Log.Error($"Can`t find git project {gitRepoPath}");
return CheckMergeChangesResult.Error;
}
var gitlabBranch = gitLabWrapper.GetBranches(project).Single(x => x.Name == branchName);
if (gitlabBranch.Commit.Id.Equals(new Sha1(head.GitCommitSha))) {
var commits = GenerateCommits(vcsWrapper, branch, syncHistory, false);
if (commits.Count == 0) {
var mergeRequests = GetMergeRequests(gitLabWrapper, branchName, defaultUser.UserName, project);
if (!mergeRequests.Any()) {
Log.Message("Zero registered merge requests.");
return CheckMergeChangesResult.NoChanges;
}
}
}
return CheckMergeChangesResult.HasChanges;
}
