private static async Task <int> Apply(ApplyOptions opts)
{
var response = await Provisioner.ApplyTerraformRunAsync(opts.RunId);
Console.WriteLine(response);
return(0);
}
public void MatchRequestHandler(MatchRequestMessage message, Player player)
{
if (message.Type == MatchRequestType.Join)
{
// Add the player to a match or remove them.
if (message.Value == 0)
{
Provisioner.PlayerLeft(player);
}
else
{
Provisioner.GetProvisioner(message.Value).AddPlayer(player);
}
}
else if (message.Type == MatchRequestType.SetReady)
{
// Set the player as ready or not.
if (message.Value == 1)
{
Provisioner.PlayerReady(player);
}
else if (message.Value == 0)
{
Provisioner.PlayerNotReady(player);
}
}
}
private static async Task <int> Destroy(DestroyOptions opts)
{
var response = await Provisioner.DestroyIfNeededAsync(opts.PipelinesPoolId, opts.TerraformWorkspaceId, opts.MinutesWithoutBuilds, "Destroy from CLI", opts.FileToWatch);
Console.WriteLine(response);
return(0);
}
public async Task <IActionResult> Edit(int id, [Bind("pID,Name,TelNumber")] Provisioner provisioner)
{
if (id != provisioner.pID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(provisioner);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ProvisionerExists(provisioner.pID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(provisioner));
}
private static async Task <int> ApplyIfNeeded(ApplyIfNeededOptions opts)
{
var response = await Provisioner.ApplyTerraformRunIfNeededAsync(opts.TerraformWorkspaceId);
Console.WriteLine(response);
return(0);
}
public static ProvisionerDto ProvisionerModelToDto(Provisioner model)
{
return(new ProvisionerDto()
{
Id = model.Id,
Name = model.Name
});
}
public async Task <IActionResult> Create([Bind("pID,Name,TelNumber")] Provisioner provisioner)
{
if (ModelState.IsValid)
{
_context.Add(provisioner);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(provisioner));
}
public Provisioner AddProvisioner()
{
var provisioner = new Provisioner()
{
Name = "Новый поставщик " + DateTime.Now
};
_unitOfWork.BeginTransaction();
_provisionerRepository.Create(provisioner);
_unitOfWork.Commit();
return(provisioner);
}
private static async Task <int> Create(CreateOptions opts)
{
var response = await Provisioner.EnsureThereIsAnAgentAsync(opts.PipelinesPoolId, opts.TerraformWorkspaceId, "Created from CLI");
Console.WriteLine(response);
if (response.RunId.HasValue() && opts.MinutesToWait.HasValue)
{
Console.WriteLine("Waiting for environment creation...");
var started = DateTime.UtcNow;
while ((DateTime.UtcNow - started).TotalMinutes < opts.MinutesToWait.Value)
{
var run = await Provisioner.GetTerraformRunAsync(response.RunId);
Console.WriteLine("Status: " + run.Status);
if (run.Status.IsFinished())
{
Console.WriteLine("It has finished!");
if (run.Status.IsErrored())
{
Console.WriteLine("With errors :(");
}
break;
}
await Task.Delay(5000);
}
// wait for Azure to report the agent as online
while ((DateTime.UtcNow - started).TotalMinutes < opts.MinutesToWait.Value)
{
var isOnline = await Provisioner.ThereIsAPipelineAgentRunning(opts.PipelinesPoolId);
Console.WriteLine("There is an agent online: " + isOnline);
if (isOnline)
{
break;
}
await Task.Delay(5000);
}
}
return(0);
}
/// <summary>
/// Update ingress details for the database server.
/// </summary>
/// <returns>
/// A <see cref="Task"/> representing the operation.
/// </returns>
async Task UpdateServerIngressDetails()
{
int?externalPort = await Provisioner.GetPublicPort();
if (externalPort != null)
{
string serverFQDN = $"{Provisioner.State.Name}.database.{KubeOptions.ClusterPublicFQDN}";
if (serverFQDN != Provisioner.State.PublicFQDN || externalPort != Provisioner.State.PublicPort)
{
Log.Info("Server {ServerName} is accessible at {ClusterPublicFQDN}:{PublicPortPort}",
Provisioner.State.Name,
serverFQDN,
externalPort.Value
);
DataAccess.Tell(
new ServerIngressChanged(ServerId, serverFQDN, externalPort)
);
// Capture current ingress details to enable subsequent provisioning actions (if any).
Provisioner.State.PublicFQDN = serverFQDN;
Provisioner.State.PublicPort = externalPort;
}
if (Provisioner.State.Phase == ServerProvisioningPhase.Ingress)
{
CompleteCurrentAction();
}
}
else
{
Log.Debug("Cannot determine public port for server {ServerName}.", Provisioner.State.Name);
if (Provisioner.State.PublicFQDN != null)
{
DataAccess.Tell(
new ServerIngressChanged(ServerId, publicFQDN: null, publicPort: null)
);
}
}
}
public void UpdateProvisioner(Provisioner provisioner)
{
_unitOfWork.BeginTransaction();
_provisionerRepository.Update(provisioner);
_unitOfWork.Commit();
}
/// <summary>
/// Destroy an instance of SQL Server.
/// </summary>
/// <returns>
/// A <see cref="Task"/> representing the operation.
/// </returns>
async Task DeprovisionServer()
{
switch (Provisioner.State.Phase)
{
case ServerProvisioningPhase.None:
{
goto case ServerProvisioningPhase.Ingress;
}
case ServerProvisioningPhase.Ingress:
{
StartDeprovisioningPhase(ServerProvisioningPhase.Ingress);
await Provisioner.EnsureExternalServiceAbsent();
goto case ServerProvisioningPhase.Monitoring;
}
case ServerProvisioningPhase.Monitoring:
{
StartDeprovisioningPhase(ServerProvisioningPhase.Monitoring);
await Provisioner.EnsureServiceMonitorAbsent();
goto case ServerProvisioningPhase.Network;
}
case ServerProvisioningPhase.Network:
{
StartDeprovisioningPhase(ServerProvisioningPhase.Network);
await Provisioner.EnsureInternalServiceAbsent();
goto case ServerProvisioningPhase.Instance;
}
case ServerProvisioningPhase.Instance:
{
StartDeprovisioningPhase(ServerProvisioningPhase.Instance);
await Provisioner.EnsureDeploymentAbsent();
goto case ServerProvisioningPhase.Security;
}
case ServerProvisioningPhase.Security:
{
StartDeprovisioningPhase(ServerProvisioningPhase.Security);
await CredentialsProvisioner.EnsureCredentialsSecretAbsent();
goto case ServerProvisioningPhase.Storage;
}
case ServerProvisioningPhase.Storage:
{
StartDeprovisioningPhase(ServerProvisioningPhase.Storage);
await Provisioner.EnsureDataVolumeClaimAbsent();
goto case ServerProvisioningPhase.Done;
}
case ServerProvisioningPhase.Done:
{
CompleteCurrentAction();
break;
}
}
}
/// <summary>
/// Reconfigure / repair an instance of SQL Server.
/// </summary>
/// <returns>
/// A <see cref="Task"/> representing the operation.
/// </returns>
async Task ReconfigureServer()
{
switch (Provisioner.State.Phase)
{
case ServerProvisioningPhase.None:
{
goto case ServerProvisioningPhase.Storage;
}
case ServerProvisioningPhase.Storage:
{
StartReconfigurationPhase(ServerProvisioningPhase.Storage);
await Provisioner.EnsureDataVolumeClaimPresent();
goto case ServerProvisioningPhase.Security;
}
case ServerProvisioningPhase.Security:
{
StartReconfigurationPhase(ServerProvisioningPhase.Security);
await CredentialsProvisioner.EnsureCredentialsSecretPresent();
goto case ServerProvisioningPhase.Instance;
}
case ServerProvisioningPhase.Instance:
{
StartReconfigurationPhase(ServerProvisioningPhase.Instance);
await Provisioner.EnsureDeploymentPresent();
goto case ServerProvisioningPhase.Network;
}
case ServerProvisioningPhase.Network:
{
StartReconfigurationPhase(ServerProvisioningPhase.Network);
await Provisioner.EnsureInternalServicePresent();
goto case ServerProvisioningPhase.Monitoring;
}
case ServerProvisioningPhase.Monitoring:
{
StartReconfigurationPhase(ServerProvisioningPhase.Monitoring);
await Provisioner.EnsureServiceMonitorPresent();
Become(WaitForServerAvailable); // We can't proceed until the deployment becomes available.
break;
}
case ServerProvisioningPhase.Configuration:
{
StartReconfigurationPhase(ServerProvisioningPhase.Configuration);
await Provisioner.InitialiseServerConfiguration();
goto case ServerProvisioningPhase.Ingress;
}
case ServerProvisioningPhase.Ingress:
{
StartReconfigurationPhase(ServerProvisioningPhase.Ingress);
await Provisioner.EnsureExternalServicePresent();
break;
}
// Reconfiguration completes when the server has valid Ingress details.
}
}
/// <summary>
/// Called when the actor is waiting for the server's Deployment to indicate that all replicas are Available.
/// </summary>
void WaitForServerAvailable()
{
Log.Info("Waiting for server {ServerId}'s Deployment to become Available...", ServerId);
StartPolling(Signal.PollDeployment);
ReceiveAsync <Signal>(async signal =>
{
string actionDescription;
switch (Provisioner.State.Action)
{
case ProvisioningAction.Provision:
{
actionDescription = "Provisioning";
break;
}
case ProvisioningAction.Reconfigure:
{
actionDescription = "Reconfiguration";
break;
}
case ProvisioningAction.Deprovision:
{
actionDescription = "De-provisioning";
break;
}
default:
{
return;
}
}
switch (signal)
{
case Signal.PollDeployment:
{
if (Provisioner.State.Status == ProvisioningStatus.Ready)
{
Become(Ready);
break;
}
DeploymentV1Beta1 deployment = await Provisioner.FindDeployment();
if (deployment == null)
{
Log.Warning("{Action} failed - cannot find Deployment for server {ServerId}.", actionDescription, ServerId);
FailCurrentAction(
reason: $"Cannot find server's associated Deployment in Kubernetes."
);
Become(Ready);
}
else if (deployment.Status.AvailableReplicas == deployment.Status.Replicas)
{
Log.Info("Server {ServerID} is now available ({AvailableReplicaCount} of {ReplicaCount} replicas are marked as Available).",
ServerId,
deployment.Status.AvailableReplicas,
deployment.Status.Replicas
);
// We're done with the Deployment now that it's marked as Available, so we're ready to initialise the server configuration.
if (Provisioner.State.Action == ProvisioningAction.Provision)
{
StartProvisioningPhase(ServerProvisioningPhase.Configuration);
}
else if (Provisioner.State.Action == ProvisioningAction.Reconfigure)
{
StartReconfigurationPhase(ServerProvisioningPhase.Configuration);
}
else
{
Log.Error("WaitForServerAvailable: Unexpected provisioning action '{Action}' on server {ServerId}.",
Provisioner.State.Action,
Provisioner.State.Id
);
FailCurrentAction(
reason: $"Server has unexpected provisioning action ({Provisioner.State.Action})."
);
return;
}
Become(Ready);
}
else
{
Log.Debug("Server {ServerID} is not available yet ({AvailableReplicaCount} of {ReplicaCount} replicas are marked as Available).",
ServerId,
deployment.Status.AvailableReplicas,
deployment.Status.Replicas
);
}
break;
}
case Signal.Timeout:
{
Log.Warning("{Action} failed - timed out waiting server {ServerId}'s Deployment to become ready.", actionDescription, ServerId);
FailCurrentAction(
reason: "Timed out waiting for server's associated Deployment in Kubernetes to become available."
);
Become(Ready);
break;
}
default:
{
Unhandled(signal);
break;
}
}
});
Receive <DatabaseServer>(_ =>
{
Log.Debug("Ignoring DatabaseServer state message (waiting for server's Deployment to become Available).'");
});
Receive <Terminated>(
terminated => HandleTermination(terminated)
);
}
/// <summary>
/// Adds a destroyer to destroy infrastructure from a configuration.
/// </summary>
/// <typeparam name="T">The type of configuration the destroyer
/// destroys.</typeparam>
/// <param name="destroyer">The destroyer to add.</param>
protected void AddDestroyer <T>(Provisioner <T> destroyer)
{
Add(KnownDestroyers, destroyer);
}
private static string[] InitAndTweakArgs(string[] args)
{
if (args.Length == 0)
{
return(args);
}
var position = Math.Max(Array.IndexOf(args, "-" + ConfigFileShortName), Array.IndexOf(args, "--" + ConfigFileLongName));
string configFile = null;
if (position != -1)
{
configFile = args[position + 1];
}
var pathToFile = configFile ?? Path.Join(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".PipelinesAgentManager");
var configFromFileResult = Config.TryCreateFromFile(pathToFile, out var configFromFile);
var configFromEnv = Config.CreateFromEnvironment();
Config[] configsToUse;
if (configFile.HasValue())
{
// if there's a file specified, use only that
if (configFromFileResult != Config.CreateFromFileResult.Success)
{
throw new Exception($"Could not load file {pathToFile}. Result: {configFromFileResult}");
}
if (!configFromFile.IsValid)
{
throw new Exception("Config file has missing fields. Ensure the 3 are set.");
}
configsToUse = new[] { configFromFile };
}
else
{
// use the env vars first, and only the file as backup
configsToUse = new[] { configFromEnv, configFromFile };
}
string terraformToken = null, pipelinesPAT = null, pipelinesOrg = null, defaultWorkspaceId = null;
int? defaultPoolId = null;
foreach (var config in configsToUse)
{
terraformToken ??= config.TerraformToken;
pipelinesPAT ??= config.PipelinesPAT;
pipelinesOrg ??= config.PipelinesOrg;
defaultWorkspaceId ??= config.DefaultWorkspace;
defaultPoolId ??= config.DefaultPoolId;
}
if (terraformToken.IsNullOrEmpty() || pipelinesPAT.IsNullOrEmpty() || pipelinesOrg.IsNullOrEmpty())
{
var sb = new StringBuilder("Could not retrieve values for: ");
void addToSb(string value, string name)
{
if (value.IsNullOrEmpty())
{
sb.Append(name);
sb.Append(", ");
}
}
addToSb(terraformToken, nameof(terraformToken));
addToSb(pipelinesPAT, nameof(pipelinesPAT));
addToSb(pipelinesOrg, nameof(pipelinesOrg));
sb.Length -= 2;
throw new Exception(sb.ToString());
}
Provisioner.Init(terraformToken, pipelinesPAT, pipelinesOrg);
if (defaultWorkspaceId.HasValue() || defaultPoolId.HasValue)
{
var modifiedArgs = args.ToList();
var verbType = typeof(Program)
.GetNestedTypes(System.Reflection.BindingFlags.NonPublic)
.Where(t =>
{
var verbAttributes = t.GetCustomAttributes(typeof(VerbAttribute), false);
return(verbAttributes.Length > 0 &&
verbAttributes[0] is VerbAttribute va &&
va.Name == args[0]);
})
.FirstOrDefault();
if (verbType != null)
{
var validOptions = verbType
.GetMembers()
.Where(m => m.IsDefined(typeof(OptionAttribute), false))
.Select(m => (m.GetCustomAttributes(typeof(OptionAttribute), false)[0] as OptionAttribute).ShortName)
.ToArray();
if (defaultWorkspaceId.HasValue() &&
validOptions.Contains(TerraformWorkspaceIdShortName.ToString()) &&
!args.Contains("-" + TerraformWorkspaceIdShortName) &&
!args.Contains("--" + TerraformWorkspaceIdLongName))
{
modifiedArgs.Add("-" + TerraformWorkspaceIdShortName);
modifiedArgs.Add(defaultWorkspaceId);
}
if (defaultPoolId.HasValue &&
validOptions.Contains(PipelinesPoolIdShortName.ToString()) &&
!args.Contains("-" + PipelinesPoolIdShortName) &&
!args.Contains("--" + PipelinesPoolIdLongName))
{
modifiedArgs.Add("-" + PipelinesPoolIdShortName);
modifiedArgs.Add(defaultPoolId.ToString());
}
}
args = modifiedArgs.ToArray();
}
return(args);
}
public DynamoProvisionerTests()
{
_provisioner = new Provisioner(CreateLocalStackDb(), "unittest_");
}
/// <summary>
/// Adds a provisioner to create infrastructure from a configuration.
/// </summary>
/// <typeparam name="T">The type of configuration the provisioner
/// provisions.</typeparam>
/// <param name="provisioner">The provisioner to add.</param>
protected void AddProvisioner <T>(Provisioner <T> provisioner)
{
Add(KnownProvisioners, provisioner);
}
/// <summary>
/// Adds a provisioner/destroyer to the given dictionary.
/// </summary>
/// <typeparam name="T">The type of configuration the provisioner/destroyer
/// provisions.</typeparam>
/// <param name="provisioners">The dictionary to add the provisioner/destroyer
/// to.</param>
/// <param name="provisioner">The provisioner/destroyer to add.</param>
private static void Add <T>(IDictionary provisioners, Provisioner <T> provisioner)
{
provisioners[typeof(T)] =
(Action <object, bool>)((item, dryrun) =>
provisioner((T)item, dryrun));
}
