public async Task InitializeAsync(CancellationToken ct)
{
var subcriptionName = new SubscriptionName(options.ProjectId, $"{options.Prefix}{topicId}");
subscriberClient = await SubscriberClient.CreateAsync(subcriptionName);
subscriberClient.StartAsync(async(pubSubMessage, subscriberToken) =>
{
try
{
var message = serializer.Deserialize <T>(pubSubMessage.Data.Span);
await consumer.HandleAsync(message, subscriberToken);
}
catch (JsonException ex)
{
log.LogError(ex, w => w
.WriteProperty("action", "ConsumeMessage")
.WriteProperty("system", "GooglePubSub")
.WriteProperty("status", "Failed")
.WriteProperty("reason", "Failed to deserialize from JSON."));
}
catch (Exception ex)
{
log.LogError(ex, w => w
.WriteProperty("action", "ConsumeMessage")
.WriteProperty("system", "GooglePubSub")
.WriteProperty("status", "Failed"));
}
return(SubscriberClient.Reply.Ack);
}).Forget();
}
private async Task <bool> MakeIdentityOperation(Func <Task <IdentityResult> > action, [CallerMemberName] string operationName = null)
{
try
{
var result = await action();
if (!result.Succeeded)
{
var errorMessageBuilder = new StringBuilder();
foreach (var error in result.Errors)
{
errorMessageBuilder.Append(error.Code);
errorMessageBuilder.Append(": ");
errorMessageBuilder.AppendLine(error.Description);
}
log.LogError(w => w
.WriteProperty("action", operationName)
.WriteProperty("status", "Failed")
.WriteProperty("message", errorMessageBuilder.ToString()));
}
return(result.Succeeded);
}
catch (Exception ex)
{
log.LogError(ex, w => w
.WriteProperty("action", operationName)
.WriteProperty("status", "Failed"));
return(false);
}
}
private void Consume(object?parameter)
{
var config = (ConsumerConfig)parameter !;
var kafkaConsumer =
new ConsumerBuilder <string, T>(config)
.SetLogHandler(KafkaLogFactory <string, T> .ConsumerLog(log))
.SetErrorHandler(KafkaLogFactory <string, T> .ConsumerError(log))
.SetStatisticsHandler(KafkaLogFactory <string, T> .ConsumerStats(log))
.SetValueDeserializer(new KafkaJsonSerializer <T>(serializer))
.Build();
using (kafkaConsumer)
{
kafkaConsumer.Subscribe(topicName);
try
{
while (!cancellationTokenSource.IsCancellationRequested)
{
try
{
var result = kafkaConsumer.Consume(cancellationTokenSource.Token);
consumer.HandleAsync(result.Message.Value, cancellationTokenSource.Token).Wait();
}
catch (OperationCanceledException)
{
return;
}
catch (JsonException ex)
{
log.LogError(ex, w => w
.WriteProperty("action", "ConsumeMessage")
.WriteProperty("system", "Kafka")
.WriteProperty("status", "Failed")
.WriteProperty("reason", "Failed to deserialize from JSON.")
.WriteProperty("topic", topicName));
}
catch (Exception ex)
{
log.LogError(ex, w => w
.WriteProperty("action", "ConsumeMessage")
.WriteProperty("system", "Kafka")
.WriteProperty("status", "Failed")
.WriteProperty("topic", topicName));
}
}
}
finally
{
kafkaConsumer.Close();
}
}
}
private async Task DumpAsync(InvocationResponse input)
{
try
{
await webhookRepository.AddInvokationAsync(input.Webhook.Id, input.Dump, input.Result, input.Elapsed);
}
catch (Exception ex)
{
log.LogError(ex, w => w
.WriteProperty("action", "DumpHook")
.WriteProperty("status", "Failed"));
}
}
private async Task QueryAsync(CancellationToken cancellationToken)
{
try
{
await webhookEventRepository.QueryPendingAsync(blockBlock.SendAsync, cancellationToken);
}
catch (Exception ex)
{
log.LogError(ex, w => w
.WriteProperty("action", "QueueWebhookEvents")
.WriteProperty("status", "Failed"));
}
}
private async Task CleanupBackupAsync(BackupStateJob job)
{
try
{
await assetStore.DeleteAsync(job.Id.ToString(), 0, null);
}
catch (Exception ex)
{
log.LogError(ex, w => w
.WriteProperty("action", "deleteBackup")
.WriteProperty("status", "failed")
.WriteProperty("backupId", job.Id.ToString()));
}
}
private async Task QueryAsync(CancellationToken cancellationToken)
{
try
{
var now = clock.GetCurrentInstant();
await ruleEventRepository.QueryPendingAsync(now, blockBlock.SendAsync, cancellationToken);
}
catch (Exception ex)
{
log.LogError(ex, w => w
.WriteProperty("action", "QueueWebhookEvents")
.WriteProperty("status", "Failed"));
}
}
public async Task QueryAsync()
{
try
{
var now = clock.GetCurrentInstant();
await ruleEventRepository.QueryPendingAsync(now, requestBlock.SendAsync);
}
catch (Exception ex)
{
log.LogError(ex, w => w
.WriteProperty("action", "QueueWebhookEvents")
.WriteProperty("status", "Failed"));
}
}
public async Task StopAsync(CancellationToken cancellationToken)
{
foreach (var initializable in initializables.OrderBy(x => x.InitializationOrder))
{
try
{
log.LogDebug(w => w
.WriteProperty("action", "ReleaseService")
.WriteProperty("status", "Started")
.WriteProperty("service", initializable.GetType().FullName));
await initializable.ReleaseAsync(cancellationToken);
log.LogInformation(w => w
.WriteProperty("action", "ReleaseService")
.WriteProperty("status", "Finished")
.WriteProperty("service", initializable.ToString()));
}
catch (Exception ex)
{
log.LogError(ex, w => w
.WriteProperty("action", "ReleaseService")
.WriteProperty("status", "Failed")
.WriteProperty("service", initializable.ToString()));
}
}
}
public async Task InvokeAsync(HttpContext context, RequestDelegate next)
{
if (context.Request.Query.TryGetValue("error", out var header) && int.TryParse(header, out var statusCode) && IsErrorStatusCode(statusCode))
{
var(error, _) = ApiExceptionConverter.ToErrorDto(statusCode, context);
await WriteErrorAsync(context, error);
return;
}
try
{
await next(context);
}
catch (Exception ex)
{
log.LogError(ex, w => w.WriteProperty("message", "An unexpected exception has occurred."));
if (!context.Response.HasStarted)
{
var(error, _) = ex.ToErrorDto(context);
await WriteErrorAsync(context, error);
}
}
if (IsErrorStatusCode(context.Response.StatusCode) && !context.Response.HasStarted)
{
var(error, _) = ApiExceptionConverter.ToErrorDto(context.Response.StatusCode, context);
await WriteErrorAsync(context, error);
}
}
public static async Task Throw(this Task <IdentityResult> task, ISemanticLog log)
{
var result = await task;
if (!result.Succeeded)
{
var errorMessageBuilder = new StringBuilder();
foreach (var error in result.Errors)
{
errorMessageBuilder.Append(error.Code);
errorMessageBuilder.Append(": ");
errorMessageBuilder.AppendLine(error.Description);
}
var errorMessage = errorMessageBuilder.ToString();
log.LogError(errorMessage, (ctx, w) => w
.WriteProperty("action", "IdentityOperation")
.WriteProperty("status", "Failed")
.WriteProperty("message", ctx));
throw new ValidationException(result.Errors.Select(x => new ValidationError(x.Description)).ToList());
}
}
private async Task SendEmailAsync(string template, string emailSubj, string emailBody, IUser user, TemplatesVars vars)
{
if (string.IsNullOrWhiteSpace(emailBody))
{
LogWarning($"No email subject configured for {template}");
return;
}
if (string.IsNullOrWhiteSpace(emailSubj))
{
LogWarning($"No email body configured for {template}");
return;
}
vars.URL = urlGenerator.UI();
vars.User = user;
emailSubj = Format(emailSubj, vars);
emailBody = Format(emailBody, vars);
try
{
await emailSender.SendAsync(user.Email, emailSubj, emailBody);
}
catch (Exception ex)
{
log.LogError(ex, w => w
.WriteProperty("action", "SendNotification")
.WriteProperty("status", "Failed"));
throw;
}
}
protected override async Task StartAsync(ISemanticLog log, CancellationToken ct)
{
IdentityModelEventSource.ShowPII = identityOptions.ShowPII;
if (identityOptions.IsAdminConfigured())
{
using (var scope = serviceProvider.CreateScope())
{
var userManager = scope.ServiceProvider.GetRequiredService <UserManager <IdentityUser> >();
var userFactory = scope.ServiceProvider.GetRequiredService <IUserFactory>();
var adminEmail = identityOptions.AdminEmail;
var adminPass = identityOptions.AdminPassword;
var isEmpty = IsEmpty(userManager);
if (isEmpty || identityOptions.AdminRecreate)
{
try
{
var user = await userManager.FindByEmailWithClaimsAsync(adminEmail);
if (user != null)
{
if (identityOptions.AdminRecreate)
{
var permissions = user.Permissions().Add(Permissions.Admin);
var values = new UserValues
{
Password = adminPass,
Permissions = permissions
};
await userManager.UpdateAsync(user.Identity, values);
}
}
else
{
var values = new UserValues
{
Email = adminEmail,
Password = adminPass,
Permissions = new PermissionSet(Permissions.Admin),
DisplayName = adminEmail
};
await userManager.CreateAsync(userFactory, values);
}
}
catch (Exception ex)
{
log.LogError(ex, w => w
.WriteProperty("action", "createAdmin")
.WriteProperty("status", "failed"));
}
}
}
}
}
public async Task InvokeAsync(HttpContext context, IActionResultExecutor <ObjectResult> writer, ISemanticLog log)
{
if (TryGetErrorCode(context, out var statusCode) && IsErrorStatusCode(statusCode))
{
var(error, _) = ApiExceptionConverter.ToErrorDto(statusCode, context);
await WriteErrorAsync(context, error, writer);
return;
}
try
{
await next(context);
}
catch (Exception ex)
{
log.LogError(ex, w => w.WriteProperty("message", "An unexpected exception has occurred."));
if (!context.Response.HasStarted)
{
var(error, _) = ex.ToErrorDto(context);
await WriteErrorAsync(context, error, writer);
}
}
if (IsErrorStatusCode(context.Response.StatusCode) && !context.Response.HasStarted)
{
var(error, _) = ApiExceptionConverter.ToErrorDto(context.Response.StatusCode, context);
await WriteErrorAsync(context, error, writer);
}
}
private async Task TryPublishAsync(IContentEntity content)
{
var id = content.Id;
try
{
var job = content.ScheduleJob;
if (job != null)
{
var command = new ChangeContentStatus
{
Actor = job.ScheduledBy,
AppId = content.AppId,
ContentId = id,
SchemaId = content.SchemaId,
Status = job.Status,
StatusJobId = job.Id
};
await commandBus.PublishAsync(command);
}
}
catch (DomainObjectNotFoundException)
{
await contentRepository.ResetScheduledAsync(content.UniqueId, default);
}
catch (Exception ex)
{
log.LogError(ex, content.Id.ToString(), (logContentId, w) => w
.WriteProperty("action", "ChangeStatusScheduled")
.WriteProperty("status", "Failed")
.WriteProperty("contentId", logContentId));
}
}
public Task PublishAsync()
{
var now = clock.GetCurrentInstant();
return(contentRepository.Value.QueryScheduledWithoutDataAsync(now, content =>
{
return Dispatch(async() =>
{
try
{
var job = content.ScheduleJob;
if (job != null)
{
var command = new ChangeContentStatus {
ContentId = content.Id, Status = job.Status, Actor = job.ScheduledBy, JobId = job.Id
};
await commandBus.Value.PublishAsync(command);
}
}
catch (Exception ex)
{
log.LogError(ex, content.Id.ToString(), (logContentId, w) => w
.WriteProperty("action", "ChangeStatusScheduled")
.WriteProperty("status", "Failed")
.WriteProperty("contentId", logContentId));
}
});
}));
}
public void Publish(string token, bool notifySelf)
{
try
{
var message = string.Join("#", (notifySelf ? Guid.Empty : InstanceId).ToString(), token);
subscriber.Publish(channelName, message);
}
catch (Exception ex)
{
log.LogError(ex, w => w
.WriteProperty("action", "PublishRedisMessage")
.WriteProperty("state", "Failed")
.WriteProperty("token", token));
}
}
public async Task <IdentityResult> ValidateAsync(UserManager <IdentityUser> manager, IdentityUser user, string password)
{
if (string.IsNullOrWhiteSpace(password))
{
return(IdentityResult.Success);
}
try
{
var isBreached = await client.IsPasswordPwned(password);
if (isBreached)
{
var errorText = T.Get("security.passwordStolen");
return(IdentityResult.Failed(new IdentityError {
Code = "PwnedError", Description = errorText
}));
}
}
catch (Exception ex)
{
log.LogError(ex, w => w
.WriteProperty("operation", "CheckPasswordPwned")
.WriteProperty("status", "Failed"));
}
return(IdentityResult.Success);
}
private async Task ProcessAsync(State currentState, CancellationToken ct)
{
try
{
currentReminder = await RegisterOrUpdateReminder("KeepAlive", TimeSpan.Zero, TimeSpan.FromMinutes(2));
var rules = await appProvider.GetRulesAsync(DomainId.Create(Key));
var rule = rules.Find(x => x.Id == currentState.RuleId);
if (rule == null)
{
throw new InvalidOperationException("Cannot find rule.");
}
using (localCache.StartContext())
{
if (currentState.FromSnapshots && ruleService.CanCreateSnapshotEvents(rule.RuleDef))
{
await EnqueueFromSnapshotsAsync(rule);
}
else
{
await EnqueueFromEventsAsync(currentState, rule, ct);
}
}
}
catch (OperationCanceledException)
{
return;
}
catch (Exception ex)
{
log.LogError(ex, w => w
.WriteProperty("action", "runRule")
.WriteProperty("status", "failed")
.WriteProperty("ruleId", currentState.RuleId?.ToString()));
}
finally
{
if (!isStopping)
{
currentState.RuleId = null;
currentState.Position = null;
await state.WriteAsync();
if (currentReminder != null)
{
await UnregisterReminder(currentReminder);
currentReminder = null;
}
currentJobToken?.Dispose();
currentJobToken = null;
}
}
}
private void Log(IIncomingGrainCallContext context, Exception ex)
{
log.LogError(ex, w => w
.WriteProperty("action", "GrainInvoked")
.WriteProperty("status", "Failed")
.WriteProperty("grain", context.Grain.ToString())
.WriteProperty("grainMethod", context.ImplementationMethod.ToString()));
}
private async Task UpsertUserAsync(IUser user)
{
if (client == null)
{
return;
}
try
{
var settings = new Dictionary <string, NotificationSettingDto>
{
[Providers.WebPush] = new NotificationSettingDto
{
Send = NotificationSend.Send,
DelayInSeconds = null
},
[Providers.Email] = new NotificationSettingDto
{
Send = NotificationSend.Send,
DelayInSeconds = 5 * 60
}
};
var userRequest = new UpsertUserDto
{
Id = user.Id,
FullName = user.Claims.DisplayName(),
PreferredLanguage = "en",
PreferredTimezone = null,
Settings = settings
};
if (user.Email.IsEmail())
{
userRequest.EmailAddress = user.Email;
}
var response = await client.Users.PostUsersAsync(options.AppId, new UpsertUsersDto
{
Requests = new List <UpsertUserDto>
{
userRequest
}
});
var apiKey = response.First().ApiKey;
await userResolver.SetClaimAsync(user.Id, SquidexClaimTypes.NotifoKey, response.First().ApiKey, true);
}
catch (Exception ex)
{
log.LogError(ex, w => w
.WriteProperty("action", "RegisterToNotifo")
.WriteProperty("status", "Failed"));
}
}
public async Task <IActionResult> GetUsers(string query)
{
try
{
var users = await userResolver.QueryByEmailAsync(query);
var response = users.Where(x => !x.IsHidden()).Select(x => UserDto.FromUser(x, this)).ToArray();
return(Ok(response));
}
catch (Exception ex)
{
log.LogError(ex, w => w
.WriteProperty("action", nameof(GetUsers))
.WriteProperty("status", "Failed"));
}
return(Ok(new UserDto[0]));
}
public void Publish(object value, bool notifySelf)
{
try
{
var senderId = notifySelf ? Guid.Empty : selfId;
var envelope = JsonConvert.SerializeObject(new Envelope {
Sender = senderId, Payload = (T)value
});
subscriber.Publish(channelName, envelope);
}
catch (Exception ex)
{
log.LogError(ex, w => w
.WriteProperty("action", "PublishRedisMessage")
.WriteProperty("status", "Failed")
.WriteProperty("channel", channelName));
}
}
private async Task ExecuteCommandAsync(BulkTaskCommand bulkCommand)
{
var(task, id, command) = bulkCommand;
try
{
await task.Bus.PublishAsync(command);
task.Results.Add(new BulkUpdateResultItem(id, task.JobIndex));
}
catch (Exception ex)
{
log.LogError(ex, w => w
.WriteProperty("action", "BulkContent")
.WriteProperty("status", "Failed")
.WriteProperty("jobIndex", task.JobIndex)
.WriteProperty("jobType", task.CommandJob.Type.ToString()));
task.Results.Add(new BulkUpdateResultItem(id, task.JobIndex, ex));
}
}
private async Task <Envelope <IEvent> > HandleAsync(Envelope <IEvent> input)
{
var eventNumber = input.Headers.EventNumber();
if (eventNumber <= lastReceivedEventNumber || !isRunning)
{
return(null);
}
var consumerName = eventConsumer.Name;
var eventId = input.Headers.EventId().ToString();
var eventType = input.Payload.GetType().Name;
try
{
log.LogInformation(w => w
.WriteProperty("action", "HandleEvent")
.WriteProperty("actionId", eventId)
.WriteProperty("state", "Started")
.WriteProperty("eventId", eventId)
.WriteProperty("eventType", eventType)
.WriteProperty("eventConsumer", consumerName));
await eventConsumer.On(input);
log.LogInformation(w => w
.WriteProperty("action", "HandleEvent")
.WriteProperty("actionId", eventId)
.WriteProperty("state", "Completed")
.WriteProperty("eventId", eventId)
.WriteProperty("eventType", eventType)
.WriteProperty("eventConsumer", consumerName));
lastReceivedEventNumber = eventNumber;
return(input);
}
catch (Exception ex)
{
OnError?.Invoke(ex);
log.LogError(ex, w => w
.WriteProperty("action", "HandleEvent")
.WriteProperty("actionId", eventId)
.WriteProperty("state", "Started")
.WriteProperty("eventId", eventId)
.WriteProperty("eventType", eventType)
.WriteProperty("eventConsumer", consumerName));
return(null);
}
}
public async Task SendAsync(UserNotification notification, NotificationSetting setting, User user, App app, bool isUpdate, CancellationToken ct = default)
{
try
{
await streamClient.SendAsync(notification);
}
catch (Exception ex)
{
log.LogError(ex, w => w
.WriteProperty("action", "SendWeb")
.WriteProperty("status", "Failed"));
}
}
public async Task InvokeAsync(HttpContext context, RequestDelegate next)
{
try
{
await next(context);
}
catch (Exception ex)
{
log.LogError(ex, w => w.WriteProperty("messag", "An unexpected exception has occurred."));
context.Response.StatusCode = 500;
}
}
private async Task ExecuteInlineAsync(string key, T job)
{
try
{
if (currentHandler != null)
{
await currentHandler.HandleAsync(new List <T> {
job
}, false, default);
}
}
catch (Exception ex)
{
log.LogError(ex, w => w
.WriteProperty("action", "HandleJob")
.WriteProperty("status", "Failed"));
var nextTime = Now.Plus(Duration.FromMinutes(5));
await schedulerStore.EnqueueScheduledAsync(key, job, nextTime, 1);
}
}
public static async Task DeleteAsync(IAssetStore assetStore, string id, ISemanticLog log)
{
try
{
await assetStore.DeleteAsync(id, 0, null);
}
catch (Exception ex)
{
log.LogError(ex, id, (logOperationId, w) => w
.WriteProperty("action", "deleteBackup")
.WriteProperty("status", "failed")
.WriteProperty("operationId", logOperationId));
}
}
public static async Task CleanupRestoreErrorAsync(BackupHandler handler, Guid appId, Guid id, ISemanticLog log)
{
try
{
await handler.CleanupRestoreErrorAsync(appId);
}
catch (Exception ex)
{
log.LogError(ex, id.ToString(), (logOperationId, w) => w
.WriteProperty("action", "cleanupRestore")
.WriteProperty("status", "failed")
.WriteProperty("operationId", logOperationId));
}
}
