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);
/// <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 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>
/// 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)
{
}
/// <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> /// 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>
/// 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);
}
/// <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)
{
}
protected void SetMessageSource(IMessageSource messageSource)
{
_messageSource = new SynchronizedMessageSource(messageSource);
}
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;
}
