public Subscription(Type messageType, BusEndpoint subscriberEndpoint, BusEndpoint publisherEndpoint, bool unsubscribeOnStop)
{
Token = Guid.NewGuid();
MessageType = messageType;
SubscriberEndpoint = subscriberEndpoint;
PublisherEndpoint = publisherEndpoint;
UnsubscribeOnStop = unsubscribeOnStop;
}
public void SubscribeTo <TMessage>(BusEndpoint publisherEndpoint, Action <TMessage> handler, bool unsubscribeOnStop = true)
where TMessage : class
{
MessageHandlers.Add(handler);
var subscription = new Subscription(typeof(TMessage), LocalEndpoint, publisherEndpoint, unsubscribeOnStop);
_subscriptions.Add(subscription);
Send(new StartSubscriptionRequest(subscription), publisherEndpoint);
}
private void SendToErrorQueue(Message obj)
{
var errorsEndpoint = new BusEndpoint(LocalEndpoint.MachineName, LocalEndpoint.QueueName + "_errors");
var errorQueuePath = MsmqEndpointParser.GetQueuePath(errorsEndpoint);
var errorQueue = GetOrCreateMessageQueue(errorQueuePath);
errorQueue.Send(obj);
errorQueue.Dispose();
}
public ServiceBus(string localQueueName)
{
LocalEndpoint = new BusEndpoint("", localQueueName);
MessageHandlers = new MessageHandlers();
TargetEndpoints = new TargetEndpoints();
MessageHandlers.Add <StartSubscriptionRequest>(Handle);
MessageHandlers.Add <EndSubscriptionRequest>(Handle);
// TODO: Should it be possible to reject a subscription request?
//MessageHandlers.Add<SubscriptionStarted>(Handle);
//MessageHandlers.Add<SubscriptionEnded>(Handle);
_replyGenerators.AddFor <StartSubscriptionRequest>(r => new SubscriptionStarted(r.Subscription));
_replyGenerators.AddFor <EndSubscriptionRequest>(r => new SubscriptionEnded(r.Subscription));
}
public void Unsubscribe <TMessage>(BusEndpoint publisherEndpoint)
where TMessage : class
{
var messageType = typeof(TMessage);
var subs = _subscriptions.For(messageType);
foreach (var subscription in subs)
{
Send(new EndSubscriptionRequest(subscription), publisherEndpoint);
}
// TODO: Need to also remove the messagehandlers, store them separately from the regular ones?
_subscriptions.Remove(messageType, publisherEndpoint);
}
private void Send(object message, BusEndpoint targetEndpoint)
{
var queuePath = MsmqEndpointParser.GetQueuePath(targetEndpoint);
if (!MessageQueue.Exists(queuePath))
{
throw new TargetEndpointNotFoundException(string.Format("Unable to reach target endpoint {0}@{1}", targetEndpoint.QueueName, targetEndpoint.MachineName));
}
var remoteQueue = new MessageQueue(queuePath, QueueAccessMode.Send);
if (!remoteQueue.CanWrite)
{
throw new UnableToSendMessageException(string.Format("Unable to send message to {0}@{1}", targetEndpoint.QueueName, targetEndpoint.MachineName));
}
remoteQueue.SendMessage(WrapInMsmqMessage(message));
}
private Subscriber(Guid token, Type messageType, BusEndpoint endpoint)
{
Token = token;
MessageType = messageType;
Endpoint = endpoint;
}
internal static string GetQueuePath(BusEndpoint endpoint)
{
return(String.Format(@"{0}\private$\{1}", endpoint.MachineName, endpoint.QueueName));
}
internal void Remove(Type messageType, BusEndpoint publisherEndpoint)
{
}
public void SetFor <TMessage>(BusEndpoint endpoint)
{
var messageType = typeof(TMessage);
_endpoints.AddOrUpdate(messageType, endpoint, (t, e) => endpoint);
}
