/// <summary> /// Initializes an instance of the <see cref="ModuleManager"/> class. /// </summary> /// <param name="moduleInitializer">Service used for initialization of modules.</param> /// <param name="moduleCatalog">Catalog that enumerates the modules to be loaded and initialized.</param> /// <param name="loggerFacade">Logger used during the load and initialization of modules.</param> public ModuleManager(IModuleInitializer moduleInitializer, IModuleCatalog moduleCatalog, IAssemblyResolver assemblyResolver, ILogger <ModuleManager> loggerFacade) { _moduleInitializer = moduleInitializer ?? throw new ArgumentNullException("moduleInitializer"); _moduleCatalog = moduleCatalog ?? throw new ArgumentNullException("moduleCatalog"); _loggerFacade = loggerFacade ?? throw new ArgumentNullException("loggerFacade"); _assemblyResolver = assemblyResolver; }
/// <summary> /// Initializes a new instance of the <see cref="ModuleManagerWithLibraryCachingFix"/> class. /// </summary> /// <param name="moduleInitializer"> /// Service used for initialization of modules. /// </param> /// <param name="moduleCatalog"> /// Catalog that enumerates the modules to be loaded and initialized. /// </param> /// <param name="loggerFacade"> /// Logger used during the load and initialization of modules. /// </param> public ModuleManagerWithLibraryCachingFix( IModuleInitializer moduleInitializer, IModuleCatalog moduleCatalog, ILoggerFacade loggerFacade) : base(moduleInitializer, moduleCatalog, loggerFacade) { }
public MefModuleManager( IModuleInitializer moduleInitializer, IModuleCatalog moduleCatalog, ILoggerFacade loggerFacade) : base(moduleInitializer, moduleCatalog, loggerFacade) { }
public SortedModuleInitializer(IUnityContainer Container, ILoggerFacade Logger) { _logger = Logger; defaultInitializer = Container.Resolve<IModuleInitializer>("defaultModuleInitializer"); moduleConfigs = LoadModuleConfig(); Container.RegisterInstance<IModuleConfigs>("ModuleConfigs", moduleConfigs); }
public ModuleManager(IModuleInitializer moduleInitializer, IModuleCatalog moduleCatalog, ILoggerFacade loggerFacade, IApplicationContext container) { if (moduleInitializer == null) { throw new ArgumentNullException("moduleInitializer"); } if (moduleCatalog == null) { throw new ArgumentNullException("moduleCatalog"); } if (loggerFacade == null) { throw new ArgumentNullException("loggerFacade"); } if (container == null) { throw new ArgumentNullException("container"); } this.moduleInitializer = moduleInitializer; this.moduleCatalog = moduleCatalog; this.loggerFacade = loggerFacade; this.container = container; }
/// <summary> /// Loads the specified modules into the given container. /// </summary> /// <param name="rootContainer">The container into wich create and add the module published services.</param> /// <param name="modulesInfo">The list of modules to load.</param> /// <remarks>A <see cref="CompositionContainer"/> is created for every module in the list and added to the /// <paramref name="rootContainer"/>. The Load() method is called on every module that /// exposes a <see cref="IModuleInitializer"/>.</remarks> public void Load(CompositionContainer rootContainer, params IModuleInfo[] modulesInfo) { Guard.ArgumentNotNull(rootContainer, "compositionContainer"); Guard.ArgumentNotNull(modulesInfo, "modules"); foreach (IModuleInfo moduleInfo in modulesInfo) { Assembly moduleAssembly = Assembly.Load(moduleInfo.AssemblyName); CompositionContainer container = String.IsNullOrEmpty(moduleInfo.VirtualPath) ? rootContainer : rootContainer.Containers.AddNew <CompositionContainer>(moduleInfo.Name); LoadServices(container, moduleInfo); foreach (Type t in moduleAssembly.GetTypes()) { if (typeof(IModuleInitializer).IsAssignableFrom(t)) { IModuleInitializer init = (IModuleInitializer)container.BuildNewItem(t); _modules.Add(moduleInfo.Name, init); try { init.Load(container); } catch (Exception ex) { ThrowModuleLoadException(ex, moduleAssembly); } } } } }
public SortedModuleInitializer(IUnityContainer Container, ILoggerFacade Logger) { _logger = Logger; defaultInitializer = Container.Resolve <IModuleInitializer>("defaultModuleInitializer"); moduleConfigs = LoadModuleConfig(); Container.RegisterInstance <IModuleConfigs>("ModuleConfigs", moduleConfigs); }
public static ConfigurationBuilder LoadInstalledModules(this ConfigurationBuilder build, IList <ModuleInfo> modules, IHostingEnvironment env) { var moduleRootFolder = new DirectoryInfo(Path.Combine(env.ContentRootPath, "Module")); var moduleFolders = moduleRootFolder.GetDirectories(); foreach (var moduleFolder in moduleFolders) { Assembly assembly = null; IModuleInitializer moduleInitializer = null; try { assembly = AssemblyLoadContext.Default.LoadFromAssemblyPath(Path.Combine(moduleFolder.FullName, moduleFolder.Name + ".dll")); var moduleInitializerType = assembly.GetTypes().FirstOrDefault(x => typeof(IModuleInitializer).IsAssignableFrom(x)); if ((moduleInitializerType != null) && (moduleInitializerType != typeof(IModuleInitializer))) { moduleInitializer = (IModuleInitializer)Activator.CreateInstance(moduleInitializerType); } } catch (FileLoadException) { throw; } if (assembly.FullName.Contains(moduleFolder.Name)) { modules.Add(new ModuleInfo { Name = moduleFolder.Name, Assembly = assembly, Initializer = moduleInitializer, Path = moduleFolder.FullName }); } } return(build); }
public PlainScript(IAsset asset, Bundle bundle, IModuleInitializer modules) : base(asset, bundle) { this.modules = modules; jsonSerializer = new SimpleJsonSerializer(); asset.AddAssetTransformer(this); }
public PlainScript(IAsset asset, Bundle bundle, IModuleInitializer modules,string baseUrl = null) : base(asset, bundle, baseUrl) { this.modules = modules; jsonSerializer = new SimpleJsonSerializer(); asset.AddAssetTransformer(this); }
public SortedModuleInitializer(IUnityContainer container, ILoggerFacade logger, IEventAggregator eventAggregator) { _logger = logger; _eventAggregator = eventAggregator; DefaultInitializer = container.Resolve<IModuleInitializer>("defaultModuleInitializer"); ModuleConfigs = LoadModuleConfig(); container.RegisterInstance<IModuleConfigs>("ModuleConfigs", ModuleConfigs); }
public SortedModuleInitializer(IUnityContainer container, ILoggerFacade logger, IEventAggregator eventAggregator) { _logger = logger; _eventAggregator = eventAggregator; DefaultInitializer = container.Resolve <IModuleInitializer>("defaultModuleInitializer"); ModuleConfigs = LoadModuleConfig(); container.RegisterInstance <IModuleConfigs>("ModuleConfigs", ModuleConfigs); }
/// <summary> /// Initializes an instance of the <see cref="ModuleManager"/> class. /// </summary> /// <param name="moduleInitializer">Service used for initialization of modules.</param> /// <param name="moduleCatalog">Catalog that enumerates the modules to be loaded and initialized.</param> /// <param name="logger">Logger used during the load and initialization of modules.</param> public ModuleManager(IModuleInitializer moduleInitializer, IModuleCatalog moduleCatalog, ILogger logger) { _moduleInitializer = moduleInitializer ?? throw new ArgumentNullException(nameof(moduleInitializer)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); _typeLoaders = new HashSet <IModuleTypeLoader>(); _subscribedToModuleTypeLoaders = new HashSet <IModuleTypeLoader>(); ModuleCatalog = moduleCatalog ?? throw new ArgumentNullException(nameof(moduleCatalog)); }
public BundleScriptModule(Bundle bundle, IModuleInitializer modules, string baseUrl = null) { this.modules = modules; this.Bundle = bundle; this.Path = bundle.Path; this.ReferencePaths = bundle.References; ModulePath = AssetModule.ConvertAssetPathToModulePath(bundle.Path, baseUrl); Alias = AssetModule.ConvertAssetPathToAlias(bundle.Path); }
/// <summary> /// Initializes an instance of the <see cref="ModuleManager"/> class. /// </summary> /// <param name="moduleInitializer">Service used for initialization of modules.</param> /// <param name="moduleCatalog">Catalog that enumerates the modules to be loaded and initialized.</param> public ModuleManager(IModuleInitializer moduleInitializer, IModuleCatalog moduleCatalog) { if (moduleInitializer == null) throw new ArgumentNullException("moduleInitializer"); if (moduleCatalog == null) throw new ArgumentNullException("moduleCatalog"); _moduleInitializer = moduleInitializer; _moduleCatalog = moduleCatalog; }
/// <summary> /// Initializes an instance of the <see cref="ModuleManager"/> class. /// </summary> /// <param name="moduleInitializer">Service used for initialization of modules.</param> /// <param name="moduleCatalog">Catalog that enumerates the modules to be loaded and initialized.</param> /// <param name="loggerFacade">Logger used during the load and initialization of modules.</param> public ModuleManager(IModuleInitializer moduleInitializer, IModuleCatalog moduleCatalog, ILoggerFacade loggerFacade) { if (moduleInitializer == null) throw new ArgumentNullException("moduleInitializer"); if (moduleCatalog == null) throw new ArgumentNullException("moduleCatalog"); if (loggerFacade == null) throw new ArgumentNullException("loggerFacade"); Contract.EndContractBlock(); this.moduleInitializer = moduleInitializer; this.moduleCatalog = moduleCatalog; this.loggerFacade = loggerFacade; }
public void FindModuleInitializerReturnsNullIfnotExists() { CompositionContainer mockContainer = new TestableRootCompositionContainer(); ModuleLoaderService loader = new ModuleLoaderService(); loader.Load(mockContainer, new ModuleInfo("TestModuleName", generatedAssemblies["TestModule"].FullName, "~/TestModule")); IModuleInitializer initializer = loader.FindInitializer("InexistantName"); Assert.IsNull(initializer); }
public void FindModuleInitializerReturnsCorrectInstance() { CompositionContainer mockContainer = new TestableRootCompositionContainer(); ModuleLoaderService loader = new ModuleLoaderService(); loader.Load(mockContainer, new ModuleInfo("TestModuleName", generatedAssemblies["TestModule"].FullName, "~/TestModule")); IModuleInitializer initializer = loader.FindInitializer("TestModuleName"); Assert.IsNotNull(initializer); Assert.AreEqual("TestModule.TestModuleInitializer", initializer.GetType().FullName); }
public static void SetModuleReturnExpression(this IModuleInitializer configuration, string scriptPath, string moduleReturnExpression) { var module = configuration[scriptPath] as PlainScript; if (module != null) { module.ModuleReturnExpression = moduleReturnExpression; } else { throw new ArgumentException("Cannot change the return expression of a predefined AMD module: " + scriptPath); } }
protected void AddModuleInitializer(IModuleInitializer module) { if (module == null) { return; } if (_moduleList.Any(item => item.GetType() == module.GetType())) { return; } _moduleList.Add(module); }
public ExternalScriptModule(ExternalScriptBundle bundle, IModuleInitializer modules,string baseUrl = null) { this.modules = modules; this.Bundle = bundle; this.Path = bundle.Path; this.ReferencePaths = bundle.References; ModulePath = AssetModule.ConvertAssetPathToModulePath(bundle.Path, baseUrl); Alias = AssetModule.ConvertAssetPathToAlias(bundle.Path); externalUrl = bundle.ExternalUrl; if (externalUrl.EndsWith(".js")) { externalUrl = externalUrl.Substring(0, externalUrl.Length - 3); } }
/// <summary> /// Initializes an instance of the <see cref="ModuleManager"/> class. /// </summary> /// <param name="moduleInitializer">Service used for initialization of modules.</param> /// <param name="moduleCatalog">Catalog that enumerates the modules to be loaded and initialized.</param> public ModuleManager(IModuleInitializer moduleInitializer, IModuleCatalog moduleCatalog) { if (moduleInitializer == null) { throw new ArgumentNullException("moduleInitializer"); } if (moduleCatalog == null) { throw new ArgumentNullException("moduleCatalog"); } _moduleInitializer = moduleInitializer; _moduleCatalog = moduleCatalog; }
/// <summary> /// Initializes an instance of the <see cref="ModuleManager"/> class. /// </summary> /// <param name="moduleInitializer">Service used for initialization of modules.</param> /// <param name="moduleCatalog">Catalog that enumerates the modules to be loaded and initialized.</param> /// <param name="loggerFacade">Logger used during the load and initialization of modules.</param> public ModuleManager(IModuleInitializer moduleInitializer, IModuleCatalog moduleCatalog, ILoggerFacade loggerFacade) { if (moduleInitializer == null) throw new ArgumentNullException(nameof(moduleInitializer)); if (moduleCatalog == null) throw new ArgumentNullException(nameof(moduleCatalog)); if (loggerFacade == null) throw new ArgumentNullException(nameof(loggerFacade)); this.moduleInitializer = moduleInitializer; this.moduleCatalog = moduleCatalog; this.loggerFacade = loggerFacade; }
/// <summary> /// Initializes an instance of the <see cref="ModuleManager"/> class. /// </summary> /// <param name="moduleInitializer">Service used for initialization of modules.</param> /// <param name="moduleCatalog">Catalog that enumerates the modules to be loaded and initialized.</param> /// <param name="loggerFacade">Logger used during the load and initialization of modules.</param> public ModuleManager(IModuleInitializer moduleInitializer, IModuleCatalog moduleCatalog) { if (moduleInitializer == null) { throw new ArgumentNullException("moduleInitializer"); } if (moduleCatalog == null) { throw new ArgumentNullException("moduleCatalog"); } this.moduleInitializer = moduleInitializer; this.moduleCatalog = moduleCatalog; this.loggerFacade = ServiceLocator.GetInstance<ILogManager>().GetSystemLogger(); }
protected virtual void InitializeModules(List <Tuple <Assembly, Type> > moduleAssemblies, IDependencyResolver dependencyResolver) { foreach (var moduleAssembly in moduleAssemblies) { //TODO: Faut-il vraiment forcer l'existance d'un ModuleItinitializer et throw si non présent if (moduleAssembly.Item2 == null) { throw new NotImplementedException("The module " + moduleAssembly.Item1.GetName().Name + " has no ModuleItinitializer."); } IModuleInitializer moduleInitializer = CreateModuleInitializerInstance(moduleAssembly.Item2); moduleInitializer.Initialize(dependencyResolver); } }
/// <summary> /// Initializes an instance of the <see cref="ModuleManager"/> class. /// </summary> /// <param name="moduleInitializer">Service used for initialization of modules.</param> /// <param name="moduleCatalog">Catalog that enumerates the modules to be loaded and initialized.</param> /// <param name="loggerFacade">Logger used during the load and initialization of modules.</param> public ModuleManager(IModuleInitializer moduleInitializer, IModuleCatalog moduleCatalog) { if (moduleInitializer == null) { throw new ArgumentNullException("moduleInitializer"); } if (moduleCatalog == null) { throw new ArgumentNullException("moduleCatalog"); } this.moduleInitializer = moduleInitializer; this.moduleCatalog = moduleCatalog; this.loggerFacade = ServiceLocator.GetInstance <ILogManager>().GetSystemLogger(); }
public ModuleManager(IModuleInitializer moduleInitializer, IModuleCatalog moduleCatalog, ILoggerFacade loggerFacade) { if (moduleInitializer == null) { throw new ArgumentNullException("moduleInitializer"); } if (moduleCatalog == null) { throw new ArgumentNullException("moduleCatalog"); } if (loggerFacade == null) { throw new ArgumentNullException("loggerFacade"); } this.moduleInitializer = moduleInitializer; this.moduleCatalog = moduleCatalog; this.loggerFacade = loggerFacade; }
private void ConfigureModules(BundleCollection bundleCollection, HttpConfiguration httpConfiguration, GlobalFilterCollection globalFilterCollection, RouteCollection routeCollection) { List<Type> moduleInitializers = new List<Type>(); IEnumerable<Assembly> assemblies = AppDomain.CurrentDomain.GetAssemblies().Where(x => x.FullName.StartsWith("RoCMS")); foreach (Assembly a in assemblies) { foreach (Type t in a.GetTypes().Where(t => t.Name.EndsWith("ModuleInitializer")).Where(t => !t.IsAbstract)) { moduleInitializers.Add(t); } } foreach (Type moduleInitializerType in moduleInitializers) { IModuleInitializer instance = (IModuleInitializer)Activator.CreateInstance(moduleInitializerType); instance.Init(); } }
/// <summary> /// Initializes an instance of the <see cref="ModuleManager"/> class. /// </summary> /// <param name="moduleInitializer">Service used for initialization of modules.</param> /// <param name="moduleCatalog">Catalog that enumerates the modules to be loaded and initialized.</param> /// <param name="loggerFacade">Logger used during the load and initialization of modules.</param> public ModuleManager(IModuleInitializer moduleInitializer, IModuleCatalog moduleCatalog, ILog loggerFacade) { if (moduleInitializer == null) { throw new ArgumentNullException("moduleInitializer"); } if (moduleCatalog == null) { throw new ArgumentNullException("moduleCatalog"); } if (loggerFacade == null) { throw new ArgumentNullException("loggerFacade"); } this.moduleInitializer = moduleInitializer; this.moduleCatalog = moduleCatalog; this.loggerFacade = loggerFacade; }
public ModuleManager(/*IModuleLoader[] loaders,*/ IModuleInitializer moduleInitializer, IModuleLibrary moduleCatalog, IPlatformLogProvider logger) { if (moduleInitializer == null) { throw new ArgumentNullException(nameof(moduleInitializer)); } if (moduleCatalog == null) { throw new ArgumentNullException(nameof(moduleCatalog)); } if (logger == null) { throw new ArgumentNullException(nameof(logger)); } m_moduleInitializer = moduleInitializer; m_library = moduleCatalog; m_logger = logger; m_subscribedLoaders = new HashSet <IModuleLoader>(); m_loaders = new List <IModuleLoader>(/*loaders*/); }
/// <summary> /// Initializes an instance of the <see cref="ModuleManager"/> class. /// </summary> /// <param name="moduleInitializer">Service used for initialization of modules.</param> /// <param name="moduleCatalog">Catalog that enumerates the modules to be loaded and initialized.</param> /// <param name="loggerFacade">Logger used during the load and initialization of modules.</param> public ModuleManager(IModuleInitializer moduleInitializer, IModuleCatalog moduleCatalog, ILoggerFacade loggerFacade) { this.moduleInitializer = moduleInitializer ?? throw new ArgumentNullException(nameof(moduleInitializer)); this.ModuleCatalog = moduleCatalog ?? throw new ArgumentNullException(nameof(moduleCatalog)); this.loggerFacade = loggerFacade ?? throw new ArgumentNullException(nameof(loggerFacade)); }
/// <summary> /// Initializes an instance of the <see cref="ModuleManager"/> class. /// </summary> /// <param name="moduleInitializer">Service used for initialization of modules.</param> /// <param name="moduleCatalog">Catalog that enumerates the modules to be loaded and initialized.</param> public ModuleManager(IModuleInitializer moduleInitializer, IModuleCatalog moduleCatalog) { ModuleInitializer = moduleInitializer ?? throw new ArgumentNullException(nameof(moduleInitializer)); ModuleCatalog = moduleCatalog ?? throw new ArgumentNullException(nameof(moduleCatalog)); }
public static void SetExtension(IModuleInitializer moduleInitializer) { ExtensionManager.Extensions.Add(moduleInitializer); }
static void AddModule(this IServiceCollection services, IModuleInitializer moduleInitializer) { moduleInitializer.Init(services); }
public RoleAwareModuleManager(IModuleInitializer moduleInitializer, IModuleCatalog moduleCatalog, IEventAggregator eventAggregator) : base(moduleInitializer, moduleCatalog, eventAggregator) { }
public ModuleInfo(Type type, IModuleInitializer instance) { Type = type; Instance = instance; }
protected AuthenticatedUserAwareModuleManager(IModuleInitializer moduleInitializer, IModuleCatalog moduleCatalog, IEventAggregator eventAggregator) : base(moduleCatalog, moduleInitializer) { eventAggregator.GetEvent <AuthenticatedUserEvent>().Subscribe(OnAuthenticatedUserEventPublished); }
public static void SetImportAlias(this IModuleInitializer configuration, string scriptPath, string importAlias) { var module = configuration[scriptPath]; module.Alias = importAlias; }
protected ModuleManager(IModuleCatalog moduleCatalog, IModuleInitializer moduleInitializer) { ModuleCatalog = moduleCatalog; ModuleInitializer = moduleInitializer; }
public ModuleManager(IModuleInitializer moduleInitializer, IModuleCatalog moduleCatalog) { ModuleInitializer = moduleInitializer; ModuleCatalog = moduleCatalog; }