public void Load(ISpeedDateStartable startable, IConfigProvider configProvider,
Action <SpeedDateConfig> startedCallback)
{
_logger = LogManager.GetLogger("SpeedDate");
_config = configProvider.Result;
_container = CreateContainer(startable);
configProvider.Configure(_container.ResolveAll <IConfig>());
_container.BuildUp(startable);
//Filter plugins for namespace & inject configuration into valid plugins
foreach (var plugin in _container.ResolveAll <IPlugin>())
{
if (_config.Plugins.Namespaces.Split(';').Any(ns =>
Regex.IsMatch(plugin.GetType().Namespace, ns.Trim().AsRegular())))
{
_logger.Debug($"Loading plugin: {plugin}");
//Inject configs, cannot use _container.BuildUp because the configProvider may have additional IConfigs
var fields = from field in plugin.GetType()
.GetFields(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public)
where Attribute.IsDefined(field, typeof(InjectAttribute))
select field;
foreach (var field in fields)
{
if (field.GetValue(plugin) == null &&
_config.TryGetConfig(field.FieldType.FullName, out var config))
{
field.SetValue(plugin, config);
}
}
}
else
{
_container.Unregister(typeof(IPlugin), plugin.GetType().FullName);
}
}
//Inject additional dependencies e.g. ILogger
foreach (var plugin in _container.ResolveAll <IPlugin>())
{
_container.BuildUp(plugin);
}
//Finally notify every plugin that loading has finished
foreach (var plugin in _container.ResolveAll <IPlugin>())
{
plugin.Loaded();
_logger.Info($"Loaded {plugin.GetType().Name}");
}
startedCallback.Invoke(_config);
}
protected MasterServerBase(TinyIoCContainer container, IPEndPoint endpoint)
: this(endpoint)
{
// Resolve lifecycle callbacks
ApplicationLifecycleCallbacks.AddRange(
container.ResolveAll<IApplicationLifecycleCallbackHandler>().OrderByDescending(s => s.Priority).ToList());
MessageLifecycleCallbacks.AddRange(
container.ResolveAll<IMessageLifecycleCallbackHandler>().OrderByDescending(s => s.Priority).ToList());
}
protected MasterServerBase(TinyIoCContainer container, IPEndPoint endpoint)
: this(endpoint)
{
// Resolve lifecycle callbacks
ApplicationLifecycleCallbacks.AddRange(
container.ResolveAll <IApplicationLifecycleCallbackHandler>().OrderByDescending(s => s.Priority).ToList());
MessageLifecycleCallbacks.AddRange(
container.ResolveAll <IMessageLifecycleCallbackHandler>().OrderByDescending(s => s.Priority).ToList());
}
public AppBootstrapper()
{
Router = new RoutingState();
Kernel = new TinyIoCContainer();
// XXX: This is gross
Kernel.Register <UIViewController>(new RouterUINavigationController(Router), "InitialPage");
Kernel.Register(typeof(IViewFor <iOSPlaygroundViewModel>), typeof(iOSPlaygroundViewController));
Kernel.Register <IScreen>(this);
var toRegister = new Dictionary <Tuple <Type, String>, List <Type> >();
RxApp.ConfigureServiceLocator(
(t, s) => s != null ? Kernel.Resolve(t, s) : Kernel.Resolve(t),
(t, s) => Kernel.ResolveAll(t, true),
(c, t, s) => {
if (toRegister != null)
{
var pair = Tuple.Create(t, s);
if (!toRegister.ContainsKey(pair))
{
toRegister[pair] = new List <Type>();
}
toRegister[pair].Add(c);
return;
}
if (s != null)
{
Kernel.Register(t, c, s);
}
else
{
Kernel.Register(t, c);
}
});
foreach (var key in toRegister.Keys)
{
var val = toRegister[key].Distinct();
Kernel.RegisterMultiple(key.Item1, val);
}
toRegister = null;
var items = Kernel.ResolveAll(typeof(ICreatesObservableForProperty), true).ToArray();
Router.Navigate.Go <iOSPlaygroundViewModel>();
}
public void Publish <T>(T message)
{
foreach (var handler in _container.ResolveAll <IHandle <T> >())
{
handler.Handle(message);
}
}
private static void Initialize(IDestination destination, IBootstrapper bootstrapper)
{
TinyIoCContainer container = new TinyIoCContainer();
NoomResolver resolver = new NoomResolver(container);
NoomCache cache = new NoomCache();
NoomTools tools = new NoomTools(resolver, cache);
NoomRouter router = new NoomRouter();
NoomNavigator navigator = new NoomNavigator(router, destination, tools);
container.Register <ICache>(cache);
container.Register <IRouter>(router);
container.Register <INavigator>(navigator);
container.Register <IResolver>(resolver);
container.RegisterMultiple(typeof(IModule), bootstrapper.FindAllModules());
foreach (Type type in bootstrapper.FindAllViews())
{
container.Register(type);
}
foreach (IModule module in container.ResolveAll <IModule>())
{
module.Register(router);
}
navigator.NavigateTo("/");
}
public override IEnumerable <object> GetServices(Type serviceType)
{
var objects = _container.CanResolve(serviceType) ? _container.ResolveAll(serviceType) : new object[] { };
var result = objects.Concat(base.GetServices(serviceType));
return(result);
}
public static void ConfigureContainer(TinyIoCContainer container)
{
container.Register(typeof(ILogHandler), typeof(Logger.Log4NetLogger)).AsSingleton();
container.Register(typeof(IMessageRouter<IMessage>), typeof(MessageRouter)).AsSingleton();
container.RegisterMultiple<IClientLifecycleCallbackHandler>(new List<Type>()
{
typeof (BlyncLightManager),
typeof (SkypeManager)
}).AsSingleton();
container.RegisterMultiple<IBlyncLightBehaviour>(new List<Type>()
{
typeof (SkypeStatusResponder),
typeof (BlyncLightScheduler)
});
container.RegisterMultiple<ISkypeBehaviour>(new List<Type>()
{
typeof (CallStatusNotifier),
typeof (UserStatusNotifier),
typeof (OnBreakBehaviour),
typeof (OnLunchBehaviour),
typeof (OnCallBehaviour)
});
//IBlyncLightBehaviour
container.Register(typeof(SkypeStatusResponder),
new SkypeStatusResponder(container.Resolve<IMessageRouter<IMessage>>()));
//IClientLifecycleCallbackHandler
container.Register(typeof(SkypeManager),
new SkypeManager(container.Resolve<ILogHandler>(),
container.Resolve<IMessageRouter<IMessage>>(),
container.ResolveAll<ISkypeBehaviour>().OrderByDescending(s => s.Priority).ToList()));
container.Register(typeof(BlyncLightManager),
new BlyncLightManager(container.Resolve<ILogHandler>(),
container.Resolve<IMessageRouter<IMessage>>(),
container.ResolveAll<IBlyncLightBehaviour>().OrderByDescending(s => s.Priority).ToList()));
//Client
container.Register(typeof(BlyncLightForSkypeClient),
new BlyncLightForSkypeClient());
}
public override IEnumerable <object> GetServices(Type serviceType)
{
if (container.CanResolve(serviceType))
{
return(container.ResolveAll(serviceType).Concat(base.GetServices(serviceType)));
}
return(base.GetServices(serviceType));
}
public override IEnumerable <object> GetServices(Type serviceType)
{
if (_TinyIoCContainer.CanResolve(serviceType))
{
return(_TinyIoCContainer.ResolveAll(serviceType, true));
}
return(base.GetServices(serviceType));
}
public AppBootstrapper()
{
Router = new RoutingState();
Kernel = new TinyIoCContainer();
// XXX: This is gross
Kernel.Register<UIViewController>(new RouterUINavigationController(Router), "InitialPage");
Kernel.Register(typeof(IViewFor<iOSPlaygroundViewModel>), typeof(iOSPlaygroundViewController));
Kernel.Register<IScreen>(this);
var toRegister = new Dictionary<Tuple<Type, String>, List<Type>>();
RxApp.ConfigureServiceLocator(
(t, s) => s != null ? Kernel.Resolve(t, s) : Kernel.Resolve(t),
(t, s) => Kernel.ResolveAll(t, true),
(c, t, s) => {
if (toRegister != null) {
var pair = Tuple.Create(t,s);
if (!toRegister.ContainsKey(pair)) {
toRegister[pair] = new List<Type>();
}
toRegister[pair].Add(c);
return;
}
if (s != null) {
Kernel.Register(t, c, s);
} else {
Kernel.Register(t, c);
}
});
foreach(var key in toRegister.Keys) {
var val = toRegister[key].Distinct();
Kernel.RegisterMultiple(key.Item1, val);
}
toRegister = null;
var items = Kernel.ResolveAll(typeof(ICreatesObservableForProperty), true).ToArray();
Router.Navigate.Go<iOSPlaygroundViewModel>();
}
private void RegisterPipelines(IPipelines pipelines)
{
var pipelineRegistrars = _tinyIoCContainer.ResolveAll <IRegisterNancyPipeline>();
foreach (var registerNancyPipeline in pipelineRegistrars)
{
registerNancyPipeline.Register(pipelines);
}
}
protected void Register(TinyIoCContainer container)
{
Configure(container);
container.Register<IMappingProvider>(new DefaultMappingProvider(container.ResolveAll<IMap>()));
container.Register<IConnectionStringProvider>(new DefaultConnectionStringProvider("ApplicationConnectionString"));
container.Register<IDatabaseFactory>(new DatabaseFactory(container.Resolve<IConnectionStringProvider>(), container.Resolve<IMappingProvider>()));
container.Register<IDatabase>(container.Resolve<IDatabaseFactory>().GetDatabase());
}
private bool RegisterMultiple(TinyIoCContainer container, ILogger logger)
{
logger.WriteLine("RegisterMultiple");
container.RegisterMultiple <ITestInterface>(new Type[] { typeof(TestClassWithInterface), typeof(TestClassWithInterface2) });
var result = container.ResolveAll <ITestInterface>();
return(result.Count() == 2);
}
void ApplyFileSearchModifiers(TinyIoCContainer container, FileSearch fileSearch)
{
var modifiers = container.ResolveAll <IFileSearchModifier <T> >();
foreach (var modifier in modifiers)
{
modifier.Modify(fileSearch);
}
}
IBundlePipeline <T> ApplyBundlePipelineModifiers(IBundlePipeline <T> pipeline, TinyIoCContainer container)
{
var modifiers = container.ResolveAll <IBundlePipelineModifier <T> >();
return(modifiers.Aggregate(
pipeline,
(currentPipeline, modifier) => modifier.Modify(currentPipeline)
));
}
void RunStartUpTasks()
{
var startUpTasks = container.ResolveAll <IStartUpTask>();
foreach (var startUpTask in startUpTasks)
{
Trace.Source.TraceInformation("Running start-up task: {0}", startUpTask.GetType().FullName);
startUpTask.Start();
}
}
public void Run()
{
var masterRegistry = new Registry(_container);
masterRegistry.RegisterInstances();
foreach (var registry in _container.ResolveAll <IRegistry>())
{
registry.RegisterInstances();
}
}
public IEnumerable <object> GetServices(Type serviceType)
{
try
{
return(container.ResolveAll(serviceType));
}
catch (Exception)
{
throw;
}
}
private bool ResolveAll(TinyIoCContainer container, ILogger logger)
{
logger.WriteLine("ResolveAll");
container.Register <ITestInterface, TestClassWithInterface>();
container.Register <ITestInterface, TestClassWithInterface>("Named1");
container.Register <ITestInterface, TestClassWithInterface>("Named2");
IEnumerable <ITestInterface> result = container.ResolveAll <ITestInterface>();
return(result.Count() == 3);
}
public IEnumerable <object> GetServices(Type serviceType)
{
try
{
return(_container.ResolveAll(serviceType, true));
}
catch (Exception)
{
return(Enumerable.Empty <object>());
}
}
/// <summary>
/// Retrieves a collection of services from the scope.
/// </summary>
/// <returns>
/// The retrieved collection of services.
/// </returns>
/// <param name="serviceType">The collection of services to be retrieved.</param>
public IEnumerable <object> GetServices(Type serviceType)
{
try
{
return(_dependencyContainer.ResolveAll(serviceType));
}
catch (TinyIoCResolutionException ex)
{
Debug.WriteLine("Exception in resolving {0}: {1}", serviceType, ex.Message);
return(null);
}
}
protected override void ConfigureRequestContainer(TinyIoCContainer container, NancyContext context)
{
base.ConfigureRequestContainer(container, context);
if (context.Request.Url.Path.EndsWith("system-information", StringComparison.OrdinalIgnoreCase))
{
context.ViewBag.SystemInformationComponents = container
.ResolveAll <ISystemInformationComponent>()
.Distinct(new SystemInformationComponentEqualityComparer())
.OrderBy(c => c.Cardinality)
.ToArray();
}
}
public IEnumerable <object> GetServices(Type serviceType)
{
if (Container == null)
{
throw new ObjectDisposedException("this", "This scope has already been disposed.");
}
try
{
return(Container.ResolveAll(serviceType));
}
catch (TinyIoCResolutionException)
{
return(Enumerable.Empty <object>());
}
}
protected override void ConfigureApplicationContainer(TinyIoCContainer container)
{
var configuration = FetchConfiguration();
container.Register(configuration);
container.Register <IDatabaseHost, DatabaseHost>().AsSingleton();
container.Register <IUserRepository, UserRepository>();
container.Register <IPaymentRepository, PaymentRepository>();
container.Register <INancyModule, UserModule>().AsSingleton();
container.Register <INancyModule, HelloViewModule>().AsSingleton();
container.Register <INancyModule, UsersModule>().AsSingleton();
var x = container.ResolveAll <INancyModule>().ToList();
}
public IEnumerable <object> GetServices(Type serviceType)
{
return(_container.CanResolve(serviceType)
? _container.ResolveAll(serviceType, true)
: Enumerable.Empty <object>());
}
protected override void ApplicationStartup(TinyIoCContainer container, IPipelines pipelines)
{
BootStrapper.RootPath = this.RootPathProvider.GetRootPath();
// create App_Data
Directory.CreateDirectory(Path.Combine(BootStrapper.RootPath, "App_Data"));
ModuleResource.ReadSystemsAndResources(BootStrapper.RootPath);
#region View Conventions
this.Conventions.ViewLocationConventions.Clear();
// Site's View Folder has most priority
// Mobile View Overrides
this.Conventions.ViewLocationConventions.Add((viewName, model, context) =>
{
string u = context.Context.Request.Headers.UserAgent.ToLowerInvariant();
if (u.Contains("mobile/"))
{
return "Site/Views/Mobile/" + viewName;
}
return string.Empty; // not mobile browser
});
// Desktop View Location
this.Conventions.ViewLocationConventions.Add((viewName, model, context) =>
{
return "Site/Views/Desktop/" + viewName;
});
// Generic View Location
this.Conventions.ViewLocationConventions.Add((viewName, model, context) =>
{
return "Site/Views/" + viewName;
});
// NancyBlack's View Location
this.Conventions.ViewLocationConventions.Add((viewName, model, context) =>
{
return "Content/Views/" + viewName;
});
// then try Views in Systems (AdminSystem, ContentSystem etc...)
foreach (var system in ModuleResource.Systems)
{
this.Conventions.ViewLocationConventions.Add((viewName, model, context) =>
{
return string.Concat("Modules/",
viewName);
});
this.Conventions.ViewLocationConventions.Add((viewName, model, context) =>
{
return string.Concat("Modules/",
system,
"/Views/",
viewName);
});
}
this.Conventions.ViewLocationConventions.Add((viewName, model, context) =>
{
return viewName; // fully qualify names
});
this.Conventions.ViewLocationConventions.Add((viewName, model, context) =>
{
return viewName.Substring(1); // fully qualify names, remove forward slash at first
});
#endregion
var formsAuthConfiguration = new FormsAuthenticationConfiguration
{
RedirectUrl = "~/__membership/login",
UserMapper = container.Resolve<IUserMapper>(),
};
FormsAuthentication.Enable(pipelines, formsAuthConfiguration);
pipelines.BeforeRequest.AddItemToStartOfPipeline((ctx) =>
{
ctx.Items["SiteDatabase"] = NancyBlackDatabase.GetSiteDatabase(this.RootPathProvider.GetRootPath());
ctx.Items["CurrentSite"] = BootStrapper.GetSiteSettings();
ctx.Items["SiteSettings"] = BootStrapper.GetSiteSettings();
if (ctx.CurrentUser == null)
{
ctx.CurrentUser = NcbUser.Anonymous;
if (ctx.Request.Url.HostName == "localhost")
{
ctx.CurrentUser = NcbUser.LocalHostAdmin;
}
}
return null;
});
foreach (var item in container.ResolveAll<IPipelineHook>())
{
item.Hook(pipelines);
}
}
public IEnumerable <object> ResolveAll(Type service)
{
return(_container.ResolveAll(service));
}
public IEnumerable <object> GetAllInstances(Type serviceType)
{
return(_container.ResolveAll(serviceType));
}
public IEnumerable <T> ResolveAll <T>() where T : class
{
return(_container.ResolveAll <T>());
}
public IEnumerable <object> ResolveAll(Type resolveType, bool includeUnamed)
{
return(_container.ResolveAll(resolveType, includeUnamed));
}
public override IEnumerable <object> GetServices(Type serviceType)
{
var objects = m_Container.CanResolve(serviceType) ? m_Container.ResolveAll(serviceType) : new object[] { };
return(objects.Concat(base.GetServices(serviceType)));
}
public T GetPlugin <T>() where T : class, IPlugin
{
return(_container.ResolveAll <IPlugin>().FirstOrDefault(plugin => plugin is T) as T);
}
public override IEnumerable <object> ResolveAll(Type type)
{
return(container.ResolveAll(type, true));
}
public IEnumerable <object> GetServices(Type serviceType)
{
var resolvedTypes = Container.ResolveAll(serviceType);
return(resolvedTypes);
}
