void TryInitializeHosting(CancellationToken onDisposing, StartupProperties startup)
{
if (_hostManager != null)
{
return;
}
lock (SyncRoot)
{
Thread.MemoryBarrier();
if (_hostManager != null)
{
return;
}
var hostManager = HostManager.RegisterHost(_host);
onDisposing.Register(Dispose);
Thread.MemoryBarrier();
_hostManager = hostManager;
try
{
_host.RaiseStart(startup);
}
catch
{
HostManager.UnregisterHost(_host);
_hostManager = null;
throw;
}
}
}
public void logging_is_not_injected()
{
IDependencyResolver resolver = new InternalDependencyResolver();
resolver.AddDependency <IGenerateCallGraphs, TopologicalSortCallGraphGenerator>();
resolver.AddDependency <IPipelineContributor, BootstrapperContributor>();
resolver.AddDependency <IPipelineContributor, First>();
var initialiser = new ThreePhasePipelineInitializer(
resolver.Resolve <IEnumerable <IPipelineContributor> >(),
resolver.Resolve <IGenerateCallGraphs>());
var props = new StartupProperties
{
OpenRasta =
{
Diagnostics = { TracePipelineExecution = false },
Pipeline = { Validate = false }
}
};
var pipeline = initialiser
.Initialize(props);
pipeline.MiddlewareFactories
.ShouldNotContain(factory => factory is LoggingMiddlewareFactory);
}
protected static IPipelineAsync CreatePipeline(
Type callGraphGeneratorType,
Type[] contributorTypes,
Action <StartupProperties> options = null)
{
var resolver = new InternalDependencyResolver();
resolver.AddDependencyInstance <IDependencyResolver>(resolver);
resolver.AddDependency <IPipelineInitializer, ThreePhasePipelineInitializer>();
resolver.AddDependency(typeof(IGenerateCallGraphs), callGraphGeneratorType, DependencyLifetime.Transient);
if (callGraphGeneratorType != null)
{
resolver.AddDependency(typeof(IGenerateCallGraphs), callGraphGeneratorType,
DependencyLifetime.Singleton);
}
foreach (var type in contributorTypes)
{
resolver.AddDependency(typeof(IPipelineContributor), type, DependencyLifetime.Singleton);
}
var runner = resolver.Resolve <IPipelineInitializer>();
var opt = new StartupProperties {
OpenRasta = { Pipeline = { Validate = true } }
};
options?.Invoke(opt);
return(runner.Initialize(opt));
}
public OpenRastaMiddleware(IConfigurationSource options,
IDependencyResolverAccessor resolverAccessor = null,
CancellationToken onDisposing = default, StartupProperties startupProperties = null)
{
Options = startupProperties ?? DefaultStartupProperties;
_host = new OwinHost(options, resolverAccessor);
TryInitializeHosting(onDisposing, Options);
}
public void keys_are_correct()
{
var props = new StartupProperties {
OpenRasta = { Pipeline = { Validate = false } }
};
props.Properties["openrasta.pipeline.validate"].ShouldBe(false);
}
void VerifyConfiguration(StartupProperties startupProperties)
{
if (!IsConfigured)
{
lock (_syncRoot)
if (!IsConfigured)
{
Configure(startupProperties);
}
}
}
public InMemoryHost(
IConfigurationSource configuration,
IDependencyResolver dependencyResolver = null,
StartupProperties startup = null)
{
Resolver = dependencyResolver ?? (configuration as IDependencyResolverAccessor)?.Resolver ?? new InternalDependencyResolver();
_configuration = configuration ?? new DelegateConfigurationSource(null);
ApplicationVirtualPath = "/";
HostManager = HostManager.RegisterHost(this);
RaiseStart(startup ?? new StartupProperties());
}
public static IEnumerable <(IPipelineMiddlewareFactory, ContributorCall)> ToDetailedMiddleware(
this IEnumerable <ContributorCall> callGraph,
StartupProperties startupProperties = null)
{
Func <ContributorCall, StartupProperties, IPipelineMiddlewareFactory> converter = CreatePreExecuteMiddleware;
foreach (var contributorCall in callGraph)
{
// change the type of middleware to create at key known stages
switch (contributorCall.Target)
{
case KnownStages.IUriMatching _:
converter = CreateRequestMiddleware;
break;
case KnownStages.IOperationResultInvocation _:
{
converter = CreateResponseMiddleware;
if (startupProperties?.OpenRasta.Errors.HandleAllExceptions == true)
{
yield return(new ResponseRetryMiddleware(), null);
}
break;
}
case KnownStages.IEnd _:
converter = CreatePostExecuteMiddleware;
break;
}
var middleware = converter(contributorCall, startupProperties);
yield return(middleware, contributorCall);
if (startupProperties?.OpenRasta.Pipeline.ContributorTrailers == null)
{
continue;
}
foreach (var followups in startupProperties.OpenRasta.Pipeline.ContributorTrailers
.Where(pair => pair.Key(contributorCall))
.Select(pair => pair.Value))
{
yield return(followups(), null);
}
}
}
public IPipelineAsync Initialize(StartupProperties startup)
{
if (startup.OpenRasta.Pipeline.Validate)
{
_contributors.VerifyKnownStagesRegistered();
}
var defaults = new List <IPipelineMiddlewareFactory>()
{
new CompatibilityMarkPipelineAsFinished()
};
if (startup.OpenRasta.Errors.HandleCatastrophicExceptions)
{
defaults.Add(new CatastrophicFailureMiddleware());
}
Func <
IGenerateCallGraphs,
IEnumerable <IPipelineMiddlewareFactory>,
IEnumerable <IPipelineContributor>,
StartupProperties,
IEnumerable <(IPipelineMiddlewareFactory middleware, ContributorCall contributor)>
> builder;
if (startup.OpenRasta.Diagnostics.TracePipelineExecution)
{
builder = LogBuild;
}
else
{
builder = Build;
}
var pipeline = builder(
_callGrapher,
defaults,
_contributors,
startup)
.ToList();
return(new PipelineAsync(
pipeline.Select(c => c.middleware).Compose(),
pipeline.Select(c => c.contributor?.Target).Where(c => c != null).ToList(),
pipeline.Select(c => c.contributor).ToList(),
pipeline.Select(c => c.middleware).ToList()));
}
void Configure(StartupProperties startupProperties)
{
IsConfigured = false;
_startupProperties = startupProperties;
AssignResolver();
Resolver.AddDependencyInstance <IHost>(Host, DependencyLifetime.Singleton);
CallWithDependencyResolver(() =>
{
RegisterRootDependencies();
VerifyContextStoreRegistered();
RegisterCoreDependencies();
RegisterLeafDependencies();
ExecuteConfigurationSource();
BuildPipeline();
IsConfigured = true;
});
}
void Configure(StartupProperties startupProperties)
{
IsConfigured = false;
_startupProperties = startupProperties;
Resolver.AddDependencyInstance(Host);
using (DependencyManager.ScopedResolver(Resolver))
{
RegisterRootDependencies();
VerifyContextStoreRegistered();
RegisterCoreDependencies();
RegisterLeafDependencies();
ExecuteConfigurationSource();
BuildPipeline();
IsConfigured = true;
}
}
public static IEnumerable <(IPipelineMiddlewareFactory, ContributorCall)> ToDetailedMiddleware(
this IEnumerable <ContributorCall> callGraph,
StartupProperties startupProperties = null)
{
Func <ContributorCall, IPipelineMiddlewareFactory> converter = CreatePreExecuteMiddleware;
foreach (var contributorCall in callGraph)
{
if (contributorCall.Target is KnownStages.IOperationResultInvocation)
{
converter = CreateResponseMiddleware;
if (startupProperties?.OpenRasta.Errors.HandleAllExceptions == true)
{
yield return(new ResponseRetryMiddleware(), null);
}
}
var middleware = converter(contributorCall);
yield return(middleware, contributorCall);
if (startupProperties?.OpenRasta.Pipeline.ContributorTrailers != null)
{
foreach (var followups in startupProperties.OpenRasta.Pipeline.ContributorTrailers
.Where(pair => pair.Key(contributorCall))
.Select(pair => pair.Value))
{
yield return(followups(), null);
}
}
if (contributorCall.Target is KnownStages.IUriMatching)
{
converter = CreateRequestMiddleware;
}
}
}
public static IApplicationBuilder UseOpenRasta(
this IApplicationBuilder app,
IConfigurationSource configurationSource,
IDependencyResolverAccessor dependencyResolver = null,
StartupProperties properties = null)
{
return(app
.Use(async(context, next) =>
{
var auth = context.Features.Get <IHttpAuthenticationFeature>();
if (auth == null)
{
auth = new HttpAuthenticationFeature();
context.Features.Set(auth);
}
await next();
})
.UseOwin(builder =>
builder.UseOpenRasta(
configurationSource,
dependencyResolver,
app.ApplicationServices.GetService <IApplicationLifetime>().ApplicationStopping, properties)));
}
public static IAppBuilder UseOpenRasta(this IAppBuilder builder, IConfigurationSource configurationSource,
IDependencyResolverAccessor dependencyResolver = null, StartupProperties properties = null)
{
var onAppDisposing =
builder.Properties.TryGetValue("host.OnAppDisposing", out var val) &&
val is CancellationToken owinDispose
? owinDispose
: CancellationToken.None;
return(builder.Use(OwinDelegates.CreateMiddleware(configurationSource, dependencyResolver, onAppDisposing, properties)));
}
public void Initialize(StartupProperties validate)
{
Initialize();
}
void HandleHostStartWithProps(object sender, StartupProperties e)
{
VerifyConfiguration(e);
}
IEnumerable <(IPipelineMiddlewareFactory middleware, ContributorCall contributor)> LogBuild(IGenerateCallGraphs callGraphGenerator, IEnumerable <IPipelineMiddlewareFactory> defaults, IEnumerable <IPipelineContributor> contributors, StartupProperties startupProperties)
{
var loggingFactory = new LoggingMiddlewareFactory();
using (Log.Operation(this, $"Initializing the pipeline. (using {callGraphGenerator.GetType()})"))
{
foreach (var result in Build(callGraphGenerator, defaults, contributors, startupProperties))
{
yield return(loggingFactory, null);
yield return(LogBuildEntry(result));
}
}
}
static IPipelineMiddlewareFactory CreatePostExecuteMiddleware(ContributorCall contrib, StartupProperties props)
{
return(new PostExecuteMiddleware(contrib));
}
static IPipelineMiddlewareFactory CreateResponseMiddleware(ContributorCall contrib, StartupProperties props)
{
return(new ResponseMiddleware(contrib));
}
public static Action <MidFunc> UseOpenRasta(this Action <MidFunc> builder,
IConfigurationSource configurationSource,
IDependencyResolverAccessor dependencyResolver = null,
CancellationToken onAppDisposing = default, StartupProperties startupProperties = null)
{
builder(new OpenRastaMiddleware(configurationSource, dependencyResolver, onAppDisposing, startupProperties).ToMidFunc());
return(builder);
}
public static MidFunc CreateMiddleware(IConfigurationSource configurationSource,
IDependencyResolverAccessor dependencyResolver = null,
CancellationToken onAppDisposing = default, StartupProperties startupProperties = null)
{
return(new OpenRastaMiddleware(configurationSource, dependencyResolver, onAppDisposing, startupProperties).ToMidFunc());
}
public InMemoryHost(Action configuration = null, IDependencyResolver dependencyResolver = null,
StartupProperties startup = null)
: this(new DelegateConfigurationSource(configuration), dependencyResolver, startup)
{
}
public static IEnumerable <IPipelineMiddlewareFactory> ToMiddleware(
this IEnumerable <ContributorCall> callGraph,
StartupProperties startupProperties = null)
{
return(ToDetailedMiddleware(callGraph, startupProperties).Select(m => m.Item1).ToList());
}
static IPipelineMiddlewareFactory CreateRequestMiddleware(ContributorCall contrib, StartupProperties props)
{
return(new RequestMiddleware(contrib, props?.OpenRasta.Errors.HandleAllExceptions ?? true));
}
static IEnumerable <(IPipelineMiddlewareFactory, ContributorCall)> Build(IGenerateCallGraphs callGraphGenerator, IEnumerable <IPipelineMiddlewareFactory> defaults, IEnumerable <IPipelineContributor> contributors, StartupProperties startupProperties)
{
foreach (var factory in defaults)
{
yield return(factory, null);
}
foreach (var contributor in callGraphGenerator
.GenerateCallGraph(contributors)
.ToDetailedMiddleware(startupProperties))
{
yield return(contributor);
}
}
