public Message EndRequest(IAsyncResult result)
{
if (result == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("result");
}
IAsyncRequest asyncRequest = result as IAsyncRequest;
if (asyncRequest == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("result", SR.GetString(SR.InvalidAsyncResult));
}
try
{
Message reply = asyncRequest.End();
if (DiagnosticUtility.ShouldTraceInformation)
{
TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.RequestChannelReplyReceived,
SR.GetString(SR.TraceCodeRequestChannelReplyReceived), reply);
}
return(reply);
}
finally
{
ReleaseRequest(asyncRequest);
}
}
public async Task<IAsyncResponse> ExecuteAsync(IAsyncRequest request)
{
try
{
_log.DebugFormat("Recieved async request : {0}, Id - {1} @ {2}", request.GetType().Name, request.Id, DateTime.Now);
var router = IoC.Container.Resolve<IAsyncRouter>();
var response = await router.ExecuteRequestAsync(request);
_log.DebugFormat("Returning async request : {0}, Id - {1} @ {2}", request.GetType().Name, request.Id, DateTime.Now);
return response;
}
catch (Exception ex)
{
_log.DebugFormat("Failed async request : {0}, Id - {1} @ {2}. {3}", request.GetType().Name, request.Id, DateTime.Now, ex.Message);
var genericFault = new GenericFault
{
Operation = request.GetType().FullName,
Message = ex.Message
};
throw new FaultException<GenericFault>(genericFault, ex.Message);
}
}
public Task<TResponse> SendAsync<TResponse>(IAsyncRequest<TResponse> request)
{
if (request == null)
throw new ArgumentNullException(nameof(request));
return _mediator.SendAsync(request.RouteTo(_baseAddress));
}
public static Cached <TResponse> Cached <TResponse>(
this IAsyncRequest <TResponse> request, TimeSpan timeToLive)
{
return(new Cached <TResponse>(request)
{
TimeToLive = timeToLive
});
}
private CacheResponse RefreshResponse(IAsyncRequest <TResponse> request)
{
return(new CacheResponse
{
Response = _mediator.SendAsync(request),
LastUpdated = DateTime.UtcNow
});
}
public static Cached <TResponse> InvalidateCache <TResponse>(
this IAsyncRequest <TResponse> request)
{
return(new Cached <TResponse>(request)
{
Invalidate = true
});
}
public async Task <TResponse> SendAsync <TResponse>(IAsyncRequest <TResponse> request)
{
var defaultHandler = GetHandler(request);
TResponse result = await defaultHandler.Handle(request);
return(result);
}
protected RequestDecorator(IAsyncRequest <TResponse> request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
Request = request;
}
public AsyncHandlerInvocationResult InvokeHandler(IAsyncRequest request, IApplicationState state)
{
if (request is THandlerRequest typedRequest)
{
var result = _handler.HandleAsync(typedRequest, state);
return(new AsyncHandlerInvocationResult(result));
}
return(default);
internal void Initialize(IFileSource fileSource, CanonicalTileId canonicalTileId, string mapId, Action p)
{
Cancel();
_state = State.Loading;
_id = canonicalTileId;
_callback = p;
_request = fileSource.Request(MakeTileResource(mapId).GetUrl(), HandleTileResponse, tileId: _id, mapId: mapId);
}
public static Routed<TResponse> RouteTo<TResponse>(
this IAsyncRequest<TResponse> request, string route, string tag = null)
{
return new Routed<TResponse>(request)
{
Route = route,
Tag = tag
};
}
/// <summary>
/// Initializes the <see cref="T:Mapbox.Map.Tile"/> object. It will
/// start a network request and fire the callback when completed.
/// </summary>
/// <param name="param"> Initialization parameters. </param>
/// <param name="callback"> The completion callback. </param>
public void Initialize(Parameters param, Action callback)
{
this.Cancel();
this.state = State.Loading;
this.id = param.Id;
this.request = param.Fs.Request(this.MakeTileResource(param.MapId).GetUrl(), this.HandleTileResponse);
this.callback = callback;
}
public async Task <TResponse> SendAsync <TResponse>(IAsyncRequest <TResponse> request)
{
_logger.LogTrace("Send async {@request", request);
var response = await _inner.SendAsync(request);
LogResponseIfError(response);
return(response);
}
/// <summary>
/// Initializes the <see cref="T:Mapbox.Map.Tile"/> object. It will
/// start a network request and fire the callback when completed.
/// </summary>
/// <param name="param"> Initialization parameters. </param>
/// <param name="callback"> The completion callback. </param>
public void Initialize(Parameters param, Action callback)
{
Cancel();
_state = State.Loading;
_id = param.Id;
_request = param.Fs.Request(MakeTileResource(param.MapId).GetUrl(), HandleTileResponse);
_callback = callback;
}
public Task <TResponse> SendAsync <TResponse>(IAsyncRequest <TResponse> request)
{
return(ExecuteScopeAsync(sp =>
{
var mediator = sp.GetService <IMediator>();
return mediator.SendAsync(request);
}));
}
public async Task <TResult> Handle <TResult>(IAsyncRequest <TResult> request)
{
var genericRequestHandler = typeof(IAsyncRequestHandler <,>);
var handlerType = genericRequestHandler.MakeGenericType(request.GetType(), typeof(TResult));
var handler = _handlerFactory(handlerType);
return(await(Task <TResult>) handler.GetType().GetMethod("Handle").Invoke(handler, new object[] { request }));
}
public Task <TResponse> SendAsync <TResponse>(IAsyncRequest <TResponse> request)
{
var defaultHandler = GetHandler(request);
RequestHandlerDelegate <TResponse> invokeHandler = () => defaultHandler.Handle(request);
var pipeline = GetPipeline(request, invokeHandler);
return(pipeline);
}
public async Task <IActionResult> InvokeHandlerAsync(IAsyncRequest request)
{
var actionResultSource = _serviceProvider.GetRequiredService <IActionResultSource>();
await _querier.InvokeHandlerAsync(request);
var actionResult = actionResultSource.ActionResult;
return(actionResult ?? new NoContentResult());
}
/// <summary>
/// Cancels the request for the <see cref="T:Mapbox.Map.Tile"/> object.
/// It will stop a network request and set the tile's state to Canceled.
/// </summary>
/// <example>
/// <code>
/// // Do not request tiles that we are already requesting
/// // but at the same time exclude the ones we don't need
/// // anymore, cancelling the network request.
/// tiles.RemoveWhere((T tile) =>
/// {
/// if (cover.Remove(tile.Id))
/// {
/// return false;
/// }
/// else
/// {
/// tile.Cancel();
/// NotifyNext(tile);
/// return true;
/// }
/// });
/// </code>
/// </example>
public void Cancel()
{
if (_request != null)
{
_request.Cancel();
_request = null;
}
_state = State.Canceled;
}
/// <summary>
/// Cancels the request for the <see cref="T:Mapbox.Map.Tile"/> object.
/// It will stop a network request and set the tile's state to Canceled.
/// </summary>
/// <example>
/// <code>
/// // Do not request tiles that we are already requesting
/// // but at the same time exclude the ones we don't need
/// // anymore, cancelling the network request.
/// this.tiles.RemoveWhere((T tile) =>
/// {
/// if (cover.Remove(tile.Id))
/// {
/// return false;
/// }
/// else
/// {
/// tile.Cancel();
/// this.NotifyNext(tile);
/// return true;
/// }
/// });
/// </code>
/// </example>
public void Cancel()
{
if (this.request != null)
{
this.request.Cancel();
this.request = null;
}
this.state = State.Canceled;
}
public async Task <Message> RequestAsync(Message message, TimeSpan timeout)
{
if (message == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("message");
}
if (timeout < TimeSpan.Zero)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new ArgumentOutOfRangeException("timeout", timeout, SR.SFxTimeoutOutOfRange0));
}
ThrowIfDisposedOrNotOpen();
AddHeadersTo(message);
IAsyncRequest request = CreateAsyncRequest(message);
TrackRequest(request);
try
{
Message reply;
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
TimeSpan savedTimeout = timeoutHelper.RemainingTime();
try
{
await request.SendRequestAsync(message, timeoutHelper);
}
catch (TimeoutException timeoutException)
{
throw TraceUtility.ThrowHelperError(new TimeoutException(SR.Format(SR.RequestChannelSendTimedOut, savedTimeout),
timeoutException), message);
}
savedTimeout = timeoutHelper.RemainingTime();
try
{
reply = await request.ReceiveReplyAsync(timeoutHelper);
}
catch (TimeoutException timeoutException)
{
throw TraceUtility.ThrowHelperError(new TimeoutException(SR.Format(SR.RequestChannelWaitForReplyTimedOut, savedTimeout),
timeoutException), message);
}
return(reply);
}
finally
{
ReleaseRequest(request);
}
}
public IAsyncRequest CompleteRequest(int transactionId)
{
if (transactionId == 0) // Exception based callback. No pending requests.
{
return(null);
}
IAsyncRequest request = _slots.Remove(transactionId - 1);
Log.TraceFormat("Request removed. Transaction id: {0}", transactionId);
return(request);
}
public async Task <ValidatedResult <TResponse> > SendAsync <TResponse>(IAsyncRequest <TResponse> request)
{
using (LoggerContext.DecorateWithUser())
{
_logger.Debug("Send {@request} for {User}", request);
}
var validationSummary = _requestValidator.Validate(request);
return(await GetValidatedResultAsync(request, validationSummary));
}
public static async Task CatchException <T>(this IAsyncRequest <T> command, TestContextFixture testContextFixture, Type exception)
{
try
{
await testContextFixture.SendAsync(command);
}
catch (Exception p)
{
p.ShouldBeOfType(exception);
}
}
public async Task <TResponse> SendAsync <TResponse>(IAsyncRequest <TResponse> request)
{
var response = default(TResponse);
await ExecuteScopeAsync(async sp =>
{
var mediator = sp.GetService <IMediator>();
response = await mediator.SendAsync(request);
});
return(response);
}
public async Task <Message> RouteShouldPass <TResp>(
IAsyncRequest <TResp> request, string resourceUri)
{
using (WebApp.Start(BaseAddress, Configuration))
{
return(await _mediator.PostAsync <Message, Message>(new Message(request), post =>
{
post.BaseAddress = BaseAddress;
post.ResourceUri = resourceUri;
post.TypeNameHandling = true;
}));
}
}
public static IAsyncResult BeginSendRequest <TRequest>(this IEndpoint endpoint, TRequest message, IServiceBus bus,
AsyncCallback callback, object state, Action <IInlineRequestConfigurator <TRequest> > configureCallback)
where TRequest : class
{
var configurator = new InlineRequestConfigurator <TRequest>(message);
configureCallback(configurator);
IAsyncRequest <TRequest> request = configurator.Build(bus);
endpoint.Send(message, context => configurator.ApplyContext(context, bus.Endpoint.Address.Uri));
return(request.BeginAsync(callback, state));
}
public void Cancel()
{
IAsyncRequest request = _fs.Request(
_mockBaseUrl + _testUrl.cancel
, (Response r) => {
Assert.IsTrue(r.HasError);
}
);
request.Cancel();
_fs.WaitForAllRequests();
}
public virtual void Enqueue <T>(IAsyncRequest <T> command, AppContext appContext)
{
if (_settings.IsDisabled)
{
return;
}
CreateCollection();
var queueJob = new QueueJob(command, appContext);
var collection = _database.GetCollection <QueueJob>(_settings.CollectionName);
collection.Insert(queueJob);
}
public override async Task <TResponseData> SendAsync <TResponseData>(IAsyncRequest <TResponseData> request)
{
if (!(request is IRequireApiSession))
{
return(await base.SendAsync(request).ConfigureAwait(false));
}
using (var scope = await _scopeFactory.StartSession().ConfigureAwait(false)) {
var response = await base.SendAsync(request).ConfigureAwait(false);
await scope.Close().ConfigureAwait(false);
return(response);
}
}
public static bool PublishRequest <TRequest>(this IServiceBus bus, TRequest message,
Action <IInlineRequestConfigurator <TRequest> > configureCallback)
where TRequest : class
{
var configurator = new InlineRequestConfigurator <TRequest>(message);
configureCallback(configurator);
IAsyncRequest <TRequest> request = configurator.Build(bus);
bus.Publish(message, context => configurator.ApplyContext(context, bus.Endpoint.Address.Uri));
return(request.Wait());
}
public async Task<IAsyncResponse> ExecuteRequestAsync(IAsyncRequest request)
{
_log.DebugFormat("Started executing async request : {0}, Id - {1} @ {2}", request.GetType().Name, request.Id, DateTime.Now);
var requestType = request.GetType();
var responseType = _requestResponseService.GetMatchingAsyncResponseType(requestType);
var requestHandlerType = typeof (IAsyncRequestHandler<,>).MakeGenericType(requestType, responseType);
var requestHandler = (IAsyncRequestHandler) IoC.Container.Resolve(requestHandlerType);
var response = await requestHandler.ExecuteAsync(request);
_log.DebugFormat("Finished executing async request : {0}, Id - {1} @ {2}", request.GetType().Name, request.Id, DateTime.Now);
return response;
}
public void AddRequest(IAsyncRequest request)
{
if (!IsConnected)
{
throw new Exception("Not connected");
}
int slot = _slots.TryAdd(request, OpcConfiguration.RequestTimeout);
if (slot == -1) // all slots occupied.
{
throw new Exception("Exceeded limit of pending requests.");
}
request.OnAdded(this, slot + 1);
// set transaction id to 1-based slot number. 0 is special case for exception based updates.
Log.TraceFormat("Request added. Transaction id: {0}", request.TransactionId);
}
