/// <summary>
/// Послать сообщение в очередь и получить сообщение в ответ
/// </summary>
/// <typeparam name="TRequest">тип запроса</typeparam>
/// <typeparam name="TResponse">тип ответа</typeparam>
/// <param name="request">запрос</param>
/// <param name="requestTimeOutInSeconds">тайм-аут запроса в секундах</param>
/// <param name="ignoreTimeoutException">Нужно ли игнорировать ошибку тайм аута. Если игнорируем, то возвращаем null</param>
/// <returns>Task</returns>
public async Task <TResponse> Request <TRequest, TResponse>(TRequest request, double requestTimeOutInSeconds, bool ignoreTimeoutException = false) where TRequest : class, IWithQueueName where TResponse : class
{
CheckForNull(request);
var queueName = GetQueueNameOrThrow(request);
InitBusAndThrowOnError();
if (requestTimeOutInSeconds <= 0)
{
throw new Exception($"Таймаут для запроса должен быть больше нуля. Текущее значение = {requestTimeOutInSeconds}");
}
var address = ComposeUri(queueName);
var requestTimeout = TimeSpan.FromSeconds(requestTimeOutInSeconds);
var client = new MessageRequestClient <TRequest, TResponse>(_bus, address, requestTimeout);
try
{
return(await client.Request(request, CancellationToken.None));
}
catch (RequestTimeoutException e)
{
if (ignoreTimeoutException)
{
return(null);
}
throw new Exception(e.Message);
}
}
static void Main(string[] args)
{
var bus = Bus.Factory.CreateUsingRabbitMq(cfg =>
{
var host = cfg.Host(new Uri("rabbitmq://192.168.17.129"), h =>
{
h.Username("guest");
h.Password("guest");
});
});
bus.Start();
var message = new DemoRequest
{
Id = 1,
Content = "MassTransit.RequestResponse.Demo",
};
var address = new Uri("rabbitmq://192.168.17.129/rabbitmq.demo.masstransit.requestresponse");
var requestTimeout = TimeSpan.FromSeconds(30);
var client = new MessageRequestClient <DemoRequest, DemoResponse>(bus, address, requestTimeout);
var result = client.Request(message).GetAwaiter().GetResult();
Console.WriteLine($"Response message: Code={result.ResultCode}, RequestId={result.RequestId}");
bus.Stop();
Console.WriteLine(" Press [enter] to exit request console.");
Console.ReadLine();
}
private static async Task DoRequest(IBus bus)
{
var client = new MessageRequestClient <MyRequest, MyResponse>(
bus,
new Uri("rabbitmq://rmqcluster/qa/rmq-reconnection-test-app"),
TimeSpan.FromSeconds(5),
TimeSpan.FromSeconds(5));
var id = Guid.NewGuid();
Console.WriteLine($"Sending payload {id}");
try
{
var response = await client.Request(new MyRequestImpl()
{
Payload = id
}).ConfigureAwait(false);
Console.WriteLine($"Received response payload {response.Payload}");
}
catch (Exception e)
{
Console.WriteLine($"Exception thrown. Type: {e.GetType().Name} Message: {e.Message}");
}
}
/// <summary>
/// Registers a request/response constructor callback for ninject.
/// </summary>
/// <typeparam name="T1">The type of the Request.</typeparam>
/// <typeparam name="T2">The type of the Response.</typeparam>
/// <param name="context">The context.</param>
/// <param name="serviceUrl">The service URL.</param>
/// <returns>IRequestClient<T1, T2>.</returns>
private static IRequestClient <T1, T2> GetRequestClient <T1, T2>(IContext context, string serviceUrl) where T1 : class where T2 : class
{
var requestTimeout = TimeSpan.FromMinutes(1);
var client = new MessageRequestClient <T1, T2>(bus, new Uri(new Uri(BusConfigurator.Uri), serviceUrl), requestTimeout);
return(client);
}
/// <summary>
/// request to a service
/// </summary>
/// <param name="address"></param>
/// <param name="request"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public Task <TResponse> Request(Uri address, TRequest request, CancellationToken cancellationToken)
{
var requestTimeout = TimeSpan.FromSeconds(300);
var client = new MessageRequestClient <TRequest, TResponse>(_bus, address, requestTimeout);
return(client.Request(request, cancellationToken));
}
private IRequestClient <JobInitRequest, JobInitResult> CreateJobInitRequestClient()
{
var requestTimeout = TimeSpan.FromMinutes(1);
var busUri = new Uri(new Uri(BusConfigurator.Uri), BusConstants.DocumentConverterJobInitRequestQueue);
var client = new MessageRequestClient <JobInitRequest, JobInitResult>(bus, busUri, requestTimeout);
return(client);
}
public async Task <TResponseMessage> SendRequest <TRequestMessage, TResponseMessage>(TRequestMessage requestMessage, string address) where TRequestMessage : class, IMessage where TResponseMessage : class, IMessage
{
var requestTimeout = TimeSpan.FromSeconds(30);
var uri = new Uri(address);
var requestClient = new MessageRequestClient <TRequestMessage, TResponseMessage>(_bus, uri,
requestTimeout);
return(await requestClient.Request(requestMessage, new CancellationToken()));
}
public static TResponse Request <TRequest, TResponse>(string queueName, TRequest request)
where TRequest : class
where TResponse : class
{
var config = (IServiceConfig)ConfigurationManager.GetSection("service");
IRequestClient <TRequest, TResponse> client = new MessageRequestClient <TRequest, TResponse>(Instance, new Uri(config.RabbitMq.GetQueueUrl(queueName)), TimeSpan.FromSeconds(30));
return(client.Request(request).Result);
}
private IRequestClient <SupportedFileTypesRequest, SupportedFileTypesResponse> CreateSupportedFileTypesRequestClient()
{
var requestTimeout = TimeSpan.FromMinutes(1);
var busUri = new Uri(new Uri(BusConfigurator.Uri), BusConstants.DocumentConverterSupportedFileTypesRequestQueue);
var client = new MessageRequestClient <SupportedFileTypesRequest, SupportedFileTypesResponse>(bus, busUri, requestTimeout);
return(client);
}
public IRequestClient <FindArchiveRecordRequest, FindArchiveRecordResponse> CreateFindArchiveRecordRequestClient(IContext context)
{
var requestTimeout = TimeSpan.FromMinutes(1);
var busUri = new Uri(new Uri(BusConfigurator.Uri), BusConstants.IndexManagerFindArchiveRecordMessageQueue);
var client = new MessageRequestClient <FindArchiveRecordRequest, FindArchiveRecordResponse>(bus, busUri, requestTimeout);
return(client);
}
private IRequestClient <ConversionStartRequest, ConversionStartResult> CreateDocumentConversionRequestClient()
{
// Very large files could take a very long time to convert
var requestTimeout = TimeSpan.FromHours(12);
var busUri = new Uri(new Uri(BusConfigurator.Uri), BusConstants.DocumentConverterConversionStartRequestQueue);
var client = new MessageRequestClient <ConversionStartRequest, ConversionStartResult>(bus, busUri, requestTimeout);
return(client);
}
private IRequestClient <ExtractionStartRequest, ExtractionStartResult> CreateDocumentExtractionRequestClient()
{
// Ocr of a large pdf can take some time
var requestTimeout = TimeSpan.FromHours(12);
var busUri = new Uri(new Uri(BusConfigurator.Uri), BusConstants.DocumentConverterExtractionStartRequestQueue);
var client = new MessageRequestClient <ExtractionStartRequest, ExtractionStartResult>(bus, busUri, requestTimeout);
return(client);
}
public async Task <JsonResult> Index(string prefix)
{
var address = new Uri("rabbitmq://localhost/suggestions");
var requestTimeout = TimeSpan.FromSeconds(30);
IRequestClient <IGetSuggestions, IReturnSuggestions> client = new MessageRequestClient <IGetSuggestions, IReturnSuggestions>(MvcApplication.BusControl, address, requestTimeout);
IReturnSuggestions result = await client.Request(new { Prefix = prefix });
return(Json(result.Suggestions, JsonRequestBehavior.AllowGet));
}
public IRequestClient <DoesExistInCacheRequest, DoesExistInCacheResponse> CreateDoesExistInCacheRequestClient(IContext context)
{
var requestTimeout = TimeSpan.FromMinutes(1);
var client =
new MessageRequestClient <DoesExistInCacheRequest, DoesExistInCacheResponse>(bus,
new Uri(new Uri(BusConfigurator.Uri), BusConstants.CacheDoesExistRequestQueue), requestTimeout);
return(client);
}
public async Task <IActionResult> Count()
{
var address = new Uri("rabbitmq://localhost/WordCount.Service");
var requestTimeout = TimeSpan.FromSeconds(30);
var client = new MessageRequestClient <ICountRequest, ICountResponse>(_bus, address, requestTimeout);
var response = await client.Request(new CountRequest(), CancellationToken.None).ConfigureAwait(false);
return(Content($"<h1> Total: {response.Count} </h1>", "text/html", Encoding.UTF8));
}
/// <summary>
/// Registers the download asset request/response constructur callback for ninject.
/// </summary>
/// <param name="context">The context.</param>
/// <returns>IRequestClient<DownloadAsset, DownloadAssetResult>.</returns>
public static IRequestClient <DownloadAssetRequest, DownloadAssetResult> RegisterDownloadAssetCallback(IContext context)
{
var requestTimeout = TimeSpan.FromMinutes(1);
var client = new MessageRequestClient <DownloadAssetRequest, DownloadAssetResult>(
bus,
new Uri(new Uri(BusConfigurator.Uri), BusConstants.WebApiDownloadAssetRequestQueue),
requestTimeout);
return(client);
}
private static void ExecuteSaga(IBusControl bus)
{
var address = new Uri($"loopback://localhost/req_resp_saga");
var requestClient = new MessageRequestClient <IStartSaga, MyResponse>(bus, address, TimeSpan.FromSeconds(30));
var response = requestClient.Request(new { CorrelationId = Guid.NewGuid(), Data = "Please do this" })
.GetAwaiter()
.GetResult();
Console.WriteLine($"This was the result: {response.ResponseMessage}");
}
private IRequestClient <FindArchiveRecordRequest, FindArchiveRecordResponse> CreateFindArchiveRecordRequestClient(IContext context)
{
var requestTimeout = TimeSpan.FromMinutes(1);
var client =
new MessageRequestClient <FindArchiveRecordRequest, FindArchiveRecordResponse>(bus,
new Uri(new Uri(BusConfigurator.Uri), BusConstants.IndexManagerFindArchiveRecordMessageQueue), requestTimeout, null,
BusConfigurator.ChangeResponseAddress);
return(client);
}
public IRequestClient <TRequest, TResult> Create <TRequest, TResult>() where TRequest : class where TResult : class
{
string name = typeof(TRequest).Name;
var address = new Uri($"{config.HostName}/{name}");
var requestTimeout = TimeSpan.FromSeconds(30);
IRequestClient <TRequest, TResult> client =
new MessageRequestClient <TRequest, TResult>(bus, address, requestTimeout);
return(client);
}
GetArchiveRecordsForPackageRequestClientCallback(IContext arg)
{
var serviceUrl = string.Format(BusConstants.IndexManagagerRequestBase, nameof(GetArchiveRecordsForPackageRequest));
var requestTimeout = TimeSpan.FromMinutes(1);
var client =
new MessageRequestClient <GetArchiveRecordsForPackageRequest, GetArchiveRecordsForPackageResponse>(bus,
new Uri(bus.Address, serviceUrl), requestTimeout, null, BusConfigurator.ChangeResponseAddress);
return(client);
}
public static async Task <TResponse> SendCommandWithRespond <TRequest, TResponse>(TRequest request, CancellationToken cancellationToken = default(CancellationToken))
where TRequest : class
where TResponse : class
{
var address = new Uri("rabbitmq://localhost/commands");
var requestTimeout = TimeSpan.FromSeconds(30);
IRequestClient <TRequest, TResponse> client =
new MessageRequestClient <TRequest, TResponse>(Startup.Bus, address, requestTimeout);
return(await client.Request(request, cancellationToken));
}
public async Task <IUserDataResponse> Get(int id)
{
var address = new Uri("rabbitmq://localhost/UserData");
var client = new MessageRequestClient <IUserDataRequest, IUserDataResponse>(_bus, address, TimeSpan.FromSeconds(30));
var response = await client.Request(new { Id = id });
//var addUserEndpoint = await _bus.GetSendEndpoint(new Uri("rabbitmq://localhost/UserData"));
//await addUserEndpoint.Send<IUserDataRequest>(new {Id = 1});
return(response);
}
/// <summary>
/// Method to run the test case
/// </summary>
/// <param name="busControl">
/// The bus for the test case to use
/// </param>
public override async Task Run(BusControl busControl)
{
var hostUri = busControl.Instance.Address;
var address = new Uri($"{hostUri.Scheme}://{hostUri.Host}/{QueueName}");
var requestTimeout = TimeSpan.FromSeconds(30);
var requestClient =
new MessageRequestClient <IRequestMessage, IResponseMessage>(busControl.Instance, address, requestTimeout);
await SendMessages(message =>
requestClient.Request(message).ConfigureAwait(false)
);
}
public static IRequestClient <GetElasticLogRecordsRequest, GetElasticLogRecordsResponse> CreateGetElasticLogRecordsRequestClient(
IContext context)
{
var requestTimeout = TimeSpan.FromMinutes(15);
var ttl = TimeSpan.FromMinutes(1);
var client = new MessageRequestClient <GetElasticLogRecordsRequest, GetElasticLogRecordsResponse>(
bus,
new Uri(new Uri(BusConfigurator.Uri), BusConstants.IndexManagerGetElasticLogRecordsRequestQueue),
requestTimeout,
ttl);
return(client);
}
public DocumentsResponse?Request(DocumentInfo input)
{
try
{
var address = new Uri("rabbitmq://localhost/" + input.Type + "Request");
var requestTimeout = TimeSpan.FromSeconds(10);
IRequestClient <Document, DocumentsResponse> requestClient =
new MessageRequestClient <Document, DocumentsResponse>(bus, address, requestTimeout);
return(requestClient.Request(input).Result);
}
catch (Exception)
{
return(null);
}
}
public async Task Test()
{
try
{
var serviceAddress = new Uri($"rabbitmq://localhost/{MvcApplication.QueueName}");
var requestClient = new MessageRequestClient <ITest, ITestResponse>(MvcApplication.Bus, serviceAddress, TimeSpan.FromSeconds(10));
var response = await requestClient.Request(new Test { Message = $"Test Request {DateTime.Now}" });
await Clients.All.TestResponse($"{DateTime.Now} - Got response: {response.Response}");
}
catch (Exception ex)
{
await Clients.All.TestResponse($"{DateTime.Now} - Got exception:\n{ex.ToString()}");
}
}
public async Task Should_be_wicked_fast()
{
var bus = Bus.Factory.CreateUsingInMemory(cfg =>
{
cfg.UseBsonSerializer();
cfg.ReceiveEndpoint("input-queue", e =>
e.Handler <PingMessage>(async context =>
{
await context.RespondAsync(new PongMessage(context.Message.CorrelationId));
}));
});
await bus.StartAsync();
try
{
var client = new MessageRequestClient <PingMessage, PongMessage>(bus, new Uri("loopback://localhost/input-queue"), TimeSpan.FromSeconds(30));
int limit = 50000;
int count = 0;
await client.Request(new PingMessage());
Stopwatch timer = Stopwatch.StartNew();
await Task.WhenAll(Enumerable.Range(0, limit).Select(async x =>
{
await client.Request(new PingMessage());
Interlocked.Increment(ref count);
}));
timer.Stop();
Console.WriteLine("Time to process {0} messages = {1}", count, timer.ElapsedMilliseconds + "ms");
Console.WriteLine("Messages per second: {0}", count * 1000 / timer.ElapsedMilliseconds);
}
catch (Exception exception)
{
Console.WriteLine(exception);
}
finally
{
await bus.StopAsync();
}
}
public async Task Request()
{
var bus = Bus.Factory.CreateUsingHttp(cfg =>
{
var mainHost = cfg.Host(new Uri("http://localhost:8080"));
//TODO: serializer?
cfg.ReceiveEndpoint(ep =>
{
ep.Consumer <HttpEater>();
});
});
var mc = new MessageRequestClient <Ping, Pong>(bus, new Uri("http://requestb.in/15alnbk1"), TimeSpan.FromMinutes(500));
await mc.Request(new Ping(), default(CancellationToken));
}
public async Task Should_work_with_the_message_request_client_too()
{
_hostAddress = new Uri("http://localhost:8080");
var busControl = Bus.Factory.CreateUsingHttp(cfg =>
{
var mainHost = cfg.Host(_hostAddress, h =>
{
h.Method = HttpMethod.Post;
});
cfg.ReceiveEndpoint(mainHost, "", ep =>
{
ep.Consumer <HttpRequestConsumer>();
});
});
await busControl.StartAsync(TestCancellationToken);
try
{
IRequestClient <Request, Response> client = new MessageRequestClient <Request, Response>(busControl, _hostAddress, TimeSpan.FromSeconds(30));
var request = new Request {
Value = "Hello"
};
for (var i = 0; i < 5; i++)
{
var timer = Stopwatch.StartNew();
var result = await client.Request(request);
timer.Stop();
await Console.Out.WriteLineAsync($"Request complete: {timer.ElapsedMilliseconds}ms, Response = {result.ResponseValue}");
}
}
finally
{
await busControl.StopAsync().WithTimeout(TimeSpan.FromSeconds(30));
}
}
private void Authenticate(string userNameKey, string passwordKey)
{
var serviceConfig = (IServiceConfig)ConfigurationManager.GetSection("service");
var userName = ConfigurationManager.AppSettings[userNameKey];
var password = ConfigurationManager.AppSettings[passwordKey];
var url = new Uri(serviceConfig.RabbitMq.GetQueueUrl(WellKnownQueues.AccessControl));
IRequestClient <IAuthenticateUser, IAuthenticateUserResult> request = new MessageRequestClient <IAuthenticateUser, IAuthenticateUserResult>(Bus.Instance, url, TimeSpan.FromSeconds(30));
var result = request.Request(new AuthenticateUser(userName, password)).Result;
if (!result.Authenticated)
{
throw new SecurityException($"Invalid credentials specified. Please check these settings {userNameKey} and {passwordKey} in the app.config file.");
}
// take care of automatical request authentication
Bus.Instance.ConnectTicket(result.Ticket);
}
public async Task Should_get_the_response_to_the_bus()
{
IRequestClient<PingMessage,PongMessage> client = new MessageRequestClient<PingMessage, PongMessage>(Bus, InputQueueAddress, TestTimeout);
await client.Request(new PingMessage(), TestCancellationToken);
}
