public void Apply(HandlerGraph graph, JasperGenerationRules rules)
{
foreach (var chain in graph.Chains.Where(IsSagaRelated))
{
Apply(chain, rules.SagaPersistence);
}
}
public void Apply(HandlerGraph graph, JasperGenerationRules rules)
{
foreach (var chain in graph.Chains)
{
applyToChain(chain);
}
}
internal async Task <RouteTree> BuildRouting(IContainer container, JasperGenerationRules generation)
{
if (!Enabled)
{
return(null);
}
var actions = await FindActions(ApplicationAssembly);
foreach (var methodCall in actions)
{
var chain = Routes.AddRoute(methodCall);
Urls.Register(chain.Route);
}
foreach (var policy in _policies)
{
policy.Apply(Routes, generation);
}
Routes.AssertNoDuplicateRoutes();
Routes.Seal();
var tree = new RouteTree(this, generation);
tree.CompileAll(container);
return(tree);
}
public void Apply(HandlerGraph graph, JasperGenerationRules rules)
{
foreach (var chain in graph.Chains)
{
chain.Middleware.Add(new SimpleWrapper());
}
}
public List <Frame> DetermineFrames(JasperGenerationRules rules)
{
if (!Handlers.Any())
{
throw new InvalidOperationException("No method handlers configured for message type " +
MessageType.FullName);
}
if (!hasConfiguredFrames)
{
hasConfiguredFrames = true;
applyAttributesAndConfigureMethods(rules);
foreach (var attribute in MessageType.GetTypeInfo()
.GetCustomAttributes(typeof(ModifyHandlerChainAttribute))
.OfType <ModifyHandlerChainAttribute>())
{
attribute.Modify(this, rules);
}
foreach (var attribute in MessageType.GetTypeInfo().GetCustomAttributes(typeof(ModifyChainAttribute))
.OfType <ModifyChainAttribute>())
{
attribute.Modify(this, rules);
}
}
var cascadingHandlers = determineCascadingMessages().ToArray();
return(Middleware.Concat(Handlers).Concat(Postprocessors).Concat(cascadingHandlers).ToList());
}
public JasperOptionsBuilder(string assemblyName = null)
{
HttpRoutes = new HttpSettings();
Services = _applicationServices;
establishApplicationAssembly(assemblyName);
var name = ApplicationAssembly?.GetName().Name ?? "JasperApplication";
CodeGeneration = new JasperGenerationRules($"{name.Replace(".", "_")}_Generated");
CodeGeneration.Sources.Add(new NowTimeVariableSource());
CodeGeneration.Assemblies.Add(GetType().GetTypeInfo().Assembly);
CodeGeneration.Assemblies.Add(ApplicationAssembly);
_baseServices = new JasperServiceRegistry(this);
Settings = new JasperSettings(this);
Settings.BindToConfigSection <JasperOptions>("Jasper");
Publish = new PublishingExpression(Settings, Messaging);
Settings.Replace(HttpRoutes);
}
public List <Frame> DetermineFrames(ConnegRules rules, JasperGenerationRules codeRules)
{
if (_hasDeterminedFrames)
{
throw new InvalidOperationException("Has already determined frames");
}
_hasDeterminedFrames = true;
if (!_hasAppliedConfigureAndAttributes)
{
rules.Apply(this);
_hasAppliedConfigureAndAttributes = true;
applyAttributesAndConfigureMethods(codeRules);
}
var list = Middleware.ToList();
list.AddRange(Route.Segments.OfType <IRoutingFrameSource>().Select(x => x.ToParsingFrame(Action)));
list.Add(Action);
list.AddRange(Postprocessors);
return(list);
}
public JasperRegistry()
{
Configuration.SetBasePath(Directory.GetCurrentDirectory());
HttpRoutes = new HttpSettings();
Services = _applicationServices;
establishApplicationAssembly();
var name = ApplicationAssembly?.GetName().Name ?? "JasperApplication";
CodeGeneration = new JasperGenerationRules($"{name.Replace(".", "_")}_Generated");
_baseServices = new JasperServiceRegistry(this);
Settings = new JasperSettings(this);
Settings.BindToConfigSection <MessagingSettings>("Messaging");
deriveServiceName();
Publish = new PublishingExpression(Settings, Messaging);
Hosting = this;
// ASP.Net Core will freak out if this isn't there
EnvironmentConfiguration[WebHostDefaults.ApplicationKey] = ApplicationAssembly.FullName;
Settings.Replace(HttpRoutes);
}
public void applies_the_Configure_IChain_method()
{
var chain = RouteChain.For <ConfiguredEndpoint>(x => x.get_configured());
var frames = chain.DetermineFrames(ConnegRules.Empty(), JasperGenerationRules.Empty());
frames.OfType <FakeWrapper>().Any().ShouldBeTrue();
}
public void apply_generic_middleware()
{
var chain = HandlerChain.For <Target>(x => x.Go(null));
var frames = chain.DetermineFrames(JasperGenerationRules.Empty());
chain.Middleware.Any(x => x is FakeMiddleware1).ShouldBeTrue();
chain.Middleware.Any(x => x is FakeMiddleware2).ShouldBeTrue();
}
public void applies_attributes_against_the_IChain()
{
var chain = RouteChain.For <ConfiguredEndpoint>(x => x.get_wrapper3());
var frames = chain.DetermineFrames(ConnegRules.Empty(), JasperGenerationRules.Empty());
frames.OfType <FakeWrapper3>().Any().ShouldBeTrue();
}
// Call this from the activator
internal Task BuildRouting(IContainer container, JasperGenerationRules generation)
{
if (!Enabled)
{
return(Task.CompletedTask);
}
return(_findActions.ContinueWith(t => { Routes.BuildRoutingTree(generation, container); }));
}
internal void Compile(JasperGenerationRules generation, JasperRuntime runtime, PerfTimer timer)
{
_generation = generation;
_container = runtime.Container;
var forwarders = runtime.Get <Forwarders>();
AddForwarders(forwarders);
}
internal void Compile(JasperGenerationRules generation, IContainer container)
{
_generation = generation;
_container = container;
var forwarders = container.GetInstance <Forwarders>();
AddForwarders(forwarders);
}
public void Apply(HandlerGraph graph, JasperGenerationRules rules)
{
// Important! Create a brand new TransactionalFrame
// for each chain
graph
.Chains
.Where(x => x.MessageType.Name.EndsWith("Command"))
.Each(x => x.Middleware.Add(new TransactionalFrame()));
}
public void Apply(RouteGraph graph, JasperGenerationRules rules)
{
// Put this middleware on any route that
// has the HTTP method POST, PUT, or DELETE
foreach (var chain in graph.Commands)
{
chain.Middleware.Add(new StopwatchFrame(chain));
}
}
public void Apply(HandlerGraph graph, JasperGenerationRules rules)
{
// We're adding the StopwatchFrame to all message types,
// but we *could* filter the application
foreach (var chain in graph.Chains)
{
chain.Middleware.Add(new StopwatchFrame(chain));
}
}
public void Apply(RouteGraph graph, JasperGenerationRules rules)
{
graph
.Where(x => x.Action.HandlerType.CanBeCastTo <ControllerBase>())
.Each(x =>
{
x.Middleware.Add(new BuildOutControllerContextFrame());
x.Middleware.Add(new SetControllerContextFrame(x.Action.HandlerType));
});
}
public void BuildRoutingTree(ConnegRules rules, JasperGenerationRules generation, JasperRuntime runtime)
{
Router.HandlerBuilder = new RouteHandlerBuilder(runtime.Container, rules, generation);
assertNoDuplicateRoutes();
foreach (var route in _chains.Select(x => x.Route))
{
Router.Add(route);
}
}
public RouteTree(HttpSettings settings, JasperGenerationRules rules)
{
foreach (var chain in settings.Routes)
{
chain.Route.Place(this);
}
_settings = settings;
_rules = rules;
_assembly = new GeneratedAssembly(rules);
}
public RouteTree(JasperHttpOptions options, JasperGenerationRules rules)
{
foreach (var chain in options.Routes)
{
chain.Route.Place(this);
}
_options = options;
_rules = rules;
_assembly = new GeneratedAssembly(rules);
}
public void AssembleType(GeneratedAssembly generatedAssembly, JasperGenerationRules rules)
{
_generatedType = generatedAssembly.AddType(TypeName, typeof(MessageHandler));
var handleMethod = _generatedType.MethodFor(nameof(MessageHandler.Handle));
handleMethod.Sources.Add(new MessageHandlerVariableSource(MessageType));
handleMethod.Frames.AddRange(DetermineFrames(rules));
handleMethod.DerivedVariables.Add(new Variable(typeof(Envelope), $"context.{nameof(IMessageContext.Envelope)}"));
handleMethod.DerivedVariables.Add(new Variable(typeof(IAdvancedMessagingActions), $"context.{nameof(IMessageContext.Advanced)}"));
}
public void Apply(HandlerGraph graph, JasperGenerationRules rules)
{
var matchingChains = graph.Chains.Where(x => x.MessageType.IsInNamespace("MyApp.Messages"));
foreach (var chain in matchingChains)
{
chain.MaximumAttempts = 2;
chain.OnException <SqlException>()
.Requeue();
}
}
public void AssemblyType(GeneratedAssembly generatedAssembly, ConnegRules rules,
JasperGenerationRules codeRules)
{
_generatedType = generatedAssembly.AddType(TypeName, typeof(RouteHandler));
var handleMethod = _generatedType.MethodFor(nameof(RouteHandler.Handle));
handleMethod.Frames.AddRange(DetermineFrames(rules, codeRules));
handleMethod.Sources.Add(new ContextVariableSource());
handleMethod.DerivedVariables.AddRange(HttpContextVariables);
}
public void BuildRoutingTree(JasperGenerationRules generation, IContainer container)
{
var rules = container.QuickBuild <ConnegRules>();
Router.HandlerBuilder = new RouteHandlerBuilder(container, rules, generation);
assertNoDuplicateRoutes();
foreach (var route in _chains.Select(x => x.Route))
{
Router.Add(route);
}
}
internal void ApplyPolicies(HandlerGraph graph, JasperGenerationRules rules)
{
foreach (var policy in _globals)
{
policy.Apply(graph, rules);
}
graph.ErrorHandlers.AddRange(this.As <IHasErrorHandlers>().ErrorHandlers);
foreach (var chain in graph.Chains)
{
chain.MaximumAttempts = DefaultMaximumAttempts;
}
}
// Call this from the activator
internal Task <RouteTree> BuildRouting(IContainer container, JasperGenerationRules generation)
{
if (!Enabled)
{
return(null);
}
return(_findActions.ContinueWith(t =>
{
if (t.IsFaulted)
{
container.GetInstance <IEnvironmentRecorder>().Failure("Failure while trying to discover HTTP route handlers", t.Exception);
throw t.Exception;
}
try
{
foreach (var policy in _policies)
{
policy.Apply(Routes, generation);
}
Routes.AssertNoDuplicateRoutes();
var tree = new RouteTree(this, generation);
tree.CompileAll(container);
return tree;
}
catch (Exception e)
{
container.GetInstance <IEnvironmentRecorder>().Failure("Failure while trying to compile the routing tree", e);
throw;
}
}));
}
public abstract void Modify(RouteChain chain, JasperGenerationRules rules);
public override void Modify(HandlerChain chain, JasperGenerationRules rules)
{
chain.Middleware.Add(new FakeFrame());
}
public override void Modify(IChain chain, JasperGenerationRules rules)
{
chain.Middleware.Add(new FakeTransaction());
}
