public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency)
{
if (m_KnownDependencies.ContainsKey(dependency))
{
return(true);
}
IHandler[] handlers = m_Kernel.GetHandlers(dependency.TargetType);
//if there's just one, we're not interested.
if (handlers.Length < 2)
{
return(false);
}
foreach (IHandler handler in handlers)
{
if (IsMatch(handler.ComponentModel, dependency) && handler.CurrentState == HandlerState.Valid)
{
if (!handler.ComponentModel.Name.Equals(dependency.DependencyKey, StringComparison.Ordinal))
{
m_KnownDependencies.Add(dependency, handler.ComponentModel.Name);
}
return(true);
}
}
return(false);
}
public void RegisterPackages(ICollection <RouteBase> routes, ICollection <IViewEngine> engines)
{
IEnumerable <IHandler> remainingPackages = _kernel.GetHandlers(typeof(IWebPackage));
while (remainingPackages.Count() != 0)
{
var validPackages = remainingPackages.Where(handler => handler.CurrentState == HandlerState.Valid).ToArray();
if (validPackages.Count() == 0)
{
break;
}
foreach (var handler in validPackages)
{
var package = _kernel.Resolve <IWebPackage>(handler.ComponentModel.Name);
package.Register(_kernel, routes, engines);
_kernel.ReleaseComponent(package);
}
remainingPackages = remainingPackages.Except(validPackages).ToArray();
}
//TODO: throw a detail-rich exception
if (remainingPackages.Count() != 0)
{
throw new ApplicationException("Web packages have unresolved dependencies");
}
}
private IEnumerable <IHandler> GetOtherHandlers(
Type serviceType,
string thisComponentName
)
{
return(kernel
.GetHandlers(serviceType)
.Where(h => h.ComponentModel.Name != thisComponentName));
}
private IEnumerable <Func <T> > ListOfFactoryMethods <T>(IKernel kernel, CreationContext context)
{
var handlers = kernel.GetHandlers(typeof(T));
return(handlers.Select(handler =>
{
Func <T> factory = () => (T)handler.Resolve(context);
return factory;
}));
}
private static IPreCommit[] FetchHooks(IKernel kernel)
{
ArrayList list = new ArrayList();
foreach (IHandler handler in kernel.GetHandlers(typeof(IPreCommit)))
{
IPreCommit hook = (IPreCommit)handler.Resolve();
list.Add(hook);
}
return (IPreCommit[])list.ToArray(typeof(IPreCommit));
}
private static IPreCommit[] FetchHooks(IKernel kernel)
{
ArrayList list = new ArrayList();
foreach (IHandler handler in kernel.GetHandlers(typeof(IPreCommit)))
{
IPreCommit hook = (IPreCommit)handler.Resolve();
list.Add(hook);
}
return((IPreCommit[])list.ToArray(typeof(IPreCommit)));
}
private void InspectServiceDependency(IHandler inspectingHandler, DependencyModel dependency, IKernel kernel)
{
var type = dependency.TargetItemType;
var handler = kernel.GetHandler(type);
if (handler == null)
{
message.AppendFormat("- Service '{0}' which was not registered.", type.FullName ?? type.Name);
message.AppendLine();
}
else if (handler == inspectingHandler)
{
var alternatives = kernel.GetHandlers(type);
message.AppendFormat("- Service '{0}' which points back to the component itself.", type.FullName ?? type.Name);
message.AppendLine();
message.Append("A dependency cannot be satisfied by the component itself, did you forget to ");
if (alternatives.Length == 1)
{
message.AppendLine("register other components for this service?");
}
else
{
message.AppendLine("make this a service override and point explicitly to a different component exposing this service?");
message.AppendLine();
message.Append("The following components also expose the service, but none of them can be resolved:");
foreach (var maybeDecoratedHandler in alternatives.Where(maybeDecoratedHandler => maybeDecoratedHandler != inspectingHandler))
{
var info = maybeDecoratedHandler as IExposeDependencyInfo;
if (info != null)
{
info.ObtainDependencyDetails(this);
}
else
{
message.AppendLine();
message.AppendFormat("'{0}' is registered and is matching the required service, but cannot be resolved.",
maybeDecoratedHandler.ComponentModel.Name);
}
}
}
}
else
{
message.AppendFormat("- Service '{0}' which was registered but is also waiting for dependencies.", handler.ComponentModel.Name);
var info = handler as IExposeDependencyInfo;
if (info != null)
{
info.ObtainDependencyDetails(this);
}
}
}
private void LoadRules()
{
IHandler[] handlers = kernel.GetHandlers(typeof(ISecurityRule));
rules = new ISecurityRule[handlers.Length];
for (int i = 0; i < rules.Length; i++)
{
Type impl = handlers[i].ComponentModel.Implementation;
if (typeof(SecurityRulesProvider).IsAssignableFrom(impl))
{
continue;
}
rules[i] = (ISecurityRule)handlers[i].Resolve(null);
}
}
private void InspectServiceDependency(IHandler inspectingHandler, DependencyModel dependency, IKernel kernel)
{
var type = dependency.TargetItemType;
var handler = kernel.GetHandler(type);
if (handler == null)
{
message.AppendFormat("- Service '{0}' which was not registered.", type.FullName ?? type.Name);
message.AppendLine();
}
else if (handler == inspectingHandler)
{
var alternatives = kernel.GetHandlers(type);
message.AppendFormat("- Service '{0}' which points back to the component itself.", type.FullName ?? type.Name);
message.AppendLine();
message.Append("A dependency cannot be satisfied by the component itself, did you forget to ");
if (alternatives.Length == 1)
{
message.AppendLine("register other components for this service?");
}
else
{
message.AppendLine("make this a service override and point explicitly to a different component exposing this service?");
message.AppendLine();
message.Append("The following components also expose the service, but none of them can be resolved:");
foreach (var maybeDecoratedHandler in alternatives.Where(maybeDecoratedHandler => maybeDecoratedHandler != inspectingHandler))
{
var info = maybeDecoratedHandler as IExposeDependencyInfo;
if (info != null)
{
info.ObtainDependencyDetails(this);
}
else
{
message.AppendLine();
message.AppendFormat("'{0}' is registered and is matching the required service, but cannot be resolved.",
maybeDecoratedHandler.ComponentModel.Name);
}
}
}
}
else
{
message.AppendFormat("- Service '{0}' which was registered but is also waiting for dependencies.", handler.ComponentModel.Name);
var info = handler as IExposeDependencyInfo;
if (info != null)
{
info.ObtainDependencyDetails(this);
}
}
}
/// <summary>
/// Queries the kernel for implementations of ISourceControl.
/// This allow new build system to be registered even without
/// restarting the application. A more efficient approach however
/// is to issue this query only once, but then you lost the ability
/// to add/remove buildsystems at runtime
/// </summary>
/// <remarks>
/// This approach invokes Resolve on the handler,
/// but do not invoke the counter part release.
/// </remarks>
/// <returns></returns>
public virtual ISourceControl[] AvailableSourceControl()
{
ArrayList list = new ArrayList();
IHandler[] handlers = _kernel.GetHandlers(typeof(ISourceControl));
foreach (IHandler handler in handlers)
{
if (handler.CurrentState == HandlerState.Valid)
{
list.Add(handler.Resolve());
}
}
return((ISourceControl[])list.ToArray(typeof(ISourceControl)));
}
/// <summary>
/// Queries the kernel for implementations of IBuildSystem.
/// This allow new build system to be registered even without
/// restarting the application. A more efficient approach however
/// is to issue this query only once, but then you lost the ability
/// to add/remove buildsystems at runtime
/// </summary>
/// <remarks>
/// This approach invokes Resolve on the handler,
/// but do not invoke the counter part release.
/// </remarks>
/// <returns></returns>
public virtual IBuildSystem[] AvailableBuildSystems()
{
ArrayList list = new ArrayList();
IHandler[] handlers = _kernel.GetHandlers(typeof(IBuildSystem));
foreach (IHandler handler in handlers)
{
if (handler.CurrentState == HandlerState.Valid)
{
list.Add(handler.Resolve());
}
}
return((IBuildSystem[])list.ToArray(typeof(IBuildSystem)));
}
