void AddSubscriberToMessage ( MessageType messageType, MessageSubscriber subscriber)
{
if (!subscriberLists.ContainsKey (messageType))
subscriberLists [messageType] = new List<MessageSubscriber> ();
subscriberLists [messageType].Add (subscriber);
}
/**
* Unsubscribe sub to system-level messages of type t.
*
* \param t System-level message type to unsubscribe from
* \param sub Subscriber to no longer receive messages of type t
*/
public void Unsubscribe(MessageType t, MessageSubscriber sub)
{
new Handler(Looper.MainLooper).Post(() =>
{
RemoveSubscription(t, sub);
});
}
public void DisposeRecipientWrapped()
{
var target = new Messenger();
var subscriber = new MessageSubscriber(target);
bool received = false;
subscriber.Subscribe <Message>(m => received = true);
int c = target.Publish(Message.Empty);
Assert.AreEqual(1, c);
#if !SILVERLIGHT
DisplayContext.Current.Dispatcher.DoEvents();
#endif
Assert.IsTrue(received);
received = false;
subscriber = null;
GC.Collect();
GC.WaitForPendingFinalizers();
c = target.Publish(Message.Empty);
Assert.AreEqual(0, c);
}
public void CanProcessSubscribedMessageWithException()
{
var thrown = false;
var manualReset = new ManualResetEventSlim(false);
var sut = new MessageSubscriber <string>(m =>
{
if (!thrown)
{
thrown = true;
throw new Exception();
}
else
{
manualReset.Set();
}
}, new LogServiceProvider());
var input = new BufferBlock <IMessage>();
sut.SubscribeTo(input);
input.Post(new Message <string>("hello", new Dictionary <string, string>()));
input.Post(new Message <string>("hello", new Dictionary <string, string>()));
manualReset.Wait(10).Should().BeTrue();
manualReset.IsSet.Should().BeTrue();
}
public void MessageIsRepublished()
{
ArtificialQueueWrapper qw = new ArtificialQueueWrapper();
Mock <ILogger> log = new Mock <ILogger>();
Mock <IMethodInspectorManager> mim = new Mock <IMethodInspectorManager>();
Mock <IConfigurationManager> config = new Mock <IConfigurationManager>();
config.Setup(x => x.Get("UseStructureMap", false)).Returns(true);
var container = new Container(new MicroserviceRegistry(typeof(ConsumeMessageTests).Assembly));
container.Configure(x => { x.For <IQueueWrapper>().ClearAll().Use(qw); });
var containerFacade = new ContainerFacade(container, config.Object);
MessageSubscriber subscriber = new MessageSubscriber(qw, log.Object, config.Object, _metrics, mim.Object, containerFacade);
Guid messageGuid = Guid.NewGuid();
BasicDeliverEventArgs eventDetails = new BasicDeliverEventArgs()
{
Body = Encoding.ASCII.GetBytes("{uuid:\"" + messageGuid + "\", method:\"GetFish\", source:\"Nowhere\", need:\"redherring\",publishedTime:\"" + DateTime.UtcNow.ToString("s") + "\", lastModifiedBy:\"test\", lastModifiedTime:\"" + DateTime.UtcNow.ToString("s") + "\"}")
};
subscriber.ConsumeMessage(null, eventDetails);
Thread.Sleep(50);
Assert.AreEqual(1, qw.AcknowledgedMessages.Count);
Assert.IsTrue(qw.AcknowledgedMessages.Contains(eventDetails));
Assert.AreEqual(1, qw.PublishedMessages.Count);
}
public void Unsubscribe()
{
using (var pub = new MessagePublisher(9202))
using (var sub = new MessageSubscriber("localhost", 9202))
{
var handler = new TestSubscribeHandler();
sub.SetReceiveHandleEvent(handler);
sub.Listen();
sub.Subscribe(Encoding.UTF8.GetBytes("A"));
Thread.Sleep(200);
pub.Send(Encoding.UTF8.GetBytes("A"), Encoding.UTF8.GetBytes("hello"));
Thread.Sleep(200);
Assert.Equal("A", Encoding.UTF8.GetString(handler.Block[0]));
Assert.Equal("hello", Encoding.UTF8.GetString(handler.Block[1]));
handler.Block = null;
sub.Unsubscribe(Encoding.UTF8.GetBytes("A"));
Thread.Sleep(200);
pub.Send(Encoding.UTF8.GetBytes("A"), Encoding.UTF8.GetBytes("hello"));
Thread.Sleep(200);
Assert.Null(handler.Block);
}
}
public void TwoMessagesWithDifferentNeedsReturnDifferentHashCodes()
{
Mock <IQueueWrapper> qw = new Mock <IQueueWrapper>();
Mock <ILogger> log = new Mock <ILogger>();
Mock <IConfigurationManager> config = new Mock <IConfigurationManager>();
Mock <IMethodInspectorManager> mim = new Mock <IMethodInspectorManager>();
MessageSubscriber subscriber = new MessageSubscriber(qw.Object, log.Object, config.Object, metrics, mim.Object, Mock.Of <IContainerFacade>());
Guid messageGuid = Guid.NewGuid();
BasicDeliverEventArgs bdea1 = new BasicDeliverEventArgs();
bdea1.Body = Encoding.ASCII.GetBytes("{" + $"uuid:\"{messageGuid}\",method:\"Hello\",need:\"1234\"" + "}");
MessageSubscriber.MethodInspector mi1 = subscriber.GetMethodInspector(bdea1);
Assert.IsNotNull(mi1);
BasicDeliverEventArgs bdea2 = new BasicDeliverEventArgs();
bdea2.Body = Encoding.ASCII.GetBytes("{" + $"uuid:\"{messageGuid}\",method:\"Hello\",need:\"1233\"" + "}");
MessageSubscriber.MethodInspector mi2 = subscriber.GetMethodInspector(bdea2);
Assert.IsNotNull(mi2);
Assert.AreNotEqual(mi1.Hash, mi2.Hash);
}
public void AddSubscriber(MessageSubscriber subscriber)
{
MessageType[] messageTypes = subscriber.MessageTypes;
for (int i = 0; i < messageTypes.Length; i++)
{
AddSubscriberToMessage(messageTypes[i], subscriber);
}
}
public void PubSub()
{
var pub = new MessagePublisher(9200);
var sub = new MessageSubscriber("localhost", 9200);
pub.Close();
sub.Close();
}
void Start()
{
subscriber = new MessageSubscriber ();
subscriber.MessageTypes = MessageTypes;
subscriber.Handler = Handler;
MessageBus.Instance.AddSubscriber (subscriber);
}
void Start()
{
MessageSubscriber subscriber = new MessageSubscriber();
subscriber.MessageTypes = MessageTypes;
subscriber.Handler = Handler;
MessageBus.Instance.AddSubscriber(subscriber);
}
public void AddSubscriber(MessageSubscriber subscriber)
{
if (_subscribers.Any(x => x.Id == subscriber.Id))
{
return;
}
_subscribers.Add(subscriber);
}
public IBusSubscriber Subscribe <T>(Func <IServiceProvider, T, object, Task> handle)
where T : class
{
var type = typeof(T);
_messageSubscribersChannel.Writer.TryWrite(MessageSubscriber.Subscribe(type,
(serviceProvider, message, context) => handle(serviceProvider, (T)message, context)));
return(this);
}
private void RemoveSubscription(MessageType t, MessageSubscriber sub)
{
List <MessageSubscriber> sub_list;
if (system_message_subs.TryGetValue(t, out sub_list))
{
// Remove from existing subscriber list
sub_list.Remove(sub);
}
}
/// <summary>
/// Creates a subscription and filter on the message subscriber for the receive port response handler.
/// </summary>
/// <param name="messageSubscriber">The message subscriber.</param>
/// <param name="receivePort">The receive port.</param>
private void CreateMessageSubscriberFilter(MessageSubscriber messageSubscriber, ReceivePort receivePort)
{
var topicChannelKey = _messageBoxChannelKey;
var receivePortSubscriptionName = receivePort.Name.FormatKey();
// Find topic channel to add subscriptions to
var topicChannelObject = Model.FindMessagingObject(topicChannelKey);
if (topicChannelObject.application != null && topicChannelObject.messagingObject != null)
{
var topicChannel = (TopicChannel)topicChannelObject.messagingObject;
// Subscriptions will be created independent of subscribers so that messages can be delivered to
// the subscriptions, meaning the subscription lifetime is not tied to the consumer. This is a durable
// subscription and the only ones we intend to create.
messageSubscriber.IsDurable = true;
// Create subscription and name it after the receive port
var subscription = new Subscription(receivePortSubscriptionName, topicChannel.TopicName)
{
IsDurable = messageSubscriber.IsDurable
};
_logger.LogDebug(TraceMessages.CreatingReceivePortSubscription, RuleName, receivePort.Name);
// Create filter expression against the receive port ID
var targetFilter = new Filter()
{
FilterExpression = $"{ModelConstants.BizTalkAckReceivePortId} = '{((Dictionary<string, object>)messageSubscriber.Properties[ModelConstants.ConfigurationEntry])[ModelConstants.BizTalkAckReceivePortId]}'"
};
// Create a group, doesn't matter too much what the operation is as there is only one filter
var targetFilterGroup = new OrFilterGroup();
targetFilterGroup.Filters.Add(targetFilter);
_logger.LogTrace(TraceMessages.CreatedSubscriptionFilterStatement, RuleName, targetFilter.FilterExpression);
// Create filter
subscription.Filters.Add(new SubscriptionFilter(targetFilterGroup));
_logger.LogTrace(TraceMessages.CreatedSubscriptionFilterGroupForReceivePort, RuleName, targetFilterGroup.Operation, receivePort.Name);
// Add subscription to channel
topicChannel.Subscriptions.Add(subscription);
// Relate subscription on channel to the subscriber
messageSubscriber.TopicSubscriptions.Add(topicChannel.TopicName, subscription.Name);
}
else
{
var error = string.Format(CultureInfo.CurrentCulture, ErrorMessages.UnableToFindMessagingObjectWithKeyInTargetModel, MessagingObjectType.Channel, topicChannelKey);
_logger.LogError(error);
Context.Errors.Add(new ErrorMessage(error));
}
}
/// <summary>
/// Creates a subscription and filter on the message subscriber for the send port.
/// </summary>
/// <param name="targetApplication">The application in the target.</param>
/// <param name="messageSubscriber">The message subscriber.</param>
/// <param name="sendPort">The send port.</param>
private void CreateMessageSubscriberFilter(Application targetApplication, MessageSubscriber messageSubscriber, SendPort sendPort)
{
var topicChannelKey = _messageBoxChannelKey;
var sendPortSubscriptionName = sendPort.Name.FormatKey();
// Find topic channel to add subscriptions to
var topicChannelObject = Model.FindMessagingObject(topicChannelKey);
if (topicChannelObject.application != null && topicChannelObject.messagingObject != null)
{
var topicChannel = (TopicChannel)topicChannelObject.messagingObject;
// Subscriptions will be created independent of subscribers so that messages can be delivered to
// the subscriptions, meaning the subscription lifetime is not tied to the consumer. This is a durable
// subscription and the only ones we intend to create.
messageSubscriber.IsDurable = true;
// Create subscription and name it after the send port
var subscription = new Subscription(sendPortSubscriptionName, topicChannel.TopicName)
{
IsDurable = messageSubscriber.IsDurable
};
// Is there a subscription on the send port?
if (sendPort.FilterExpression?.Group != null)
{
// Parse the filter on the send port and create a new one for the target model
subscription.Filters.Add(CreateSubscriptionFilter(targetApplication, sendPort));
}
else
{
// No filter, in these cases BizTalk will automatically set up a subscription with the
// property SPTransportID system property, which is used by orchestrations to automatically
// promote this property and associated value on a message published through an orchestration
// send port.
// There are also cases where there is a Filter document set on the property which has
// no groups and is empty (sendPort.FilterExpression.Groups is null). Treat this as having
// no subscription.
subscription.Filters.Add(CreateDefaultSubscriptionFilter(targetApplication, sendPort));
}
// Add subscription to channel
topicChannel.Subscriptions.Add(subscription);
// Relate subscription on channel to the subscriber
messageSubscriber.TopicSubscriptions.Add(topicChannel.TopicName, subscription.Name);
}
else
{
var error = string.Format(CultureInfo.CurrentCulture, ErrorMessages.UnableToFindMessagingObjectWithKeyInTargetModel, MessagingObjectType.Channel, topicChannelKey);
_logger.LogError(error);
Context.Errors.Add(new ErrorMessage(error));
}
}
void AddSubscriberToMessage(MessageType messageType,
MessageSubscriber subscriber)
{
if (!subscriberLists.ContainsKey(messageType))
{
subscriberLists [messageType] =
new List <MessageSubscriber> ();
}
subscriberLists [messageType].Add(subscriber);
}
public static void Subscribe(LogCategory category, RecieveLogMessage callback, object contextFilter)
{
if (m_subscribers.Find(x => x.Category == category && x.Callback == callback && x.ContextFilter.Equals(contextFilter)) != null)
{
WLog.Warning(LogCategory.None, null, "Subscriber list already contains callback: {0}!", callback);
}
MessageSubscriber subscriber = new MessageSubscriber(category, callback, contextFilter);
m_subscribers.Add(subscriber);
}
public void CanProcessSubscribedMessage()
{
var manualReset = new ManualResetEvent(false);
var sut = new MessageSubscriber <string>(m => manualReset.Set(), new LogServiceProvider());
var input = new BufferBlock <IMessage>();
sut.SubscribeTo(input);
input.Post(new Message <string>("hello", new Dictionary <string, string>()));
manualReset.WaitOne(10).Should().BeTrue();
}
static void Main(string[] args)
{
var applicationUrl = MessageSubscriber.RecieveRabbitMQMessages();
var process = new Process();
process.StartInfo.FileName = "D:/PuppeteerSharp-Example-master/PuppeteerExample/bin/Debug/netcoreapp3.1/PuppeteerExample.exe";
process.StartInfo.Arguments = applicationUrl;
process.Start();
// proc.WaitForExit();
var exitCode = process.ExitCode;
process.Close();
}
public CCSMockService()
{
try
{
// active mq
this.publisher = new MessagePublisher(TOPIC_NAME_UPDATE_SIMULATION, BROKER);
this.subscriber = new MessageSubscriber(TOPIC_NAME_UPDATE_CCS, BROKER);
this.subscriber.OnMessageReceived += new MessageReceivedDelegate(subscriber_OnMessageReceived);
}
catch (Exception ex)
{
logger.Error("Error creating publisher for activemq" + ex.ToString());
}
}
public void UndeserialisableMessageIsAcked()
{
ArtificialQueueWrapper qw = new ArtificialQueueWrapper();
Mock <ILogger> log = new Mock <ILogger>();
Mock <IMethodInspectorManager> mim = new Mock <IMethodInspectorManager>();
Mock <IConfigurationManager> config = new Mock <IConfigurationManager>();
MessageSubscriber subscriber = new MessageSubscriber(qw, log.Object, config.Object, _metrics, mim.Object, Mock.Of <IContainerFacade>());
BasicDeliverEventArgs eventDetails = new BasicDeliverEventArgs()
{
Body = Encoding.ASCII.GetBytes("{message:\"Hello World\"}")
};
subscriber.ConsumeMessage(null, eventDetails);
Assert.IsTrue(qw.AcknowledgedMessages.Contains(eventDetails));
}
/// <summary>
/// Creates a message subscriber for a send port.
/// </summary>
/// <param name="intermediaryKeyPrefix">The prefix for the endpoint key.</param>
/// <param name="targetApplication">The application in the target.</param>
/// <param name="sendPort">The send port.</param>
/// <returns>The created message subscriber.</returns>
private MessageSubscriber CreateMessageSubscriberIntermediary(string intermediaryKeyPrefix, Application targetApplication, SendPort sendPort)
{
_logger.LogDebug(TraceMessages.CreatingMessageSubscriberIntermediary, RuleName, MigrationTargetResources.MessageSubscriberName, sendPort.Name);
// Format names
var applicationName = targetApplication.Name.FormatKey();
var sendPortName = sendPort.Name.FormatKey();
// Create an intermediary based on the message subscriber
var messageSubscriberIntermediary = new MessageSubscriber(sendPort.Name)
{
Description = MigrationTargetResources.MessageSubscriberDescription,
Key = $"{intermediaryKeyPrefix}:{ModelConstants.MessageSubscriberLeafKey}",
ResourceMapKey = $"topicSubscriber{applicationName.Replace(".", "-").Replace(" ", string.Empty).Replace(":", "-")}{sendPortName.Replace(".", "-").Replace("/", "-").Replace(":", "-")}",
Rating = ConversionRating.FullConversion,
Activator = true
};
// Set scenario and step name as properties on the endpoint
messageSubscriberIntermediary.Properties.Add(ModelConstants.ScenarioName, $"{applicationName}.{sendPortName}");
messageSubscriberIntermediary.Properties.Add(ModelConstants.ScenarioStepName, "messageSubscriber");
// Set BizTalk specific configuration properties
var configurationEntries = new Dictionary <string, object>()
{
{ ModelConstants.BizTalkSpName, $"{sendPort.Name}" },
{ ModelConstants.BizTalkSpId, $"{targetApplication.Name.FormatKey()}.{sendPort.Name.FormatKey()}" },
{ ModelConstants.BizTalkAckSendPortName, $"{sendPort.Name}" },
{ ModelConstants.BizTalkAckSendPortId, $"{targetApplication.Name.FormatKey()}.{sendPort.Name.FormatKey()}" }
};
// Add configuration properties
messageSubscriberIntermediary.Properties.Add(ModelConstants.ConfigurationEntry, configurationEntries);
// Set BizTalk specific routing properties
var routingProperties = new Dictionary <string, object>()
{
{ ModelConstants.BizTalkAckSendPortName, $"{sendPortName}" }
};
// Add routing properties
messageSubscriberIntermediary.Properties.Add(ModelConstants.RoutingProperties, routingProperties);
// Add subscription filter
CreateMessageSubscriberFilter(targetApplication, messageSubscriberIntermediary, sendPort);
return(messageSubscriberIntermediary);
}
public void Start()
{
MessageSubscriber subscriber = new MessageSubscriber();
subscriber.MessageTypes = new string[]
{ YagaMessageType.PAUSE_START };
subscriber.action = StartAction;
MessageBus.MessageBus.Instance.AddSubscriber(subscriber);
subscriber.MessageTypes = new string[]
{ YagaMessageType.PAUSE_END };
subscriber.action = EndAction;
MessageBus.MessageBus.Instance.AddSubscriber(subscriber);
}
public static void addSubscriber(GameObject gObject, Message message, Action <object> action)
{
if (instance.subscriberExists(gObject, message))
{
Debug.LogError("Objects can't subscribe to the same message multiple times");
return;
}
MessageSubscriber mSubscriber = new MessageSubscriber();
mSubscriber.subscriber = gObject;
mSubscriber.action = action;
mSubscriber.message = message;
instance.messageSubscribers.Add(mSubscriber);
}
public void BadMessageReturnsNullMethodInspector()
{
Mock <IQueueWrapper> qw = new Mock <IQueueWrapper>();
Mock <ILogger> log = new Mock <ILogger>();
Mock <IConfigurationManager> config = new Mock <IConfigurationManager>();
Mock <IMethodInspectorManager> mim = new Mock <IMethodInspectorManager>();
MessageSubscriber subscriber = new MessageSubscriber(qw.Object, log.Object, config.Object, metrics, mim.Object, Mock.Of <IContainerFacade>());
BasicDeliverEventArgs bdea = new BasicDeliverEventArgs
{
Body = Encoding.ASCII.GetBytes("Hello, Dave!")
};
MessageSubscriber.MethodInspector mi = subscriber.GetMethodInspector(bdea);
Assert.IsNull(mi);
}
public void LongMessageReturnsGoodMethodInspector()
{
Mock <IQueueWrapper> qw = new Mock <IQueueWrapper>();
Mock <ILogger> log = new Mock <ILogger>();
Mock <IConfigurationManager> config = new Mock <IConfigurationManager>();
Mock <IMethodInspectorManager> mim = new Mock <IMethodInspectorManager>();
MessageSubscriber subscriber = new MessageSubscriber(qw.Object, log.Object, config.Object, metrics, mim.Object, Mock.Of <IContainerFacade>());
BasicDeliverEventArgs bdea = new BasicDeliverEventArgs
{
Body = Encoding.ASCII.GetBytes("{" + $"uuid:\"{Guid.NewGuid()}\",method:\"Hello\",need:\"12345678901234567890123456789012345678901234567890123456789012345678901234567890\"" + "}")
};
MessageSubscriber.MethodInspector mi = subscriber.GetMethodInspector(bdea);
Assert.IsNotNull(mi);
}
public NotificationManager()
{
_notifications = new ObservableCollection <Notification>();
_subscriptions = new MessageSubscriber();
_closeCommand = new RelayCommand <Notification>(Remove);
_subscriptions.Subscribe <NotificationMessage>(OnNotificationMessage);
_notificationControl = new Notifications();
_notificationControl.CloseCommand = _closeCommand;
_notificationControl.ItemsSource = _notifications;
_notificationControl.SizeChanged += OnContentResized;
_notificationPopup = new Popup();
_notificationPopup.Child = _notificationControl;
_notifications.CollectionChanged += OnNotificationsCollectionChanged;
}
public void Post([FromBody] PublishConfiguration publishConfiguration)
{
foreach (var item in _context.channelOnboard)
{
MessagePublisher mp = new MessagePublisher(item.sourceName, publishConfiguration.sourceNotificationInterval);
var subscriber = _context.subscriberOnboard.Where(s => s.ChannelId == item.Id).FirstOrDefault();
if (subscriber != null)
{
MessageSubscriber sub1 = new MessageSubscriber(subscriber.SubEmail, subscriber.Category);
sub1.Subscribe(mp);
mp.Publish();
IntrimData.SetData(mp.GetAllNotification());
//_context.notificationQueue.AddRange(mp.GetAllNotification());
//_context.SaveChanges();
}
}
}
public void AcceptOnErrorAlwaysRejectsWhenErrorsAreNotPresent()
{
Mock <IQueueWrapper> qw = new Mock <IQueueWrapper>();
Mock <ILogger> log = new Mock <ILogger>();
Mock <IConfigurationManager> config = new Mock <IConfigurationManager>();
Mock <IMethodInspectorManager> mim = new Mock <IMethodInspectorManager>();
MessageSubscriber subscriber = new MessageSubscriber(qw.Object, log.Object, config.Object, metrics, mim.Object, Mock.Of <IContainerFacade>());
HandlerAttribute handlerAttribute = new HandlerAttribute("Blah")
{
ErrorsBehaviour = ErrorsBehaviour.AcceptOnlyIfErrorsExist, AcceptanceBehaviour = AcceptanceBehaviour.OnlyWithoutSolution
};
object message = new Message <string, bool>()
{
};
Assert.IsFalse(subscriber.ProcessAcceptanceBehaviours(handlerAttribute, typeof(Message <string, bool>), message));
}
public void PubSubTopic(string topic, string message)
{
using (var pub = new MessagePublisher(9201))
using (var sub = new MessageSubscriber("localhost", 9201))
{
var handler = new TestSubscribeHandler();
sub.SetReceiveHandleEvent(handler);
sub.Listen();
sub.Subscribe(Encoding.UTF8.GetBytes(topic));
Thread.Sleep(200);
pub.Send(Encoding.UTF8.GetBytes(topic), Encoding.UTF8.GetBytes(message));
Thread.Sleep(200);
Assert.Equal(topic, Encoding.UTF8.GetString(handler.Block[0]));
Assert.Equal(message, Encoding.UTF8.GetString(handler.Block[1]));
}
}
public void MessageWithoutParameterIsReceivedWrapped()
{
Messenger target = new Messenger();
MessageSubscriber subscriber = new MessageSubscriber(target);
bool received1 = false;
bool received2 = false;
subscriber.Subscribe <Message>(m => received1 = true);
subscriber.Subscribe <Message>(m => received2 = true);
target.Publish(Message.Empty);
#if !SILVERLIGHT
DisplayContext.Current.Dispatcher.DoEvents();
#endif
Assert.IsTrue(received1);
Assert.IsTrue(received2);
}
public void MessageWithoutParameterIsReceivedWrapped()
{
Messenger target = new Messenger();
MessageSubscriber subscriber = new MessageSubscriber(target);
bool received1 = false;
bool received2 = false;
subscriber.Subscribe<Message>(m => received1 = true);
subscriber.Subscribe<Message>(m => received2 = true);
target.Publish(Message.Empty);
#if !SILVERLIGHT
DisplayContext.Current.Dispatcher.DoEvents();
#endif
Assert.IsTrue(received1);
Assert.IsTrue(received2);
}
void RemoveSubscriberToMessage ( MessageType messageType, MessageSubscriber subscriber)
{
if (subscriberLists.ContainsKey (messageType))
subscriberLists [messageType].Remove (subscriber);
}
public void AddSubscriber( MessageSubscriber subscriber )
{
MessageType[] messageTypes = subscriber.MessageTypes;
for (int i = 0; i < messageTypes.Length; i++)
AddSubscriberToMessage (messageTypes[i], subscriber);
}
static void Main(string[] args)
{
try
{
TransportSettings ts = TransportSettings.UseRabbitMq("localhost");
int saltNumber = new Random().Next(1000, 10000);
string appName = string.Format("cclient_{0}", saltNumber);
var bus = ServiceBusFactory.New(sbc =>
{
sbc.ReceiveFrom(ts.GetQueueUri(appName));
sbc.UseControlBus();
ts.ApplyGlobalConfig(sbc);
});
bus.PublishRequest(new NodeSetupRequest
{
NodeId = appName,
CorrelationId = CombGuid.Generate(),
NqApplicationId = 1000,
NqInstanceNumber = 0,
NqApplicationVersionInfo = "1.0.0.0"
}, x =>
{
x.HandleTimeout(TimeSpan.FromSeconds(10d), () =>
{
Console.WriteLine("Node setup request timed out - please ensure server connectivity and try again.");
throw new TimeoutException();
});
x.HandleFault(fault =>
{
Console.WriteLine("Node setup request total error.");
throw new IOException();
});
x.Handle<NodeSetupResponse>(msg =>
{
Console.WriteLine("Got NodeSetupResponse: " + msg.ToString());
x.SetTimeout(TimeSpan.FromSeconds(30));
});
});
using (var ms = new MessageSubscriber(bus))
{
ms.Subscribe();
Console.WriteLine("Waiting for messages. Press Escape to exit.");
while (Console.ReadKey().Key != ConsoleKey.Escape)
{
Thread.Sleep(10);
}
}
bus.Dispose();
}
catch (TimeoutException)
{ }
catch (IOException) { }
}
public UnregisterMessageSubscriberTester(Messenger messenger)
{
_subscriber = new MessageSubscriber(messenger);
}
public void NotifiedInRegistrationOrderWrapped()
{
Messenger target = new Messenger();
MessageSubscriber subscriber = new MessageSubscriber(target);
int notificationCounter = 0;
int notified1 = 0;
int notified2 = 0;
subscriber.Subscribe<Message>(m => notified1 = ++notificationCounter);
subscriber.Subscribe<Message>(m => notified2 = ++notificationCounter);
target.Publish(Message.Empty);
#if !SILVERLIGHT
DisplayContext.Current.Dispatcher.DoEvents();
#endif
Assert.AreEqual(1, notified1);
Assert.AreEqual(2, notified2);
}
void SendMessageToSubscriber(Message message, MessageSubscriber subscriber)
{
subscriber.Handler.HandleMessage (message);
}
public void DisposeRecipientWrapped()
{
var target = new Messenger();
var subscriber = new MessageSubscriber(target);
bool received = false;
subscriber.Subscribe<Message>(m => received = true);
int c = target.Publish(Message.Empty);
Assert.AreEqual(1, c);
#if !SILVERLIGHT
DisplayContext.Current.Dispatcher.DoEvents();
#endif
Assert.IsTrue(received);
received = false;
subscriber = null;
GC.Collect();
GC.WaitForPendingFinalizers();
c = target.Publish(Message.Empty);
Assert.AreEqual(0, c);
}
