public void Configure(FubuRegistry registry)
{
registry.Policies.Add<HtmlConventionActivation>();
registry.Services<UIServiceRegistry>();
registry.ViewFacility(new HtmlDocumentViewFacility());
}
protected override void configure(FubuRegistry registry)
{
registry.Actions.IncludeType<ShowEditEndpoints>();
registry.Import<HtmlConventionRegistry>(x => {
x.FieldChrome<TableRowFieldChrome>();
});
}
void IFeatureSettings.Apply(FubuRegistry registry)
{
if (!Enabled) return;
registry.Actions.IncludeType<LoginController>();
registry.Actions.IncludeType<LogoutController>();
registry.Services.IncludeRegistry<AuthenticationServiceRegistry>();
registry.Policies.Global.Add(new ApplyAuthenticationPolicy());
if (MembershipEnabled == MembershipStatus.Enabled)
{
if (!Strategies.OfType<MembershipNode>().Any())
{
Strategies.InsertFirst(new MembershipNode());
}
}
foreach (IContainerModel strategy in Strategies)
{
var instance = strategy.ToInstance();
registry.Services.AddService(typeof (IAuthenticationStrategy), instance);
}
}
public void Configure(FubuRegistry registry)
{
registry.Policies.Add<ViewDiagnosticsMenu>();
registry.Actions.IncludeType<ViewsEndpoint>();
registry.Services(x => x.FillType<IActivator, ProblemGatherer>());
registry.Services(x => x.FillType<IViewProblemStoreCache, ViewProblemStoreCache>());
}
void IFeatureSettings.Apply(FubuRegistry registry)
{
if (!Enabled) return;
registry.Services.IncludeRegistry<AntiForgeryServiceRegistry>();
registry.Policies.Local.Add<AntiForgeryPolicy>();
}
public ConfigSource(FubuRegistry provenance, IConfigurationAction action)
{
_provenance = provenance;
_action = action;
Id = Guid.NewGuid();
_description = new Lazy<Description>(() => Description.For(action));
}
public void is_registered()
{
var registry = new FubuRegistry();
registry.Import<ViewEnginesExtension>();
registry.AlterSettings<CommonViewNamespaces>(x =>
{
x.Add("Foo");
x.Add("Bar");
});
var graph = BehaviorGraph.BuildFrom(registry);
var useNamespaces = graph.Services.DefaultServiceFor<CommonViewNamespaces>().Value.As<CommonViewNamespaces>();
useNamespaces.Namespaces.Each(x => Debug.WriteLine(x));
useNamespaces.Namespaces.ShouldHaveTheSameElementsAs(new[]
{
typeof(VirtualPathUtility).Namespace,
typeof(string).Namespace,
typeof(FileSet).Namespace,
typeof(ParallelQuery).Namespace,
typeof(HtmlTag).Namespace,
"Foo",
"Bar",
});
}
protected override void configure(FubuRegistry registry)
{
registry.Services(x => x.AddService<IFieldAccessRule, ShowEditFakePolicy>());
registry.Actions.IncludeType<ShowEditEndpoints>();
registry.Import<HtmlConventionRegistry>(x => {
x.Profile("table", profile => profile.FieldChrome<TableRowFieldChrome>());
});
}
public void Configure(FubuRegistry registry)
{
registry.Configure(graph => {
graph.Settings.Get<ViewEngines>().UseGraph(graph);
});
}
void IFeatureSettings.Apply(FubuRegistry registry)
{
if (!Enabled) return;
registry.Actions.FindWith<SendsMessageActionSource>();
registry.Policies.Global.Add<SendsMessageConvention>();
registry.Policies.Global.Add<ApplyScheduledJobRouting>();
registry.Services.IncludeRegistry<ScheduledJobServicesRegistry>();
registry.Services.IncludeRegistry<MonitoringServiceRegistry>();
registry.Policies.ChainSource<SystemLevelHandlers>();
registry.Services.IncludeRegistry(new FubuTransportServiceRegistry(registry.Mode));
registry.Services.IncludeRegistry<PollingServicesRegistry>();
registry.Policies.Global.Add<StatefulSagaConvention>();
// Just forcing it to get spun up.
registry.AlterSettings<ChannelGraph>(x => {});
registry.Handlers.Include<SystemLevelHandlers>();
registry.Configure(graph =>
{
graph.Handlers.Each(chain =>
{
// Apply the error handling node
chain.InsertFirst(new ExceptionHandlerNode(chain));
// Hate how we're doing this, but disable tracing
// on the polling job requests here.
if (chain.InputType().Closes(typeof (JobRequest<>)))
{
chain.Tags.Add(BehaviorChain.NoTracing);
}
});
});
if (InMemoryTransport == InMemoryTransportMode.AllInMemory)
{
registry.Services.For<ITransport>().ClearAll();
registry.Services.AddService<ITransport, InMemoryTransport>();
SettingTypes.Each(settingType =>
{
var settings = InMemory.InMemoryTransport.ToInMemory(settingType);
registry.Services.ReplaceService(settingType, new ObjectInstance(settings));
});
}
if (InMemoryTransport != InMemoryTransportMode.Disabled)
{
registry.Services.AddService<ITransport, InMemoryTransport>();
}
registry.Policies.Global.Add<ReorderBehaviorsPolicy>(x =>
{
x.ThisNodeMustBeBefore<StatefulSagaNode>();
x.ThisNodeMustBeAfter<HandlerCall>();
});
}
void IFeatureSettings.Apply(FubuRegistry registry)
{
if (Enabled)
{
registry.Services.IncludeRegistry<ServerSentEventRegistry>();
registry.Policies.ChainSource<TopicChainSource>();
}
}
public void Configure(FubuRegistry registry)
{
registry.Services<AssetServicesRegistry>();
registry.Policies.Add<AssetContentEndpoint>();
registry.AlterSettings<CommonViewNamespaces>(x => {
x.AddForType<AssetBottleRegistration>();
});
}
void IFeatureSettings.Apply(FubuRegistry registry)
{
if (!Enabled) return;
registry.Services.IncludeRegistry<BasicLocalizationServices>();
if (DefaultCulture != null)
{
registry.Services.ReplaceService(DefaultCulture);
}
}
public static Task Compile(BehaviorGraph graph, IPerfTimer timer, FubuRegistry registry)
{
return TypeRepository.FindTypes(graph.AllAssemblies(),
TypeClassification.Concretes | TypeClassification.Closed, IsValidationRegistration)
.ContinueWith(t =>
{
t.Result.Distinct()
.Each(type => registry.Services.For(typeof(IValidationRegistration)).Add(type));
});
}
public static BehaviorGraph Build(FubuRegistry registry, IPerfTimer perfTimer,
IEnumerable<Assembly> packageAssemblies, IActivationDiagnostics diagnostics, IFubuApplicationFiles files)
{
var featureLoader = new FeatureLoader();
featureLoader.LookForFeatures();
if (registry.Mode.InDevelopment())
{
registry.AlterSettings<DiagnosticsSettings>(_ => _.TraceLevel = TraceLevel.Verbose);
registry.AlterSettings<AssetSettings>(_ => _.SetupForDevelopment());
}
var graph = new BehaviorGraph
{
ApplicationAssembly = registry.ApplicationAssembly,
PackageAssemblies = packageAssemblies
};
var accessorRules = AccessorRulesCompiler.Compile(graph, perfTimer);
var config = registry.Config;
perfTimer.Record("Applying Settings", () => applySettings(config, graph, diagnostics, files));
perfTimer.Record("Enable built in polling jobs", () => enableBuiltInJobs(graph));
perfTimer.Record("Applying Feature Settings", () => featureLoader.ApplyAll(graph.Settings, registry).Wait());
perfTimer.Record("Local Application BehaviorGraph", () => config.BuildLocal(graph, perfTimer));
perfTimer.Record("Explicit Configuration", () => config.Global.Explicits.RunActions(graph));
perfTimer.Record("Global Policies", () => config.Global.Policies.RunActions(graph));
perfTimer.Record("Inserting Conneg and Authorization Nodes",
() => insertConnegAndAuthorizationNodes(graph));
perfTimer.Record("Applying Global Reorderings", () => config.ApplyGlobalReorderings(graph));
if (registry.Mode.InDevelopment() || graph.Settings.Get<DiagnosticsSettings>().TraceLevel != TraceLevel.None)
{
perfTimer.Record("Applying Tracing", () => ApplyTracing.Configure(graph));
}
accessorRules.Wait();
new AutoImportModelNamespacesConvention().Configure(graph);
return graph;
}
public void can_register_new_type_resolution_strategies()
{
var registry = new FubuRegistry();
registry.ResolveTypes(x => x.AddStrategy <ProxyDetector>());
var graph = registry.BuildGraph();
var resolver = graph.Services.DefaultServiceFor <ITypeResolver>().Value.ShouldBeOfType <TypeResolver>();
resolver.ResolveType(new Proxy <UniqueInput>()).ShouldEqual(typeof(UniqueInput));
}
public void SetUp()
{
var registry = new FubuRegistry();
registry.Actions.IncludeType <FakeEndpoint>();
server = FubuApplication.For(registry).StructureMap(new Container())
.Packages(x => {
x.Assembly(Assembly.GetExecutingAssembly());
})
.RunEmbedded(".".ToFullPath());
}
public void SetUp()
{
var registry = new FubuRegistry();
container = SetupContainerForFastPack();
new FubuFastPackRegistryExtension().Configure(registry);
AssetDeclarationVerificationActivator.Latched = true;
FubuApplication.For(() => registry).StructureMap(() => container).Bootstrap();
PackageRegistry.AssertNoFailures();
}
public void the_policies_from_settings_are_available()
{
var registry = new FubuRegistry();
new GridConfigurationExtension().Configure(registry);
var graph = BehaviorGraph.BuildFrom(registry);
var policies = graph.Settings.Get <ColumnPolicies>();
graph.Services.DefaultServiceFor <IColumnPolicies>().Value.ShouldBeTheSameAs(policies);
}
public void SetUp()
{
FubuTransport.AllQueuesInMemory = true;
container = new Container();
var registry = new FubuRegistry();
registry.Import <AllInMemoryRegistry>();
registry.Import <AnotherRegistry>();
runtime = FubuApplication.For(registry).StructureMap(container).Bootstrap();
}
void IFubuRegistryExtension.Configure(FubuRegistry registry)
{
registry.Policies.Add <RegisterAuthenticationStrategies>();
registry.Services <AuthenticationServiceRegistry>();
registry.Policies.Add(new ApplyAuthenticationPolicy());
registry.Policies.Add <FormsAuthenticationEndpointsRegistration>();
registry.Policies.Add <AttachDefaultLoginView>();
registry.Policies.Add <ApplyPassThroughAuthenticationPolicy>();
registry.Policies.Add <AddDefaultMembershipAuthentication>();
}
public void find_home_is_not_null()
{
var graph = new FubuRegistry(x =>
{
x.Applies.ToThisAssembly();
x.Actions.IncludeClassesSuffixedWithController();
x.Routes.HomeIs <MyHomeController>(c => c.ThisIsHome());
}).BuildGraph();
graph.FindHomeChain().FirstCall().Method.Name.ShouldEqual("ThisIsHome");
}
public void should_only_apply_behavior_once()
{
var hostRegistry = new FubuRegistry();
var packageRegistry = new FubuPackageRegistry();
packageRegistry.Actions.IncludeType <Controller1>();
hostRegistry.Import(packageRegistry, string.Empty);
theGraph = BehaviorGraph.BuildFrom(hostRegistry);
var chain = chainFor(x => x.BasicContinuation(null))
.Output.Writers.OfType <Writer>().ShouldHaveCount(1);
}
public void can_set_the_node_name_programmatically()
{
var registry = new FubuRegistry {
NodeName = "MyNode"
};
using (var fubuRuntime = registry.ToRuntime())
{
fubuRuntime.Get <ChannelGraph>().Name.ShouldBe("MyNode");
}
}
public void Configure(FubuRegistry registry)
{
registry.Policies.Add <NavigationRootPolicy>(x =>
{
x.ForKey(DiagnosticKeys.Main);
x.WrapWithChrome <DashboardChrome>();
x.Alter(chain => chain.BehaviorChain.Route.Prepend("_fubu"));
});
registry.Policies.Add <DiagnosticsMenu>();
}
public void Configure(FubuRegistry registry)
{
registry.Policies.Add <TransactionalBehaviorPolicy>();
var defaultDataDirectory = FubuMvcPackageFacility.GetApplicationPath().ParentDirectory().AppendPath("data");
var defaultSettings = new RavenDbSettings
{
DataDirectory = defaultDataDirectory
};
registry.Services(x => x.SetServiceIfNone(defaultSettings));
}
public void register_a_non_default_culture_info()
{
var registry = new FubuRegistry();
registry.Features.Localization.Enable(true);
registry.Features.Localization.Configure(x => { x.DefaultCulture = new CultureInfo("en-CA"); });
using (var runtime = registry.ToRuntime())
{
runtime.Get <CultureInfo>().Name.ShouldBe("en-CA");
}
}
public static void ApplySmartGridConventions(this FubuRegistry registry, Action <AppliesToExpression> configure)
{
var pool = new TypePool(null);
pool.IgnoreCallingAssembly();
var expression = new AppliesToExpression(pool);
configure(expression);
registry.ApplyConvention(new SmartGridConvention(pool));
}
public void limit_behaviors_by_policy_on_interface_methods()
{
BehaviorGraph graph = new FubuRegistry(x =>
{
x.Actions.ExcludeNonConcreteTypes().ForTypesOf <IRouter>(o => { o.Include(c => c.Go()); });
}).BuildGraph();
IEnumerable <string> calls = graph.Behaviors.Select(x => x.Calls.First().Method).Select(m =>
"{0} - {1}".ToFormat(m.DeclaringType.Name, m.Name));
calls.ShouldHaveTheSameElementsAs("Router1 - Go", "Router2 - Go", "Router3 - Go");
}
public void SetUp()
{
var registry = new FubuRegistry(x =>
{
x.Actions.IncludeType <Controller1>();
x.Actions.IncludeType <Controller2>();
x.Media.ApplyContentNegotiationToActions(call => call.OutputType() == typeof(ViewModel3));
});
theGraph = registry.BuildGraph();
}
public static BehaviorChain ChainFor(Expression <Func <FubuValidationSettingsEndpoint, object> > expression)
{
var registry = new FubuRegistry(x =>
{
x.Actions.IncludeType <FubuValidationSettingsEndpoint>();
x.Import <FubuMvcValidation>();
});
var graph = BehaviorGraph.BuildFrom(registry);
return(graph.BehaviorFor(expression));
}
public FubuApplication BuildApplication()
{
return(FubuApplication.For(() =>
{
var registry = new FubuRegistry();
registry.Actions.IncludeType <GraphQuery>();
_configuration(registry);
return registry;
}).StructureMap(_container));
}
private static BehaviorGraph buildGraph(Action <FubuRegistry> configuration)
{
var registry = new FubuRegistry();
registry.Actions.IncludeType <OneController>();
registry.Actions.IncludeType <TwoController>();
registry.Actions.IncludeType <ThreeController>();
configuration(registry);
return(BehaviorGraph.BuildFrom(registry));
}
public void SetUp()
{
var registry = new FubuRegistry();
registry.Actions.IncludeType <WrapWithAttributeController>();
graph = registry.BuildGraph();
graph.Behaviors.Count().ShouldBeGreaterThan(0);
graph.Behaviors.SelectMany(x => x.Calls).Each(x => Debug.WriteLine(x.Description));
}
private BehaviorChain chainFor(Expression <Func <CompositeChainFilterEndpoint, object> > expression)
{
var registry = new FubuRegistry(x =>
{
x.Actions.IncludeType <CompositeChainFilterEndpoint>();
x.Import <FubuMvcValidation>();
});
var graph = BehaviorGraph.BuildFrom(registry);
return(graph.BehaviorFor(expression));
}
public void SetUp()
{
theRegistry = new FubuRegistry(x => x.ApplySmartGridConventions(o =>
{
o.ToAssemblyContainingType <SmartGridConventionTester>();
}));
// Want no types here
theRegistry.Actions.IncludeTypes(t => false);
theGraph = theRegistry.BuildGraph();
}
public void SetUp()
{
var registry = new FubuRegistry(x =>
{
x.Actions.IncludeType <AsyncAction>();
x.Policies.Add <EarlyReturnConvention>();
});
_server = FubuApplication.For(registry)
.StructureMap(new Container())
.RunEmbedded(port: PortFinder.FindPort(5500));
}
public void SetUp()
{
var registry = new FubuRegistry();
registry.Import <DiagnosticsRegistration>();
graph = BehaviorGraph.BuildFrom(registry);
urls = MockRepository.GenerateMock <IUrlRegistry>();
graph.Behaviors.Any().ShouldBeTrue();
graph.Actions().Each(x => Debug.WriteLine(x.Description));
}
public void SetUp()
{
var registry = new FubuRegistry(x =>
{
x.Actions.IncludeType <SitesController>();
x.Actions.IncludeType <CasesController>();
x.ApplyConvention <EnsureEntityExistsConvention>();
});
theGraph = registry.BuildGraph();
}
void IFubuRegistryExtension.Configure(FubuRegistry registry)
{
registry.Services(services =>
{
// This isn't something that changes very often at all
var encodings = new IHttpContentEncoding[] { new GZipHttpContentEncoding(), new DeflateHttpContentEncoding() };
var encoders = new HttpContentEncoders(encodings);
services.SetServiceIfNone<IHttpContentEncoders>(encoders);
});
registry.ApplyConvention(new ContentCompressionConvention(_filters.Matches));
}
public void the_routes_from_FubuPackageRegistry_have_the_prefix()
{
var registry = new FubuRegistry();
new SomePackageRegistry().As <IFubuRegistryExtension>().Configure(registry);
var graph = BehaviorGraph.BuildFrom(registry);
graph.ChainFor <SomeRandomClass>(x => x.get_some_data())
.As <RoutedChain>()
.GetRoutePattern().ShouldStartWith("mypak");
}
public void pick_up_behaviors_from_this_assembly()
{
BehaviorGraph graph = new FubuRegistry(x =>
{
x.Actions.IncludeTypesNamed(name => name.EndsWith("Controller"));
}).BuildGraph();
graph.Behaviors.Count().ShouldBeGreaterThan(0);
graph.Behaviors.Each(x => x.Calls.First().HandlerType.Name.EndsWith("Controller"));
graph.Routes.Each(x => Debug.WriteLine(x.Pattern));
}
public void the_url_prefix_of_a_fubu_package_registry_should_be_respected()
{
var registry = new FubuRegistry();
registry.Import <FooPackageRegistry>();
var graph = BehaviorGraph.BuildFrom(registry);
graph.ChainFor <FooEndpointClass>(x => x.get_some_foo())
.As <RoutedChain>()
.GetRoutePattern().ShouldBe("moar/some/foo");
}
public void Modify(FubuRegistry registry)
{
registry.Services(x =>
{
x.ReplaceService<IOutputWriter, DebuggingOutputWriter>();
x.ReplaceService<IObjectResolver, RecordingObjectResolver>();
x.ReplaceService<IDebugReport, DebugReport>();
x.ReplaceService<IRequestData, RecordingRequestData>();
x.ReplaceService<IFubuRequest, RecordingFubuRequest>();
x.ReplaceService<IDebugDetector, DebugDetector>();
});
}
// TOOD -- clean this up a little bit
public static BehaviorGraph Build(FubuRegistry registry)
{
var graph = new BehaviorGraph {
ApplicationAssembly = registry.ApplicationAssembly
};
var config = registry.Config;
PackageRegistry.Timer.Record("Applying Settings", () => applySettings(config, graph));
var viewDiscovery = graph.Settings.Get <ViewEngineSettings>().BuildViewBag(graph);
var layoutAttachmentTasks =
viewDiscovery.ContinueWith(
t => graph.Settings.Get <ViewEngineSettings>().Facilities.Select(x => x.LayoutAttachment).ToArray());
graph.Settings.Replace(viewDiscovery);
AccessorRulesCompiler.Compile(graph);
var htmlConventionCollation = HtmlConventionCollator.BuildHtmlConventions(graph);
addBuiltInDiagnostics(graph);
PackageRegistry.Timer.Record("Local Application BehaviorGraph", () => config.BuildLocal(graph));
viewDiscovery.RecordContinuation("View Attachment", t =>
{
var attacher = new ViewAttachmentWorker(t.Result, graph.Settings.Get <ViewAttachmentPolicy>());
attacher.Configure(graph);
}).Wait();
PackageRegistry.Timer.Record("Explicit Configuration", () => config.Global.Explicits.RunActions(graph));
PackageRegistry.Timer.Record("Global Policies", () => config.Global.Policies.RunActions(graph));
PackageRegistry.Timer.Record("Inserting Conneg and Authorization Nodes",
() => insertConnegAndAuthorizationNodes(graph));
PackageRegistry.Timer.Record("Applying Global Reorderings", () => config.ApplyGlobalReorderings(graph));
PackageRegistry.Timer.Record("Applying Tracing", () => applyTracing(graph));
// Wait until all the other threads are done.
var registration = htmlConventionCollation.ContinueWith(t => config.RegisterServices(graph));
Task.WaitAll(registration, layoutAttachmentTasks);
Task.WaitAll(layoutAttachmentTasks.Result);
new AutoImportModelNamespacesConvention().Configure(graph);
return(graph);
}
private void registeredTypeIs <TService, TImplementation>()
{
var registry = new FubuRegistry();
registry.Import <NavigationRegistryExtension>();
using (var runtime = registry.ToRuntime())
{
var container = runtime.Get <IContainer>();
container.Model.For <TService>().Default.ReturnedType.ShouldBe(typeof(TImplementation));
}
}
public void Configure(FubuRegistry registry)
{
registry.Services(x =>
{
x.ReplaceService<IOutputWriter, DebuggingOutputWriter>();
x.ReplaceService<IObjectResolver, RecordingObjectResolver>();
x.ReplaceService<IDebugReport, DebugReport>();
x.ReplaceService<IRequestData, RecordingRequestData>();
x.ReplaceService<IFubuRequest, RecordingFubuRequest>();
x.ReplaceService<IDebugDetector, DebugDetector>();
x.ReplaceService<IAuthorizationPolicyExecutor, RecordingAuthorizationPolicyExecutor>();
});
}
public void Apply(FubuRegistry registry)
{
registry.Services.IncludeRegistry <FubuValidationServiceRegistry>();
if (!Enabled)
{
return;
}
registry.Services.IncludeRegistry <FubuMvcValidationServices>();
registry.Actions.FindWith <RemoteRulesSource>();
registry.Actions.FindWith <ValidationSummarySource>();
}
// Tested through the FubuRegistry.BuildLocal()
public bool HasImported(FubuRegistry registry)
{
if (_imports.Any(x => x.Registry.GetType() == registry.GetType()))
{
return true;
}
if (_imports.Any(x => x.Registry.Config.HasImported(registry)))
{
return true;
}
return false;
}
public void Configure(FubuRegistry registry)
{
registry.Services(addServices);
registry.Services(addActivators);
registry.Services(setupAssetCaching);
registry.Configure(graph =>
{
var chain = createAssetContentChain(graph);
chain.Filters.Add(new AssetEtagInvocationFilter(_assetCache));
addCaching(chain);
addWritingAction(chain);
});
}
public void Configure(FubuRegistry registry)
{
registry.Configure(graph => {
graph.Settings.Get<ViewEngines>().UseGraph(graph);
});
registry.AlterSettings<CommonViewNamespaces>(x =>
{
x.Add(typeof(VirtualPathUtility).Namespace); // System.Web
x.AddForType<string>(); // System
x.AddForType<FileSet>(); // FubuCore
x.AddForType<ParallelQuery>(); // System.Linq
x.AddForType<HtmlTag>(); // HtmlTags
});
}
// TOOD -- clean this up a little bit
public static BehaviorGraph Build(FubuRegistry registry)
{
var graph = new BehaviorGraph {ApplicationAssembly = registry.ApplicationAssembly};
var config = registry.Config;
PackageRegistry.Timer.Record("Applying Settings", () => applySettings(config, graph));
var assetDiscovery = AssetSettings.Build(graph);
var viewDiscovery = graph.Settings.Get<ViewEngineSettings>().BuildViewBag(graph);
var layoutAttachmentTasks =
viewDiscovery.ContinueWith(
t => graph.Settings.Get<ViewEngineSettings>().Facilities.Select(x => x.LayoutAttachment).ToArray());
graph.Settings.Replace(viewDiscovery);
AccessorRulesCompiler.Compile(graph);
var htmlConventionCollation = HtmlConventionCollator.BuildHtmlConventions(graph);
addBuiltInDiagnostics(graph);
PackageRegistry.Timer.Record("Local Application BehaviorGraph", () => config.BuildLocal(graph));
viewDiscovery.RecordContinuation("View Attachment",t =>
{
var attacher = new ViewAttachmentWorker(t.Result, graph.Settings.Get<ViewAttachmentPolicy>());
attacher.Configure(graph);
}).Wait(10.Seconds());
PackageRegistry.Timer.Record("Explicit Configuration", () => config.Global.Explicits.RunActions(graph));
PackageRegistry.Timer.Record("Global Policies", () => config.Global.Policies.RunActions(graph));
PackageRegistry.Timer.Record("Inserting Conneg and Authorization Nodes",
() => insertConnegAndAuthorizationNodes(graph));
PackageRegistry.Timer.Record("Applying Global Reorderings", () => config.ApplyGlobalReorderings(graph));
PackageRegistry.Timer.Record("Applying Tracing", () => applyTracing(graph));
// Wait until all the other threads are done.
var registration = htmlConventionCollation.ContinueWith(t => config.RegisterServices(graph));
Task.WaitAll(registration, layoutAttachmentTasks, assetDiscovery);
Task.WaitAll(layoutAttachmentTasks.Result);
new AutoImportModelNamespacesConvention().Configure(graph);
return graph;
}
public void do_not_use_the_excluded_views()
{
var registry = new FubuRegistry();
registry.AlterSettings<ViewEngines>(x => {
x.AddFacility(new FakeViewEngine1());
x.AddFacility(new FakeViewEngine2());
x.ExcludeViews(v => v.Name().StartsWith("A"));
x.ExcludeViews(v => v.Name().StartsWith("C"));
});
var views = BehaviorGraph.BuildFrom(registry).Settings.Get<ViewEngines>().Views;
views.Views.OrderBy(x => x.Name()).Select(x => x.Name())
.ShouldHaveTheSameElementsAs("B1", "B2", "B3", "B4", "B5", "B6");
}
public static BehaviorGraph Import(FubuRegistry registry, SettingsCollection parentSettings)
{
var graph = new BehaviorGraph(parentSettings);
startBehaviorGraph(registry, graph);
var config = registry.Config;
config.RunActions(ConfigurationType.Settings, graph);
config.Sources.Union(config.Imports).SelectMany(x => x.BuildChains(graph.Settings)).Each(chain => graph.AddChain(chain));
config.RunActions(ConfigurationType.Explicit, graph);
config.RunActions(ConfigurationType.Policy, graph);
config.RunActions(ConfigurationType.Reordering, graph);
config.RunActions(ConfigurationType.InjectNodes, graph);
return graph;
}
public static BehaviorGraph Build(FubuRegistry registry)
{
var graph = new BehaviorGraph();
startBehaviorGraph(registry, graph);
var config = registry.Config;
var log = new ConfigLog();
graph.Services.AddService(log);
log.Import(config);
config.Add(new SystemServicesPack());
config.Add(new DefaultConfigurationPack());
// Apply settings
config.RunActions(ConfigurationType.Settings, graph);
config.Add(new RegisterAllSettings(graph));
config.AllServiceRegistrations().Each(x => {
x.Apply(graph.Services);
});
config.RunActions(ConfigurationType.Discovery, graph);
config.UniqueImports().Each(import => import.ImportInto(graph, log));
config.RunActions(ConfigurationType.Explicit, graph);
config.RunActions(ConfigurationType.Policy, graph);
config.RunActions(ConfigurationType.Attributes, graph);
config.RunActions(ConfigurationType.ModifyRoutes, graph);
config.RunActions(ConfigurationType.InjectNodes, graph);
config.RunActions(ConfigurationType.Conneg, graph);
config.RunActions(ConfigurationType.Attachment, graph);
config.RunActions(ConfigurationType.Navigation, graph);
config.RunActions(ConfigurationType.ByNavigation, graph);
config.RunActions(ConfigurationType.Reordering, graph);
config.RunActions(ConfigurationType.Instrumentation, graph);
graph.Services.AddService(config);
return graph;
}
// Need to track the ConfigLog
public static BehaviorGraph Import(FubuRegistry registry, BehaviorGraph parent, ConfigLog log)
{
var graph = BehaviorGraph.ForChild(parent);
startBehaviorGraph(registry, graph);
var config = registry.Config;
config.RunActions(ConfigurationType.Settings, graph);
config.RunActions(ConfigurationType.Discovery, graph);
config.Imports.Each(import => import.ImportInto(graph, log));
config.RunActions(ConfigurationType.Explicit, graph);
config.RunActions(ConfigurationType.Policy, graph);
config.RunActions(ConfigurationType.Reordering, graph);
config.RunActions(ConfigurationType.Attributes, graph);
config.RunActions(ConfigurationType.ModifyRoutes, graph);
config.RunActions(ConfigurationType.InjectNodes, graph);
config.RunActions(ConfigurationType.Conneg, graph);
return graph;
}
public static void Activate(this IContainerFacility facility, ICollection<RouteBase> routes, FubuRegistry registry)
{
// "Bake" the fubu configuration model into your
// IoC container for the application
var graph = registry.BuildGraph();
graph.EachService(facility.Register);
var factory = facility.BuildFactory();
// Register all the Route objects into the routes
// collection
// TODO -- need a way to do this with debugging
graph.VisitRoutes(x =>
{
x.Actions += (routeDef, chain) =>
{
var route = routeDef.ToRoute();
route.RouteHandler = new FubuRouteHandler(factory, chain.UniqueId);
routes.Add(route);
};
});
}
public static BehaviorGraph Build(FubuRegistry registry)
{
var graph = new BehaviorGraph();
startBehaviorGraph(registry, graph);
lookForAccessorOverrides(graph);
var config = registry.Config;
config.Add(new SystemServicesPack());
config.Add(new DefaultConfigurationPack());
// Apply settings
config.RunActions(ConfigurationType.Settings, graph);
var viewDiscovery = graph.Settings.Get<ViewEngines>().BuildViewBag(graph.Settings);
discoverChains(config, graph);
var attacher = new ViewAttachmentWorker(viewDiscovery.Result, graph.Settings.Get<ViewAttachmentPolicy>());
attacher.Configure(graph);
config.RunActions(ConfigurationType.Explicit, graph);
config.RunActions(ConfigurationType.Policy, graph);
config.RunActions(ConfigurationType.InjectNodes, graph);
config.RunActions(ConfigurationType.Attachment, graph);
// apply the authorization, input, and output nodes
graph.Behaviors.Each(x => x.InsertNodes(graph.Settings.Get<ConnegSettings>()));
config.RunActions(ConfigurationType.Reordering, graph);
config.RunActions(ConfigurationType.Instrumentation, graph);
registerServices(config, graph);
return graph;
}
public HealthMonitoringExpression(FubuRegistry parent)
{
_parent = parent;
}
protected override void configure(FubuRegistry registry)
{
registry.Actions.IncludeType<ConventionEndpoint>();
}
