Nancy service bootstrapper sample

NancyBoostrapper

public class ServiceBootstrapper : NancyBootstrapperBase<IWindsorContainer>
{
	bool _modulesRegistered;

	protected override IEnumerable<IStartup> GetStartupTasks()
	{
		return ApplicationContainer.ResolveAll<IStartup>();
	}

	protected override INancyEngine GetEngineInternal()
	{
		return ApplicationContainer.Resolve<INancyEngine>();
	}

	protected override IModuleKeyGenerator GetModuleKeyGenerator()
	{
		return ApplicationContainer.Resolve<IModuleKeyGenerator>();
	}

	protected override IWindsorContainer GetApplicationContainer()
	{
		if (ApplicationContainer != null) return ApplicationContainer;
		var container = WindsorContainerFactory.GetContainer();
		container.Kernel.Resolver.AddSubResolver(new CollectionResolver(container.Kernel, true));
		return container;
	}

	protected override void RegisterModules(IWindsorContainer container, IEnumerable<ModuleRegistration> moduleRegistrationTypes)
	{
		if (_modulesRegistered) return;
		_modulesRegistered = true;
		IEnumerable<ComponentRegistration<object>> components = moduleRegistrationTypes
			.Select(r => Component.For(typeof(NancyModule))
			.ImplementedBy(r.ModuleType)
			.Named(r.ModuleKey)
			.LifeStyle.PerWebRequest);
		ApplicationContainer.Register(components.ToArray());
	}

	public override IEnumerable<NancyModule> GetAllModules(NancyContext context)
	{
		return ApplicationContainer.ResolveAll<NancyModule>();
	}

	public override NancyModule GetModuleByKey(string moduleKey, NancyContext context)
	{
		return ApplicationContainer.Resolve<NancyModule>(moduleKey);
	}

	protected override void RegisterBootstrapperTypes(IWindsorContainer applicationContainer)
	{
		applicationContainer.Register(Component.For<INancyModuleCatalog>().Instance(this));
	}

	protected override void RegisterTypes(IWindsorContainer container, IEnumerable<TypeRegistration> typeRegistrations)
	{
		IEnumerable<ComponentRegistration<object>> components = typeRegistrations
			.Where(t => t.RegistrationType != typeof(IModuleKeyGenerator))
			.Select(r => Component.For(r.RegistrationType)
				.ImplementedBy(r.ImplementationType));
		container.Register(components.ToArray());
		container.Register(Component.For<IModuleKeyGenerator>().ImplementedBy<WindsorModuleKeyGenerator>());
		container.Register(Component.For<Func<IRouteCache>>()
			.UsingFactoryMethod(ctx => (Func<IRouteCache>)(ctx.Resolve<IRouteCache>)));
	}

	protected override void RegisterCollectionTypes(IWindsorContainer container, IEnumerable<CollectionTypeRegistration> collectionTypeRegistrations)
	{
		foreach (CollectionTypeRegistration collectionTypeRegistration in collectionTypeRegistrations)
		{
			foreach (Type implementationType in collectionTypeRegistration.ImplementationTypes)
				container.Register(Component.For(collectionTypeRegistration.RegistrationType).ImplementedBy(implementationType));
		}
	}

	protected override void RegisterInstances(IWindsorContainer container, IEnumerable<InstanceRegistration> instanceRegistrations)
	{
		foreach (InstanceRegistration instanceRegistration in instanceRegistrations)
		{
			container.Register(
				Component.For(instanceRegistration.RegistrationType).Instance(instanceRegistration.Implementation));
		}
	}
}

public class WindsorModuleKeyGenerator : IModuleKeyGenerator
{
	
	public string GetKeyForModuleType(Type moduleType)
	{
		return moduleType.FullName.StartsWith("Castle.Proxies") ? moduleType.BaseType.FullName : moduleType.FullName;
	}
}