public void StartAllIStartable() { HealthChecks.RegisterHealthCheck("Startable", (Func <HealthCheckResult>)StartableHealtCheck); IHandler[] handlers = Kernel.GetAssignableHandlers(typeof(object)); IEnumerable <HandlerInfo> startableHandlers = GetStartableHandlers(handlers); foreach (var handlerInfo in startableHandlers.OrderBy(h => h.Priority)) { try { handlerInfo.Handler.Resolve(CreationContext.CreateEmpty()); _logger.InfoFormat("Component {0} started correctly.", handlerInfo.Description); } catch (Exception ex) { _logger.ErrorFormat(ex, "Cannot start component {0} because it raised exception. Retry in {1} seconds.", handlerInfo.Description, _timeoutInSecondsBeforeRetryRestartFailedServices); handlerInfo.StartException = ex; _handlersWithStartError.Add(handlerInfo); } } if (_handlersWithStartError.Count > 0) { _retryStartTimer = new System.Threading.Timer( RetryStartTimerCallback, null, 1000 * _timeoutInSecondsBeforeRetryRestartFailedServices, //Due time 1000 * _timeoutInSecondsBeforeRetryRestartFailedServices //Period ); } }
private void RetryStartTimerCallback(object state) { _retryCount++; if (!_executing) { try { _executing = true; foreach (var handlerInfo in _handlersWithStartError.ToList()) { try { handlerInfo.Handler.Resolve(CreationContext.CreateEmpty()); _handlersWithStartError.Remove(handlerInfo); _logger.InfoFormat("Component {0} started correctly after {1} retries.", handlerInfo.Description, _retryCount); } catch (Exception ex) { //Handler still failed start, leave it into collection and will be restarted. _logger.ErrorFormat(ex, "Cannot start component {0} because it raised exception. Retry in {1} seconds.", handlerInfo.Description, _timeoutInSecondsBeforeRetryRestartFailedServices); } } } finally { _executing = false; if (_handlersWithStartError.Count == 0) { _retryStartTimer.Dispose(); } } } }
private void onComponentRegistered(string key, IHandler handler) { if ((bool)(handler.ComponentModel.ExtendedProperties["IsSerializerFactory"] ?? false)) { if (handler.CurrentState == HandlerState.WaitingDependency) { m_SerializerFactoryWaitList.Add(handler); } else { registerSerializerFactory(handler); } } var messageHandlerFor = handler.ComponentModel.ExtendedProperties["MessageHandlerFor"] as string[]; if (messageHandlerFor != null && messageHandlerFor.Length > 0) { if (handler.CurrentState == HandlerState.WaitingDependency) { m_MessageHandlerWaitList.Add(handler); } else { handler.Resolve(CreationContext.CreateEmpty()); } } processWaitList(); }
public override bool ReleaseCore(Burden burden) { var genericType = ProxyUtil.GetUnproxiedType(burden.Instance); var handler = GetSubHandler(CreationContext.CreateEmpty(), genericType); return(handler.Release(burden)); }
public void TestCustom() { kernel.Register(Component.For(typeof(IComponent)).ImplementedBy(typeof(CustomComponent)).Named("a")); IHandler handler = kernel.GetHandler("a"); IComponent instance1 = handler.Resolve(CreationContext.CreateEmpty()) as IComponent; Assert.IsNotNull(instance1); }
private bool TryRegisterSerializerFactory(IHandler handler) { var factory = handler.TryResolve(CreationContext.CreateEmpty()); if (factory == null) { return(false); } m_MessagingEngine.SerializationManager.RegisterSerializerFactory(factory as ISerializerFactory); return(true); }
/// <summary> /// Request the component instance /// </summary> /// <param name = "handler"></param> private bool TryStart(IHandler handler) { try { inStart = true; return(handler.TryResolve(CreationContext.CreateEmpty()) != null); } finally { inStart = false; } }
private void processWaitList() { foreach (var handler in m_MessageHandlerWaitList.Where(handler => handler.CurrentState == HandlerState.Valid)) { handler.Resolve(CreationContext.CreateEmpty()); } foreach (var factoryHandler in m_SerializerFactoryWaitList.ToArray().Where(factoryHandler => factoryHandler.CurrentState == HandlerState.Valid)) { registerSerializerFactory(factoryHandler); m_SerializerWaitList.Remove(factoryHandler); } }
public void TryResolvingViaChildKernelShouldNotThrowException() { using (var childKernel = new DefaultKernel()) { Kernel.Register(Component.For <BookStore>()); Kernel.AddChildKernel(childKernel); var handler = childKernel.GetHandler(typeof(BookStore)); // Assert setup invariant Assert.IsInstanceOf <ParentHandlerWrapper>(handler); Assert.DoesNotThrow(() => handler.TryResolve(CreationContext.CreateEmpty())); } }
public void TestSingleton() { kernel.Register(Component.For(typeof(IComponent)).ImplementedBy(typeof(SingletonComponent)).Named("a")); IHandler handler = kernel.GetHandler("a"); IComponent instance1 = handler.Resolve(CreationContext.CreateEmpty()) as IComponent; IComponent instance2 = handler.Resolve(CreationContext.CreateEmpty()) as IComponent; Assert.IsNotNull(instance1); Assert.IsNotNull(instance2); Assert.IsTrue(instance1.Equals(instance2)); Assert.IsTrue(instance1.ID == instance2.ID); }
public void TestTransient() { Kernel.Register(Component.For <IComponent>().ImplementedBy(typeof(TransientComponent)).Named("a")); var handler = Kernel.GetHandler("a"); var instance1 = handler.Resolve(CreationContext.CreateEmpty()) as IComponent; var instance2 = handler.Resolve(CreationContext.CreateEmpty()) as IComponent; Assert.IsNotNull(instance1); Assert.IsNotNull(instance2); Assert.IsTrue(!instance1.Equals(instance2)); Assert.IsTrue(instance1.ID != instance2.ID); }
public override object PerformConversion(String value, Type targetType) { if (ReferenceExpressionUtil.IsReference(value)) { string newValue = ReferenceExpressionUtil.ExtractComponentName(value); var handler = Context.Kernel.LoadHandlerByName(newValue, targetType, null); if (handler == null) { throw new ConverterException(string.Format("Component '{0}' was not found in the container.", newValue)); } return(handler.Resolve(Context.CurrentCreationContext ?? CreationContext.CreateEmpty())); } throw new NotImplementedException(); }
public override object PerformConversion(String value, Type targetType) { var componentName = ReferenceExpressionUtil.ExtractComponentKey(value); if (componentName == null) { throw new ConverterException(string.Format("Could not convert expression '{0}' to type '{1}'. Expecting a reference override like ${{some key}}", value, targetType.FullName)); } var handler = Context.Kernel.LoadHandlerByKey(componentName, targetType, null); if (handler == null) { throw new ConverterException(string.Format("Component '{0}' was not found in the container.", componentName)); } return(handler.Resolve(Context.CurrentCreationContext ?? CreationContext.CreateEmpty())); }
public void RegisterFacility_WithControlProxyHook_WorksFine() { var type = typeof(SynchronizeFacility).FullName; var container2 = new WindsorContainer(); var facNode = new MutableConfiguration("facility"); facNode.Attributes["type"] = type; facNode.Attributes[Constants.ControlProxyHookAttrib] = typeof(DummyProxyHook).AssemblyQualifiedName; container2.Kernel.ConfigurationStore.AddFacilityConfiguration(type, facNode); container2.AddFacility(new SynchronizeFacility()); container2.Register(Component.For <DummyForm>().Named("dummy.form.class")); var model = container2.Kernel.GetHandler("dummy.form.class").ComponentModel; var options = model.ObtainProxyOptions(false); Assert.IsNotNull(options, "Proxy options should not be null"); Assert.IsTrue(options.Hook.Resolve(container2.Kernel, CreationContext.CreateEmpty()) is DummyProxyHook, "Proxy hook should be a DummyProxyHook"); }
internal static void AddBehaviors <T>(IKernel kernel, WcfExtensionScope scope, KeyedByTypeCollection <T> behaviors, IWcfBurden burden, Predicate <T> predicate) { foreach (var handler in FindExtensions <T>(kernel, scope)) { T behavior = (T)handler.Resolve(CreationContext.CreateEmpty()); if (predicate == null || predicate(behavior)) { if (behaviors != null) { behaviors.Add(behavior); } if (burden != null) { burden.Add(behavior); } } } }
/// <summary> /// Applies the synchronization support to the model. /// </summary> /// <param name = "model">The model.</param> /// <param name = "kernel">The kernel.</param> private void ApplySynchronization(ComponentModel model, IKernel kernel) { var options = model.ObtainProxyOptions(); model.Interceptors.Add(new InterceptorReference(typeof(SynchronizeInterceptor))); var metaInfo = metaStore.GetMetaFor(model.Implementation); if (metaInfo != null) { IInterceptorSelector userSelector = null; if (options.Selector != null) { userSelector = options.Selector.Resolve(kernel, CreationContext.CreateEmpty()); } options.Selector = new InstanceReference <IInterceptorSelector>(new SynchronizeInterceptorSelector(metaInfo, userSelector)); foreach (var reference in metaInfo.GetUniqueSynchContextReferences()) { reference.Attach(model); } } }
private void BindEnvironment(object instance, EnvironmentScope envScope) { var resolver = _kernel.Resolver; var context = CreationContext.CreateEmpty(); instance = ProxyUtil.GetUnproxiedInstance(instance); foreach (var property in _componentModel.Properties .Where(property => envScope.Contains(property.Property.PropertyType))) { try { var value = resolver.Resolve(context, context.Handler, _componentModel, property.Dependency); if (value == null) { continue; } if (value == EnvironmentScope.Null) { value = null; } try { var setMethod = property.Property.GetSetMethod(); setMethod.Invoke(instance, new[] { value }); } catch { // ignore } } catch { // ignore } } }
public void TestPerThread() { Kernel.Register(Component.For <IComponent>().ImplementedBy(typeof(PerThreadComponent)).Named("a")); var handler = Kernel.GetHandler("a"); var instance1 = handler.Resolve(CreationContext.CreateEmpty()) as IComponent; var instance2 = handler.Resolve(CreationContext.CreateEmpty()) as IComponent; Assert.IsNotNull(instance1); Assert.IsNotNull(instance2); Assert.IsTrue(instance1.Equals(instance2)); Assert.IsTrue(instance1.ID == instance2.ID); var thread = new Thread(OtherThread); thread.Start(); thread.Join(); Assert.IsNotNull(instance3); Assert.IsTrue(!instance1.Equals(instance3)); Assert.IsTrue(instance1.ID != instance3.ID); }
private void processWaitList() { foreach (var pair in m_WaitList.ToArray().Where(pair => pair.Key.CurrentState == HandlerState.Valid && pair.Key.TryResolve(CreationContext.CreateEmpty()) != null)) { pair.Value(pair.Key); m_WaitList.Remove(pair.Key); } }
protected virtual void Start(IHandler handler) { handler.Resolve(CreationContext.CreateEmpty()); }
public IEnumerable <IHandler> GetAllHandlersFor(Type type) { return(from h in container.Kernel.GetAssignableHandlers(type) select(IHandler) new DefaultHandler(null, h.ComponentModel.Implementation, () => h.Resolve(CreationContext.CreateEmpty()))); }
private void OtherThread() { var handler = Kernel.GetHandler("a"); instance3 = handler.Resolve(CreationContext.CreateEmpty()) as IComponent; }
private bool InvokeInSynchronizationContext(IInvocation invocation) { if (metaInfo != null) { IHandler handler = null; SynchronizationContext syncContext = null; SynchronizationContext prevSyncContext = null; var methodInfo = invocation.MethodInvocationTarget; var syncContextRef = metaInfo.GetSynchronizedContextFor(methodInfo); if (syncContextRef != null) { switch (syncContextRef.ReferenceType) { case SynchronizeContextReferenceType.Key: handler = kernel.GetHandler(syncContextRef.ComponentKey); break; case SynchronizeContextReferenceType.Interface: handler = kernel.GetHandler(syncContextRef.ServiceType); break; } if (handler == null) { throw new ApplicationException("The synchronization context could not be resolved. Did you forget to register it in the container?"); } syncContext = handler.Resolve(CreationContext.CreateEmpty()) as SynchronizationContext; if (syncContext == null) { throw new ApplicationException(string.Format("{0} does not implement {1}", syncContextRef, typeof(SynchronizationContext).FullName)); } prevSyncContext = SynchronizationContext.Current; } else { syncContext = SynchronizationContext.Current; } if (syncContext != activeSyncContext) { try { var result = CreateResult(invocation); if (prevSyncContext != null) { SynchronizationContext.SetSynchronizationContext(syncContext); } if (syncContext.GetType() == typeof(SynchronizationContext)) { InvokeSynchronously(invocation, result); } else { syncContext.Send(state => { activeSyncContext = syncContext; try { InvokeSafely(invocation, result); } finally { activeSyncContext = null; } }, null); } } finally { if (prevSyncContext != null) { SynchronizationContext.SetSynchronizationContext(prevSyncContext); } } } else { InvokeSynchronously(invocation, null); } return(true); } return(false); }
private bool InvokeInSynchronizationContext(IInvocation invocation) { if (metaInfo == null) { return(false); } SynchronizationContext syncContext = null; SynchronizationContext prevSyncContext = null; var methodInfo = invocation.MethodInvocationTarget; var syncContextRef = metaInfo.GetSynchronizedContextFor(methodInfo); if (syncContextRef != null) { syncContext = syncContextRef.Resolve(kernel, CreationContext.CreateEmpty()); prevSyncContext = SynchronizationContext.Current; } else { syncContext = SynchronizationContext.Current; } if (syncContext != activeSyncContext) { try { var result = CreateResult(invocation); if (prevSyncContext != null) { SynchronizationContext.SetSynchronizationContext(syncContext); } if (syncContext.GetType() == typeof(SynchronizationContext)) { InvokeSynchronously(invocation, result); } else { syncContext.Send(state => { activeSyncContext = syncContext; try { InvokeSafely(invocation, result); } finally { activeSyncContext = null; } }, null); } } finally { if (prevSyncContext != null) { SynchronizationContext.SetSynchronizationContext(prevSyncContext); } } } else { InvokeSynchronously(invocation, null); } return(true); }
/// <summary> /// Request the component instance /// </summary> /// <param name="handler"/> private bool TryStart(IHandler handler) { return(handler.TryResolve(CreationContext.CreateEmpty()) != null); }
private void Start(IHandler handler) { handler.Resolve(CreationContext.CreateEmpty()); }