public void Dispose_ProvidersAreDisposed()
{
// Arrange
var factory = new LoggerFactory();
var disposableProvider1 = CreateProvider();
var disposableProvider2 = CreateProvider();
factory.AddProvider(disposableProvider1);
factory.AddProvider(disposableProvider2);
// Act
factory.Dispose();
// Assert
Mock.Get<IDisposable>(disposableProvider1)
.Verify(p => p.Dispose(), Times.Once());
Mock.Get<IDisposable>(disposableProvider2)
.Verify(p => p.Dispose(), Times.Once());
}
private Tuple<ILoggerFactory, ConsoleSink> SetUpFactory(Func<string, LogLevel, bool> filter)
{
var t = SetUp(null);
var logger = t.Item1;
var sink = t.Item2;
var provider = new Mock<ILoggerProvider>();
provider.Setup(f => f.CreateLogger(
It.IsAny<string>()))
.Returns(logger);
var factory = new LoggerFactory();
factory.AddProvider(provider.Object);
return new Tuple<ILoggerFactory, ConsoleSink>(factory, sink);
}
public void Dispose_ThrowException_SwallowsException()
{
// Arrange
var factory = new LoggerFactory();
var throwingProvider = new Mock<ILoggerProvider>();
throwingProvider.As<IDisposable>()
.Setup(p => p.Dispose())
.Throws<Exception>();
factory.AddProvider(throwingProvider.Object);
// Act
factory.Dispose();
// Assert
throwingProvider.As<IDisposable>()
.Verify(p => p.Dispose(), Times.Once());
}
public async void Invoke_WithNonMatchingPath_IgnoresRequest()
{
// Arrange
var elmStore = new ElmStore();
var factory = new LoggerFactory();
var optionsMock = new Mock <IOptions <ElmOptions> >();
optionsMock
.SetupGet(o => o.Value)
.Returns(new ElmOptions());
factory.AddProvider(new ElmLoggerProvider(elmStore, optionsMock.Object.Value));
RequestDelegate next = _ =>
{
return(Task.FromResult <object>(null));
};
var captureMiddleware = new ElmCaptureMiddleware(
next,
factory,
optionsMock.Object);
var pageMiddleware = new ElmPageMiddleware(
next,
optionsMock.Object,
elmStore);
var contextMock = GetMockContext("/nonmatchingpath");
// Act
await captureMiddleware.Invoke(contextMock.Object);
await pageMiddleware.Invoke(contextMock.Object);
// Assert
// Request.Query is used by the ElmPageMiddleware to parse the query parameters
contextMock.VerifyGet(c => c.Request.Query, Times.Never());
}
public GrpcTestClass(Action <IServiceCollection>?initialConfigureServices)
{
LoggerFactory = new LoggerFactory();
LoggerFactory.AddProvider(new ForwardingLoggerProvider((logLevel, category, eventId, message, exception) =>
{
LoggedMessage?.Invoke(logLevel, category, eventId, message, exception);
}));
var builder = new HostBuilder()
.ConfigureServices(services =>
{
initialConfigureServices?.Invoke(services);
services.AddSingleton <ILoggerFactory>(LoggerFactory);
})
.ConfigureWebHostDefaults(webHost =>
{
webHost
.UseTestServer()
.UseStartup <TStartup>();
});
_host = builder.Start();
_server = _host.GetTestServer();
// Need to set the response version to 2.0.
// Required because of this TestServer issue - https://github.com/aspnet/AspNetCore/issues/16940
var responseVersionHandler = new ResponseVersionHandler {
InnerHandler = _server.CreateHandler()
};
var client = new HttpClient(responseVersionHandler)
{
BaseAddress = new Uri("http://localhost")
};
Client = client;
}
public async Task ClientAttemptingToUseUnsupportedProtocolIsLoggedAsDebug()
{
var loggerProvider = new HandshakeErrorLoggerProvider();
LoggerFactory.AddProvider(loggerProvider);
var hostBuilder = TransportSelector.GetWebHostBuilder()
.UseKestrel(options =>
{
options.Listen(new IPEndPoint(IPAddress.Loopback, 0), listenOptions =>
{
listenOptions.UseHttps(TestResources.TestCertificatePath, "testPassword");
});
})
.ConfigureServices(AddTestLogging)
.Configure(app => app.Run(httpContext => Task.CompletedTask));
using (var host = hostBuilder.Build())
{
host.Start();
using (var socket = await HttpClientSlim.GetSocket(new Uri($"https://127.0.0.1:{host.GetPort()}/")))
using (var stream = new NetworkStream(socket, ownsSocket: false))
using (var sslStream = new SslStream(stream, true, (sender, certificate, chain, errors) => true))
{
// SslProtocols.Tls is TLS 1.0 which isn't supported by Kestrel by default.
await Assert.ThrowsAsync <IOException>(() =>
sslStream.AuthenticateAsClientAsync("127.0.0.1", clientCertificates: null,
enabledSslProtocols: SslProtocols.Tls,
checkCertificateRevocation: false));
}
}
await loggerProvider.FilterLogger.LogTcs.Task.DefaultTimeout();
Assert.Equal(1, loggerProvider.FilterLogger.LastEventId);
Assert.Equal(LogLevel.Debug, loggerProvider.FilterLogger.LastLogLevel);
}
private static void ConfigureServices(ServiceCollection services)
{
var configuration = new ConfigurationBuilder().SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", false, true)
.AddEnvironmentVariables()
.Build();
services.AddSingleton <IConfiguration>(configuration);
var loggerFactory = new LoggerFactory();
services.AddDbContext <ApplicationDbContext>(
options => options
.UseSqlServer(
configuration.GetConnectionString("DefaultConnection"),
sqlServerOptions => sqlServerOptions.CommandTimeout(600)).EnableSensitiveDataLogging()
.UseLoggerFactory(loggerFactory));
services.AddDefaultIdentity <ApplicationUser>(IdentityOptionsProvider.GetIdentityOptions)
.AddRoles <ApplicationRole>().AddEntityFrameworkStores <ApplicationDbContext>();
services.AddSingleton <ILoggerFactory>(
provider =>
{
var factory = new LoggerFactory();
factory.AddProvider(new OneLineConsoleLoggerProvider(true));
return(factory);
});
services.AddScoped(typeof(IDeletableEntityRepository <>), typeof(EfDeletableEntityRepository <>));
services.AddScoped(typeof(IRepository <>), typeof(EfRepository <>));
services.AddScoped <IDbQueryRunner, DbQueryRunner>();
// Application services
services.AddTransient <IEmailSender, NullMessageSender>();
services.AddTransient <ISettingsService, SettingsService>();
services.AddTransient <INewsService, NewsService>();
services.AddTransient <ITagsService, TagsService>();
}
public async Task HandshakeTimesOutAndIsLoggedAsDebug()
{
var loggerProvider = new HandshakeErrorLoggerProvider();
LoggerFactory.AddProvider(loggerProvider);
var hostBuilder = TransportSelector.GetWebHostBuilder()
.UseKestrel(options =>
{
options.Listen(new IPEndPoint(IPAddress.Loopback, 0), listenOptions =>
{
listenOptions.UseHttps(o =>
{
o.ServerCertificate = new X509Certificate2(TestResources.TestCertificatePath, "testPassword");
o.HandshakeTimeout = TimeSpan.FromSeconds(1);
});
});
})
.ConfigureServices(AddTestLogging)
.Configure(app => app.Run(httpContext => Task.CompletedTask));
using (var host = hostBuilder.Build())
{
host.Start();
using (var socket = await HttpClientSlim.GetSocket(new Uri($"https://127.0.0.1:{host.GetPort()}/")))
using (var stream = new NetworkStream(socket, ownsSocket: false))
{
// No data should be sent and the connection should be closed in well under 30 seconds.
Assert.Equal(0, await stream.ReadAsync(new byte[1], 0, 1).DefaultTimeout());
}
}
await loggerProvider.FilterLogger.LogTcs.Task.DefaultTimeout();
Assert.Equal(2, loggerProvider.FilterLogger.LastEventId);
Assert.Equal(LogLevel.Debug, loggerProvider.FilterLogger.LastLogLevel);
}
private ServiceCollection SetupInitialServices()
{
var serviceCollection = new ServiceCollection();
#if DNX451 || DNXCORE50
var manifest = _serviceProvider.GetRequiredService <IRuntimeServices>();
if (manifest != null)
{
foreach (var service in manifest.Services)
{
serviceCollection.AddTransient(
service, sp => _serviceProvider.GetService(service));
}
}
#endif
var loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(_loggerProvider);
var logger = loggerFactory.CreateLogger <DatabaseTool>();
serviceCollection.AddScoped(typeof(ILogger), sp => logger);
serviceCollection.AddScoped <IFileService, FileSystemFileService>();
return(serviceCollection);
}
private void FilterTest(Func <string, bool> filter, params string[] expected)
{
var loggerFactory = new LoggerFactory();
var loggerProvider = new TestLoggerProvider(filter);
loggerFactory.AddProvider(loggerProvider);
var dbLogger = new InterceptingLogger <LoggerCategory.Database>(loggerFactory, new LoggingOptions());
var sqlLogger = new InterceptingLogger <LoggerCategory.Database.Sql>(loggerFactory, new LoggingOptions());
var queryLogger = new InterceptingLogger <LoggerCategory.Query>(loggerFactory, new LoggingOptions());
var randomLogger = loggerFactory.CreateLogger("Random");
dbLogger.LogInformation("DB1");
sqlLogger.LogInformation("SQL1");
queryLogger.LogInformation("Query1");
randomLogger.LogInformation("Random1");
dbLogger.LogInformation("DB2");
sqlLogger.LogInformation("SQL2");
queryLogger.LogInformation("Query2");
randomLogger.LogInformation("Random2");
Assert.Equal(loggerProvider.Messages, expected);
}
private async Task <int> MainInternalAsync(string[] args)
{
var options = CommandLineOptions.Parse(args, _stdout, _stderr);
var loggerFactory = new LoggerFactory();
var commandProvider = new CommandOutputProvider
{
LogLevel = ResolveLogLevel(options)
};
loggerFactory.AddProvider(commandProvider);
var logger = loggerFactory.CreateLogger(LoggerName);
if (string.IsNullOrEmpty(options.WatchPath.Value))
{
// invalid args syntax
return(1);
}
await new DotNetWatcher(logger).WatchAsync(new List <string> {
options.WatchPath.Value
}, _cancellationToken);
return(0);
}
public Task <ActionResult> Logs(
ProcessFilter?processFilter,
[FromQuery][Range(-1, int.MaxValue)] int durationSeconds = 30,
[FromQuery] LogLevel level = LogLevel.Debug)
{
TimeSpan duration = ConvertSecondsToTimeSpan(durationSeconds);
return(this.InvokeService(async() =>
{
IProcessInfo processInfo = await _diagnosticServices.GetProcessAsync(processFilter, HttpContext.RequestAborted);
LogFormat format = ComputeLogFormat(Request.GetTypedHeaders().Accept);
if (format == LogFormat.None)
{
return this.NotAcceptable();
}
string contentType = (format == LogFormat.EventStream) ? ContentTypeEventStream : ContentTypeNdJson;
string downloadName = (format == LogFormat.EventStream) ? null : FormattableString.Invariant($"{GetFileNameTimeStampUtcNow()}_{processInfo.ProcessId}.txt");
return new OutputStreamResult(async(outputStream, token) =>
{
using var loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(new StreamingLoggerProvider(outputStream, format, level));
var settings = new EventLogsPipelineSettings
{
Duration = duration,
LogLevel = level,
};
await using EventLogsPipeline pipeline = new EventLogsPipeline(processInfo.Client, settings, loggerFactory);
await pipeline.RunAsync(token);
}, contentType, downloadName);
}));
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
var connection = ConfigurationManagerWrapper.ConnectionStrings[nameOrConnectionString];
var connectionString = connection.ConnectionString;
var builder = new OracleConnectionStringBuilder(connectionString);
switch (connection.ProviderName)
{
case "Sqlserver": optionsBuilder.UseSqlServer(connectionString: connectionString, sqlServerOptionsAction: option => option.UseRowNumberForPaging()); break;
case "Oracle.ManagedDataAccess.Client":
optionsBuilder.UseOracle(connectionString, o => o.UseOracleSQLCompatibility("11")); break;
}
if (!autoDetectChangesEnabled)
{
optionsBuilder.UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking);
}
var loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(new EFLoggerProvider());
optionsBuilder.UseLoggerFactory(loggerFactory);
}
public static DbContextOptions <NaheulbookDbContext> GetDbContextOptions(bool logSqlQueries = false)
{
var connectionString = $"Server={Environment.GetEnvironmentVariable("MYSQL_HOST") ?? "localhost"};" +
$"Port={Environment.GetEnvironmentVariable("MYSQL_PORT") ?? "3306"};" +
"Database=naheulbook_integration;" +
"User=naheulbook;" +
"Password=naheulbook;" +
"SslMode=None";
var dbContextOptionsBuilder = new DbContextOptionsBuilder <NaheulbookDbContext>()
.EnableSensitiveDataLogging()
.UseMySql(connectionString, ServerVersion.AutoDetect(connectionString), builder => builder.EnableRetryOnFailure());
if (logSqlQueries)
{
var logger = new LoggerConfiguration()
.WriteTo.Console(theme: ConsoleTheme.None)
.CreateLogger();
var loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(new SerilogLoggerProvider(logger));
dbContextOptionsBuilder.UseLoggerFactory(loggerFactory);
}
return(dbContextOptionsBuilder.Options);
}
public void Log_dampens_logLevel_when_CommandExecuted()
{
var reporter = new TestOperationReporter();
var loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(new OperationLoggerProvider(reporter));
var logger = loggerFactory.CreateLogger(DbLoggerCategory.Database.Command.Name);
logger.Log <object>(
LogLevel.Information,
RelationalEventId.CommandExecuted,
null,
null,
(_, __) => "-- Can't stop the SQL");
Assert.Collection(
reporter.Messages,
x =>
{
Assert.Equal("-- Can't stop the SQL", x.Message);
Assert.Equal(LogLevel.Debug, x.Level);
});
}
public async Task ClientHandshakeFailureLoggedAsDebug()
{
var loggerProvider = new HandshakeErrorLoggerProvider();
LoggerFactory.AddProvider(loggerProvider);
var hostBuilder = TransportSelector.GetWebHostBuilder()
.UseKestrel(options =>
{
options.Listen(new IPEndPoint(IPAddress.Loopback, 0), listenOptions =>
{
listenOptions.UseHttps(TestResources.TestCertificatePath, "testPassword");
});
})
.ConfigureServices(AddTestLogging)
.Configure(app => { });
using (var host = hostBuilder.Build())
{
host.Start();
using (var socket = await HttpClientSlim.GetSocket(new Uri($"https://127.0.0.1:{host.GetPort()}/")))
using (var stream = new NetworkStream(socket))
{
// Send null bytes and close socket
await stream.WriteAsync(new byte[10], 0, 10);
}
await loggerProvider.FilterLogger.LogTcs.Task.TimeoutAfter(TestConstants.DefaultTimeout);
}
Assert.Equal(1, loggerProvider.FilterLogger.LastEventId.Id);
Assert.Equal(LogLevel.Debug, loggerProvider.FilterLogger.LastLogLevel);
Assert.True(loggerProvider.ErrorLogger.TotalErrorsLogged == 0,
userMessage: string.Join(Environment.NewLine, loggerProvider.ErrorLogger.ErrorMessages));
}
public void WriteToFileAndOverwrite()
{
var tmpFile = Path.GetTempFileName();
try {
var factory = new LoggerFactory();
factory.AddProvider(new FileLoggerProvider(tmpFile, false));
var logger = factory.CreateLogger("TEST");
logger.LogInformation("Line1");
factory.Dispose();
Assert.Equal(1, System.IO.File.ReadAllLines(tmpFile).Length);
factory = new LoggerFactory();
logger = factory.CreateLogger("TEST");
factory.AddProvider(new FileLoggerProvider(tmpFile, false));
logger.LogInformation("Line2");
factory.Dispose();
Assert.Equal(1, System.IO.File.ReadAllLines(tmpFile).Length); // file should be overwritten
} finally {
System.IO.File.Delete(tmpFile);
}
}
private void FilterTest(Func <string, bool> filter, params string[] expected)
{
var loggerFactory = new LoggerFactory();
var loggerProvider = new TestLoggerProvider(filter);
loggerFactory.AddProvider(loggerProvider);
var dbLogger = new DiagnosticsLogger <DbLoggerCategory.Database>(loggerFactory, new LoggingOptions(), new DiagnosticListener("Fake"));
var sqlLogger = new DiagnosticsLogger <DbLoggerCategory.Database.Command>(loggerFactory, new LoggingOptions(), new DiagnosticListener("Fake"));
var queryLogger = new DiagnosticsLogger <DbLoggerCategory.Query>(loggerFactory, new LoggingOptions(), new DiagnosticListener("Fake"));
var randomLogger = loggerFactory.CreateLogger("Random");
dbLogger.Logger.LogInformation(1, "DB1");
sqlLogger.Logger.LogInformation(2, "SQL1");
queryLogger.Logger.LogInformation(3, "Query1");
randomLogger.LogInformation(4, "Random1");
dbLogger.Logger.LogInformation(1, "DB2");
sqlLogger.Logger.LogInformation(2, "SQL2");
queryLogger.Logger.LogInformation(3, "Query2");
randomLogger.LogInformation(4, "Random2");
Assert.Equal(loggerProvider.Messages, expected);
}
public ContactManagerTests()
{
var applicationConfig = new ApplicationConfig
{
SqlDbConnectionString =
@"Data Source=(localdb)\ProjectsV13;Initial Catalog=ContactManager;Integrated Security=True;Connect Timeout=30;Encrypt=False;TrustServerCertificate=True;ApplicationIntent=ReadWrite;MultiSubnetFailover=False"
};
var applicationConfigOptions = Options.Create(applicationConfig);
var config = new MapperConfiguration(cfg => {
cfg.AddProfile <MappingProfile>();
});
IMapper mapper = config.CreateMapper();
var loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(new EfCoreFilteredLoggerProvider(true));
var logger = loggerFactory.CreateLogger("ContactRepository");
var dbContextFactory = new ContactDbContextFactory(applicationConfigOptions, loggerFactory);
contactRepository = new ContactRepository(dbContextFactory, mapper, loggerFactory);
}
public void Test1()
{
ConsoleLoggerOptions consoleLoggerOptions = new ConsoleLoggerOptions();
MyOptionsMonitor <ConsoleLoggerOptions> optionsMonitor = new MyOptionsMonitor <ConsoleLoggerOptions>(consoleLoggerOptions);
ConsoleLoggerProvider loggerProvider = new ConsoleLoggerProvider(optionsMonitor);
var f = new LoggerFactory();
f.AddProvider(loggerProvider);
string brokerList = "192.168.1.112:9092,192.168.1.112:9093";
KfkManagement kfkManagement = new KfkManagement(brokerList, f);
List <string> topics = new List <string>()
{
"test000", "zjmtest0"
};
topics.Clear();
string topicName = "zjmtestw";
for (int i = 0; i < 50; i++)
{
topics.Add(topicName + i.ToString());
}
int p = 0;
int num = 100000;
foreach (var topic in topics)
{
for (int j = 0; j < num; j++)
{
kfkManagement.Produce(topic, p.ToString());
}
}
kfkManagement.Flush();
}
public async Task DoesNotThrowObjectDisposedExceptionOnEmptyConnection()
{
var loggerProvider = new HandshakeErrorLoggerProvider();
LoggerFactory.AddProvider(loggerProvider);
using (var server = new TestServer(context => Task.CompletedTask,
new TestServiceContext(LoggerFactory),
listenOptions =>
{
listenOptions.UseHttps(TestResources.TestCertificatePath, "testPassword");
}))
{
using (var connection = server.CreateConnection())
using (var sslStream = new SslStream(connection.Stream, true, (sender, certificate, chain, errors) => true))
{
await sslStream.AuthenticateAsClientAsync("127.0.0.1", clientCertificates : null,
enabledSslProtocols : SslProtocols.Tls11 | SslProtocols.Tls12,
checkCertificateRevocation : false);
}
}
Assert.False(loggerProvider.ErrorLogger.ObjectDisposedExceptionLogged);
}
public ServiceBusListenerTests()
{
_mockExecutor = new Mock <ITriggeredFunctionExecutor>(MockBehavior.Strict);
var client = new ServiceBusClient(_testConnection);
ServiceBusProcessor processor = client.CreateProcessor(_entityPath);
ServiceBusReceiver receiver = client.CreateReceiver(_entityPath);
ServiceBusOptions config = new ServiceBusOptions
{
ExceptionHandler = ExceptionReceivedHandler
};
_mockMessageProcessor = new Mock <MessageProcessor>(MockBehavior.Strict, processor);
_mockMessagingProvider = new Mock <MessagingProvider>(MockBehavior.Strict, new OptionsWrapper <ServiceBusOptions>(config));
_mockMessagingProvider
.Setup(p => p.CreateMessageProcessor(_entityPath, _testConnection))
.Returns(_mockMessageProcessor.Object);
_mockMessagingProvider
.Setup(p => p.CreateBatchMessageReceiver(_entityPath, _testConnection))
.Returns(receiver);
Mock <ServiceBusAccount> mockServiceBusAccount = new Mock <ServiceBusAccount>(MockBehavior.Strict);
mockServiceBusAccount.Setup(a => a.ConnectionString).Returns(_testConnection);
_loggerFactory = new LoggerFactory();
_loggerProvider = new TestLoggerProvider();
_loggerFactory.AddProvider(_loggerProvider);
_listener = new ServiceBusListener(_functionId, EntityType.Queue, _entityPath, false, _mockExecutor.Object, config, mockServiceBusAccount.Object,
_mockMessagingProvider.Object, _loggerFactory, false);
}
public void SetLogLevel_UpdatesLogger()
{
var provider = new DynamicLoggerProvider(GetLoggerSettings());
LoggerFactory fac = new LoggerFactory();
fac.AddProvider(provider);
ILogger logger = fac.CreateLogger(typeof(A.B.C.D.TestClass));
Assert.NotNull(logger);
Assert.True(logger.IsEnabled(LogLevel.Critical));
Assert.True(logger.IsEnabled(LogLevel.Error));
Assert.True(logger.IsEnabled(LogLevel.Warning));
Assert.True(logger.IsEnabled(LogLevel.Information));
Assert.False(logger.IsEnabled(LogLevel.Debug));
provider.SetLogLevel("A", LogLevel.Debug);
Assert.True(logger.IsEnabled(LogLevel.Information));
Assert.True(logger.IsEnabled(LogLevel.Debug));
provider.SetLogLevel("A", LogLevel.Information);
Assert.True(logger.IsEnabled(LogLevel.Information));
Assert.False(logger.IsEnabled(LogLevel.Debug));
}
private JobHost CreateTestJobHost()
{
ExplicitTypeLocator locator = new ExplicitTypeLocator(typeof(FilesTestJobs));
var resolver = new TestNameResolver();
resolver.Values.Add("test", "TestValue");
ILoggerFactory loggerFactory = new LoggerFactory();
TestLoggerProvider provider = new TestLoggerProvider();
loggerFactory.AddProvider(provider);
IHost host = new HostBuilder()
.ConfigureWebJobs(builder =>
{
builder.AddAzureStorageCoreServices()
.AddFiles(o =>
{
o.RootPath = this.rootPath;
});
})
.ConfigureServices(services =>
{
services.AddSingleton <IWebJobsExceptionHandler>(new TestExceptionHandler());
services.AddSingleton <INameResolver>(resolver);
services.AddSingleton <ITypeLocator>(locator);
})
.ConfigureLogging(logging =>
{
logging.ClearProviders();
logging.AddProvider(provider);
})
.Build();
return(host.GetJobHost());
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddJwtBearer(options =>
{
options.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuer = true,
ValidateAudience = true,
ValidateLifetime = true,
ValidateIssuerSigningKey = true,
ValidIssuer = Configuration["Jwt:Issuer"],
ValidAudience = Configuration["Jwt:Audience"],
IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(Configuration["Jwt:Key"]))
};
});
services.Configure <MvcOptions>(options =>
{
options.Filters.Add(new RequireHttpsAttribute());
});
// Add framework services.
services.AddMvc()
.AddCsvSerializerFormatters()
.AddPlainTextFormatters()
.AddBsonSerializerFormatters()
.AddProtobufFormatters()
.AddMessagePackFormatters()
.AddYamlFormatters()
.SetCompatibilityVersion(CompatibilityVersion.Version_2_2)
.AddJsonOptions(a =>
a.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver());
// Add service and create Policy with options
services.AddCors(options =>
{
options.AddPolicy("CorsPolicy",
builder => builder.AllowAnyOrigin()
.AllowAnyMethod()
.AllowAnyHeader()
.AllowCredentials());
});
var logFactory = new LoggerFactory();
logFactory.AddProvider(new SqliteLoggerProvider());
services.AddDbContext <ProductsContext>(options =>
options.UseSqlite(Configuration.GetConnectionString("DefaultConnection"))
.UseLoggerFactory(logFactory));
// Start Registering and Initializing AutoMapper
Mapper.Initialize(cfg => cfg.AddProfile <MappingProfile>());
services.AddAutoMapper();
//using Dependency Injection
services.AddScoped <ProductsContext, ProductsContext>();
services.AddTransient <IUnitOfWork <ProductsContext>, UnitOfWork <ProductsContext> >();
services.AddTransient <IRepository <Models.Product, ProductsContext>, Repository <Models.Product, ProductsContext> >();
services.AddTransient <IRepository <Models.ProductOwner, ProductsContext>, Repository <Models.ProductOwner, ProductsContext> >();
services.AddTransient <IRepository <Models.Manufacturer, ProductsContext>, Repository <Models.Manufacturer, ProductsContext> >();
services.AddTransient <IRepository <Models.User, ProductsContext>, Repository <Models.User, ProductsContext> >();
//services.AddSingleton<IProductsService, ProductsService>();
services.AddScoped <IProductsService, ProductsService>();
services.Configure <GzipCompressionProviderOptions>(options => options.Level = System.IO.Compression.CompressionLevel.Optimal);
services.AddResponseCompression(options =>
{
/*options.MimeTypes = new[]
* {
* // Default
* "text/plain",
* "text/css",
* "application/javascript",
* "text/html",
* "application/xml",
* "text/xml",
* "application/json",
* "text/json",
* // Custom
* "image/svg+xml"
* };*/
options.EnableForHttps = true;
});
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new Info {
Title = "Priduct Web API", Version = "v1"
});
});
}
public void LoggerLogs_At_Configured_Setting()
{
// arrange
var provider = new DynamicLoggerProvider(GetLoggerSettings());
LoggerFactory fac = new LoggerFactory();
fac.AddProvider(provider);
ILogger logger = fac.CreateLogger(typeof(A.B.C.D.TestClass));
// act I - log at all levels, expect Info and above to work
using (var unConsole = new ConsoleOutputBorrower())
{
WriteLogEntries(logger);
// pause the thread to allow the logging to happen
Thread.Sleep(10);
var logged = unConsole.ToString();
// assert I
Assert.Contains("Critical message", logged);
Assert.Contains("Error message", logged);
Assert.Contains("Warning message", logged);
Assert.Contains("Informational message", logged);
Assert.DoesNotContain("Debug message", logged);
Assert.DoesNotContain("Trace message", logged);
}
// act II - adjust rules, expect Error and above to work
provider.SetLogLevel("A.B.C.D", LogLevel.Error);
using (var unConsole = new ConsoleOutputBorrower())
{
WriteLogEntries(logger);
// pause the thread to allow the logging to happen
Thread.Sleep(10);
var logged2 = unConsole.ToString();
// assert II
Assert.Contains("Critical message", logged2);
Assert.Contains("Error message", logged2);
Assert.DoesNotContain("Warning message", logged2);
Assert.DoesNotContain("Informational message", logged2);
Assert.DoesNotContain("Debug message", logged2);
Assert.DoesNotContain("Trace message", logged2);
}
// act III - adjust rules, expect Trace and above to work
provider.SetLogLevel("A", LogLevel.Trace);
using (var unConsole = new ConsoleOutputBorrower())
{
WriteLogEntries(logger);
// pause the thread to allow the logging to happen
Thread.Sleep(10);
var logged3 = unConsole.ToString();
// assert III
Assert.Contains("Critical message", logged3);
Assert.Contains("Error message", logged3);
Assert.Contains("Warning message", logged3);
Assert.Contains("Informational message", logged3);
Assert.Contains("Debug message", logged3);
Assert.Contains("Trace message", logged3);
}
// act IV - adjust rules, expect nothing to work
provider.SetLogLevel("A", LogLevel.None);
using (var unConsole = new ConsoleOutputBorrower())
{
WriteLogEntries(logger);
// pause the thread to allow the logging to happen
Thread.Sleep(10);
var logged4 = unConsole.ToString();
// assert IV
Assert.DoesNotContain("Critical message", logged4);
Assert.DoesNotContain("Error message", logged4);
Assert.DoesNotContain("Warning message", logged4);
Assert.DoesNotContain("Informational message", logged4);
Assert.DoesNotContain("Debug message", logged4);
Assert.DoesNotContain("Trace message", logged4);
}
// act V - reset the rules, expect Info and above to work
provider.SetLogLevel("A", null);
using (var unConsole = new ConsoleOutputBorrower())
{
WriteLogEntries(logger);
// pause the thread to allow the logging to happen
Thread.Sleep(10);
var logged5 = unConsole.ToString();
// assert V
Assert.NotNull(provider.GetLoggerConfigurations().First(c => c.Name == "A"));
Assert.Contains("Critical message", logged5);
Assert.Contains("Error message", logged5);
Assert.Contains("Warning message", logged5);
Assert.Contains("Informational message", logged5);
Assert.DoesNotContain("Debug message", logged5);
Assert.DoesNotContain("Trace message", logged5);
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public IServiceProvider ConfigureServices(IServiceCollection services)
{
#region 配置DbContextOption
var dbConnectionString = Configuration["AppSettings:SqlServer:SqlServerConnection"];
if (Configuration["AppSettings:Sqlite:Enabled"].ObjToBool())
{
dbConnectionString = Configuration["AppSettings:Sqlite:SqliteConnection"];
}
else if (Configuration["AppSettings:SqlServer:Enabled"].ObjToBool())
{
dbConnectionString = Configuration["AppSettings:SqlServer:SqlServerConnection"];
}
else if (Configuration["AppSettings:MySql:Enabled"].ObjToBool())
{
dbConnectionString = Configuration["AppSettings:MySql:MySqlConnection"];
}
else if (Configuration["AppSettings:Oracle:Enabled"].ObjToBool())
{
dbConnectionString = Configuration["AppSettings:Oracle:OracleConnection"];
}
services.AddDbContext <MyDbContext>(ops =>
{
var loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(new EFLoggerProvider());
//打开延迟加载代理的创建。 便于加载导航属性
ops.UseLazyLoadingProxies();
ops.UseSqlServer(dbConnectionString).UseLoggerFactory(loggerFactory);
});
services.Add(new ServiceDescriptor(typeof(DbContext), typeof(MyDbContext), ServiceLifetime.Scoped));
#endregion
#region 部分服务注入-netcore自带方法
// 缓存注入
services.AddScoped <ICaching, MemoryCaching>();
services.AddSingleton <IMemoryCache>(factory =>
{
var cache = new MemoryCache(new MemoryCacheOptions());
return(cache);
});
// Redis注入
services.AddSingleton <IRedisCacheManager, RedisCacheManager>();
// log日志注入
services.AddSingleton <ILoggerHelper, LogHelper>();
#endregion
#region Automapper
services.AddAutoMapper(typeof(Startup));
#endregion
#region CORS 跨域
//跨域第二种方法，声明策略，记得下边app中配置
services.AddCors(c =>
{
#region 全开放的处理
c.AddPolicy("AllRequests", policy =>
{
policy
.AllowAnyOrigin() //允许任何源
.AllowAnyMethod() //允许任何方式
.AllowAnyHeader() //允许任何头
.AllowCredentials(); //允许cookie
});
#endregion
#region 指定域名ip
c.AddPolicy("LimitRequests", policy =>
{
// 支持多个域名端口，注意端口号后不要带/斜杆：比如localhost:80/，是错的
// 注意，http://127.0.0.1:80 和 http://localhost:80 是不一样的，尽量写两个
policy
.WithOrigins("http://127.0.0.1:4002", "http://*****:*****@xxx.com", Url = "http://127.0.0.1"
}
});
// 按相对路径排序
c.OrderActionsBy(o => o.RelativePath);
});
//就是这里
var xmlPath = Path.Combine(basePath, "ZC.Customer.xml"); //这个就是刚刚配置的xml文件名
c.IncludeXmlComments(xmlPath, true); //默认的第二个参数是false，这个是controller的注释，记得修改
var xmlModelPath = Path.Combine(basePath, "ZC.Customer.Model.xml"); //这个就是Model层的xml文件名
c.IncludeXmlComments(xmlModelPath);
#region Token绑定到ConfigureServices
//添加header验证信息
//c.OperationFilter<SwaggerHeader>();
// 发行人
var IssuerName = (Configuration.GetSection("Audience"))["Issuer"];
var security = new Dictionary <string, IEnumerable <string> > {
{ IssuerName, new string[] { } },
};
c.AddSecurityRequirement(security);
//方案名称“ZC.Customer”可自定义，上下一致即可
c.AddSecurityDefinition(IssuerName, new ApiKeyScheme
{
Description = "JWT授权(数据将在请求头中进行传输) 直接在下框中输入Bearer {token}（注意两者之间是一个空格）\"",
Name = "Authorization", //jwt默认的参数名称
In = "header", //jwt默认存放Authorization信息的位置(请求头中)
Type = "apiKey"
});
#endregion
});
#endregion
#region MVC + GlobalExceptions
//注入全局异常捕获
services.AddMvc(o =>
{
// 全局异常过滤
o.Filters.Add(typeof(GlobalExceptionsFilter));
})
.SetCompatibilityVersion(CompatibilityVersion.Version_2_2)
// 取消默认驼峰
.AddJsonOptions(options => { options.SerializerSettings.ContractResolver = new DefaultContractResolver(); });
#endregion
#region Httpcontext
// Httpcontext 注入
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
services.AddScoped <IUser, AspNetUser>();
#endregion
#region 设置HttpClient
services.AddHttpClient("IMS", client =>
{
client.BaseAddress = new Uri(Configuration["SystemUrl:ImsUrl"]);
client.DefaultRequestHeaders.Add("Accept", "application/json");
}).AddTransientHttpErrorPolicy(b => b.WaitAndRetryAsync(new[] {
// 该策略将处理典型的瞬态故障，如果需要，会最多重试 3 次 Http 请求。
// 这个策略将在第一次重试前延迟 1 秒，第二次重试前 5 秒，在第三次重试前延迟 10 秒
TimeSpan.FromSeconds(1),
TimeSpan.FromSeconds(5),
TimeSpan.FromSeconds(10)
}));
services.AddHttpClient("CRM", client =>
{
client.BaseAddress = new Uri(Configuration["SystemUrl:CrmUrl"]);
client.DefaultRequestHeaders.Add("Accept", "application/json");
}).AddTransientHttpErrorPolicy(b => b.WaitAndRetryAsync(new[] {
// 该策略将处理典型的瞬态故障，如果需要，会最多重试 3 次 Http 请求。
// 这个策略将在第一次重试前延迟 1 秒，第二次重试前 5 秒，在第三次重试前延迟 10 秒
TimeSpan.FromSeconds(1),
TimeSpan.FromSeconds(5),
TimeSpan.FromSeconds(10)
}));
services.AddHttpClient("UMa.User", client =>
{
client.BaseAddress = new Uri(Configuration["SystemUrl:UmaUserUrl"]);
client.DefaultRequestHeaders.Add("Accept", "application/json");
}).AddTransientHttpErrorPolicy(b => b.WaitAndRetryAsync(new[] {
// 该策略将处理典型的瞬态故障，如果需要，会最多重试 3 次 Http 请求。
// 这个策略将在第一次重试前延迟 1 秒，第二次重试前 5 秒，在第三次重试前延迟 10 秒
TimeSpan.FromSeconds(1),
TimeSpan.FromSeconds(5),
TimeSpan.FromSeconds(10)
}));
#endregion 设置HttpClient
services.AddSignalR();
#region Authorize权限设置三种情况
//使用说明：
//如果你只是简单的基于角色授权的，第一步：【1/2 简单角色授权】，第二步：配置【统一认证】，第三步：开启中间件app.UseMiddleware<JwtTokenAuth>()不能验证过期，或者 app.UseAuthentication();可以验证过期时间
//如果你是用的复杂的策略授权，配置权限在数据库，第一步：【3复杂策略授权】，第二步：配置【统一认证】，第三步：开启中间件app.UseAuthentication();
//综上所述，设置权限，必须要三步走，涉及授权策略 + 配置认证 + 开启授权中间件，只不过自定义的中间件不能验证过期时间，所以我都是用官方的。
#region 【1/2、简单角色授权】
#region 1、基于角色的API授权
// 1【授权】、这个很简单，其他什么都不用做，
// 无需配置服务，只需要在API层的controller上边，增加特性即可，注意，只能是角色的:
// [Authorize(Roles = "Admin")]
// 2【认证】、然后在下边的configure里，配置中间件即可:app.UseMiddleware<JwtTokenAuth>();但是这个方法，无法验证过期时间，所以如果需要验证过期时间，还是需要下边的第三种方法，官方认证
#endregion
#region 2、基于策略的授权（简单版）
// 1【授权】、这个和上边的异曲同工，好处就是不用在controller中，写多个 roles 。
// 然后这么写 [Authorize(Policy = "Admin")]
services.AddAuthorization(options =>
{
options.AddPolicy("Client", policy => policy.RequireRole("Client").Build());
options.AddPolicy("Admin", policy => policy.RequireRole("Admin").Build());
options.AddPolicy("SystemOrAdmin", policy => policy.RequireRole("Admin", "System"));
});
// 2【认证】、然后在下边的configure里，配置中间件即可:app.UseMiddleware<JwtTokenAuth>();但是这个方法，无法验证过期时间，所以如果需要验证过期时间，还是需要下边的第三种方法，官方认证
#endregion
#endregion
#region 【3、复杂策略授权】
#region 参数
//读取配置文件
var audienceConfig = Configuration.GetSection("Audience");
var symmetricKeyAsBase64 = audienceConfig["Secret"];
var keyByteArray = Encoding.ASCII.GetBytes(symmetricKeyAsBase64);
var signingKey = new SymmetricSecurityKey(keyByteArray);
var signingCredentials = new SigningCredentials(signingKey, SecurityAlgorithms.HmacSha256);
// 如果要数据库动态绑定，这里先留个空，后边处理器里动态赋值
var permission = new List <PermissionItem>();
// 角色与接口的权限要求参数
var permissionRequirement = new PermissionRequirement(
"/api/denied", // 拒绝授权的跳转地址（目前无用）
permission,
ClaimTypes.Role, //基于角色的授权
audienceConfig["Issuer"], //发行人
audienceConfig["Audience"], //听众
signingCredentials, //签名凭据
expiration: TimeSpan.FromSeconds(2 * 60 * 60) //接口的过期时间
);
#endregion
//【授权】
services.AddAuthorization(options =>
{
options.AddPolicy(PermissionNames.Permission,
policy => policy.Requirements.Add(permissionRequirement));
});
#endregion
#region 【统一认证】
// 令牌验证参数
var tokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = signingKey,
ValidateIssuer = true,
ValidIssuer = audienceConfig["Issuer"], //发行人
ValidateAudience = true,
ValidAudience = audienceConfig["Audience"], //订阅人
ValidateLifetime = true,
ClockSkew = TimeSpan.FromSeconds(30),
RequireExpirationTime = true,
};
//2.1【认证】、core自带官方JWT认证
services.AddAuthentication(x =>
{
x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(o =>
{
o.TokenValidationParameters = tokenValidationParameters;
o.Events = new JwtBearerEvents
{
OnAuthenticationFailed = context =>
{
// 如果过期，则把<是否过期>添加到，返回头信息中
if (context.Exception.GetType() == typeof(SecurityTokenExpiredException))
{
context.Response.Headers.Add("Token-Expired", "true");
}
return(Task.CompletedTask);
}
};
});
//2.2【认证】、IdentityServer4 认证 (暂时忽略)
//services.AddAuthentication("Bearer")
// .AddIdentityServerAuthentication(options =>
// {
// options.Authority = "http://localhost:5002";
// options.RequireHttpsMetadata = false;
// options.ApiName = "vcan_ims.api";
// });
// 注入权限处理器
services.AddSingleton <IAuthorizationHandler, PermissionHandler>();
services.AddSingleton(permissionRequirement);
#endregion
#endregion
#region AutoFac DI
//实例化 AutoFac 容器
var builder = new ContainerBuilder();
//注册要通过反射创建的组件
//builder.RegisterType<AdvertisementServices>().As<IAdvertisementServices>();
builder.RegisterType <GlobalCacheAOP>(); //可以直接替换其他拦截器
builder.RegisterType <GlobalRedisCacheAOP>(); //可以直接替换其他拦截器
builder.RegisterType <GlobalLogAOP>(); //这样可以注入第二个
#region 带有接口层的服务注入
try
{
#region Service.dll 注入，有对应接口
//获取项目绝对路径，请注意，这个是实现类的dll文件，不是接口 IService.dll ，注入容器当然是Activatore
var servicesDllFile = Path.Combine(basePath, "ZC.Customer.Services.dll");
var assemblysServices = Assembly.LoadFrom(servicesDllFile);//直接采用加载文件的方法
//builder.RegisterAssemblyTypes(assemblysServices).AsImplementedInterfaces();//指定已扫描程序集中的类型注册为提供所有其实现的接口。
// AOP 开关，如果想要打开指定的功能，只需要在 appsettigns.json 对应对应 true 就行。
var cacheType = new List <Type>();
if (Appsettings.app(new string[] { "AppSettings", "RedisCaching", "Enabled" }).ObjToBool())
{
cacheType.Add(typeof(GlobalRedisCacheAOP));
}
if (Appsettings.app(new string[] { "AppSettings", "MemoryCachingAOP", "Enabled" }).ObjToBool())
{
cacheType.Add(typeof(GlobalCacheAOP));
}
if (Appsettings.app(new string[] { "AppSettings", "LogAOP", "Enabled" }).ObjToBool())
{
cacheType.Add(typeof(GlobalLogAOP));
}
builder.RegisterAssemblyTypes(assemblysServices)
.AsImplementedInterfaces()
.InstancePerLifetimeScope()
.EnableInterfaceInterceptors() //引用Autofac.Extras.DynamicProxy;
// 如果你想注入两个，就这么写 InterceptedBy(typeof(GlobalCacheAOP), typeof(GlobalLogAOP));
//允许将拦截器服务的列表分配给注册。
.InterceptedBy(cacheType.ToArray());
#endregion
#region Repository.dll 注入，有对应接口
var repositoryDllFile = Path.Combine(basePath, "ZC.Customer.Repository.dll");
var assemblysRepository = Assembly.LoadFrom(repositoryDllFile);
builder.RegisterAssemblyTypes(assemblysRepository).AsImplementedInterfaces();
#endregion
}
catch (Exception)
{
throw new Exception("※※★※※ 如果你是第一次下载项目，请先对整个解决方案dotnet build（F6编译），然后再对api层 dotnet run（F5执行），\n因为解耦了，如果你是发布的模式，请检查bin文件夹是否存在Repository.dll和service.dll ※※★※※");
}
#endregion
//将services填充到Autofac容器生成器中
builder.Populate(services);
//使用已进行的组件登记创建新容器
var ApplicationContainer = builder.Build();
#endregion
#region 设置上传文件大小
services.Configure <FormOptions>(x => {
x.MultipartBodyLengthLimit = 300_000_000;//不到300M
});
#endregion
return(new AutofacServiceProvider(ApplicationContainer));//第三方IOC接管 core内置DI容器
}
public MetricsEventManagerTests()
{
_loggerFactory = new LoggerFactory();
_testLoggerProvider = new TestLoggerProvider();
_loggerFactory.AddProvider(_testLoggerProvider);
_functionExecutionEventArguments = new List <FunctionExecutionEventArguments>();
_mockEventGenerator = new Mock <IEventGenerator>();
_mockEventGenerator.Setup(e => e.LogFunctionExecutionEvent(
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <int>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <long>(),
It.IsAny <bool>()))
.Callback((string executionId, string siteName, int concurrency, string functionName, string invocationId, string executionStage, long executionTimeSpan, bool success) =>
{
if (_throwOnExecutionEvent && executionStage == ExecutionStage.InProgress.ToString())
{
_throwOnExecutionEvent = false;
throw new Exception("Kaboom!");
}
lock (_syncLock)
{
_functionExecutionEventArguments.Add(new FunctionExecutionEventArguments(executionId, siteName, concurrency, functionName, invocationId, executionStage, executionTimeSpan, success));
}
});
_events = new List <SystemMetricEvent>();
_mockEventGenerator.Setup(p => p.LogFunctionMetricEvent(
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <long>(),
It.IsAny <long>(),
It.IsAny <long>(),
It.IsAny <long>(),
It.IsAny <DateTime>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>()))
.Callback((string subscriptionId, string appName, string functionName, string eventName, long average, long min, long max, long count, DateTime eventTimestamp, string data, string runtimeSiteName, string slotName) =>
{
var evt = new SystemMetricEvent
{
FunctionName = functionName,
EventName = eventName,
Average = average,
Minimum = min,
Maximum = max,
Count = count,
Data = data,
RuntimeSiteName = runtimeSiteName,
SlotName = slotName
};
lock (_syncLock)
{
_events.Add(evt);
}
});
_mockEventPublisher = new Mock <IMetricsPublisher>();
_mockAppServiceOptions = new Mock <IOptionsMonitor <AppServiceOptions> >();
_mockAppServiceOptions.Setup(a => a.CurrentValue).Returns(new AppServiceOptions {
AppName = "RandomAppName", SubscriptionId = Guid.NewGuid().ToString()
});
_linuxFunctionExecutionActivityPublisher = new Mock <ILinuxContainerActivityPublisher>();
var logger = _loggerFactory.CreateLogger <MetricsEventManager>();
_metricsEventManager = new MetricsEventManager(_mockAppServiceOptions.Object, _mockEventGenerator.Object, MinimumLongRunningDurationInMs / 1000, _mockEventPublisher.Object, _linuxFunctionExecutionActivityPublisher.Object, logger);
_metricsLogger = new WebHostMetricsLogger(_metricsEventManager);
}
public override void ConfigureServiceCollection(IServiceCollection services)
{
Configuration = new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.Build();
//var mapperconfig = new MapperConfiguration(cfg =>
//{
// cfg.CreateMap<AssetSettingsListDto, AssetSettingsDetails>();
// cfg.CreateMap<AssetSettingsDto, AssetSettingsResponse>();
//});
//var mapper = mapperconfig.CreateMapper();
serviceTypeParameters = LoadJson <ServiceTypeParameterDto>("ExternalObjects\\STP_Cache.json");
deviceTypeParameters = LoadJson <DeviceTypeParameterAttributeDto>("ExternalObjects\\DTP_Cache.json");
StubServiceTypeParameterRepository = Substitute.For <IServiceTypeParameterRepository>();
StubServiceTypeParameterRepository.FetchAllServiceTypeParameter().ReturnsForAnyArgs(x => { return(serviceTypeParameters); });
StubDeviceTypeParameterAttributeRepository = Substitute.For <IDeviceTypeParameterAttributeRepository>();
StubDeviceTypeParameterAttributeRepository.Fetch(Arg.Any <DeviceTypeParameterAttributeDto>()).ReturnsForAnyArgs(x => { return(deviceTypeParameters); });
#region Log - Configuration - StartUpObjects
ILoggerFactory loggerFactory = new LoggerFactory();
var logger = new LoggerConfiguration().ReadFrom.Configuration(Configuration);
loggerFactory.AddProvider(new SerilogLoggerProvider(logger.CreateLogger()));
services.AddSingleton(loggerFactory.CreateLogger(GetType()));
services.AddSingleton <IInjectConfig>(this);
services.AddSingleton <IConfiguration>(Configuration);
services.Configure <Configurations>(Configuration);
Configurations configurations = new Configurations();
Configuration.Bind(configurations);
services.AddSingleton(Options.Create <Configurations>(configurations));
services.AddScoped <ILoggingService, LoggingService>();
services.AddScoped <LogRequestContext>();
//services.AddScoped<IStartUpObject, StartUpCacheUpdater>();
#endregion
#region Cache
services.AddSingleton <ICache>(new ParameterAttributeMemoryCache("ParameterAttributeCache",
new CacheItemPolicy
{
Priority = CacheItemPriority.NotRemovable
}
));
services.AddSingleton <ICache>(new ServiceTypeParameterMemoryCache("ServiceTypeParameterCache",
new CacheItemPolicy
{
Priority = CacheItemPriority.NotRemovable
}
));
services.AddSingleton <IDeviceTypeParameterAttributeRepository>(x => StubDeviceTypeParameterAttributeRepository);
services.AddSingleton <IServiceTypeParameterRepository>(x => StubServiceTypeParameterRepository);
services.AddScoped <Infrastructure.Cache.Interfaces.IParameterAttributeCache, ParameterAttributeCache>();
services.AddScoped <IServiceTypeParameterCache, ServiceTypeParameterCache>();
#endregion
#region ConfigNameValueCollection & ConfigListsCollection
//UIParameter to DBAttribute Mapper
services.AddSingleton <DeviceConfigRequestToAttributeMaps>(this.BuildConfigNameValueCollection <DeviceConfigRequestToAttributeMaps>("deviceConfigParameterAttributeMaps", false));
services.AddSingleton <DeviceConfigAttributeToRequestMaps>(this.BuildConfigNameValueCollection <DeviceConfigAttributeToRequestMaps>("deviceConfigParameterAttributeMaps", true));
services.AddSingleton <DeviceConfigParameterNames>(this.BuildConfigNameValueCollection <DeviceConfigParameterNames>("deviceConfigParameterName", false));
services.AddSingleton <ConfigListsCollection>(new ParameterGroupsNonMandatoryLists
{
Values = new List <string>(Configuration["AppSettings:DeviceConfigParameterGroupsNonMandatoryLists"].Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries))
});
services.AddSingleton <ConfigListsCollection>(new ParametersNonMandatoryLists
{
Values = new List <string>(Configuration["AppSettings:DeviceConfigParametersNonMandatoryLists"].Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries))
});
services.AddSingleton <ConfigListsCollection>(new AttributesNonMandatoryLists
{
Values = new List <string>(Configuration["AppSettings:DeviceConfigAttributesNonMandatoryLists"].Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries))
});
#endregion
#region Transactions
services.AddSingleton <ITransactions, ExecuteTransaction>();
#endregion
#region Subscription
//services.AddScoped<IRequestValidator<DeviceConfigRequestBase>, SubscriptionValidator>();
services.AddScoped <ISubscriptionServicePlanRepository, SubscriptionServicePlanRepository>();
#endregion
#region Validators
//Service Request Validators
services.AddScoped <IRequestValidator <IServiceRequest>, CustomerUIDValidator>();
services.AddScoped <IRequestValidator <IServiceRequest>, UserUIDValidator>();
services.AddScoped <IRequestValidator <DevicePingLogRequest>, PingValidator>();
//Device Config Request Validators
services.AddScoped <IRequestValidator <DeviceConfigRequestBase>, DeviceTypeParameterGroupValidator>();
services.AddScoped <IRequestValidator <DeviceConfigRequestBase>, DeviceTypeValidator>();
services.AddScoped <IRequestValidator <DeviceConfigRequestBase>, AssetUIDsValidator>();
services.AddScoped <IRequestValidator <DeviceConfigRequestBase>, AllAttributeAsMandatoryValidator>();
#endregion
services.AddScoped <IAssetDeviceRepository, AssetDeviceRepository>();
services.AddScoped <IMessageConstructor, MessageConstructor>();
//Acknowledgement Bypasser
services.AddScoped <IAckBypasser, AcknowledgementBypasser>();
//Device Config Settings Base
services.AddScoped <IDeviceConfigSettingConfig, DeviceConfigSettingConfigBase>();
services.AddScoped <IGroupSettingsConfig, MetersSettingsConfig>();
#region Device Parameter Groups
//Service
services.AddScoped <IDeviceConfigService <DeviceConfigParameterGroupRequest, ParameterGroupDetails>, DeviceConfigParamGroupService>();
//Repository
services.AddScoped <IDeviceParamGroupRepository, DeviceParamGroupRepository>();
#endregion
#region Device Parameters
//Service
services.AddScoped <DeviceConfigParmetersServiceBase, DeviceConfigParamService>();
//Validators
services.AddScoped <IRequestValidator <DeviceConfigParameterRequest>, DeviceParameterGroupByIdValidator>();
//Repository
services.AddScoped <IDeviceParamRepository, DeviceParamRepository>();
#endregion
#region Repository
//Repository
services.AddScoped <IDeviceConfigRepository, DeviceConfigRepository.MySql.DeviceConfig.DeviceConfigRepository>();
services.AddScoped <IUserAssetRepository, UserAssetRepository>();
services.AddScoped <IDeviceTypeRepository, DeviceTypeRepository>();
services.AddScoped <ISubscriptionServicePlanRepository, SubscriptionServicePlanRepository>();
#endregion
#region Asset Security
//Service
services.AddScoped <IDeviceConfigService <DeviceConfigAssetSecurityRequest, DeviceConfigAssetSecurityDetails>, DeviceConfigAssetSecurityService>();
//Validator
services.AddScoped <IRequestValidator <DeviceConfigAssetSecurityRequest>, AssetSecurityValidator>();
#endregion
#region Fault Code Reporting
services.AddScoped <IDeviceConfigService <DeviceConfigFaultCodeReportingRequest, DeviceConfigFaultCodeReportingDetails>, DeviceConfigFaultCodeReportingService>();
//Validator
services.AddScoped <IRequestValidator <DeviceConfigFaultCodeReportingRequest>, FaultCodeReportingValidator>();
#endregion
#region Reporting Schedule
//Service
services.AddScoped <IDeviceConfigService <DeviceConfigReportingScheduleRequest, DeviceConfigReportingScheduleDetails>, DeviceConfigReportingScheduleService>();
//Validator
services.AddScoped <IRequestValidator <DeviceConfigReportingScheduleRequest>, ReportingScheduleValidator>();
#endregion
#region Moving Threshold
//Service
services.AddScoped <IDeviceConfigService <DeviceConfigMovingThresholdRequest, DeviceConfigMovingThresholdDetails>, DeviceConfigMovingThresholdService>();
//Validator
services.AddScoped <IRequestValidator <DeviceConfigMovingThresholdRequest>, MovingThresholdValidator>();
#endregion
#region Speeding Thresholds
//Service
services.AddScoped <IDeviceConfigService <DeviceConfigSpeedingThresholdsRequest, DeviceConfigSpeedingThresholdsDetails>, DeviceConfigSpeedingThresholdsService>();
//Validator
services.AddScoped <IRequestValidator <DeviceConfigSpeedingThresholdsRequest>, SpeedingThresholdsValidator>();
#endregion
#region Meters
//Service
services.AddScoped <IDeviceConfigService <DeviceConfigMetersRequest, DeviceConfigMetersDetails>, DeviceConfigMetersService>();
//Validator
services.AddScoped <IRequestValidator <DeviceConfigMetersRequest>, MetersValidator>();
#endregion
#region Maintenance Mode
//Service
services.AddScoped <IDeviceConfigService <DeviceConfigMaintenanceModeRequest, DeviceConfigMaintenanceModeDetails>, DeviceConfigMaintenanceModeService>();
//Validator
services.AddScoped <IRequestValidator <DeviceConfigMaintenanceModeRequest>, MaintenanceModeValidator>();
#endregion
//Service
//services.AddSingleton<IDeviceConfigService<DeviceConfigAssetSecurityRequest, DeviceConfigAssetSecurityDetails>, DeviceSettingsService>();
services.AddSingleton <T>();
}
static void Main(string[] args)
{
ServicePointManager.DefaultConnectionLimit = 100;
IWebHost host = null;
var processor = new ConsoleLoggerProcessor();
CustomConsoleLogProvider loggerProvider = new CustomConsoleLogProvider(processor);
using var loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(loggerProvider);
var logger = loggerFactory.CreateLogger("Configuration");
IConfiguration conf = null;
try
{
// This is the only way that LoadArgs can print to console. Because LoadArgs is called by the HostBuilder before Logs.Configure is called
conf = new DefaultConfiguration()
{
Logger = logger
}.CreateConfiguration(args);
if (conf == null)
{
return;
}
Logs.Configure(loggerFactory);
new BTCPayServerOptions().LoadArgs(conf);
Logs.Configure(null);
/////
host = new WebHostBuilder()
.UseKestrel()
.UseIISIntegration()
.UseContentRoot(Directory.GetCurrentDirectory())
.UseConfiguration(conf)
.ConfigureLogging(l =>
{
l.AddFilter("Microsoft", LogLevel.Error);
l.AddFilter("System.Net.Http.HttpClient", LogLevel.Critical);
l.AddFilter("Microsoft.AspNetCore.Antiforgery.Internal", LogLevel.Critical);
l.AddProvider(new CustomConsoleLogProvider(processor));
})
.UseStartup <Startup>()
.Build();
host.StartWithTasksAsync().GetAwaiter().GetResult();
var urls = host.ServerFeatures.Get <IServerAddressesFeature>().Addresses;
foreach (var url in urls)
{
logger.LogInformation("Listening on " + url);
}
host.WaitForShutdown();
}
catch (ConfigException ex)
{
if (!string.IsNullOrEmpty(ex.Message))
{
Logs.Configuration.LogError(ex.Message);
}
}
catch (Exception e) when(PluginManager.IsExceptionByPlugin(e))
{
var pluginDir = new DataDirectories().Configure(conf).PluginDir;
PluginManager.DisablePlugin(pluginDir, e.Source);
}
finally
{
processor.Dispose();
if (host == null)
{
Logs.Configuration.LogError("Configuration error");
}
if (host != null)
{
host.Dispose();
}
Serilog.Log.CloseAndFlush();
loggerProvider.Dispose();
}
}
public ThresholdTracerTests(ITestOutputHelper testOutputHelper)
{
_loggerFactory = new LoggerFactory();
_loggerFactory.AddProvider(new XUnitLoggerProvider(testOutputHelper));
}
public void AddProvider(ILoggerProvider provider) => _loggerFactory.AddProvider(provider);
private const long MAX_DEBUG_LOG_FILE_SIZE = 2000000; // If debug log is in use roll it every N MB.
static void Main(string[] args)
{
ServicePointManager.DefaultConnectionLimit = 100;
IWebHost host = null;
var processor = new ConsoleLoggerProcessor();
CustomConsoleLogProvider loggerProvider = new CustomConsoleLogProvider(processor);
var loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(loggerProvider);
var logger = loggerFactory.CreateLogger("Configuration");
try
{
// This is the only way that LoadArgs can print to console. Because LoadArgs is called by the HostBuilder before Logs.Configure is called
var conf = new DefaultConfiguration()
{
Logger = logger
}.CreateConfiguration(args);
if (conf == null)
{
return;
}
Logs.Configure(loggerFactory);
new BTCPayServerOptions().LoadArgs(conf);
Logs.Configure(null);
/////
host = new WebHostBuilder()
.UseKestrel()
.UseIISIntegration()
.UseContentRoot(Directory.GetCurrentDirectory())
.UseConfiguration(conf)
.ConfigureLogging(l =>
{
l.AddFilter("Microsoft", LogLevel.Error);
l.AddFilter("System.Net.Http.HttpClient", LogLevel.Critical);
l.AddFilter("Microsoft.AspNetCore.Antiforgery.Internal", LogLevel.Critical);
l.AddFilter("AspNet.Security.OpenIdConnect.Server.OpenIdConnectServerHandler", LogLevel.Error);
l.AddProvider(new CustomConsoleLogProvider(processor));
// Use Serilog for debug log file.
var debugLogFile = BTCPayServerOptions.GetDebugLog(conf);
if (string.IsNullOrEmpty(debugLogFile) != false)
{
return;
}
Serilog.Log.Logger = new LoggerConfiguration()
.Enrich.FromLogContext()
.MinimumLevel.Is(BTCPayServerOptions.GetDebugLogLevel(conf))
.WriteTo.File(debugLogFile, rollingInterval: RollingInterval.Day, fileSizeLimitBytes: MAX_DEBUG_LOG_FILE_SIZE, rollOnFileSizeLimit: true, retainedFileCountLimit: 1)
.CreateLogger();
l.AddSerilog(Serilog.Log.Logger);
})
.UseStartup <Startup>()
.Build();
host.StartWithTasksAsync().GetAwaiter().GetResult();
var urls = host.ServerFeatures.Get <IServerAddressesFeature>().Addresses;
foreach (var url in urls)
{
logger.LogInformation("Listening on " + url);
}
host.WaitForShutdown();
}
catch (ConfigException ex)
{
if (!string.IsNullOrEmpty(ex.Message))
{
Logs.Configuration.LogError(ex.Message);
}
}
finally
{
processor.Dispose();
if (host == null)
{
Logs.Configuration.LogError("Configuration error");
}
if (host != null)
{
host.Dispose();
}
Serilog.Log.CloseAndFlush();
loggerProvider.Dispose();
}
}
