public async Task <RepositoryInfo> CreateAsync(CreateRepositoryRequest request, ISecurityContext context)
{
Ensure.NotNull(request, nameof(request));
Ensure.NotNull(context, nameof(context));
var repository = new RepositoryInfo(
id: await db.Repositories.Sequence.NextAsync(),
name: request.Name,
ownerId: request.OwnerId,
origin: request.Origin,
providerId: request.ProviderId,
encryptedAcessToken: request.EncryptedAccessToken,
properties: request.Properties
);
// TODO: Create the repository and it's first branch inside of a transaction
await db.Repositories.InsertAsync(repository);
// Create the master branch
await branchService.CreateAsync(new CreateBranchRequest(repository.Id, "master"), context);
#region Logging
await eventLog.CreateAsync(new Event(
action : "create",
resource : "repository#" + repository.Id,
userId : context.UserId.Value
));
#endregion
return(repository);
}
public async Task <Deployment> DeployAsync(DeployRequest request, ISecurityContext context)
{
Ensure.NotNull(request, nameof(request));
Ensure.NotNull(context, nameof(context));
var environment = request.Environment;
var program = request.Program;
var release = await releaseService.GetAsync(program.Id, program.Version);
var hosts = await hostService.ListAsync(environment);
var deployment = await StartAsync(
environment : environment,
release : release,
creatorId : context.UserId.Value
);
var targets = new DeploymentTarget[hosts.Count];
for (var i = 0; i < hosts.Count; i++)
{
targets[i] = new DeploymentTarget(
deploymentId: deployment.Id,
hostId: hosts[i].Id,
status: DeploymentStatus.Pending
);
}
var results = await ActivateAsync(release, hosts);
for (var i = 0; i < results.Length; i++)
{
var deployResult = results[i];
targets[i].Status = deployResult.Succeeded
? DeploymentStatus.Succeeded
: DeploymentStatus.Failed;
targets[i].Message = deployResult.Message;
}
// Complete the deployment & save the targets
await CompleteAsync(deployment, targets, succceded : true);
// Log the action
await eventLog.CreateAsync(new Event(
action : "deploy",
resource : "program#" + release.Id + "@" + release.Version,
userId : context.UserId
));
return(deployment);
}
// TODO: Accept bash script?
public async Task RunCommandAsync(string commandText, IEnvironment environment, ISecurityContext context)
{
Validate.NotNullOrEmpty(commandText, nameof(commandText));
Validate.NotNull(environment, nameof(environment));
Validate.NotNull(context, nameof(context));
var commands = CommandHelper.ToLines(commandText);
var parameters = new JsonObject {
{ "commands", commands }
};
// tag: || InstanceIds
// if tag: value:WebServer
var request = new SendCommandRequest {
DocumentName = "AWS-RunShellScript",
Targets = new[] {
new CommandTarget("tag:envId", values: new[] { environment.Id.ToString() })
},
Parameters = parameters
};
var result = await ssm.SendCommandAsync(request);
#region Logging
await eventLog.CreateAsync(new Event(
action : "run:command",
resource : "environment#" + environment.Id,
userId : context.UserId.Value,
context : new JsonObject
{
{ "commandId", result.Command.CommandId }
}
));
#endregion
}
public async Task RegisterHostAsync(Cluster cluster, HostInfo host)
{
Validate.NotNull(cluster, nameof(cluster));
Validate.NotNull(host, nameof(host));
// - Register to any attached load balancers
if (cluster.Properties.TryGetValue(ClusterProperties.TargetGroupArn, out var targetGroupArnNode))
{
var registration = new RegisterTargetsRequest(
targetGroupArn: targetGroupArnNode,
targets: new[] { new TargetDescription(id: host.ResourceId) }
);
// Register the instances with the lb's target group
await elbClient.RegisterTargetsAsync(registration);
await eventLog.CreateAsync(new Event(
action : "c",
resource : "borg:host/" + host.Id
));
}
}
public async Task <bool> DeleteAsync(RepositoryUser record, ISecurityContext context)
{
Ensure.NotNull(record, nameof(record));
Ensure.NotNull(context, nameof(context));
var result = await db.RepositoryUsers.PatchAsync((record.RepositoryId, record.UserId), new[] {
Change.Replace("deleted", Func("NOW"))
}, condition : IsNull("deleted")) > 0;
if (result)
{
await eventLog.CreateAsync(new Event("delete", $"borg:repository/{record.RepositoryId}/user/{record.UserId}"));
}
return(result);
}
public async Task <ProgramRelease> CreateAsync(CreateProgramReleaseRequest request, ISecurityContext context)
{
Ensure.NotNull(request, nameof(request));
Ensure.NotNull(context, nameof(request));
if (request.Version == default)
{
throw new ArgumentException("Must be be default", nameof(request.Version));
}
// Create the package ----------------------
var package = await packageManager.CreateAsync(new CreatePackageRequest(
programId : request.Program.Id,
programVersion : request.Version,
stream : request.Package.Stream,
format : request.Package.Format,
sha256 : request.Package.Sha256,
dekId : request.Package.DekId
), context);
// Create the release ----------------------
var release = await releaseService.CreateAsync(new RegisterProgramReleaseRequest(
program : request.Program,
version : request.Version,
commitId : request.Commit?.Id ?? 0L,
buildId : request.Build?.Id,
creatorId : context.UserId.Value,
properties : request.Program.Properties
));
#region Logging
await eventLog.CreateAsync(new Event(
action : "create",
resource : "program#" + release.ProgramId + "@" + release.Version,
userId : context.UserId
));
#endregion
return(release);
}
