private void ConnectToSubscriptionService()
{
_subscriptionServiceEndpoint = _objectBuilder.GetInstance <IEndpointFactory>()
.GetEndpoint(_objectBuilder.GetInstance <IConfiguration>().SubscriptionServiceUri);
_subscriptionServiceEndpoint.Send(new AddSubscriptionClient(_clientId, _bus.Endpoint.Uri, _bus.Endpoint.Uri));
}
void SubscriptionManager()
{
_bus = ServiceBusConfigurator.New(servicesBus =>
{
servicesBus.ReceiveFrom("msmq://localhost/mt_subscription_ui");
servicesBus.SetObjectBuilder(_builder);
servicesBus.ConfigureService <SubscriptionClientConfigurator>(client =>
{
// need to add the ability to read from configuratino settings somehow
client.SetSubscriptionServiceEndpoint("msmq://localhost/mt_subscriptions");
});
});
_unsubscribe = _bus.Subscribe(this);
_subscriptionServiceEndpoint = _builder.GetInstance <IEndpointFactory>().GetEndpoint("msmq://localhost/mt_subscriptions");
_subscriptionServiceEndpoint.Send(new CacheUpdateRequest(_bus.Endpoint.Uri));
// _timeoutRepository.TimeoutAdded += TimeoutRefreshNeeded;
// _timeoutRepository.TimeoutUpdated += TimeoutRefreshNeeded;
// _timeoutRepository.TimeoutRemoved += TimeoutRefreshNeeded;
}
private T CreateInstance <T>()
{
//return typeof(T).IsInterface
// //? InterfaceBuilder.CreateObject<T>()
// : _dependencyInjectionContainer.GetInstance<T>();
return(_dependencyInjectionContainer.GetInstance <T>());
}
private Consumes <TMessage> .Selected BuildConsumer()
{
TComponent component = _builder.GetInstance <TComponent>();
Consumes <TMessage> .Selected consumer = component.TranslateTo <Consumes <TMessage> .Selected>();
return(consumer);
}
public IBusService Create(IServiceBus bus, IObjectBuilder builder)
{
var endpointFactory = builder.GetInstance <IEndpointFactory>();
var service = new SubscriptionClient(endpointFactory)
{
SubscriptionServiceUri = _subscriptionServiceUri
};
return(service);
}
private Consumes <TMessage> .All BuildConsumer()
{
TComponent component = _builder.GetInstance <TComponent>();
if (component == null)
{
throw new ConfigurationException(string.Format("Unable to resolve type '{0}' from container: ", typeof(TComponent)));
}
Consumes <TMessage> .All consumer = component.TranslateTo <Consumes <TMessage> .All>();
return(consumer);
}
public IBusService Create(IServiceBus bus, IObjectBuilder builder)
{
var service = builder.GetInstance <TService>();
return(service);
}
public void HandleMessage(IMessage message)
{
var messageInformation = new MessageInformation
{
UniqueIdentifier = Guid.NewGuid(),
Topic = _topic,
Channel = _channel,
HandlerType = _handlerType,
MessageType = _messageType,
Message = message,
DeserializedMessageBody = null,
Started = DateTime.UtcNow
};
_bus.SetCurrentMessageInformation(messageInformation);
// Get handler
object handler;
try
{
handler = _objectBuilder.GetInstance(_handlerType);
messageInformation.HandlerType = handler.GetType();
}
catch (Exception ex)
{
messageInformation.Finished = DateTime.UtcNow;
_messageAuditor.TryOnFailed(_logger, _bus,
new FailedMessageInformation
(
messageInformation,
FailedMessageQueueAction.Finish,
FailedMessageReason.HandlerConstructor,
ex
)
);
message.Finish();
return;
}
// Get deserialized value
object value;
try
{
value = _serializer.Deserialize(_concreteMessageType, message.Body);
}
catch (Exception ex)
{
messageInformation.Finished = DateTime.UtcNow;
_messageAuditor.TryOnFailed(_logger, _bus,
new FailedMessageInformation
(
messageInformation,
FailedMessageQueueAction.Finish,
FailedMessageReason.MessageDeserialization,
ex
)
);
message.Finish();
return;
}
// Handle message
messageInformation.DeserializedMessageBody = value;
_messageAuditor.TryOnReceived(_logger, _bus, messageInformation);
try
{
_handleMethod.Invoke(handler, new[] { value });
}
catch (Exception ex)
{
bool requeue = (message.Attempts < message.MaxAttempts);
messageInformation.Finished = DateTime.UtcNow;
if (requeue)
{
message.Requeue();
}
else
{
message.Finish();
}
_messageAuditor.TryOnFailed(_logger, _bus,
new FailedMessageInformation
(
messageInformation,
requeue ? FailedMessageQueueAction.Requeue : FailedMessageQueueAction.Finish,
requeue ? FailedMessageReason.HandlerException : FailedMessageReason.MaxAttemptsExceeded,
ex
)
);
return;
}
messageInformation.Finished = DateTime.UtcNow;
_messageAuditor.TryOnSucceeded(_logger, _bus, messageInformation);
}
private T CreateInstance <T>()
{
return(typeof(T).IsInterface
? InterfaceBuilder.CreateObject <T>()
: _dependencyInjectionContainer.GetInstance <T>());
}
public IBusService Create(IServiceBus bus, IObjectBuilder builder)
{
var ef = builder.GetInstance <IEndpointFactory>();
return(new RoutingService(_routes, ef));
}
