public void AddProvider(ILoggerProvider provider) {
lock (_sync) {
_providers = _providers.Concat(new[] { provider }).ToArray();
foreach (var logger in _loggers)
logger.Value.AddProvider(provider);
}
}
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 ConfigurationOptionSettingsProvider(ILoggerProvider loggerProvider, IEc2Service ec2Service,
IElasticBeanstalkServiceConfigurationProvider configurationProvider)
{
this.configurationProvider = configurationProvider;
this.ec2Service = ec2Service;
this.loggerProvider = loggerProvider;
}
public IdentityManagementService(IIdentityManagementServiceConfigurationProvider configurationProvider,
ILoggerProvider loggerProvider)
{
this.loggerProvider = loggerProvider;
this.configurationProvider = configurationProvider;
credentials = new BasicAWSCredentials(configurationProvider.AccessKey, configurationProvider.SecretKey);
}
public CustomDiskCache(ILoggerProvider lp, string physicalCachePath, int subfolders, bool hashModifiedDate, long asyncMaxQueuedBytes)
{
this.lp = lp;
this.physicalCachePath = physicalCachePath;
this.subfolders = subfolders;
this.hashModifiedDate = hashModifiedDate;
this.CurrentWrites.MaxQueueBytes = asyncMaxQueuedBytes;
}
internal MethodWeaver(TypeReferenceProvider typeReferenceProvider, MethodReferenceProvider methodReferenceProvider,
ILoggerProvider loggerProvider, MethodDefinition methodDefinition)
{
_typeReferenceProvider = typeReferenceProvider;
_methodReferenceProvider = methodReferenceProvider;
_methodDefinition = methodDefinition;
_body = methodDefinition.Body;
_loggerProvider = loggerProvider;
}
/// <summary>
/// Adds the provider.
/// </summary>
/// <param name="providers">The providers.</param>
public void AddProvider(ILoggerProvider[] providers) {
lock (lockObject) {
_providers.AddRange(providers);
//When add the provider, will need to update the provider of original logger
foreach (var logger in _loggers) {
logger.Value.AddProvider(providers);
}
}
}
public DatabaseTool(
[CanBeNull] IServiceProvider serviceProvider,
[NotNull] ILoggerProvider loggerProvider)
{
Check.NotNull(loggerProvider, nameof(loggerProvider));
_serviceProvider = new ServiceProvider(serviceProvider);
_loggerProvider = loggerProvider;
}
public QueryEngineParameterValueProvider(IQueryEngine queryEngine, IResultBuilder resultBuilder, bool required, string name, ILoggerProvider loggerProvider)
{
_queryEngine = queryEngine;
ResultBuilder = resultBuilder;
Required = required;
Name = name;
TimerLogger = loggerProvider.GetLogger(LogHeirarchy.Root.Timer.Value, GetType());
FlowLogger = loggerProvider.GetLogger(LogHeirarchy.Root.Flow.Value, GetType());
}
/// <summary>
/// Creates and starts a thread that consumes the queue, pausing until notified when 'queue' empties.
/// </summary>
/// <param name="cs"></param>
/// <param name="queue"></param>
/// <param name="cache"></param>
public CleanupWorker(ILoggerProvider lp, CleanupStrategy cs, CleanupQueue queue, CustomDiskCache cache)
: base("DiskCache-CleanupWorker")
{
this.cs = cs;
this.queue = queue;
this.cache = cache;
this.lp = lp;
t = new Thread(main);
t.IsBackground = true;
t.Start();
}
public ElasticBeanstalkService(IElasticBeanstalkServiceConfigurationProvider configurationProvider, ILoggerProvider loggerProvider)
{
this.loggerProvider = loggerProvider;
this.configurationProvider = configurationProvider;
creds = new BasicAWSCredentials(configurationProvider.AccessKey, configurationProvider.SecretKey);
currentCNamePrefix = $"{configurationProvider.CNamePrefix}-{configurationProvider.DeploymentEnvironmentName}";
loggerProvider.GetLogger().Debug("Current CNamePrefix: {currentCNamePrefix}", currentCNamePrefix);
nextCNamePrefix = $"{configurationProvider.CNamePrefix}Next-{configurationProvider.DeploymentEnvironmentName}";
loggerProvider.GetLogger().Debug("Next CNamePrefix: {nextCNamePrefix}", nextCNamePrefix);
}
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 Program(IApplicationEnvironment appEnv, ILoggerProvider logProvider)
{
_logger = logProvider?.CreateLogger(this.GetType().ToString()) ?? new ConsoleLogger(this.GetType().ToString(), (catgory,level) => { return true; }, true);
Configuration =
new ConfigurationBuilder()
.SetBasePath(appEnv.ApplicationBasePath)
.AddJsonFile("config.json", true)
.Build();
_migrator = new Migrator(Configuration, appEnv.ApplicationName);
}
public DbContextOperations(
[NotNull] ILoggerProvider loggerProvider,
[NotNull] string assemblyName,
[NotNull] string startupAssemblyName,
[CanBeNull] string environment)
{
Check.NotNull(loggerProvider, nameof(loggerProvider));
Check.NotEmpty(assemblyName, nameof(assemblyName));
Check.NotEmpty(startupAssemblyName, nameof(startupAssemblyName));
_loggerProvider = loggerProvider;
_assemblyName = assemblyName;
_startupAssemblyName = startupAssemblyName;
_logger = new LazyRef<ILogger>(() => _loggerProvider.CreateCommandsLogger());
var startup = new StartupInvoker(startupAssemblyName, environment);
_runtimeServices = startup.ConfigureServices();
}
internal static void SetLoggerProvider(ILoggerProvider ilp)
{
lock (logInstances)
{
currentLoggerProvider = ilp;
foreach (KeyValuePair<string, ILog> aLog in logInstances)
{
if (ilp == null)
{
aLog.Value.setWrappedInstance(null);
}
else
{
aLog.Value.setWrappedInstance(currentLoggerProvider.GetLogger(aLog.Key));
}
}
}
}
public DatabaseOperations(
[NotNull] ILoggerProvider loggerProvider,
[NotNull] string assemblyName,
[NotNull] string startupAssemblyName,
[CanBeNull] string environment,
[NotNull] string projectDir,
[NotNull] string rootNamespace)
{
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));
_loggerProvider = loggerProvider;
_projectDir = projectDir;
_rootNamespace = rootNamespace;
var startup = new StartupInvoker(startupAssemblyName, environment);
_servicesBuilder = new DesignTimeServicesBuilder(startup);
}
public DbContextOperations([NotNull] ILoggerProvider loggerProvider,
[NotNull] Assembly assembly,
[NotNull] Assembly startupAssembly,
[CanBeNull] string environment,
[NotNull] string contentRootPath)
{
Check.NotNull(loggerProvider, nameof(loggerProvider));
Check.NotNull(assembly, nameof(assembly));
Check.NotNull(startupAssembly, nameof(startupAssembly));
Check.NotEmpty(contentRootPath, nameof(contentRootPath));
_loggerProvider = loggerProvider;
_assembly = assembly;
_startupAssembly = startupAssembly;
_environment = environment;
_contentRootPath = contentRootPath;
_logger = new LazyRef<ILogger>(() => _loggerProvider.CreateCommandsLogger());
var startup = new StartupInvoker(_logger, startupAssembly, environment, contentRootPath);
_runtimeServices = startup.ConfigureServices();
}
public CloudFrontDeployer(ElasticBeanstalkDeploymentConfigurationProvider configProvider,
IElasticBeanstalkService elasticBeanstalkService,
IS3Service s3Service,
ISmokeTestService smokeTestService,
IIdentityManagementService iamService,
ICloudFrontService cloudFrontService,
ISslUploaderService sslUploaderService,
IConfigurationOptionSettingsProvider configurationOptionSettingsProvider,
IRoute53Service route53Service,
ILoggerProvider loggerProvider)
{
this.configurationOptionSettingsProvider = configurationOptionSettingsProvider;
this.smokeTestService = smokeTestService;
this.elasticBeanstalkService = elasticBeanstalkService;
this.s3Service = s3Service;
this.configProvider = configProvider;
this.iamService = iamService;
this.cloudFrontService = cloudFrontService;
this.sslUploaderService = sslUploaderService;
this.route53Service = route53Service;
this.loggerProvider = loggerProvider;
}
public CleanupManager(ILoggerProvider lp, CustomDiskCache cache, CleanupStrategy cs)
{
this.cache = cache;
this.cs = cs;
this.lp = lp;
queue = new CleanupQueue();
//Called each request
cache.CacheResultReturned += delegate(CustomDiskCache sender, CacheResult r) {
if (r.Result == CacheQueryResult.Miss)
this.AddedFile(r.RelativePath); //It was either updated or added.
else
this.BeLazy();
};
//Called when the filesystem changes unexpectedly.
cache.Index.FileDisappeared += delegate(string relativePath, string physicalPath) {
if (lp.Logger != null) lp.Logger.Warn("File disappeared from the cache unexpectedly - reindexing entire cache. File name: {0}", relativePath);
//Stop everything ASAP and start a brand new cleaning run.
queue.ReplaceWith(new CleanupWorkItem(CleanupWorkItem.Kind.CleanFolderRecursive, "", cache.PhysicalCachePath));
worker.MayHaveWork();
};
worker = new CleanupWorker(lp, cs,queue,cache);
}
public DatabaseOperations(
[NotNull] ILoggerProvider loggerProvider,
[NotNull] AssemblyLoader startupAssemblyLoader,
[NotNull] Assembly startupAssembly,
[CanBeNull] string environment,
[NotNull] string projectDir,
[NotNull] string contentRootPath,
[NotNull] string rootNamespace)
{
Check.NotNull(startupAssemblyLoader, nameof(startupAssemblyLoader));
Check.NotNull(loggerProvider, nameof(loggerProvider));
Check.NotNull(startupAssembly, nameof(startupAssembly));
Check.NotNull(projectDir, nameof(projectDir));
Check.NotEmpty(contentRootPath, nameof(contentRootPath));
Check.NotNull(rootNamespace, nameof(rootNamespace));
_loggerProvider = loggerProvider;
_projectDir = projectDir;
_rootNamespace = rootNamespace;
var logger = new LazyRef<ILogger>(() => loggerProvider.CreateCommandsLogger());
var startup = new StartupInvoker(logger, startupAssembly, environment, contentRootPath);
_servicesBuilder = new DesignTimeServicesBuilder(startupAssemblyLoader, startup);
}
public static DbContextOptionsBuilder UseLoggerProvider(this DbContextOptionsBuilder builder, ILoggerProvider provider)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (provider == null)
{
throw new ArgumentNullException(nameof(provider));
}
var extension = builder.Options.FindExtension <CoreOptionsExtension>();
var loggerFactory = extension?.LoggerFactory;
if (extension.LoggerFactory != null)
{
loggerFactory.AddProvider(provider);
}
else
{
builder.UseLoggerFactory(new LoggerFactory(new ILoggerProvider[] {
provider
}));
}
return(builder);
}
public WebConfigWriter(ILoggerProvider lp, string physicalDirPath)
: this(lp,physicalDirPath, null)
{
}
public static void SetLoggerProvider(ILoggerProvider loggerProvider)
{
LogManager.SetLoggerProvider(loggerProvider);
}
public CustomDiskCache(ILoggerProvider lp, string physicalCachePath, int subfolders, bool hashModifiedDate)
: this(lp,physicalCachePath,subfolders,hashModifiedDate, 1024*1024*10)
{
}
/// <summary>
/// Adds a <see cref="ILoggerProvider" /> to the logger factory used by the driver.
/// <para>
/// Be sure to call this method before initializing the <see cref="ICluster"/> to ensure that
/// <see cref="ILoggerFactory"/> API is used as driver logging mechanism instead of
/// <see cref="Trace"/>.
/// </para>
/// </summary>
/// <param name="provider">The logger provider to add to the logger factory</param>
public static void AddLoggerProvider(ILoggerProvider provider)
{
UseLoggerFactory = true;
LoggerFactory.AddProvider(provider);
}
public S3Service(IS3ConfigurationProvider s3ConfigurationProvider, ILoggerProvider loggerProvider)
{
this.loggerProvider = loggerProvider;
this.s3ConfigurationProvider = s3ConfigurationProvider;
credentials = new BasicAWSCredentials(s3ConfigurationProvider.AccessKey, s3ConfigurationProvider.SecretKey);
}
public static ITestHost CreateJobHost(
IOptions <DurableTaskOptions> options,
string storageProvider,
Type durabilityProviderFactoryType,
ILoggerProvider loggerProvider,
INameResolver nameResolver,
IDurableHttpMessageHandlerFactory durableHttpMessageHandler,
ILifeCycleNotificationHelper lifeCycleNotificationHelper,
IMessageSerializerSettingsFactory serializerSettingsFactory,
Action <ITelemetry> onSend,
bool addDurableClientFactory,
ITypeLocator typeLocator)
{
// Unless otherwise specified, use legacy partition management for tests as it makes the task hubs start up faster.
// These tests run on a single task hub workers, so they don't test partition management anyways, and that is tested
// in the DTFx repo.
if (!options.Value.StorageProvider.ContainsKey(nameof(AzureStorageOptions.UseLegacyPartitionManagement)))
{
options.Value.StorageProvider.Add(nameof(AzureStorageOptions.UseLegacyPartitionManagement), true);
}
IHost host = new HostBuilder()
.ConfigureLogging(
loggingBuilder =>
{
loggingBuilder.AddProvider(loggerProvider);
})
.ConfigureWebJobs(
webJobsBuilder =>
{
if (addDurableClientFactory)
{
webJobsBuilder.AddDurableClientFactoryDurableTask(options);
}
else
{
webJobsBuilder.AddDurableTask(options, storageProvider, durabilityProviderFactoryType);
}
webJobsBuilder.AddAzureStorage();
})
.ConfigureServices(
serviceCollection =>
{
serviceCollection.AddSingleton(typeLocator);
serviceCollection.AddSingleton(nameResolver);
serviceCollection.AddSingleton(durableHttpMessageHandler);
if (lifeCycleNotificationHelper != null)
{
serviceCollection.AddSingleton(lifeCycleNotificationHelper);
}
if (serializerSettingsFactory != null)
{
serviceCollection.AddSingleton(serializerSettingsFactory);
}
if (onSend != null)
{
serviceCollection.AddSingleton <ITelemetryActivator>(serviceProvider =>
{
var durableTaskOptions = serviceProvider.GetService <IOptions <DurableTaskOptions> >();
var nameResolver = serviceProvider.GetService <INameResolver>();
var telemetryActivator = new TelemetryActivator(durableTaskOptions, nameResolver)
{
OnSend = onSend,
};
return(telemetryActivator);
});
}
})
.Build();
return(new FunctionsV2HostWrapper(host, options, nameResolver));
}
protected override async Task <int> ExecuteEngineAsync(
CommandContext commandContext,
PreviewCommandSettings commandSettings,
IEngineManager engineManager)
{
SetPipelines(commandContext, commandSettings, engineManager);
ExitCode exitCode = ExitCode.Normal;
ILogger logger = engineManager.Engine.Services.GetRequiredService <ILogger <Bootstrapper> >();
// Execute the engine for the first time
using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource())
{
if (!await engineManager.ExecuteAsync(cancellationTokenSource))
{
return((int)ExitCode.ExecutionError);
}
}
// Start the preview server
Dictionary <string, string> contentTypes = commandSettings.ContentTypes?.Length > 0
? GetContentTypes(commandSettings.ContentTypes)
: new Dictionary <string, string>();
ILoggerProvider loggerProvider = engineManager.Engine.Services.GetRequiredService <ILoggerProvider>();
IDirectory outputDirectory = engineManager.Engine.FileSystem.GetOutputDirectory();
Server previewServer = null;
if (outputDirectory.Exists)
{
previewServer = await StartPreviewServerAsync(
outputDirectory.Path,
commandSettings.Port,
commandSettings.ForceExt,
commandSettings.VirtualDirectory,
!commandSettings.NoReload,
contentTypes,
loggerProvider,
logger);
}
// Start the watchers
ActionFileSystemWatcher inputFolderWatcher = null;
if (!commandSettings.NoWatch)
{
logger.LogInformation("Watching paths(s) {0}", string.Join(", ", engineManager.Engine.FileSystem.InputPaths));
inputFolderWatcher = new ActionFileSystemWatcher(
outputDirectory.Path,
engineManager.Engine.FileSystem.GetInputDirectories().Select(x => x.Path),
true,
"*.*",
path =>
{
_changedFiles.Enqueue(path);
_messageEvent.Set();
});
}
// Start the message pump
CommandUtilities.WaitForControlC(
() =>
{
_exit.Set();
_messageEvent.Set();
},
logger);
// Wait for activity
while (true)
{
_messageEvent.WaitOne(); // Blocks the current thread until a signal
if (_exit)
{
break;
}
// Execute if files have changed
HashSet <string> changedFiles = new HashSet <string>();
while (_changedFiles.TryDequeue(out string changedFile))
{
if (changedFiles.Add(changedFile))
{
logger.LogDebug($"{changedFile} has changed");
}
}
if (changedFiles.Count > 0)
{
logger.LogInformation($"{changedFiles.Count} files have changed, re-executing");
// Reset caches when an error occurs during the previous preview
string existingResetCacheSetting = null;
bool setResetCacheSetting = false;
if (exitCode == ExitCode.ExecutionError)
{
existingResetCacheSetting = engineManager.Engine.Settings.GetString(Keys.ResetCache);
setResetCacheSetting = true;
ConfigurationSettings[Keys.ResetCache] = "true";
}
// If there was an execution error due to reload, keep previewing but clear the cache
using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource())
{
exitCode = await engineManager.ExecuteAsync(cancellationTokenSource)
? ExitCode.Normal
: ExitCode.ExecutionError;
}
// Reset the reset cache setting after removing it
if (setResetCacheSetting)
{
if (existingResetCacheSetting == null)
{
ConfigurationSettings.Remove(Keys.ResetCache);
}
{
ConfigurationSettings[Keys.ResetCache] = existingResetCacheSetting;
}
}
if (previewServer == null)
{
if (outputDirectory.Exists)
{
previewServer = await StartPreviewServerAsync(
outputDirectory.Path,
commandSettings.Port,
commandSettings.ForceExt,
commandSettings.VirtualDirectory,
!commandSettings.NoReload,
contentTypes,
loggerProvider,
logger);
}
}
else
{
await previewServer.TriggerReloadAsync();
}
}
// Check one more time for exit
if (_exit)
{
break;
}
logger.LogInformation("Hit Ctrl-C to exit");
_messageEvent.Reset();
}
// Shutdown
logger.LogInformation("Shutting down");
inputFolderWatcher?.Dispose();
previewServer?.Dispose();
return((int)exitCode);
}
public void AddProvider(ILoggerProvider provider)
{
var logger = provider.CreateLogger(_name);
_loggers = _loggers.Concat(new[] {logger}).ToArray();
}
/// <summary>
/// Initializes a new instance of the <see cref="LinqRepositoryContextBase"/> class.
/// </summary>
protected LinqRepositoryContextBase()
{
Conventions = RepositoryConventions.Default <LinqRepositoryContextBase>();
_loggerProvider = NullLoggerProvider.Instance;
}
public WebConfigWriter(ILoggerProvider lp, string physicalDirPath, string alternateWebConfigContents)
{
this.physicalDirPath = physicalDirPath;
this.lp = lp;
if (alternateWebConfigContents != null) this.webConfigContents = alternateWebConfigContents;
}
public static ILogger CreateCommandsLogger(this ILoggerProvider loggerProvider) => loggerProvider.CreateLogger(CommandsLoggerName);
public MqttNetLogger(ILoggerProvider loggerProvider)
{
_loggerProvider = loggerProvider;
}
public MemoryConnectionPool(ILoggerProvider loggerProvider)
{
logger = loggerProvider.CreateLogger("MemoryConnectionPool");
}
public void AddProvider(ILoggerProvider provider)
{
}
public bool TryAddProvider(ILoggerProvider provider)
{
return(_providers.TryAdd(provider.GetType().FullName, provider));
}
public ShaderLoader(ILoggerProvider loggerProvider)
{
_logger = loggerProvider.CreateLogger <ShaderLoader>();
}
public void AddProvider(ILoggerProvider provider)
{
throw new NotImplementedException();
}
/// <summary>
/// Does nothing. Used for testing purposes.
/// </summary>
/// <param name="provider">Not used provider parameter. Used for testing with ILogger service.</param>
public void AddProvider(ILoggerProvider provider)
{
// intentionally does nothing
}
public MqttNetChildLogger(string source, ILoggerProvider loggerProvider)
{
_source = source ?? string.Empty;
_logger = loggerProvider.CreateLogger(source);
_loggerProvider = loggerProvider;
}
public void AddProvider(ILoggerProvider provider)
{
System.Configuration.ConfigurationManager.GetSection("system.xml/xmlReader");
}
/// <summary>
/// Adds an <see cref="T:Microsoft.Extensions.Logging.ILoggerProvider" /> to the logging system.
/// </summary>
/// <param name="provider">The <see cref="T:Microsoft.Extensions.Logging.ILoggerProvider" />.</param>
public void AddProvider(ILoggerProvider provider)
{
SelfLog.WriteLine("Ignoring added logger provider {0}", provider);
}
internal void AddProvider(ILoggerProvider provider)
{
var logger = provider.Create(_name);
_loggers = _loggers.Concat(new[] { logger }).ToArray();
}
public void AddProvider(ILoggerProvider provider)
{
}
public GetScheduleForStore(IMessages messages, IHttpRequestConverter httpRequestConverter, ILoggerProvider log)
{
_messages = messages;
_httpRequestConverter = httpRequestConverter;
_log = log.CreateLogger(nameof(GetScheduleForStore));
}
