public void SendTwiceAndReceiveMultipleMessage()
{
Helper.CreateAndOpenQueue(queue =>
{
var transportMessage = new ServiceBusMessage(new object[]
{
new Message1("MessageName1", 2011),
new Message2("MessageName2", 2012),
new Message1("MessageName3", 2013),
new Message2("MessageName4", 2014),
new Message2("MessageName5", 2015),
});
queue.Send(queue.Transport.TranslateToTransportMessage(transportMessage));
queue.Send(queue.Transport.TranslateToTransportMessage(transportMessage));
Helper.AssertTransportMessage(transportMessage,
queue.Transport.TranslateToServiceBusMessage(queue.Receive(TimeSpan.FromSeconds(5))));
Helper.AssertTransportMessage(transportMessage,
queue.Transport.TranslateToServiceBusMessage(queue.Receive(TimeSpan.FromSeconds(5))));
},
new ITransport[]
{
new MsmqTransport(),
new InMemoryTransport()
});
}
public void ObserveTest()
{
Helper.CreateAndOpenQueue(queue =>
{
var messageCount = 0;
var transportMessage = new ServiceBusMessage(new object[]
{
new Message1("MessageName", 2011)
});
using(var observer = queue.Transport.CreateObserver(queue.Name))
{
observer.MessageReceived += (message, ob) =>
{
messageCount++;
Helper.AssertTransportMessage(transportMessage,
queue.Transport.TranslateToServiceBusMessage(message));
};
observer.Start();
queue.Send(queue.Transport.TranslateToTransportMessage(transportMessage));
queue.Send(queue.Transport.TranslateToTransportMessage(transportMessage));
queue.Send(queue.Transport.TranslateToTransportMessage(transportMessage));
observer.Wait();
}
Assert.AreEqual(messageCount, 3);
});
}
public ServiceBusMessage ReceiveMessage(int timeOut = 0)
{
ServiceBusMessage sbMessage = null;
{
try
{
BrokeredMessage receivedMessage = this._QueueClient.Receive(new TimeSpan(0, 0, timeOut));
if (receivedMessage != null)
{
sbMessage = new ServiceBusMessage()
{
ID = receivedMessage.MessageId,
Message = receivedMessage.GetBody<string>()
};
receivedMessage.Complete();
}
}
catch (MessagingException)
{
//throw new Exception(e.Message);
}
}
return sbMessage;
}
public static void AssertTransportMessage(ServiceBusMessage sent, ServiceBusMessage received)
{
Assert.AreEqual(sent.Messages.Length, received.Messages.Length);
for (int i = 0; i < sent.Messages.Length; i++)
{
var sentMessage = sent.Messages[i];
var receivedMessage = received.Messages[i];
Assert.AreEqual(sentMessage.GetType(), receivedMessage.GetType());
ObjectComparer.AreObjectsEqual(sentMessage, receivedMessage);
}
}
public void SendMessage(ServiceBusMessage sbMessage)
{
BrokeredMessage brokeredMessage = new BrokeredMessage(sbMessage.Message);
brokeredMessage.MessageId = sbMessage.ID;
try
{
this._QueueClient.SendAsync(brokeredMessage);
}
catch (MessagingException e)
{
throw new Exception(e.Message);
}
}
public void TestIt()
{
Helper.CreateAndOpenQueue(queue =>
{
var transportMessage = new ServiceBusMessage(new object[]
{
new Message1("MessageName", 2011)
});
queue.Send(queue.Transport.TranslateToTransportMessage(transportMessage));
var queue2 = queue.Transport.OpenEndpoint(queue.Name);
queue2.Send(queue.Transport.TranslateToTransportMessage(transportMessage));
});
}
public TransportMessage TranslateToTransportMessage(ServiceBusMessage serviceBusMessage)
{
// do not send empty messages
if (serviceBusMessage.Messages == null || serviceBusMessage.Messages.Length == 0)
throw new ArgumentException("Transport message is null or empty.");
Message message = new Message
{
Body = serviceBusMessage,
Formatter = new MsmqMessageFormatter(),
Label = serviceBusMessage.Messages.First().GetType().FullName
};
return new TransportMessage(message);
}
public void SendAndReceiveSingleMessage()
{
Helper.CreateAndOpenQueue(queue =>
{
var transportMessage = new ServiceBusMessage(new object[]
{
new Message1("MessageName", 2011)
});
queue.Send(queue.Transport.TranslateToTransportMessage(transportMessage));
Helper.AssertTransportMessage(transportMessage,
queue.Transport.TranslateToServiceBusMessage(queue.Receive(TimeSpan.FromSeconds(5))));
},
new ITransport[]
{
new MsmqTransport(),
new InMemoryTransport()
});
}
public Task <ServiceBusMessage> UpdateAsync(ServiceBusMessage content)
{
throw new NotImplementedException();
}
/// <summary>
/// Gets service bus action details.
/// </summary>
/// <param name="jobActionType">Job action type.</param>
/// <param name="serviceBusMessage">Service bus message.</param>
/// <returns>PSServiceBusJobActionDetails</returns>
internal static PSServiceBusJobActionDetails GetServiceBusJobActionDetails(JobActionType jobActionType, ServiceBusMessage serviceBusMessage)
{
if (serviceBusMessage == null)
{
throw new ArgumentNullException(paramName: "serviceBusMessage");
}
var psServieBusJobActionDetails = new PSServiceBusJobActionDetails(jobActionType)
{
ServiceBusAuthentication = Converter.GetServiceBusActionAuthenticationDetails(serviceBusMessage.Authentication),
ServiceBusMessage = serviceBusMessage.Message,
ServiceBusNamespaceProperty = serviceBusMessage.NamespaceProperty,
ServiceBusTransportType = serviceBusMessage.TransportType.ToString()
};
return psServieBusJobActionDetails;
}
private void SendResponseSchemaEvent(ServiceBusMessage result)
{
SendClientResponse(result, (action, content) => action.udsSchemaEvent(result.Content));
}
public override bool TryAdd(ServiceBusMessage message)
{
TryAddCalledWith = message;
return(true);
}
/// <summary>
/// Renews the lock on the message specified by the lock token. The lock will be renewed based on the setting specified on the queue.
/// </summary>
/// <remarks>
/// When a message is received in <see cref="ReceiveMode.PeekLock"/> mode, the message is locked on the server for this
/// receiver instance for a duration as specified during the Queue/Subscription creation (LockDuration).
/// If processing of the message requires longer than this duration, the lock needs to be renewed.
/// For each renewal, it resets the time the message is locked by the LockDuration set on the Entity.
/// </remarks>
public virtual async Task RenewLockAsync(
ServiceBusMessage message,
CancellationToken cancellationToken = default)
{
message.SystemProperties.LockedUntilUtc = await RenewLockAsync(message.SystemProperties.LockToken).ConfigureAwait(false);
}
/// <summary>
/// Publishes message with group into broker.
/// </summary>
/// <param name="message">Incoming message.</param>
/// <param name="groupName">Group identifier.</param>
public void AcceptMessage(ServiceBusMessage message, string groupName)
{
// TODO: реализовать
throw new NotImplementedException();
}
// Passes a service bus message from a queue to topic using a brokered message
public static void SBQueue2SBTopic(
[ServiceBusTrigger(SecondQueueNameKey)] string message,
[ServiceBus(TopicNameKey)] out ServiceBusMessage output)
{
output = SBQueue2SBTopic_GetOutputMessage(message);
}
public TransportMessage TranslateToTransportMessage(ServiceBusMessage serviceBusMessage)
{
return(new TransportMessage(serviceBusMessage));
}
public static AmqpMessage SBMessageToAmqpMessage(ServiceBusMessage sbMessage)
{
// body
var amqpMessage = sbMessage.ToAmqpMessage();
// properties
amqpMessage.Properties.MessageId = sbMessage.MessageId;
amqpMessage.Properties.CorrelationId = sbMessage.CorrelationId;
amqpMessage.Properties.ContentType = sbMessage.ContentType;
amqpMessage.Properties.ContentEncoding = sbMessage.AmqpMessage.Properties.ContentEncoding;
amqpMessage.Properties.Subject = sbMessage.Subject;
amqpMessage.Properties.To = sbMessage.To;
amqpMessage.Properties.ReplyTo = sbMessage.ReplyTo;
amqpMessage.Properties.GroupId = sbMessage.SessionId;
amqpMessage.Properties.ReplyToGroupId = sbMessage.ReplyToSessionId;
amqpMessage.Properties.GroupSequence = sbMessage.AmqpMessage.Properties.GroupSequence;
if (sbMessage.AmqpMessage.Properties.UserId.HasValue)
{
ReadOnlyMemory <byte> userId = sbMessage.AmqpMessage.Properties.UserId.Value;
if (MemoryMarshal.TryGetArray(userId, out ArraySegment <byte> segment))
{
amqpMessage.Properties.UserId = segment;
}
else
{
amqpMessage.Properties.UserId = new ArraySegment <byte>(userId.ToArray());
}
}
// If TTL is set, it is used to calculate AbsoluteExpiryTime and CreationTime
if (sbMessage.TimeToLive != TimeSpan.MaxValue)
{
amqpMessage.Header.Ttl = (uint)sbMessage.TimeToLive.TotalMilliseconds;
amqpMessage.Properties.CreationTime = DateTime.UtcNow;
if (AmqpConstants.MaxAbsoluteExpiryTime - amqpMessage.Properties.CreationTime.Value > sbMessage.TimeToLive)
{
amqpMessage.Properties.AbsoluteExpiryTime = amqpMessage.Properties.CreationTime.Value + sbMessage.TimeToLive;
}
else
{
amqpMessage.Properties.AbsoluteExpiryTime = AmqpConstants.MaxAbsoluteExpiryTime;
}
}
else
{
if (sbMessage.AmqpMessage.Properties.CreationTime.HasValue)
{
amqpMessage.Properties.CreationTime = sbMessage.AmqpMessage.Properties.CreationTime.Value.UtcDateTime;
}
if (sbMessage.AmqpMessage.Properties.AbsoluteExpiryTime.HasValue)
{
amqpMessage.Properties.AbsoluteExpiryTime = sbMessage.AmqpMessage.Properties.AbsoluteExpiryTime.Value.UtcDateTime;
}
}
// message annotations
foreach (KeyValuePair <string, object> kvp in sbMessage.AmqpMessage.MessageAnnotations)
{
switch (kvp.Key)
{
case AmqpMessageConstants.ScheduledEnqueueTimeUtcName:
if ((sbMessage.ScheduledEnqueueTime != null) && sbMessage.ScheduledEnqueueTime > DateTimeOffset.MinValue)
{
amqpMessage.MessageAnnotations.Map.Add(AmqpMessageConstants.ScheduledEnqueueTimeUtcName, sbMessage.ScheduledEnqueueTime.UtcDateTime);
}
break;
case AmqpMessageConstants.PartitionKeyName:
if (sbMessage.PartitionKey != null)
{
amqpMessage.MessageAnnotations.Map.Add(AmqpMessageConstants.PartitionKeyName, sbMessage.PartitionKey);
}
break;
case AmqpMessageConstants.ViaPartitionKeyName:
if (sbMessage.TransactionPartitionKey != null)
{
amqpMessage.MessageAnnotations.Map.Add(AmqpMessageConstants.ViaPartitionKeyName, sbMessage.TransactionPartitionKey);
}
break;
default:
amqpMessage.MessageAnnotations.Map.Add(kvp.Key, kvp.Value);
break;
}
}
// application properties
if (sbMessage.ApplicationProperties != null && sbMessage.ApplicationProperties.Count > 0)
{
if (amqpMessage.ApplicationProperties == null)
{
amqpMessage.ApplicationProperties = new ApplicationProperties();
}
foreach (KeyValuePair <string, object> pair in sbMessage.ApplicationProperties)
{
if (TryGetAmqpObjectFromNetObject(pair.Value, MappingType.ApplicationProperty, out var amqpObject))
{
amqpMessage.ApplicationProperties.Map.Add(pair.Key, amqpObject);
}
else
{
throw new NotSupportedException(Resources.InvalidAmqpMessageProperty.FormatForUser(pair.Key.GetType()));
}
}
}
// delivery annotations
foreach (KeyValuePair <string, object> kvp in sbMessage.AmqpMessage.DeliveryAnnotations)
{
if (TryGetAmqpObjectFromNetObject(kvp.Value, MappingType.ApplicationProperty, out var amqpObject))
{
amqpMessage.DeliveryAnnotations.Map.Add(kvp.Key, amqpObject);
}
}
// header - except for ttl which is set above with the properties
if (sbMessage.AmqpMessage.Header.DeliveryCount != null)
{
amqpMessage.Header.DeliveryCount = sbMessage.AmqpMessage.Header.DeliveryCount;
}
if (sbMessage.AmqpMessage.Header.Durable != null)
{
amqpMessage.Header.Durable = sbMessage.AmqpMessage.Header.Durable;
}
if (sbMessage.AmqpMessage.Header.FirstAcquirer != null)
{
amqpMessage.Header.FirstAcquirer = sbMessage.AmqpMessage.Header.FirstAcquirer;
}
if (sbMessage.AmqpMessage.Header.Priority != null)
{
amqpMessage.Header.Priority = sbMessage.AmqpMessage.Header.Priority;
}
// footer
foreach (KeyValuePair <string, object> kvp in sbMessage.AmqpMessage.Footer)
{
amqpMessage.Footer.Map.Add(kvp.Key, kvp.Value);
}
return(amqpMessage);
}
protected override void AfterSave(Protocol entity)
{
try
{
_logger.WriteDebug(new LogMessage($"VecompSoftware.DocSuite.Private.WebAPI.Controllers.Entity.Protocols.AfterSave with entity UniqueId {entity.UniqueId}"), LogCategories);
Protocol protocol = _unitOfWork.Repository <Protocol>().GetByUniqueIdWithRole(entity.UniqueId).FirstOrDefault();
if (protocol != null)
{
IList <CategoryFascicle> categoryFascicles = protocol.Category.CategoryFascicles.Where(f => f.DSWEnvironment == (int)DSWEnvironmentType.Protocol || f.DSWEnvironment == 0).ToList();
CategoryFascicle categoryFascicle = categoryFascicles.FirstOrDefault();
if (categoryFascicles != null && categoryFascicles.Count > 1)
{
categoryFascicle = categoryFascicles.FirstOrDefault(f => f.FascicleType == FascicleType.Period);
}
IIdentityContext identity = new IdentityContext(_currentIdentity.FullUserName);
ICQRS command = null;
if (CurrentUpdateActionType.HasValue && CurrentUpdateActionType == UpdateActionType.ActivateProtocol)
{
command = new CommandCreateProtocol(_parameterEnvService.CurrentTenantName, _parameterEnvService.CurrentTenantId, protocol.TenantAOO.UniqueId, null, null, null, identity, protocol, categoryFascicle, null);
}
if (CurrentDeleteActionType.HasValue && CurrentDeleteActionType == DeleteActionType.DeleteProtocol)
{
command = new CommandUpdateProtocol(_parameterEnvService.CurrentTenantName, _parameterEnvService.CurrentTenantId, protocol.TenantAOO.UniqueId, null, null, null, identity, protocol, categoryFascicle, null);
}
if (HttpContext.Current.Request.HttpMethod == HttpMethod.Put.Method &&
CurrentUpdateActionType.HasValue && CurrentUpdateActionType != UpdateActionType.ActivateProtocol)
{
command = new CommandUpdateProtocol(_parameterEnvService.CurrentTenantName, _parameterEnvService.CurrentTenantId, protocol.TenantAOO.UniqueId, null, null, null, identity, protocol, categoryFascicle, null);
}
if (command != null)
{
WorkflowActionDocumentUnitLinkModel workflowActionDocumentUnitLinkModel;
DocumentUnitModel documentUnitModel;
foreach (IWorkflowAction workflowAction in WorkflowActions)
{
workflowAction.IdWorkflowActivity = IdWorkflowActivity;
if (workflowAction is IWorkflowActionDocumentUnitLink)
{
workflowActionDocumentUnitLinkModel = (WorkflowActionDocumentUnitLinkModel)workflowAction;
documentUnitModel = workflowActionDocumentUnitLinkModel.GetReferenced();
if (documentUnitModel.UniqueId != protocol.UniqueId)
{
documentUnitModel = workflowActionDocumentUnitLinkModel.GetDestinationLink();
}
documentUnitModel.Year = protocol.Year;
documentUnitModel.Number = protocol.Number.ToString();
}
command.WorkflowActions.Add(workflowAction);
}
ServiceBusMessage message = _cqrsMapper.Map(command, new ServiceBusMessage());
if (message == null || string.IsNullOrEmpty(message.ChannelName))
{
throw new DSWException($"Queue name to command [{command}] is not mapped", null, DSWExceptionCode.SC_Mapper);
}
Task.Run(async() =>
{
await _queueService.SubscribeQueue(message.ChannelName).SendToQueueAsync(message);
}).Wait();
}
}
}
catch (DSWException ex)
{
_logger.WriteError(ex, LogCategories);
}
base.AfterSave(entity);
}
private void AddMessageDelay(DateTimeOffset enqueueTime, ServiceBusMessage message) => message.ScheduledEnqueueTime = enqueueTime;
public ServiceBusMessage Create(ServiceBusMessage content)
{
return(CreateAsync(content).Result);
}
/// <summary>
/// Update service bus properties.
/// </summary>
/// <param name="serviceBusParams">Service bus message properties specified via PowerShell.</param>
/// <param name="existingServiceBusMessage">Existing job's service bus message properties.</param>
private void UpdateServiceBus(PSServiceBusParams serviceBusParams, ServiceBusMessage existingServiceBusMessage)
{
if (existingServiceBusMessage != null)
{
existingServiceBusMessage.TransportType = serviceBusParams.TransportType.GetValueOrDefaultEnum<ServiceBusTransportType?>(defaultValue: existingServiceBusMessage.TransportType);
existingServiceBusMessage.NamespaceProperty = serviceBusParams.NamespaceProperty.GetValueOrDefault(defaultValue: existingServiceBusMessage.NamespaceProperty);
existingServiceBusMessage.Message = serviceBusParams.Message.GetValueOrDefault(defaultValue: existingServiceBusMessage.Message);
this.PopulateServiceBusAuthentication(serviceBusParams.Authentication, existingServiceBusMessage.Authentication);
}
}
public TransportMessage TranslateToTransportMessage(ServiceBusMessage serviceBusMessage)
{
return new TransportMessage(serviceBusMessage);
}
private static void AddMessageLabel <T>(Message <T> eventMessage, ServiceBusMessage message) where T : IMessage => message.Subject = eventMessage.Label;
public Task <bool> DeleteAsync(ServiceBusMessage content)
{
throw new NotImplementedException();
}
public async Task Publish <T>(T @event) where T : Event
{
ServiceBusMessage message = new ServiceBusMessage(JsonConvert.SerializeObject(@event));
await serviceBusSender.SendMessageAsync(message);
}
public ServiceBusMessage Update(ServiceBusMessage content)
{
throw new NotImplementedException();
}
public async Task <IActionResult> PublishRoutineAsync(
[HttpTrigger(AuthorizationLevel.Function, HttpVerbs.Post, Route = "routines/{routineId}/publish")] HttpRequest req,
Guid routineId,
ExecutionContext context,
[ServiceBus(GymLogTopicKey)] IAsyncCollector <ServiceBusMessage> collector,
ILogger log)
{
var request = await req.ToRequestMessageAsync <PublishRequestMessage>().ConfigureAwait(false);
var eventId = context.InvocationId;
var spanId = request.SpanId;
var correlationId = request.CorrelationId;
var upn = request.Upn;
var @interface = request.Interface;
log.LogData(LogLevel.Information, request,
EventType.PublishRequestReceived, EventStatusType.Succeeded, eventId,
SpanType.Publisher, SpanStatusType.PublisherInProgress, spanId,
@interface, correlationId);
if (routineId != request.RoutineId)
{
log.LogData(LogLevel.Error, request,
EventType.InvalidPublishRequest, EventStatusType.Failed, eventId,
SpanType.Publisher, SpanStatusType.PublisherInProgress, spanId,
@interface, correlationId,
message: EventType.InvalidPublishRequest.ToDisplayName());
return(new BadRequestResult());
}
var entity = new RoutineEntity()
{
PartitionKey = correlationId.ToString(),
RowKey = eventId.ToString(),
Upn = upn,
CorrelationId = correlationId,
SpanId = spanId,
Interface = @interface,
EventId = eventId,
EventName = EventType.RoutineCompleted.ToDisplayName(),
RoutineId = routineId,
Routine = request.Routine,
};
var res = default(ObjectResult);
try
{
if (this._settings.ForceError.Publisher.Publish)
{
throw new ErrorEnforcementException("Error Enforced!");
}
await this._client.CreateTableIfNotExistsAsync(this._settings.GymLog.StorageAccount.Table.TableName).ConfigureAwait(false);
var table = this._client.GetTableClient(this._settings.GymLog.StorageAccount.Table.TableName);
var records = await table.QueryAsync <ExerciseEntity>(p => p.PartitionKey == correlationId.ToString() &&
p.SpanId == spanId)
.ToListAsync()
.ConfigureAwait(false);
records = records.Where(p => !p.Exercise.IsNullOrWhiteSpace())
.ToList();
if (!records.Any())
{
res = records.ToPublishResponseMessage(request, eventId);
log.LogData(LogLevel.Error, res.Value,
EventType.RecordNotFound, EventStatusType.Failed, eventId,
SpanType.Publisher, SpanStatusType.PublisherInProgress, spanId,
request.Interface, correlationId,
message: EventType.RecordNotFound.ToDisplayName());
return(res);
}
var entities = records.GroupBy(p => p.Exercise)
.Select(g => new ExerciseEntityGroup()
{
Exercise = g.Key, Entity = g.OrderByDescending(q => q.Timestamp).First()
})
.Select(p => p.Entity)
.OrderByDescending(p => p.Timestamp)
.ToList();
res = entities.ToPublishResponseMessage(request, eventId);
log.LogData(LogLevel.Information, res.Value,
EventType.RecordPopulated, EventStatusType.Succeeded, eventId,
SpanType.Publisher, SpanStatusType.PublisherInProgress, spanId,
@interface, correlationId,
message: EventType.RecordPopulated.ToDisplayName());
var messageId = Guid.NewGuid();
var subSpanId = Guid.NewGuid();
var timestamp = DateTimeOffset.UtcNow;
var message = (RoutineQueueMessage)(PublishResponseMessage)res.Value;
var msg = new ServiceBusMessage(message.ToJson())
{
CorrelationId = correlationId.ToString(),
MessageId = messageId.ToString(),
ContentType = ContentTypes.ApplicationJson,
};
msg.ApplicationProperties.Add("pubSpanId", spanId);
msg.ApplicationProperties.Add("subSpanId", subSpanId);
msg.ApplicationProperties.Add("interface", @interface.ToString());
msg.ApplicationProperties.Add("timestamp", timestamp.ToString(CultureInfo.InvariantCulture));
await collector.AddAsync(msg).ConfigureAwait(false);
log.LogData(LogLevel.Information, msg,
EventType.MessagePublished, EventStatusType.Succeeded, eventId,
SpanType.Publisher, SpanStatusType.PublisherInProgress, spanId,
@interface, correlationId,
messageId: messageId.ToString(),
message: EventType.MessagePublished.ToDisplayName());
var response = await table.UpsertEntityAsync(entity).ConfigureAwait(false);
var r = response.ToRoutineResponseMessage(request, eventId, entity.RoutineId);
log.LogData(response.Status.ToLogLevel(), r.Value,
response.Status.ToRoutineCompletedEventType(), response.Status.ToEventStatusType(), eventId,
SpanType.Publisher, SpanStatusType.PublisherCompleted, spanId,
@interface, correlationId,
clientRequestId: response.ClientRequestId,
message: response.Status.ToResponseMessage(r));
}
catch (Exception ex)
{
res = new InternalServerErrorObjectResult()
{
Upn = upn,
CorrelationId = correlationId,
Interface = @interface,
SpanId = spanId,
EventId = eventId,
Message = ex.Message,
};
log.LogData(LogLevel.Error, res.Value,
EventType.MessageNotPublished, EventStatusType.Failed, eventId,
SpanType.Publisher, SpanStatusType.PublisherCompleted, spanId,
@interface, correlationId,
ex: ex,
message: ex.Message);
}
return(res);
}
public bool Delete(ServiceBusMessage content)
{
throw new NotImplementedException();
}
/// <summary>
///
/// </summary>
/// <param name="message"></param>
/// <param name="timeout"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
internal async Task <long> ScheduleMessageInternalAsync(
ServiceBusMessage message,
TimeSpan timeout,
CancellationToken cancellationToken = default)
{
var stopWatch = Stopwatch.StartNew();
using (AmqpMessage amqpMessage = AmqpMessageConverter.SBMessageToAmqpMessage(message))
{
var request = AmqpRequestMessage.CreateRequest(
ManagementConstants.Operations.ScheduleMessageOperation,
timeout,
null);
if (_sendLink.TryGetOpenedObject(out SendingAmqpLink sendLink))
{
request.AmqpMessage.ApplicationProperties.Map[ManagementConstants.Request.AssociatedLinkName] = sendLink.Name;
}
ArraySegment <byte>[] payload = amqpMessage.GetPayload();
var buffer = new BufferListStream(payload);
ArraySegment <byte> value = buffer.ReadBytes((int)buffer.Length);
var entry = new AmqpMap();
{
entry[ManagementConstants.Properties.Message] = value;
entry[ManagementConstants.Properties.MessageId] = message.MessageId;
if (!string.IsNullOrWhiteSpace(message.SessionId))
{
entry[ManagementConstants.Properties.SessionId] = message.SessionId;
}
if (!string.IsNullOrWhiteSpace(message.PartitionKey))
{
entry[ManagementConstants.Properties.PartitionKey] = message.PartitionKey;
}
if (!string.IsNullOrWhiteSpace(message.ViaPartitionKey))
{
entry[ManagementConstants.Properties.ViaPartitionKey] = message.ViaPartitionKey;
}
}
request.Map[ManagementConstants.Properties.Messages] = new List <AmqpMap> {
entry
};
RequestResponseAmqpLink mgmtLink = await _managementLink.GetOrCreateAsync(
UseMinimum(_connectionScope.SessionTimeout,
timeout.CalculateRemaining(stopWatch.Elapsed)))
.ConfigureAwait(false);
using AmqpMessage response = await mgmtLink.RequestAsync(
request.AmqpMessage,
timeout.CalculateRemaining(stopWatch.Elapsed))
.ConfigureAwait(false);
cancellationToken.ThrowIfCancellationRequested <TaskCanceledException>();
stopWatch.Stop();
AmqpResponseMessage amqpResponseMessage = AmqpResponseMessage.CreateResponse(response);
if (amqpResponseMessage.StatusCode == AmqpResponseStatusCode.OK)
{
var sequenceNumbers = amqpResponseMessage.GetValue <long[]>(ManagementConstants.Properties.SequenceNumbers);
if (sequenceNumbers == null || sequenceNumbers.Length < 1)
{
throw new ServiceBusException(true, "Could not schedule message successfully.");
}
return(sequenceNumbers[0]);
}
else
{
throw amqpResponseMessage.ToMessagingContractException();
}
}
}
public async Task <bool> SendServiceBusMessage(ServiceBusMessage message)
{
return(true);
//ToDo: Add Service Bus logic here
}
protected async override Task <object> InternalProcessMessageAsync(ServiceBusMessage message)
{
Stopwatch watch = Stopwatch.StartNew();
Interlocked.Increment(ref _receivedMessage);
lock (typeof(CsvProcessor))
{
_maxAge = Math.Max(Math.Abs(message.Age.Ticks), _maxAge);
}
Payload payload = null;
try
{
string jsonSerialized = System.Text.Encoding.UTF8.GetString(message.Data);
payload = await JsonConvert.DeserializeObjectAsync <Payload>(jsonSerialized);
if (payload.IsRequest)
{
Interlocked.Increment(ref _requestCount);
var responsePayload = new Payload()
{
IsRequest = false,
Sql = payload.Sql,
Result = new List <string>()
};
string connectionString = ConfigurationManager.ConnectionStrings["default"].ConnectionString;
using (SqlConnection connection = new SqlConnection(connectionString))
{
await connection.OpenAsync();
using (SqlCommand command = new SqlCommand(payload.Sql, connection))
{
command.CommandType = System.Data.CommandType.Text;
command.CommandTimeout = 60;
command.CommandText = payload.Sql;
using (var reader = await command.ExecuteReaderAsync())
{
bool read = await reader.ReadAsync();
if (read)
{
int recordIndex = 0;
object[] fieldsFlyWeight = new object[reader.FieldCount];
while (read != false)
{
var values = reader.GetValues(fieldsFlyWeight);
recordIndex++;
var csv = String.Join(",", fieldsFlyWeight);
responsePayload.Result.Add(csv);
read = await reader.ReadAsync();
}
}
}
}
}
if (message.OriginatorRequiresReply)
{
var data = System.Text.Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(responsePayload));
var replyMessage = ServiceBusMessage.CreateReply(message, data, DataFormatEnum.BinaryNet);
Interlocked.Increment(ref _replyCount);
Root.ServiceBusInstance.SendAsync(replyMessage);
}
}
else
{
Interlocked.Increment(ref _responseCount);
}
}
catch (Exception ex)
{
throw ex;
}
finally
{
lock (typeof(CsvProcessor))
{
_maxProcessingTime = Math.Max((watch.Elapsed).Ticks, _maxProcessingTime);
}
watch.Stop();
}
return(payload);
}
public async Task ProcessMessages()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
#region Snippet:ServiceBusProcessMessages
#if SNIPPET
string connectionString = "<connection_string>";
string queueName = "<queue_name>";
// since ServiceBusClient implements IAsyncDisposable we create it with "await using"
await using var client = new ServiceBusClient(connectionString);
#else
string connectionString = TestEnvironment.ServiceBusConnectionString;
string queueName = scope.QueueName;
await using var client = CreateClient();
#endif
// create the sender
ServiceBusSender sender = client.CreateSender(queueName);
// create a set of messages that we can send
ServiceBusMessage[] messages = new ServiceBusMessage[]
{
new ServiceBusMessage("First"),
new ServiceBusMessage("Second")
};
// send the message batch
await sender.SendMessagesAsync(messages);
#region Snippet:ServiceBusConfigureProcessor
// create the options to use for configuring the processor
var options = new ServiceBusProcessorOptions
{
// By default or when AutoCompleteMessages is set to true, the processor will complete the message after executing the message handler
// Set AutoCompleteMessages to false to [settle messages](https://docs.microsoft.com/en-us/azure/service-bus-messaging/message-transfers-locks-settlement#peeklock) on your own.
// In both cases, if the message handler throws an exception without settling the message, the processor will abandon the message.
AutoCompleteMessages = false,
// I can also allow for multi-threading
MaxConcurrentCalls = 2
};
// create a processor that we can use to process the messages
await using ServiceBusProcessor processor = client.CreateProcessor(queueName, options);
// configure the message and error handler to use
processor.ProcessMessageAsync += MessageHandler;
processor.ProcessErrorAsync += ErrorHandler;
async Task MessageHandler(ProcessMessageEventArgs args)
{
string body = args.Message.Body.ToString();
Console.WriteLine(body);
// we can evaluate application logic and use that to determine how to settle the message.
await args.CompleteMessageAsync(args.Message);
}
Task ErrorHandler(ProcessErrorEventArgs args)
{
// the error source tells me at what point in the processing an error occurred
Console.WriteLine(args.ErrorSource);
// the fully qualified namespace is available
Console.WriteLine(args.FullyQualifiedNamespace);
// as well as the entity path
Console.WriteLine(args.EntityPath);
Console.WriteLine(args.Exception.ToString());
return(Task.CompletedTask);
}
// start processing
await processor.StartProcessingAsync();
// since the processing happens in the background, we add a Conole.ReadKey to allow the processing to continue until a key is pressed.
Console.ReadKey();
#endregion
#endregion
}
}
public static AmqpMessage SBMessageToAmqpMessage(ServiceBusMessage sbMessage)
{
var amqpMessage = sbMessage.ToAmqpMessage();
amqpMessage.Properties.MessageId = sbMessage.MessageId;
amqpMessage.Properties.CorrelationId = sbMessage.CorrelationId;
amqpMessage.Properties.ContentType = sbMessage.ContentType;
amqpMessage.Properties.Subject = sbMessage.Subject;
amqpMessage.Properties.To = sbMessage.To;
amqpMessage.Properties.ReplyTo = sbMessage.ReplyTo;
amqpMessage.Properties.GroupId = sbMessage.SessionId;
amqpMessage.Properties.ReplyToGroupId = sbMessage.ReplyToSessionId;
if (sbMessage.TimeToLive != TimeSpan.MaxValue)
{
amqpMessage.Header.Ttl = (uint)sbMessage.TimeToLive.TotalMilliseconds;
amqpMessage.Properties.CreationTime = DateTime.UtcNow;
if (AmqpConstants.MaxAbsoluteExpiryTime - amqpMessage.Properties.CreationTime.Value > sbMessage.TimeToLive)
{
amqpMessage.Properties.AbsoluteExpiryTime = amqpMessage.Properties.CreationTime.Value + sbMessage.TimeToLive;
}
else
{
amqpMessage.Properties.AbsoluteExpiryTime = AmqpConstants.MaxAbsoluteExpiryTime;
}
}
if ((sbMessage.ScheduledEnqueueTime != null) && sbMessage.ScheduledEnqueueTime > DateTimeOffset.MinValue)
{
amqpMessage.MessageAnnotations.Map.Add(AmqpMessageConstants.ScheduledEnqueueTimeUtcName, sbMessage.ScheduledEnqueueTime.UtcDateTime);
}
if (sbMessage.PartitionKey != null)
{
amqpMessage.MessageAnnotations.Map.Add(AmqpMessageConstants.PartitionKeyName, sbMessage.PartitionKey);
}
if (sbMessage.TransactionPartitionKey != null)
{
amqpMessage.MessageAnnotations.Map.Add(AmqpMessageConstants.ViaPartitionKeyName, sbMessage.TransactionPartitionKey);
}
if (sbMessage.ApplicationProperties != null && sbMessage.ApplicationProperties.Count > 0)
{
if (amqpMessage.ApplicationProperties == null)
{
amqpMessage.ApplicationProperties = new ApplicationProperties();
}
foreach (var pair in sbMessage.ApplicationProperties)
{
if (TryGetAmqpObjectFromNetObject(pair.Value, MappingType.ApplicationProperty, out var amqpObject))
{
amqpMessage.ApplicationProperties.Map.Add(pair.Key, amqpObject);
}
else
{
throw new NotSupportedException(Resources.InvalidAmqpMessageProperty.FormatForUser(pair.Key.GetType()));
}
}
}
return(amqpMessage);
}
public async Task CreateFromReceivedMessageCopiesProperties()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: true, enableSession: true))
{
var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
var sender = client.CreateSender(scope.QueueName);
var msg = new ServiceBusMessage(new BinaryData(GetRandomBuffer(100)));
msg.ContentType = "contenttype";
msg.CorrelationId = "correlationid";
msg.Subject = "label";
msg.MessageId = "messageId";
msg.PartitionKey = "key";
msg.ApplicationProperties.Add("testProp", "my prop");
msg.ReplyTo = "replyto";
msg.ReplyToSessionId = "replytosession";
msg.ScheduledEnqueueTime = DateTimeOffset.Now;
msg.SessionId = "key";
msg.TimeToLive = TimeSpan.FromSeconds(60);
msg.To = "to";
await sender.SendMessageAsync(msg);
ServiceBusSessionReceiver receiver = await client.AcceptNextSessionAsync(scope.QueueName);
ServiceBusReceivedMessage received = await receiver.ReceiveMessageAsync();
AmqpAnnotatedMessage rawReceived = received.GetRawAmqpMessage();
Assert.IsNotNull(rawReceived.Header.DeliveryCount);
Assert.IsTrue(rawReceived.MessageAnnotations.ContainsKey(AmqpMessageConstants.LockedUntilName));
Assert.IsTrue(rawReceived.MessageAnnotations.ContainsKey(AmqpMessageConstants.SequenceNumberName));
Assert.IsTrue(rawReceived.MessageAnnotations.ContainsKey(AmqpMessageConstants.EnqueueSequenceNumberName));
Assert.IsTrue(rawReceived.MessageAnnotations.ContainsKey(AmqpMessageConstants.EnqueuedTimeUtcName));
AssertMessagesEqual(msg, received);
var toSend = new ServiceBusMessage(received);
AmqpAnnotatedMessage rawSend = toSend.GetRawAmqpMessage();
// verify that all system set properties have been cleared out
Assert.IsNull(rawSend.Header.DeliveryCount);
Assert.IsFalse(rawSend.MessageAnnotations.ContainsKey(AmqpMessageConstants.LockedUntilName));
Assert.IsFalse(rawSend.MessageAnnotations.ContainsKey(AmqpMessageConstants.SequenceNumberName));
Assert.IsFalse(rawSend.MessageAnnotations.ContainsKey(AmqpMessageConstants.DeadLetterSourceName));
Assert.IsFalse(rawSend.MessageAnnotations.ContainsKey(AmqpMessageConstants.EnqueueSequenceNumberName));
Assert.IsFalse(rawSend.MessageAnnotations.ContainsKey(AmqpMessageConstants.EnqueuedTimeUtcName));
Assert.IsFalse(rawSend.MessageAnnotations.ContainsKey(AmqpMessageConstants.DeadLetterSourceName));
Assert.IsFalse(toSend.ApplicationProperties.ContainsKey(AmqpMessageConstants.DeadLetterReasonHeader));
Assert.IsFalse(toSend.ApplicationProperties.ContainsKey(AmqpMessageConstants.DeadLetterErrorDescriptionHeader));
AssertMessagesEqual(toSend, received);
void AssertMessagesEqual(ServiceBusMessage sentMessage, ServiceBusReceivedMessage received)
{
Assert.IsTrue(received.Body.ToArray().SequenceEqual(sentMessage.Body.ToArray()));
Assert.AreEqual(received.ContentType, sentMessage.ContentType);
Assert.AreEqual(received.CorrelationId, sentMessage.CorrelationId);
Assert.AreEqual(received.Subject, sentMessage.Subject);
Assert.AreEqual(received.ContentType, sentMessage.ContentType);
Assert.AreEqual(received.CorrelationId, sentMessage.CorrelationId);
Assert.AreEqual(received.MessageId, sentMessage.MessageId);
Assert.AreEqual(received.PartitionKey, sentMessage.PartitionKey);
Assert.AreEqual((string)received.ApplicationProperties["testProp"], (string)sentMessage.ApplicationProperties["testProp"]);
Assert.AreEqual(received.ReplyTo, sentMessage.ReplyTo);
Assert.AreEqual(received.ReplyToSessionId, sentMessage.ReplyToSessionId);
Assert.AreEqual(received.ScheduledEnqueueTime.UtcDateTime.Second, sentMessage.ScheduledEnqueueTime.UtcDateTime.Second);
Assert.AreEqual(received.SessionId, sentMessage.SessionId);
Assert.AreEqual(received.TimeToLive, sentMessage.TimeToLive);
Assert.AreEqual(received.To, sentMessage.To);
Assert.AreEqual(received.TransactionPartitionKey, sentMessage.TransactionPartitionKey);
}
}
}
private async Task SendAsync(ServiceBusSender client, ServiceBusMessage message, CancellationToken cancellationToken)
{
await client.SendMessageAsync(message, cancellationToken).ConfigureAwait(false);
}
public async Task TransactionThrowsWhenOperationsOfDifferentPartitionsAreInSameTransaction()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: true, enableSession: false))
{
var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.CreateSender(scope.QueueName);
ServiceBusReceiver receiver = client.CreateReceiver(scope.QueueName);
string body = Guid.NewGuid().ToString("N");
ServiceBusMessage message1 = GetMessage(partitionKey: "1");
ServiceBusMessage message2 = GetMessage(partitionKey: "2");
// Two send operations to different partitions.
var transaction = new CommittableTransaction();
using (TransactionScope ts = new TransactionScope(transaction, TransactionScopeAsyncFlowOption.Enabled))
{
await sender.SendAsync(message1);
Assert.ThrowsAsync <InvalidOperationException>(
async() => await sender.SendAsync(message2));
ts.Complete();
}
transaction.Rollback();
// Adding delay since transaction Commit/Rollback is an asynchronous operation.
// Operating on the same message should not be done.
await Task.Delay(TimeSpan.FromSeconds(2));
// Two complete operations to different partitions.
await sender.SendAsync(message1);
await sender.SendAsync(message2);
ServiceBusReceivedMessage receivedMessage1 = await receiver.ReceiveAsync();
Assert.NotNull(receivedMessage1);
ServiceBusReceivedMessage receivedMessage2 = await receiver.ReceiveAsync();
Assert.NotNull(receivedMessage2);
transaction = new CommittableTransaction();
using (TransactionScope ts = new TransactionScope(transaction, TransactionScopeAsyncFlowOption.Enabled))
{
await receiver.CompleteAsync(receivedMessage1);
Assert.ThrowsAsync <InvalidOperationException>(
async() => await receiver.CompleteAsync(receivedMessage2));
ts.Complete();
}
transaction.Rollback();
// Adding delay since transaction Commit/Rollback is an asynchronous operation.
// Operating on the same message should not be done.
await Task.Delay(TimeSpan.FromSeconds(2));
await receiver.CompleteAsync(receivedMessage1);
// the service seems to abandon the message that
// triggered the InvalidOperationException
// in the transaction
Assert.That(
async() =>
await receiver.CompleteAsync(receivedMessage2), Throws.InstanceOf <ServiceBusException>()
.And.Property(nameof(ServiceBusException.Reason))
.EqualTo(ServiceBusException.FailureReason.MessageLockLost));
}
}
private void SendResponseDataErrorEvent(ServiceBusMessage result)
{
SendClientResponse(result, (action, content) => action.udsDataError(result.Content));
}
public async Task TransactionalSendViaCommitTest()
{
var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
await using var intermediateQueue = await ServiceBusScope.CreateWithQueue(enablePartitioning : true, enableSession : false);
await using var destination1 = await ServiceBusScope.CreateWithTopic(enablePartitioning : true, enableSession : false);
await using var destination2 = await ServiceBusScope.CreateWithQueue(enablePartitioning : true, enableSession : false);
var intermediateSender = client.CreateSender(intermediateQueue.QueueName);
var intermediateReceiver = client.CreateReceiver(intermediateQueue.QueueName);
var destination1Sender = client.CreateSender(destination1.TopicName);
var destination1ViaSender = client.CreateSender(destination1.TopicName, new ServiceBusSenderOptions
{
ViaQueueOrTopicName = intermediateQueue.QueueName
});
var destination2ViaSender = client.CreateSender(destination2.QueueName, new ServiceBusSenderOptions
{
ViaQueueOrTopicName = intermediateQueue.QueueName
});
var destination1Receiver = client.CreateReceiver(destination1.TopicName, destination1.SubscriptionNames.First());
var destination2Receiver = client.CreateReceiver(destination2.QueueName);
var body = Encoding.Default.GetBytes(Guid.NewGuid().ToString("N"));
var message1 = new ServiceBusMessage(body)
{
MessageId = "1", PartitionKey = "pk1"
};
var message2 = new ServiceBusMessage(body)
{
MessageId = "2", PartitionKey = "pk2", ViaPartitionKey = "pk1"
};
var message3 = new ServiceBusMessage(body)
{
MessageId = "3", PartitionKey = "pk3", ViaPartitionKey = "pk1"
};
await intermediateSender.SendAsync(message1).ConfigureAwait(false);
var receivedMessage = await intermediateReceiver.ReceiveAsync();
Assert.NotNull(receivedMessage);
Assert.AreEqual("pk1", receivedMessage.PartitionKey);
// If the transaction succeeds, then all the operations occurred on the same partition.
using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
await intermediateReceiver.CompleteAsync(receivedMessage);
await destination1ViaSender.SendAsync(message2);
await destination2ViaSender.SendAsync(message3);
ts.Complete();
}
// Assert that first message indeed completed.
receivedMessage = await intermediateReceiver.ReceiveAsync(TimeSpan.FromSeconds(5));
Assert.Null(receivedMessage);
// Assert that second message reached its destination.
var receivedMessage1 = await destination1Receiver.ReceiveAsync();
Assert.NotNull(receivedMessage1);
Assert.AreEqual("pk2", receivedMessage1.PartitionKey);
// Assert destination1 message actually used partitionKey in the destination entity.
var destination1Message = new ServiceBusMessage(body)
{
PartitionKey = "pk2"
};
using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
await destination1Receiver.CompleteAsync(receivedMessage1);
await destination1Sender.SendAsync(destination1Message);
ts.Complete();
}
// Assert that third message reached its destination.
var receivedMessage2 = await destination2Receiver.ReceiveAsync();
Assert.NotNull(receivedMessage2);
Assert.AreEqual("pk3", receivedMessage2.PartitionKey);
await destination2Receiver.CompleteAsync(receivedMessage2);
// Cleanup
receivedMessage1 = await destination1Receiver.ReceiveAsync();
await destination1Receiver.CompleteAsync(receivedMessage1);
}
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context)
{
context.OwinContext.Response.Headers.Add("Access-Control-Allow-Origin", new[] { "*" });
string appId, kind, username, @params, authRule, year, number, uniqueId, token, user;
appId = kind = username = @params = authRule = year = number = uniqueId = token = user = string.Empty;
try
{
_logger.WriteDebug(new LogMessage("GrantResourceOwnerCredentials"), LogCategories);
IFormCollection forms = await context.OwinContext.Request.ReadFormAsync();
appId = forms.Single(f => f.Key == "appId").Value.Single();
_logger.WriteDebug(new LogMessage(string.Concat("AppID-> ", appId)), LogCategories);
kind = forms.Single(f => f.Key == "kind").Value.Single();
_logger.WriteDebug(new LogMessage(string.Concat("Kind-> ", kind)), LogCategories);
username = forms.Single(f => f.Key == "username").Value.Single();
_logger.WriteDebug(new LogMessage(string.Concat("Username-> ", username)), LogCategories);
authRule = forms.Single(f => f.Key == "authRule").Value.Single();
_logger.WriteDebug(new LogMessage(string.Concat("AuthRule-> ", authRule)), LogCategories);
@params = forms.Single(f => f.Key == "params").Value.SingleOrDefault();
_logger.WriteDebug(new LogMessage(string.Concat("Params-> ", @params)), LogCategories);
if (kind == "Protocol")
{
string[] keys = @params.Split('|');
year = keys.Single(f => f.StartsWith("year=")).Split('=').Last();
number = keys.Single(f => f.StartsWith("number=")).Split('=').Last();
uniqueId = _unitOfWork.Repository <Protocol>().GetByCompositeKey(short.Parse(year), int.Parse(number)).Single().UniqueId.ToString();
}
if (kind == "Protocol" && authRule == VALUE_ExternalViewer_AuthenticationRule_Token)
{
string[] keys = @params.Split('|');
token = keys.Single(f => f.StartsWith("token=")).Split('=').Last();
user = keys.Single(f => f.StartsWith("user="******"The AppId '{appId}' is not valid."), LogCategories);
context.SetError("invalid_grant", $"The AppId {appId} is not valid.");
context.Rejected();
return;
}
if (string.IsNullOrEmpty(kind))
{
_logger.WriteWarning(new LogMessage($"The Kind '{kind}' is not valid."), LogCategories);
context.SetError("invalid_grant", "The Kind is not valid.");
context.Rejected();
return;
}
if (string.IsNullOrEmpty(username) || !ValidIntegrations.Any(f => f.Key == username))
{
_logger.WriteWarning(new LogMessage($"The Username '{username}' is not valid."), LogCategories);
context.SetError("invalid_grant", $"The Username {username} is not valid.");
context.Rejected();
return;
}
if (string.IsNullOrEmpty(authRule))
{
_logger.WriteWarning(new LogMessage($"The AuthRule '{authRule}' is not valid."), LogCategories);
context.SetError("invalid_grant", "The AuthRule is not valid.");
context.Rejected();
return;
}
currentIntegration = ValidIntegrations[username];
if (currentIntegration.Key != authenticationId || currentIntegration.Value != authRule)
{
_logger.WriteWarning(new LogMessage($"{username}: The configuration is not valid."), LogCategories);
context.SetError("invalid_grant", "The configuration is not valid.");
context.Rejected();
return;
}
if (kind == "Protocol" && authRule == VALUE_ExternalViewer_AuthenticationRule_OAuth2 &&
(string.IsNullOrEmpty(year) || string.IsNullOrEmpty(number)))
{
_logger.WriteWarning(new LogMessage($"The protocols oauth2 params {year}/{number} is not valid."), LogCategories);
context.SetError("invalid_grant", "The protocols oauth2 params is not valid.");
context.Rejected();
return;
}
if (kind == "Protocol" && authRule == VALUE_ExternalViewer_AuthenticationRule_Token &&
(string.IsNullOrEmpty(user) || string.IsNullOrEmpty(token) || string.IsNullOrEmpty(year) || string.IsNullOrEmpty(number)))
{
_logger.WriteWarning(new LogMessage($"The protocols token params {user}/{token}/{year}/{number} is not valid."), LogCategories);
context.SetError("invalid_grant", "The protocols token params is not valid.");
context.Rejected();
return;
}
if (kind == "Protocol" && authRule == VALUE_ExternalViewer_AuthenticationRule_Token)
{
string topicName = _messageConfiguration.GetConfigurations()["EventTokenSecurity"].TopicName;
if (!await _topicService.SubscriptionExists(topicName, token))
{
_logger.WriteWarning(new LogMessage($"AppId {appId} has no valid token {authenticationId}"), LogCategories);
context.SetError($"AppId {appId} has not validate token {authenticationId}", "The protocols params is not valid.");
context.Rejected();
return;
}
ServiceBusMessage serviceBusMessage = (await _topicService.GetMessagesAsync(topicName, token)).FirstOrDefault();
IEventTokenSecurity tokenSecurityModel = null;
if (serviceBusMessage == null || (tokenSecurityModel = (IEventTokenSecurity)serviceBusMessage.Content) == null)
{
_logger.WriteWarning(new LogMessage($"AppId {appId} has no valid token"), LogCategories);
context.SetError($"AppId {appId} has not validate token {token}", "The protocols params is not valid.");
context.Rejected();
return;
}
if (tokenSecurityModel.ContentType.ContentTypeValue.DocumentUnitAuhtorized.UniqueId.ToString() != uniqueId)
{
_logger.WriteWarning(new LogMessage($"AppId {appId} token is not valid for protocol {uniqueId}-{year}/{number}"), LogCategories);
context.SetError($"AppId {appId} token is not valid for protocol {uniqueId}-{year}/{number}", "The protocols params is not valid.");
context.Rejected();
return;
}
Guid secureToken = tokenSecurityModel.ContentType.ContentTypeValue.Token;
_logger.WriteDebug(new LogMessage($"SecureToken is {secureToken}"), LogCategories);
}
ClaimsIdentity identity = new ClaimsIdentity(context.Options.AuthenticationType);
identity.AddClaim(new Claim(CLAIM_ExternalViewer_OAuth2_Kind, kind, ClaimValueTypes.String, ClaimsIdentity.DefaultIssuer, string.Empty));
identity.AddClaim(new Claim(CLAIM_ExternalViewer_AuthenticationRule, authRule, ClaimValueTypes.String, ClaimsIdentity.DefaultIssuer, string.Empty));
if (kind == "Protocol")
{
identity.AddClaim(new Claim(CLAIM_ExternalViewer_OAuth2_Year, year, ClaimValueTypes.String, ClaimsIdentity.DefaultIssuer, string.Empty));
identity.AddClaim(new Claim(CLAIM_ExternalViewer_OAuth2_Number, number, ClaimValueTypes.String, ClaimsIdentity.DefaultIssuer, string.Empty));
identity.AddClaim(new Claim(CLAIM_ExternalViewer_OAuth2_UniqueId, uniqueId, ClaimValueTypes.String, ClaimsIdentity.DefaultIssuer, string.Empty));
if (authRule == VALUE_ExternalViewer_AuthenticationRule_Token)
{
identity.AddClaim(new Claim(CLAIM_ExternalViewer_Token_Hash, token, ClaimValueTypes.String, ClaimsIdentity.DefaultIssuer, string.Empty));
identity.AddClaim(new Claim(CLAIM_ExternalViewer_Token_User, user, ClaimValueTypes.String, ClaimsIdentity.DefaultIssuer, string.Empty));
}
}
context.Validated(identity);
}
private static async Task Main(string[] args)
{
await using var stage = await Prepare.Stage(connectionString, destination);
await using var serviceBusClient = new ServiceBusClient(connectionString);
await using var sender = serviceBusClient.CreateSender(destination);
var messages = new List <ServiceBusMessage>();
for (var i = 0; i < 10; i++)
{
var message = new ServiceBusMessage("Deep Dive{i}");
messages.Add(message);
}
WriteLine($"Sending {messages.Count} messages in a batch.");
await sender.SendMessagesAsync(messages);
messages.Clear();
WriteLine();
for (var i = 0; i < 6500; i++)
{
var message = new ServiceBusMessage($"Deep Dive{i}");
messages.Add(message);
}
try
{
WriteLine($"Sending {messages.Count} messages in a batch.");
await sender.SendMessagesAsync(messages);
}
catch (ServiceBusException ex) when(ex.Reason == ServiceBusFailureReason.MessageSizeExceeded)
{
await Error.WriteLineAsync(ex.Message);
}
messages.Clear();
WriteLine();
for (var i = 0; i < 101; i++)
{
var message = new ServiceBusMessage($"Deep Dive{i}");
messages.Add(message);
}
try
{
using (var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
WriteLine($"Sending {messages.Count} messages in a batch with in transaction '{Transaction.Current.TransactionInformation.LocalIdentifier}'.");
await sender.SendMessagesAsync(messages);
scope.Complete();
}
}
catch (ServiceBusException ex) when(ex.Reason == ServiceBusFailureReason.QuotaExceeded)
{
await Error.WriteLineAsync(ex.Message);
}
var messagesToSend = new Queue <ServiceBusMessage>();
for (var i = 0; i < 4500; i++)
{
var message = new ServiceBusMessage($"Deep Dive{i}. Deep Dive{i}. Deep Dive{i}.");
messagesToSend.Enqueue(message);
}
var messageCount = messagesToSend.Count;
int batchCount = 1;
while (messagesToSend.Count > 0)
{
using ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync();
if (messageBatch.TryAddMessage(messagesToSend.Peek()))
{
messagesToSend.Dequeue();
}
else
{
throw new Exception($"Message {messageCount - messagesToSend.Count} is too large and cannot be sent.");
}
while (messagesToSend.Count > 0 && messageBatch.TryAddMessage(messagesToSend.Peek()))
{
messagesToSend.Dequeue();
}
WriteLine($"Sending {messageBatch.Count} messages in a batch {batchCount++}.");
await sender.SendMessagesAsync(messageBatch);
}
}
private static void AddMessageId <T>(Message <T> eventMessage, ServiceBusMessage message) where T : IMessage => message.MessageId = eventMessage.MessageId;
/// <summary>
/// Populates Service bus message object with valid values.
/// </summary>
/// <param name="serviceBusQueueActionParams">Service bus properties specified via PowerShell.</param>
/// <param name="serviceBusMessage">Servce message object to be populated.</param>
private void PopulateServiceBusMessage(PSServiceBusParams serviceBusQueueActionParams, ServiceBusMessage serviceBusMessage)
{
if (string.IsNullOrWhiteSpace(serviceBusQueueActionParams.NamespaceProperty) ||
string.IsNullOrWhiteSpace(serviceBusQueueActionParams.Message) ||
string.IsNullOrWhiteSpace(serviceBusQueueActionParams.TransportType))
{
throw new PSManagement.PSArgumentException(Resources.SchedulerInvalidServiceBus);
}
if (serviceBusMessage == null)
{
throw new ArgumentException("serviceBusMessage: Object must be initialized");
}
ServiceBusAuthentication authentication = this.GetServiceBusAuthentication(serviceBusQueueActionParams.Authentication);
serviceBusMessage.Authentication = this.GetServiceBusAuthentication(serviceBusQueueActionParams.Authentication);
serviceBusMessage.Message = serviceBusQueueActionParams.Message;
serviceBusMessage.NamespaceProperty = serviceBusQueueActionParams.NamespaceProperty;
serviceBusMessage.TransportType = serviceBusQueueActionParams.TransportType.GetValueOrDefaultEnum<ServiceBusTransportType>(defaultValue: ServiceBusTransportType.NetMessaging);
}
