/// <summary>
/// Sends a new message to an existing queue
/// </summary>
/// <param name="messageToSend">The message to send.</param>
/// <param name="data">The additional data.</param>
/// <returns></returns>
public IQueueOutputMessage Send(IMessage messageToSend, IAdditionalMessageData data)
{
using (IScope scope = _tracer.BuildSpan("SendMessage").StartActive(finishSpanOnDispose: true))
{
scope.Span.AddCommonTags(data, _connectionInformation);
scope.Span.Add(data);
scope.Span.SetTag("IsBatch", false);
messageToSend.Inject(_tracer, scope.Span.Context, _headers.StandardHeaders);
try
{
var outputMessage = _handler.Send(messageToSend, data);
if (outputMessage.HasError)
{
Tags.Error.Set(scope.Span, true);
if (outputMessage.SendingException != null)
{
scope.Span.Log(outputMessage.SendingException.ToString());
}
}
scope.Span.AddMessageIdTag(outputMessage.SentMessage.MessageId);
return(outputMessage);
}
catch (Exception e)
{
Tags.Error.Set(scope.Span, true);
scope.Span.Log(e.ToString());
throw;
}
}
}
/// <summary>
/// Sends the specified message.
/// </summary>
/// <param name="messageToSend">The message to send.</param>
/// <param name="data">The data.</param>
/// <returns></returns>
/// <exception cref="DotNetWorkQueueException">An error occurred while sending a message</exception>
public IQueueOutputMessage Send(IMessage messageToSend, IAdditionalMessageData data)
{
try
{
//TODO - temp - fail all messages with routes, as they are not supported yet
if (!string.IsNullOrEmpty(data.Route))
{
throw new NotImplementedException("Redis transport does not yet support routes");
}
//correlationID must be stored as a message header
messageToSend.SetHeader(_headers.CorelationId, new RedisQueueCorrelationIdSerialized((Guid)data.CorrelationId.Id.Value));
var messageId = _sendMessage.Handle(new SendMessageCommand(messageToSend, data));
if (messageId == "JobAlreadyExists")
{
return new QueueOutputMessage(_sentMessageFactory.Create(null, data.CorrelationId), new DotNetWorkQueueException("Failed to enqueue a record. The job already exists"));
}
return new QueueOutputMessage(_sentMessageFactory.Create(new RedisQueueId(messageId), data.CorrelationId));
}
catch (Exception exception)
{
return new QueueOutputMessage(_sentMessageFactory.Create(null, data.CorrelationId), exception);
}
}
/// <inheritdoc />
public IQueueOutputMessage Send(LinqExpressionToRun linqExpression, IAdditionalMessageData data = null)
{
var message = new MessageExpression(MessageExpressionPayloads.ActionText,
_compositeSerialization.InternalSerializer.ConvertToBytes(linqExpression));
return(_queue.Send(message, data));
}
/// <inheritdoc />
public async Task <Guid> SendMessageAsync(IMessage messageToSend, IAdditionalMessageData data)
{
using (var scope = _tracer.StartActivity("SendMessage"))
{
scope?.AddCommonTags(data, _connectionInformation);
if (scope?.Context != null)
{
messageToSend.Inject(_tracer, scope.Context, _headers.StandardHeaders);
}
try
{
var id = await _handler.SendMessageAsync(messageToSend, data).ConfigureAwait(false);
if (id == Guid.Empty)
{
scope?.SetStatus(Status.Error);
}
;
scope?.AddMessageIdTag(id.ToString());
return(id);
}
catch (Exception e)
{
scope?.SetStatus(Status.Error);;
scope?.RecordException(e);
throw;
}
}
}
/// <summary>
/// Adds the SQL command params for the user specific meta data
/// </summary>
/// <param name="command">The command.</param>
/// <param name="data">The data.</param>
private static void AddUserColumnsParams(NpgsqlCommand command, IAdditionalMessageData data)
{
foreach (var metadata in data.AdditionalMetaData)
{
command.Parameters.AddWithValue("@" + metadata.Name, metadata.Value);
}
}
/// <summary>
/// Sends the specified linqExpression for execution.
/// </summary>
/// <param name="linqExpression">The linqExpression.</param>
/// <param name="timeOut">The time out.</param>
/// <param name="data">The data.</param>
/// <returns></returns>
/// <remarks>Your expression must return a type of object, or the JSON serializer may throw casting errors</remarks>
public async Task <IReceivedMessage <object> > SendAsync(LinqExpressionToRun linqExpression, TimeSpan timeOut,
IAdditionalMessageData data = null)
{
var message = new MessageExpression(MessageExpressionPayloads.FunctionText, _compositeSerialization.InternalSerializer.ConvertToBytes(linqExpression));
return(await _queue.SendAsync(message, timeOut, data).ConfigureAwait(false));
}
/// <summary>
/// Sets the specified meta data on the messageData context
/// </summary>
/// <param name="jobName">Name of the job.</param>
/// <param name="scheduledTime">The scheduled time.</param>
/// <param name="eventTime">The event time.</param>
/// <param name="route">The route.</param>
/// <param name="messageData">The message data.</param>
public void Set(string jobName, DateTimeOffset scheduledTime, DateTimeOffset eventTime, string route, IAdditionalMessageData messageData)
{
messageData.SetSetting("JobName", jobName);
messageData.SetSetting("JobEventTime", eventTime);
messageData.SetSetting("JobScheduledTime", scheduledTime);
messageData.Route = route;
}
/// <summary>
/// Sends a new message to an existing queue
/// </summary>
/// <param name="messageToSend">The message to send.</param>
/// <param name="data">The additional data.</param>
/// <returns></returns>
public IQueueOutputMessage Send(IMessage messageToSend, IAdditionalMessageData data)
{
using (var scope = _tracer.StartActivity("SendMessage"))
{
scope?.AddCommonTags(data, _connectionInformation);
scope?.Add(data);
scope?.SetTag("IsBatch", false);
if (scope != null)
{
messageToSend.Inject(_tracer, scope.Context, _headers.StandardHeaders);
}
try
{
var outputMessage = _handler.Send(messageToSend, data);
if (outputMessage.HasError)
{
scope?.SetStatus(Status.Error);
if (outputMessage.SendingException != null)
{
scope?.RecordException(outputMessage.SendingException);
}
}
scope?.AddMessageIdTag(outputMessage.SentMessage.MessageId);
return(outputMessage);
}
catch (Exception e)
{
scope?.SetStatus(Status.Error);
scope?.RecordException(e);
throw;
}
}
}
/// <summary>
/// Sends a new message to an existing queue
/// </summary>
/// <param name="messageToSend">The message to send.</param>
/// <param name="data">The additional data.</param>
/// <returns></returns>
public async Task <IQueueOutputMessage> SendAsync(IMessage messageToSend, IAdditionalMessageData data)
{
//lets add a bit more information to the active span if possible
using (var scope = _tracer.StartActivity("SendMessage"))
{
scope?.AddCommonTags(data, _connectionInformation);
scope?.Add(data);
scope?.SetTag("IsBatch", false);
if (scope?.Context != null)
{
messageToSend.Inject(_tracer, scope.Context, _headers.StandardHeaders);
}
try
{
var outputMessage = await _handler.SendAsync(messageToSend, data);
if (outputMessage.HasError)
{
scope?.SetStatus(Status.Error);
if (outputMessage.SendingException != null)
{
scope?.RecordException(outputMessage.SendingException);
}
}
scope?.AddMessageIdTag(outputMessage.SentMessage.MessageId);
return(outputMessage);
}
catch (Exception e)
{
scope?.SetStatus(Status.Error);
scope?.RecordException(e);
throw;
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="SendMessageCommand"/> class.
/// </summary>
/// <param name="messageToSend">The message to send.</param>
/// <param name="messageData">The message data.</param>
public SendMessageCommand(IMessage messageToSend, IAdditionalMessageData messageData)
{
Guard.NotNull(() => messageToSend, messageToSend);
Guard.NotNull(() => messageData, messageData);
MessageData = messageData;
MessageToSend = messageToSend;
}
/// <inheritdoc />
public DateTime GetTime(IMessage message, IAdditionalMessageData data)
{
var delay = data.GetDelay();
return(delay.HasValue
? _getTime.Create().GetCurrentUtcDate().Add(delay.Value)
: _getTime.Create().GetCurrentUtcDate());
}
/// <summary>
/// Initializes a new instance of the <see cref="SendMessageCommand"/> class.
/// </summary>
/// <param name="messageToSend">The message to send.</param>
/// <param name="messageData">The message data.</param>
public SendMessageCommand(IMessage messageToSend, IAdditionalMessageData messageData)
{
Guard.NotNull(() => messageToSend, messageToSend);
Guard.NotNull(() => messageData, messageData);
MessageData = messageData;
MessageToSend = messageToSend;
}
/// <summary>
/// Gets the event time.
/// </summary>
/// <param name="messageData">The message data.</param>
/// <returns></returns>
public DateTimeOffset GetEventTime(IAdditionalMessageData messageData)
{
if (messageData.TryGetSetting("JobEventTime", out var value))
{
return (DateTimeOffset)value;
}
return DateTimeOffset.MinValue;
}
/// <summary>
/// Gets the name of the job.
/// </summary>
/// <param name="messageData">The message data.</param>
/// <returns></returns>
public string GetJobName(IAdditionalMessageData messageData)
{
if (messageData.TryGetSetting("JobName", out var value))
{
return (string)value;
}
return string.Empty;
}
/// <summary>
/// Creates the status record.
/// </summary>
/// <param name="connection">The connection.</param>
/// <param name="message">The message.</param>
/// <param name="data">The data.</param>
/// <returns></returns>
private IDbCommand CreateStatusRecord(IDbConnection connection, IMessage message,
IAdditionalMessageData data)
{
var command = connection.CreateCommand();
SendMessage.BuildStatusCommand(command, _tableNameHelper, _headers, data, message, 0, _options.Value, _getTime.GetCurrentUtcDate());
return(command);
}
/// <summary>
/// Creates metadata needed to add this job to the db.
/// </summary>
/// <param name="jobName">Name of the job.</param>
/// <param name="scheduledTime">The scheduled time.</param>
/// <param name="eventTime">The event time.</param>
/// <param name="route">The route.</param>
/// <param name="messageData">The message data.</param>
public void Create(string jobName, DateTimeOffset scheduledTime, DateTimeOffset eventTime,
string route, IAdditionalMessageData messageData)
{
var item = new AdditionalMetaData<string>("JobName", jobName);
messageData.AdditionalMetaData.Add(item);
_jobSchedulerMetaData.Set(jobName, scheduledTime, eventTime, route, messageData);
}
/// <summary>
/// Gets the scheduled time.
/// </summary>
/// <param name="messageData">The message data.</param>
/// <returns></returns>
public DateTimeOffset GetScheduledTime(IAdditionalMessageData messageData)
{
if (messageData.TryGetSetting("JobScheduledTime", out var value))
{
return((DateTimeOffset)value);
}
return(DateTimeOffset.MinValue);
}
/// <summary>
/// Gets the name of the job.
/// </summary>
/// <param name="messageData">The message data.</param>
/// <returns></returns>
public string GetJobName(IAdditionalMessageData messageData)
{
object value;
if (messageData.TryGetSetting("JobName", out value))
{
return (string)value;
}
return string.Empty;
}
/// <summary>
/// Gets the event time.
/// </summary>
/// <param name="messageData">The message data.</param>
/// <returns></returns>
public DateTimeOffset GetEventTime(IAdditionalMessageData messageData)
{
object value;
if (messageData.TryGetSetting("JobEventTime", out value))
{
return (DateTimeOffset)value;
}
return DateTimeOffset.MinValue;
}
/// <summary>
/// Creates metadata needed to add this job to the db.
/// </summary>
/// <param name="jobName">Name of the job.</param>
/// <param name="scheduledTime">The scheduled time.</param>
/// <param name="eventTime">The event time.</param>
/// <param name="messageData">The message data.</param>
/// <param name="route">The route.</param>
public void Create(string jobName, DateTimeOffset scheduledTime, DateTimeOffset eventTime,
IAdditionalMessageData messageData, string route)
{
var item = new AdditionalMetaData <string>("JobName", jobName);
messageData.AdditionalMetaData.Add(item);
_jobSchedulerMetaData.Set(jobName, scheduledTime, eventTime, route, messageData);
}
internal static SQLiteCommand CreateMetaDataRecord(TimeSpan? delay, TimeSpan expiration, SQLiteConnection connection,
IMessage message, IAdditionalMessageData data, TableNameHelper tableNameHelper,
IHeaders headers, SqLiteMessageQueueTransportOptions options, IGetTime getTime)
{
var command = new SQLiteCommand(connection);
BuildMetaCommand(command, tableNameHelper, headers,
data, message, 0, options, delay, expiration, getTime.GetCurrentUtcDate());
return command;
}
/// <summary>
/// Sends the specified message.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="data">The additional message data.</param>
/// <returns></returns>
public IQueueOutputMessage Send(T message, IAdditionalMessageData data = null)
{
ThrowIfDisposed();
if (data != null)
{
return(InternalSend(message, data));
}
return(InternalSend(message, new AdditionalMessageData()));
}
internal static IDbCommand CreateMetaDataRecord(TimeSpan?delay, TimeSpan expiration, IDbConnection connection,
IMessage message, IAdditionalMessageData data, TableNameHelper tableNameHelper,
IHeaders headers, SqLiteMessageQueueTransportOptions options, IGetTime getTime)
{
var command = connection.CreateCommand();
BuildMetaCommand(command, tableNameHelper, data, options, delay, expiration, getTime.GetCurrentUtcDate());
return(command);
}
public DateTime GetTime(IMessage message, IAdditionalMessageData data)
{
var delay = data.GetDelay();
return delay.HasValue
?
_getTime.Create().GetCurrentUtcDate().Add(delay.Value)
:
_getTime.Create().GetCurrentUtcDate();
}
internal static void BuildMetaCommand(NpgsqlCommand command,
ITableNameHelper tableNameHelper,
IHeaders headers,
IAdditionalMessageData data,
IMessage message,
long id,
PostgreSqlMessageQueueTransportOptions options,
TimeSpan?delay,
TimeSpan expiration,
DateTime currentDateTime)
{
var sbMeta = new StringBuilder();
sbMeta.AppendLine("Insert into " + tableNameHelper.MetaDataName);
sbMeta.Append("(QueueID, CorrelationID, QueuedDateTime ");
//add configurable columns - queue
options.AddBuiltInColumns(sbMeta);
//add configurable columns - user
if (options.AdditionalColumnsOnMetaData)
{
AddUserColumns(sbMeta, data);
}
//close the column list
sbMeta.AppendLine(") ");
//add standard values that are always present
sbMeta.Append("VALUES (");
sbMeta.Append("@QueueID, @CorrelationID, now() at time zone 'utc' ");
//add the values for built in fields
options.AddBuiltInColumnValues(delay, expiration, currentDateTime, sbMeta);
//add configurable column value - user
if (options.AdditionalColumnsOnMetaData)
{
AddUserColumnsValues(sbMeta, data);
}
sbMeta.Append(")"); //close the VALUES
command.CommandText = sbMeta.ToString();
options.AddBuiltInColumnsParams(command, data);
command.Parameters.Add("@QueueID", NpgsqlDbType.Bigint, 8).Value = id;
command.Parameters.Add("@CorrelationID", NpgsqlDbType.Uuid, 16).Value = data.CorrelationId.Id.Value;
//add configurable column command params - user
if (options.AdditionalColumnsOnMetaData)
{
AddUserColumnsParams(command, data);
}
}
/// <summary>
/// Adds the SQL command params for the user specific meta data
/// </summary>
/// <param name="command">The command.</param>
/// <param name="data">The data.</param>
private static void AddUserColumnsParams(IDbCommand command, IAdditionalMessageData data)
{
foreach (var metadata in data.AdditionalMetaData)
{
var param = command.CreateParameter();
param.ParameterName = "@" + metadata.Name;
param.Value = metadata.Value;
command.Parameters.Add(param);
}
}
/// <summary>
/// Creates the status record.
/// </summary>
/// <param name="connection">The connection.</param>
/// <param name="id">The identifier.</param>
/// <param name="message">The message.</param>
/// <param name="data">The data.</param>
/// <param name="trans">The transaction.</param>
private void CreateStatusRecord(SqlConnection connection, long id, IMessage message,
IAdditionalMessageData data, SqlTransaction trans)
{
using (var command = connection.CreateCommand())
{
SendMessage.BuildStatusCommand(command, _tableNameHelper, _headers, data, message, id, _options.Value);
command.Transaction = trans;
command.ExecuteNonQuery();
}
}
/// <summary>
/// Creates the status record.
/// </summary>
/// <param name="connection">The connection.</param>
/// <param name="id">The identifier.</param>
/// <param name="message">The message.</param>
/// <param name="data">The data.</param>
/// <param name="trans">The transaction.</param>
/// <returns></returns>
private async Task CreateStatusRecordAsync(NpgsqlConnection connection, long id, IMessage message,
IAdditionalMessageData data, NpgsqlTransaction trans)
{
using (var command = connection.CreateCommand())
{
SendMessage.BuildStatusCommand(command, _tableNameHelper, _headers, data, message, id, _options.Value);
command.Transaction = trans;
await command.ExecuteNonQueryAsync().ConfigureAwait(false);
}
}
/// <summary>
/// Creates the meta data record.
/// </summary>
/// <param name="delay">The delay.</param>
/// <param name="expiration">The expiration.</param>
/// <param name="connection">The connection.</param>
/// <param name="id">The identifier.</param>
/// <param name="message">The message.</param>
/// <param name="data">The data.</param>
/// <param name="trans">The transaction.</param>
/// <param name="currentTime">The current time.</param>
/// <returns></returns>
private async Task CreateMetaDataRecordAsync(TimeSpan?delay, TimeSpan expiration, NpgsqlConnection connection, long id,
IMessage message, IAdditionalMessageData data, NpgsqlTransaction trans, DateTime currentTime)
{
using (var command = connection.CreateCommand())
{
SendMessage.BuildMetaCommand(command, _tableNameHelper, _headers,
data, message, id, _options.Value, delay, expiration, currentTime);
command.Transaction = trans;
await command.ExecuteNonQueryAsync().ConfigureAwait(false);
}
}
internal static void BuildStatusCommand(IDbCommand command,
TableNameHelper tableNameHelper,
IHeaders headers,
IAdditionalMessageData data,
IMessage message,
long id,
SqLiteMessageQueueTransportOptions options,
DateTime currentDateTime)
{
var builder = new StringBuilder();
builder.AppendLine("Insert into " + tableNameHelper.StatusName);
builder.Append("(QueueID, Status, CorrelationID ");
//add configurable columns - user
AddUserColumns(builder, data);
//close the column list
builder.AppendLine(") ");
//add standard values that are always present
builder.Append("VALUES (");
builder.Append($"@QueueID, {Convert.ToInt32(QueueStatuses.Waiting)}, @CorrelationID");
//add configurable column value - user
AddUserColumnsValues(builder, data);
builder.Append(")"); //close the VALUES
command.CommandText = builder.ToString();
options.AddBuiltInColumnsParams(command, data, null, TimeSpan.Zero, currentDateTime);
if (id > 0)
{
var paramid = command.CreateParameter();
paramid.ParameterName = "@QueueID";
paramid.DbType = DbType.Int64;
paramid.Value = id;
command.Parameters.Add(paramid);
}
var param = command.CreateParameter();
param.ParameterName = "@CorrelationID";
param.DbType = DbType.StringFixedLength;
param.Size = 38;
param.Value = data.CorrelationId.Id.Value.ToString();
command.Parameters.Add(param);
//add configurable column command params - user
AddUserColumnsParams(command, data);
AddHeaderColumnParams(command, message, headers);
}
/// <summary>
/// Handles the specified message.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="data">The additional message data.</param>
/// <param name="timeOut">The time out.</param>
/// <returns></returns>
public ISentMessage Handle(TSendMessage message, IAdditionalMessageData data, TimeSpan timeOut)
{
//store the destination queue as a header
data.SetHeader(_headers.StandardHeaders.RpcConnectionInfo, _connectionInformation.Clone());
//store the timeout as a header
data.SetHeader(_headers.StandardHeaders.RpcTimeout, _rpcTimeoutFactory.Create(timeOut));
//send the request
return(_sendQueue.Send(message, data).SentMessage);
}
/// <summary>
/// Sends a new message to an existing queue
/// </summary>
/// <param name="messageToSend">The message to send.</param>
/// <param name="data">The additional data.</param>
/// <returns></returns>
/// <exception cref="DotNetWorkQueueException"></exception>
/// <exception cref="System.Exception">Failed to insert record</exception>
/// <exception cref="System.ApplicationException"></exception>
public IQueueOutputMessage Send(IMessage messageToSend, IAdditionalMessageData data)
{
try
{
var id = _dataStorage.SendMessage(messageToSend, data);
return(new QueueOutputMessage(_sentMessageFactory.Create(new MessageQueueId(id), data.CorrelationId)));
}
catch (Exception exception)
{
return(new QueueOutputMessage(_sentMessageFactory.Create(null, data.CorrelationId), exception));
}
}
/// <summary>
/// Sends the specified message.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="responseId">The response identifier.</param>
/// <param name="inputData"></param>
/// <returns></returns>
public IQueueOutputMessage Send(T message, IResponseId responseId, IAdditionalMessageData inputData = null)
{
ThrowIfDisposed();
Guard.NotNull(() => message, message);
Guard.NotNull(() => responseId, responseId);
var data = SetupForSend(message, responseId, inputData);
//send the message to the transport
return(_sendMessages.Send(data.Item1, data.Item2));
}
/// <summary>
/// Sends a new message to an existing queue
/// </summary>
/// <param name="messageToSend">The message to send.</param>
/// <param name="data">The data.</param>
/// <returns></returns>
/// <exception cref="DotNetWorkQueueException">An error occurred while sending a message</exception>
public async Task <IQueueOutputMessage> SendAsync(IMessage messageToSend, IAdditionalMessageData data)
{
try
{
var id = await _dataStorage.SendMessageAsync(messageToSend, data).ConfigureAwait(false);
return(new QueueOutputMessage(_sentMessageFactory.Create(new MessageQueueId(id), data.CorrelationId)));
}
catch (Exception exception)
{
return(new QueueOutputMessage(_sentMessageFactory.Create(null, data.CorrelationId), exception));
}
}
/// <summary>
/// Sends a new message to an existing queue
/// </summary>
/// <param name="messageToSend">The message to send.</param>
/// <param name="data">The additional data.</param>
/// <returns></returns>
/// <exception cref="DotNetWorkQueueException"></exception>
/// <exception cref="System.Exception">Failed to insert record</exception>
/// <exception cref="System.ApplicationException"></exception>
public IQueueOutputMessage Send(IMessage messageToSend, IAdditionalMessageData data)
{
try
{
var id = _sendMessage.Handle(
new SendMessageCommand(messageToSend, data));
return new QueueOutputMessage(_sentMessageFactory.Create(new SqLiteMessageQueueId(id), data.CorrelationId));
}
catch (Exception exception)
{
return new QueueOutputMessage(_sentMessageFactory.Create(null, data.CorrelationId), exception);
}
}
/// <summary>
/// Handles the specified message.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="data">The additional message data.</param>
/// <param name="timeOut">The time out.</param>
/// <returns></returns>
public async Task <ISentMessage> HandleAsync(TSendMessage message, IAdditionalMessageData data, TimeSpan timeOut)
{
//store the destination queue as a header
data.SetHeader(_headers.StandardHeaders.RpcConnectionInfo, _connectionInformation.Clone());
//store the timeout as a header
data.SetHeader(_headers.StandardHeaders.RpcTimeout, _rpcTimeoutFactory.Create(timeOut));
//send the request
var result = await _sendQueue.SendAsync(message, data).ConfigureAwait(false);
return(result.SentMessage);
}
/// <summary>
/// Adds the common tags.
/// </summary>
/// <param name="span">The span.</param>
/// <param name="data">The data.</param>
/// <param name="connectionInformation">The connection information.</param>
public static void AddCommonTags(this ISpan span, IAdditionalMessageData data, IConnectionInformation connectionInformation)
{
span.SetTag("Server", connectionInformation.Server);
span.SetTag("Queue", connectionInformation.QueueName);
span.SetTag("CorrelationId", data.CorrelationId.ToString());
if (!string.IsNullOrEmpty(data.Route))
{
span.SetTag("Route", data.Route);
}
foreach (var userTag in data.TraceTags)
{
span.SetTag(userTag.Key, userTag.Value);
}
}
/// <summary>
/// Sends a new message to an existing queue
/// </summary>
/// <param name="messageToSend">The message to send.</param>
/// <param name="data">The additional data.</param>
/// <returns></returns>
public async Task<IQueueOutputMessage> SendAsync(IMessage messageToSend, IAdditionalMessageData data)
{
using (_sendAsyncTimer.NewContext())
{
var result = await _handler.SendAsync(messageToSend, data).ConfigureAwait(false);
if (!result.HasError)
{
_sendMeter.Mark("SendMessageAsync", 1);
}
else
{
_sendErrorMeter.Mark("SendMessageAsync", 1);
}
return result;
}
}
/// <summary>
/// Sends a new message to an existing queue
/// </summary>
/// <param name="messageToSend">The message to send.</param>
/// <param name="data">The additional data.</param>
/// <returns></returns>
public IQueueOutputMessage Send(IMessage messageToSend, IAdditionalMessageData data)
{
using (_sendTimer.NewContext())
{
var result = _handler.Send(messageToSend, data);
if (!result.HasError)
{
_sendMeter.Mark("SendMessage", 1);
}
else
{
_sendErrorMeter.Mark("SendMessage", 1);
}
return result;
}
}
/// <summary>
/// Sends a new message to an existing queue
/// </summary>
/// <param name="messageToSend">The message to send.</param>
/// <param name="data">The additional data.</param>
/// <returns></returns>
public IQueueOutputMessage Send(IMessage messageToSend, IAdditionalMessageData data)
{
using (_sendTimer.NewContext())
{
var result = _handler.Send(messageToSend, data);
if (!result.HasError)
{
_sendMeter.Mark("SendMessage", 1);
}
else
{
_sendErrorMeter.Mark("SendMessage", 1);
}
return(result);
}
}
/// <summary>
/// Generates the headers for a message, and sets a correlation ID if the user didn't provide one.
/// </summary>
/// <param name="data">The data.</param>
/// <returns></returns>
public Dictionary<string, object> HeaderSetup(IAdditionalMessageData data)
{
Guard.NotNull(() => data, data);
//a correlation ID is required. Verify that we have one.
if (data.CorrelationId == null || !data.CorrelationId.HasValue)
{
data.CorrelationId = _correlationIdFactory.Create();
}
Dictionary<string, object> additionalHeaders = null;
if (data.Headers != null && data.Headers.Count > 0)
{
additionalHeaders = data.Headers.ToDictionary(entry => entry.Key,
entry => entry.Value);
}
return additionalHeaders;
}
internal static void BuildMetaCommand(NpgsqlCommand command,
TableNameHelper tableNameHelper,
IHeaders headers,
IAdditionalMessageData data,
IMessage message,
long id,
PostgreSqlMessageQueueTransportOptions options,
TimeSpan? delay,
TimeSpan expiration,
DateTime currentDateTime)
{
var sbMeta = new StringBuilder();
sbMeta.AppendLine("Insert into " + tableNameHelper.MetaDataName);
sbMeta.Append("(QueueID, CorrelationID, QueuedDateTime ");
//add configurable columns - queue
options.AddBuiltInColumns(sbMeta);
AddHeaderColumns(sbMeta, message, headers);
//close the column list
sbMeta.AppendLine(") ");
//add standard values that are always present
sbMeta.Append("VALUES (");
sbMeta.Append("@QueueID, @CorrelationID, now() at time zone 'utc' ");
//add the values for built in fields
options.AddBuiltInColumnValues(delay, expiration, currentDateTime, sbMeta);
AddHeaderValues(sbMeta, message, headers);
sbMeta.Append(")"); //close the VALUES
command.CommandText = sbMeta.ToString();
options.AddBuiltInColumnsParams(command, data);
AddHeaderColumnParams(command, message, headers);
command.Parameters.Add("@QueueID", NpgsqlDbType.Bigint, 8).Value = id;
command.Parameters.Add("@CorrelationID", NpgsqlDbType.Uuid, 16).Value = data.CorrelationId.Id.Value;
}
internal static void BuildStatusCommand(SQLiteCommand command,
TableNameHelper tableNameHelper,
IHeaders headers,
IAdditionalMessageData data,
IMessage message,
long id,
SqLiteMessageQueueTransportOptions options,
DateTime currentDateTime)
{
var builder = new StringBuilder();
builder.AppendLine("Insert into " + tableNameHelper.StatusName);
builder.Append("(QueueID, Status, CorrelationID ");
//add configurable columns - user
AddUserColumns(builder, data);
//close the column list
builder.AppendLine(") ");
//add standard values that are always present
builder.Append("VALUES (");
builder.Append($"@QueueID, {Convert.ToInt32(QueueStatuses.Waiting)}, @CorrelationID");
//add configurable column value - user
AddUserColumnsValues(builder, data);
builder.Append(")"); //close the VALUES
command.CommandText = builder.ToString();
options.AddBuiltInColumnsParams(command, data, null, TimeSpan.Zero, currentDateTime);
command.Parameters.Add("@QueueID", DbType.Int64, 8).Value = id;
command.Parameters.Add("@CorrelationID", DbType.StringFixedLength, 38).Value = data.CorrelationId.Id.Value.ToString();
//add configurable column command params - user
AddUserColumnsParams(command, data);
AddHeaderColumnParams(command, message, headers);
}
internal static void BuildStatusCommand(SqlCommand command,
TableNameHelper tableNameHelper,
IHeaders headers,
IAdditionalMessageData data,
IMessage message,
long id,
SqlServerMessageQueueTransportOptions options)
{
var builder = new StringBuilder();
builder.AppendLine("Insert into " + tableNameHelper.StatusName);
builder.Append("(QueueID, Status, CorrelationID ");
//add configurable columns - user
AddUserColumns(builder, data);
//close the column list
builder.AppendLine(") ");
//add standard values that are always present
builder.Append("VALUES (");
builder.Append($"@QueueID, {Convert.ToInt32(QueueStatuses.Waiting)}, @CorrelationID");
//add configurable column value - user
AddUserColumnsValues(builder, data);
builder.Append(")"); //close the VALUES
command.CommandText = builder.ToString();
options.AddBuiltInColumnsParams(command, data);
command.Parameters.Add("@QueueID", SqlDbType.BigInt, 8).Value = id;
command.Parameters.Add("@CorrelationID", SqlDbType.UniqueIdentifier, 16).Value = data.CorrelationId.Id.Value;
//add configurable column command params - user
AddUserColumnsParams(command, data);
AddHeaderColumnParams(command, message, headers);
}
/// <summary>
/// Adds the built in columns parameters.
/// </summary>
/// <param name="command">The command.</param>
/// <param name="data">The data.</param>
internal void AddBuiltInColumnsParams(NpgsqlCommand command, IAdditionalMessageData data)
{
if (EnablePriority)
{
var priority = 0;
if (data.GetPriority().HasValue)
{
// ReSharper disable once PossibleInvalidOperationException
priority = data.GetPriority().Value;
}
command.Parameters.Add("@priority", NpgsqlDbType.Integer, 1).Value = priority;
}
if (EnableRoute)
{
if (!string.IsNullOrEmpty(data.Route))
{
command.Parameters.Add("@Route", NpgsqlDbType.Varchar, 255).Value = data.Route;
}
else
{
command.Parameters.Add("@Route", NpgsqlDbType.Varchar, 255).Value = DBNull.Value;
}
}
if (EnableStatus)
{
command.Parameters.Add("@Status", NpgsqlDbType.Integer, 4).Value = 0;
}
}
/// <summary>
/// Sends the specified linqExpression to be executed. Additional message meta data is optional.
/// </summary>
/// <param name="linqExpression">The linqExpression to execute.</param>
/// <param name="data">The optional additional message data.</param>
/// <returns></returns>
public async Task<IQueueOutputMessage> SendAsync(LinqExpressionToRun linqExpression, IAdditionalMessageData data = null)
{
var message = new MessageExpression(MessageExpressionPayloads.ActionText, _compositeSerialization.InternalSerializer.ConvertToBytes(linqExpression));
return await _queue.SendAsync(message, data).ConfigureAwait(false);
}
/// <summary>
/// Sends the specified linqExpression to be executed. Additional message meta data is optional.
/// </summary>
/// <param name="linqExpression">The linqExpression to execute.</param>
/// <param name="data">The optional additional message data.</param>
/// <returns></returns>
public IQueueOutputMessage Send(LinqExpressionToRun linqExpression, IAdditionalMessageData data = null)
{
var message = new MessageExpression(MessageExpressionPayloads.ActionText,
_compositeSerialization.InternalSerializer.ConvertToBytes(linqExpression));
return _queue.Send(message, data);
}
/// <summary>
/// Sets the specified meta data on the messageData context
/// </summary>
/// <param name="jobName">Name of the job.</param>
/// <param name="scheduledTime">The scheduled time.</param>
/// <param name="eventTime">The event time.</param>
/// <param name="route">The route. May be null.</param>
/// <param name="messageData">The message data.</param>
protected override void SetMetaDataForJob(string jobName, DateTimeOffset scheduledTime, DateTimeOffset eventTime,
string route, IAdditionalMessageData messageData)
{
_createJobMetaData.Create(jobName, scheduledTime, eventTime, messageData, route);
}
/// <summary>
/// Sends the specified linqExpression for execution.
/// </summary>
/// <param name="method">The linqExpression.</param>
/// <param name="timeOut">The time out.</param>
/// <param name="data">The data.</param>
/// <returns></returns>
/// <remarks>
/// Your expression must return a type of object, or the JSON serializer may throw casting errors
/// </remarks>
public IReceivedMessage<object> Send(Expression<Func<IReceivedMessage<MessageExpression>, IWorkerNotification, object>> method, TimeSpan timeOut, IAdditionalMessageData data = null)
{
var message = new MessageExpression(MessageExpressionPayloads.Function, _serializer.ConvertFunctionToBytes(method));
return _queue.Send(message, timeOut, data);
}
/// <summary>
/// Sends the specified linqExpression to be executed. Additional message meta data is optional.
/// </summary>
/// <param name="method">The linqExpression to execute.</param>
/// <param name="data">The optional additional message data.</param>
/// <returns></returns>
public IQueueOutputMessage Send(Expression<Action<IReceivedMessage<MessageExpression>, IWorkerNotification>> method, IAdditionalMessageData data = null)
{
var message = new MessageExpression(MessageExpressionPayloads.Action, _serializer.ConvertMethodToBytes(method));
return _queue.Send(message, data);
}
/// <summary>
/// Sets the specified meta data on the messageData context
/// </summary>
/// <param name="jobName">Name of the job.</param>
/// <param name="scheduledTime">The scheduled time.</param>
/// <param name="eventTime">The event time.</param>
/// <param name="route">The route. May be null.</param>
/// <param name="messageData">The message data.</param>
protected abstract void SetMetaDataForJob(string jobName, DateTimeOffset scheduledTime, DateTimeOffset eventTime,
string route, IAdditionalMessageData messageData);
/// <summary>
/// Adds the SQL command params for the user specific meta data
/// </summary>
/// <param name="command">The command.</param>
/// <param name="data">The data.</param>
public static void AddUserColumnsParams(SqlCommand command, IAdditionalMessageData data)
{
foreach (var metadata in data.AdditionalMetaData)
{
command.Parameters.AddWithValue("@" + metadata.Name, metadata.Value);
}
}
/// <summary>
/// Adds the values for the user specific meta data to the SQL command.
/// </summary>
/// <param name="command">The command.</param>
/// <param name="data">The data.</param>
public static void AddUserColumnsValues(StringBuilder command, IAdditionalMessageData data)
{
var i = 0;
foreach (var metadata in data.AdditionalMetaData)
{
if (i == 0)
{
command.Append(",");
}
command.Append("@" + metadata.Name);
if (i < data.AdditionalMetaData.Count - 1)
{
command.Append(",");
}
i++;
}
}
/// <summary>
/// Sends the specified linqExpression to be executed. Additional message meta data is optional.
/// </summary>
/// <param name="method">The linqExpression to execute.</param>
/// <param name="data">The optional additional message data.</param>
/// <returns></returns>
public async Task<IQueueOutputMessage> SendAsync(Expression<Action<IReceivedMessage<MessageExpression>, IWorkerNotification>> method, IAdditionalMessageData data = null)
{
var message = new MessageExpression(MessageExpressionPayloads.Action, _serializer.ConvertMethodToBytes(method));
return await _queue.SendAsync(message, data).ConfigureAwait(false);
}
/// <summary>
/// Adds the headers.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="data">The data.</param>
public void AddHeaders (IMessage message, IAdditionalMessageData data)
{
message.SetHeader(_headers.StandardHeaders.FirstPossibleDeliveryDate, new ValueTypeWrapper<DateTime>(_getFirstMessageDeliveryTime.GetTime(message, data)));
}
/// <summary>
/// Sends the specified linqExpression for execution.
/// </summary>
/// <param name="method">The linqExpression.</param>
/// <param name="timeOut">The time out.</param>
/// <param name="data">The data.</param>
/// <returns></returns>
/// <remarks>
/// Your expression must return a type of object, or the JSON serializer may throw casting errors
/// </remarks>
public async Task<IReceivedMessage<object>> SendAsync(Expression<Func<IReceivedMessage<MessageExpression>, IWorkerNotification, object>> method, TimeSpan timeOut, IAdditionalMessageData data = null)
{
var message = new MessageExpression(MessageExpressionPayloads.Function, _serializer.ConvertFunctionToBytes(method));
return await _queue.SendAsync(message, timeOut, data).ConfigureAwait(false);
}
/// <summary>
/// Sends a new message to an existing queue
/// </summary>
/// <param name="messageToSend">The message to send.</param>
/// <param name="data">The data.</param>
/// <returns></returns>
/// <exception cref="DotNetWorkQueueException">An error occurred while sending a message</exception>
public async Task<IQueueOutputMessage> SendAsync(IMessage messageToSend, IAdditionalMessageData data)
{
try
{
var id = await _sendMessageAsync.Handle(
new SendMessageCommand(messageToSend, data)).ConfigureAwait(false);
return new QueueOutputMessage(_sentMessageFactory.Create(new SqLiteMessageQueueId(id), data.CorrelationId));
}
catch (Exception exception)
{
return new QueueOutputMessage(_sentMessageFactory.Create(null, data.CorrelationId), exception);
}
}
/// <summary>
/// Sends the specified linqExpression for execution.
/// </summary>
/// <param name="linqExpression">The linqExpression.</param>
/// <param name="timeOut">The time out.</param>
/// <param name="data">The data.</param>
/// <returns></returns>
/// <remarks>Your expression must return a type of object, or the JSON serializer may throw casting errors</remarks>
public IReceivedMessage<object> Send(LinqExpressionToRun linqExpression, TimeSpan timeOut, IAdditionalMessageData data = null)
{
var message = new MessageExpression(MessageExpressionPayloads.FunctionText, _compositeSerialization.InternalSerializer.ConvertToBytes(linqExpression));
return _queue.Send(message, timeOut, data);
}
/// <summary>
/// Sends the specified linqExpression for execution.
/// </summary>
/// <param name="linqExpression">The linqExpression.</param>
/// <param name="timeOut">The time out.</param>
/// <param name="data">The data.</param>
/// <returns></returns>
/// <remarks>Your expression must return a type of object, or the JSON serializer may throw casting errors</remarks>
public async Task<IReceivedMessage<object>> SendAsync(LinqExpressionToRun linqExpression, TimeSpan timeOut,
IAdditionalMessageData data = null)
{
var message = new MessageExpression(MessageExpressionPayloads.FunctionText, _compositeSerialization.InternalSerializer.ConvertToBytes(linqExpression));
return await _queue.SendAsync(message, timeOut, data).ConfigureAwait(false);
}
/// <summary>
/// Sends a new message to an existing queue
/// </summary>
/// <param name="messageToSend">The message to send.</param>
/// <param name="data">The additional data.</param>
/// <returns></returns>
public async Task<IQueueOutputMessage> SendAsync(IMessage messageToSend, IAdditionalMessageData data)
{
using (_sendAsyncTimer.NewContext())
{
var result = await _handler.SendAsync(messageToSend, data);
if (!result.HasError)
{
_sendMeter.Mark("SendMessageAsync", 1);
}
else
{
_sendErrorMeter.Mark("SendMessageAsync", 1);
}
return result;
}
}
