/// <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 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 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;
}
