private ResolvedEvent?ResolveLinkToEvent(EventRecord eventRecord, ClaimsPrincipal user, long?commitPosition)
{
if (eventRecord.EventType == SystemEventTypes.LinkTo)
{
try {
var linkPayload = Helper.UTF8NoBom.GetString(eventRecord.Data.Span);
var parts = linkPayload.Split(LinkToSeparator, 2);
if (long.TryParse(parts[0], out long eventNumber))
{
var streamId = parts[1];
var res = _readIndex.ReadEvent(streamId, eventNumber);
if (res.Result == ReadEventResult.Success)
{
return(ResolvedEvent.ForResolvedLink(res.Record, eventRecord, commitPosition));
}
return(ResolvedEvent.ForFailedResolvedLink(eventRecord, res.Result, commitPosition));
}
Log.Warning($"Invalid link event payload [{linkPayload}]: {eventRecord}");
return(ResolvedEvent.ForUnresolvedEvent(eventRecord, commitPosition));
} catch (Exception exc) {
Log.Error(exc, "Error while resolving link for event record: {eventRecord}",
eventRecord.ToString());
}
// return unresolved link
return(ResolvedEvent.ForFailedResolvedLink(eventRecord, ReadEventResult.Error, commitPosition));
}
return(ResolvedEvent.ForUnresolvedEvent(eventRecord, commitPosition));
}
private void InitializeSwaggerMetadata()
{
SwaggerMetadataProvider.SetInfo("Fabric Authorization API", "v1",
"Fabric.Authorization contains a set of APIs that allow client applications to manage roles and permissions for users.");
var securitySchemeBuilder = new Oauth2SecuritySchemeBuilder();
securitySchemeBuilder.Flow(Oauth2Flows.Implicit);
securitySchemeBuilder.Description("Authentication with Fabric.Identity");
securitySchemeBuilder.AuthorizationUrl(@"http://localhost:5001");
securitySchemeBuilder.Scope("fabric/authorization.read", "Grants read access to fabric.authorization resources.");
securitySchemeBuilder.Scope("fabric/authorization.write", "Grants write access to fabric.authorization resources.");
securitySchemeBuilder.Scope("fabric/authorization.manageclients", "Grants 'manage clients' access to fabric.authorization resources.");
securitySchemeBuilder.Scope("fabric/authorization.dos.write", "Grants write access to fabric.authorization.dos resources.");
try
{
SwaggerMetadataProvider.SetSecuritySchemeBuilder(securitySchemeBuilder, "fabric.identity");
}
catch (ArgumentException ex)
{
_logger.Warning("Error configuring Swagger Security Scheme. {exceptionMessage}", ex.Message);
}
catch (NullReferenceException ex)
{
_logger.Warning("Error configuring Swagger Security Scheme: {exceptionMessage", ex.Message);
}
}
private void StartComponents()
{
if (_nodeState != VNodeState.Leader)
{
_logger.Debug("PROJECTIONS SUBSYSTEM: Not starting because node is not leader. Current node state: {nodeState}",
_nodeState);
return;
}
if (_subsystemState != SubsystemState.Ready && _subsystemState != SubsystemState.Stopped)
{
_logger.Debug("PROJECTIONS SUBSYSTEM: Not starting because system is not ready or stopped. Current Subsystem state: {subsystemState}",
_subsystemState);
return;
}
if (_runningComponentCount > 0)
{
_logger.Warning("PROJECTIONS SUBSYSTEM: Subsystem is stopped, but components are still running.");
return;
}
_subsystemState = SubsystemState.Starting;
_restarting = false;
_instanceCorrelationId = Guid.NewGuid();
_logger.Information("PROJECTIONS SUBSYSTEM: Starting components for Instance: {instanceCorrelationId}", _instanceCorrelationId);
_pendingComponentStarts = _componentCount;
_leaderMainBus.Publish(new ProjectionSubsystemMessage.StartComponents(_instanceCorrelationId));
}
private IList <JobLogDB.EventLogMaterial> FindOrCreateMaterial(int pallet, int fixturenum, DateTime endUTC, string order, string part, int process, int count)
{
var rows = _status.FindMaterialIDs(pallet, fixturenum, endUTC);
if (rows.Count == 0)
{
Log.Warning("Unable to find any material ids for pallet " + pallet.ToString() + "-" +
fixturenum.ToString() + " for order " + order + " for event at time " + endUTC.ToString());
rows = _status.CreateMaterialIDs(pallet, fixturenum, endUTC, order, AllocateMatIds(count, order, part, process), 0);
}
if (rows[0].Order != order)
{
Log.Warning("MaterialIDs for pallet " + pallet.ToString() + "-" + fixturenum.ToString() +
" for event at time " + endUTC.ToString() + " does not have matching orders: " +
"expected " + order + " but found " + rows[0].Order);
rows = _status.CreateMaterialIDs(pallet, fixturenum, endUTC, order, AllocateMatIds(count, order, part, process), 0);
}
if (rows.Count < count)
{
Log.Warning("Pallet " + pallet.ToString() + "-" + fixturenum.ToString() +
" at event time " + endUTC.ToString() + " with order " + order + " was expected to have " +
count.ToString() + " material ids, but only " + rows.Count + " were loaded");
int maxCounter = -1;
foreach (var row in rows)
{
if (row.LocCounter > maxCounter)
{
maxCounter = row.LocCounter;
}
}
//stupid that IList doesn't have AddRange
foreach (var row in _status.CreateMaterialIDs(
pallet, fixturenum, rows[0].LoadedUTC, order, AllocateMatIds(count - rows.Count, order, part, process), maxCounter + 1))
{
rows.Add(row);
}
}
var ret = new List <JobLogDB.EventLogMaterial>();
foreach (var row in rows)
{
if (Settings.SerialType != SerialType.NoAutomaticSerials)
{
CreateSerial(row.MatID, order, part, process, fixturenum.ToString(), _log, Settings);
}
ret.Add(new JobLogDB.EventLogMaterial()
{
MaterialID = row.MatID, Process = process, Face = ""
});
}
return(ret);
}
private void OnConnectionBlocked(object sender, ConnectionBlockedEventArgs e)
{
if (_disposed)
{
return;
}
_logger.Warning("A RabbitMQ connection is shutdown. Trying to re-connect...");
TryConnect();
}
private void ReadUserDataCompleted(ClientMessage.ReadStreamEventsBackwardCompleted completed,
AuthenticationRequest authenticationRequest)
{
try {
if (completed.Result == ReadStreamResult.StreamDeleted ||
completed.Result == ReadStreamResult.NoStream ||
completed.Result == ReadStreamResult.AccessDenied)
{
if (_logFailedAuthenticationAttempts)
{
Log.Warning("Authentication Failed for {id}: {reason}", authenticationRequest.Id, "Invalid user.");
}
authenticationRequest.Unauthorized();
return;
}
if (completed.Result == ReadStreamResult.Error)
{
if (_logFailedAuthenticationAttempts)
{
Log.Warning("Authentication Failed for {id}: {reason}", authenticationRequest.Id,
"The system is not ready.");
}
authenticationRequest.NotReady();
return;
}
var userData = completed.Events[0].Event.Data.ParseJson <UserData>();
if (userData.LoginName != authenticationRequest.Name)
{
authenticationRequest.Error();
return;
}
if (userData.Disabled)
{
if (_logFailedAuthenticationAttempts)
{
Log.Warning("Authentication Failed for {id}: {reason}", authenticationRequest.Id,
"The account is disabled.");
}
authenticationRequest.Unauthorized();
}
else
{
AuthenticateWithPasswordHash(authenticationRequest, userData);
}
} catch {
authenticationRequest.Unauthorized();
}
}
private async Task ProcessWorkItemsChanged(IEnumerable <OutputMapping1GetListValues> workItemsChanged,
RemedyPollResult result, DateTime timestampUtc)
{
Stopwatch watch = new Stopwatch();
watch.Start();
int count = 0;
foreach (var workItem in workItemsChanged)
{
_logger.Information("Processing workItemChanged for id {InstanceId}", workItem.InstanceId);
// We can do the next line because this service will always be in the same time zone as Remedy
DateTime lastModifiedDateUtc = workItem.Last_Modified_Date.ToUniversalTime();
if (lastModifiedDateUtc <= timestampUtc)
{
_logger.Warning($"WorkItem { workItem.Web_Incident_ID} has a last modified date less than or equal to our cutoff time, so ignoring ({ lastModifiedDateUtc } <= { timestampUtc }");
continue;
}
Exception error = null;
try
{
await TryProcessIssue(workItem);
}
catch (Exception err)
{
error = err;
}
if (error == null)
{
result.RecordsProcesed.Add(workItem);
}
else
{
result.ProcessErrors.Add(new ProcessError()
{
WorkItem = workItem,
ErrorMessage = error.Message
});
}
count++;
}
TimeSpan avg = count > 0 ? watch.Elapsed / count : TimeSpan.Zero;
_logger.Information($"Processed { count } work item changes in { watch.Elapsed }. Average = { avg.TotalMilliseconds }ms/record ");
}
public async Task SaveWorkLog(WorkLog workLog)
{
// Check if employment exists between two users
if (!await _unitOfWork.Employments.EmploymentExists(workLog.EmployerId, workLog.EmployeeId))
{
Log.Warning("Trying to log work for users that have no employment relationship." +
" employer:{}, employee:{}", workLog.EmployerId, workLog.EmployeeId);
throw new EntityNotFoundException("Could not find employment info with those two users");
}
await _unitOfWork.WorkLogs.AddWorkLog(workLog);
await _unitOfWork.CompleteAsync();
}
public static void LogApiFailure(this Serilog.ILogger logger, DelegateResult <HttpResponseMessage> result, TimeSpan timeSpan, int retryCount, Context context)
{
if (result.Exception != null)
{
logger.Warning(result.Exception, "An exception occurred on retry {RetryAttempt} for {PolicyKey} - Retrying in {SleepDuration}ms",
retryCount, context.PolicyKey, timeSpan.TotalMilliseconds);
}
else
{
logger.Warning("A non success code {StatusCode} with reason {Reason} and content {Content} was received on retry {RetryAttempt} for {PolicyKey} - Retrying in {SleepDuration}ms",
(int)result.Result.StatusCode, result.Result.ReasonPhrase,
result.Result.Content?.ReadAsStringAsync().GetAwaiter().GetResult(),
retryCount, context.PolicyKey, timeSpan.TotalMilliseconds);
}
}
public void Log(LogEntry entry)
{
switch (entry.Severity)
{
case LoggingEventType.Verbose:
_logger.Verbose(entry.Exception, entry.Message, entry.Args);
break;
case LoggingEventType.Debug:
_logger.Debug(entry.Exception, entry.Message, entry.Args);
break;
case LoggingEventType.Information:
_logger.Information(entry.Exception, entry.Message, entry.Args);
break;
case LoggingEventType.Warning:
_logger.Warning(entry.Exception, entry.Message, entry.Args);
break;
case LoggingEventType.Error:
_logger.Error(entry.Exception, entry.Message, entry.Args);
break;
case LoggingEventType.Fatal:
_logger.Fatal(entry.Exception, entry.Message, entry.Args);
break;
default:
throw new ArgumentException($"Severity {entry.Severity} is not supported by SerilogAdapter", "Severity");
}
}
/// <summary>
/// Logs the specified log event.
/// </summary>
/// <param name="logEvent">The <see cref="T:Swan.LogMessageReceivedEventArgs" /> instance containing the event data.</param>
public void Log(LogMessageReceivedEventArgs logEvent)
{
switch (logEvent.MessageType)
{
case LogLevel.None:
break;
case LogLevel.Info:
_logger.Information("{@logEvent}", logEvent);
break;
case LogLevel.Trace:
_logger.Verbose("{@logEvent}", logEvent);
break;
case LogLevel.Debug:
_logger.Debug("{@logEvent}", logEvent);
break;
case LogLevel.Warning:
_logger.Warning("{@logEvent}", logEvent);
break;
case LogLevel.Error:
_logger.Error("{@logEvent}", logEvent);
break;
case LogLevel.Fatal:
_logger.Fatal("{@logEvent}", logEvent);
break;
}
}
private IModel CreateConsumerChannel(Serilog.ILogger logger)
{
if (!_persistentConnection.IsConnected)
{
_persistentConnection.TryConnect();
}
logger.Information("Creating RabbitMQ consumer channel");
var channel = _persistentConnection.CreateModel();
channel.ExchangeDeclare(exchange: BROKER_NAME,
type: "direct");
channel.QueueDeclare(queue: _queueName,
durable: true,
exclusive: false,
autoDelete: false,
arguments: null);
channel.CallbackException += (sender, ea) =>
{
logger.Warning($"Recreating RabbitMQ consumer channel {ea.Exception}");
_consumerChannel.Dispose();
_consumerChannel = CreateConsumerChannel(logger);
StartBasicConsume();
};
return(channel);
}
public bool WriteCore(TraceEventType eventType, int eventId, object state, Exception exception, Func <object, Exception, string> formatter)
{
var log = new OwinContextLog(eventId, formatter(state, exception));
switch (eventType)
{
case TraceEventType.Critical:
_logger.Fatal(exception, SerilogMessage, log);
return(true);
case TraceEventType.Error:
_logger.Error(exception, SerilogMessage, log);
return(true);
case TraceEventType.Information:
_logger.Information(exception, SerilogMessage, log);
return(true);
case TraceEventType.Warning:
_logger.Warning(exception, SerilogMessage, log);
return(true);
case TraceEventType.Verbose:
_logger.Verbose(exception, SerilogMessage, log);
return(true);
default:
return(false);
}
}
private bool ProcessWorkItemWithLogging(WorkItemData sourceWorkItemData, int current, int totalWorkItem)
{
var sourceWorkItem = TfsExtensions.ToWorkItem(sourceWorkItemData);
workItemLog = contextLog.ForContext("SourceWorkItemId", sourceWorkItem.Id);
using (LogContext.PushProperty("sourceWorkItemTypeName", sourceWorkItem.Type.Name))
using (LogContext.PushProperty("currentWorkItem", current))
using (LogContext.PushProperty("totalWorkItems", totalWorkItem))
using (LogContext.PushProperty("sourceWorkItemId", sourceWorkItem.Id))
using (LogContext.PushProperty("sourceRevisionInt", sourceWorkItem.Revision))
using (LogContext.PushProperty("targetWorkItemId", null))
{
ProcessWorkItem(sourceWorkItemData, _config.WorkItemCreateRetryLimit);
if (_config.PauseAfterEachWorkItem)
{
Console.WriteLine("Do you want to continue? (y/n)");
if (Console.ReadKey().Key != ConsoleKey.Y)
{
workItemLog.Warning("USER ABORTED");
return(false);
}
}
}
return(true);
}
/// <summary>
/// Write a message with the given severity to the logs. Takes a StringBuilder to allow for minimal allocation.
/// </summary>
/// <param name="logLevel">The severity level of the log message.</param>
/// <param name="logMessage">The log message itself in StringBuilder form for manipulation.</param>
/// <param name="callerName">The name of the calling method.</param>
/// <param name="callerSourceFile">The name of the source file of the caller.</param>
/// <param name="callerLineNumber">The line number where the log is being called.</param>
private void Write(
LogLevel logLevel,
StringBuilder logMessage,
[CallerMemberName] string callerName = null,
[CallerFilePath] string callerSourceFile = null,
[CallerLineNumber] int callerLineNumber = 0)
{
string indentedLogMsg = IndentMsg(logMessage);
string logLevelName = logLevel.ToString().ToUpper();
int threadId = Thread.CurrentThread.ManagedThreadId;
switch (logLevel)
{
case LogLevel.Diagnostic:
_logger.Verbose(s_logMessageTemplate, logLevelName, threadId, callerName, callerSourceFile, callerLineNumber, indentedLogMsg);
return;
case LogLevel.Verbose:
_logger.Debug(s_logMessageTemplate, logLevelName, threadId, callerName, callerSourceFile, callerLineNumber, indentedLogMsg);
return;
case LogLevel.Normal:
_logger.Information(s_logMessageTemplate, logLevelName, threadId, callerName, callerSourceFile, callerLineNumber, indentedLogMsg);
return;
case LogLevel.Warning:
_logger.Warning(s_logMessageTemplate, logLevelName, threadId, callerName, callerSourceFile, callerLineNumber, indentedLogMsg);
return;
case LogLevel.Error:
_logger.Error(s_logMessageTemplate, logLevelName, threadId, callerName, callerSourceFile, callerLineNumber, indentedLogMsg);
return;
}
}
private void EventSource_Event(string projectFile, BuildEventArgs e, ErrorLevel errorLevel)
{
try
{
if (e.BuildEventContext.IsBuildEventContextInvalid())
{
return;
}
if (projectFile == null)
{
return;
}
if (!_projectsLookup.TryGetValue(projectFile, out var projectEntry))
{
_logger.Warning("Project entry not found by ProjectFile='{ProjectFile}'.", projectFile);
return;
}
if (projectEntry.IsInvalid)
{
return;
}
OnErrorRaised(projectEntry, e, errorLevel);
}
catch (Exception ex)
{
_logger.Error(ex, "Error during eventsource_raised.");
}
}
private void PublishWriteStreamMetadataAndCheckpointEventDelayed()
{
var attempt = _inCheckpointWriteAttempt;
var delayInSeconds = CalculateBackoffTimeSecs(attempt);
if (delayInSeconds == 0)
{
PublishWriteStreamMetadataAndCheckpointEvent();
}
else
{
if (attempt >= MinAttemptWarnThreshold && _logger != null)
{
_logger.Warning("Attempt: {attempt} to write checkpoint for {projection} at {requestedCheckpointPosition} with expected version number {lastWrittenCheckpointEventNumber}. Backing off for {time} second(s).",
attempt,
_name,
_requestedCheckpointPosition,
_lastWrittenCheckpointEventNumber,
delayInSeconds);
}
_ioDispatcher.Delay(
TimeSpan.FromSeconds(delayInSeconds),
PublishWriteStreamMetadataAndCheckpointEvent);
}
}
public void Log(object sender, LogEventArgs e)
{
switch (e.Severity)
{
case LogSeverity.Debug:
var debugMsg = CreatetMessage(e.Message);
_logger.Debug(debugMsg);
break;
case LogSeverity.Info:
var infoMsg = CreatetMessage(e.Message);
_logger.Information(infoMsg);
break;
case LogSeverity.Warning:
var warningMsg = CreatetMessage(e.Message);
_logger.Warning(warningMsg);
break;
case LogSeverity.Error:
var errorMsg = CreatetMessage(e.Message, e.Exception);
_logger.Error(errorMsg);
break;
case LogSeverity.Fatal:
var fatalMsg = CreatetMessage(e.Message);
_logger.Fatal(fatalMsg);
break;
}
}
public async Task StopAsync(TimeSpan?timeout = null, CancellationToken cancellationToken = default)
{
if (Interlocked.Exchange(ref _stopCalled, 1) == 1)
{
Log.Warning("Stop was already called.");
return;
}
timeout ??= TimeSpan.FromSeconds(5);
_mainQueue.Publish(new ClientMessage.RequestShutdown(false, true));
if (_subsystems != null)
{
foreach (var subsystem in _subsystems)
{
subsystem.Stop();
}
}
var cts = new CancellationTokenSource();
await using var _ = cts.Token.Register(() => _shutdownSource.TrySetCanceled(cancellationToken));
cts.CancelAfter(timeout.Value);
await _shutdownSource.Task.ConfigureAwait(false);
}
private IList <JobLogDB.EventLogMaterial> FindMaterial(string pal, IReadOnlyList <LogEntry> oldEvts = null)
{
if (oldEvts == null)
{
oldEvts = _log.CurrentPalletLog(pal);
}
for (int i = oldEvts.Count - 1; i >= 0; i--)
{
if (oldEvts[i].Material.Count() > 0)
{
return(oldEvts[i].Material.Select(JobLogDB.EventLogMaterial.FromLogMat).ToList());
}
}
Log.Warning("Unable to find existing material for pallet {pal}", pal);
var matId = _log.AllocateMaterialID("", "", 1);
return(new[] {
new JobLogDB.EventLogMaterial()
{
MaterialID = matId,
Process = 1,
Face = "",
}
});
}
private Task Log(LogMessage logMessage)
{
switch (logMessage.Severity)
{
case LogSeverity.Critical:
_logger.Fatal(logMessage.ToString());
break;
case LogSeverity.Error:
_logger.Error(logMessage.ToString());
break;
case LogSeverity.Warning:
_logger.Warning(logMessage.ToString());
break;
case LogSeverity.Info:
_logger.Information(logMessage.ToString());
break;
case LogSeverity.Verbose:
case LogSeverity.Debug:
_logger.Debug(logMessage.ToString());
break;
default:
_logger.Fatal(logMessage.ToString());
break;
}
return(Task.CompletedTask);
}
void OnConnectionErrorOccurred(object sender, ClientErrorEventArgs args)
{
Log.Error(args.Exception,
"EventStore connection with id = {ConnectionId} error occured",
args.Connection.ConnectionName);
_onError?.Invoke(args.Exception);
var exception = (args.Exception as AggregateException)?.GetBaseException() ?? args.Exception;
switch (exception)
{
case RetriesLimitReachedException retriesLimitReached:
Log.Fatal(
"EventStore connection's limit of reconnection or operation retries reached. " +
"Stopping service...",
retriesLimitReached);
_onFatalFailure();
break;
case ClusterException clusterException:
Log.Fatal(
"EventStore connection could not establish link with EventStore cluster. " +
"Maximum number of cluster connection attempts reached. " +
"Stopping service...",
clusterException);
_onFatalFailure();
break;
default:
Log.Warning(exception, "");
break;
}
}
public async Task <bool> CreateUserAsync(ApplicationUser user, Role role)
{
// Find role
var appRole = await _roleManager.FindByNameAsync(ApplicationRole.GetRoleName(role));
if (appRole == null)
{
Log.Warning("Trying to add user: {user} into non-existing role: {role}", user, role);
throw new EntityNotFoundException($"Role does not exist");
}
// Create user
user.EmailConfirmed = false;
user.EmailConfirmationCode = StringGenerator.GetRandomString(16);
var createResult = await _userManager.CreateAsync(user, StringGenerator.GetRandomString(16));
if (!createResult.Succeeded)
{
Log.Information("Could not create user: {createResult.Errors.ToList()}", createResult.Errors.ToList());
return(false);
}
// Assign user to role
var addToRoleResult = await _userManager.AddToRoleAsync(user, appRole.Name);
return(addToRoleResult.Succeeded);
// TODO: send mail
// Send email to user with his email confirmation code
}
private EnvDTE.Window TryOpenFile(string localPath, string viewKind = EnvDTE.Constants.vsViewKindCode)
{
try {
ThreadHelper.ThrowIfNotOnUIThread();
var dte = _serviceProvider.GetService(typeof(DTE)) as DTE;
if (dte == null)
{
Log.Error($"{nameof(dte)} is null for {localPath}");
return(null);
}
var window = dte.ItemOperations.OpenFile(localPath, viewKind);
return(window);
}
catch (ArgumentException ex) {
if (ex?.Message?.Contains("The parameter is incorrect") == true)
{
Log.Warning(ex, $"{localPath} may not exist");
}
else
{
Log.Warning(ex, $"{localPath}");
}
}
catch (Exception ex) {
Log.Error(ex, $"{localPath}");
}
return(null);
}
private void ReadNotificationsFrom(long fromEventNumber)
{
if (_stopped)
{
return;
}
_ioDispatcher.ReadForward(
UserManagementService.UserPasswordNotificationsStreamId, fromEventNumber, 100, false,
SystemAccounts.System, completed => {
if (_stopped)
{
return;
}
switch (completed.Result)
{
case ReadStreamResult.AccessDenied:
case ReadStreamResult.Error:
case ReadStreamResult.NotModified:
_log.Error("Failed to read: {stream} completed.Result={e}",
UserManagementService.UserPasswordNotificationsStreamId, completed.Result.ToString());
_ioDispatcher.Delay(
TimeSpan.FromSeconds(10), () => ReadNotificationsFrom(fromEventNumber));
break;
case ReadStreamResult.NoStream:
case ReadStreamResult.StreamDeleted:
_ioDispatcher.Delay(
TimeSpan.FromSeconds(1), () => ReadNotificationsFrom(0));
break;
case ReadStreamResult.Success:
foreach (var @event in completed.Events)
{
PublishPasswordChangeNotificationFrom(@event);
}
if (completed.IsEndOfStream)
{
_ioDispatcher.Delay(
TimeSpan.FromSeconds(1), () => ReadNotificationsFrom(completed.NextEventNumber));
}
else
{
ReadNotificationsFrom(completed.NextEventNumber);
}
break;
default:
throw new NotSupportedException();
}
},
() => {
_log.Warning("Timeout reading stream: {stream}. Trying again in 10 seconds.", UserManagementService.UserPasswordNotificationsStreamId);
_ioDispatcher.Delay(TimeSpan.FromSeconds(10), () => ReadNotificationsFrom(fromEventNumber));
},
Guid.NewGuid());
}
public void OnGet()
{
_logueo.LogDebug("Este es un mensaje DEBUG");
_logueo.LogWarning("Este es un mensaje de WARNING");
_logueo.LogError("Este es un mensaje de ERROR");
_email.EnviarCorreo();
_loggerTabla.Error("Mensaje de ERROR de Serilog");
_loggerTabla.Debug("Mensaje de DEBUG de Serilog");
_loggerTabla.Warning("Mensaje de WARNING de Serilog");
}
public async Task <IActionResult> GetCurrentUser()
{
if (!User.Identity.IsAuthenticated)
{
_logger.Warning("GetCurrentUser called for unauthenticated user");
return(NotFound());
}
else
{
string email;
try
{
email = User.GetEmail();
}
catch (InvalidOperationException err)
{
_logger.Error(err, "Unable to retrieve email address for current user '{UserName}': {ErrorMessage}", User.Identity.Name, err.Message);
return(NotFound($"Unable to retrieve email address for current user '{User.Identity.Name}': {err.Message}"));
}
if (string.IsNullOrWhiteSpace(email))
{
_logger.Error("Email address is empty for current user {UserName}", User.Identity.Name);
return(NotFound($"Email address is empty for current user '{User.Identity.Name}'"));
}
var personId = await _personRepository.GetPersonIdByEmailAsync(email);
if (personId == null)
{
_logger.Error("Unable to find a user for {EmailAddress}", email);
return(NotFound($"Unable to find a user for {email}"));
}
var person = await _personRepository.GetPersonAsync(personId.Value);
if (person == null)
{
_logger.Error("Unable to find a user for {EmailAddress} with id {PersonId}", email, personId);
return(NotFound($"Unable to find a user for {email} with id {personId}"));
}
// The following is temporary and should be replaced by real logic after our demo on tuesday.
var permissions = new List <string>();
if (User.IsAdmin() || User.IsInRole("Octava Business Analyst"))
{
string permissionName = Core.Data.Permissions.EditStatusDescription.ToString();
permissionName = permissionName.First().ToString().ToLower() + permissionName.Substring(1);
permissions.Add(permissionName);
}
return(Ok(new { person.Id, person.Name, person.Email, Roles = User.GetRoles().ToArray(), Permissions = permissions.ToArray() }));
}
}
public bool Acquire()
{
if (_acquired)
{
throw new InvalidOperationException($"DB mutex '{MutexName}' is already acquired.");
}
try {
_dbMutex?.Dispose();
_dbMutex = new Mutex(initiallyOwned: true, name: MutexName, createdNew: out _acquired);
_dbMutex.WaitOne(TimeSpan.FromSeconds(5));
} catch (AbandonedMutexException exc) {
Log.Warning(exc,
"DB mutex '{mutex}' is said to be abandoned. "
+ "Probably previous instance of server was terminated abruptly.",
MutexName);
}
return(_acquired);
}
public IActionResult Serilog()
{
_serilogLogger.Verbose("Serilog Verbose");
_serilogLogger.Debug("Serilog Debug");
_serilogLogger.Information("Serilog Information");
_serilogLogger.Warning("Serilog Warning");
_serilogLogger.Error("Serilog Error");
_serilogLogger.Fatal("Serilog Fatal");
return(Ok());
}
private void StartMessage(OutstandingMessage message, DateTime expires)
{
var result = _outstandingMessages.StartMessage(message, expires);
if (result == StartMessageResult.SkippedDuplicate)
{
Log.Warning("Skipping message {stream}/{eventNumber} with duplicate eventId {eventId}",
message.ResolvedEvent.OriginalStreamId,
message.ResolvedEvent.OriginalEventNumber,
message.EventId);
}
}
