/// <summary>
/// Sends a request to target with a JSON model, waits response
/// </summary>
public async Task <HorseResult <TResponse> > RequestJson <TResponse>(string target, ushort?contentType, object model,
IEnumerable <KeyValuePair <string, string> > messageHeaders = null)
{
TypeDeliveryDescriptor descriptor = _client.DeliveryContainer.GetDescriptor(model.GetType());
HorseMessage message = descriptor.CreateMessage(MessageType.DirectMessage, target, contentType);
message.Serialize(model, _client.JsonSerializer);
if (messageHeaders != null)
{
foreach (KeyValuePair <string, string> pair in messageHeaders)
{
message.AddHeader(pair.Key, pair.Value);
}
}
HorseMessage responseMessage = await _client.Request(message);
if (responseMessage.ContentType == 0)
{
TResponse response = responseMessage.Deserialize <TResponse>(_client.JsonSerializer);
return(new HorseResult <TResponse>(response, message, HorseResultCode.Ok));
}
return(new HorseResult <TResponse>(default, responseMessage, (HorseResultCode)responseMessage.ContentType));
/// <summary>
/// Pushes a message to a queue
/// </summary>
public async Task <HorseResult> PushJson(string queue, object jsonObject, string messageId, bool waitAcknowledge,
IEnumerable <KeyValuePair <string, string> > messageHeaders = null)
{
TypeDeliveryDescriptor descriptor = _client.DeliveryContainer.GetDescriptor(jsonObject.GetType());
HorseMessage message = descriptor.CreateMessage(MessageType.QueueMessage, queue, 0);
if (!string.IsNullOrEmpty(messageId))
{
message.SetMessageId(messageId);
}
message.WaitResponse = waitAcknowledge;
if (messageHeaders != null)
{
foreach (KeyValuePair <string, string> pair in messageHeaders)
{
message.AddHeader(pair.Key, pair.Value);
}
}
message.Serialize(jsonObject, _client.JsonSerializer);
if (string.IsNullOrEmpty(message.MessageId) && waitAcknowledge)
{
message.SetMessageId(_client.UniqueIdGenerator.Create());
}
return(await _client.WaitResponse(message, waitAcknowledge));
}
/// <summary>
/// Sends a JSON message by full name
/// </summary>
public async Task <HorseResult> SendJson <T>(T model, bool waitAcknowledge, IEnumerable <KeyValuePair <string, string> > messageHeaders = null)
{
TypeDeliveryDescriptor descriptor = _client.DeliveryContainer.GetDescriptor(model.GetType());
HorseMessage message = descriptor.CreateMessage(MessageType.DirectMessage, null, null);
if (string.IsNullOrEmpty(message.Target))
{
return(new HorseResult(HorseResultCode.SendError));
}
message.WaitResponse = waitAcknowledge;
message.Serialize(model, _client.JsonSerializer);
if (messageHeaders != null)
{
foreach (KeyValuePair <string, string> pair in messageHeaders)
{
message.AddHeader(pair.Key, pair.Value);
}
}
if (waitAcknowledge)
{
return(await _client.SendAndGetAck(message));
}
return(await _client.SendAsync(message));
}
/// <summary>
/// Publishes a JSON object to a router
/// </summary>
public async Task <HorseResult> PublishJson(string routerName,
object model,
string messageId = null,
bool waitForAcknowledge = false,
ushort?contentType = null,
IEnumerable <KeyValuePair <string, string> > messageHeaders = null)
{
TypeDeliveryDescriptor descriptor = _client.DeliveryContainer.GetDescriptor(model.GetType());
HorseMessage message = descriptor.CreateMessage(MessageType.Router, routerName, contentType);
if (!string.IsNullOrEmpty(messageId))
{
message.SetMessageId(messageId);
}
else
{
message.SetMessageId(_client.UniqueIdGenerator.Create());
}
message.WaitResponse = waitForAcknowledge;
message.Serialize(model, _client.JsonSerializer);
if (messageHeaders != null)
{
foreach (KeyValuePair <string, string> pair in messageHeaders)
{
message.AddHeader(pair.Key, pair.Value);
}
}
return(await _client.WaitResponse(message, waitForAcknowledge));
}
/// <summary>
/// Unsubscribe from direct messages
/// </summary>
public void OffDirect <T>()
{
TypeDeliveryDescriptor descriptor = _deliveryContainer.GetDescriptor <T>();
if (descriptor == null)
{
throw new ArgumentNullException("Can't resolve TypeDeliveryDescriptor. Use overload method On(ushort,T)");
}
if (!descriptor.ContentType.HasValue)
{
throw new NullReferenceException("Type doesn't have ContentTypeAttribute. Add that attribute to type or use overload method On(ushort,T)");
}
OffDirect(descriptor.ContentType.Value);
}
/// <summary>
/// Unsubscribe from messages of a queue
/// </summary>
public void Off <T>()
{
TypeDeliveryDescriptor descriptor = _deliveryContainer.GetDescriptor <T>();
if (descriptor == null)
{
throw new ArgumentNullException("Can't resolve TypeDeliveryDescriptor. Use overload method On(string,ushort,T)");
}
if (string.IsNullOrEmpty(descriptor.QueueName))
{
throw new NullReferenceException("Type doesn't have QueueNameAttribute. Add that attribute to type or use overload method On(string,ushort,T)");
}
Off(descriptor.QueueName);
}
/// <summary>
/// Finds target for consumer and model
/// </summary>
private Tuple <string, ushort> GetTarget(ReadSource source, TypeDeliveryDescriptor consumerDescriptor, TypeDeliveryDescriptor modelDescriptor)
{
ushort contentType = 0;
string target = null;
if (source == ReadSource.Queue)
{
if (consumerDescriptor.HasQueueName)
{
target = consumerDescriptor.QueueName;
}
else if (modelDescriptor.HasQueueName)
{
target = modelDescriptor.QueueName;
}
}
else
{
if (consumerDescriptor.HasContentType)
{
contentType = consumerDescriptor.ContentType ?? 0;
}
else if (modelDescriptor.HasContentType)
{
contentType = modelDescriptor.ContentType ?? 0;
}
if (consumerDescriptor.HasDirectReceiver)
{
target = consumerDescriptor.DirectTarget;
}
else if (modelDescriptor.HasDirectReceiver)
{
target = modelDescriptor.DirectTarget;
}
}
if (source == ReadSource.Queue && string.IsNullOrEmpty(target))
{
target = modelDescriptor.QueueName;
}
return(new Tuple <string, ushort>(target, contentType));
}
/// <summary>
/// Returns all subscribed queues
/// </summary>
public Tuple <string, TypeDeliveryDescriptor>[] GetSubscribedQueues()
{
List <Tuple <string, TypeDeliveryDescriptor> > queues = new List <Tuple <string, TypeDeliveryDescriptor> >();
lock (_subscriptions)
{
foreach (ReadSubscription subscription in _subscriptions)
{
if (subscription.Source != ReadSource.Queue)
{
continue;
}
TypeDeliveryDescriptor descriptor = _deliveryContainer.GetDescriptor(subscription.MessageType);
queues.Add(new Tuple <string, TypeDeliveryDescriptor>(subscription.Queue, descriptor));
}
}
return(queues.Distinct().ToArray());
}
private ReadSubscription CreateConsumerSubscription(ModelTypeInfo typeInfo, Func <IConsumerFactory> consumerFactoryBuilder)
{
bool useConsumerFactory = consumerFactoryBuilder != null;
TypeDeliveryResolver resolver = new TypeDeliveryResolver();
TypeDeliveryDescriptor consumerDescriptor = resolver.Resolve(typeInfo.ConsumerType, null);
TypeDeliveryDescriptor modelDescriptor = resolver.Resolve(typeInfo.ModelType, Configurator);
var target = GetTarget(typeInfo.Source, consumerDescriptor, modelDescriptor);
object consumerInstance = useConsumerFactory ? null : Activator.CreateInstance(typeInfo.ConsumerType);
ConsumerExecuter executer = null;
switch (typeInfo.Source)
{
case ReadSource.Queue:
{
Type executerType = typeof(QueueConsumerExecuter <>);
Type executerGenericType = executerType.MakeGenericType(typeInfo.ModelType);
executer = (ConsumerExecuter)Activator.CreateInstance(executerGenericType,
typeInfo.ConsumerType,
consumerInstance,
consumerFactoryBuilder);
break;
}
case ReadSource.Direct:
{
Type executerType = typeof(DirectConsumerExecuter <>);
Type executerGenericType = executerType.MakeGenericType(typeInfo.ModelType);
executer = (ConsumerExecuter)Activator.CreateInstance(executerGenericType,
typeInfo.ConsumerType,
consumerInstance,
consumerFactoryBuilder);
break;
}
case ReadSource.Request:
{
Type executerType = typeof(RequestHandlerExecuter <,>);
Type executerGenericType = executerType.MakeGenericType(typeInfo.ModelType, typeInfo.ResponseType);
executer = (ConsumerExecuter)Activator.CreateInstance(executerGenericType,
typeInfo.ConsumerType,
consumerInstance,
consumerFactoryBuilder);
break;
}
}
if (executer != null)
{
executer.Resolve(Configurator);
}
ReadSubscription subscription = new ReadSubscription
{
Source = typeInfo.Source,
Queue = target.Item1,
ContentType = target.Item2,
MessageType = typeInfo.ModelType,
ResponseType = typeInfo.ResponseType,
Action = null,
ConsumerExecuter = executer
};
return(subscription);
}
