public void Load(IModuleConfiguration config, string modulePackagesPath, string extension, params string[] moduleNames)
{
_logger.Debug("Loading modules from: " + modulePackagesPath);
var paths = _resolver.GetAssemblyPaths(modulePackagesPath, string.Empty);
var catalog = new AggregateCatalog();
foreach (var path in paths)
{
_addToCatalog(path, catalog);
}
var container = new CompositionContainer(catalog);
var lazyModules = _getModules(container);
var modules = lazyModules
.Where(m => moduleNames.Contains(m.Metadata.Name) ||
(extension != null && m.Metadata.Extensions != null && (m.Metadata.Extensions.Split(',').Contains(extension))))
.Select(m => m.Value);
_logger.Debug("Initializing modules");
foreach (var module in modules)
{
_logger.Debug(string.Format("Initializing module:{0}", module.GetType().FullName));
module.Initialize(config);
}
_logger.Debug("Modules initialized");
}
private void RegisterFactoryMethod(IModuleConfiguration configuration, Type componentType, MethodInfo method)
{
var iface = method.ReturnType;
var factory = new FactoryMethodReference(componentType, method);
configuration.RegisterFactoryMethod(iface, factory);
}
public TheInitializeMethod()
{
_configMock.SetupGet(c => c.Debug).Returns(false);
_configMock.SetupGet(c => c.IsRepl).Returns(false);
_configMock.SetupGet(c => c.Cache).Returns(false);
_configMock.SetupGet(c => c.Overrides).Returns(_overrides);
_config = _configMock.Object;
}
public SettingsPageViewModel(IModuleConfiguration moduleConfiguration)
{
configuration = moduleConfiguration;
configuration.StreamingValueChanged += OnStreamingValueChanged;
configuration.CurrentCameraChanged += OnCurrentCameraChanged;
configuration.SupportedVideoSizesChanged += OnSupportedVideoSizesChanged;
configuration.CurrentVideoSizeChanged += OnCurrentVideoSizeChanged;
}
public void Initialize(IModuleConfiguration config)
{
Guard.AgainstNullArgument("config", config);
if (!config.Overrides.ContainsKey(typeof(IScriptEngine)))
{
config.ScriptEngine<MonoScriptEngine>();
}
}
public void Initialize(IModuleConfiguration config)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
config.FilePreProcessor<CompileOnlyOptionFilePreProcessor>();
}
public void Initialize(IModuleConfiguration config)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
var engineType = config.IsRepl ? typeof(VisualBasicReplEngine) : typeof(VisualBasicScriptEngine);
config.Overrides[typeof (IScriptEngine)] = engineType;
config.LineProcessor<VisualBasicNamespaceLineProcessor>();
}
public void Initialize(IModuleConfiguration config)
{
Guard.AgainstNullArgument("config", config);
if (!config.Overrides.ContainsKey(typeof(IScriptEngine)))
{
var engineType = config.Cache ? typeof(RoslynScriptPersistentEngine) : typeof(RoslynScriptEngine);
engineType = config.Debug ? typeof(RoslynScriptInMemoryEngine) : engineType;
engineType = config.Repl ? typeof(RoslynScriptEngine) : engineType;
config.Overrides[typeof(IScriptEngine)] = engineType;
}
}
public void Initialize(IModuleConfiguration config)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
var engineType = config.IsRepl ? typeof(VisualBasicReplEngine) : typeof(VisualBasicScriptEngine);
config.Overrides[typeof(IScriptEngine)] = engineType;
config.LineProcessor <VisualBasicNamespaceLineProcessor>();
}
public void Initialize(IModuleConfiguration config)
{
Guard.AgainstNullArgument("config", config);
if (!config.Overrides.ContainsKey(typeof(IScriptEngine)))
{
var engineType = config.Cache ? typeof(CSharpPersistentEngine) : typeof(CSharpScriptEngine);
engineType = config.Debug ? typeof(CSharpScriptInMemoryEngine) : engineType;
engineType = config.IsRepl ? typeof(CSharpReplEngine) : engineType;
config.Overrides[typeof(IScriptEngine)] = engineType;
}
}
public void Initialize(IModuleConfiguration config)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
var engineType = config.Cache ? typeof(CSharpPersistentEngine) : typeof(CSharpScriptEngine);
engineType = config.Debug ? typeof(CSharpScriptInMemoryEngine) : engineType;
engineType = config.IsRepl ? typeof(CSharpReplEngine) : engineType;
config.Overrides[typeof(IScriptEngine)] = engineType;
}
public VideoStreamingService(ICameraController cameraController, IImageEncoder imageEncoder,
IModuleConfiguration moduleConfiguration, IWebClient webClient)
{
encoder = imageEncoder;
SendImage += OnSendImage;
client = webClient;
controller = cameraController;
configuration = moduleConfiguration;
configuration.StreamingValueChanged += OnStreamingValueChanged;
configuration.CurrentVideoSizeChanged += OnCurrentVideoSizeChanged;
}
public void Initialize(IModuleConfiguration config)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
var engineType = config.Cache ? typeof(CSharpPersistentEngine) : typeof(CSharpScriptEngine);
engineType = config.Debug ? typeof(CSharpScriptInMemoryEngine) : engineType;
engineType = config.IsRepl ? typeof(CSharpReplEngine) : engineType;
config.Overrides[typeof(IScriptEngine)] = engineType;
}
public CameraPageViewModel(ICameraController cameraController, IModuleConfiguration moduleConfiguration,
ICommands moduleCommands)
{
controller = cameraController;
configuration = moduleConfiguration;
commands = moduleCommands;
configuration.StreamingValueChanged += OnStreamingChanged;
UpdateStreamingButtons(configuration.Streaming);
Window.Current.VisibilityChanged += OnVisibilityChanged;
}
/// <nodoc/>
private static IEnumerable <DirectoryMembershipFingerprinterRule> CreateFromConfig(
IModuleConfiguration moduleConfiguration,
StringTable stringTable)
{
foreach (var rule in moduleConfiguration.DirectoryMembershipFingerprinterRules)
{
yield return(new DirectoryMembershipFingerprinterRule(
rule.Name,
rule.Root,
rule.DisableFilesystemEnumeration,
rule.FileIgnoreWildcards.Select(wildCard => wildCard.ToString(stringTable)).ToList()));
}
}
/// <nodoc />
public ModuleConfiguration(IModuleConfiguration template, PathRemapper pathRemapper)
: base(template, pathRemapper)
{
Contract.Assume(template != null);
Contract.Assume(pathRemapper != null);
ModuleId = template.ModuleId;
Name = template.Name;
FileAccessAllowList = new List <IFileAccessAllowlistEntry>(template.FileAccessAllowList.Select(entry => new FileAccessAllowlistEntry(entry, pathRemapper)));
CacheableFileAccessAllowlist = new List <IFileAccessAllowlistEntry>(template.CacheableFileAccessAllowList.Select(entry => new FileAccessAllowlistEntry(entry, pathRemapper)));
DirectoryMembershipFingerprinterRules = new List <IDirectoryMembershipFingerprinterRule>(template.DirectoryMembershipFingerprinterRules.Select(rule => new DirectoryMembershipFingerprinterRule(rule, pathRemapper)));
Mounts = new List <IMount>(template.Mounts.Select(mount => new Mount(mount, pathRemapper)));
}
public void Load(IModuleConfiguration config, string[] modulePackagesPaths, string hostBin, string extension, params string[] moduleNames)
{
if (modulePackagesPaths == null) return;
_logger.Debug("Loading modules from: " + string.Join(", ", modulePackagesPaths.Select(i => i)));
var paths = new List<string>();
AddPaths(modulePackagesPaths, hostBin, paths);
var catalog = CreateAggregateCatalog(paths);
var container = new CompositionContainer(catalog);
var lazyModules = GetLazyModules(container);
InitializeModules(config, extension, moduleNames, lazyModules);
}
public ModuleContextCandidate(
Assembly assembly,
Type moduleConfigType,
LibraryModuleConfiguration libraryModuleConfiguration,
IModuleConfigurationManager moduleConfigurationManager,
EmbeddedFileProvider embeddedFileProvider,
IModuleConfiguration defaultModuleConfiguration
)
{
Assembly = assembly;
ModuleConfigType = moduleConfigType;
LibraryModuleConfiguration = libraryModuleConfiguration;
ModuleConfigurationManager = moduleConfigurationManager;
EmbeddedFileProvider = embeddedFileProvider;
DefaultModuleConfiguration = defaultModuleConfiguration;
}
public void Load(IModuleConfiguration config, string[] modulePackagesPaths, string hostBin, string extension,
params string[] moduleNames)
{
Guard.AgainstNullArgument("moduleNames", moduleNames);
if (modulePackagesPaths == null)
{
return;
}
// only CSharp module needed - use fast path
if (moduleNames.Length == 1 && DefaultCSharpModules.ContainsKey(moduleNames[0]) && (string.IsNullOrWhiteSpace(extension) || extension.Equals(DefaultCSharpExtension, StringComparison.InvariantCultureIgnoreCase)))
{
_logger.Debug("Only CSharp module is needed - will skip module lookup");
var csharpModuleAssembly = DefaultCSharpModules[moduleNames[0]];
var module = _assemblyUtility.LoadFile(Path.Combine(hostBin, csharpModuleAssembly));
if (module != null)
{
var moduleType = module.GetExportedTypes().FirstOrDefault(f => typeof(IModule).IsAssignableFrom(f));
if (moduleType != null)
{
var moduleInstance = Activator.CreateInstance(moduleType) as IModule;
if (moduleInstance != null)
{
_logger.Debug(String.Format("Initializing module: {0}", module.GetType().FullName));
moduleInstance.Initialize(config);
return;
}
}
}
}
_logger.Debug("Loading modules from: " + String.Join(", ", modulePackagesPaths.Select(i => i)));
var paths = new List <string>();
AddPaths(modulePackagesPaths, hostBin, paths);
var catalog = CreateAggregateCatalog(paths);
var container = new CompositionContainer(catalog);
var lazyModules = GetLazyModules(container);
InitializeModules(config, extension, moduleNames, lazyModules);
}
private void Initialize(IModuleConfiguration configuration)
{
if (configuration.FileAccessAllowList != null)
{
foreach (var allowlistEntry in configuration.FileAccessAllowList)
{
AddAllowListEntry(allowlistEntry, false);
}
}
if (configuration.CacheableFileAccessAllowList != null)
{
foreach (var allowlistEntry in configuration.CacheableFileAccessAllowList)
{
AddAllowListEntry(allowlistEntry, true);
}
}
}
public DataResult <bool> UpdateConfiguration(int id, IModuleConfiguration moduleConfiguration, Version configurationVersion)
{
try
{
m_dynamicModuleUoW.UpdateConfiguration(id, moduleConfiguration.Serialize(), configurationVersion);
return(Success(true));
}
catch (NoResultException <DynamicModuleEntity> e)
{
m_logger.LogWarning(e);
return(Error <bool>(m_translator.Translate("invalid-dynamic-module-id"), DataResultErrorCode.DynamicModuleNotExistId));
}
catch (DatabaseException e)
{
m_logger.LogWarning(e);
return(Error <bool>(e.Message));
}
}
public void HydrateModuleConfiguration(IModuleConfiguration configuration, IModuleConfigurationViewModel viewModel)
{
if (!(configuration is TConfig))
{
throw new InvalidOperationException(
$"Only type {typeof(TConfig)} can be hydrated"
);
}
if (!(viewModel is TViewModel))
{
throw new InvalidOperationException(
$"Only type {typeof(TViewModel)} can hydrate configuration"
);
}
HydrateModuleConfiguration((TConfig)configuration, (TViewModel)viewModel);
}
private void Initialize(IModuleConfiguration configuration)
{
if (configuration.FileAccessWhiteList != null)
{
foreach (var whitelistEntry in configuration.FileAccessWhiteList)
{
AddWhiteListEntry(whitelistEntry, false);
}
}
if (configuration.CacheableFileAccessWhitelist != null)
{
foreach (var whitelistEntry in configuration.CacheableFileAccessWhitelist)
{
AddWhiteListEntry(whitelistEntry, true);
}
}
}
public void Load(IModuleConfiguration config, string[] modulePackagesPaths, string hostBin, string extension,
params string[] moduleNames)
{
Guard.AgainstNullArgument("moduleNames", moduleNames);
if (modulePackagesPaths == null) return;
// only CSharp module needed - use fast path
if (moduleNames.Length == 1 && DefaultCSharpModules.ContainsKey(moduleNames[0]) && (string.IsNullOrWhiteSpace(extension) || extension.Equals(DefaultCSharpExtension, StringComparison.InvariantCultureIgnoreCase)))
{
_logger.Debug("Only CSharp module is needed - will skip module lookup");
var csharpModuleAssembly = DefaultCSharpModules[moduleNames[0]];
var module = _assemblyUtility.LoadFile(Path.Combine(hostBin, csharpModuleAssembly));
if (module != null)
{
var moduleType = module.GetExportedTypes().FirstOrDefault(f => typeof (IModule).IsAssignableFrom(f));
if (moduleType != null)
{
var moduleInstance = Activator.CreateInstance(moduleType) as IModule;
if (moduleInstance != null)
{
_logger.Debug(String.Format("Initializing module: {0}", module.GetType().FullName));
moduleInstance.Initialize(config);
return;
}
}
}
}
_logger.Debug("Loading modules from: " + String.Join(", ", modulePackagesPaths.Select(i => i)));
var paths = new List<string>();
AddPaths(modulePackagesPaths, hostBin, paths);
var catalog = CreateAggregateCatalog(paths);
var container = new CompositionContainer(catalog);
var lazyModules = GetLazyModules(container);
InitializeModules(config, extension, moduleNames, lazyModules);
}
public void Load(IModuleConfiguration config, string[] modulePackagesPaths, string hostBin, string extension, params string[] moduleNames)
{
if (modulePackagesPaths == null)
{
return;
}
_logger.Debug("Loading modules from: " + string.Join(", ", modulePackagesPaths.Select(i => i)));
var paths = new List <string>();
AddPaths(modulePackagesPaths, hostBin, paths);
var catalog = CreateAggregateCatalog(paths);
var container = new CompositionContainer(catalog);
var lazyModules = GetLazyModules(container);
InitializeModules(config, extension, moduleNames, lazyModules);
}
private void InitializeModules(IModuleConfiguration config, string extension, string[] moduleNames,
IEnumerable <Lazy <IModule, IModuleMetadata> > lazyModules)
{
var modules = lazyModules
.Where(m => moduleNames.Contains(m.Metadata.Name) ||
(extension != null && m.Metadata.Extensions != null &&
(m.Metadata.Extensions.Split(',').Contains(extension))) || m.Metadata.Autoload == true)
.Select(m => m.Value);
_logger.Debug("Initializing modules");
foreach (var module in modules)
{
_logger.Debug(string.Format("Initializing module: {0}", module.GetType().FullName));
module.Initialize(config);
}
_logger.Debug("Modules initialized");
}
private void InitializeModules(IModuleConfiguration config, string extension, string[] moduleNames,
IEnumerable<Lazy<IModule, IModuleMetadata>> lazyModules)
{
var modules = lazyModules
.Where(m => moduleNames.Contains(m.Metadata.Name) ||
(extension != null && m.Metadata.Extensions != null &&
(m.Metadata.Extensions.Split(',').Contains(extension))) || m.Metadata.Autoload == true)
.Select(m => m.Value);
_logger.Debug("Initializing modules");
foreach (var module in modules)
{
_logger.Debug(string.Format("Initializing module: {0}", module.GetType().FullName));
module.Initialize(config);
}
_logger.Debug("Modules initialized");
}
public void Load(IModuleConfiguration config, string[] modulePackagesPaths, string extension, params string[] moduleNames)
{
if (modulePackagesPaths == null)
{
return;
}
_logger.Debug("Loading modules from: " + string.Join(", ", modulePackagesPaths.Select(i => i)));
var paths = new List <string>();
foreach (var modulePackagesPath in modulePackagesPaths)
{
var modulePaths = _resolver.GetAssemblyPaths(modulePackagesPath);
paths.AddRange(modulePaths);
}
var catalog = new AggregateCatalog();
foreach (var path in paths)
{
_addToCatalog(path, catalog);
}
var container = new CompositionContainer(catalog);
var lazyModules = _getModules(container);
var modules = lazyModules
.Where(m => moduleNames.Contains(m.Metadata.Name) ||
(extension != null && m.Metadata.Extensions != null && (m.Metadata.Extensions.Split(',').Contains(extension))))
.Select(m => m.Value);
_logger.Debug("Initializing modules");
foreach (var module in modules)
{
_logger.Debug(string.Format("Initializing module: {0}", module.GetType().FullName));
module.Initialize(config);
}
_logger.Debug("Modules initialized");
}
static SliceFixture()
{
Environment.SetEnvironmentVariable(ModuleConfiguration.EnvironmentConfigurationKey, "moduletest");
Configuration = ModuleConfiguration.CreateConfiguration();
Configuration.Environment.Should().Be("moduletest");
//overrideConfiguration?.Invoke(Configuration);
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", true, true)
.AddEnvironmentVariables();
_configuration = builder.Build();
var startup = new Startup(_configuration);
var services = new ServiceCollection();
startup.ConfigureServices(services);
var provider = services.BuildServiceProvider();
_scopeFactory = provider.GetService <IServiceScopeFactory>();
_checkpoint = new Checkpoint();
}
public ModuleRegister(IConfiguration configuration)
{
this._configuration = configuration ??
throw new ArgumentNullException(nameof(configuration));
AppSettings appSettings = configuration.Get <AppSettings>();
this._modules = appSettings.Modules
.Select(s =>
{
Type type = Type.GetType(s.Type);
if (type == null)
{
throw new TypeLoadException(
$"Cannot load type \"{s.Type}\"");
}
IModuleConfiguration module = (IModuleConfiguration)Activator.CreateInstance(type);
return(module);
}
);
}
public void Initialize(IModuleConfiguration config)
{
config.Overrides[typeof(string)] = "module loaded";
}
public override void Configure(IModuleConfiguration configuration)
{
}
public CameraController(IModuleConfiguration moduleConfiguration)
{
configuration = moduleConfiguration;
configuration.CurrentVideoSizeChanged += OnCurrentVideoSizeChanged;
}
public abstract void Configure(IModuleConfiguration configuration);
public void Initialize(IModuleConfiguration config)
{
config.Overrides[typeof (string)] = "module loaded";
}
public void Initialize(IModuleConfiguration config)
{
config.LineProcessor<GistLineProcessor>();
}
public void Load(IModuleConfiguration config, string[] modulePackagesPaths, string hostBin, string extension,
params string[] moduleNames)
{
//todo: implement later
}
private static ModuleAction CreateNewModuleRoot(CloudCoreModule module, IModuleConfiguration moduleConfiguration)
{
var moduleRoot = new MenuRoot(module);
return moduleRoot;
}
public RTMWebClient(IModuleConfiguration moduleConfiguration)
{
configuration = moduleConfiguration;
}
public void Initialize(IModuleConfiguration config)
{
Console.WriteLine("Mono Engine initialized!");
if (!config.Overrides.ContainsKey(typeof(IScriptEngine)))
config.ScriptEngine<MonoScriptEngine>();
}
public void Initialize(IModuleConfiguration config)
{
config.ScriptEngine<LolCodeEngine>();
}
public ImageEncoder(IModuleConfiguration moduleConfiguration)
{
configuration = moduleConfiguration;
configuration.VideoQualityChanged += OnVideoQualityChanged;
configuration.StreamingValueChanged += OnStreamingValueChanged;
}
public void Initialize(IModuleConfiguration config)
{
Console.WriteLine("Mono Engine initialized!");
config.ScriptEngine<MonoScriptEngine>();
}
private static ModuleAction GetModuleRoot(CloudCoreModule module, IModuleConfiguration moduleConfiguration)
{
return Environment.LoadedModuleActions.GetRoot() ??
CreateNewModuleRoot(module, moduleConfiguration);
}
public CameraModuleCommands(IModuleConfiguration moduleConfiguration, INavigationService navigationService)
{
service = navigationService;
configuration = moduleConfiguration;
}
internal static void AddModuleActions(CloudCoreModule module, IModuleConfiguration moduleConfiguration)
{
var moduleRoot = GetModuleRoot(module, moduleConfiguration);
moduleConfiguration.LoadModuleActions(moduleRoot as MenuRoot);
}
public void Initialize(IModuleConfiguration config)
{
Console.WriteLine("brainfuck module initialized");
config.ScriptEngine<BrainfuckEngine>();
}
/// <summary>
/// Creates a new ComponentRegisterer for the given module configuration.
/// </summary>
/// <param name="configuration"></param>
public ComponentRegisterer(IModuleConfiguration configuration)
{
_configuration = configuration;
}
public void Initialize(IModuleConfiguration config)
{
Console.WriteLine("brainfuck module initialized");
config.ScriptEngine <BrainfuckEngine>();
}
private static IList <ModuleContext> GetAssemblies(IConfiguration configuration, ILoggerFactory loggerFactory)
{
var assemblyList = new List <ModuleContext>();
var defaultConfigurationSection = configuration.GetSection("DefaultConfiguration"); // module.*.json5
var configurationSection = configuration.GetSection("Configuration"); // modules-autogenerated.xml
var loadedAssemblies = new ConcurrentDictionary <string, Assembly>();
var moduleCandidatePerAssembly = new ConcurrentDictionary <string, IDictionary <string, ModuleContextCandidate> >();
var standaloneModuleCandidatePerAssembly = new ConcurrentDictionary <string, ModuleContextCandidate>();
foreach (var libraryModuleKeySection in defaultConfigurationSection.GetChildren())
{
var libraryModuleSection = defaultConfigurationSection.GetSection(libraryModuleKeySection.Key);
var generalModuleConfiguration = new LibraryModuleConfiguration();
libraryModuleSection.Bind(generalModuleConfiguration);
var assembly = loadedAssemblies.GetOrAdd(
generalModuleConfiguration.AssemblyName,
Assembly.Load
);
var moduleCandidate = moduleCandidatePerAssembly.GetOrAdd(
generalModuleConfiguration.AssemblyName,
(key) => new Dictionary <string, ModuleContextCandidate>()
);
var moduleConfigType = assembly.ExportedTypes.FirstOrDefault(
x => typeof(IModuleConfiguration).IsAssignableFrom(x)
);
var moduleConfigurationManagerType = assembly.ExportedTypes.FirstOrDefault(
x => typeof(IModuleConfigurationManager).IsAssignableFrom(x)
);
if (moduleConfigType != null)
{
var moduleConfigurationSection = libraryModuleSection.GetSection("Configuration");
IModuleConfiguration defaultModuleConfiguration = null;
if (moduleConfigurationSection.GetChildren().Any())
{
defaultModuleConfiguration = Activator.CreateInstance(moduleConfigType) as IModuleConfiguration;
moduleConfigurationSection.Bind(defaultModuleConfiguration);
}
IModuleConfigurationManager moduleConfigurationManager = null;
if (moduleConfigurationManagerType != null)
{
moduleConfigurationManager =
Activator.CreateInstance(moduleConfigurationManagerType) as IModuleConfigurationManager;
}
var embeddedFileProvider = new EmbeddedFileProvider(assembly);
if (string.IsNullOrEmpty(defaultModuleConfiguration?.Name))
{
assemblyList.Add(
new ModuleContext(
assembly,
moduleConfigType,
generalModuleConfiguration,
moduleConfigurationManager,
embeddedFileProvider,
null,
defaultModuleConfiguration
)
);
}
else
{
moduleCandidate.Add(
defaultModuleConfiguration.Name,
new ModuleContextCandidate(
assembly,
moduleConfigType,
generalModuleConfiguration,
moduleConfigurationManager,
embeddedFileProvider,
defaultModuleConfiguration
)
);
}
standaloneModuleCandidatePerAssembly.GetOrAdd(
generalModuleConfiguration.AssemblyName,
(key) => new ModuleContextCandidate(
assembly,
moduleConfigType,
generalModuleConfiguration,
moduleConfigurationManager,
embeddedFileProvider,
defaultModuleConfiguration
)
);
}
}
foreach (var libraryModuleKeySection in configurationSection.GetChildren())
{
var libraryModuleSection = configurationSection.GetSection(libraryModuleKeySection.Key);
var generalModuleConfiguration = new LibraryModuleConfiguration();
libraryModuleSection.Bind(generalModuleConfiguration);
if (
!loadedAssemblies.TryGetValue(generalModuleConfiguration.AssemblyName, out var assembly) ||
!moduleCandidatePerAssembly.TryGetValue(generalModuleConfiguration.AssemblyName, out var moduleCandidates)
)
{
// something went terribly wrong, try to keep it alive by continue
continue;
}
var moduleConfigType = assembly.ExportedTypes.FirstOrDefault(
x => typeof(IModuleConfiguration).IsAssignableFrom(x)
);
if (moduleConfigType != null)
{
IModuleConfiguration moduleConfiguration = null;
var configurationInstanceSection = libraryModuleSection.GetSection("Configuration");
if (configurationInstanceSection.GetChildren().Any())
{
moduleConfiguration = Activator.CreateInstance(moduleConfigType) as IModuleConfiguration;
configurationInstanceSection.Bind(moduleConfiguration);
}
if (
moduleConfiguration != null &&
!string.IsNullOrEmpty(moduleConfiguration.Name) &&
moduleCandidates.TryGetValue(moduleConfiguration.Name, out var moduleCandidate)
)
{
assemblyList.Add(
new ModuleContext(
moduleCandidate.Assembly,
moduleCandidate.ModuleConfigType,
moduleCandidate.LibraryModuleConfiguration,
moduleCandidate.ModuleConfigurationManager,
moduleCandidate.EmbeddedFileProvider,
moduleConfiguration,
moduleCandidate.DefaultModuleConfiguration
)
);
moduleCandidates.Remove(moduleConfiguration.Name);
}
else if (
moduleConfiguration != null &&
standaloneModuleCandidatePerAssembly.TryGetValue(
generalModuleConfiguration.AssemblyName,
out var standaloneModuleCandidate
)
)
{
assemblyList.Add(
new ModuleContext(
standaloneModuleCandidate.Assembly,
standaloneModuleCandidate.ModuleConfigType,
standaloneModuleCandidate.LibraryModuleConfiguration,
standaloneModuleCandidate.ModuleConfigurationManager,
standaloneModuleCandidate.EmbeddedFileProvider,
moduleConfiguration,
standaloneModuleCandidate.DefaultModuleConfiguration
)
);
}
else
{
loggerFactory?.CreateLogger <IModuleConfiguration>().LogWarning(
string.Format(
"Dynamic module of type '{0}' lack of configuration or name, skipping. Assuming only make available dynamic module for other purpose",
generalModuleConfiguration.AssemblyName
)
);
}
}
}
foreach (var moduleCandidates in moduleCandidatePerAssembly.Values)
{
foreach (var moduleCandidate in moduleCandidates.Values)
{
assemblyList.Add(
new ModuleContext(
moduleCandidate.Assembly,
moduleCandidate.ModuleConfigType,
moduleCandidate.LibraryModuleConfiguration,
moduleCandidate.ModuleConfigurationManager,
moduleCandidate.EmbeddedFileProvider,
null,
moduleCandidate.DefaultModuleConfiguration
)
);
}
}
return(assemblyList);
}
public void Initialize(IModuleConfiguration config)
{
Console.WriteLine("Web console initialized!");
config.Console<SignalRConsole>();
}
public void Initialize(IModuleConfiguration config)
{
Console.WriteLine("Web console initialized!");
config.Console <SignalRConsole>();
}
