private IRequestClient <FindArchiveRecordRequest> CreateFindArchiveRecordRequestClient(IComponentContext context)
{
var requestTimeout = TimeSpan.FromMinutes(1);
var uri = new Uri(new Uri(BusConfigurator.Uri), BusConstants.IndexManagerFindArchiveRecordMessageQueue);
return(bus.CreateRequestClient <FindArchiveRecordRequest>(uri, requestTimeout));
}
public async Task <RoomInfo> CreateRoom(string gameKey, long blind)
{
//生成roomId
string roomId = "";
while (true)
{
roomId = $"{matchingGroup}-{++_roomIdSeed}";
if (!_allRoomId.Contains(roomId))
{
break;
}
}
if (!_roomConfig.TryGetValue(blind, out var blindConfig))
{
throw new Exception($"have no blind{blind} room");
}
var busClient = _bus.CreateRequestClient <CreateRoomMqCommand>(new Uri($"{mqUri}/{gameKey}"), TimeSpan.FromSeconds(3));
var busResponse = await busClient.GetResponseExt <CreateRoomMqCommand, BodyResponse <NullBody> >
(new CreateRoomMqCommand(roomId, gameKey, blind, blindConfig.MinCoins,
blindConfig.MaxCoins, blindConfig.TipsPersent, RoomInfo.MAX_USER_NUM,
blindConfig.MinCarry, blindConfig.MaxCarry, blindConfig.RoomType));
if (busResponse.Message.StatusCode != StatusCodeDefines.Success)
{
throw new Exception($"Create Room {roomId} blind{blind} error");
}
return(new RoomInfo(roomId, 0, gameKey, blind));
}
private IRequestClient <JobInitRequest> CreateJobInitRequestClient()
{
var requestTimeout = TimeSpan.FromMinutes(1);
var busUri = new Uri(new Uri(BusConfigurator.Uri), BusConstants.DocumentConverterJobInitRequestQueue);
var client = bus.CreateRequestClient <JobInitRequest>(busUri, requestTimeout);
return(client);
}
/// <summary>
/// Registers the download asset request/response constructur callback for a DI container.
/// </summary>
/// <returns>IRequestClient<DownloadAsset, DownloadAssetResult>.</returns>
public static IRequestClient <DownloadAssetRequest> RegisterDownloadAssetCallback()
{
var requestTimeout = TimeSpan.FromMinutes(1);
var client = bus.CreateRequestClient <DownloadAssetRequest>(
new Uri(new Uri(BusConfigurator.Uri), BusConstants.WebApiDownloadAssetRequestQueue),
requestTimeout);
return(client);
}
public async void GetMoney()
{
IRequestClient <GetMoneyMqCommand> client = _mqBus.CreateRequestClient <GetMoneyMqCommand>
(new Uri("rabbitmq://localhost/SkyWatch/Money"));
var response = client.GetResponse <BodyResponse <MoneyMqResponse> >(new GetMoneyMqCommand(10000000002));
var moneyRes = await response;
_testOutputHelper.WriteLine($"GetMoney:{moneyRes.Message.Body.CurCoins} --01");
Assert.Equal(StatusCodeDefines.Success, moneyRes.Message.StatusCode);
}
public override IRequestClient <IDataRequest, IDataResponse> CreateRequestClient(IBusControl busControl)
{
var serviceAddress = new Uri(ConfigurationManager.AppSettings["ServiceAddress"]);
IRequestClient <IDataRequest, IDataResponse> client = busControl.CreateRequestClient <IDataRequest, IDataResponse>(serviceAddress, TimeSpan.FromSeconds(500));
return(client);
}
public Task <INewOrderNotification> NewOrder(INewOrder requestCmd)
{
IRequestClient <INewOrder, INewOrderNotification> client =
_busControl.CreateRequestClient <INewOrder, INewOrderNotification>(serviceAddress, TimeSpan.FromSeconds(10));
return(client.Request(requestCmd));
}
GetArchiveRecordsForPackageRequestClientCallback(IComponentContext arg)
{
var serviceUrl = string.Format(BusConstants.IndexManagagerRequestBase, nameof(GetArchiveRecordsForPackageRequest));
var requestTimeout = TimeSpan.FromMinutes(1);
return(bus.CreateRequestClient <GetArchiveRecordsForPackageRequest>(new Uri(bus.Address, serviceUrl), requestTimeout));
}
private static IRequestClient <CreateNewUserRequest, CreateNewUserResponse> CreateRequestClient(IBusControl busControl)
{
var serviceAddress = new Uri("rabbitmq://localhost/test/createuser");
var client = busControl.CreateRequestClient <CreateNewUserRequest, CreateNewUserResponse>(serviceAddress, TimeSpan.FromSeconds(10));
return(client);
}
/// <summary>
/// 创建请求客户端
/// </summary>
/// <param name="busControl"></param>
/// <returns></returns>
private static IRequestClient <ISimpleRequest, ISimpleResponse> CreateRequestClient(IBusControl busControl)
{
var serviceAddress = new Uri($"{RabbitMqConstants.RabbitMqUri}{RabbitMqConstants.RequestClientQueue}");
var client = busControl.CreateRequestClient <ISimpleRequest, ISimpleResponse>(serviceAddress, TimeSpan.FromSeconds(10));
return(client);
}
public async Task <TReturn> SendRequest <TCommand, TReturn>(TCommand command) where TCommand : class where TReturn : class
{
var client = _bus.CreateRequestClient <TCommand>(new Uri($"{_configuration.Host}/${_configuration.CommandRequestQueue}"));
var response = await client.GetResponse <TReturn>(command);
return(response.Message);
}
public static IRequestClient <ISimpleRequest, ISimpleResponse> CreateRequestClient(this IBusControl busControl)
{
var serviceAddress = new Uri(ConfigurationManager.AppSettings["ServiceAddress"]);
var client = busControl.CreateRequestClient <ISimpleRequest, ISimpleResponse>(serviceAddress, TimeSpan.FromSeconds(10));
return(client);
}
private static IRequestClient <OrderPlaced> CreateRequestClient(IBusControl busControl)
{
var serviceAddress = new Uri("exchange:OrderPlaced");
var client = busControl.CreateRequestClient <OrderPlaced>(serviceAddress, TimeSpan.FromSeconds(10));
return(client);
}
private static void SendMessage(IBusControl bus)
{
var mqAddress = new Uri($"rabbitmq://192.168.80.71/EDCVHOST/Qka.MassTransitTestv3");
var client = bus.CreateRequestClient <IRequestMessage, IResponseMessage>(mqAddress,
TimeSpan.FromHours(10)); // 创建请求客户端，10s之内木有回馈则认为是超时(Timeout)
do
{
Console.WriteLine("Press q to exit if you want.");
string value = Console.ReadLine();
if (value.ToLower().Equals("q"))
{
break;
}
Task.Run(async() =>
{
var request = new RequestMessage()
{
MessageId = 10001,
Content = value,
RequestId = 10001
};
var response = await client.Request(request);
Console.WriteLine($"Request => MessageId={request.MessageId}, Content={request.Content}");
Console.WriteLine($"Response => MessageCode={response.MessageCode}, Content={response.Content}");
}).Wait();
} while (true);
}
public async Task <ToAppResponse> AppRoomRequest(AppRoomRequest request)
{
ToAppResponse commonResponse = null;
//验证是否是本人ID
long uid = _userConnManager.GetUidByConn(Context.ConnectionId);
if (request.Id != uid)
{
return(new ToAppResponse(null, StatusCodeDefines.Error, null));
}
var busClient = _bus.CreateRequestClient <AppRoomRequest>(new Uri($"{Configuration["Rabbitmq:Uri"]}{request.GameRoomKey}"), TimeSpan.FromSeconds(5));
try
{
var busResponse = await busClient.GetResponseExt <AppRoomRequest, ToAppResponse>(request);
commonResponse = busResponse?.Message;
}
catch (Exception)
{
return(new ToAppResponse(null, StatusCodeDefines.BusError, null));
}
return(commonResponse);
}
private void btnSendRequestReply_Click(object sender, EventArgs e)
{
try
{
// Setup local variables for the loop
var requestTasks = new List <Task>();
var totalBarsToSend = int.Parse(drpTotalMessagesToSend.Text);
var barsInEach = int.Parse(drpBatchSize.Text);
var totalBarsSent = 0;
// Use our custom code (extension method) to figure out where to deliver a request-reply style of a command/query.
// You can do it manually but it requires lot of code.
var client = _azureBus.CreateRequestClient <ServeBarsCommand, ServeBarsResponse>(TimeSpan.FromSeconds(5));
// Basic validation
if (barsInEach > totalBarsToSend)
{
throw new Exception("Error! Batchsize greater than the total. Makes no sense!");
}
// Start loop until all bars are delivered
while (ShouldKeepSending(totalBarsSent, totalBarsToSend))
{
// Figure out how many bars to send in the next command
var thisBatchSize = NextBatchSize(totalBarsSent: totalBarsSent, barsInEachCommand: barsInEach, totalBarsToSend: totalBarsToSend);
// Declare a command and fill it with next batch of bars
var command = new ServeBarsCommand();
command.BarOwner = $"John Doe-{totalBarsSent}";
command.Bars = GetBarsToUpdate(thisBatchSize);
// Send the command in a task, and log when we get a reply
var task = client
.Request(command)
.ContinueWith(async(t) =>
{
var response = await t;
// Output on main thread since we're in a task continuation.
Invoke(new Action(() =>
{
LogLine($"Reply ({response.ServedCounter}): {response.AckText}\r\n");
}));
});
requestTasks.Add(task);
totalBarsSent += thisBatchSize;
}
LogLine($"Sent {totalBarsSent} Commands, now waiting for all to complete ..\r\n");
// Wait for all to complete
Task.WaitAll(requestTasks.ToArray());
}
catch (Exception ex)
{
LogError($"Exception when doing Request/Reply. \r\n ExType: {ex.GetType().Name}\r\n ExMessage: {ex.Message}\r\n");
}
}
static IRequestClient <ISimpleRequest, ISimpleResponse> CreateRequestClient(IBusControl busControl)
{
var serviceAddress = new Uri(Configuration["ServiceAddress"]);
IRequestClient <ISimpleRequest, ISimpleResponse> client =
busControl.CreateRequestClient <ISimpleRequest, ISimpleResponse>(serviceAddress, TimeSpan.FromSeconds(10));
return(client);
}
private static IRequestClient <ISimpleRequest, ISimpleResponse> CreateRequestClient(IBusControl busControl)
{
var serviceAddress = new Uri("sb://jperotest.servicebus.windows.net/request_service");
IRequestClient <ISimpleRequest, ISimpleResponse> client =
busControl.CreateRequestClient <ISimpleRequest, ISimpleResponse>(serviceAddress, TimeSpan.FromSeconds(10));
return(client);
}
CreateRequestClient <TRequest>(TimeSpan?timeout = null)
where TRequest : class
{
return(_bus.CreateRequestClient <TRequest>(
_queueUri,
timeout ?? Configuration.RequestTimeout
));
}
private IRequestClient <TManagerCommandRequest, TManagerCommandResponse> CreateRequestClient <TManagerCommandRequest, TManagerCommandResponse>(IEndpointConfiguration endpointConfiguration)
where TManagerCommandRequest : ManagerCommandRequest
where TManagerCommandResponse : ManagerCommandResponse
{
var serviceAddress = endpointConfiguration.Address;
return(_busControl.CreateRequestClient <TManagerCommandRequest, TManagerCommandResponse>(serviceAddress, TimeSpan.FromSeconds(30)));
}
/// <summary>
/// Registers a request/response constructor callback for a DI container.
/// </summary>
/// <typeparam name="T1">The type of the Request.</typeparam>
/// <param name="serviceUrl">The service URL.</param>
/// <returns>IRequestClient<T1, T2>.</returns>
private static IRequestClient <T1> GetRequestClient <T1>(string serviceUrl) where T1 : class
{
var requestTimeout = TimeSpan.FromMinutes(1);
var client = bus.CreateRequestClient <T1>(new Uri(new Uri(BusConfigurator.Uri), serviceUrl), requestTimeout);
return(client);
}
public Task <TR> SendRequest <T, TR>(string target, T message, int secoonds = 10) where T : class where TR : class
{
Uri uri = new Uri(Utils.CombineUrl(BusConfig.Current.Uri, target));
IRequestClient <T, TR> client =
Control.CreateRequestClient <T, TR>(uri, TimeSpan.FromSeconds(secoonds));
return(client.Request(message));
}
private IRequestClient <TRequest, TResponse> CreateRequestClient <TRequest, TResponse>(IEndpointConfiguration endpointConfiguration)
where TRequest : class, IWorkflowMessage
where TResponse : class, IWorkflowMessage
{
var serviceAddress = endpointConfiguration.Address;
return(_busControl.CreateRequestClient <TRequest, TResponse>(serviceAddress, TimeSpan.FromSeconds(30)));
}
static IRequestClient<ISimpleRequest, ISimpleResponse> CreateRequestClient(IBusControl busControl)
{
var serviceAddress = new Uri(ConfigurationManager.AppSettings["ServiceAddress"]);
IRequestClient<ISimpleRequest, ISimpleResponse> client =
busControl.CreateRequestClient<ISimpleRequest, ISimpleResponse>(serviceAddress, TimeSpan.FromSeconds(10));
return client;
}
private async Task <TOut> GetResponseRabbitTask <TIn, TOut>(TIn request)
where TIn : class
where TOut : class
{
var client = _busControl.CreateRequestClient <TIn>(_rabbitMqUrl);
var response = await client.GetResponse <TOut>(request);
return(response.Message);
}
static IRequestClient <ISubmitOrder, IOrderReceived> CreateRequestClient(IBusControl busControl)
{
//var serviceAddress = new Uri(ConfigurationManager.AppSettings["ServiceAddress"]);
//IRequestClient<ISimpleRequest, ISimpleResponse> client =
// busControl.CreateRequestClient<ISimpleRequest, ISimpleResponse>(serviceAddress, TimeSpan.FromSeconds(10));
var client = busControl.CreateRequestClient <ISubmitOrder, IOrderReceived>(new Uri("sb://abc-orders.servicebus.windows.net/input-queue"), TimeSpan.FromSeconds(30));
return(client);
}
static IRequestClient <CheckOrderStatus, IMessageResponse <OrderStatus> > CreateRequestClient(IBusControl busControl)
{
var serviceAddress = new Uri("rabbitmq://fly.rmq.cloudamqp.com/umeawlvd/checkorderstatus");
var client = busControl.CreateRequestClient <CheckOrderStatus, IMessageResponse <OrderStatus> >(
serviceAddress,
TimeSpan.FromSeconds(120)
);
return(client);
}
static IRequestClient <IGenerateScorecardRequest, IGenerateScorecardResponse> CreateRequestClient(IBusControl busControl)
{
var config = MassTransitConfigurationManager.Config;
var url = config.Host + "/" + MassTransitQueue.GenerateScorecardResponse;
var serviceAddress = new Uri(url);
IRequestClient <IGenerateScorecardRequest, IGenerateScorecardResponse> client =
busControl.CreateRequestClient <IGenerateScorecardRequest, IGenerateScorecardResponse>(serviceAddress, TimeSpan.FromSeconds(10));
return(client);
}
public async Task <ActionResult <Order> > Post([FromBody] Order order)
{
IRequestClient <Order, Order> client =
_bus.CreateRequestClient <Order, Order>(new Uri("rabbitmq://localhost/trendyol_rpc"), TimeSpan.FromSeconds(10));
var response = await client.Request(new Order { Id = order.Id, OrderCode = "tt" });
Console.WriteLine($"{order.Id} - test:" + response.Id);
return(response);
}
public static IRequestClient <GetDigitizationOrderData> GetOrderClient()
{
// ReSharper disable once RedundantAssignment
var requestTimeout = TimeSpan.FromMinutes(1);
#if DEBUG
requestTimeout = TimeSpan.FromMinutes(10);
#endif
return(bus.CreateRequestClient <GetDigitizationOrderData>(new Uri(new Uri(BusConfigurator.Uri), BusConstants.ManagementApiGetDigitizationOrderData), requestTimeout));
}
public override async Task CreateRequestClientAsync(string queueName,
TimeSpan timeout, CancellationToken cancellationToken)
{
await Task.Run(() =>
{
var requestClient = _bus.CreateRequestClient <ICommandMessage, ICommandMessage>(
new Uri($"{_host.Settings.HostAddress.AbsoluteUri}/{queueName}"),
timeout);
_requestResponseClients.Add(queueName, new RequestResponseClient(requestClient));
}, cancellationToken);
}
