/// <summary> /// Invokes the registered exception listener, if any. /// </summary> /// <param name="ex">The exception that arose during NMS processing.</param> /// <see cref="ExceptionListener"/> protected virtual void InvokeExceptionListener(Exception ex) { IExceptionListener exListener = ExceptionListener; if (exListener != null) { exListener.OnException(ex); } }
public InternalChainedExceptionListener(IExceptionListener internalListener, IExceptionListener userListener) { AddListener(internalListener); if (userListener != null) { AddListener(userListener); this.userListener = userListener; } }
//these are for starting and stoppign the script from an external source like //notepad++ public static void DirectInit(string f, string dir, string ll, IIOStream io, IExceptionListener listener) { IsConsole = false; IO = io; Init(listener); Settings.SetQuickDirectory(dir); Settings.SetLogLevel(ll); DirectRun(f); }
private MicroserviceInitializer AttachExceptionListeners() { FirstChanceExceptionListener = new FirstChanceExceptionListener(Logger); FirstChanceExceptionListener.Listen(); UnhandledExceptionListener = new UnhandledExceptionListener(Logger); UnhandledExceptionListener.Listen(); return(this); }
public static void Init(IExceptionListener el) { Settings.LoadSettings(); //on load set predefined functions and extensions to mitigate load from reflection predefinedFunctions = Utilities.GetPredefinedFunctions(); Compiler.PredefinedList = predefinedFunctions; ExtensionStack.Clear(); ExtensionStack.AddRange(Utilities.GetExtensions()); Compiler.ExceptionListener = el; ExceptionListener.stupidFix = true; // }
/// <summary> /// Prepares the connection before it is exposed. /// The default implementation applies ExceptionListener and client id. /// Can be overridden in subclasses. /// </summary> /// <param name="con">The Connection to prepare.</param> /// <exception cref="EMSException">if thrown by any EMS API methods.</exception> protected virtual void PrepareConnection(IConnection con) { if (ClientId != null) { con.ClientID = ClientId; } if (this.exceptionListener != null || this.reconnectOnException) { IExceptionListener listenerToUse = this.exceptionListener; if (reconnectOnException) { listenerToUse = new InternalChainedExceptionListener(this, listenerToUse); } con.ExceptionListener = listenerToUse; } }
public void RegisteredExceptionListenerIsInvokedOnException() { SimpleMessageConsumer messageConsumer = new SimpleMessageConsumer(); ISession session = (ISession)mocks.CreateMock(typeof(ISession)); Expect.Call(session.CreateQueue(DESTINATION_NAME)).Return(QUEUE_DESTINATION); Expect.Call(session.CreateConsumer(QUEUE_DESTINATION, null)).Return(messageConsumer); // an exception is thrown, so the rollback logic is being applied here... Expect.Call(session.Transacted).Return(false); IConnection connection = (IConnection)mocks.CreateMock(typeof(IConnection)); //connection.ExceptionListener += container.OnException; connection.ExceptionListener = container; Expect.Call(connection.CreateSession(false, container.SessionAcknowledgeMode)).Return(session); connection.Start(); IConnectionFactory connectionFactory = (IConnectionFactory)mocks.CreateMock(typeof(IConnectionFactory)); Expect.Call(connectionFactory.CreateConnection()).Return(connection); EMSException theException = new EMSException(EXCEPTION_MESSAGE); IExceptionListener exceptionListener = (IExceptionListener)mocks.CreateMock(typeof(IExceptionListener)); exceptionListener.OnException(theException); //IMessage message = (IMessage) mocks.CreateMock(typeof (IMessage)); TextMessage message = new TextMessage(null, "hello"); mocks.ReplayAll(); container.ConnectionFactory = connectionFactory; container.DestinationName = DESTINATION_NAME; container.MessageListener = new BadSessionAwareMessageListener(theException); container.ExceptionListener = exceptionListener; container.AfterPropertiesSet(); // manually trigger an Exception with the above bad MessageListener... messageConsumer.SendMessage(message); mocks.VerifyAll(); }
public void RegisteredExceptionListenerIsInvokedOnException() { SimpleMessageConsumer messageConsumer = new SimpleMessageConsumer(); ISession session = A.Fake <ISession>(); A.CallTo(() => session.GetQueue(DESTINATION_NAME)).Returns(QUEUE_DESTINATION); A.CallTo(() => session.CreateConsumer(QUEUE_DESTINATION, null)).Returns(messageConsumer); // an exception is thrown, so the rollback logic is being applied here... A.CallTo(() => session.Transacted).Returns(false); IConnection connection = A.Fake <IConnection>(); connection.ExceptionListener += container.OnException; A.CallTo(() => connection.CreateSession(container.SessionAcknowledgeMode)).Returns(session); connection.Start(); IConnectionFactory connectionFactory = A.Fake <IConnectionFactory>(); A.CallTo(() => connectionFactory.CreateConnection()).Returns(connection); NMSException theException = new NMSException(EXCEPTION_MESSAGE); IExceptionListener exceptionListener = A.Fake <IExceptionListener>(); exceptionListener.OnException(theException); IMessage message = A.Fake <IMessage>(); container.ConnectionFactory = connectionFactory; container.DestinationName = DESTINATION_NAME; container.MessageListener = new BadSessionAwareMessageListener(theException); container.ExceptionListener = exceptionListener; container.AfterPropertiesSet(); // manually trigger an Exception with the above bad MessageListener... messageConsumer.SendMessage(message); }
/// <summary> /// Adds the exception listener to the chain /// </summary> /// <param name="listener">The listener.</param> public void AddListener(IExceptionListener listener) { AssertUtils.ArgumentNotNull(listener, "listener", "ExceptionListener must not be null"); listeners.Add(listener); }
public ConcordionBuilder WithExceptionListener(IExceptionListener eventRecorder) { // TODO - add code here for processing return this; }
public ConcordionBuilder WithExceptionListener(IExceptionListener eventRecorder) { // TODO - add code here for processing return(this); }