public MessageProcessor(IMessageSource msgSource, IMessageMatcher matcher, ISubscriptionStore store, IConfigurationSource cfg) { LiveMessageSource = msgSource; MessageMatcher = matcher; SubscriptionStore = store; TaskDelay = cfg.Get<int>(this, DefaultDelayKey, DefaultDelay); }
public Controller(IConnectionFactory sourceConnectionFactory, string queueName) { _queueName = queueName; _sourceConnection = new RabbitMqConnection(sourceConnectionFactory); _sourceChannel = new RabbitMqModel(_sourceConnection); _sourceChannel.QueueDeclarePassive(queueName); _messageSource = new ConfirmingGetter(_sourceChannel) { QueueName = queueName }; _messagePublisher = new ConfirmingPublisher(_sourceChannel); }
public MessageProcessor(IMessageSource source, IMessageDecoder decoders, IEnumerable<IMessageHandler> handlers, ILogger logger) { MessageSource = source; MessageDecoder = decoders; MessageHandlers = handlers; Logger = logger; }
/// <summary> /// Applies resources of the specified culture to the specified target object. /// </summary> /// <param name="target">Target object to apply resources to.</param> /// <param name="messageSource"><see cref="IMessageSource"/> instance to retrieve resources from.</param> /// <param name="culture">Resource culture to use for resource lookup.</param> public void ApplyResources(object target, IMessageSource messageSource, CultureInfo culture) { AssertUtils.ArgumentNotNull(target, "target"); AssertUtils.ArgumentNotNull(culture, "culture"); IList<Resource> resources = GetResources(target, messageSource, culture); foreach (Resource resource in resources) { resource.Target.SetValue(target, null, resource.Value); } }
/// <summary> /// Loads resources from the storage and creates a list of <see cref="Resource"/> instances that should be applied to the target. /// </summary> /// <remarks> /// This feature is not currently supported on version 1.0 of the .NET platform. /// </remarks> /// <param name="target">Target to get a list of resources for.</param> /// <param name="messageSource"><see cref="IMessageSource"/> instance to retrieve resources from.</param> /// <param name="culture">Resource locale.</param> /// <returns>A list of resources to apply.</returns> protected override IList LoadResources(object target, IMessageSource messageSource, CultureInfo culture) { #if ! NET_1_0 IList resources; resources = new ArrayList(); if (messageSource is ResourceSetMessageSource) { for (int i = 0; i < ((ResourceSetMessageSource) messageSource).ResourceManagers.Count; i++) { ResourceManager rm = ((ResourceSetMessageSource) messageSource).ResourceManagers[i] as ResourceManager; ResourceSet invariantResources = null; try { invariantResources = rm.GetResourceSet(CultureInfo.InvariantCulture, true, true); } catch (MissingManifestResourceException mmrex) { // ignore but log missing ResourceSet log.Debug("No ResourceSet available for invariant culture", mmrex); } if (invariantResources != null) { foreach (DictionaryEntry resource in invariantResources) { string resourceName = (string)resource.Key; if (resourceName.StartsWith("$this") && !ignoreList.Contains(resourceName)) { // redirect resource resolution if necessary object resourceValue = rm.GetObject(resourceName, culture); if (resourceValue is String && ((String)resourceValue).StartsWith("$messageSource")) { resourceValue = messageSource.GetResourceObject(((String)resourceValue).Substring(15), culture); } resources.Add(new Resource(Expression.ParsePrimary(resourceName.Substring(6)), resourceValue)); } } } } } return resources; #else throw new NotSupportedException("Operation not supported in .NET 1.0 Release."); #endif }
public void SetUp() { A.Fake<IConnectionFactory>(); _connection = A.Fake<IConnection>(); _lazyConnection = new Lazy<IConnection>(() => { _connection.Start(); return _connection; }); _session = A.Fake<ISession>(); _consumer = A.Fake<IMessageConsumer>(); _deserializer = A.Fake<IMessageDeserializer<ITestMessage>>(); _observer = A.Fake<IObserver<ITestMessage>>(); _destination = A.Fake<IDestination>(); _acknowledgementMode = AcknowledgementMode.AutoAcknowledge; A.CallTo(() => _connection.CreateSession(A<Apache.NMS.AcknowledgementMode>.Ignored)).Returns(_session); A.CallTo(() => _session.CreateConsumer(_destination)).Returns(_consumer); _source = new MessageSource<ITestMessage>(_lazyConnection, new[] {_deserializer}, _destination, _acknowledgementMode); }
/// <summary> /// Creates a new instance of the /// <see cref="Spring.Context.Support.MessageSourceAccessor"/> class /// </summary> /// <param name="messageSource"> /// The <see cref="Spring.Context.IMessageSource"/> to use to locate /// messages. /// </param> /// <param name="cultureInfo"> /// The <see cref="System.Globalization.CultureInfo"/> to use for /// locale specific messages. /// </param> public MessageSourceAccessor( IMessageSource messageSource, CultureInfo cultureInfo) { _messageSource = messageSource; _defaultCultureInfo = cultureInfo; }
/// <summary> /// Gets the list of resolved error messages for the supplied lookup <paramref name="provider"/>. /// </summary> /// <remarks> /// <p> /// If there are no errors for the supplied lookup <paramref name="provider"/>, /// an <b>empty</b> <see cref="System.Collections.IList"/> will be returned. /// </p> /// </remarks> /// <param name="provider">Error key that was used to group messages.</param> /// <param name="messageSource"><see cref="IMessageSource"/> to resolve messages against.</param> /// <returns> /// A list of resolved error messages for the supplied lookup <paramref name="provider"/>. /// </returns> public IList GetResolvedErrors(string provider, IMessageSource messageSource) { AssertUtils.ArgumentNotNull(provider, "provider"); IList messages = new ArrayList(); IList errors = (IList) errorMap[provider]; if (errors != null) { foreach (ErrorMessage error in errors) { messages.Add(error.GetMessage(messageSource)); } } return messages; }
/// <summary> /// Initializes a new instance of Command /// </summary> /// <param name="messageSource">The Source of the message, like a ConnectionManager or a Form capable of manage responses</param> /// <param name="messageSourceMetadata">Aditional data provided by the source of the message, like an IPEndPoint or a Delegate</param> /// <param name="command">The command name</param> /// <param name="parameters">The command parameters</param> /// <param name="id">The command id</param> public Command(IMessageSource messageSource, object messageSourceMetadata, string command, string parameters, int id) : this(messageSource, messageSourceMetadata, messageSource != null ? messageSource.ModuleName : null, null, command, parameters, id) { }
IPullAsyncQueue <TMessage> IAsyncQueueFactory <TMessage> .From(IMessageSource <TMessage> source, TimeSpan interval) { this._source = source; this._interval = interval; return(this); }
//////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> Attaches to the given message source. </summary> /// /// <param name="messageSource"> The message source. </param> public void Attach(IMessageSource messageSource) { mMessageSource = messageSource; mMessageSource.MessageSent += MessageSent; }
public LoggingMessageSourceDecorator(IMessageSource messageSource) { _messageSource = messageSource; }
/// <summary> /// Initializes a new instance of Command /// </summary> /// <param name="messageSource">The Source of the message, like a ConnectionManager or a Form capable of manage responses</param> /// <param name="command">The command name</param> /// <param name="parameters">The command parameters</param> /// <param name="id">The command id</param> protected BaseMessage(IMessageSource messageSource, string command, string parameters, int id) : this(messageSource, null, null, null, command, parameters, id) { }
/// <summary> /// Loads resources from the storage and creates a list of <see cref="Resource"/> instances that should be applied to the target. /// </summary> /// <param name="target">Target to get a list of resources for.</param> /// <param name="messageSource"><see cref="IMessageSource"/> instance to retrieve resources from.</param> /// <param name="culture">Resource locale.</param> /// <returns>A list of resources to apply.</returns> protected abstract IList LoadResources(object target, IMessageSource messageSource, CultureInfo culture);
/// <summary> /// Applies resources to the specified target object, using current thread's uiCulture to resolve resources. /// </summary> /// <param name="target">Target object to apply resources to.</param> /// <param name="messageSource"><see cref="IMessageSource"/> instance to retrieve resources from.</param> public void ApplyResources(object target, IMessageSource messageSource) { AssertUtils.ArgumentNotNull(target, "target"); ApplyResources(target, messageSource, Thread.CurrentThread.CurrentUICulture); }
public DemoAsyncNotificationHandler2(IMessageSource messageSource) { _messageSource = messageSource; }
/// <summary> /// Creates a new instance of the /// <see cref="Spring.Context.Support.DelegatingMessageSource"/> class. /// </summary> /// <param name="parentMessageSource"> /// The parent message source used to try and resolve messages that /// this object can't resolve. /// </param> public DelegatingMessageSource(IMessageSource parentMessageSource) { ParentMessageSource = parentMessageSource; }
public SynchronizedMessageSource(IMessageSource source) { _source = source; _sourceLock = new SemaphoreSlim(1); }
/// <summary> /// Returns a list of <see cref="Resource"/> instances that should be applied to the target. /// </summary> /// <param name="target">Target to get a list of resources for.</param> /// <param name="messageSource"><see cref="IMessageSource"/> instance to retrieve resources from.</param> /// <param name="culture">Resource locale.</param> /// <returns>A list of resources to apply.</returns> private IList<Resource> GetResources(object target, IMessageSource messageSource, CultureInfo culture) { IList<Resource> resources = resourceCache.GetResources(target, culture); if (resources == null) { resources = LoadResources(target, messageSource, culture); resourceCache.PutResources(target, culture, resources); } return resources; }
/// <summary> /// Initializes a new instance of Command /// </summary> /// <param name="messageSource">The Source of the message, like a ConnectionManager or a Form capable of manage responses</param> /// <param name="messageSourceMetadata">Aditional data provided by the source of the message, like an IPEndPoint or a Delegate</param> /// <param name="command">The command name</param> /// <param name="parameters">The command parameters</param> /// <param name="id">The command id</param> protected BaseMessage(IMessageSource messageSource, object messageSourceMetadata, string command, string parameters, int id) : this(messageSource, messageSourceMetadata, null, null, command, parameters, id) { }
public virtual bool IsValidMessageSource(IMessageSource source) { return(true); }
/// <summary> /// Initializes a new instance of Command /// </summary> /// <param name="messageSource">The Source of the message, like a ConnectionManager or a Form capable of manage responses</param> /// <param name="source">The source module of the command</param> /// <param name="destination">The destination module of the command</param> /// <param name="command">The command name</param> /// <param name="parameters">The command parameters</param> /// <param name="id">The command id</param> protected BaseMessage(IMessageSource messageSource, string source, string destination, string command, string parameters, int id) : this(messageSource, null, source, destination, command, parameters, id) { }
private void GetMessageLocalizationFallbacks(IMessageSource msgSource) { Assert.AreEqual("Dies ist Spring.NET", msgSource.GetMessage("MyMessage", new object[] { "Spring", ".NET" }), "message not as expected"); Assert.AreEqual("Isso e Spring.NET", msgSource.GetMessage("MyMessage", new CultureInfo("pt-BR"), new object[] { "Spring", ".NET" }), "message not as expected"); Assert.AreEqual("Visual Studio liebt Spring.NET", msgSource.GetMessage("MyNewMessage", new object[] { "Spring", ".NET" }), "message not as expected"); // test localization fallbacks Assert.AreEqual("Visual Studio loves Spring.NET", msgSource.GetMessage("MyNewMessage", new CultureInfo("pt-BR"), new object[] { "Spring", ".NET" }), "message not as expected"); Assert.AreEqual("Des is Spring.NET", msgSource.GetMessage("MyMessage", new CultureInfo("de-AT"), new object[] { "Spring", ".NET" }), "message not as expected"); Assert.AreEqual("Dies ist Spring.NET", msgSource.GetMessage("MyMessage", new CultureInfo("de"), new object[] { "Spring", ".NET" }), "message not as expected"); Assert.AreEqual("Visual Studio liebt Spring.NET", msgSource.GetMessage("MyNewMessage", new CultureInfo("de-AT"), new object[] { "Spring", ".NET" }), "message not as expected"); // extra tests for the "exotic" serbian culture if (!SystemUtils.MonoRuntime) { Assert.AreEqual("Ovo je Spring.NET", msgSource.GetMessage("MyMessage", new CultureInfo(CultureInfoUtils.SerbianLatinCultureName), new object[] { "Spring", ".NET" }), "message not as expected"); Assert.AreEqual("Ово је Spring.NET", msgSource.GetMessage("MyMessage", new CultureInfo(CultureInfoUtils.SerbianCyrillicCultureName), new object[] { "Spring", ".NET" }), "message not as expected"); Assert.AreEqual("Visual Studio voli Spring.NET", msgSource.GetMessage("MyNewMessage", new CultureInfo(CultureInfoUtils.SerbianCyrillicCultureName), new object[] { "Spring", ".NET" }), "message not as expected"); Assert.AreEqual("First name", msgSource.GetMessage("field.firstname", new CultureInfo(CultureInfoUtils.SerbianCyrillicCultureName)), "message not as expected"); } }
public OnlineSupervisedLearningProcessor(IMessageSource <SupervisedData> messageSource, ISupervisedLearning learner) : base(messageSource) { this.learner = learner; }
public void ShouldAcknowledgeMessagesIfValid() { _source = new MessageSource<ITestMessage>(_lazyConnection, new[] {_deserializer}, _destination, AcknowledgementMode.ClientAcknowledge); Mock<IMessageConsumer> mockConsumer = MockConsumerExtensions.Create(_session, _destination); ITextMessage textMessage = A.Fake<ITextMessage>(); _source.Messages.Subscribe(_observer); mockConsumer.RaiseFakeMessage(textMessage); A.CallTo(() => textMessage.Acknowledge()).MustHaveHappened(Repeated.Exactly.Once); }
public void AddMessageSource(IMessageSource source) => MessageProcessor.Add(source);
public WaitingCommandCall(CommandNotification notification, IMessageSource source) { Notification = notification; Source = source; }
/// <summary> /// Initializes local message source /// </summary> protected void InitializeMessageSource() { if (this.MessageSource == null) { string key = CreateSharedStateKey( "MessageSource" ); IDictionary sharedState = this.SharedState; IMessageSource messageSource = sharedState[key] as IMessageSource; if (messageSource == null) { lock (sharedState.SyncRoot) { messageSource = sharedState[key] as IMessageSource; if (messageSource == null) { ResourceSetMessageSource defaultMessageSource = new ResourceSetMessageSource(); defaultMessageSource.UseCodeAsDefaultMessage = true; ResourceManager rm = GetLocalResourceManager(); if (rm != null) { defaultMessageSource.ResourceManagers.Add( rm ); } sharedState[key] = defaultMessageSource; messageSource = defaultMessageSource; } } } this.MessageSource = messageSource; } }
public SampleMessageProcessor(IMessageSource <SampleMessage> messageSource) : base(messageSource) { }
/// <summary> /// Converts the string representation of a command to a Command object. /// A return value indicates whether the conversion succeded or not. /// <param name="source">The IMessageSource object source of the command parsed</param> /// <param name="s">A string containing the command to convert</param> /// <param name="result">When this method returns, contains the Command equivalent to the command /// contained in s, if the conversion succeeded, or null if the conversion failed. /// The conversion fails if the s parameter is a null reference (Nothing in Visual Basic) or is not of the correct format. /// This parameter is passed uninitialized</param> /// </summary> /// <returns>true if conversion was successfull, false otherwise</returns> public static bool TryParse(IMessageSource source, string s, out Command result) { result = null; Regex rx; Match m; //ModuleClient source; //ModuleClient destination; string sCommand; string sParams; string sSrc; string sDest; string sId; int id; // Regular Expresion Generation rx = rxParse; m = rx.Match(s); // Check if input string matchs Regular Expression if (!m.Success) return false; // Extract Data sCommand = m.Result("${cmd}").ToLower(); sParams = m.Result("${params}"); sId = m.Result("${id}"); sSrc = m.Result("${src}"); if ((source != null) && ((sSrc == null) || (sSrc == ""))) sSrc = source.ModuleName; sDest = ""; // m.Result("${dest}"); if ((sId == null) || (sId.Length < 1)) id = -1; else id = Int32.Parse(sId); // Check if command matchs a prototype sParams = sParams.Replace("\\\"", "\""); result = new Command(sSrc, sDest, sCommand, sParams, id); result.MessageSource = source; //cmd.sentTime = DateTime.Now; return true; }
public ServiceEndpointClient(IMessageSource <IEvent> eventSource, IMessageSource <IResponse> responseSource, IMessagePublisher <IRequest> requestPublisher, IMessagePublisher <ICommand> commandPublisher, Type serviceType) : base(eventSource, responseSource, requestPublisher, commandPublisher, serviceType) { }
/// <summary> /// Initializes a new instance of Command /// </summary> /// <param name="messageSource">The Source of the message, like a ConnectionManager or a Form capable of manage responses</param> /// <param name="source">The source module of the command</param> /// <param name="destination">The destination module of the command</param> /// <param name="command">The command name</param> /// <param name="parameters">The command parameters</param> /// <param name="id">The command id</param> protected Command(IMessageSource messageSource, string source, string destination, string command, string parameters, int id) : this(messageSource, null, source, destination, command, parameters, id) { }
public void Subscribe(IMessageSource source) { source.OnMessage += Broadcast; sources.Add(source); }
/// <summary> /// Creates a new instance of the /// <see cref="Spring.Context.Support.MessageSourceAccessor"/> class /// that uses the current <see cref="System.Globalization.CultureInfo.CurrentUICulture"/> /// for all locale specific lookups. /// </summary> /// <param name="messageSource"> /// The <see cref="Spring.Context.IMessageSource"/> to use to locate messages. /// </param> public MessageSourceAccessor(IMessageSource messageSource) : this(messageSource, CultureInfo.CurrentUICulture) { }
public IMessageConsumer <TMessage> CreateConsumer(IMessageSource <TMessage> source) { throw new System.NotImplementedException(); }
/// <summary> /// Loads resources from the storage and creates a list of <see cref="Resource"/> instances that should be applied to the target. /// </summary> /// <param name="target">Target to get a list of resources for.</param> /// <param name="messageSource"><see cref="IMessageSource"/> instance to retrieve resources from.</param> /// <param name="culture">Resource locale.</param> /// <returns>A list of resources to apply.</returns> protected abstract IList<Resource> LoadResources(object target, IMessageSource messageSource, CultureInfo culture);
private void PrintMessage(IMessageSource src, ChannelMessage msg) { Root._consoleWriter.PrintMessage(src, msg); }
/// <summary> /// Initializes local message source /// </summary> protected void InitializeMessageSource() { if (MessageSource == null) { string key = GetType().FullName + ".MessageSource"; MessageSource = (IMessageSource) Context.Cache.Get(key); if (MessageSource == null) { ResourceSetMessageSource defaultMessageSource = new ResourceSetMessageSource(); ResourceManager rm = GetLocalResourceManager(); if (rm != null) { defaultMessageSource.ResourceManagers.Add(rm); } Context.Cache.Insert(key, defaultMessageSource); MessageSource = defaultMessageSource; } } }
/// <summary> /// Gets the list of resolved error messages for the supplied lookup <paramref name="provider"/>. /// </summary> /// <remarks> /// <p> /// If there are no errors for the supplied lookup <paramref name="provider"/>, /// an <b>empty</b> <see cref="System.Collections.IList"/> will be returned. /// </p> /// </remarks> /// <param name="provider">Error key that was used to group messages.</param> /// <param name="messageSource"><see cref="IMessageSource"/> to resolve messages against.</param> /// <returns> /// A list of resolved error messages for the supplied lookup <paramref name="provider"/>. /// </returns> public IList<string> GetResolvedErrors(string provider, IMessageSource messageSource) { AssertUtils.ArgumentNotNull(provider, "provider"); IList<string> messages = new List<string>(); List<ErrorMessage> errors; if (errorMap.TryGetValue(provider, out errors)) { foreach (ErrorMessage error in errors) { messages.Add(error.GetMessage(messageSource)); } } return messages; }
IPullAsyncQueue <TMessage> IAsyncQueueFactory <TMessage> .From(IMessageSource <TMessage> source) { return(((IAsyncQueueFactory <TMessage>) this).From(source, TimeSpan.Zero)); }
public void PrintMessage(IMessageSource sender, ChannelMessage msg) { bool isError = false; var messageColor = default(ConsoleColor); switch (msg.Kind) { case ChannelMessageKind.Trace: if (!sender.Verbose) { return; } messageColor = ConsoleColor.Gray; break; case ChannelMessageKind.Info: break; case ChannelMessageKind.Warning: messageColor = ConsoleColor.Yellow; isError = true; break; default: Contracts.Assert(msg.Kind == ChannelMessageKind.Error); messageColor = ConsoleColor.Red; isError = true; break; } lock (_lock) { EnsureNewLine(isError); var wr = isError ? _err : _out; bool toColor = isError ? _colorOut : _colorErr; if (toColor && msg.Kind != ChannelMessageKind.Info) { Console.ForegroundColor = messageColor; } string prefix = WriteAndReturnLinePrefix(msg.Sensitivity, wr); var commChannel = sender as PipeBase <ChannelMessage>; if (commChannel?.Verbose == true) { WriteHeader(wr, commChannel); if (_test != null) { WriteHeader(_test, commChannel); } } if (msg.Kind == ChannelMessageKind.Warning) { wr.Write("Warning: "); _test?.Write("Warning: "); } _parent.PrintMessageNormalized(wr, msg.Message, true, prefix); if (_test != null) { _parent.PrintMessageNormalized(_test, msg.Message, true); } if (toColor) { Console.ResetColor(); } } }
public IMessageProducer <MessageEx> CreateProducer(IMessageSource <MessageEx> messageSource) { return(new MsmqMessageProducer(messageSource.Name, _sendTransactionType, _log)); }
/// <summary> /// Initializes local message source /// </summary> private void InitializeMessageSource() { if (MessageSource == null) { string MessageSourceKey = CreateSharedStateKey( "MessageSource" ); if (this.SharedState[MessageSourceKey] == null) { lock (this.SharedState.SyncRoot) { if (this.SharedState[MessageSourceKey] == null) { ResourceSetMessageSource defaultMessageSource = new ResourceSetMessageSource(); defaultMessageSource.UseCodeAsDefaultMessage = true; ResourceManager rm = GetLocalResourceManager(); if (rm != null) { defaultMessageSource.ResourceManagers.Add( rm ); } this.SharedState[MessageSourceKey] = defaultMessageSource; } } } MessageSource = (IMessageSource)this.SharedState[MessageSourceKey]; } }
public void SetUp() { mocks = new MockRepository(); _messageSource = (IMessageSource)mocks.CreateMock(typeof(IMessageSource)); }
public void SetUp() { mocks = new MockRepository(); mockMsgSource = mocks.StrictMock<IMessageSource>(); mockMsgSourceResolvable = mocks.StrictMock<IMessageSourceResolvable>(); }
protected void SetMessageSource(IMessageSource messageSource) { _messageSource = new SynchronizedMessageSource(messageSource); }
public void ShouldDeserializeAndPublishMessageOfRightTypeName() { Mock<IMessageConsumer> mockConsumer = MockConsumerExtensions.Create(_session, _destination); IBytesMessage bytesMessage = A.Fake<IBytesMessage>(); ITestMessage message = A.Fake<ITestMessage>(); const string serializedFixtureString = "<xml>Some fixture XML</xml>"; var bytes = Encoding.UTF8.GetBytes(serializedFixtureString); A.CallTo(() => bytesMessage.Content).Returns(bytes); A.CallTo(() => bytesMessage.Properties.Contains(MessagePropertyNames.TypeName)).Returns(true); A.CallTo(() => bytesMessage.Properties.GetString(MessagePropertyNames.TypeName)).Returns("SomeTypeName"); A.CallTo(() => _deserializer.Deserialize(A<Stream>._)).Returns(message); A.CallTo(() => _deserializer.GetTypeName()).Returns("SomeTypeName"); _source = new MessageSource<ITestMessage>(_lazyConnection, new[] {_deserializer}, _destination, _acknowledgementMode); _source.Messages.Subscribe(_observer); mockConsumer.RaiseFakeMessage(bytesMessage); A.CallTo(() => _observer.OnNext(message)).MustHaveHappened(); }
public Message(IMessageSource messageSource, byte[] body, IDictionary <string, string> properties, long offset) : this(messageSource, body, properties, new Dictionary <string, string>(), offset) { }
public void ShouldNotAcknowledgeMessagesIfInvalid() { _source = new MessageSource<ITestMessage>(_lazyConnection, new[] {_deserializer}, _destination, AcknowledgementMode.ClientAcknowledge); Mock<IMessageConsumer> mockConsumer = MockConsumerExtensions.Create(_session, _destination); IBytesMessage bytesMessage = A.Fake<IBytesMessage>(); A.CallTo(() => _deserializer.Deserialize(A<Stream>.Ignored)).Throws<Exception>(); _source.Messages.Subscribe(_observer); mockConsumer.RaiseFakeMessage(bytesMessage); A.CallTo(() => bytesMessage.Acknowledge()).MustNotHaveHappened(); }
public Message(IMessageSource messageSource, byte[] body, IDictionary <string, string> properties, IDictionary <string, string> systemProperties) : this(messageSource, body, properties, systemProperties, 0L) { }
public Message(IMessageSource messageSource, byte[] body, IDictionary <string, string> properties, IDictionary <string, string> systemProperties, DateTime enqueuedTime, DateTime dequeuedTime) : this(messageSource, body, properties, systemProperties, 0L, enqueuedTime, dequeuedTime) { }
/// <summary> /// Resolves the message against specified <see cref="IMessageSource"/>. /// </summary> /// <param name="messageSource">Message source to resolve this error message against.</param> /// <returns>Resolved error message.</returns> public string GetMessage(IMessageSource messageSource) { if (messageSource == null) { return Id; } if (Parameters == null) { return messageSource.GetMessage(Id); } else { return messageSource.GetMessage(Id, Parameters); } }
public Message(IMessageSource messageSource, byte[] body, IDictionary <string, string> properties, IDictionary <string, string> systemProperties, long offset) : this(messageSource, body, properties, systemProperties, offset, DateTime.MinValue, DateTime.UtcNow) { }
/// <summary> /// Initializes the default message source for this context. /// </summary> /// <remarks> /// <p> /// Uses any parent context's message source if one is not available /// in this context. /// </p> /// </remarks> private void InitMessageSource() { if (ContainsLocalObject(MessageSourceObjectName)) { object candidateSource = GetObject(MessageSourceObjectName); if (candidateSource is IMessageSource) { _messageSource = (IMessageSource)GetObject(MessageSourceObjectName); // make IMessageSource aware of any parent IMessageSource... if (ParentContext != null) { IHierarchicalMessageSource hierSource = MessageSource as IHierarchicalMessageSource; if (hierSource != null) { IMessageSource parentMessageSource = GetInternalParentMessageSource(); hierSource.ParentMessageSource = parentMessageSource; } } #region Instrumentation if (log.IsDebugEnabled) { log.Debug(StringUtils.Surround( "Using MessageSource [", MessageSource, "]")); } #endregion } else { _messageSource = new DelegatingMessageSource( GetInternalParentMessageSource()); #region Instrumentation if (log.IsWarnEnabled) { log.Warn(string.Format( "Found object in context named '{0}' : this name " + "is typically reserved for IMessageSource objects. " + "Falling back to default '{1}'.", MessageSourceObjectName, MessageSource)); } #endregion } } else if (ParentContext != null) { _messageSource = new DelegatingMessageSource( GetInternalParentMessageSource()); ObjectFactory.RegisterSingleton(MessageSourceObjectName, _messageSource); #region Instrumentation if (log.IsDebugEnabled) { log.Debug(string.Format( "No message source found in the current context: using parent context's message source '{0}'.", MessageSource)); } #endregion } else { _messageSource = new StaticMessageSource(); ObjectFactory.RegisterSingleton(MessageSourceObjectName, _messageSource); #region Instrumentation if (log.IsDebugEnabled) { log.Debug(string.Format( "No IMessageSource found with name '{0}' : using default '{1}'.", MessageSourceObjectName, MessageSource)); } #endregion } }
public MessageSource(IMessageSource messageSource) : base() { this.messageSource = messageSource; }