private async Task EventAppeared(EventStoreCatchUpSubscription sub, ResolvedEvent evt)
{
_logger.LogTrace("EventAppeared {SubscriptionName} {Stream} Projector {ProjectorId}",
sub.SubscriptionName,
sub.StreamId,
ProjectorId);
var de = evt.Event.ToDomainEvent();
var desc = new ProjectionEventData
{
EventData = de,
EventNumber = evt.OriginalEventNumber
};
// if (_useQueue)
// {
// _logger.LogTrace("Enqueue Event {@0}", desc);
// await Queue.EnqueueAsync(desc).ConfigureAwait(false);
// }
// else
// {
await HandleEventAsync(desc).ConfigureAwait(false);
// }
}
private static void LogToConsole(string message, Level logLevel, Exception ex = null)
{
switch (logLevel)
{
case Level.Error:
_logger.LogError(new EventId(1), ex, message);
break;
case Level.Debug:
_logger.LogDebug(new EventId(1), ex, message);
break;
case Level.Warning:
_logger.LogWarning(new EventId(1), ex, message);
break;
case Level.Information:
_logger.LogInformation(new EventId(1), ex, message);
break;
case Level.Verbose:
_logger.LogTrace(new EventId(1), ex, message);
break;
default:
_logger.LogDebug(new EventId(1), ex, message);
break;
}
}
public static bool IsJsonOfTypeEventStoreData(JToken json, Microsoft.Extensions.Logging.ILogger logger)
{
try
{
if ((json["events"] != null && json["events"].Type == JTokenType.Array) ||
(json["Events"] != null && json["Events"].Type == JTokenType.Array))
{
return(true);
}
}
catch (Exception ex)
{
logger.LogTrace(ex, ex.Message);
logger.LogTrace($"Json seams not to be of Type {nameof(EventStoreData)}.");
}
return(false);
}
//private IEventStoreConnection CreateForCluster(ConnectionSettingsBuilder connectionSettingsBuilder)
//{
// var endpoints = Options.ClusterIpEndpoints.Select((x, i) =>
// {
// var ipa = GetHostIp(x);
// var port = Options.TcpPort;
// if (Options.ClusterHttpPorts.Length >= i + 1) port = Options.ClusterHttpPorts[i];
// _logger.LogTrace($"Creating Cluster IP Endpoint: {ipa}:{port}");
// return new IPEndPoint(ipa, port);
// });
// var clusterSettings = ClusterSettings.Create()
// .DiscoverClusterViaGossipSeeds()
// .SetGossipTimeout(TimeSpan.FromMilliseconds(500))
// .SetGossipSeedEndPoints(endpoints.ToArray())
// ;
// var con = EventStoreConnection.Create(connectionSettingsBuilder, clusterSettings);
// return con;
//}
public IEventStoreConnection CreateNewConnection(Action <ConnectionSettingsBuilder> setup = null)
{
_logger.LogTrace("Creating Connection");
IEventStoreConnection con;
var connectionSettingsBuilder = ConnectionSettings.Create()
.KeepReconnecting()
.KeepRetrying();
setup?.Invoke(connectionSettingsBuilder);
//if (!Options.UseCluster)
//{
var ipa = GetHostIp(Options.IpEndPoint);
if (Options.UseSslCertificate)
{
_logger.LogInformation("Connecting To GetEventStore: with SSL IP: {0}:{1} // User: {2}", Options.IpEndPoint, Options.ExtSecureTcpPort, Options.OpsUsername);
var url = $"tcp://{ipa.MapToIPv4()}:{Options.ExtSecureTcpPort}";
connectionSettingsBuilder.UseSslConnection(Options.SslTargetHost, Options.SslValidateServer);
var uri = new Uri(url);
con = EventStoreConnection.Create(connectionSettingsBuilder, uri);
}
else
{
_logger.LogInformation("Connecting To GetEventStore: without SSL IP: {0}:{1} // User: {2}", Options.IpEndPoint, Options.TcpPort, Options.OpsUsername);
var url = $"tcp://{ipa.MapToIPv4()}:{Options.TcpPort}";
var uri = new Uri(url);
con = EventStoreConnection.Create(connectionSettingsBuilder, uri);
}
//}
//else
//{
// if (Options.UseSslCertificate)
// //var ipa = GetHostIp(Options.IpEndPoint);
// // var url = $"tcp://{ipa.MapToIPv4()}:{Options.ExtSecureTcpPort}";
// connectionSettingsBuilder.UseSslConnection(Options.SslTargetHost, Options.SslValidateServer);
// _logger.LogInformation("Connecting To GetEventStore: for Cluster // User: {0}", Options.OpsUsername);
// con = CreateForCluster(connectionSettingsBuilder);
//}
RegisterEvents(con);
//con.ConnectAsync().ConfigureAwait(false).GetAwaiter().GetResult();
return(con);
}
internal async Task HandleEventAsync(ProjectionEventData entry)
{
_logger.LogTrace("Handled Item {EventNumber} {StreamName} {ProjectorId}", entry.EventNumber, StreamName, ProjectorId);
CurrentCheckPoint = entry.EventNumber;
try
{
await _projector.ProcessEventAsync(entry.EventData);
Status.LastCheckPoint = entry.EventNumber;
Status.ModifiedOnUtc = DateTime.UtcNow;
await EntityStore.UpdateItemAsync(Status, _cancellationToken);
}
catch (Exception e)
{
_logger.LogError(e, "Error while Processing Event {EventNumber} from {StreamName} {ProjectorId}", entry.EventNumber, StreamName, ProjectorId);
throw;
}
}
private void DumpEnv()
{
_log.LogDebug($"appBaseDir=[{_appBaseDir}]");
_log.LogDebug($"procModDir=[{_procModDir}]");
var env = Environment.GetEnvironmentVariables();
foreach (var envKey in env.Keys.Cast <string>().OrderBy(x => x))
{
_log.LogTrace($"* [{envKey}]=[{env[envKey]}]");
}
}
public async Task <bool> CheckAggregateExists <T>(string aggregateId, string streamName) where T : AggregateRoot
{
_logger.LogDebug("CheckAggregateExists {type} {AggregateId} {StreamName}", typeof(T), aggregateId, streamName);
//var sliceStart = 1; //Ignores $StreamCreated
long sliceStart = 0; //Ignores $StreamCreated
var con = await _provider.GetActiveConnection();
var currentSlice = await con
.ReadStreamEventsForwardAsync(streamName, sliceStart, 1, false, _provider.OpsCredentials)
.ConfigureAwait(false);
if (currentSlice.Status == SliceReadStatus.StreamNotFound)
{
_logger.LogTrace("CheckAggregateExists {type} {AggregateId} {StreamName} not found", typeof(T), aggregateId, streamName);
return(false);
}
return(true);
}
private static async Task <RTCPeerConnection> CreatePeerConnection()
{
RTCConfiguration config = new RTCConfiguration
{
X_DisableExtendedMasterSecretKey = true
};
var pc = new RTCPeerConnection(config);
MediaStreamTrack audioTrack = new MediaStreamTrack(SDPWellKnownMediaFormatsEnum.PCMU);
pc.addTrack(audioTrack);
var dc = await pc.createDataChannel("sipsocery-dc");
pc.onicecandidateerror += (candidate, error) => logger.LogWarning($"Error adding remote ICE candidate. {error} {candidate}");
pc.OnTimeout += (mediaType) => logger.LogWarning($"Timeout for {mediaType}.");
pc.oniceconnectionstatechange += (state) => logger.LogInformation($"ICE connection state changed to {state}.");
pc.onsignalingstatechange += () => logger.LogInformation($"Signaling state changed to {pc.signalingState}.");
pc.OnReceiveReport += (re, media, rr) => logger.LogDebug($"RTCP Receive for {media} from {re}\n{rr.GetDebugSummary()}");
pc.OnSendReport += (media, sr) => logger.LogDebug($"RTCP Send for {media}\n{sr.GetDebugSummary()}");
pc.OnRtcpBye += (reason) => logger.LogDebug($"RTCP BYE receive, reason: {(string.IsNullOrWhiteSpace(reason) ? "<none>" : reason)}.");
pc.onsignalingstatechange += () =>
{
if (pc.signalingState == RTCSignalingState.have_remote_offer)
{
logger.LogTrace("Remote SDP:");
logger.LogTrace(pc.remoteDescription.sdp.ToString());
}
else if (pc.signalingState == RTCSignalingState.have_local_offer)
{
logger.LogTrace("Local SDP:");
logger.LogTrace(pc.localDescription.sdp.ToString());
}
};
return(pc);
}
public void DoSomeStuff()
{
var position1 = new { A = 1 };
var position2 = new { B = 2 };
using (_logger.BeginScope("my scope"))
{
_logger.LogTrace("Trace");
_logger.LogDebug("Debug");
_logger.LogInformation("Processed {Position1} {Position2}", position1, position2);
_logger.LogWarning("Warning");
_logger.LogError("Error");
_logger.LogCritical("Critical error");
}
}
public void Execute(string[] args)
{
_logger.LogTrace("TestTrace");
_logger.LogInformation("Starting");
var startTime = DateTimeOffset.Now;
_logger.LogInformation(1, "Started at '{StartTime}' and 0x{Hello:X} is hex of 42", startTime, 42);
// or
_logger.ProgramStarting(startTime, 42);
using (_logger.PurchaseOrderScope("00655321"))
{
try
{
throw new Exception("Boom");
}
catch (Exception ex)
{
_logger.LogCritical(1, ex, "Unexpected critical error starting application");
_logger.LogError(1, ex, "Unexpected error");
_logger.LogWarning(1, ex, "Unexpected warning");
}
using (_logger.BeginScope("Main"))
{
_logger.LogInformation("Waiting for user input");
string input;
do
{//这段代码有些问题，打印的顺序不固定。原因不明。test2
Console.WriteLine("Enter some test to log more, or 'quit' to exit.");
input = Console.ReadLine();
_logger.LogInformation("User typed '{input}' on the command line", input);
_logger.LogWarning("The time is now {Time}, it's getting late!", DateTimeOffset.Now);
}while (input != "quit");
}
}
var endTime = DateTimeOffset.Now;
_logger.LogInformation(2, "Stopping at '{StopTime}'", endTime);
// or
_logger.ProgramStopping(endTime);
_logger.LogInformation("Stopping");
}
public override void Log(ILogMessage message)
{
if (message.Message.Contains("Resolving dependency information took"))
{
return;
}
if (message.Message.Trim().StartsWith("CACHE"))
{
return;
}
var level = message.Level;
var text = message.Message;
switch (level)
{
// ReSharper disable TemplateIsNotCompileTimeConstantProblem
case LogLevel.Debug:
m_Logger.LogDebug(text);
break;
case LogLevel.Verbose:
m_Logger.LogTrace(text);
break;
case LogLevel.Information:
m_Logger.LogInformation(text);
break;
case LogLevel.Minimal:
m_Logger.LogInformation(text);
break;
case LogLevel.Warning:
m_Logger.LogWarning(text);
break;
case LogLevel.Error:
m_Logger.LogError(text);
break;
// ReSharper restore TemplateIsNotCompileTimeConstantProblem
default:
throw new ArgumentOutOfRangeException(nameof(level), level, null);
}
}
public override void Log(ILogMessage message)
{
if (message.Message.Contains("Resolving dependency information took"))
{
return;
}
if (message.Message.Trim().StartsWith("CACHE"))
{
return;
}
var level = message.Level;
string prefix = "[NuGet] ";
var text = prefix + message.Message;
switch (level)
{
case LogLevel.Debug:
m_Logger.LogDebug(text);
break;
case LogLevel.Verbose:
m_Logger.LogTrace(text);
break;
case LogLevel.Information:
m_Logger.LogInformation(text);
break;
case LogLevel.Minimal:
m_Logger.LogInformation(text);
break;
case LogLevel.Warning:
m_Logger.LogWarning(text);
break;
case LogLevel.Error:
m_Logger.LogError(text);
break;
default:
throw new ArgumentOutOfRangeException(nameof(level), level, null);
}
}
public void Write(EventType eventType, Func <string> logMessage)
{
switch (eventType)
{
case EventType.Trace:
netCoreLogger.LogTrace(logMessage());
break;
case EventType.Info:
netCoreLogger.LogInformation(logMessage());
break;
case EventType.Error:
netCoreLogger.LogError(logMessage());
break;
}
}
private async Task <string> LoadJsonAsync(string name, string partitionId)
{
var manager = _provider.CreateProjectionsManager();
string json;
if (string.IsNullOrEmpty(partitionId))
{
json = await manager.GetStateAsync(name, _provider.OpsCredentials).ConfigureAwait(false);
}
else
{
json = await manager.GetPartitionStateAsync(name, partitionId, _provider.OpsCredentials).ConfigureAwait(false);
}
_logger.LogTrace("State {StateJson}", json);
return(json);
}
private static void HexLoggingFormatter(Microsoft.Extensions.Logging.ILogger logger, string method, ReadOnlySpan <byte> buffer)
{
if (!logger.IsEnabled(Microsoft.Extensions.Logging.LogLevel.Trace))
{
return;
}
var builder = new StringBuilder($"{method}[{buffer.Length}] ");
// Write the hex
foreach (var b in buffer)
{
builder.Append(b.ToString("X2"));
builder.Append(" ");
}
logger.LogTrace(builder.ToString());
}
static void WriteLog(ILogger logger, LogLevel logLevel, string message)
{
if (logger == null)
{
Console.WriteLine($"{logLevel}: {message}");
}
else
{
switch (logLevel)
{
case LogLevel.Trace:
logger.LogTrace(message);
break;
case LogLevel.Debug:
logger.LogDebug(message);
break;
case LogLevel.Information:
logger.LogInformation(message);
break;
case LogLevel.Warning:
logger.LogWarning(message);
break;
case LogLevel.Error:
logger.LogCritical(message);
break;
case LogLevel.Critical:
logger.LogCritical(message);
break;
default:
break;
}
}
}
public override void Log(ILogMessage message)
{
var level = message.Level;
string prefix = "[NuGet] ";
var text = prefix + message.Message;
switch (level)
{
case LogLevel.Debug:
m_Logger.LogDebug(text);
break;
case LogLevel.Verbose:
m_Logger.LogTrace(text);
break;
case LogLevel.Information:
m_Logger.LogInformation(text);
break;
case LogLevel.Minimal:
m_Logger.LogInformation(text);
break;
case LogLevel.Warning:
m_Logger.LogWarning(text);
break;
case LogLevel.Error:
m_Logger.LogError(text);
break;
default:
throw new ArgumentOutOfRangeException(nameof(level), level, null);
}
}
public void Log(string message)
{
_logger.LogTrace(message);
}
public static IWebHostBuilder CreateWebHostBuilder(string[] args)
{
bool all = args.Contains("all", StringComparer.OrdinalIgnoreCase);
bool sample1 = all || args.Contains("sample1", StringComparer.OrdinalIgnoreCase);
bool sample2 = all || args.Contains("sample2", StringComparer.OrdinalIgnoreCase);
bool everyMinute = all || args.Contains("everyMinute", StringComparer.OrdinalIgnoreCase);
bool evenMinutes = all || args.Contains("evenMinutes", StringComparer.OrdinalIgnoreCase);
var loggerFactory = new SerilogLoggerFactory(new LoggerConfiguration()
.MinimumLevel.Verbose()
.WriteTo.Console()
.CreateLogger());
_logger = loggerFactory.CreateLogger <Program>();
var builder = WebHost.CreateDefaultBuilder(args)
.SuppressStatusMessages(true)
.ConfigureServices(s => {
s.AddSingleton <ILoggerFactory>(loggerFactory);
// will shutdown the host if no jobs are running
s.AddJobLifetimeService();
// inserts a startup action that does not complete until the critical health checks are healthy
// gets inserted as 1st startup action so that any other startup actions dont run until the critical resources are available
s.AddStartupActionToWaitForHealthChecks("Critical");
s.AddHealthChecks().AddCheck <MyCriticalHealthCheck>("My Critical Resource", tags: new[] { "Critical" });
// add health check that does not return healthy until the startup actions have completed
// useful for readiness checks
s.AddHealthChecks().AddCheckForStartupActions("Critical");
if (everyMinute)
{
s.AddCronJob <EveryMinuteJob>("* * * * *");
}
if (evenMinutes)
{
s.AddCronJob <EvenMinutesJob>("*/2 * * * *");
}
if (sample1)
{
s.AddJob(sp => new Sample1Job(sp.GetRequiredService <ILoggerFactory>()), o => o.ApplyDefaults <Sample1Job>().WaitForStartupActions(true).InitialDelay(TimeSpan.FromSeconds(5)));
}
if (sample2)
{
s.AddHealthChecks().AddCheck <Sample2Job>("Sample2Job");
s.AddJob <Sample2Job>(true);
}
// if you don't specify priority, actions will automatically be assigned an incrementing priority starting at 0
s.AddStartupAction("Test1", async() => {
_logger.LogTrace("Running startup 1 action.");
for (int i = 0; i < 3; i++)
{
await Task.Delay(1000);
_logger.LogTrace("Running startup 1 action...");
}
_logger.LogTrace("Done running startup 1 action.");
});
// then these startup actions will run concurrently since they both have the same priority
s.AddStartupAction <MyStartupAction>(priority: 100);
s.AddStartupAction <OtherStartupAction>(priority: 100);
s.AddStartupAction("Test2", async() => {
_logger.LogTrace("Running startup 2 action.");
for (int i = 0; i < 2; i++)
{
await Task.Delay(1500);
_logger.LogTrace("Running startup 2 action...");
}
//throw new ApplicationException("Boom goes the startup.");
_logger.LogTrace("Done running startup 2 action.");
});
//s.AddStartupAction("Boom", () => throw new ApplicationException("Boom goes the startup"));
})
.Configure(app => {
app.UseHealthChecks("/health");
app.UseReadyHealthChecks("Critical");
// this middleware will return Service Unavailable until the startup actions have completed
app.UseWaitForStartupActionsBeforeServingRequests();
// add mvc or other request middleware after the UseWaitForStartupActionsBeforeServingRequests call
});
return(builder);
}
public async Task AddOpsUserToAdminsAsync()
{
_logger.LogTrace("AddOpsUserToAdminsAsync");
if (await CheckOpsUserIsInAdminGroupAsync().ConfigureAwait(false))
{
_logger.LogTrace("ops user is already admin");
return;
}
var manager = _provider.CreateUsersManager();
var ops = await manager.GetUserAsync("ops", _provider.AdminCredentials).ConfigureAwait(false);
if (ops.Groups == null || ops.Groups != null && !ops.Groups.Contains("$admins"))
{
var groups = new List <string>();
if (ops.Groups != null)
{
groups.AddRange(ops.Groups);
}
groups.Add("$admins");
await manager.UpdateUserAsync("ops", ops.FullName, groups.ToArray(), _provider.AdminCredentials)
.ConfigureAwait(false);
_logger.LogTrace("Group $admin added to ops user");
}
}
public void Trace(object message)
{
_extLogger.LogTrace(message.ToString());
}
public async Task <RTCSessionDescriptionInit> GotOffer(RTCSessionDescriptionInit offer)
{
logger.LogTrace($"SDP offer received.");
logger.LogTrace(offer.sdp);
var pc = new RTCPeerConnection();
if (_presetIceAddresses != null)
{
foreach (var addr in _presetIceAddresses)
{
var rtpPort = pc.GetRtpChannel().RTPPort;
var publicIPv4Candidate = new RTCIceCandidate(RTCIceProtocol.udp, addr, (ushort)rtpPort, RTCIceCandidateType.host);
pc.addLocalIceCandidate(publicIPv4Candidate);
}
}
MediaStreamTrack audioTrack = new MediaStreamTrack(SDPWellKnownMediaFormatsEnum.PCMU);
pc.addTrack(audioTrack);
MediaStreamTrack videoTrack = new MediaStreamTrack(new VideoFormat(VideoCodecsEnum.VP8, VP8_PAYLOAD_ID));
pc.addTrack(videoTrack);
pc.OnRtpPacketReceived += (IPEndPoint rep, SDPMediaTypesEnum media, RTPPacket rtpPkt) =>
{
pc.SendRtpRaw(media, rtpPkt.Payload, rtpPkt.Header.Timestamp, rtpPkt.Header.MarkerBit, rtpPkt.Header.PayloadType);
};
pc.OnTimeout += (mediaType) => logger.LogWarning($"Timeout for {mediaType}.");
pc.oniceconnectionstatechange += (state) => logger.LogInformation($"ICE connection state changed to {state}.");
pc.onsignalingstatechange += () => logger.LogInformation($"Signaling state changed to {pc.signalingState}.");
pc.onconnectionstatechange += (state) =>
{
logger.LogInformation($"Peer connection state changed to {state}.");
if (state == RTCPeerConnectionState.failed)
{
pc.Close("ice failure");
}
};
var setResult = pc.setRemoteDescription(offer);
if (setResult == SetDescriptionResultEnum.OK)
{
var offerSdp = pc.createOffer(null);
await pc.setLocalDescription(offerSdp);
var answer = pc.createAnswer(null);
logger.LogTrace($"SDP answer created.");
logger.LogTrace(answer.sdp);
return(answer);
}
else
{
logger.LogWarning($"Failed to set remote description {setResult}.");
return(null);
}
}
public void LogTrace(string message, params object[] args) => logger.LogTrace(message, args);
public void Trace(string message)
{
_readLogger.LogTrace(message);
}
/// <summary>Logs exception with trace log level.</summary>
/// <remarks><para>See <see cref="ExceptionLoggingHelper"/> for more information.</para>
/// <para>This method is null-logger-safe - if <paramref name="log"/> is null, message and exception won't be logged.</para></remarks>
/// <param name="exception">Exception message to log.</param>
/// <param name="log">Logger instance.</param>
/// <param name="message">Log message template.</param>
/// <param name="args">Structured log message arguments.</param>
/// <returns>Always returns true.</returns>
public static bool LogAsTrace(this Exception exception, ILogger log, string message, params object[] args)
{
log?.LogTrace(exception, message, args);
return(true);
}
private void Handle_Reconnecting(object sender, ClientReconnectingEventArgs e)
{
_logger?.LogTrace($"Reconnecting: {e.Connection.ConnectionName}");
Reconnecting?.Invoke(sender, e);
}
public void CreateDirectory(string filePath)
{
Logger.LogTrace("CreateDirectory called");
filePath = filePath?.Replace("\\", "/");
RootFs.CreateDirectoryAsync(filePath).ConfigureAwait(false).GetAwaiter().GetResult();
}
public static void LogTrace(this ILogger logger, Object obj, string message, params object[] args)
{
Log(logger, obj, () => logger.LogTrace(message, args));
}
