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 GraphModel(IDependencyParserStrategy dps, ISerializationStrategy iss, List<Node> nodes)
{
mDependencyParserStrategy = dps;
mSerializationStrategy = iss;
_nodeIdentifierDict = new Dictionary<Node, int>();
_nodeIdentifierReverseDict = new Dictionary<int, Node>();
_dependencyList = new List<object>();
int i = 0;
foreach (Node n in nodes)
{
_nodeIdentifierDict.Add(n, i);
_nodeIdentifierReverseDict.Add(i++, n);
object dependency = mDependencyParserStrategy.ParseDependencies(((IModule)n.ParentModule).GetDependencyObject());
if(dependency != null && !_dependencyList.Exists(elem => elem.Equals(dependency)))
_dependencyList.Add(dependency);
}
_nodeConnections = new List<NodeConnection>();
foreach (Node node in nodes)
{
foreach (NodeConnection conn in node.Connections)
{
if (!_nodeConnections.Contains(conn))
_nodeConnections.Add(conn);
}
}
}
void PublishMessage <TRequestMessage, TReplyMessage>(TRequestMessage message, MessageProperties messageProperties,
Action <IMessageContext <TReplyMessage> > replyAction,
TimeSpan timeout)
{
PublishMessage(message, messageProperties, (p, pi) =>
{
IConsumeInfo replyInfo = pi.ReplyInfo;
string queueName = Guid.NewGuid().ToString();
p.ReplyTo = new PublicationAddress(replyInfo.ExchangeType, "", queueName).ToString();
p.CorrelationId = Guid.NewGuid().ToString();
ISerializationStrategy serializationStrategy = pi.SerializationStrategy ?? _defaultSerializationStrategy;
IConsumeInfo consumeInfo = CloneConsumeInfo(replyInfo);
consumeInfo.ExchangeName = "";
consumeInfo.QueueName = queueName;
consumeInfo.IsQueueExclusive = true;
new Subscription <TReplyMessage>(_connection,
_defaultDeadLetterConfiguration,
serializationStrategy,
consumeInfo,
queueName /* routing key */,
replyAction,
null,
x => { },
this,
SubscriptionType.RemoteProcedure,
timeout).Start();
});
}
public void PublishReply <TRequestMessage, TReplyMessage>(PublicationAddress publicationAddress,
TReplyMessage replyMessage,
IBasicProperties replyProperties)
{
IModel channel = _connection.CreateModel();
if (publicationAddress.ExchangeName != string.Empty)
{
channel.ExchangeDeclare(publicationAddress.ExchangeName, publicationAddress.ExchangeType, false, true, null);
}
IConsumeInfo consumeInfo = _consumeRouteConfiguration.GetRouteInfo(typeof(TRequestMessage));
ISerializationStrategy serializationStrategy = consumeInfo.SerializationStrategy ?? _defaultSerializationStrategy;
byte[] bytes = serializationStrategy.Serialize(replyMessage);
channel.BasicPublish(publicationAddress, replyProperties, bytes);
channel.Close();
string log = string.Format("Published reply message to host: {0}, port: {1}, exchange: {2}, routingKey: {3}",
_connection.Endpoint.HostName,
_connection.Endpoint.Port,
publicationAddress.ExchangeName,
publicationAddress.RoutingKey);
Logger.Current.Write(log, TraceEventType.Information);
}
public ConsumerContext(IConnection connection, IConsumeInfo consumeInfo,
ISerializationStrategy defaultSerializationStrategy, IMessagePublisher messagePublisher)
{
_consumeInfo = consumeInfo;
_defaultSerializationStrategy = defaultSerializationStrategy;
_messagePublisher = messagePublisher;
_channel = connection.CreateModel();
Logger.Current.Write(string.Format("Declaring exchange:\'{0}\' durable:{1} auto-delete:{2}",
consumeInfo.ExchangeName,
consumeInfo.IsExchangeDurable.ToString(CultureInfo.InvariantCulture),
consumeInfo.IsExchangeAutoDelete.ToString(CultureInfo.InvariantCulture)),
TraceEventType.Information);
_channel.ExchangeDeclare(consumeInfo.ExchangeName, consumeInfo.ExchangeType, consumeInfo.IsExchangeDurable,
consumeInfo.IsExchangeAutoDelete, null);
Logger.Current.Write(string.Format("Declaring queue:\'{0}\' durable:{1} auto-delete:{2}",
consumeInfo.QueueName,
consumeInfo.IsQueueDurable.ToString(CultureInfo.InvariantCulture),
consumeInfo.IsQueueAutoDelete.ToString(CultureInfo.InvariantCulture)),
TraceEventType.Information);
_channel.QueueDeclare(consumeInfo.QueueName, consumeInfo.IsQueueDurable, consumeInfo.IsQueueExclusive,
consumeInfo.IsQueueAutoDelete, null);
Logger.Current.Write(
string.Format("Binding queue \'{0}\' to exchange \'{1}\'", consumeInfo.QueueName, consumeInfo.ExchangeName),
TraceEventType.Information);
_channel.QueueBind(consumeInfo.QueueName, consumeInfo.ExchangeName, consumeInfo.DefaultRoutingKey);
}
static ConsumeInfo GetConsumeInfo(Type type, IConsumeConfigurationConvention convention)
{
var consumeInfo = new ConsumeInfo
{
ExchangeName = convention.GetExchangeName(type),
ExchangeType = convention.GetExchangeType(type),
QueueName = convention.GetQueueName(type),
IsAutoAcknowledge = convention.IsAutoAcknowledge(type),
DefaultRoutingKey = convention.GetDefaultRouteKey(type),
IsQueueExclusive = convention.IsExclusive(type),
IsExchangeAutoDelete = convention.IsAutoDeleteExchange(type),
IsExchangeDurable = convention.IsDurableExchange(type),
IsQueueAutoDelete = convention.IsAutoDeleteQueue(type),
IsQueueDurable = convention.IsDurableQueue(type),
QualityOfService = convention.GetQualityOfService(type),
DeadLetterConfiguration = convention.GetDeadLetterConfiguration(type)
};
ISerializationStrategy serializationStrategy = convention.GetSerializationStrategy(type);
if (serializationStrategy != null)
{
consumeInfo.SerializationStrategy = serializationStrategy;
}
Action <IErrorContext> errorCallback = convention.GetErrorCallback(type);
if (errorCallback != null)
{
consumeInfo.ErrorCallback = errorCallback;
}
return(consumeInfo);
}
public GraphModel(IDependencyParserStrategy dps, ISerializationStrategy iss, List <Node> nodes)
{
mDependencyParserStrategy = dps;
mSerializationStrategy = iss;
_nodeIdentifierDict = new Dictionary <Node, int>();
_nodeIdentifierReverseDict = new Dictionary <int, Node>();
_dependencyList = new List <object>();
int i = 0;
foreach (Node n in nodes)
{
_nodeIdentifierDict.Add(n, i);
_nodeIdentifierReverseDict.Add(i++, n);
object dependency = mDependencyParserStrategy.ParseDependencies(((IModule)n.ParentModule).GetDependencyObject());
if (dependency != null && !_dependencyList.Exists(elem => elem.Equals(dependency)))
{
_dependencyList.Add(dependency);
}
}
_nodeConnections = new List <NodeConnection>();
foreach (Node node in nodes)
{
foreach (NodeConnection conn in node.Connections)
{
if (!_nodeConnections.Contains(conn))
{
_nodeConnections.Add(conn);
}
}
}
}
/// <summary>
/// Deserializes an object from an assembly manifest resource.
/// </summary>
/// <typeparam name="TObject"> The run-time type of the object root to deserialize. </typeparam>
/// <param name="serializationStrategy"> The serialization strategy. </param>
/// <param name="resourceType"> A type within the source assembly where the manifest resource lives. </param>
/// <param name="resourceName"> The fully qualified manifest resource name to load. </param>
/// <param name="result"> A valid object of the specified type or null if the manifest resource name was not found in the assembly of the resource type. </param>
/// <returns> A value indicating whether the manifest resource name was found in the target type's assembly. </returns>
public static bool TryGetFromAssemblyResource <TObject>(this ISerializationStrategy serializationStrategy, Type resourceType, string resourceName, out TObject result)
{
Type targetType;
bool retval;
if ((object)serializationStrategy == null)
{
throw new ArgumentNullException(nameof(serializationStrategy));
}
if ((object)resourceType == null)
{
throw new ArgumentNullException(nameof(resourceType));
}
if ((object)resourceName == null)
{
throw new ArgumentNullException(nameof(resourceName));
}
result = default(TObject);
targetType = typeof(TObject);
using (Stream stream = resourceType.GetTypeInfo().Assembly.GetManifestResourceStream(resourceName))
{
if (retval = ((object)stream != null))
{
result = (TObject)serializationStrategy.GetObjectFromStream(stream, targetType);
}
}
return(retval);
}
public ObjectResolver(string objectId, string collectionId, IPersistenceStrategy persistenceStrategy,
ISerializationStrategy serializationStrategy,
IObjectDeserializationErrorHandlingStrategy objectDeserializationErrorHandlingStrategy)
{
if (objectId == null)
{
throw new ArgumentNullException(nameof(objectId));
}
if (collectionId == null)
{
throw new ArgumentNullException(nameof(collectionId));
}
if (persistenceStrategy == null)
{
throw new ArgumentNullException(nameof(persistenceStrategy));
}
if (serializationStrategy == null)
{
throw new ArgumentNullException(nameof(serializationStrategy));
}
if (objectDeserializationErrorHandlingStrategy == null)
{
throw new ArgumentNullException(nameof(objectDeserializationErrorHandlingStrategy));
}
this.objectId = objectId;
this.collectionId = collectionId;
this.persistenceStrategy = persistenceStrategy;
this.serializationStrategy = serializationStrategy;
this.objectDeserializationErrorHandlingStrategy = objectDeserializationErrorHandlingStrategy;
}
internal PersistentCollection(string collectionId, IPersistenceStrategy persistenceStrategy,
ISerializationStrategy serializationStrategy,
IObjectDeserializationErrorHandlingStrategy deserializationErrorHandlingStrategy)
{
this.collectionId = collectionId;
this.persistenceStrategy = persistenceStrategy;
this.serializationStrategy = serializationStrategy;
this.deserializationErrorHandlingStrategy = deserializationErrorHandlingStrategy;
}
void PublishMessage(object message, MessageProperties messageProperties,
Action <IBasicProperties, IPublishInfo> replyAction)
{
IPublishInfo publishInfo = _publishRouteConfiguration.GetRouteInfo(message.GetType());
IModel channel = _connection.CreateModel();
channel.ExchangeDeclare(publishInfo.ExchangeName, publishInfo.ExchangeType,
publishInfo.IsDurable,
publishInfo.IsAutoDelete, null);
ISerializationStrategy serializationStrategy = publishInfo.SerializationStrategy ?? _defaultSerializationStrategy;
byte[] bytes = serializationStrategy.Serialize(message);
var properties = new BasicProperties();
ListDictionary messageHeaders = GetHeaders(messageProperties.Headers, publishInfo.DefaultHeaders);
if (messageHeaders.Count != 0)
{
properties.Headers = messageHeaders;
}
properties.SetPersistent(publishInfo.IsPersistent);
properties.ContentType = serializationStrategy.ContentType;
properties.ContentEncoding = serializationStrategy.ContentEncoding;
if (publishInfo.IsSigned)
{
properties.UserId = _userName;
}
properties.CorrelationId = Guid.NewGuid().ToString();
if (messageProperties.Expiration.HasValue)
{
properties.Expiration = messageProperties.Expiration.Value.TotalMilliseconds.ToString();
}
else if (publishInfo.Expiration.HasValue)
{
properties.Expiration = publishInfo.Expiration.Value.TotalMilliseconds.ToString();
}
if (replyAction != null)
{
replyAction(properties, publishInfo);
}
channel.BasicPublish(publishInfo.ExchangeName, messageProperties.RoutingKey ?? publishInfo.DefaultRoutingKey,
properties, bytes);
channel.Close();
string log = string.Format("Published message to host: {0}, port: {1}, exchange: {2}, routingKey: {3}",
_connection.Endpoint.HostName,
_connection.Endpoint.Port,
publishInfo.ExchangeName,
messageProperties.RoutingKey);
Logger.Current.Write(log, TraceEventType.Information);
}
public GraphModel(IDependencyParserStrategy dps, ISerializationStrategy iss)
{
_nodeIdentifierDict = new Dictionary <Node, int>();
_nodeIdentifierReverseDict = new Dictionary <int, Node>();
_nodeConnections = new List <NodeConnection>();
_dependencyList = new List <object>();
mDependencyParserStrategy = dps;
mSerializationStrategy = iss;
}
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));
}
public static string Serialize <T>(this T obj, ISerializationStrategy serializationStrategy) where T : class
{
if (typeof(T) == typeof(String))
{
return(obj as string);
}
return(serializationStrategy.Serialize(obj));
}
public GraphModel(IDependencyParserStrategy dps, ISerializationStrategy iss)
{
_nodeIdentifierDict = new Dictionary<Node, int>();
_nodeIdentifierReverseDict = new Dictionary<int, Node>();
_nodeConnections = new List<NodeConnection>();
_dependencyList = new List<object>();
mDependencyParserStrategy = dps;
mSerializationStrategy = iss;
}
public GraphModel(IDependencyParserStrategy dps, ISerializationStrategy iss, string file)
{
mDependencyParserStrategy = dps;
mSerializationStrategy = iss;
_nodeIdentifierDict = new Dictionary <Node, int>();
_nodeIdentifierReverseDict = new Dictionary <int, Node>();
_nodeConnections = new List <NodeConnection>();
iss.DeserializeFile(file, ref _nodeIdentifierDict, ref _nodeIdentifierReverseDict, ref _nodeConnections);
}
public void Publish <TMessage>(TMessage message, string routingKey, ISerializationStrategy serializationStrategy)
{
Console.WriteLine(
string.Format("Publishing message to exchange:\'{0}\' routing key:\'{1}\'", _exchangeName, routingKey),
TraceEventType.Information);
byte[] msg = serializationStrategy.Serialize(message);
var properties = new BasicProperties();
properties.Timestamp = new AmqpTimestamp((long)(DateTime.Now - _unixEpoch).TotalSeconds);
_channel.BasicPublish(_exchangeName, routingKey, properties, msg);
}
public GraphModel(IDependencyParserStrategy dps, ISerializationStrategy iss, string file)
{
mDependencyParserStrategy = dps;
mSerializationStrategy = iss;
_nodeIdentifierDict = new Dictionary<Node, int>();
_nodeIdentifierReverseDict = new Dictionary<int, Node>();
_nodeConnections = new List<NodeConnection>();
iss.DeserializeFile(file, ref _nodeIdentifierDict, ref _nodeIdentifierReverseDict, ref _nodeConnections);
}
public PersistenceManager([NotNull] PersistenceManagerConfig config,
ISerializationStrategy serializationStrategy, IPersistenceStrategy persistenceStrategy)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
this.config = config;
SerializationStrategy = serializationStrategy;
PersistenceStrategy = persistenceStrategy;
}
public MessagePublisher(string userName,
IRouteConfiguration <IPublishInfo> publishRouteConfiguration,
IRouteConfiguration <IConsumeInfo> consumeRouteConfiguration,
ISerializationStrategy defaultSerializationStrategy,
IQueueStrategy queueStrategy)
{
_userName = userName;
_publishRouteConfiguration = publishRouteConfiguration;
_consumeRouteConfiguration = consumeRouteConfiguration;
_defaultSerializationStrategy = defaultSerializationStrategy;
_queueStrategy = queueStrategy;
}
public PersistentCollectionsLibrary(IPersistenceStrategy persistenceStrategy,
IObjectDeserializationErrorHandlingStrategy deserializationErrorHandlingStrategy = null)
{
if (persistenceStrategy == null) throw new ArgumentNullException("persistenceStrategy");
this.persistenceStrategy = persistenceStrategy;
if (deserializationErrorHandlingStrategy == null)
{
this.deserializationErrorHandlingStrategy = new DefaultObjectDeserializationErrorHandlingStrategy();
}
else
{
this.deserializationErrorHandlingStrategy = deserializationErrorHandlingStrategy;
}
serializationStrategy = new JsonSerializationStrategy();
}
// 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 Subscription(IConnection connection, IDeadLetterStrategy deadLetterStrategy,
ISerializationStrategy defaultSerializationStrategy, IConsumeInfo consumeInfo,
string routingKey,
Action <IMessageContext <TMessage> > callback, IDictionary exchangeArguments,
Action <IErrorContext> defaultErrorCallback, IMessagePublisher messagePublisher,
SubscriptionType subscriptionType, TimeSpan callbackTimeout)
{
_connection = connection;
_deadLetterStrategy = deadLetterStrategy;
_defaultSerializationStrategy = defaultSerializationStrategy;
_consumeInfo = consumeInfo;
_routingKey = routingKey ?? _consumeInfo.DefaultRoutingKey;
_callback = callback;
_defaultErrorCallback = defaultErrorCallback;
_messagePublisher = messagePublisher;
_subscriptionType = subscriptionType;
_callbackTimeout = callbackTimeout;
_exchangeArguments = exchangeArguments;
}
public PersistentCollectionsLibrary(IPersistenceStrategy persistenceStrategy,
IObjectDeserializationErrorHandlingStrategy deserializationErrorHandlingStrategy = null)
{
if (persistenceStrategy == null)
{
throw new ArgumentNullException(nameof(persistenceStrategy));
}
this.persistenceStrategy = persistenceStrategy;
if (deserializationErrorHandlingStrategy == null)
{
this.deserializationErrorHandlingStrategy = new DefaultObjectDeserializationErrorHandlingStrategy();
}
else
{
this.deserializationErrorHandlingStrategy = deserializationErrorHandlingStrategy;
}
serializationStrategy = new JsonSerializationStrategy();
}
static PublishInfo GetPublishInfo(Type type, IPublishConfigurationConvention convention)
{
var publishInfo = new PublishInfo
{
ExchangeName = convention.GetExchangeName(type),
IsAutoDelete = convention.IsAutoDeleteExchange(type),
IsDurable = convention.IsDurableExchange(type),
IsPersistent = convention.IsPersistent(type),
ExchangeType = convention.GetExchangeType(type),
DefaultRoutingKey = convention.GetDefaultRouteKey(type),
IsSigned = convention.IsSigned(type)
};
ISerializationStrategy serializationStrategy = convention.GetSerializationStrategy(type);
if (serializationStrategy != null)
{
publishInfo.SerializationStrategy = serializationStrategy;
}
return(publishInfo);
}
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);
}
public IConsumeConfigurationContext WithSerializationStrategy(ISerializationStrategy serializationStrategy)
{
ConsumeInfo.SerializationStrategy = serializationStrategy;
return(this);
}
public IPublishConfigurationContext WithSerializationStrategy(ISerializationStrategy serializationStrategy)
{
PublishInfo.SerializationStrategy = serializationStrategy;
return(this);
}
public IConsumeConfigurationContext WithSerializationStrategy(ISerializationStrategy serializationStrategy)
{
ConsumeInfo.SerializationStrategy = serializationStrategy;
return this;
}
internal abstract string GetSerializedData(ISerializationStrategy serializationStrategy);
public TMessage GetMessage <TMessage>(ISerializationStrategy serializationStrategy)
where TMessage : class
{
return(GetMessage <TMessage>(serializationStrategy, true));
}
internal abstract string GetSerializedData(ISerializationStrategy serializationStrategy);
public IConfigurationContext WithDefaultSerializationStrategy(ISerializationStrategy serializationStrategy)
{
ConfigurationModel.DefaultSerializationStrategy = serializationStrategy;
return(this);
}
public void SetStrategy(ISerializationStrategy strategy) => this.strategy = strategy;
public PackageManager(ISerializationStrategy serializationStrategy, ICompressionStrategy compressionStrategy)
{
_serializationStrategy = serializationStrategy;
_compressionStrategy = compressionStrategy;
}
public IPublishConfigurationContext WithSerializationStrategy(ISerializationStrategy serializationStrategy)
{
PublishInfo.SerializationStrategy = serializationStrategy;
return this;
}
