public void SetupSecondAzureServiceBusTestFixture()
{
_secondBus = CreateSecondBus();
_secondBusHandle = _secondBus.Start();
try
{
_secondBusSendEndpoint = Await(() => _secondBus.GetSendEndpoint(_secondBus.Address));
_secondInputQueueSendEndpoint = Await(() => _secondBus.GetSendEndpoint(_secondInputQueueAddress));
}
catch (Exception)
{
try
{
using (var tokenSource = new CancellationTokenSource(TestTimeout))
{
_secondBusHandle.Stop(tokenSource.Token);
}
}
finally
{
_secondBusHandle = null;
_secondBus = null;
}
throw;
}
}
public void SetupAzureServiceBusTestFixture()
{
_bus = CreateBus();
_bus.ConnectReceiveEndpointObserver(new ReceiveEndpointObserver());
_busHandle = _bus.Start();
try
{
Await(() => _busHandle.Ready);
_busSendEndpoint = _bus.GetSendEndpoint(_bus.Address).Result;
_busSendEndpoint.ConnectSendObserver(_sendObserver);
_inputQueueSendEndpoint = _bus.GetSendEndpoint(_inputQueueAddress).Result;
_inputQueueSendEndpoint.ConnectSendObserver(_sendObserver);
}
catch (Exception ex)
{
Console.WriteLine("The bus creation failed: {0}", ex);
_busHandle.Stop();
throw;
}
}
public async Task Send <TWorkflowMessage>(IEndpointConfiguration endpointConfiguration, TWorkflowMessage workflowMessage, CancellationToken cancellationToken)
where TWorkflowMessage : class, IWorkflowMessage
{
var sendEndpoint = await _busControl.GetSendEndpoint(endpointConfiguration.Address).ConfigureAwait(false);
await sendEndpoint.Send(workflowMessage, cancellationToken).ConfigureAwait(false);
}
public async Task <IActionResult> executeplanning(RequiredAdaptation requiredAdaptation)
{
IEnumerable <MicroController> microControllers = await _executorService.GetPlanning(requiredAdaptation);
//foreach (var mc in microControllers)
// {
//if (mc.Id == 1)
//{
Uri uri = new Uri($"rabbitmq://localhost/regressiontest");
var endPoint = await _bus.GetSendEndpoint(uri);
await endPoint.Send(requiredAdaptation);
//}
//if (mc.Id == 2)
//{
Uri uri2 = new Uri($"rabbitmq://localhost/errerdetection");
var endPoint2 = await _bus.GetSendEndpoint(uri2);
await endPoint2.Send(requiredAdaptation);
//}
//if (mc.Id == 3)
//{
//}
//}
return(Ok(true));
}
public void SetupInMemoryTestFixture()
{
_bus = CreateBus();
_busHandle = _bus.Start();
try
{
_busSendEndpoint = Await(() => _bus.GetSendEndpoint(_bus.Address));
_busSendEndpoint.ConnectSendObserver(_sendObserver);
_inputQueueSendEndpoint = Await(() => _bus.GetSendEndpoint(_inputQueueAddress));
_inputQueueSendEndpoint.ConnectSendObserver(_sendObserver);
}
catch (Exception)
{
try
{
using (var tokenSource = new CancellationTokenSource(TestTimeout))
{
_busHandle?.Stop(tokenSource.Token);
}
}
finally
{
_busHandle = null;
_bus = null;
}
throw;
}
}
public async Task <IHttpActionResult> RegiterNew(OrderDTO orderDTO)
{
var order = new Order(orderDTO.CustomerName, orderDTO.CustomerPhone, orderDTO.PizzaID, Guid.NewGuid());
_dbSet.Add(order);
await _context.SaveChangesAsync();
orderDTO = (OrderDTO) new OrderDTO().InjectFrom(order);
orderDTO.StatusDescription = ((OrderStatus)order.Status).ToString();
var endPoint = await _bus.GetSendEndpoint(_sendToUri);
await endPoint.Send <IRegisterOrderCommand>(new
{
OrderID = order.OrderID,
CustomerName = orderDTO.CustomerName,
CustomerPhone = orderDTO.CustomerPhone,
PizzaID = orderDTO.PizzaID,
CorrelationId = order.CorrelationId,
Timestamp = DateTime.UtcNow
});
return(Created(new Uri(_baseUri + orderDTO.OrderID), orderDTO));
}
public void SetupAzureServiceBusTestFixture()
{
_bus = CreateBus();
_bus.ConnectReceiveEndpointObserver(new ReceiveEndpointObserver());
_busHandle = _bus.Start();
try
{
_busSendEndpoint = _bus.GetSendEndpoint(_bus.Address).Result;
_busSendEndpoint.ConnectSendObserver(_sendObserver);
_inputQueueSendEndpoint = _bus.GetSendEndpoint(_inputQueueAddress).Result;
_inputQueueSendEndpoint.ConnectSendObserver(_sendObserver);
}
catch (Exception)
{
try
{
using (var tokenSource = new CancellationTokenSource(TestTimeout))
{
_bus.Stop(tokenSource.Token);
}
}
finally
{
_busHandle = null;
_bus = null;
}
throw;
}
}
public async Task Send <T>(T command, string queue) where T : CommandEvent
{
var sendToUri = new Uri($"{"rabbitmq://localhost/"}{queue}");
var endPoint = await _bus.GetSendEndpoint(sendToUri);
await endPoint.Send <T>(command);
}
public virtual async Task Send(ICommand command)
{
if (_busControl == null)
{
throw new InvalidOperationException("MassTransit bus must be started before sending commands.");
}
var commandType = command.GetType();
ISendEndpoint endpoint;
if (_options.UseInMemoryBus)
{
endpoint = await _busControl.GetSendEndpoint(
new Uri($"loopback://localhost/{commandType.Name}"))
.ConfigureAwait(false);
}
else
{
endpoint = await _busControl.GetSendEndpoint(
new Uri($"{_options.RabbitMQUri}/{commandType.Name}"))
.ConfigureAwait(false);
}
await endpoint.Send(command, commandType).ConfigureAwait(false);
}
public async Task CreateArticle(CreateArticle createArticle)
{
var sendEndpoint =
await _busControl.GetSendEndpoint(new Uri("rabbitmq://localhost:5672/helloworld"));
await sendEndpoint.Send(createArticle);
}
public void SetupSecondAzureServiceBusTestFixture()
{
_secondBus = CreateSecondBus();
_secondBusHandle = _secondBus.Start();
try
{
_secondBusSendEndpoint = Await(() => _secondBus.GetSendEndpoint(_secondBus.Address));
_secondInputQueueSendEndpoint = Await(() => _secondBus.GetSendEndpoint(_secondInputQueueAddress));
}
catch (Exception)
{
try
{
using (var tokenSource = new CancellationTokenSource(TestTimeout))
{
_secondBusHandle.Stop(tokenSource.Token);
}
}
finally
{
_secondBusHandle = null;
_secondBus = null;
}
throw;
}
}
public Task Send <T>(string channel, T message, Type messageType, CancellationToken cancellationToken = default(CancellationToken)) where T : class
{
var sendEndPoint = _busControl.GetSendEndpoint(new Uri($"{_configuration.GetConnectionString(MicroservicesConstants.MessageBusHost)}/{channel}")).Result;
sendEndPoint.Send(message, messageType);
return(Task.CompletedTask);
}
public async Task PriceOrder(string locationCode, IPriceOrderResponse pulseResponse)
{
await Task.Delay(3000);
var endPoint = await _busControl.GetSendEndpoint(new Uri($"{CustomKey.RABBITMQ_BASE_ENDPOINT}/{CustomKey.RABBITMQ_PRICE_ORDER_RESPONSE_ENDPOINT}"));
await endPoint.SendWithHeaders <IPriceOrderResponse>(pulseResponse, _consumeContext);
}
public async Task SendAssignDeviceMsg(string deviceId, CancellationToken token)
{
var endpoint = await _busControl.GetSendEndpoint(new Uri($"queue:{string.Format(QUEUE_NAME_FORMAT, deviceId)}"));
await endpoint.Send <IDeviceStatus>(new DataCollection
{
DeviceId = deviceId,
Status = "Assigned",
When = DateTime.UtcNow
});
}
/// Sends a message
public async Task Send(CreateAccount msg)
{
if (msg == null)
{
return;
}
// sends a messaged to be consumed by CreateAccountConsumer
var sendEndpoint = await bus.GetSendEndpoint(new Uri("loopback://localhost/queue_name"));
await sendEndpoint.Send(msg);
}
private static async void DownloadPackage(IBusControl bus, string packageId)
{
var endpoint = await bus.GetSendEndpoint(new Uri(bus.Address, BusConstants.RepositoryManagerDownloadPackageMessageQueue));
var updateEndpoint = await bus.GetSendEndpoint(new Uri(bus.Address, BusConstants.IndexManagerUpdateArchiveRecordMessageQueue));
Console.WriteLine("Sending message on queue...");
// Need to update our dummy record, to not contain the primary data link. If this is not done, we get an exception
// when creating the Gebrauchskopie, as we find two VE with the same primary data link.
await updateEndpoint.Send <IUpdateArchiveRecord>(new
{
MutationId = 0,
ArchiveRecord = new ArchiveRecord
{
ArchiveRecordId = "9999",
Security = new ArchiveRecordSecurity
{
MetadataAccessToken = new List <string> {
"BAR"
}, PrimaryDataFulltextAccessToken = new List <string> {
"BAR"
},
PrimaryDataDownloadAccessToken = new List <string> {
"BAR"
}
},
Metadata = new ArchiveRecordMetadata {
PrimaryDataLink = ""
}
}
});
await endpoint.Send <IDownloadPackage>(new
{
PackageId = packageId,
ArchiveRecordId = 9999, // Id not relevant for our use case
CallerId = "MyId",
RetentionCategory = CacheRetentionCategory.UsageCopyPublic
});
Console.WriteLine("Waiting on queue to respond...");
DownloadReceivedEvent.WaitOne();
Console.WriteLine("Processed downloaded message");
AssetReadyReceivedEvent.WaitOne();
Console.WriteLine("Queue received message");
Console.WriteLine("");
Console.WriteLine("");
}
public async Task StartAsync(CancellationToken cancellationToken)
{
Console.WriteLine();
Console.WriteLine();
Console.WriteLine("How many jobs:");
var response = Console.ReadLine();
int.TryParse(response, out var n);
n = n > 0 ? n : new Random().Next(100, 5000);
_logger.LogDebug("Starting bus");
await _busControl.StartAsync(cancellationToken).ConfigureAwait(false);
_logger.LogDebug("Bus started");
_logger.LogInformation("Testing with {Count} jobs", n);
var endpoint = await _busControl.GetSendEndpoint(new Uri("loopback://localhost/create_jobs")).ConfigureAwait(false);
await endpoint.Send(new CreateJobsCommand
{
CorrelationId = NewId.Next().ToString(),
// ideally we wouldn't do this
// instead we would retrieve jobs from a store inside the consumer
// aim to keep message sizes small
Jobs = Enumerable.Range(0, n).Select(_ => NewId.NextGuid().ToString()).ToArray(),
}).ConfigureAwait(false);
}
public async Task Send <T>(T message, string reciever) where T : class, ICommand
{
var sendToUri = new Uri($"{_bus.Address.Scheme}://{_bus.Address.Host}/{reciever}");
var endPoint = await _bus.GetSendEndpoint(sendToUri);
await endPoint.Send(message);
}
private static void AppendPackage(IBusControl bus, string packageId)
{
var endpoint = bus.GetSendEndpoint(new Uri(bus.Address, BusConstants.RepositoryManagerArchiveRecordAppendPackageMessageQueue)).Result;
Console.WriteLine("Sending message on queue...");
var t = endpoint.Send <IArchiveRecordAppendPackage>(new
{
MutationId = 1,
ArchiveRecord = new ArchiveRecord
{
ArchiveRecordId = "9999",
Security = new ArchiveRecordSecurity
{
MetadataAccessToken = new List <string> {
"BAR"
}, PrimaryDataFulltextAccessToken = new List <string> {
"BAR"
},
PrimaryDataDownloadAccessToken = new List <string> {
"BAR"
}
},
Metadata = new ArchiveRecordMetadata {
PrimaryDataLink = packageId
}
}
});
}
public async Task PublishMessageAsync(dynamic e)
{
var address = "rabbitmq://localhost/messages";
var endpoint = await _bus.GetSendEndpoint(new Uri(address));
await endpoint.Send(e);
}
public async Task Send <T>(T message, string endpoint) where T : class
{
endpoint = GetEndpointAddressByName(endpoint) ?? endpoint;
var se = await _control.GetSendEndpoint(new System.Uri(endpoint));
await se.Send(message);
}
private static async Task SendMessage <MessageType>(IBusControl bus, MessageType msg, string host = null, int port = 0, string queue = null)
where MessageType : class
{
if (host == null || queue == null)
{
await bus.Publish <MessageType>(msg);
}
else
{
// Send message to the specific host and queue
Uri uri;
if (port != 0)
{
uri = new Uri($"rabbitmq://{host}:{port}/{queue}");
}
else
{
uri = new Uri($"rabbitmq://{host}/{queue}");
}
var ep = await bus.GetSendEndpoint(uri);
await ep.Send <MessageType>(msg);
}
}
public async Task <ActionResult> DeliverProduct([FromBody] DeliveryModel deliveryModel)
{
try
{
//deliver product
var identity = (System.Security.Claims.ClaimsIdentity)HttpContext.User.Identity;
var userId = identity.Claims.FirstOrDefault(c => c.Type == "userId").Value;
DeliveryDb.deliveryList.Add(new DeliveryModel(DeliveryDb.deliveryList.Count + 1, deliveryModel.orderId, userId, deliveryModel.DeliveredBy, deliveryModel.DeliveryStatus));
//change status in order
Uri uri = new Uri($"rabbitmq://{_config.GetValue<string>("RabbitMQHostName")}/delStatus");
var endPoint = await _bus.GetSendEndpoint(uri);
var order = new Common.OrderDetails();
order.OrderId = deliveryModel.orderId;
order.UserId = deliveryModel.userId;
order.IsDeliverySuccessful = deliveryModel.DeliveryStatus;
await endPoint.Send(order);
_log.LogInformation("Order has been delivered.");
return(Ok("Order Delivered"));
}
catch (Exception ex)
{
_log.LogInformation("Order can't be delivered.");
return(Ok("Order can't be delivered."));
}
}
/// <summary>
/// Sends registration message to the other application
/// </summary>
private static void SendMessage()
{
string address = "rabbitmq://localhost";
string queue = "uppgift4.domains.queueGrade";
Uri rootUri = new Uri(address);
IBusControl busControl = Bus.Factory.CreateUsingRabbitMq(r =>
{
r.Host(rootUri, settings =>
{
settings.Username("guest");
settings.Password("guest");
});
});
Task <ISendEndpoint> sendEndpointTask = busControl.GetSendEndpoint(new Uri(string.Concat(address, "/", queue)));
ISendEndpoint sendEndpoint = sendEndpointTask.Result;
while (true)
{
var message = CreateMessage();
Task sendTask = sendEndpoint.Send <IStudentRegistration>(new
{
Ideal = message[0],
CourseCode = message[1],
Term = message[2],
ExamNumber = message[3],
Grade = message[4]
});
WaitForMessage();
}
}
public static async Task Send <T>(this IBusControl busControl, T message, string queue) where T : class
{
if (Uri.TryCreate(busControl.Address, queue, out Uri endpointUri))
{
ISendEndpoint sendEndpoint;
string key = endpointUri.ToString();
if (Endpoints.ContainsKey(key))
{
sendEndpoint = Endpoints[key];
}
else
{
lock (SyncLock)
{
if (Endpoints.ContainsKey(key))
{
sendEndpoint = Endpoints[key];
}
else
{
sendEndpoint = busControl.GetSendEndpoint(endpointUri).Result;
Endpoints.Add(key, sendEndpoint);
}
}
}
await sendEndpoint.Send(message);
}
else
{
throw new ConfigurationException($"We cannot initialize a new Uri from these sources: Address:{busControl.Address} Queue:{queue}");
}
}
private static void ScheduleMessagesWithQuartzInMemory()
{
string rabbitMqAddress = "rabbitmq://localhost:5672/accounting";
string rabbitMqQueue = "mycompany.queues.news.scheduled";
Uri rabbitMqRootUri = new Uri(rabbitMqAddress);
IBusControl rabbitBusControl = Bus.Factory.CreateUsingRabbitMq(rabbit =>
{
rabbit.Host(rabbitMqRootUri, settings =>
{
settings.Password("accountant");
settings.Username("accountant");
});
rabbit.UseInMemoryScheduler();
});
Uri sendUri = new Uri(string.Concat(rabbitMqAddress, "/", rabbitMqQueue));
Task <ISendEndpoint> sendEndpointTask = rabbitBusControl.GetSendEndpoint(sendUri);
ISendEndpoint sendEndpoint = sendEndpointTask.Result;
Task <ScheduledMessage <IWorldNews> > scheduledMessageTask = sendEndpoint.ScheduleSend <IWorldNews>
(new Uri("rabbitmq://localhost:5672/quartz"), TimeSpan.FromSeconds(30), new { Message = "The world is going down." });
ScheduledMessage <IWorldNews> scheduledMessage = scheduledMessageTask.Result;
Console.ReadKey();
}
/// <summary>
/// Послать сообщение в очередь
/// </summary>
/// <typeparam name="T">тип сообщения</typeparam>
/// <param name="message">сообщение</param>
/// <returns>Task</returns>
public async Task Send <T>(T message) where T : class, IWithQueueName
{
CheckForNull(message);
var queueName = GetQueueNameOrThrow(message);
InitBusAndThrowOnError();
var sendEndpoint = await _bus.GetSendEndpoint(ComposeUri(queueName));
if (sendEndpoint == null)
{
throw new Exception($"Не удалось найти очередь {queueName}");
}
await sendEndpoint.Send(message, pc => pc.SetAwaitAck(false));
}
public async Task <IActionResult> RegisterOrder(OrderViewModel model)
{
MemoryStream memory = new MemoryStream();
using (var uploadedFile = model.File.OpenReadStream())
{
await uploadedFile.CopyToAsync(memory);
}
model.ImageData = memory.ToArray();
model.PictureUrl = model.File.FileName;
model.OrderId = Guid.NewGuid();
var sendToUri = new Uri($"{RabbitMqMassTransitConstants.RabbitMqUri }/" +
$"{RabbitMqMassTransitConstants.RegisterOrderCommandQueue}");
var endPoint = await _busControl.GetSendEndpoint(sendToUri);
await endPoint.Send <IRegisterOrderCommand>(
new
{
model.OrderId,
model.UserEmail,
model.ImageData,
model.PictureUrl
});
ViewData["OrderId"] = model.OrderId;
return(View("Thanks"));
}
private void CreateOrder(CreateOrderModel createOrderModel)
{
var sendToUri = new Uri($"{MqConstants.RabbitMqUri}{MqConstants.OrderQueue}");
var endPoint = _bus.GetSendEndpoint(sendToUri).Result;
endPoint.Send <ICreateOrderCommand>(createOrderModel).Wait();
}
public static async Task SendNewAccountMessage(IBusControl publishEndpoint, Contracts.IAccount newAccount)
{
var destinationAddress = new Uri("rabbitmq://localhost/consumer_queue");
var destination = await publishEndpoint.GetSendEndpoint(destinationAddress);
await destination.Send <Contracts.IAccount>(newAccount);
}
private static void RunMessageBus()
{
string rabbitMqAddress = "rabbitmq://localhost:5672/payment";
string rabbitMqQueue = "superdigital.payments.orderpayments";
Uri rabbitMqRootUri = new Uri(rabbitMqAddress);
IBusControl rabbitBusControl = Bus.Factory.CreateUsingRabbitMq(rabbit =>
{
rabbit.Host(rabbitMqRootUri, settings =>
{
settings.Password("guest");
settings.Username("guest");
});
});
Task <ISendEndpoint> sendEndpointTask = rabbitBusControl.GetSendEndpoint(new Uri(string.Concat(rabbitMqAddress, "/", rabbitMqQueue)));
ISendEndpoint sendEndpoint = sendEndpointTask.Result;
for (int i = 0; i < 100; i++)
{
Task sendTask = sendEndpoint.Send <ICreatePayment>(new
{
CreditAccount = 5587,
DebitAccount = 6698,
Value = i + 580,
PaymentType = "Salary"
});
sendTask.Wait();
Console.WriteLine("Mensagem {0} enviada", i);
}
Console.ReadKey();
}
public void SetupSecondAzureServiceBusTestFixture()
{
_secondBus = CreateSecondBus();
_secondBusHandle = _secondBus.Start();
try
{
_secondBusSendEndpoint = Await(() => _secondBus.GetSendEndpoint(_secondBus.Address));
_secondInputQueueSendEndpoint = Await(() => _secondBus.GetSendEndpoint(_secondInputQueueAddress));
}
catch (Exception ex)
{
Console.WriteLine("The bus creation failed: {0}", ex);
_secondBusHandle.Stop();
throw;
}
}
public BusTestScenario(TimeSpan timeout, IBusControl busControl)
{
_timeout = timeout;
_busControl = busControl;
Received = new ReceivedMessageList(timeout);
_skipped = new ReceivedMessageList(timeout);
_published = new PublishedMessageList(timeout);
_tokenSource = new CancellationTokenSource(timeout);
CancellationToken = _tokenSource.Token;
_subjectSendEndpoint = _busControl.GetSendEndpoint(new Uri("loopback://localhost/input_queue")).Result;
var testSendObserver = new TestSendObserver(timeout);
Sent = testSendObserver.Messages;
_subjectSendEndpoint.ConnectSendObserver(testSendObserver);
var consumeObserver = new TestConsumeObserver(timeout);
Received = consumeObserver.Messages;
busControl.ConnectConsumeObserver(consumeObserver);
_busHandle = _busControl.Start();
}
public async Task SetupAzureServiceBusTestFixture()
{
_bus = CreateBus();
_bus.ConnectReceiveEndpointObserver(new ReceiveEndpointObserver());
_busHandle = await _bus.StartAsync();
try
{
_busSendEndpoint = await _bus.GetSendEndpoint(_bus.Address);
_busSendEndpoint.ConnectSendObserver(_sendObserver);
_inputQueueSendEndpoint = await _bus.GetSendEndpoint(_inputQueueAddress);
_inputQueueSendEndpoint.ConnectSendObserver(_sendObserver);
}
catch (Exception)
{
try
{
using (var tokenSource = new CancellationTokenSource(TestTimeout))
{
await _bus.StopAsync(tokenSource.Token);
}
}
finally
{
_busHandle = null;
_bus = null;
}
throw;
}
}
public void SetupInMemoryTestFixture()
{
_bus = CreateBus();
_busHandle = _bus.Start();
try
{
_busSendEndpoint = Await(() => _bus.GetSendEndpoint(_bus.Address));
_busSendEndpoint.ConnectSendObserver(_sendObserver);
_inputQueueSendEndpoint = Await(() => _bus.GetSendEndpoint(_inputQueueAddress));
_inputQueueSendEndpoint.ConnectSendObserver(_sendObserver);
}
catch (Exception)
{
try
{
using (var tokenSource = new CancellationTokenSource(TestTimeout))
{
_busHandle?.Stop(tokenSource.Token);
}
}
finally
{
_busHandle = null;
_bus = null;
}
throw;
}
}
public void SetupAzureServiceBusTestFixture()
{
_bus = CreateBus();
_bus.ConnectReceiveEndpointObserver(new ReceiveEndpointObserver());
_busHandle = _bus.Start();
try
{
Await(() => _busHandle.Ready);
_busSendEndpoint = _bus.GetSendEndpoint(_bus.Address).Result;
_busSendEndpoint.ConnectSendObserver(_sendObserver);
_inputQueueSendEndpoint = _bus.GetSendEndpoint(_inputQueueAddress).Result;
_inputQueueSendEndpoint.ConnectSendObserver(_sendObserver);
}
catch (Exception ex)
{
Console.WriteLine("The bus creation failed: {0}", ex);
_busHandle.Stop();
throw;
}
}
