/// <summary>
/// Handles any exception occurred in the module Initialization process,
/// logs the error using the <see cref="ILoggerFacade"/> and throws a <see cref="ModuleInitializeException"/>.
/// This method can be overridden to provide a different behavior.
/// </summary>
/// <param name="moduleInfo">The module metadata where the error happenened.</param>
/// <param name="assemblyName">The assembly name.</param>
/// <param name="exception">The exception thrown that is the cause of the current error.</param>
/// <exception cref="ModuleInitializeException"></exception>
public virtual void HandleModuleInitializationError(ModuleInfo moduleInfo, string assemblyName, Exception exception)
{
if (moduleInfo == null) throw new ArgumentNullException("moduleInfo");
if (exception == null) throw new ArgumentNullException("exception");
Exception moduleException;
if (exception is ModuleInitializeException)
{
moduleException = exception;
}
else
{
if (!string.IsNullOrEmpty(assemblyName))
{
moduleException = new ModuleInitializeException(moduleInfo.ModuleName, assemblyName, exception.Message, exception);
}
else
{
moduleException = new ModuleInitializeException(moduleInfo.ModuleName, exception.Message, exception);
}
}
this.loggerFacade.Log(moduleException.ToString(), Category.Exception, Priority.High);
throw moduleException;
}
private void EnsureModulesDiscovered()
{
ModulesConfigurationSection section = this.Store.RetrieveModuleConfigurationSection();
if (section != null)
{
foreach (ModuleConfigurationElement element in section.Modules)
{
IList<string> dependencies = new List<string>();
if (element.Dependencies.Count > 0)
{
foreach (ModuleDependencyConfigurationElement dependency in element.Dependencies)
{
dependencies.Add(dependency.ModuleName);
}
}
ModuleInfo moduleInfo = new ModuleInfo(element.ModuleName, element.ModuleType)
{
Ref = GetFileAbsoluteUri(element.AssemblyFile),
InitializationMode = element.StartupLoaded ? InitializationMode.WhenAvailable : InitializationMode.OnDemand
};
moduleInfo.DependsOn.AddRange(dependencies.ToArray());
AddModule(moduleInfo);
}
}
}
public void CannotRetrieveWithIncorrectRef()
{
var retriever = new FileModuleTypeLoader();
var moduleInfo = new ModuleInfo() { Ref = "NotForLocalRetrieval" };
Assert.IsFalse(retriever.CanLoadModuleType(moduleInfo));
}
public void WhenInitializingAModuleWithACatalogPendingToBeLoaded_ThenLoadsTheCatalogInitializesTheModule()
{
var aggregateCatalog = new AggregateCatalog(new AssemblyCatalog(typeof(MefModuleInitializer).Assembly));
var compositionContainer = new CompositionContainer(aggregateCatalog);
compositionContainer.ComposeExportedValue(aggregateCatalog);
var serviceLocatorMock = new Mock<IServiceLocator>();
var loggerFacadeMock = new Mock<ILoggerFacade>();
var serviceLocator = serviceLocatorMock.Object;
var loggerFacade = loggerFacadeMock.Object;
compositionContainer.ComposeExportedValue(serviceLocator);
compositionContainer.ComposeExportedValue(loggerFacade);
var moduleInitializer = compositionContainer.GetExportedValue<IModuleInitializer>();
var repository = compositionContainer.GetExportedValue<DownloadedPartCatalogCollection>();
var moduleInfo = new ModuleInfo("TestModuleForInitializer", typeof(TestModuleForInitializer).AssemblyQualifiedName);
repository.Add(moduleInfo, new TypeCatalog(typeof(TestModuleForInitializer)));
moduleInitializer.Initialize(moduleInfo);
ComposablePartCatalog existingCatalog;
Assert.IsFalse(repository.TryGet(moduleInfo, out existingCatalog));
var module = compositionContainer.GetExportedValues<IModule>().OfType<TestModuleForInitializer>().First();
Assert.IsTrue(module.Initialized);
}
public void WhenInitializingAModuleWithNoCatalogPendingToBeLoaded_ThenInitializesTheModule()
{
var aggregateCatalog = new AggregateCatalog(new AssemblyCatalog(typeof(MefModuleInitializer).Assembly));
var compositionContainer = new CompositionContainer(aggregateCatalog);
compositionContainer.ComposeExportedValue(aggregateCatalog);
var serviceLocatorMock = new Mock<IServiceLocator>();
var loggerFacadeMock = new Mock<ILoggerFacade>();
var serviceLocator = serviceLocatorMock.Object;
var loggerFacade = loggerFacadeMock.Object;
compositionContainer.ComposeExportedValue(serviceLocator);
compositionContainer.ComposeExportedValue(loggerFacade);
aggregateCatalog.Catalogs.Add(new TypeCatalog(typeof(TestModuleForInitializer)));
var moduleInitializer = compositionContainer.GetExportedValue<IModuleInitializer>();
var moduleInfo = new ModuleInfo("TestModuleForInitializer", typeof(TestModuleForInitializer).AssemblyQualifiedName);
var module = compositionContainer.GetExportedValues<IModule>().OfType<TestModuleForInitializer>().First();
Assert.IsFalse(module.Initialized);
moduleInitializer.Initialize(moduleInfo);
Assert.IsTrue(module.Initialized);
}
/// <summary>
/// Uses the container to resolve a new <see cref="IModule"/> by specifying its <see cref="Type"/>.
/// </summary>
/// <param name="moduleInfo">The module to create.</param>
/// <returns>
/// A new instance of the module specified by <paramref name="moduleInfo"/>.
/// </returns>
protected override IModule CreateModule(ModuleInfo moduleInfo)
{
// If there is a catalog that needs to be integrated with the AggregateCatalog as part of initialization, I add it to the container's catalog.
ComposablePartCatalog partCatalog;
if (this.downloadedPartCatalogs.TryGet(moduleInfo, out partCatalog))
{
if (!this.aggregateCatalog.Catalogs.Contains(partCatalog))
{
this.aggregateCatalog.Catalogs.Add(partCatalog);
}
this.downloadedPartCatalogs.Remove(moduleInfo);
}
if (this.ImportedModules != null && this.ImportedModules.Count() != 0)
{
Lazy<IModule, IModuleExport> lazyModule =
this.ImportedModules.FirstOrDefault(x => (x.Metadata.ModuleName == moduleInfo.ModuleName));
if (lazyModule != null)
{
return lazyModule.Value;
}
}
// This does not fall back to the base implementation because the type must be in the MEF container and not just in the application domain.
throw new ModuleInitializeException(
string.Format(CultureInfo.CurrentCulture, Properties.Resources.FailedToGetType, moduleInfo.ModuleType));
}
/// <summary>
/// Evaluates the <see cref="ModuleInfo.Ref"/> property to see if the current typeloader will be able to retrieve the <paramref name="moduleInfo"/>.
/// Returns true if the <see cref="ModuleInfo.Ref"/> property starts with "file://", because this indicates that the file
/// is a local file.
/// </summary>
/// <param name="moduleInfo">Module that should have it's type loaded.</param>
/// <returns>
/// <see langword="true"/> if the current typeloader is able to retrieve the module, otherwise <see langword="false"/>.
/// </returns>
public virtual bool CanLoadModuleType(ModuleInfo moduleInfo)
{
if (moduleInfo == null)
throw new ArgumentNullException(nameof(moduleInfo));
return moduleInfo.Ref != null && moduleInfo.Ref.StartsWith(RefFilePrefix, StringComparison.Ordinal);
}
public void WhenItemsInCollection_TryGetReturnsTrueAndCatalog()
{
// Prepare
ModuleInfo moduleInfo1 = new ModuleInfo();
ModuleInfo moduleInfo2 = new ModuleInfo();
ModuleInfo moduleInfo3 = new ModuleInfo();
ComposablePartCatalog catalog1 = new TypeCatalog();
ComposablePartCatalog catalog2 = new TypeCatalog();
ComposablePartCatalog catalog3 = new TypeCatalog();
DownloadedPartCatalogCollection target = new DownloadedPartCatalogCollection();
target.Add(moduleInfo1, catalog1);
target.Add(moduleInfo2, catalog2);
target.Add(moduleInfo3, catalog3);
// Act
bool actual = target.TryGet(moduleInfo3, out catalog3);
// Verify
Assert.IsTrue(actual);
Assert.AreSame(catalog3, target.Get(moduleInfo3));
}
public void CanRetrieveWithCorrectRef()
{
var retriever = new FileModuleTypeLoader();
var moduleInfo = new ModuleInfo() { Ref = "file://somefile" };
Assert.IsTrue(retriever.CanLoadModuleType(moduleInfo));
}
public ModuleInfo CreateModuleInfo()
{
ModuleInfo info = new ModuleInfo();
info.ModuleName = "MefModuleOne";
info.Ref = "file:///MefModulesForTesting.dll";
return info;
}
/// <summary>
/// Evaluates the <see cref="ModuleInfo.Ref"/> property to see if the current typeloader will be able to retrieve the <paramref name="moduleInfo"/>.
/// Returns true if the <see cref="ModuleInfo.Ref"/> property starts with "file://", because this indicates that the file
/// is a local file.
/// </summary>
/// <param name="moduleInfo">Module that should have it's type loaded.</param>
/// <returns>
/// <see langword="true"/> if the current typeloader is able to retrieve the module, otherwise <see langword="false"/>.
/// </returns>
/// <exception cref="ArgumentNullException">An <see cref="ArgumentNullException"/> is thrown if <paramref name="moduleInfo"/> is null.</exception>
public bool CanLoadModuleType(ModuleInfo moduleInfo)
{
if (moduleInfo == null)
{
throw new System.ArgumentNullException("moduleInfo");
}
return moduleInfo.Ref != null && moduleInfo.Ref.StartsWith(RefFilePrefix, StringComparison.Ordinal);
}
/// <summary>
/// Initializes a new instance of the <see cref="ModuleDownloadProgressChangedEventArgs"/> class.
/// </summary>
/// <param name="moduleInfo">The module info.</param>
/// <param name="bytesReceived">The bytes received.</param>
/// <param name="totalBytesToReceive">The total bytes to receive.</param>
public ModuleDownloadProgressChangedEventArgs(ModuleInfo moduleInfo, long bytesReceived, long totalBytesToReceive)
: base(CalculateProgressPercentage(bytesReceived, totalBytesToReceive), null)
{
if (moduleInfo == null)
throw new ArgumentNullException(nameof(moduleInfo));
this.ModuleInfo = moduleInfo;
this.BytesReceived = bytesReceived;
this.TotalBytesToReceive = totalBytesToReceive;
}
/// <summary>
/// Initializes a new instance of the <see cref="LoadModuleCompletedEventArgs"/> class.
/// </summary>
/// <param name="moduleInfo">The module info.</param>
/// <param name="error">Any error that occurred during the call.</param>
public LoadModuleCompletedEventArgs(ModuleInfo moduleInfo, Exception error)
{
if (moduleInfo == null)
{
throw new ArgumentNullException("moduleInfo");
}
this.ModuleInfo = moduleInfo;
this.Error = error;
}
public void CanCreateCatalogFromList()
{
var moduleInfo = new ModuleInfo("MockModule", "type");
List<ModuleInfo> moduleInfos = new List<ModuleInfo> { moduleInfo };
var moduleCatalog = new ModuleCatalog(moduleInfos);
Assert.AreEqual(1, moduleCatalog.Modules.Count());
Assert.AreEqual(moduleInfo, moduleCatalog.Modules.ElementAt(0));
}
/// <summary>
/// Retrieves the <paramref name="moduleInfo"/>.
/// </summary>
/// <param name="moduleInfo">Module that should have it's type loaded.</param>
public virtual void LoadModuleType(ModuleInfo moduleInfo)
{
if (moduleInfo == null)
{
throw new System.ArgumentNullException("moduleInfo");
}
try
{
Uri uri = new Uri(moduleInfo.Ref, UriKind.RelativeOrAbsolute);
// If this module has already been downloaded, I fire the completed event.
if (this.IsSuccessfullyDownloaded(uri))
{
this.RaiseLoadModuleCompleted(moduleInfo, null);
}
else
{
string path;
if (moduleInfo.Ref.StartsWith(RefFilePrefix + "/", StringComparison.Ordinal))
{
path = moduleInfo.Ref.Substring(RefFilePrefix.Length + 1);
}
else
{
path = moduleInfo.Ref.Substring(RefFilePrefix.Length);
}
long fileSize = -1L;
if (File.Exists(path))
{
FileInfo fileInfo = new FileInfo(path);
fileSize = fileInfo.Length;
}
// Although this isn't asynchronous, nor expected to take very long, I raise progress changed for consistency.
this.RaiseModuleDownloadProgressChanged(moduleInfo, 0, fileSize);
this.aggregateCatalog.Catalogs.Add(new AssemblyCatalog(path));
// Although this isn't asynchronous, nor expected to take very long, I raise progress changed for consistency.
this.RaiseModuleDownloadProgressChanged(moduleInfo, fileSize, fileSize);
// I remember the downloaded URI.
this.RecordDownloadSuccess(uri);
this.RaiseLoadModuleCompleted(moduleInfo, null);
}
}
catch (Exception ex)
{
this.RaiseLoadModuleCompleted(moduleInfo, ex);
}
}
public void ShouldForwardValuesToModuleInfo()
{
ModuleInfoGroup group = new ModuleInfoGroup();
group.Ref = "MyCustomGroupRef";
ModuleInfo moduleInfo = new ModuleInfo();
Assert.IsNull(moduleInfo.Ref);
group.Add(moduleInfo);
Assert.AreEqual(group.Ref, moduleInfo.Ref);
}
public void LoadModuleType(ModuleInfo moduleInfo)
{
Thread retrieverThread = new Thread(() =>
{
Thread.Sleep(SleepTimeOut);
this.RaiseLoadModuleCompleted(new LoadModuleCompletedEventArgs(moduleInfo, CallbackArgumentError));
callbackEvent.Set();
});
retrieverThread.Start();
}
/// <summary>
/// Adds a new module that is statically referenced to the specified module info group.
/// </summary>
/// <param name="moduleInfoGroup">The group where to add the module info in.</param>
/// <param name="moduleName">The name for the module.</param>
/// <param name="moduleType">The type for the module. This type should be a descendant of <see cref="IModule"/>.</param>
/// <param name="dependsOn">The names for the modules that this module depends on.</param>
/// <returns>Returns the instance of the passed in module info group, to provide a fluid interface.</returns>
public static ModuleInfoGroup AddModule(
this ModuleInfoGroup moduleInfoGroup,
string moduleName,
Type moduleType,
params string[] dependsOn)
{
if (moduleType == null) throw new ArgumentNullException("moduleType");
if (moduleInfoGroup == null) throw new ArgumentNullException("moduleInfoGroup");
ModuleInfo moduleInfo = new ModuleInfo(moduleName, moduleType.AssemblyQualifiedName);
moduleInfo.DependsOn.AddRange(dependsOn);
moduleInfoGroup.Add(moduleInfo);
return moduleInfoGroup;
}
public void Initialize(ModuleInfo moduleInfo)
{
if (moduleInfo == null) throw new ArgumentNullException("moduleInfo");
IModule moduleInstance = null;
try
{
moduleInstance = this.CreateModule(moduleInfo);
if (moduleInstance != null)
moduleInstance.Initialize();
}
catch (Exception ex)
{
this.HandleModuleInitializationError(
moduleInfo,
moduleInstance != null ? moduleInstance.GetType().Assembly.FullName : null,
ex);
}
}
public void WhenItemsNotInCollection_GetThrows()
{
// Prepare
ModuleInfo moduleInfo1 = new ModuleInfo();
ModuleInfo moduleInfo2 = new ModuleInfo();
ModuleInfo moduleInfo3 = new ModuleInfo();
ComposablePartCatalog catalog1 = new TypeCatalog();
ComposablePartCatalog catalog2 = new TypeCatalog();
DownloadedPartCatalogCollection target = new DownloadedPartCatalogCollection();
target.Add(moduleInfo1, catalog1);
target.Add(moduleInfo2, catalog2);
// Act
target.Get(moduleInfo3);
// Verify
}
/// <summary>
/// Called when a part's imports have been satisfied and it is safe to use.
/// </summary>
/// <remarks>
/// Whenever the MEF container loads new types that cause ImportedModules to be recomposed, this is called.
/// This method ensures that as the MEF container discovered new modules, the ModuleCatalog is updated.
/// </remarks>
public virtual void OnImportsSatisfied()
{
// To prevent a double foreach loop, we key on the module type for anything already in the catalog.
IDictionary<string, ModuleInfo> registeredModules = this.ModuleCatalog.Modules.ToDictionary(m => m.ModuleName);
foreach (Lazy<IModule, IModuleExport> lazyModule in this.ImportedModules)
{
// It is important that the Metadata.ModuleType is used here.
// Using GetType().Name would cause the Module to be constructed here rather than lazily when the module is needed.
Type moduleType = lazyModule.Metadata.ModuleType;
ModuleInfo registeredModule = null;
if (!registeredModules.TryGetValue(lazyModule.Metadata.ModuleName, out registeredModule))
{
// If the module is not already in the catalog is it added.
ModuleInfo moduleInfo = new ModuleInfo()
{
ModuleName = lazyModule.Metadata.ModuleName,
ModuleType = moduleType.AssemblyQualifiedName,
InitializationMode = lazyModule.Metadata.InitializationMode,
State = lazyModule.Metadata.InitializationMode == InitializationMode.OnDemand ? ModuleState.NotStarted : ModuleState.ReadyForInitialization,
};
if (lazyModule.Metadata.DependsOnModuleNames != null)
{
moduleInfo.DependsOn.AddRange(lazyModule.Metadata.DependsOnModuleNames);
}
this.ModuleCatalog.AddModule(moduleInfo);
}
else
{
// If the module is already in the catalog then override the module type name from the imported module
registeredModule.ModuleType = moduleType.AssemblyQualifiedName;
}
}
this.LoadModulesThatAreReadyForLoad();
}
public void WhenItemsAdded_GetReturnsItems()
{
// Prepare
ModuleInfo moduleInfo1 = new ModuleInfo();
ModuleInfo moduleInfo2 = new ModuleInfo();
ModuleInfo moduleInfo3 = new ModuleInfo();
ComposablePartCatalog catalog1 = new TypeCatalog();
ComposablePartCatalog catalog2 = new TypeCatalog();
ComposablePartCatalog catalog3 = new TypeCatalog();
DownloadedPartCatalogCollection target = new DownloadedPartCatalogCollection();
// Act
target.Add(moduleInfo1, catalog1);
target.Add(moduleInfo2, catalog2);
target.Add(moduleInfo3, catalog3);
// Verify
Assert.AreSame(catalog1, target.Get(moduleInfo1));
Assert.AreSame(catalog2, target.Get(moduleInfo2));
Assert.AreSame(catalog3, target.Get(moduleInfo3));
}
/// <summary>
/// Adds a <see cref="ModuleInfo"/> to the <see cref="ModuleCatalog"/>.
/// </summary>
/// <param name="moduleInfo">The <see cref="ModuleInfo"/> to add.</param>
/// <returns>The <see cref="ModuleCatalog"/> for easily adding multiple modules.</returns>
public IModuleCatalog AddModule(ModuleInfo moduleInfo)
{
_items.Add(moduleInfo);
return(this);
}
private void RaiseLoadModuleCompleted(ModuleInfo moduleInfo, Exception error)
{
this.RaiseLoadModuleCompleted(new LoadModuleCompletedEventArgs(moduleInfo, error));
}
/// <summary>
/// Return the list of <see cref="ModuleInfo"/>s that <paramref name="moduleInfo"/> depends on.
/// </summary>
/// <remarks>
/// If the <see cref="ModuleCatalog"/> was not yet validated, this method will call <see cref="Validate"/>.
/// </remarks>
/// <param name="moduleInfo">The <see cref="ModuleInfo"/> to get the </param>
/// <returns>An enumeration of <see cref="ModuleInfo"/> that <paramref name="moduleInfo"/> depends on.</returns>
public virtual IEnumerable<ModuleInfo> GetDependentModules(ModuleInfo moduleInfo)
{
this.EnsureCatalogValidated();
return this.GetDependentModulesInner(moduleInfo);
}
/// <summary>
/// Return the list of <see cref="ModuleInfo"/>s that <paramref name="moduleInfo"/> depends on.
/// </summary>
/// <param name="moduleInfo">The <see cref="ModuleInfo"/> to get the</param>
/// <returns>
/// An enumeration of <see cref="ModuleInfo"/> that <paramref name="moduleInfo"/> depends on.
/// </returns>
public IEnumerable<ModuleInfo> GetDependentModules(ModuleInfo moduleInfo)
{
var catalog = this.catalogs.Single(x => x.Modules.Contains(moduleInfo));
return catalog.GetDependentModules(moduleInfo);
}
/// <summary>
/// Adds a <see cref="ModuleInfo"/> to the <see cref="ModuleCatalog"/>.
/// </summary>
/// <param name="moduleInfo">The <see cref="ModuleInfo"/> to add.</param>
public void AddModule(ModuleInfo moduleInfo)
{
this.catalogs[0].AddModule(moduleInfo);
}
public void ShouldThrowExceptionIfBogusType()
{
var moduleInfo = new ModuleInfo("TestModule", "BadAssembly.BadType");
ModuleInitializer loader = new ModuleInitializer(new MockContainerAdapter(), new MockLogger());
try
{
loader.Initialize(moduleInfo);
Assert.Fail("Did not throw exception");
}
catch (ModuleInitializeException ex)
{
StringAssert.Contains(ex.Message, "BadAssembly.BadType");
}
catch(Exception)
{
Assert.Fail();
}
}
public override void HandleModuleInitializationError(ModuleInfo moduleInfo, string assemblyName, Exception exception)
{
HandleModuleInitializerrorCalled = true;
}
private static ModuleInfo CreateModuleInfo(Type type, params string[] dependsOn)
{
ModuleInfo moduleInfo = new ModuleInfo(type.Name, type.AssemblyQualifiedName);
moduleInfo.DependsOn.AddRange(dependsOn);
return moduleInfo;
}
/// <summary>
/// Adds a <see cref="ModuleInfo"/> to the <see cref="ModuleCatalog"/>.
/// </summary>
/// <param name="moduleInfo">The <see cref="ModuleInfo"/> to add.</param>
/// <returns>The <see cref="ModuleCatalog"/> for easily adding multiple modules.</returns>
public virtual void AddModule(ModuleInfo moduleInfo)
{
this.Items.Add(moduleInfo);
}
/// <summary>
/// Removes the catalgo for the specified module info.
/// </summary>
/// <param name="moduleInfo">The module info.</param>
public void Remove(ModuleInfo moduleInfo)
{
this.catalogs.Remove(moduleInfo);
}
/// <summary>
/// Tries to ge the catalog for the specified module info.
/// </summary>
/// <param name="moduleInfo">The module info.</param>
/// <param name="catalog">The catalog.</param>
/// <returns>true if found; otherwise false;</returns>
public bool TryGet(ModuleInfo moduleInfo, out ComposablePartCatalog catalog)
{
return this.catalogs.TryGetValue(moduleInfo, out catalog);
}
/// <summary>
/// Gets the catalog for the specified module info.
/// </summary>
/// <param name="moduleInfo">The module info.</param>
/// <returns></returns>
public ComposablePartCatalog Get(ModuleInfo moduleInfo)
{
return this.catalogs[moduleInfo];
}
/// <summary>
/// Returns the <see cref="ModuleInfo"/> on which the received module dependens on.
/// </summary>
/// <param name="moduleInfo">Module whose dependant modules are requested.</param>
/// <returns>Collection of <see cref="ModuleInfo"/> dependants of <paramref name="moduleInfo"/>.</returns>
protected virtual IEnumerable<ModuleInfo> GetDependentModulesInner(ModuleInfo moduleInfo)
{
return this.Modules.Where(dependantModule => moduleInfo.DependsOn.Contains(dependantModule.ModuleName));
}
private void RaiseModuleDownloadProgressChanged(ModuleInfo moduleInfo, long bytesReceived, long totalBytesToReceive)
{
this.RaiseModuleDownloadProgressChanged(new ModuleDownloadProgressChangedEventArgs(moduleInfo, bytesReceived, totalBytesToReceive));
}