public TMessage GetMessage <TMessage>(ISerializationStrategy serializationStrategy, bool retry)
where TMessage : class
{
TMessage message = default(TMessage);
if (!retry)
{
Console.WriteLine("Getting message ...");
BasicGetResult args = _channel.BasicGet(_queueName, true);
if (args != null)
{
message = new BinarySerializationStrategy().Deserialize <TMessage>(args.Body);
}
return(message);
}
new Action(() =>
{
try
{
var consumer = new QueueingBasicConsumer(_channel);
Console.WriteLine("Consuming messages ...");
_channel.BasicConsume(_queueName, true, "", null, consumer);
var args = (BasicDeliverEventArgs)consumer.Queue.Dequeue();
message = serializationStrategy.Deserialize <TMessage>(args.Body);
}
catch (EndOfStreamException)
{
}
}).Background().BlockUntil(() => message != null)();
return(message);
}
public static T Deserialize <T>(this string serializedValue, ISerializationStrategy serializationStrategy) where T : class
{
if (typeof(T) == typeof(String))
{
return(serializedValue as T);
}
return((T)serializationStrategy.Deserialize(typeof(T), serializedValue));
}
// I do have dependecy in my project on JSON.Net, but who said, that I can't abstract using it, so I could change serializer without having to modify code, that depends on serialization/deserialiation
protected async Task <T> Get <T>(string endpoint, ISerializationStrategy <T> serializationStrategy)
{
string responseBody = null;
HttpResponseMessage response = await this.HttpClient.GetAsync(endpoint);
if (response.IsSuccessStatusCode)
{
responseBody = await response.Content.ReadAsStringAsync();
T result = serializationStrategy.Deserialize(responseBody);
return(result);
}
return(default(T));
}
public IMessageContext <TMessage> GetMessage()
{
Logger.Current.Write(string.Format("Pulling message from queue:\'{0}\' auto-acknowledge:{1}",
_consumeInfo.QueueName, _consumeInfo.IsAutoAcknowledge), TraceEventType.Information);
IMessageContext <TMessage> messageContext = null;
BasicGetResult result = _channel.BasicGet(_consumeInfo.QueueName, _consumeInfo.IsAutoAcknowledge);
if (result != null)
{
ISerializationStrategy serializationStrategy = _consumeInfo.SerializationStrategy ?? _defaultSerializationStrategy;
object message = serializationStrategy.Deserialize <TMessage>(result.Body);
messageContext = new MessageContext <TMessage>(_deadLetterStrategy, (TMessage)message, _consumeInfo, _channel, result.DeliveryTag,
result.Redelivered, result.Exchange, result.RoutingKey,
result.BasicProperties, result.Body, _messagePublisher);
}
return(messageContext);
}
public IBasicProperties GetMessageProperties <TMessage>(ISerializationStrategy serializationStrategy)
where TMessage : class
{
TMessage message = default(TMessage);
BasicDeliverEventArgs args = null;
new Action(() =>
{
try
{
var consumer = new QueueingBasicConsumer(_channel);
_channel.BasicConsume(_queueName, true, "", null, consumer);
args = (BasicDeliverEventArgs)consumer.Queue.Dequeue();
message = serializationStrategy.Deserialize <TMessage>(args.Body);
}
catch (EndOfStreamException)
{
}
}).Background().BlockUntil(() => message != null).Then(() => _channel.Close())();
return(args.BasicProperties);
}
void Subscribe(IModel channel)
{
ILogger logger = Logger.Current;
_stopwatch.Start();
string log =
string.Format(
"Starting thread for subscription to messages from host: {0}, port: {1}, exchange: {2}, queue: {3}, routingKey: {4}",
_connection.Endpoint.HostName,
_connection.Endpoint.Port,
_consumeInfo.ExchangeName,
_consumeInfo.QueueName,
_routingKey);
logger.Write(log, TraceEventType.Information);
while (true)
{
if (WaitExceeded() || _threadCancelled)
{
break;
}
BasicDeliverEventArgs eventArgs = null;
try
{
object eArgs = null;
_consumer.Queue.Dequeue(1000, out eArgs);
if (eArgs != null)
{
eventArgs = (BasicDeliverEventArgs)eArgs;
logger.Write(string.Format("Message received: {0} bytes", eventArgs.Body.Length), TraceEventType.Information);
ISerializationStrategy serializationStrategy = _consumeInfo.SerializationStrategy ??
_defaultSerializationStrategy;
object message = serializationStrategy.Deserialize <TMessage>(eventArgs.Body);
var messageContext = new MessageContext <TMessage>(_deadLetterStrategy, (TMessage)message,
_consumeInfo,
channel,
eventArgs.DeliveryTag, eventArgs.Redelivered,
eventArgs.Exchange, eventArgs.RoutingKey,
eventArgs.BasicProperties, eventArgs.Body,
_messagePublisher);
_callback(messageContext);
if (_subscriptionType == SubscriptionType.RemoteProcedure)
{
log =
string.Format(
"Terminating RPC subscription to messages from host: {0}, port: {1}, exchange: {2}, queue: {3}, routingKey: {4}",
_connection.Endpoint.HostName,
_connection.Endpoint.Port,
_consumeInfo.ExchangeName,
_consumeInfo.QueueName,
_routingKey);
logger.Write(log, TraceEventType.Information);
break;
}
}
}
catch (EndOfStreamException)
{
logger.Write("Received EndOfStreamException.", TraceEventType.Information);
InvokeErrorCallback(eventArgs, channel);
channel.Dispose();
channel = null;
logger.Write("Subscription terminated.", TraceEventType.Information);
break;
}
catch (AlreadyClosedException e)
{
Logger.Current.Write(string.Format("An AlreadyClosedException occurred: {0} {1}", e.Message, e.StackTrace), TraceEventType.Error);
InvokeErrorCallback(eventArgs, channel);
break;
}
catch (Exception e)
{
Logger.Current.Write("An exception occurred while dequeuing a message: " + e.Message, TraceEventType.Error);
InvokeErrorCallback(eventArgs, channel);
}
}
}
public string Deserialize(string data)
{
return(_serializationStrategy.Deserialize(data));
}
public Persistent <TEntity> GetObject()
{
var o = new Persistent <TEntity>(objectId);
var data = persistenceStrategy.TryLoad(objectId, collectionId);
if (data == null)
{
// data does not exist, return new with default
return(o);
}
try
{
o.Entity = serializationStrategy.Deserialize <TEntity>(data);
}
catch (DeserializationErrorsException <TEntity> exception)
{
var errorContext = new ErrorContext(exception.Errors, persistenceStrategy, collectionId,
objectId);
objectDeserializationErrorHandlingStrategy.Handle(errorContext);
if (errorContext.Decision == Decision.DoNotIgnoreAndRethrowTheException)
{
throw;
}
else if (errorContext.Decision == Decision.IgnoreErrorsAndReturnDefaultsForMissingData)
{
o.Entity = exception.DeserializedFallbackEntity;
return(o);
}
else if (errorContext.Decision == Decision.RetryDeserialization)
{
throw new RetryException();
}
else
{
throw new InvalidOperationException("Unknown Decision: " + errorContext.Decision);
}
}
if (o.Entity.ObjectId != objectId)
{
var errorContext = new ErrorContext(
new[]
{
new DeserializationErrorDetails()
{
DeserializationErrorKind = DeserializationErrorKind.ObjectIdMismatch
}
},
persistenceStrategy, collectionId, objectId);
objectDeserializationErrorHandlingStrategy.Handle(errorContext);
if (errorContext.Decision == Decision.DoNotIgnoreAndRethrowTheException)
{
throw new InvalidOperationException(
string.Format(
"Deserialized entity objectId {0} is different than requested objectId {1}",
o.Entity.ObjectId, objectId));
}
else if (errorContext.Decision == Decision.IgnoreErrorsAndReturnDefaultsForMissingData)
{
o.Entity.ObjectId = objectId;
}
else if (errorContext.Decision == Decision.RetryDeserialization)
{
throw new RetryException();
}
else
{
throw new InvalidOperationException("Unknown Decision: " + errorContext.Decision);
}
}
return(o);
}