public async Task Handle_ShouldDeployPipeline_IfOnDefaultBranch_AndCommitMessageDoesntContainSkip()
{
var requestValidator = Substitute.For <RequestValidator>();
var starter = Substitute.For <PipelineStarter>();
var deployer = Substitute.For <PipelineDeployer>();
var statusNotifier = Substitute.For <GithubStatusNotifier>();
var commitMessageFetcher = Substitute.For <GithubCommitMessageFetcher>();
var logger = Substitute.For <ILogger <Handler> >();
var handler = new Handler(requestValidator, starter, deployer, statusNotifier, commitMessageFetcher, config, logger);
var pushEvent = new PushEvent
{
Ref = "refs/heads/master",
Repository = new Repository {
Name = repoName, DefaultBranch = "master"
},
HeadCommit = new Commit {
Id = sha, Message = ""
}
};
requestValidator.Validate(Any <ApplicationLoadBalancerRequest>()).Returns(pushEvent);
var response = await handler.Handle(new ApplicationLoadBalancerRequest { });
await deployer.Received().Deploy(Is(pushEvent));
}
public async Task StartExecutionIsCalled_ForTags()
{
var repoName = "name";
var sha = "sha";
var @ref = "refs/tags/v0.1.0";
var payload = new PushEvent
{
Ref = @ref,
HeadCommit = new Commit
{
Id = sha,
},
Repository = new Repository
{
Name = repoName
}
};
var serializedPayload = Serialize(payload);
var stepFunctionsClient = Substitute.For <IAmazonStepFunctions>();
var logger = Substitute.For <ILogger <PipelineStarter> >();
var pipelineStarter = new PipelineStarter(stepFunctionsClient, logger);
await pipelineStarter.StartPipelineIfExists(payload);
var StateMachineArn = $"arn:aws:states:us-east-1:5:stateMachine:{repoName}-cicd-pipeline";
await stepFunctionsClient.Received().StartExecutionAsync(Arg.Is <StartExecutionRequest>(req =>
req.StateMachineArn == StateMachineArn &&
req.Name == null &&
req.Input == serializedPayload
));
}
public async Task Handle_ShouldNotStartPipeline_IfCommitMessageContainsSkip()
{
var requestValidator = Substitute.For <RequestValidator>();
var starter = Substitute.For <PipelineStarter>();
var deployer = Substitute.For <PipelineDeployer>();
var statusNotifier = Substitute.For <GithubStatusNotifier>();
var commitMessageFetcher = Substitute.For <GithubCommitMessageFetcher>();
var logger = Substitute.For <ILogger <Handler> >();
var handler = new Handler(requestValidator, starter, deployer, statusNotifier, commitMessageFetcher, config, logger);
var message = "[skip ci]";
commitMessageFetcher.FetchCommitMessage(Any <GithubEvent>()).Returns(message);
var pushEvent = new PushEvent
{
Ref = "refs/heads/master",
Repository = new Repository {
Name = repoName, DefaultBranch = "develop"
},
HeadCommit = new Commit {
Id = sha
}
};
requestValidator.Validate(Any <ApplicationLoadBalancerRequest>()).Returns(pushEvent);
var response = await handler.Handle(new ApplicationLoadBalancerRequest { });
await starter.DidNotReceiveWithAnyArgs().StartPipelineIfExists(null !);
await commitMessageFetcher.Received().FetchCommitMessage(Is(pushEvent));
}
/// <summary>
/// Ajout dans la stack
/// </summary>
/// <param name="item">Item à ajouter</param>
public new void Push(T item)
{
// Appelle Push sur la classe mère
base.Push(item);
// S'il existe un abonnement à cet évènement
if (PushEvent != null)
{
// Déclenchement de l'évènement d'ajout dans la stack d'un emplacement
PushEvent.Invoke();
}
}
public void Should_write_many_events(int count, int threads)
{
var builders = TestHelpers.GenerateEventBuilders(count);
using (Hercules.Management.CreateTemporaryStream(out var stream))
{
builders.PushEvents(PushEvent.ToStream(stream), threads);
var events = Hercules.Stream.ReadEvents(stream, count, count / 4);
events.ShouldBeEqual(builders.ToEvents());
}
}
public IEnumerator HandleButton(KeypadButton button, KeyCode keyCode, PushEvent handler)
{
var delay = startDelay;
while (Input.GetKey(keyCode) || IsHeld(button))
{
MasterAudio.PlaySound3DFollowTransformAndForget("singlebeep", FreeplayDevice.transform, 1f, null);
handler.Invoke();
yield return(new WaitForSeconds(Mathf.Max(delay, minDelay)));
delay -= Acceleration;
}
}
private IEnumerable <Task> GetPushEventTasks(PushEvent pushEvent)
{
if (!pushEvent.OnDefaultBranch && !pushEvent.Ref.StartsWith("refs/tags/"))
{
yield break;
}
if (!pushEvent.HeadCommitMessage.Contains("[skip meta-ci]"))
{
yield return(pipelineDeployer.Deploy(pushEvent));
}
if (!pushEvent.HeadCommitMessage.Contains("[skip ci]"))
{
yield return(pipelineStarter.StartPipelineIfExists(pushEvent));
}
}
private static MattermostMessage GetMessagePush(PushEvent payload)
{
if (!payload.deleted && !payload.forced)
{
if (!payload._ref.StartsWith("refs/tags/"))
{
var retVal = BaseMessageForRepo(payload.repository.full_name);
MattermostAttachment att = null;
if (payload.commits.Count > 0)
{
var multi = payload.commits.Count > 1 ? "s" : "";
var userMd = $"[{payload.sender.login}]({payload.sender.html_url})";
var branch = payload._ref.Replace("refs/heads/", "");
var branchMd = $"[{branch}]({payload.repository.html_url}/tree/{branch})";
var repoMd = $"[{payload.repository.full_name}]({payload.repository.html_url})";
retVal.Text =
$"{userMd} pushed {payload.commits.Count} commit{multi} to {branchMd} on {repoMd}";
att = new MattermostAttachment();
foreach (var commit in payload.commits)
{
var sanitised = Regex.Replace(commit.message, @"\r\n?|\n", " ");
att.Text +=
$"- [`{commit.id.Substring(0, 8)}`]({commit.url}) - {sanitised}\n";
}
}
else
{
throw new WarningException("No commits in payload, no need to send message.");
}
retVal.Attachments = new List <MattermostAttachment>
{
att
};
return(retVal);
}
}
throw new NotImplementedException($"Unhandled Push Type: {payload._ref}");
}
public void Should_read_events_in_many_client_shards(int count)
{
var builders = TestHelpers.GenerateEventBuilders(count);
using (Hercules.Management.CreateTemporaryStream(out var stream))
{
builders.PushEvents(PushEvent.ToStream(stream));
var shards = Hercules.Stream.ReadEvents(stream, count, count / 4, 3);
shards.SelectMany(x => x).ShouldBeEqual(builders.ToEvents());
foreach (var shard in shards)
{
shard.Should().NotBeEmpty();
}
}
}
void Start()
{
instance = this;
if (isAdmin)
{
put(MODULE_CODE_ADMIN_AGENCY, AdminAgencyManager.deserializeModuleOne);
put(MODULE_CODE_ADMIN_SELLER, AdminUserRZ.deserializeModuleOne);
}
else
{
put(MODULE_CODE_USER, MainData.instance.user.deserializeModuleOne);
put(MODULE_CODE_DEAL, MainData.instance.deserializeDealModuleOne);
put(MODULE_CODE_BANK_ACCOUNT, MainData.instance.user.bacnkAccount.deserializeModule);
put(MODULE_CODE_SIMPLE_DEAL, readPushData);
put(MODULE_CODE_EAMIL, MainData.instance.deserializeEmailModule);
put(MODULE_CODE_SIMPLE_ORDER, MainData.instance.deserializeSimpleOrderModuleOne);
put(MODULE_CODE_FRIEND, MainData.instance.deserializeFriendModuleOne);
put(MODULE_CODE_MESSAGE, MainData.instance.deserializeMessageModuleOne);
put(MODULE_CODE_ORDER, MainData.instance.deserializeOrderModuleOne);
GameObject push_obj = GameObject.Find("push");
pushEvent = push_obj.GetComponent <PushEvent>();
}
}
private object ConvertPayload()
{
switch (Event)
{
case PingEvent.EventString:
return(PingEvent.FromJson(PayloadText));
case CommitCommentEvent.EventString:
return(CommitCommentEvent.FromJson(PayloadText));
case CreateEvent.EventString:
return(CreateEvent.FromJson(PayloadText));
case DeleteEvent.EventString:
return(DeleteEvent.FromJson(PayloadText));
case DeploymentEvent.EventString:
return(DeploymentEvent.FromJson(PayloadText));
case DeploymentStatusEvent.EventString:
return(DeploymentStatusEvent.FromJson(PayloadText));
case ForkEvent.EventString:
return(ForkEvent.FromJson(PayloadText));
case GollumEvent.EventString:
return(GollumEvent.FromJson(PayloadText));
case InstallationEvent.EventString:
return(InstallationEvent.FromJson(PayloadText));
case InstallationRepositoriesEvent.EventString:
return(InstallationRepositoriesEvent.FromJson(PayloadText));
case IssueCommentEvent.EventString:
return(IssueCommentEvent.FromJson(PayloadText));
case IssuesEvent.EventString:
return(IssuesEvent.FromJson(PayloadText));
case LabelEvent.EventString:
return(LabelEvent.FromJson(PayloadText));
case MemberEvent.EventString:
return(MemberEvent.FromJson(PayloadText));
case MembershipEvent.EventString:
return(MembershipEvent.FromJson(PayloadText));
case MilestoneEvent.EventString:
return(MilestoneEvent.FromJson(PayloadText));
case OrganizationEvent.EventString:
return(OrganizationEvent.FromJson(PayloadText));
case OrgBlockEvent.EventString:
return(OrgBlockEvent.FromJson(PayloadText));
case PageBuildEvent.EventString:
return(PageBuildEvent.FromJson(PayloadText));
case ProjectCardEvent.EventString:
return(ProjectCardEvent.FromJson(PayloadText));
case ProjectColumnEvent.EventString:
return(ProjectColumnEvent.FromJson(PayloadText));
case ProjectEvent.EventString:
return(ProjectEvent.FromJson(PayloadText));
case PublicEvent.EventString:
return(PublicEvent.FromJson(PayloadText));
case PullRequestEvent.EventString:
return(PullRequestEvent.FromJson(PayloadText));
case PullRequestReviewEvent.EventString:
return(PullRequestReviewEvent.FromJson(PayloadText));
case PullRequestReviewCommentEvent.EventString:
return(PullRequestReviewCommentEvent.FromJson(PayloadText));
case PushEvent.EventString:
return(PushEvent.FromJson(PayloadText));
case ReleaseEvent.EventString:
return(ReleaseEvent.FromJson(PayloadText));
case RepositoryEvent.EventString:
return(RepositoryEvent.FromJson(PayloadText));
case StatusEvent.EventString:
return(StatusEvent.FromJson(PayloadText));
case WatchEvent.EventString:
return(WatchEvent.FromJson(PayloadText));
default:
throw new NotImplementedException(
$"Event Type: `{Event}` is not implemented. Want it added? Open an issue at https://github.com/promofaux/GithubWebhooks");
}
}
public void OnPush(object sender, CollectionChangeEventArgs e)
{
PushEvent?.Invoke(sender, e);
}
public async Task <IActionResult> FetchRepoInfo(long repoId)
{
ObjectId currentUser = ObjectId.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
var client = _githubClientService.GetGitHubClient(currentUser);
var mongoDb = _mongoService.GetDb;
var mongoSettings = _mongoService.GetDBSettings;
var repoCollection = mongoDb.GetCollection <Repository>(mongoSettings.ReposCollectionName);
var filterRepo = Builders <Repository> .Filter.Eq(r => r.Id, repoId);
var repo = (await repoCollection.FindAsync <Repository>(filterRepo)).FirstOrDefault();
var userCollection = mongoDb.GetCollection <Models.User>(mongoSettings.UserCollectionName);
var filterUser = Builders <Models.User> .Filter.Eq(u => u.Id, currentUser);
var user = (await userCollection.FindAsync <Models.User>(filterUser)).FirstOrDefault();
var branches = await _githubClientService.GetBranches(currentUser, repo);
var query = _neoContext.Cypher
.Unwind(branches, "branch")
.Match("(r:Repo {Id:" + repo.Id + "})")
.Merge("(b:Branch {Name: branch.Name})")
.OnCreate().Set("b.Name = branch.Name")
.Merge("(r)-[rel:HAS_BRANCH]->(b)")
;
var branchCreate = query.Query.DebugQueryText;
await query.ExecuteWithoutResultsAsync();
List <PullRequestEvent> pullRequestEvents = new List <PullRequestEvent>();
var gitEventsJsonArray = await _githubClientService.GetRepoEvents(user.GithubLogin, repo.Name, user.OAuthToken);
foreach (var a in gitEventsJsonArray)
{
var type = ((JValue)a["type"]).ToString();
var payload = ((JObject)a["payload"]);
var created = a.Value <DateTime>("created_at");
var createdString = created.ToString("yyyy-MM-dd") + "T" + created.ToString("HH:mm:ss") + "Z";
switch (type)
{
case "PushEvent":
var branch = payload["ref"].ToString();
var pom = branch.Split("/");
var branchName = pom[pom.Length - 1]; //
PushEvent pushEvent = new PushEvent
{
Id = ((JValue)a["id"]).ToString(),
Created = createdString
};
List <ComitPushNode> commits = new List <ComitPushNode>();
foreach (var c in (JArray)payload["commits"])
{
var commitAuthor = ((JObject)c["author"]);
ComitPushNode comitPushNode = new ComitPushNode
{
Sha = ((JValue)c["sha"]).ToString(),
Message = ((JValue)c["message"]).ToString(),
Author = commitAuthor["name"].ToString(),
Push_Id = pushEvent.Id
};
commits.Add(comitPushNode);
}
// add to Neo4J
var queryAddPush = _neoContext.Cypher
.Match("(r:Repo {Id: " + repo.Id + $" }})-[rel1:HAS_BRANCH]->(b:Branch {{Name: '{branchName}'}})")
.Merge($"(p:PushEvent {{Id:'{pushEvent.Id}'}})")
.OnCreate().Set($"p.Id = '{pushEvent.Id}'")
.Merge("(b)<-[rel2:PUSHED_TO]-(p)")
.Set($"rel2.Created = datetime('{pushEvent.Created}')")
;
var queryPushText = queryAddPush.Query.DebugQueryText;
await queryAddPush.ExecuteWithoutResultsAsync();
var queryCommitsImport = _neoContext.Cypher
.Unwind(commits, "commit")
.Match($"(p:PushEvent {{Id:'{pushEvent.Id}'}})")
.Merge("(c:CommitPush {Sha: commit.Sha})")
.OnCreate().Set("c.Sha = commit.Sha, c.Author = commit.Author, c.Message = commit.Message, c.Push_Id = commit.Push_Id")
.Merge("(p)-[rel:CONTAINS_COMMIT]->(c)")
;
var queryCommitsText = queryCommitsImport.Query.DebugQueryText;
await queryCommitsImport.ExecuteWithoutResultsAsync();
break;
case "PullRequestEvent":
var pullRequestInfo = (JObject)payload["pull_request"];
JObject headBranch = (JObject)pullRequestInfo["head"], baseBranch = (JObject)pullRequestInfo["base"];
PullRequestEvent pullRequestEvent = new PullRequestEvent
{
Id = ((JValue)a["id"]).ToString(),
Action = ((JValue)payload["action"]).ToString(),
CreatedAt = createdString,
Merged = (bool)pullRequestInfo["merged"],
PullRequestUrl = ((JValue)pullRequestInfo["url"]).ToString(),
BaseBranch = ((JValue)baseBranch["ref"]).ToString(),
HeadBranch = ((JValue)headBranch["ref"]).ToString()
};
if (pullRequestEvent.Action == "closed")
{
var queryPullRequest = _neoContext.Cypher
.Match($"(r {{Id: {repoId} }})-[:HAS_BRANCH]->(b1:Branch {{Name: '{pullRequestEvent.HeadBranch}'}})")
.Match($"(r)-[:HAS_BRANCH]->(b2:Branch {{Name: '{pullRequestEvent.BaseBranch}'}})")
.Merge($"(b1)-" +
$"[rel:MERGED_INTO {{Id: '{pullRequestEvent.Id}', " +
$"CreatedAt:datetime('{pullRequestEvent.CreatedAt}')}}]" +
$"->(b2)")
;
var queryPullRequestText = queryPullRequest.Query.DebugQueryText;
await queryPullRequest.ExecuteWithoutResultsAsync();
}
break;
default:
break;
}
}
await FetchIssues(repoId);
return(Ok());
}
public virtual async Task Deploy(PushEvent payload)
{
var stackName = $"{payload.Repository.Name}-{config.StackSuffix}";
var contentsUrl = payload.Repository.ContentsUrl;
var templateContent = await fileFetcher.Fetch(contentsUrl, config.TemplateFilename, payload.Ref);
var pipelineDefinition = await fileFetcher.Fetch(contentsUrl, config.PipelineDefinitionFilename, payload.Ref);
var roleArn = config.RoleArn;
if (templateContent == null)
{
logger.LogInformation($"Couldn't find template for {payload.Repository.Name}");
return;
}
var parameters = new List <Parameter> {
new Parameter {
ParameterKey = "GithubToken", ParameterValue = config.GithubToken
},
new Parameter {
ParameterKey = "GithubOwner", ParameterValue = config.GithubOwner
},
new Parameter {
ParameterKey = "GithubRepo", ParameterValue = payload.Repository.Name
},
new Parameter {
ParameterKey = "GithubBranch", ParameterValue = payload.Repository.DefaultBranch
}
};
if (pipelineDefinition != null)
{
var key = await UploadDefinition(payload.Repository.Name, pipelineDefinition);
parameters.Add(new Parameter
{
ParameterKey = "PipelineDefinitionBucket",
ParameterValue = config.ArtifactStore
});
parameters.Add(new Parameter
{
ParameterKey = "PipelineDefinitionKey",
ParameterValue = key
});
}
try
{
await statusNotifier.NotifyPending(payload.Repository.Name, payload.HeadCommit.Id);
await stackDeployer.Deploy(new DeployStackContext
{
StackName = stackName,
Template = templateContent,
NotificationArn = config.StatusNotificationTopicArn,
ClientRequestToken = payload.HeadCommit.Id,
PassRoleArn = roleArn,
Parameters = parameters
});
}
catch (NoUpdatesException)
{
await statusNotifier.NotifySuccess(payload.Repository.Name, payload.HeadCommit.Id);
}
catch (Exception e)
{
logger.LogError($"Failed to create/update stack: {e.Message} {e.StackTrace}");
await statusNotifier.NotifyFailure(payload.Repository.Name, payload.HeadCommit.Id);
}
}
