static void _catalog_Changed(object sender, ComposablePartCatalogChangeEventArgs e)
{
if (null != _directoryCatalog)
{
_directoryCatalog.Refresh();
}
}
/// <summary>
/// Método acionado quando o catálogo estiver sendo alterado.
/// </summary>
/// <param name="e"></param>
protected virtual void OnChanging(ComposablePartCatalogChangeEventArgs e)
{
if (Changing != null)
{
Changing(this, e);
}
}
void directoryCatalog_Changing(object sender, ComposablePartCatalogChangeEventArgs e)
{
try
{
// Remove handlers
foreach (var handler in Handlers)
{
for (var i = handlerService.Handlers.Count - 1; i > 0; i--)
{
var h = handlerService.Handlers[i];
if (h.GetType() == handler.GetType())
{
handlerService.Handlers.RemoveAt(i);
}
}
Stencil.Instance.RemoveType(handler.GetType());
}
}
catch (Exception ex)
{
Out.WriteLine(ex.Message);
}
}
/// <summary>
/// Refreshes the <see cref="ComposablePartDefinition"/>s with the latest files in the directory that match
/// the searchPattern. If any files have been added they will be added to the catalog and if any files were
/// removed they will be removed from the catalog. For files that have been removed keep in mind that the
/// assembly cannot be unloaded from the process so <see cref="ComposablePartDefinition"/>s for those files
/// will simply be removed from the catalog.
///
/// Possible exceptions that can be thrown are any that <see cref="Directory.GetFiles(string, string)"/>.
/// </summary>
/// <exception cref="DirectoryNotFoundException">
/// The specified path has been removed since object construction.
/// </exception>
public void Refresh()
{
ThrowIfDisposed();
ComposablePartDefinition[] addedDefinitions;
ComposablePartDefinition[] removedDefinitions;
object changeReferenceObject;
string[] afterFiles;
string[] beforeFiles;
while (true)
{
afterFiles = GetFiles();
lock (_thisLock)
{
changeReferenceObject = _loadedFiles;
beforeFiles = _loadedFiles.ToArray();
}
var newCatalog = ExecuteScripts(afterFiles);
// Notify listeners to give them a preview before completing the changes
addedDefinitions = newCatalog.ToArray();
removedDefinitions = _catalog.ToArray();
using (var atomicComposition = new AtomicComposition())
{
var changingArgs = new ComposablePartCatalogChangeEventArgs(addedDefinitions, removedDefinitions, atomicComposition);
OnChanging(changingArgs);
// if the change went through then write the catalog changes
lock (_thisLock)
{
if (changeReferenceObject != _loadedFiles)
{
// Someone updated the list while we were diffing so we need to try the diff again
continue;
}
_catalog = newCatalog;
_loadedFiles = afterFiles.ToReadOnlyCollection();
// Lastly complete any changes added to the atomicComposition during the change event
atomicComposition.Complete();
// Break out of the while(true)
break;
} // WriteLock
} // AtomicComposition
} // while (true)
var changedArgs = new ComposablePartCatalogChangeEventArgs(addedDefinitions, removedDefinitions, null);
OnChanged(changedArgs);
}
private void Watcher_Deleted(object sender, FileSystemEventArgs e)
{
if (innerCatalog.KeyedParts.ContainsKey(e.FullPath))
{
var affectedParts = innerCatalog.KeyedParts[e.FullPath];
var changeArgs = new ComposablePartCatalogChangeEventArgs(Enumerable.Empty <ComposablePartDefinition>(), affectedParts, null);
AddOrDeleteChanging(changeArgs, () => innerCatalog.RemoveKeyedParts(e.FullPath), false);
}
}
protected virtual void OnChanging(ComposablePartCatalogChangeEventArgs e)
{
EventHandler <ComposablePartCatalogChangeEventArgs> handler = this.Changing;
if (handler != null)
{
handler(this, e);
}
}
/// <summary>
/// Raises the <see cref="INotifyComposablePartCatalogChanged.Changing"/> event.
/// </summary>
/// <param name="e">
/// An <see cref="ComposablePartCatalogChangeEventArgs"/> containing the data for the event.
/// </param>
protected virtual void OnChanging(ComposablePartCatalogChangeEventArgs e)
{
EventHandler <ComposablePartCatalogChangeEventArgs> changingEvent = this.Changing;
if (changingEvent != null)
{
changingEvent(this, e);
}
}
/// <summary>
/// Event handler. Called by Catalog for changed events.
/// </summary>
///
/// <param name="sender"> Source of the event. </param>
/// <param name="e"> Composable part catalog change event information. </param>
private void Catalog_Changed(object sender, ComposablePartCatalogChangeEventArgs e)
{
foreach (ComposablePartDefinition a in e.AddedDefinitions)
{
Debug.Print($"ADDED {a.ToString()}");
}
foreach (ComposablePartDefinition r in e.RemovedDefinitions)
{
Debug.Print($"REMOVED {r.ToString()}");
}
}
void directoryCatalog_Changed(object sender, ComposablePartCatalogChangeEventArgs e)
{
// Register handlers
foreach (var handler in Handlers)
{
Stencil.Instance.AddType(handler.GetType());
var instance = Stencil.Instance.Resolve(handler.GetType()) as IHandler;
handlerService.Handlers.Add(instance);
}
}
private void Watcher_Created(object sender, FileSystemEventArgs e)
{
if (filter(new FileInfo(e.FullPath)))
{
var streamReader = new StreamReader(e.FullPath);
var html = streamReader.ReadToEnd();
streamReader.Dispose();
var newParts = innerCatalog.AddFragmentWithKey(e.FullPath, html, false);
if (newParts.Count > 0)
{
var changeArgs = new ComposablePartCatalogChangeEventArgs(newParts, Enumerable.Empty <ComposablePartDefinition>(), null);
AddOrDeleteChanging(changeArgs, () => innerCatalog.AddKeyedParts(e.FullPath, newParts), true);
}
}
}
/// <summary>
/// </summary>
/// <param name="assemblies">
/// </param>
/// <exception cref="ObjectDisposedException">
/// The <see cref="XapCatalog"/> has been disposed of.
/// </exception>
private void DiscoverParts(IEnumerable <Assembly> assemblies)
{
ThrowIfDisposed();
List <ComposablePartDefinition> addedDefinitions = new List <ComposablePartDefinition>();
Dictionary <string, ComposablePartCatalog> addedCatalogs = new Dictionary <string, ComposablePartCatalog>();
using (new ReadLock(_lock))
{
foreach (Assembly assembly in assemblies)
{
if (addedCatalogs.ContainsKey(assembly.FullName))
{
// Nothing to do because the assembly has already been added.
continue;
}
AssemblyCatalog catalog = new AssemblyCatalog(assembly);
addedDefinitions.AddRange(catalog.Parts);
addedCatalogs.Add(assembly.FullName, catalog);
}
}
// Generate notifications
using (AtomicComposition atomicComposition = new AtomicComposition())
{
ComposablePartCatalogChangeEventArgs changingArgs = new ComposablePartCatalogChangeEventArgs(
addedDefinitions, Enumerable.Empty <ComposablePartDefinition>(), atomicComposition);
OnChanging(changingArgs);
using (new WriteLock(_lock))
{
foreach (KeyValuePair <string, ComposablePartCatalog> item in addedCatalogs)
{
_catalogCollection.Catalogs.Add(item.Value);
}
}
atomicComposition.Complete();
}
ComposablePartCatalogChangeEventArgs changedArgs = new ComposablePartCatalogChangeEventArgs(
addedDefinitions, Enumerable.Empty <ComposablePartDefinition>(), null);
OnChanged(changedArgs);
}
/// <summary>
/// Fires the <see cref="Changed"/> event.
/// </summary>
/// <param name="addedDefinitions">The collection of added <see cref="ComposablePartDefinition"/> instances.</param>
/// <param name="removedDefinitions">The collection of removed <see cref="ComposablePartDefinition"/> instances.</param>
/// <param name="composition"><see cref="AtomicComposition"/> instance.</param>
protected virtual void OnChanged(IEnumerable <ComposablePartDefinition> addedDefinitions, IEnumerable <ComposablePartDefinition> removedDefinitions, AtomicComposition composition)
{
if (Changed != null)
{
if (addedDefinitions == null)
{
addedDefinitions = Enumerable.Empty <ComposablePartDefinition>();
}
if (removedDefinitions == null)
{
removedDefinitions = Enumerable.Empty <ComposablePartDefinition>();
}
var args = new ComposablePartCatalogChangeEventArgs(
addedDefinitions, removedDefinitions, composition);
Changed(this, args);
}
}
private void AddOrDeleteChanging(ComposablePartCatalogChangeEventArgs changeArgs, Action addDeleteAction, bool added)
{
bool changeException = false;
ChangeRejectedException changeRejectedException = null;
string failureDetails = null;
bool recompositionSuccess = false;
RecompositionEventReason recompositionEventReason = RecompositionEventReason.Deleted;
try
{
Changing?.Invoke(this, changeArgs);
}
catch (ChangeRejectedException exc)
{
failureDetails = GetChangeRejectedExceptionMessage(exc);
changeException = true;
}
addDeleteAction();
Changed?.Invoke(this, changeArgs);
if (!changeException)
{
recompositionSuccess = true;
}
else
{
RecompositionException(changeRejectedException);
}
if (added)
{
recompositionEventReason = RecompositionEventReason.Added;
}
RecompositionAttemptEvent?.Invoke(this, new RecompositionAttemptEventArgs(recompositionSuccess, recompositionEventReason, failureDetails));
}
void clusterBrightPluginsCatalog_Changed(object sender, ComposablePartCatalogChangeEventArgs e)
{
this.OnBrightPluginsChanged();
}
public void ShouldRaiseOnchangedAndOnChanging()
{
// arrange
bool onChangedCalled = false;
bool onChangingCalled = false;
ComposablePartCatalogChangeEventArgs onChangedEventArgs = null;
ComposablePartCatalogChangeEventArgs onChangingEventArgs = null;
var scriptName = @"c:\workingdirectory\_plugins\SimpleScript.csx";
var fileSystem = GetMockFileSystem(scriptName, Scripts.SimpleScript);
var scriptCsCatalog = new ScriptCsCatalog("_plugins", GetOptions(fileSystem: fileSystem.Object));
scriptCsCatalog.Changing += (object sender, ComposablePartCatalogChangeEventArgs e) =>
{
onChangingCalled = true;
onChangingEventArgs = e;
};
scriptCsCatalog.Changed += (object sender, ComposablePartCatalogChangeEventArgs e) =>
{
onChangedCalled = true;
onChangedEventArgs = e;
};
// act
var mefHost = GetComposedMefHost(scriptCsCatalog);
// assert
scriptCsCatalog.LoadedFiles.Count.ShouldEqual(1);
mefHost.Plugins.Count.ShouldEqual(1);
mefHost.Plugins[0].DoSomething().ShouldEqual("Simple");
// arrange
UpdateFileSystem(fileSystem, new[] { scriptName }, new[] { Scripts.DoubleScript });
// act
scriptCsCatalog.Refresh();
// assert
scriptCsCatalog.LoadedFiles.Count.ShouldEqual(1);
mefHost.Plugins.Count.ShouldEqual(1);
mefHost.Plugins[0].DoSomething().ShouldEqual("Double");
onChangingCalled.ShouldBeTrue();
onChangingEventArgs.ShouldNotBeNull();
onChangingEventArgs.AtomicComposition.ShouldNotBeNull();
onChangingEventArgs.AddedDefinitions.ShouldNotBeNull();
onChangingEventArgs.AddedDefinitions.ShouldNotBeEmpty();
onChangingEventArgs.AddedDefinitions.Count().ShouldEqual(1);
onChangingEventArgs.AddedDefinitions.First().ToString().ShouldEqual("Submission#0+DoubleSomething");
onChangingEventArgs.RemovedDefinitions.ShouldNotBeNull();
onChangingEventArgs.RemovedDefinitions.ShouldNotBeEmpty();
onChangingEventArgs.RemovedDefinitions.Count().ShouldEqual(1);
onChangingEventArgs.RemovedDefinitions.First().ToString().ShouldEqual("Submission#0+SimpleSomething");
onChangedCalled.ShouldBeTrue();
onChangedEventArgs.ShouldNotBeNull();
onChangedEventArgs.AtomicComposition.ShouldBeNull();
onChangedEventArgs.AddedDefinitions.ShouldNotBeNull();
onChangedEventArgs.AddedDefinitions.ShouldNotBeEmpty();
onChangedEventArgs.AddedDefinitions.Count().ShouldEqual(1);
onChangedEventArgs.AddedDefinitions.First().ToString().ShouldEqual("Submission#0+DoubleSomething");
onChangedEventArgs.RemovedDefinitions.ShouldNotBeNull();
onChangedEventArgs.RemovedDefinitions.ShouldNotBeEmpty();
onChangedEventArgs.RemovedDefinitions.Count().ShouldEqual(1);
onChangedEventArgs.RemovedDefinitions.First().ToString().ShouldEqual("Submission#0+SimpleSomething");
}
private void DiscoverTypes(IEnumerable <ContractInfo> contracts)
{
lock (_lock)
{
if (_catalogCollection == null)
{
_catalogCollection = new AggregateCatalog();
}
var exports = new List <Tuple <ContractInfo, Colosoft.Reflection.Composition.IExport> >();
foreach (var i in contracts)
{
if (i.Types.Count == 0)
{
var tuple = new Tuple <ContractInfo, Reflection.Composition.IExport>(i, ExportManager.GetExport(i.ContractType, i.ContractName, _uiContext));
if (tuple.Item2 != null)
{
exports.Add(tuple);
}
}
else
{
var contractExports = ExportManager.GetExports(i.ContractType, i.ContractName, _uiContext);
int contractCount = 0;
foreach (var j in contractExports)
{
if (i.Types.Contains(j.Type, Colosoft.Reflection.TypeName.TypeNameEqualityComparer.Instance))
{
contractCount++;
var tuple = new Tuple <ContractInfo, Reflection.Composition.IExport>(i, j);
exports.Add(tuple);
}
}
}
}
if (exports.Count > 0)
{
var pkgParts = new List <Colosoft.Reflection.AssemblyPart>();
var partDescriptions = new List <PartDescription>();
foreach (var i in exports)
{
var assemblyPart = new Colosoft.Reflection.AssemblyPart(string.Format("{0}.dll", i.Item2.Type.AssemblyName.Name));
if (!pkgParts.Exists(f => StringComparer.InvariantCultureIgnoreCase.Equals(f.Source, assemblyPart.Source)))
{
pkgParts.Add(assemblyPart);
}
System.ComponentModel.Composition.CreationPolicy creationPolicy = System.ComponentModel.Composition.CreationPolicy.Any;
switch (i.Item2.CreationPolicy)
{
case Reflection.Composition.CreationPolicy.NonShared:
creationPolicy = System.ComponentModel.Composition.CreationPolicy.NonShared;
break;
case Reflection.Composition.CreationPolicy.Shared:
creationPolicy = System.ComponentModel.Composition.CreationPolicy.Shared;
break;
}
ImportingConstructorDescription importingConstructor = null;
if (i.Item2.ImportingConstructor)
{
importingConstructor = new ImportingConstructorDescription(i.Item2.Type, null);
}
var partDescription = new PartDescription(i.Item2.Type, new ExportDescription[] {
new ExportDescription {
ContractTypeName = i.Item1.ContractType,
ContractName = string.IsNullOrEmpty(i.Item2.ContractName) ? null : i.Item2.ContractName.Trim(),
Metadata = i.Item2.Metadata
}
}, new ImportDescription[0], i.Item2.UseDispatcher, importingConstructor, creationPolicy);
partDescriptions.Add(partDescription);
}
var catalog = new DefinitionCatalog(new DiscoverAssembliesContainer(this, _assemblyRepository, pkgParts.ToArray(), exports), partDescriptions);
var addedDefinitions = catalog.Parts;
using (AtomicComposition composition = new AtomicComposition())
{
var args = new ComposablePartCatalogChangeEventArgs(addedDefinitions, Enumerable.Empty <ComposablePartDefinition>(), composition);
this.OnChanging(args);
_catalogCollection.Catalogs.Add(catalog);
composition.Complete();
}
ComposablePartCatalogChangeEventArgs e = new ComposablePartCatalogChangeEventArgs(addedDefinitions, Enumerable.Empty <ComposablePartDefinition>(), null);
this.OnChanged(e);
}
}
}
void Catalog_Changed(object sender, ComposablePartCatalogChangeEventArgs e)
{
//e.AddedDefinitions;
}
/// <summary>
/// Adds a Package to the catalog. It will ensure that the same Package added more than
/// once will not cause duplication in the catalog. It will also ensure that the same
/// assembly appearing in multiple packages will not cause duplication in the catalog.
/// </summary>
/// <param name="package">
/// Package obtained by constructing a <see cref="Package" /> object or
/// calling <see cref="Package.DownloadPackageAsync" />.
/// </param>
public void AddPackage(Package package)
{
this.ThrowIfDisposed();
Requires.NotNull(package, "package");
List <AssemblyCatalog> addedCatalogs = new List <AssemblyCatalog>();
ComposablePartDefinition[] addedDefinitions;
using (new ReadLock(this._lock))
{
if (this._packages.ContainsKey(package.Uri))
{
// Nothing to do because the package has already been added.
return;
}
foreach (Assembly assembly in package.Assemblies)
{
if (!this._loadedAssemblies.Contains(assembly.FullName))
{
addedCatalogs.Add(new AssemblyCatalog(assembly));
}
}
}
addedDefinitions = addedCatalogs.SelectMany(asmCat => asmCat.Parts).ToArray <ComposablePartDefinition>();
if (addedDefinitions.Length == 0)
{
// If the package doesn't contain any added definitions then simply add it to the
// list of known packages and then return
using (new WriteLock(this._lock))
{
if (!this._packages.ContainsKey(package.Uri))
{
this._packages.Add(package.Uri, package);
}
}
return;
}
// Need to raise the changing event inside an AtomicComposition to allow listeners
// to contribute state change based on whether or not the changes to the catalog
// are completed.
using (var atomicComposition = new AtomicComposition())
{
var changingArgs = new ComposablePartCatalogChangeEventArgs(addedDefinitions, Enumerable.Empty <ComposablePartDefinition>(), atomicComposition);
this.OnChanging(changingArgs); // throws ChangedRejectedException if these changes break the composition.
using (new WriteLock(this._lock))
{
if (this._packages.ContainsKey(package.Uri))
{
// Someone beat us to it so return and don't complete the AtomicComosition
return;
}
this._packages.Add(package.Uri, package);
foreach (var catalog in addedCatalogs)
{
if (!this._loadedAssemblies.Contains(catalog.Assembly.FullName))
{
this._loadedAssemblies.Add(catalog.Assembly.FullName);
this._parts.AddRange(catalog.Parts);
}
}
}
atomicComposition.Complete();
}
var changedArgs = new ComposablePartCatalogChangeEventArgs(addedDefinitions, Enumerable.Empty <ComposablePartDefinition>(), null);
this.OnChanged(changedArgs);
}
private void UpdateWebApiRegistry(ComposablePartCatalogChangeEventArgs eventArg)
{
using (TraceSources.AddInManager.TraceActivity("Updating WebApi routes."))
{
// TODO this could be cleaned up a bit
foreach (var partDefinition in eventArg.RemovedDefinitions)
{
IEnumerable <ExportDefinition> exports = partDefinition.ExportDefinitions;
var apiExport = exports.SingleOrDefault(export => StringComparer.Ordinal.Equals(export.ContractName,
Extensibility.ContractNames.ApiController));
if (apiExport == null)
{
continue;
}
IApiControllerMetadata controllerMetadata =
AttributedModelServices.GetMetadataView <IApiControllerMetadata>(apiExport.Metadata);
Type controllerType = AddInModelServices.GetPartType(partDefinition).Value;
string routeName = string.Format("{0}_{1}",
controllerMetadata.PackageId,
controllerType.FullName.Replace('.', '_'));
TraceSources.AddInManager.TraceInformation("Removing route: {0} (Source: {1}, Version: {2})",
routeName,
controllerMetadata.PackageId,
controllerMetadata.PackageVersion);
RouteBase route = RouteTable.Routes[routeName];
using (RouteTable.Routes.GetWriteLock())
{
RouteTable.Routes.Remove(route);
}
}
foreach (var partDefinition in eventArg.AddedDefinitions)
{
IEnumerable <ExportDefinition> exports = partDefinition.ExportDefinitions;
var apiExport = exports.SingleOrDefault(export => StringComparer.Ordinal.Equals(export.ContractName,
Extensibility.ContractNames.ApiController));
if (apiExport == null)
{
continue;
}
IApiControllerMetadata controllerMetadata =
AttributedModelServices.GetMetadataView <IApiControllerMetadata>(apiExport.Metadata);
Type controllerType = AddInModelServices.GetPartType(partDefinition).Value;
// Pacakge version explicitly ignored in order to remain backwards compatible
string urlTemplate = string.Format("api/{0}/{1}/",
controllerMetadata.PackageId,
controllerMetadata.UrlFragment.Trim('/'));
string routeName = string.Format("{0}_{1}",
controllerMetadata.PackageId,
controllerType.FullName.Replace('.', '_'));
string controllerName = controllerType.Name.Substring(0, controllerType.Name.Length - "Controller".Length);
TraceSources.AddInManager.TraceInformation(
"Adding route: {0} (Template: '{1}', Controller: {2}, Source: {3}, Version: {4})",
routeName,
urlTemplate,
controllerName,
controllerMetadata.PackageId,
controllerMetadata.PackageVersion);
using (RouteTable.Routes.GetWriteLock())
{
RouteTable.Routes.MapHttpRoute(
routeName,
urlTemplate,
new
{
Controller = controllerName,
});
}
}
}
}
void serverPluginsCatalog_Changed(object sender, ComposablePartCatalogChangeEventArgs e)
{
this.OnServerPluginsChanged();
}
void dCat_Changed(object sender, ComposablePartCatalogChangeEventArgs e)
{
Console.WriteLine("Directory catalog changed");
}
private void HandleInterceptedCatalogChanging(object sender, ComposablePartCatalogChangeEventArgs e)
{
Recompose(e.AddedDefinitions, e.RemovedDefinitions, e.AtomicComposition);
}
