Esempio n. 1
0
        /// <summary>
        /// Publishes the specified events to the current event bus provider.
        /// </summary>
        /// <returns>The unique id of the queue item.</returns>
        public static Task <IEnumerable <string> > PublishBatch(this IEventBusQueue queue, IEnumerable <IEventBusMessage> messages)
        {
            var stringMessegas = new List <string>();

            messages.Do(message => stringMessegas.Add(JsonConvert.SerializeObject(message)));

            return(queue.PublishBatch(stringMessegas));
        }
Esempio n. 2
0
        /// <summary>
        /// Pulls a single item from the specified queue, or null if nothing was available.
        /// After completing the message processing, you must call Complete().
        /// </summary>
        public static async Task <QueueMessageHandle <TMessage> > Pull <TMessage>(this IEventBusQueue queue, int timeoutSeconds = 10)
            where TMessage : IEventBusMessage
        {
            var item = await queue.Pull(timeoutSeconds);

            if (item == null)
            {
                return(null);
            }

            return(item.As <TMessage>());
        }
Esempio n. 3
0
 public static Task PullAll <TMessage>(this IEventBusQueue queue, Func <TMessage, Task> @handler)
     where TMessage : IEventBusMessage
 {
     return(queue.PullAll(message =>
     {
         if (message.IsEmpty())
         {
             return Task.CompletedTask;
         }
         try
         {
             var @event = JsonConvert.DeserializeObject <TMessage>(message);
             return handler(@event);
         }
         catch (Exception ex)
         {
             throw new Exception("Failed to deserialize event message to " + typeof(TMessage).FullName + ":\r\n" + message, ex);
         }
     }));
 }
Esempio n. 4
0
        /// <summary>
        /// Pulls a single item from the specified queue, or null if nothing was available.
        /// After completing the message processing, you must call Complete().
        /// </summary>
        public static async Task <QueueMessageHandle <TMessage> > Pull <TMessage>(this IEventBusQueue queue, int timeoutSeconds = 10)
            where TMessage : IEventBusMessage
        {
            var item = await queue.Pull(timeoutSeconds);

            if (item == null || item.RawMessage.IsEmpty())
            {
                return(null);
            }

            try
            {
                var message = JsonConvert.DeserializeObject <TMessage>(item.RawMessage);
                return(new QueueMessageHandle <TMessage>(item.RawMessage, item.MessageId, message, () => item.Complete()));
            }
            catch (Exception ex)
            {
                throw new Exception("Failed to deserialize event message to " + typeof(TMessage).FullName + ":\r\n" + item.RawMessage, ex);
            }
        }
Esempio n. 5
0
        /// <summary>
        /// Publishes the specified event to the current event bus provider.
        /// </summary>
        /// <returns>The unique id of the queue item.</returns>
        public static Task <string> Publish(this IEventBusQueue queue, IEventBusMessage message)
        {
            var textMessage = JsonConvert.SerializeObject(message);

            return(queue.Publish(textMessage));
        }
Esempio n. 6
0
 protected DestinationEndpoint(Assembly domainAssembly)
 {
     DomainAssembly = domainAssembly;
     PublishQueue   = EventBus.Queue(QueueUrl);
     RefreshQueue   = EventBus.Queue(QueueUrl.TrimEnd(".fifo") + "-REFRESH.fifo");
 }
Esempio n. 7
0
 public EventBusQueue(IEventBusQueue queue) => Queue = queue;