/// <summary> /// Handles a ScheduleMe that has expired from the Pending queue. If it is time to send the message, the message is published to the destination queue. /// If the time has not yet come, put the message back into the Pending queue with a new expiry time. /// </summary> /// <param name="message"></param> private void Evaluate(ScheduleMe message) { log.DebugWrite("Received message for publish at {0}", message.WakeTime); if (!bus.IsConnected) { return; } try { // If wake time is past, publish the message var timeToPublish = TimeToPublish(message); if (timeToPublish < 5000) { Publish(message); } else { // otherwise put it back on the pending queue ReQueue(message, timeToPublish); } } catch (Exception ex) { log.ErrorWrite(ex); } }
public void FuturePublish <T>(DateTime futurePublishDate, T message, string cancellationKey = null) where T : class { Preconditions.CheckNotNull(message, "message"); var scheduleMeType = typeof(ScheduleMe); var scheduleMeExchange = publishExchangeDeclareStrategy.DeclareExchange(advancedBus, scheduleMeType, ExchangeType.Topic); var baseMessageType = typeof(T); var concreteMessageType = message.GetType(); var serializedMessage = messageSerializationStrategy.SerializeMessage(new Message <T>(message) { Properties = { DeliveryMode = messageDeliveryModeStrategy.GetDeliveryMode(concreteMessageType) } }); var scheduleMe = new ScheduleMe { WakeTime = futurePublishDate, CancellationKey = cancellationKey, InnerMessage = serializedMessage.Body, MessageProperties = serializedMessage.Properties, BindingKey = typeNameSerializer.Serialize(typeof(T)), ExchangeType = ExchangeType.Topic, Exchange = conventions.ExchangeNamingConvention(baseMessageType), RoutingKey = "#" }; var easyNetQMessage = new Message <ScheduleMe>(scheduleMe) { Properties = { DeliveryMode = messageDeliveryModeStrategy.GetDeliveryMode(scheduleMeType) } }; advancedBus.Publish(scheduleMeExchange, conventions.TopicNamingConvention(scheduleMeType), false, easyNetQMessage); }
/// <summary> /// Send the message to the exchange it was ultimately destined for /// </summary> /// <param name="wrappedMessage"></param> private void Publish(ScheduleMe wrappedMessage) { try { var bindingKey = wrappedMessage.BindingKey; var message = wrappedMessage.InnerMessage; log.DebugWrite(string.Format( "Publishing message to '{0}'", bindingKey)); var exchange = bus.Advanced.ExchangeDeclare(bindingKey, ExchangeType.Topic); bus.Advanced.Publish( exchange, bindingKey, false, false, new MessageProperties { Type = bindingKey }, message); } catch (Exception ex) { log.ErrorWrite("Error in publish \r\n{0}", ex); } }
public Task FuturePublishAsync <T>(DateTime futurePublishDate, string cancellationKey, T message) where T : class { Preconditions.CheckNotNull(message, "message"); var messageType = typeof(ScheduleMe); return(publishExchangeDeclareStrategy.DeclareExchangeAsync(advancedBus, messageType, ExchangeType.Topic).Then(exchange => { var typeName = typeNameSerializer.Serialize(typeof(T)); var messageBody = serializer.MessageToBytes(message); var scheduleMe = new ScheduleMe { WakeTime = futurePublishDate, BindingKey = typeName, CancellationKey = cancellationKey, InnerMessage = messageBody }; var easyNetQMessage = new Message <ScheduleMe>(scheduleMe) { Properties = { DeliveryMode = messageDeliveryModeStrategy.GetDeliveryMode(messageType) } }; return advancedBus.PublishAsync(exchange, conventions.TopicNamingConvention(messageType), false, false, easyNetQMessage); })); }
public void Store(ScheduleMe scheduleMe) { WithStoredProcedureCommand(insertSql, command => { command.Parameters.AddWithValue("@WakeTime", scheduleMe.WakeTime); command.Parameters.AddWithValue("@BindingKey", scheduleMe.BindingKey); command.Parameters.AddWithValue("@Message", scheduleMe.InnerMessage); command.ExecuteNonQuery(); }); }
public void Store(ScheduleMe scheduleMe) { WithStoredProcedureCommand(dialect.InsertProcedureName, command => { AddParameter(command, dialect.WakeTimeParameterName, scheduleMe.WakeTime, DbType.DateTime); AddParameter(command, dialect.BindingKeyParameterName, scheduleMe.BindingKey, DbType.String); AddParameter(command, dialect.MessageParameterName, scheduleMe.InnerMessage, DbType.Binary); command.ExecuteNonQuery(); }); }
private void OnMessage(ScheduleMe message) { log.DebugWrite("Got Schedule Message"); scheduleRepository.Store(new Schedule { Id = Guid.NewGuid(), CancellationKey = message.CancellationKey, BindingKey = message.BindingKey, InnerMessage = message.InnerMessage, State = ScheduleState.Pending, WakeTime = message.WakeTime }); }
/// <summary> /// Returns a new expiry time span in milliseconds for the message. /// If the milliseconds exceeds Int32.MaxValue, returns MaxValue. /// If the expiry time is past, returns 0. /// </summary> /// <param name="message"></param> /// <returns></returns> private int TimeToPublish(ScheduleMe message) { TimeSpan expirySpan = message.WakeTime.Subtract(DateTime.Now); double expiry = expirySpan.TotalMilliseconds; if (expiry > Int32.MaxValue) { expiry = Int32.MaxValue; } if (expiry < 0) { expiry = 0; } return(Convert.ToInt32(expiry)); }
private void OnMessage(ScheduleMe message) { log.DebugWrite("Got Schedule Message"); scheduleRepository.Store(new Schedule { Id = Guid.NewGuid(), CancellationKey = message.CancellationKey, BindingKey = message.BindingKey, InnerMessage = message.InnerMessage, State = ScheduleState.Pending, WakeTime = message.WakeTime, Exchange = message.Exchange, ExchangeType = message.ExchangeType, RoutingKey = message.RoutingKey, BasicProperties = message.MessageProperties }); }
public void Store(ScheduleMe scheduleMe) { WithStoredProcedureCommand(dialect.InsertProcedureName, command => { AddParameter(command, dialect.WakeTimeParameterName, scheduleMe.WakeTime, DbType.DateTime); AddParameter(command, dialect.BindingKeyParameterName, scheduleMe.BindingKey, DbType.String); AddParameter(command, dialect.CancellationKeyParameterName, scheduleMe.CancellationKey, DbType.String); AddParameter(command, dialect.MessageParameterName, scheduleMe.InnerMessage, DbType.Binary); AddParameter(command, dialect.ExchangeParameterName, scheduleMe.Exchange, DbType.String); AddParameter(command, dialect.ExchangeTypeParameterName, scheduleMe.ExchangeType, DbType.String); AddParameter(command, dialect.RoutingKeyParameterName, scheduleMe.RoutingKey, DbType.String); AddParameter(command, dialect.MessagePropertiesParameterName, SerializeToString(scheduleMe.MessageProperties), DbType.String); AddParameter(command, dialect.InstanceNameParameterName, configuration.InstanceName, DbType.String); command.ExecuteNonQuery(); }); }
/// <summary> /// Put the message back into the ScheduleMe_Pending queue /// </summary> /// <param name="message"></param> /// <param name="queueFor"></param> private void ReQueue(ScheduleMe message, int expiry) { try { var advancedBus = bus.Advanced; var conventions = advancedBus.Container.Resolve <IConventions>(); var exchangeName = conventions.ExchangeNamingConvention(ScheduleMeType) + "_Pending"; IExchange exchange = advancedBus.ExchangeDeclare(exchangeName, ExchangeType.Topic); IMessage <ScheduleMe> newMessage = new Message <ScheduleMe>(message); newMessage.Properties.Expiration = expiry.ToString(); log.DebugWrite(string.Format("Requeuing message for {0}", FriendlyTimeSpan(expiry))); advancedBus.Publish(exchange, "#", false, false, newMessage); } catch (Exception ex) { log.ErrorWrite("Error in requeue \r\n{0}", ex); } }
public void OnMessage(ScheduleMe scheduleMe) { log.DebugWrite("Got Schedule Message"); scheduleRepository.Store(scheduleMe); }
public void Store(ScheduleMe scheduleMe) { throw new NotImplementedException(); }