public async Task <ProcessResult> ProcessRequestAsync(ProcessRequest request, CancellationToken token)
{
if (request is RawProcessRequest)
{
Processors.IRequestProcessor <RawProcessRequest> processor = new Processors.RawRequestProcessor(_config, _tracker, _logger);
return(await processor.ProcessRequestAsync(request as RawProcessRequest, token));
}
else if (request is FormattedProcessRequest)
{
//TODO: refactor Action vs Event -- current implementation a little confusing
FormattedProcessRequest formattedRequest = request as FormattedProcessRequest;
Processors.IRequestProcessor <FormattedProcessRequest> processor = null;
switch (formattedRequest.Action)
{
case FormattedProcessRequest.RequestedAction.Rotate:
processor = new Processors.SecretExpiringRequestProcessor(_config, _tracker, _logger);
break;
case FormattedProcessRequest.RequestedAction.Cleanup:
processor = new Processors.SecretExpiredRequestProcessor(_config, _tracker, _logger);
break;
case FormattedProcessRequest.RequestedAction.ScheduleDependencyUpdates:
processor = new Processors.ScheduleDependencyUpdatesRequestProcessor(_config, _tracker, _logger);
break;
case FormattedProcessRequest.RequestedAction.PerformDependencyUpdate:
processor = new Processors.SecretVersionCreatedRequestProcessor(_config, _tracker, _logger);
break;
}
//unknown request Action
if (null == processor)
{
throw new InvalidOperationException($"No processor has been identified for operation of type: {formattedRequest.Action}");
}
return(await processor.ProcessRequestAsync(formattedRequest, token));
}
//else if (request is SchedulingProcessRequest)
//{
// Processors.IRequestProcessor<SchedulingProcessRequest> processor = new Processors.SchedulingRequestProcessor(_config, _logger);
// return await processor.ProcessRequestAsync(request as SchedulingProcessRequest, token);
//}
//unknown request Type
throw new InvalidOperationException();
}
protected override async Task OnProcessRequestAsync(RawProcessRequest request, ProcessResult result, CancellationToken token)
{
FormattedProcessRequest fr = request.FormatRequest();
try
{
if (fr.Action == FormattedProcessRequest.RequestedAction.DoNothing)
{
result.Status |= ProcessResult.ProcessingStatus.Skipped;
Logger.LogInformation($"Event processing is being skipped. Vault Name: {fr.VaultName}. Object: {fr.ObjectName}.");
}
else
{
//THIS NEEDS TO CHANGE TO USE SHARED CLIENT to avoid Socket exceptions
await Helpers.QueueClientHelper.CreateQueueClient(Config, Config.FormattedMessagesQueueName).SendMessageAsync(fr.Serialize());
}
result.Status |= ProcessResult.ProcessingStatus.Success;
}
catch (Exception ex) //todo: filter for specific exceptions...
{
result.Status |= ProcessResult.ProcessingStatus.Failed;
result.Description = ex.Message;
}
}
protected override async Task InvokeSecretMetadataManagerMethodAsync(ISecretMetadataManager manager, FormattedProcessRequest request, CancellationToken token)
{
await manager.ProcessExpiredSecretAsync(request.ObjectUri, token);
}
protected override async Task OnRecordTransactionStartAsync(Common.Tracking.TrackingContext context)
{
Ef.Entities.Transaction tx = await _dbContext.Transactions.FirstOrDefaultAsync(t => t.TransactionId == context.Request.TransactionId);
if (null == tx)
{
string key = string.Empty, uri = string.Empty;
FormattedProcessRequest.SecretEvent evnt = FormattedProcessRequest.SecretEvent.Unknown;
FormattedProcessRequest.RequestedAction action = FormattedProcessRequest.RequestedAction.Unknown;
TransactionPurpose purpose = TransactionPurpose.Unknown;
FormattedProcessRequest fpr = context.Request as FormattedProcessRequest;
if (null == fpr)
{
fpr = (context.Request as RawProcessRequest)?.FormatRequest();
}
if (null != fpr)
{
uri = fpr.ObjectUri;
evnt = fpr.Event;
action = fpr.Action;
purpose = TransactionPurpose.ExecuteRotationProcess;
}
if (context.Request is RawProcessRequest)
{
action = FormattedProcessRequest.RequestedAction.Unknown;
purpose = TransactionPurpose.ProcessKVEvent;
}
if (!string.IsNullOrWhiteSpace(uri))
{
var s = SecretManagement.Contracts.Data.SecretBase.FromKeyvaultUri(uri);
if (null != s)
{
key = s.Key;
}
}
tx = new Ef.Entities.Transaction()
{
TransactionId = context.Request.TransactionId,
SecretKey = key,
SecretUri = uri,
Action = action,
Event = evnt,
Purpose = purpose
};
if (context.Request.ParentTransactionId != Guid.Empty)
{
tx.ParentTransaction = await _dbContext.Transactions.FirstOrDefaultAsync(t => t.TransactionId == context.Request.ParentTransactionId);
}
_dbContext.Transactions.Add(tx);
}
Ef.Entities.Attempt attempt = new Ef.Entities.Attempt()
{
StartingStatus = context.Result.Status,
StartTimeUtc = context.StartTime,
Transaction = tx
};
List <Ef.Entities.Attempt> attempts = tx.Attempts?.ToList();
if (null == attempts)
{
attempts = new List <Ef.Entities.Attempt>();
}
attempts.Add(attempt);
tx.Attempts = attempts;
_dbContext.Attempts.Add(attempt);
await _dbContext.SaveChangesAsync();
context.TrackingState.Add(this, attempt.AttemptId);
}
