/// <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); }