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>(); }