public Program()
{
// a DI based application would get ILoggerFactory injected instead
var factory = new LoggerFactory();
// getting the logger immediately using the class's name is conventional
_logger = factory.CreateLogger(typeof(Program).FullName);
// providers may be added to an ILoggerFactory at any time, existing ILoggers are updated
#if !DNXCORE50
factory.AddNLog(new global::NLog.LogFactory());
#endif
factory.AddConsole();
factory.AddConsole((category, logLevel) => logLevel >= LogLevel.Critical && category.Equals(typeof(Program).FullName));
}
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.Options)
.Returns(new ElmOptions());
factory.AddProvider(new ElmLoggerProvider(elmStore, optionsMock.Object.Options));
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 void ConfigureServices()
{
IServiceProvider mainProv = CallContextServiceLocator.Locator.ServiceProvider;
IApplicationEnvironment appEnv = mainProv.GetService<IApplicationEnvironment>();
IRuntimeEnvironment runtimeEnv = mainProv.GetService<IRuntimeEnvironment>();
ILoggerFactory logFactory = new LoggerFactory();
logFactory.AddConsole(LogLevel.Information);
ServiceCollection sc = new ServiceCollection();
sc.AddInstance(logFactory);
sc.AddSingleton(typeof(ILogger<>), typeof(Logger<>));
sc.AddEntityFramework()
.AddSqlite()
.AddDbContext<StarDbContext>();
sc.AddSingleton<ILibraryManager, LibraryManager>(factory => mainProv.GetService<ILibraryManager>() as LibraryManager);
sc.AddSingleton<ICache, Cache>(factory => new Cache(new CacheContextAccessor()));
sc.AddSingleton<IExtensionAssemblyLoader, ExtensionAssemblyLoader>();
sc.AddSingleton<IStarLibraryManager, StarLibraryManager>();
sc.AddSingleton<PluginLoader>();
sc.AddSingleton(factory => mainProv.GetService<IAssemblyLoadContextAccessor>());
sc.AddInstance(appEnv);
sc.AddInstance(runtimeEnv);
Services = sc;
ServiceProvider = sc.BuildServiceProvider();
}
public MigrationsOperations(
[NotNull] ILoggerProvider loggerProvider,
[NotNull] string assemblyName,
[NotNull] string startupAssemblyName,
[NotNull] string projectDir,
[NotNull] string rootNamespace,
[CanBeNull] IServiceProvider dnxServices = null)
{
Check.NotNull(loggerProvider, nameof(loggerProvider));
Check.NotEmpty(assemblyName, nameof(assemblyName));
Check.NotEmpty(startupAssemblyName, nameof(startupAssemblyName));
Check.NotNull(projectDir, nameof(projectDir));
Check.NotNull(rootNamespace, nameof(rootNamespace));
var loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(loggerProvider);
_loggerProvider = loggerProvider;
_logger = new LazyRef<ILogger>(() => loggerFactory.CreateCommandsLogger());
_projectDir = projectDir;
_rootNamespace = rootNamespace;
_servicesBuilder = new DesignTimeServicesBuilder(dnxServices);
_contextOperations = new DbContextOperations(
loggerProvider,
assemblyName,
startupAssemblyName,
dnxServices);
}
public static ServiceProvider CreateTestServices(
IServiceProvider applicationServices,
Project project,
ReportingChannel channel)
{
var services = new ServiceProvider(applicationServices);
var loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(new TestHostLoggerProvider(channel));
services.Add(typeof(ILoggerFactory), loggerFactory);
var libraryExporter = applicationServices.GetRequiredService<ILibraryExporter>();
var export = libraryExporter.GetExport(project.Name);
var projectReference = export.MetadataReferences
.OfType<IMetadataProjectReference>()
.Where(r => r.Name == project.Name)
.FirstOrDefault();
services.Add(
typeof(ISourceInformationProvider),
new SourceInformationProvider(projectReference, loggerFactory.CreateLogger<SourceInformationProvider>()));
services.Add(typeof(ITestDiscoverySink), new TestDiscoverySink(channel));
services.Add(typeof(ITestExecutionSink), new TestExecutionSink(channel));
return services;
}
private static async Task Run(string[] args)
{
try
{
// This wont work...
// See https://github.com/aspnet/Configuration/issues/214
//var config = new ConfigurationBuilder();
//config.AddJsonFile("wiki.json");
var jsonConfig = new JsonConfigurationSource("wiki.json");
var config = new ConfigurationBuilder(jsonConfig);
var builder = new ContainerBuilder();
var module = new ConfigurationModule(config.Build());
builder.RegisterModule(module);
var loggerFactory = new LoggerFactory();
loggerFactory.AddConsole(LogLevel.Information);
builder.RegisterInstance(loggerFactory).As<ILoggerFactory>().SingleInstance();
builder.RegisterType<GetDescriptionAction>().AsImplementedInterfaces().InstancePerDependency();
builder.RegisterType<AddValueToAlternativeKeysAction>().AsImplementedInterfaces().InstancePerDependency();
builder.Register(ctx => new CompositeDictEntryAction(ctx.Resolve<IEnumerable<IDictEntryAction>>()))
.Keyed<IDictEntryAction>(DictEntryActionKey);
builder.Register(
ctx =>
new Wiki.Wiki(ctx.Resolve<HttpClient>(),
ctx.ResolveOptionalKeyed<IDictEntryAction>(DictEntryActionKey),
ctx.Resolve<ILoggerFactory>()))
.AsImplementedInterfaces()
.InstancePerDependency();
builder.RegisterInstance(new DictConfig
{
FilePath = Path.Combine("..", "..", "resources", "kindle_dict.html"),
OpfFilePath = Path.Combine("..", "..", "resources"),
TemplateFilePath = Path.Combine("..", "..", "resources", "knidle_dict_template.html"),
EntryTemplateFilePath = Path.Combine("..", "..", "resources", "knidle_dict_entry_template.html"),
OpfTemplateFilePath = Path.Combine("..", "..", "resources", "kindle_dict_template.opf"),
}).SingleInstance();
builder.RegisterType<Dict>().AsImplementedInterfaces().SingleInstance();
var logger = loggerFactory.CreateLogger(typeof (Program).FullName);
var container = builder.Build();
var wiki = container.Resolve<IWiki>();
logger.LogInformation("Getting wiki description...");
var wikiDesc = await wiki.GetDescriptionAsync().ConfigureAwait(false);
logger.LogInformation("Getting entries...");
var entries = await wiki.GetEntriesAsync().ConfigureAwait(false);
var dict = container.Resolve<IDict>();
logger.LogInformation("Saving dictionary...");
await dict.SaveAsync(wikiDesc, entries).ConfigureAwait(false);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
}
}
public async Task NtlmAuthenticationTest(ServerType serverType, RuntimeFlavor runtimeFlavor, RuntimeArchitecture architecture, string applicationBaseUrl)
{
var logger = new LoggerFactory()
.AddConsole(LogLevel.Warning)
.CreateLogger(string.Format("Ntlm:{0}:{1}:{2}", serverType, runtimeFlavor, architecture));
using (logger.BeginScope("NtlmAuthenticationTest"))
{
var musicStoreDbName = Guid.NewGuid().ToString().Replace("-", string.Empty);
var connectionString = string.Format(DbUtils.CONNECTION_STRING_FORMAT, musicStoreDbName);
var deploymentParameters = new DeploymentParameters(Helpers.GetApplicationPath(), serverType, runtimeFlavor, architecture)
{
ApplicationBaseUriHint = applicationBaseUrl,
EnvironmentName = "NtlmAuthentication", //Will pick the Start class named 'StartupNtlmAuthentication'
ApplicationHostConfigTemplateContent = (serverType == ServerType.IISExpress) ? File.ReadAllText("NtlmAuthentation.config") : null,
SiteName = "MusicStoreNtlmAuthentication", //This is configured in the NtlmAuthentication.config
UserAdditionalCleanup = parameters =>
{
if (!Helpers.RunningOnMono)
{
// Mono uses InMemoryStore
DbUtils.DropDatabase(musicStoreDbName, logger);
}
}
};
// Override the connection strings using environment based configuration
deploymentParameters.EnvironmentVariables
.Add(new KeyValuePair<string, string>(
"SQLAZURECONNSTR_DefaultConnection",
string.Format(DbUtils.CONNECTION_STRING_FORMAT, musicStoreDbName)));
using (var deployer = ApplicationDeployerFactory.Create(deploymentParameters, logger))
{
var deploymentResult = deployer.Deploy();
var httpClientHandler = new HttpClientHandler() { UseDefaultCredentials = true };
var httpClient = new HttpClient(httpClientHandler) { BaseAddress = new Uri(deploymentResult.ApplicationBaseUri) };
// Request to base address and check if various parts of the body are rendered & measure the cold startup time.
var response = await RetryHelper.RetryRequest(async () =>
{
return await httpClient.GetAsync(string.Empty);
}, logger: logger, cancellationToken: deploymentResult.HostShutdownToken);
Assert.False(response == null, "Response object is null because the client could not " +
"connect to the server after multiple retries");
var validator = new Validator(httpClient, httpClientHandler, logger, deploymentResult);
await validator.VerifyNtlmHomePage(response);
//Should be able to access the store as the Startup adds necessary permissions for the current user
await validator.AccessStoreWithPermissions();
logger.LogInformation("Variation completed successfully.");
}
}
}
static void Main(string[] args)
{
ILoggerFactory loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(new DiagnosticsLoggerProvider());
loggerFactory.AddConsole();
FooManager manager = new FooManager(loggerFactory);
manager.Run();
}
private async Task OpenIdConnectTestSuite(ServerType serverType, RuntimeFlavor runtimeFlavor, RuntimeArchitecture architecture, string applicationBaseUrl)
{
var logger = new LoggerFactory()
.AddConsole(LogLevel.Warning)
.CreateLogger(string.Format("OpenId:{0}:{1}:{2}", serverType, runtimeFlavor, architecture));
using (logger.BeginScope("OpenIdConnectTestSuite"))
{
var musicStoreDbName = Guid.NewGuid().ToString().Replace("-", string.Empty);
var connectionString = string.Format(DbUtils.CONNECTION_STRING_FORMAT, musicStoreDbName);
var deploymentParameters = new DeploymentParameters(Helpers.GetApplicationPath(), serverType, runtimeFlavor, architecture)
{
ApplicationBaseUriHint = applicationBaseUrl,
EnvironmentName = "OpenIdConnectTesting",
UserAdditionalCleanup = parameters =>
{
if (!Helpers.RunningOnMono)
{
// Mono uses InMemoryStore
DbUtils.DropDatabase(musicStoreDbName, logger);
}
}
};
// Override the connection strings using environment based configuration
deploymentParameters.EnvironmentVariables
.Add(new KeyValuePair<string, string>(
"SQLAZURECONNSTR_DefaultConnection",
string.Format(DbUtils.CONNECTION_STRING_FORMAT, musicStoreDbName)));
using (var deployer = ApplicationDeployerFactory.Create(deploymentParameters, logger))
{
var deploymentResult = deployer.Deploy();
var httpClientHandler = new HttpClientHandler();
var httpClient = new HttpClient(httpClientHandler) { BaseAddress = new Uri(deploymentResult.ApplicationBaseUri) };
// Request to base address and check if various parts of the body are rendered & measure the cold startup time.
var response = await RetryHelper.RetryRequest(async () =>
{
return await httpClient.GetAsync(string.Empty);
}, logger: logger, cancellationToken: deploymentResult.HostShutdownToken);
Assert.False(response == null, "Response object is null because the client could not " +
"connect to the server after multiple retries");
var validator = new Validator(httpClient, httpClientHandler, logger, deploymentResult);
await validator.VerifyHomePage(response);
// OpenIdConnect login.
await validator.LoginWithOpenIdConnect();
logger.LogInformation("Variation completed successfully.");
}
}
}
public MigrationTool([NotNull] ILoggerProvider loggerProvider, [NotNull] Assembly assembly)
{
Check.NotNull(loggerProvider, nameof(loggerProvider));
Check.NotNull(assembly, nameof(assembly));
var loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(loggerProvider);
_loggerProvider = loggerProvider;
_logger = new LazyRef<ILogger>(() => loggerFactory.CreateLogger<MigrationTool>());
_assembly = assembly;
}
public Logger(LoggerFactory loggerFactory, string name)
{
_loggerFactory = loggerFactory;
_name = name;
var providers = loggerFactory.GetProviders();
_loggers = new ILogger[providers.Length];
for (var index = 0; index != providers.Length; index++)
{
_loggers[index] = providers[index].CreateLogger(name);
}
}
public async static Task ProcessedImagesTrigger([QueueTrigger(QueueNames.Seen)]CloudQueueMessage message, CancellationToken cancellationToken)
{
var connectionFactory = new StorageConnectionFactory(CloudConfigurationManager.GetSetting("storageAccountConnection"));
var factory = new LoggerFactory();
factory.AddConsole();
factory.AddEventLog();
var logger = factory.CreateLogger("ToprakWebjobs");
var imageRepository = new ImageRepository(connectionFactory, logger);
var queueRepository = new QueueRepository(connectionFactory, logger);
IResultsRepository resultsRepository = new ResultsRepository(CloudConfigurationManager.GetSetting("Database"), logger);
var envelope = TutanakDataEnvelope.GorulmusTutanakMesajiFactory(message.AsString);
envelope.TutanakData.Image = (new Uri(envelope.TutanakData.Image)).Segments[2];
await resultsRepository.RecordResult(envelope);
var imageSeen = envelope.TutanakData;
var results = (await resultsRepository.GetTutanakResultsAsync(imageSeen.Image)).ToList();
var compareProperties =
typeof(GorulmusTutanakMesaji).GetProperties()
.Where(p => p.GetCustomAttributes(false).All(a => a.GetType() != typeof(NoCompareAttribute)))
.OrderBy(p => p.Name)
.Select(p => p.Name);
var resultHashGroups =
results.Select(
r =>
compareProperties.Select(p => r.GetType().GetProperty(p).GetValue(r)).Aggregate((i, j) => $"{i},{j}"))
.GroupBy(h => h)
.Select(g => g.Count())
.OrderByDescending(c => c).ToList();
var sameReadLimit = Convert.ToInt32(CloudConfigurationManager.GetSetting("SameReadLimit"));
if (resultHashGroups.Any() && resultHashGroups.Max() >= sameReadLimit)
{
await imageRepository.TransferToProcessed(imageSeen.Image, cancellationToken);
await resultsRepository.RecordReadSuccessResult(envelope);
} else
{
await
queueRepository.AddMessageAsync(
QueueNames.ToBeProcessed,
new CloudQueueMessage(imageRepository.GetUnprocessedUri(imageSeen.Image).AbsoluteUri),
cancellationToken);
}
}
// This function will get triggered/executed when a new message is written
// on an Azure Queue called queue.
public async static Task NewImagesTrigger([QueueTrigger(QueueNames.NewImages)]CloudQueueMessage message, CancellationToken cancellationToken)
{
var connectionFactory = new StorageConnectionFactory(CloudConfigurationManager.GetSetting("storageAccountConnection"));
var factory = new LoggerFactory();
factory.AddConsole();
factory.AddEventLog();
var logger = factory.CreateLogger("ToprakWebjobs");
var imageManager = new ImageManagerService(connectionFactory, logger);
await imageManager.AddToCirculation(true, cancellationToken);
}
public DatabaseTool(
[CanBeNull] IServiceProvider serviceProvider,
[NotNull] ILoggerProvider loggerProvider)
{
Check.NotNull(loggerProvider, nameof(loggerProvider));
_serviceProvider = new ServiceProvider(serviceProvider);
var loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(loggerProvider);
_logger = new LazyRef<ILogger>(() => loggerFactory.CreateLogger<DatabaseTool>());
_serviceProvider.AddService(typeof(ILogger), _logger.Value);
_serviceProvider.AddService(typeof(CSharpCodeGeneratorHelper), new CSharpCodeGeneratorHelper());
_serviceProvider.AddService(typeof(ModelUtilities), new ModelUtilities());
}
public void Execute(string[] args)
{
var options = new Options();
Parser.Default.ParseArguments(args, options);
var factory = new LoggerFactory();
factory.AddConsole();
var logger = factory.CreateLogger("category-1");
int number = options.Number;
for (int i = 0; i < number; i++)
logger.LogInformation("message " + i);
}
// Please set the following connection strings in app.config for this WebJob to run:
// AzureWebJobsDashboard and AzureWebJobsStorage
public static void Main()
{
var connectionFactory = new StorageConnectionFactory(CloudConfigurationManager.GetSetting("storageAccountConnection"));
var factory = new LoggerFactory();
factory.AddConsole();
factory.AddEventLog();
var logger = factory.CreateLogger("ToprakWebjobs");
AppDomain.CurrentDomain.UnhandledException +=
(sender, args) => { logger.LogCritical(args.ExceptionObject.ToString()); };
var host = new JobHost();
// The following code ensures that the WebJob will be running continuously
host.RunAndBlock();
}
/// <summary>
/// Registers controller types from the specified <paramref name="assemblies"/> as services and as a source
/// for controller discovery.
/// </summary>
/// <param name="services">The <see cref="IServiceCollection"/>.</param>
/// <param name="controllerAssemblies">Assemblies to scan.</param>
/// <returns>The <see cref="IServiceCollection"/>.</returns>
public static IServiceCollection WithControllersAsServices(
[NotNull] this IServiceCollection services,
[NotNull] IEnumerable<Assembly> controllerAssemblies)
{
var assemblyProvider = new FixedSetAssemblyProvider();
foreach (var assembly in controllerAssemblies)
{
assemblyProvider.CandidateAssemblies.Add(assembly);
}
var loggerFactory = new LoggerFactory();
var controllerTypeProvider = new DefaultControllerTypeProvider(assemblyProvider, loggerFactory);
var controllerTypes = controllerTypeProvider.ControllerTypes;
return WithControllersAsServices(services, controllerTypes.Select(type => type.AsType()));
}
public void ConfigureServices(IServiceCollection services)
{
var loggerFactory = new LoggerFactory { MinimumLevel = LogLevel.Debug };
loggerFactory.AddConsole();
loggerFactory.AddDebug();
services.AddMvc(
config =>
{
config.Filters.Add(new GlobalFilter(loggerFactory));
});
services.AddScoped<ConsoleLogActionOneFilter>();
services.AddScoped<ConsoleLogActionTwoFilter>();
services.AddScoped<ClassConsoleLogActionBaseFilter>();
services.AddScoped<ClassConsoleLogActionOneFilter>();
}
public async void Invoke_WithMatchingPath_FulfillsRequest()
{
// Arrange
var elmStore = new ElmStore();
var factory = new LoggerFactory();
var optionsMock = new Mock<IOptions<ElmOptions>>();
optionsMock
.SetupGet(o => o.Options)
.Returns(new ElmOptions());
factory.AddProvider(new ElmLoggerProvider(elmStore, optionsMock.Object.Options));
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("/Elm");
using (var responseStream = new MemoryStream())
{
contextMock
.SetupGet(c => c.Response.Body)
.Returns(responseStream);
contextMock
.SetupGet(c => c.ApplicationServices)
.Returns(() => null);
// Act
await captureMiddleware.Invoke(contextMock.Object);
await pageMiddleware.Invoke(contextMock.Object);
string response = Encoding.UTF8.GetString(responseStream.ToArray());
// Assert
contextMock.VerifyGet(c => c.Request.Query, Times.AtLeastOnce());
Assert.True(response.Contains("<title>ASP.NET Logs</title>"));
}
}
public async Task HelloWorld(ServerType serverType, RuntimeFlavor runtimeFlavor, RuntimeArchitecture architecture, string applicationBaseUrl, ServerType delegateServer, bool noSource = false)
{
var logger = new LoggerFactory()
.AddConsole()
.CreateLogger($"HelloWorld:{serverType}:{runtimeFlavor}:{architecture}:{delegateServer}");
using (logger.BeginScope("HelloWorldTest"))
{
var deploymentParameters = new DeploymentParameters(Helpers.GetTestSitesPath(), serverType, runtimeFlavor, architecture)
{
ApplicationBaseUriHint = applicationBaseUrl,
Command = delegateServer == ServerType.WebListener ? "weblistener" : "web",
PublishWithNoSource = noSource,
EnvironmentName = "HelloWorld", // Will pick the Start class named 'StartupHelloWorld',
ApplicationHostConfigTemplateContent = (serverType == ServerType.IISExpress) ? File.ReadAllText("Http.config") : null,
SiteName = "HttpTestSite", // This is configured in the Http.config
};
using (var deployer = ApplicationDeployerFactory.Create(deploymentParameters, logger))
{
var deploymentResult = deployer.Deploy();
var httpClientHandler = new HttpClientHandler();
var httpClient = new HttpClient(httpClientHandler) { BaseAddress = new Uri(deploymentResult.ApplicationBaseUri) };
// Request to base address and check if various parts of the body are rendered & measure the cold startup time.
var response = await RetryHelper.RetryRequest(() =>
{
return httpClient.GetAsync(string.Empty);
}, logger, deploymentResult.HostShutdownToken);
var responseText = await response.Content.ReadAsStringAsync();
try
{
Assert.Equal("Hello World", responseText);
}
catch (XunitException)
{
logger.LogWarning(response.ToString());
logger.LogWarning(responseText);
throw;
}
}
}
}
public DatabaseTool(
[CanBeNull] IServiceProvider serviceProvider,
[NotNull] ILoggerProvider loggerProvider)
{
Check.NotNull(loggerProvider, nameof(loggerProvider));
_serviceProvider = new ServiceProvider(serviceProvider);
var loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(loggerProvider);
_logger = new LazyRef<ILogger>(() => loggerFactory.CreateLogger<DatabaseTool>());
_serviceProvider.AddService(typeof(ILogger), _logger.Value);
_serviceProvider.AddService(typeof(IFileService), new FileSystemFileService());
_serviceProvider.AddService(typeof(CSharpCodeGeneratorHelper), new CSharpCodeGeneratorHelper());
_serviceProvider.AddService(typeof(ModelUtilities), new ModelUtilities());
var metadataReferencesProvider = new MetadataReferencesProvider(_serviceProvider);
_serviceProvider.AddService(typeof(MetadataReferencesProvider), metadataReferencesProvider);
var compilationService = new RoslynCompilationService();
_serviceProvider.AddService(typeof(ITemplating), new RazorTemplating(compilationService, metadataReferencesProvider));
}
public static void Main(string[] args)
{
var loggerFactory = new LoggerFactory();
// This will write (1) to console with colors, and (2) to a rolling file with a custom formatting.
loggerFactory.AddSerilog(
new LoggerConfiguration()
.WriteTo.ColoredConsole()
.WriteTo.RollingFile( "dailylogs.log", Serilog.Events.LogEventLevel.Warning, "@{Timestamp:HH:mm:ss.fff} --- {Message}{NewLine}{Exception}{NewLine}")
);
var log = loggerFactory.Create("My test app");
log.WriteVerbose("This is verbose -- won't show up by default");
log.WriteInformation("This is just for your information");
log.WriteCritical("Something critical");
log.WriteWarning("just a warning");
log.WriteCritical("Another critical event, causing an exception", new Exception("testException"));
}
public void BeginScope_IgnoresExceptionInIntermediateLoggersAndThrowsAggregateException()
{
// Arrange
var store = new List<string>();
var loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(new CustomLoggerProvider("provider1", ThrowExceptionAt.None, store));
loggerFactory.AddProvider(new CustomLoggerProvider("provider2", ThrowExceptionAt.BeginScope, store));
loggerFactory.AddProvider(new CustomLoggerProvider("provider3", ThrowExceptionAt.None, store));
var logger = loggerFactory.CreateLogger("Test");
// Act
var aggregateException = Assert.Throws<AggregateException>(() => logger.BeginScope("Scope1"));
// Assert
Assert.Equal(new[] { "provider1.Test-Scope1", "provider3.Test-Scope1" }, store);
Assert.NotNull(aggregateException);
Assert.Equal("An error occurred while writing to logger(s).", aggregateException.Message);
Assert.Equal(1, aggregateException.InnerExceptions.Count);
var exception = aggregateException.InnerExceptions[0];
Assert.Equal("provider2.Test-Error occurred while creating scope.", exception.Message);
}
public void IsEnabled_IgnoresExceptionInIntermediateLoggers()
{
// Arrange
var store = new List<string>();
var loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(new CustomLoggerProvider("provider1", ThrowExceptionAt.None, store));
loggerFactory.AddProvider(new CustomLoggerProvider("provider2", ThrowExceptionAt.IsEnabled, store));
loggerFactory.AddProvider(new CustomLoggerProvider("provider3", ThrowExceptionAt.None, store));
var logger = loggerFactory.CreateLogger("Test");
// Act
var aggregateException = Assert.Throws<AggregateException>(() => logger.LogInformation("Hello!"));
// Assert
Assert.Equal(new[] { "provider1.Test-Hello!", "provider3.Test-Hello!" }, store);
Assert.NotNull(aggregateException);
Assert.Equal("An error occurred while writing to logger(s).", aggregateException.Message);
Assert.Equal(1, aggregateException.InnerExceptions.Count);
var exception = aggregateException.InnerExceptions[0];
Assert.Equal("provider2.Test-Error occurred while checking if logger is enabled.", exception.Message);
}
public void Log_AggregatesExceptionsFromMultipleLoggers()
{
// Arrange
var store = new List<string>();
var loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(new CustomLoggerProvider("provider1", ThrowExceptionAt.Log, store));
loggerFactory.AddProvider(new CustomLoggerProvider("provider2", ThrowExceptionAt.Log, store));
var logger = loggerFactory.CreateLogger("Test");
// Act
var aggregateException = Assert.Throws<AggregateException>(() => logger.LogInformation("Hello!"));
// Assert
Assert.Empty(store);
Assert.NotNull(aggregateException);
Assert.Equal("An error occurred while writing to logger(s).", aggregateException.Message);
var exceptions = aggregateException.InnerExceptions;
Assert.Equal(2, exceptions.Count);
Assert.Equal("provider1.Test-Error occurred while logging data.", exceptions[0].Message);
Assert.Equal("provider2.Test-Error occurred while logging data.", exceptions[1].Message);
}
protected override void Load(ContainerBuilder builder)
{
builder.Register(
c =>
{
var factory = new LoggerFactory();
factory.AddEventLog();
return factory.CreateLogger("ToprakWeb");
}).As<ILogger>().InstancePerLifetimeScope();
var connectionString = this.config["Data:ImageRepository:ConnectionString"];
var databaseConnectionString = this.config["Data:Database:ConnectionString"];
builder.Register(
c =>
connectionString == "Dev"
? new StorageConnectionFactory()
: new StorageConnectionFactory(connectionString))
.As<IStorageConnectionFactory>()
.InstancePerLifetimeScope();
builder.Register(c => new QueueRepository(c.Resolve<IStorageConnectionFactory>(), c.Resolve<ILogger>()))
.As<IQueueRepository>()
.InstancePerLifetimeScope();
builder.Register(c => new ImageRepository(c.Resolve<IStorageConnectionFactory>(), c.Resolve<ILogger>()))
.As<IImageRepository>()
.InstancePerLifetimeScope();
builder.Register(c => new ImageManagerService(c.Resolve<IQueueRepository>(), c.Resolve<IImageRepository>(), c.Resolve<ILogger>()))
.As<IImageManagerService>()
.InstancePerLifetimeScope();
builder.Register(c => new ResultsRepository.ResultsRepository(databaseConnectionString, c.Resolve<ILogger>()))
.As<IResultsRepository>()
.InstancePerLifetimeScope();
}
public Program()
{
// a DI based application would get ILoggerFactory injected instead
var factory = new LoggerFactory();
// getting the logger immediately using the class's name is conventional
_logger = factory.CreateLogger(typeof(Program).FullName);
// providers may be added to an ILoggerFactory at any time, existing ILoggers are updated
#if !DNXCORE50
factory.AddNLog(new global::NLog.LogFactory());
factory.AddSerilog(new Serilog.LoggerConfiguration()
.Enrich.WithMachineName()
.Enrich.WithProcessId()
.Enrich.WithThreadId()
.MinimumLevel.Debug()
.WriteTo.RollingFile("file-{Date}.txt", outputTemplate: "{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} {Level}:{EventId} [{SourceContext}] {Message}{NewLine}{Exception}")
.WriteTo.Sink(new RollingFileSink("file-{Date}.json", new JsonFormatter(), null, null))
.WriteTo.Sink(new FileSink("dump.txt", new RawFormatter(), null)));
#endif
factory.AddConsole();
factory.AddConsole((category, logLevel) => logLevel >= LogLevel.Critical && category.Equals(typeof(Program).FullName));
}
public async Task SmokeTestSuite(
ServerType serverType,
RuntimeFlavor donetFlavor,
RuntimeArchitecture architecture,
string applicationBaseUrl,
bool noSource = false)
{
var logger = new LoggerFactory()
.AddConsole()
.CreateLogger(string.Format("Smoke:{0}:{1}:{2}", serverType, donetFlavor, architecture));
using (logger.BeginScope("SmokeTestSuite"))
{
var musicStoreDbName = Guid.NewGuid().ToString().Replace("-", string.Empty);
var deploymentParameters = new DeploymentParameters(Helpers.GetApplicationPath(), serverType, donetFlavor, architecture)
{
ApplicationBaseUriHint = applicationBaseUrl,
EnvironmentName = "SocialTesting",
PublishWithNoSource = noSource,
UserAdditionalCleanup = parameters =>
{
if (!Helpers.RunningOnMono
&& parameters.ServerType != ServerType.IIS
&& parameters.ServerType != ServerType.IISNativeModule)
{
// Mono uses InMemoryStore
DbUtils.DropDatabase(musicStoreDbName, logger);
}
}
};
// Override the connection strings using environment based configuration
deploymentParameters.EnvironmentVariables
.Add(new KeyValuePair<string, string>(
"SQLAZURECONNSTR_DefaultConnection",
string.Format(DbUtils.CONNECTION_STRING_FORMAT, musicStoreDbName)));
using (var deployer = ApplicationDeployerFactory.Create(deploymentParameters, logger))
{
var deploymentResult = deployer.Deploy();
Helpers.SetInMemoryStoreForIIS(deploymentParameters, logger);
var httpClientHandler = new HttpClientHandler();
var httpClient = new HttpClient(httpClientHandler) { BaseAddress = new Uri(deploymentResult.ApplicationBaseUri) };
// Request to base address and check if various parts of the body are rendered & measure the cold startup time.
var response = await RetryHelper.RetryRequest(async () =>
{
return await httpClient.GetAsync(string.Empty);
}, logger: logger, cancellationToken: deploymentResult.HostShutdownToken);
var validator = new Validator(httpClient, httpClientHandler, logger, deploymentResult);
await validator.VerifyHomePage(response);
// Verify the static file middleware can serve static content.
await validator.VerifyStaticContentServed();
// Making a request to a protected resource should automatically redirect to login page.
await validator.AccessStoreWithoutPermissions();
// Register a user - Negative scenario where the Password & ConfirmPassword do not match.
await validator.RegisterUserWithNonMatchingPasswords();
// Register a valid user.
var generatedEmail = await validator.RegisterValidUser();
await validator.SignInWithUser(generatedEmail, "Password~1");
// Register a user - Negative scenario : Trying to register a user name that's already registered.
await validator.RegisterExistingUser(generatedEmail);
// Logout from this user session - This should take back to the home page
await validator.SignOutUser(generatedEmail);
// Sign in scenarios: Invalid password - Expected an invalid user name password error.
await validator.SignInWithInvalidPassword(generatedEmail, "InvalidPassword~1");
// Sign in scenarios: Valid user name & password.
await validator.SignInWithUser(generatedEmail, "Password~1");
// Change password scenario
await validator.ChangePassword(generatedEmail);
// SignIn with old password and verify old password is not allowed and new password is allowed
await validator.SignOutUser(generatedEmail);
await validator.SignInWithInvalidPassword(generatedEmail, "Password~1");
await validator.SignInWithUser(generatedEmail, "Password~2");
// Making a request to a protected resource that this user does not have access to - should
// automatically redirect to the configured access denied page
await validator.AccessStoreWithoutPermissions(generatedEmail);
// Logout from this user session - This should take back to the home page
await validator.SignOutUser(generatedEmail);
// Login as an admin user
await validator.SignInWithUser("*****@*****.**", "YouShouldChangeThisPassword1!");
// Now navigating to the store manager should work fine as this user has the necessary permission to administer the store.
await validator.AccessStoreWithPermissions();
// Create an album
var albumName = await validator.CreateAlbum();
var albumId = await validator.FetchAlbumIdFromName(albumName);
// Get details of the album
await validator.VerifyAlbumDetails(albumId, albumName);
// Verify status code pages acts on non-existing items.
await validator.VerifyStatusCodePages();
// Get the non-admin view of the album.
await validator.GetAlbumDetailsFromStore(albumId, albumName);
// Add an album to cart and checkout the same
await validator.AddAlbumToCart(albumId, albumName);
await validator.CheckOutCartItems();
// Delete the album from store
await validator.DeleteAlbum(albumId, albumName);
// Logout from this user session - This should take back to the home page
await validator.SignOutUser("Administrator");
// Google login
await validator.LoginWithGoogle();
// Facebook login
await validator.LoginWithFacebook();
// Twitter login
await validator.LoginWithTwitter();
// MicrosoftAccountLogin
await validator.LoginWithMicrosoftAccount();
logger.LogInformation("Variation completed successfully.");
}
}
}
private ServiceCollection SetupInitialServices()
{
var serviceCollection = new ServiceCollection();
#if DNX451 || DNXCORE50
var manifest = _serviceProvider.GetRequiredService<IServiceManifest>();
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;
}
public async Task Publish_And_Run_Tests(ServerType serverType, RuntimeFlavor runtimeFlavor, RuntimeArchitecture architecture, string applicationBaseUrl, bool noSource)
{
var logger = new LoggerFactory()
.AddConsole()
.CreateLogger(string.Format("Publish:{0}:{1}:{2}:{3}", serverType, runtimeFlavor, architecture, noSource));
using (logger.BeginScope("Publish_And_Run_Tests"))
{
var musicStoreDbName = Guid.NewGuid().ToString().Replace("-", string.Empty);
var connectionString = string.Format(DbUtils.CONNECTION_STRING_FORMAT, musicStoreDbName);
var deploymentParameters = new DeploymentParameters(Helpers.GetApplicationPath(), serverType, runtimeFlavor, architecture)
{
ApplicationBaseUriHint = applicationBaseUrl,
PublishApplicationBeforeDeployment = true,
PublishWithNoSource = noSource,
UserAdditionalCleanup = parameters =>
{
if (!Helpers.RunningOnMono)
{
// Mono uses InMemoryStore
DbUtils.DropDatabase(musicStoreDbName, logger);
}
}
};
// Override the connection strings using environment based configuration
deploymentParameters.EnvironmentVariables
.Add(new KeyValuePair<string, string>(
"SQLAZURECONNSTR_DefaultConnection",
string.Format(DbUtils.CONNECTION_STRING_FORMAT, musicStoreDbName)));
using (var deployer = ApplicationDeployerFactory.Create(deploymentParameters, logger))
{
var deploymentResult = deployer.Deploy();
var httpClientHandler = new HttpClientHandler() { UseDefaultCredentials = true };
var httpClient = new HttpClient(httpClientHandler) { BaseAddress = new Uri(deploymentResult.ApplicationBaseUri) };
// Request to base address and check if various parts of the body are rendered & measure the cold startup time.
// Add retry logic since tests are flaky on mono due to connection issues
var response = await RetryHelper.RetryRequest(async () =>
{
return await httpClient.GetAsync(string.Empty);
}, logger: logger, cancellationToken: deploymentResult.HostShutdownToken);
var validator = new Validator(httpClient, httpClientHandler, logger, deploymentResult);
await validator.VerifyHomePage(response);
// Static files are served?
await validator.VerifyStaticContentServed();
if (serverType != ServerType.IISExpress)
{
if (Directory.GetFiles(deploymentParameters.ApplicationPath, "*.cmd", SearchOption.TopDirectoryOnly).Length > 0)
{
throw new Exception("publishExclude parameter values are not honored.");
}
}
logger.LogInformation("Variation completed successfully.");
}
}
}
