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)); }
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; }