internal static ILifetimeScope GetScope() { var context = HttpContext.Current; if (initialized) { return(GetScope(context, createIfNotPresent: true)); } else if (allowDefaultScopeOutOfHttpContext && !IsRequestAvailable()) { // We're not running within a Http Request. If the option has been set to allow a normal scope to // be used in this situation, we'll use that instead ILifetimeScope scope = CallContextLifetimeScope.ObtainCurrentScope(); if (scope == null) { throw new InvalidOperationException("Not running within a Http Request, and no Scope was manually created. Either run from within a request, or call container.BeginScope()"); } return(scope); } else if (context == null) { throw new InvalidOperationException( "HttpContext.Current is null. PerWebRequestLifestyle can only be used in ASP.Net"); } else { EnsureInitialized(); return(GetScope(context, createIfNotPresent: true)); } }
public void Install(Castle.Windsor.IWindsorContainer container, Castle.MicroKernel.SubSystems.Configuration.IConfigurationStore store) { container.Register( Component.For <IServiceBus>() .UsingFactoryMethod(() => ServiceBusFactory.New(sbc => { sbc.UseMsmq(); sbc.VerifyMsmqConfiguration(); sbc.UseMulticastSubscriptionClient(); sbc.ReceiveFrom("msmq://localhost/web"); sbc.SetCreateMissingQueues(true); sbc.UseJsonSerializer(); sbc.Subscribe(subs => subs.LoadFrom(container)); sbc.BeforeConsumingMessage(() => container.BeginScope()); sbc.AfterConsumingMessage(() => CallContextLifetimeScope.ObtainCurrentScope().Dispose()); }) ) .LifestyleSingleton() ); }
static IPublishEndpoint GetCurrentPublishEndpoint(IKernel context) { var currentScope = CallContextLifetimeScope.ObtainCurrentScope(); return(currentScope != null ? context.Resolve <ConsumeContext>() : (IPublishEndpoint)context.Resolve <IBus>()); }
static ISendEndpointProvider GetCurrentSendEndpointProvider(IKernel context) { var currentScope = CallContextLifetimeScope.ObtainCurrentScope(); return(currentScope != null ? context.Resolve <ConsumeContext>() : (ISendEndpointProvider)context.Resolve <IBus>()); }
public ILifetimeScope GetScope(CreationContext context) { if (CallContextLifetimeScope.ObtainCurrentScope() is MessageLifetimeScope lifetimeScope) { return(lifetimeScope); } throw new InvalidOperationException("MessageScope was not available. Add UseMessageScope() to your receive endpoint to enable message scope"); }
private static IDisposable RequireScope() { var current = CallContextLifetimeScope.ObtainCurrentScope(); if (current == null) { return(BeginScope()); } return(null); // Return null, not the parent otherwise you'll cause premature disposal }
public static IDisposable CreateNewOrUseExistingMessageScope(this IKernel kernel) { var currentScope = CallContextLifetimeScope.ObtainCurrentScope(); if (currentScope is MessageLifetimeScope) { return(null); } return(kernel.BeginScope()); }
public void Dispose() { CallContextLifetimeScope contextLifetimeScope = CallContextLifetimeScope.ObtainCurrentScope(); if (contextLifetimeScope == null) { this._webRequestScopeAccessor.Dispose(); return; } contextLifetimeScope.Dispose(); }
public static IDisposable CreateNewOrUseExistingMessageScope(this IKernel kernel) { var currentScope = CallContextLifetimeScope.ObtainCurrentScope(); if (currentScope is MessageLifetimeScope scope) { kernel.Resolve <ScopedConsumeContextProvider>().SetContext(scope.ConsumeContext); return(null); } return(kernel.BeginScope()); }
protected virtual void Dispose(bool disposing) { if (!disposed) { disposed = true; var scope = CallContextLifetimeScope.ObtainCurrentScope(); if (scope != null) { scope.Dispose(); } } }
public void Starts_Windsor_scope_when_container_is_created() { var globalContainer = new ObjectContainer(); var scenarioContainer = new ObjectContainer(globalContainer); var beforeScope = CallContextLifetimeScope.ObtainCurrentScope(); CreateContainerViaPlugin(globalContainer, scenarioContainer); var afterScope = CallContextLifetimeScope.ObtainCurrentScope(); beforeScope.Should().BeNull(); afterScope.Should().NotBeNull(); }
public void RegisterRequestClient <T>(Uri destinationAddress, RequestTimeout timeout = default) where T : class { _container.Register(Component.For <IRequestClient <T> >().UsingFactoryMethod(kernel => { var clientFactory = kernel.Resolve <IClientFactory>(); var currentScope = CallContextLifetimeScope.ObtainCurrentScope(); return((currentScope != null) ? clientFactory.CreateRequestClient <T>(kernel.Resolve <ConsumeContext>(), destinationAddress, timeout) : clientFactory.CreateRequestClient <T>(destinationAddress, timeout)); })); }
async Task IFilter <ConsumeContext> .Send(ConsumeContext context, IPipe <ConsumeContext> next) { if (CallContextLifetimeScope.ObtainCurrentScope() is MessageLifetimeScope) { await next.Send(context).ConfigureAwait(false); } else { using (new MessageLifetimeScope(context)) { await next.Send(context).ConfigureAwait(false); } } }
public ILifetimeScope GetScope(CreationContext context) { CallContextLifetimeScope contextLifetimeScope = CallContextLifetimeScope.ObtainCurrentScope(); if (contextLifetimeScope != null) { return((ILifetimeScope)contextLifetimeScope); } if (HttpContext.Current != null && PerWebRequestLifestyleModuleUtils.IsInitialized) { return(this._webRequestScopeAccessor.GetScope(context)); } throw new InvalidOperationException("Naither Http nor CallContext scope was available. Did you forget to call container.BeginScope()?"); }
/// <summary> /// Get all NancyModule implementation instances /// </summary> /// <param name="context">The current context</param> /// <returns>An <see cref="IEnumerable{T}"/> instance containing <see cref="NancyModule"/> instances.</returns> public override IEnumerable <INancyModule> GetAllModules(NancyContext context) { var currentScope = CallContextLifetimeScope.ObtainCurrentScope(); if (currentScope != null) { return(this.ApplicationContainer.ResolveAll <INancyModule>()); } using (this.ApplicationContainer.BeginScope()) { return(this.ApplicationContainer.ResolveAll <INancyModule>()); } }
/// <summary> /// Retrieves a specific <see cref="INancyModule"/> implementation - should be per-request lifetime /// </summary> /// <param name="moduleType">Module type</param> /// <param name="context">The current context</param> /// <returns>The <see cref="INancyModule"/> instance</returns> public override INancyModule GetModule(Type moduleType, NancyContext context) { var currentScope = CallContextLifetimeScope.ObtainCurrentScope(); if (currentScope != null) { return(this.ApplicationContainer.Resolve <INancyModule>(moduleType.FullName)); } using (this.ApplicationContainer.BeginScope()) { return(this.ApplicationContainer.Resolve <INancyModule>(moduleType.FullName)); } }
public void Windsor_scope_ends_when_scenario_ends() { var globalContainer = new ObjectContainer(); var scenarioContainer = new ObjectContainer(globalContainer); CreateContainerViaPlugin(globalContainer, scenarioContainer); var activeScope = CallContextLifetimeScope.ObtainCurrentScope(); scenarioContainer.Dispose(); var endedScope = CallContextLifetimeScope.ObtainCurrentScope(); activeScope.Should().NotBeNull(); endedScope.Should().BeNull(); }
/// <summary> /// Retrieves a specific <see cref="NancyModule"/> implementation based on its key /// </summary> /// <param name="moduleKey">Module key</param> /// <param name="context">The current context</param> /// <returns>The <see cref="NancyModule"/> instance that was retrived by the <paramref name="moduleKey"/> parameter.</returns> public override NancyModule GetModuleByKey(string moduleKey, NancyContext context) { var currentScope = CallContextLifetimeScope.ObtainCurrentScope(); if (currentScope != null) { return(this.ApplicationContainer.Resolve <NancyModule>(moduleKey)); } using (this.ApplicationContainer.BeginScope()) { return(this.ApplicationContainer.Resolve <NancyModule>(moduleKey)); } }
/// <inheritdoc /> public override async Task Invoke(IIncomingPhysicalMessageContext context, Func <Task> next) { CallContextLifetimeScope currentScope = CallContextLifetimeScope.ObtainCurrentScope(); if (currentScope != null) { throw new InternalProgrammingError($"Didn't expect a Castle-Windsor scope yet, for MessageId: {context.MessageId}"); } using (Kernel.BeginScope()) { ISession session = Kernel.Resolve <ISession>(); try { Contract.Assert(session.IsOpen); ITransaction transaction = session.BeginTransaction(IsolationLevel.Unspecified); try { MessageContextAccessor.MessageContext = new RequestMessageContext(context.MessageHeaders); try { await next().ConfigureAwait(false); } finally { MessageContextAccessor.MessageContext = null; } Logger.Info(() => $"Flush and commit our request transaction, for MessageId: {context.MessageId}."); await session.FlushAsync().ConfigureAwait(false); await transaction.CommitAsync().ConfigureAwait(false); } catch (OperationCanceledException) { Logger.Info($"Operation cancelled, for MessageId: {context.MessageId}."); throw; } catch (MessageDeserializationException) { Logger.Info($"Message deserialization exception for MessageId: {context.MessageId}."); throw; } catch (Exception e) { Logger.Error($"While flush and committing for MessageId: {context.MessageId}.", e); throw; } finally { if (transaction.IsActive) { Logger.Error($"Rolling back transaction for MessageId: {context.MessageId}."); await transaction.RollbackAsync().ConfigureAwait(false); } } } finally { Kernel.ReleaseComponent(session); } } }