/// <summary>
/// Creates a server for the given protocol, listening for connections at the given listener, and optionally a logger
/// provider.
/// </summary>
/// <param name="protocol">the protocol that connections are passed to</param>
/// <param name="listener">the listener that listens for connections</param>
/// <param name="logger">an optional logger provider</param>
public Server(IProtocol protocol, IListener listener, ILoggerProvider logger = null)
{
_protocol = protocol;
Listener = listener;
_loggerProvider = logger;
_logger = _loggerProvider?.CreateLogger("isrv");
}
private async Task ListenAsync()
{
_cancellationToken.Token.ThrowIfCancellationRequested();
while (Listener.Active)
{
_cancellationToken.Token.ThrowIfCancellationRequested();
_logger?.LogDebug("Awaiting connection...");
var connection = await Listener.AcceptAsync();
if (connection == null) // listener shutdown
{
continue;
}
_logger?.LogDebug("Got connection " + connection.Id + "!");
#pragma warning disable 4014
Task.Factory.StartNew(async() =>
{
try
{
await _protocol.HandleConnectionAsync(connection,
_loggerProvider?.CreateLogger("c" + connection.Id));
}
catch (Exception ex)
{
_logger?.LogError("Couldn't handle request" + ex);
}
});
#pragma warning restore 4014
}
}
private void ConfigLogging(IConfiguration configuration, ILoggerProvider loggerProvider)
{
UseLogging = configuration?.Get <LoggingConfig>()?.LoggingSection?.IsEnabled;
if (UseLogging ?? false)
{
Logger = loggerProvider?.CreateLogger(Name) ?? throw new NullReferenceException("No ILoggerProvider implementation registered...");
}
}
public void AddProvider(ILoggerProvider provider)
{
var logger = provider.CreateLogger(_name);
int logIndex;
if (_loggers == null)
{
logIndex = 0;
_loggers = new ILogger[1];
}
else
{
logIndex = _loggers.Length;
Array.Resize(ref _loggers, logIndex + 1);
}
_loggers[logIndex] = logger;
}
public async Task Process_LogSuccess_WhenTokenValid()
{
ILogger fakeLogger = Substitute.For <ILogger>();
ILoggerProvider fakeLoggerProvider = Substitute.For <ILoggerProvider>();
fakeLoggerProvider.CreateLogger(Arg.Any <string>()).Returns(fakeLogger);
var processor = new CbsRequestProcessor(Substitute.For <ISecurityContext>(), fakeLoggerProvider, Substitute.For <ITokenValidator>());
await TestAmqpHost.ProcessCbsRequestAsync("111", processor);
fakeLogger.Received(1).Log(
LogLevel.Debug,
Arg.Any <EventId>(),
Arg.Is <FormattedLogValues>(f => f.ToString().StartsWith("Valid $cbs request")),
Arg.Any <Exception>(),
Arg.Any <Func <FormattedLogValues, Exception, string> >()
);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ILoggerProvider loggerProvider)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.ConfigureExceptionHandler(loggerProvider.CreateLogger("default"));
//app.UseCors(x => x
// .AllowAnyOrigin()
// .AllowAnyMethod()
// .AllowAnyHeader());
app.UseSwagger();
app.UseSwaggerUI(c =>
{
c.SwaggerEndpoint("/swagger/v1/swagger.json", "i-Delivery Api V1");
c.RoutePrefix = string.Empty;
});
app.UseHttpsRedirection();
app.UseRouting();
//// global cors policy
//app.UseCors(x => x
// .AllowAnyMethod()
// .AllowAnyHeader()
// .SetIsOriginAllowed(origin => true) // allow any origin
// .AllowCredentials()); // allow credentials
app.UseCors("AllowAll");
app.UseAuthentication();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
}
public static async Task <Connection> BuildEstablishedConnection(
bool isServer,
IBufferedPipe inputStream,
IBufferedPipe outputStream,
ILoggerProvider loggerProvider,
Func <IStream, bool> streamListener = null,
Settings?localSettings = null,
Settings?remoteSettings = null,
HuffmanStrategy huffmanStrategy = HuffmanStrategy.Never)
{
ILogger logger = null;
if (loggerProvider != null)
{
logger = loggerProvider.CreateLogger("http2Con");
}
if (streamListener == null)
{
streamListener = (s) => false;
}
var config = new ConnectionConfigurationBuilder(isServer)
.UseStreamListener(streamListener)
.UseHuffmanStrategy(huffmanStrategy)
.UseSettings(localSettings ?? Settings.Default)
.Build();
var conn = new Connection(
config, inputStream, outputStream,
new Connection.Options
{
Logger = logger,
});
await PerformHandshakes(
conn,
inputStream, outputStream,
remoteSettings);
return(conn);
}
private static async Task HandleExceptionAsync(HttpContext context, Exception exception)
{
var statusCode = HttpStatusCode.InternalServerError; // 500 if unexpected
var message = GetErrorMessage(exception);
var userMessage = GetUserMessage(exception);
HttpResponse response = context.Response;
response.StatusCode = (int)statusCode;
response.ContentType = "application/json";
var result = new { Succeeded = false, ErrorMessage = userMessage, Result = string.Empty };
var newLogger = _logger.CreateLogger("");
newLogger.LogError(exception, message);
await response.WriteAsync(JsonConvert.SerializeObject(result));
}
private void Inject(MainSettingsModelSO mainSettingsModel, ILoggerProvider loggerProvider, IAvatarInput input, SpawnedAvatar avatar, VRPlatformHelper vrPlatformHelper, AvatarTailor tailor)
{
_mainSettingsModel = mainSettingsModel;
_logger = loggerProvider.CreateLogger <AvatarTracking>(avatar.avatar.descriptor.name);
_input = input;
_avatar = avatar;
_vrPlatformHelper = vrPlatformHelper;
_tailor = tailor;
if (_avatar.pelvis)
{
_initialPelvisPose = new Pose(_avatar.pelvis.position, _avatar.pelvis.rotation);
}
if (_avatar.leftLeg)
{
_initialLeftFootPose = new Pose(_avatar.leftLeg.position, _avatar.leftLeg.rotation);
}
if (_avatar.rightLeg)
{
_initialRightFootPose = new Pose(_avatar.rightLeg.position, _avatar.rightLeg.rotation);
}
}
public GameClient(ILoggerProvider loggerProvider, NavigationManager navigationManager)
{
_logger = loggerProvider.CreateLogger(nameof(GameClient));
_hubConnection = new HubConnectionBuilder()
.WithUrl(navigationManager.ToAbsoluteUri(GAMEHUB_NAME))
.WithAutomaticReconnect(new RandomRetryPolicy())
.ConfigureLogging(logging => logging.AddProvider(loggerProvider))
.Build();
_hubConnection.Closed += OnHubClosed;
_hubConnection.Reconnecting += OnHubReconnecting;
_hubConnection.Reconnected += OnHubReconnected;
_hubConnection.On <CreateGameResponse>("OnCreateGameResponse", HandleCreateGameResponse);
_hubConnection.On <JoinGameResponse>("OnJoinGameResponse", HandleJoinGameResponse);
_hubConnection.On <GameUpdateResponse>("OnGameUpdateResponse", HandleGameUpdateResponse);
_hubConnection.On <PlayerUpdateResponse>("OnPlayerUpdateResponse", HandlePlayerUpdateResponse);
_hubConnection.On <DealGameResponse>("OnDealGameResponse", HandleDealGameResponse);
_hubConnection.On <UpdateQuoteResponse>("OnUpdateQuoteResponse", HandleUpdateQuoteResponse);
_hubConnection.On <TradeResponse>("OnTradeResponse", HandleTradeResponse);
_hubConnection.On <TradeUpdateResponse>("OnTradeUpdateResponse", HandleTradeUpdateResponse);
_logger.LogDebug("GameClient Created");
}
public async Task Process_LogError_WhenTokenInvalid()
{
var testException = new ArgumentException("Test");
ILogger fakeLogger = Substitute.For <ILogger>();
ILoggerProvider fakeLoggerProvider = Substitute.For <ILoggerProvider>();
fakeLoggerProvider.CreateLogger(Arg.Any <string>()).Returns(fakeLogger);
ITokenValidator fakeTokenValidator = Substitute.For <ITokenValidator>();
fakeTokenValidator
.When(instance => instance.Validate(Arg.Any <string>()))
.Do(_ => throw testException);
var processor = new CbsRequestProcessor(Substitute.For <ISecurityContext>(), fakeLoggerProvider, fakeTokenValidator);
await TestAmqpHost.ProcessCbsRequestAsync("abc", processor);
fakeLogger.Received(1).Log(
LogLevel.Error,
Arg.Any <EventId>(),
Arg.Is <FormattedLogValues>(f => f.ToString().StartsWith("Failed to validate $cbs request")),
testException,
Arg.Any <Func <FormattedLogValues, Exception, string> >()
);
}
public async Task Process_LogsUnsupportedOperation(string operation)
{
ILogger fakeLogger = Substitute.For <ILogger>();
ILoggerProvider fakeLoggerProvider = Substitute.For <ILoggerProvider>();
fakeLoggerProvider.CreateLogger(Arg.Any <string>()).Returns(fakeLogger);
var processor = new ManagementRequestProcessor(fakeLoggerProvider);
var request = new Message
{
ApplicationProperties = new Amqp.Framing.ApplicationProperties
{
["operation"] = operation
}
};
await TestAmqpHost.ProcessManagementRequestAsync(request, processor);
fakeLogger.Received(1).Log(
LogLevel.Debug,
Arg.Any <EventId>(),
Arg.Is <FormattedLogValues>(a => a.ToString() == $"Unsupported operation {operation}."),
Arg.Any <Exception>(),
Arg.Any <Func <FormattedLogValues, Exception, string> >());
}
static int Main(string[] args)
{
IServiceCollection descriptors = new ServiceCollection();
descriptors.AddLogging(builder =>
{
builder.AddConsoleFormatter <CustomFormatter, CustomOptions>();
builder.AddConsole(o => { o.FormatterName = "custom"; });
});
ServiceProvider provider = descriptors.BuildServiceProvider();
ILoggerProvider logger = provider.GetRequiredService <ILoggerProvider>();
logger.CreateLogger("log").LogError("Hello");
if (ConstructorCallCount != 1 ||
WriteCallCount != 1)
{
return(-1);
}
return(100);
}
/// <inheritdoc />
public ILogger CreateLogger(string categoryName)
{
return(new EventBulkingDecoratorLogger(this.bulkingConfig, provider.CreateLogger(categoryName)));
}
public void AddProvider(ILoggerProvider provider)
{
var logger = provider.CreateLogger(_name);
_loggers = _loggers.Concat(new[] {logger}).ToArray();
}
public TriggerController(IScheduler scheduler, ILoggerProvider loggerProvider)
{
Scheduler = scheduler;
Logger = loggerProvider.CreateLogger(nameof(TriggerController));
}
internal void AddProvider(ILoggerProvider provider)
{
var logger = provider.CreateLogger(_name);
_loggers = _loggers.Concat(new[] { logger }).ToArray();
}
public MagicOnionLogger(ILoggerProvider provider)
{
logger = provider.CreateLogger("MagicOnion");
}
public ILogger CreateLogger(string categoryName)
{
var logger = _inner.CreateLogger(categoryName);
return(new TimedLogger(logger));
}
public virtual ILogger Create <T>()
{
return(_loggerProvider.CreateLogger(typeof(T).Name));
}
public DeviceManager(ILoggerProvider loggerProvider, IDeviceProvider deviceProvider)
{
_logger = loggerProvider.CreateLogger <DeviceManager>();
_deviceProvider = deviceProvider;
}
internal AvatarLoader(ILoggerProvider loggerProvider, DiContainer container)
{
_logger = loggerProvider.CreateLogger <AvatarLoader>();
_container = container;
}
public ILogger CreateLogger(string categoryName)
{
return(new FixedApplicationInsightsLogger(_inner.CreateLogger(categoryName), _telemetryClient));
}
public AddNotificationItemConsumer(ILoggerProvider loggerProvider, IScheduler scheduler, INotificationEntryRepository repo)
{
Logger = loggerProvider.CreateLogger(nameof(AddNotificationItemConsumer));
Scheduler = scheduler;
Repo = repo;
}
public MainCameraController(ILoggerProvider loggerProvider, Settings settings, GameScenesManager gameScenesManager)
{
_logger = loggerProvider.CreateLogger <MainCameraController>();
_settings = settings;
_gameScenesManager = gameScenesManager;
}
public ILogger CreateLogger(string categoryName)
{
return(_loggerProvider.CreateLogger(categoryName));
}
public void NLogBenchmark()
{
using ILoggerProvider Provider = NLogProvider.CreateNLogProvider();
WriteLogMessages(Provider.CreateLogger("LoggingBenchmarks.Benchmarks"), 1);
}
public static ILogger CreateCommandsLogger(this ILoggerProvider loggerProvider) => loggerProvider.CreateLogger(CommandsLoggerName);
public MirrorHelper(ILoggerProvider loggerProvider, DiContainer container, ShaderLoader shaderLoader)
{
_logger = loggerProvider.CreateLogger <MirrorHelper>();
_container = container;
_shaderLoader = shaderLoader;
}
private void Inject(Settings settings, ILoggerProvider loggerProvider)
{
_logger = loggerProvider.CreateLogger <AvatarSRTracking>();
_settings = settings;
}
public UserRepository(MongoDbContext dbContext, ILoggerProvider loggerProvider)
{
_dbContext = dbContext;
_log = loggerProvider.CreateLogger(nameof(UserRepository));
}
