public async Task <string> Request_VM(
string vmId,
[FromQuery] string vmArg,
[FromServices] WebApiVMControllerFactory vmControllerFactory,
[FromServices] IHubServiceProvider hubServiceProvider,
[FromServices] IPrincipalAccessor principalAccessor,
[FromServices] IHubPipeline hubPipeline,
[FromServices] IDotNetifyHubResponseManager hubResponseManager
)
{
var hub = CreateHubHandler(vmControllerFactory, hubServiceProvider, principalAccessor, hubPipeline, hubResponseManager, nameof(IDotNetifyHubMethod.Request_VM), vmId, vmArg);
try
{
await hub.RequestVMAsync(vmId, vmArg);
_taskCompletionSource.TrySetResult(_responses.LastOrDefault());
_responses.Clear();
}
catch (Exception ex)
{
_taskCompletionSource.TrySetResult(ex.Serialize());
}
return(await _taskCompletionSource.Task);
}
/// <summary>
/// Creates a dotNetify hub that uses HTTP context for its hub context, and sets the response callback to a local function.
/// </summary>
/// <param name="vmControllerFactory">Factory of view model controllers.</param>
/// <param name="serviceProvider">Allows to provide scoped service provider for the view models.</param>
/// <param name="principalAccessor">Allows to pass the hub principal.</param>
/// <param name="hubPipeline">Manages middlewares and view model filters.</param>
/// <param name="hubResponseFactory">Factory of objects to send responses back to hub clients.</param>
/// <param name="callType">Hub call type.</param>
/// <param name="vmId">Identifies the view model.</param>
/// <param name="data">View model data.</param>
/// <returns>Hub instance.</returns>
private IDotNetifyHubHandler CreateHubHandler(
IVMControllerFactory vmControllerFactory,
IHubServiceProvider hubServiceProvider,
IPrincipalAccessor principalAccessor,
IHubPipeline hubPipeline,
IDotNetifyHubResponseManager hubResponseManager,
string callType,
string vmId,
object data = null)
{
var httpCallerContext = new HttpCallerContext(HttpContext);
if (principalAccessor is HubInfoAccessor)
{
var hubPrincipalAccessor = principalAccessor as HubInfoAccessor;
hubPrincipalAccessor.Principal = HttpContext?.User;
hubPrincipalAccessor.Context = new DotNetifyHubContext(httpCallerContext, callType, vmId, data, null, hubPrincipalAccessor.Principal);
}
return(new DotNetifyHubHandler(vmControllerFactory, hubServiceProvider, principalAccessor, hubPipeline, hubResponseManager)
{
CallerContext = httpCallerContext,
OnVMResponse = ResponseVMCallback
});
}
public async Task Dispose_VM(
string vmId,
[FromServices] WebApiVMControllerFactory vmControllerFactory,
[FromServices] IHubServiceProvider hubServiceProvider,
[FromServices] IPrincipalAccessor principalAccessor,
[FromServices] IHubPipeline hubPipeline,
[FromServices] IDotNetifyHubResponseManager hubResponseManager
)
{
var hub = CreateHubHandler(vmControllerFactory, hubServiceProvider, principalAccessor, hubPipeline, hubResponseManager, nameof(IDotNetifyHubMethod.Dispose_VM), vmId);
await hub.DisposeVMAsync(vmId);
}
/// <summary>
/// Constructor for dependency injection.
/// </summary>
/// <param name="vmControllerFactory">Factory of view model controllers.</param>
/// <param name="serviceProvider">Allows to provide scoped service provider for the view models.</param>
/// <param name="principalAccessor">Allows to pass the hub principal.</param>
/// <param name="hubPipeline">Manages middlewares and view model filters.</param>
/// <param name="globalHubContext">Provides access to hubs.</param>
public DotNetifyHub(
IVMControllerFactory vmControllerFactory,
IHubServiceProvider serviceProvider,
IPrincipalAccessor principalAccessor,
IHubPipeline hubPipeline,
IHubContext <DotNetifyHub> globalHubContext)
{
_vmControllerFactory = vmControllerFactory;
_vmControllerFactory.ResponseDelegate = Response_VM;
_serviceProvider = serviceProvider;
_principalAccessor = principalAccessor;
_hubPipeline = hubPipeline;
_globalHubContext = globalHubContext;
}
public async Task <string> Request_VM(
string vmId,
[FromQuery] string vmArg,
[FromServices] IVMFactory vmFactory,
[FromServices] IHubServiceProvider hubServiceProvider,
[FromServices] IVMServiceScopeFactory serviceScopeFactory,
[FromServices] IHubPipeline hubPipeline,
[FromServices] IPrincipalAccessor principalAccessor
)
{
var taskCompletionSource = new TaskCompletionSource <string>(TaskCreationOptions.RunContinuationsAsynchronously);
Task responseVM(string arg1, string arg2, string arg3)
{
taskCompletionSource.TrySetResult(arg3);
return(Task.CompletedTask);
}
var vmController = new VMController(responseVM, vmFactory, serviceScopeFactory.CreateScope())
{
ResponseVMFilter = CreateRespondingVMFilter(hubPipeline, vmId, vmArg)
};
var httpCallerContext = InitializeContext(vmController, hubServiceProvider, principalAccessor);
var connectionId = httpCallerContext.ConnectionId;
try
{
var hubContext = new DotNetifyHubContext(httpCallerContext, nameof(Request_VM), vmId, vmArg, BuildHeaders(), httpCallerContext.User);
vmController.RequestVMFilter = CreateVMFilter(hubContext, hubPipeline);
await hubPipeline.RunMiddlewaresAsync(hubContext, async ctx =>
{
await vmController.OnRequestVMAsync(connectionId, ctx.VMId, ctx.Data);
vmController.Dispose();
});
}
catch (Exception ex)
{
var finalEx = await hubPipeline.RunExceptionMiddlewareAsync(httpCallerContext, ex);
if (finalEx is OperationCanceledException == false)
{
taskCompletionSource.TrySetResult(DotNetifyHub.SerializeException(finalEx));
}
}
return(await taskCompletionSource.Task);
}
/// <summary>
/// Initializes the scoped context of the request.
/// </summary>
/// <param name="vmController">View model controller.</param>
/// <param name="hubServiceProvider">Service provideer context.</param>
/// <param name="principalAccessor">Principal user context.</param>
/// <returns>HTTP caller context.</returns>
private HttpCallerContext InitializeContext(VMController vmController, IHubServiceProvider hubServiceProvider, IPrincipalAccessor principalAccessor)
{
if (hubServiceProvider is HubServiceProvider)
{
(hubServiceProvider as HubServiceProvider).ServiceProvider = vmController.ServiceProvider;
}
var httpCallerContext = new HttpCallerContext(HttpContext);
if (principalAccessor is HubPrincipalAccessor)
{
var hubPrincipalAccessor = principalAccessor as HubPrincipalAccessor;
hubPrincipalAccessor.Principal = HttpContext?.User;
hubPrincipalAccessor.CallerContext = httpCallerContext;
}
return(httpCallerContext);
}
public async Task <string> Update_VM(
string vmId,
[FromQuery] string vmArg,
[FromBody] Dictionary <string, object> vmData,
[FromServices] IVMFactory vmFactory,
[FromServices] IHubServiceProvider hubServiceProvider,
[FromServices] IVMServiceScopeFactory serviceScopeFactory,
[FromServices] IHubPipeline hubPipeline,
[FromServices] IPrincipalAccessor principalAccessor)
{
var taskCompletionSource1 = new TaskCompletionSource <string>();
var taskCompletionSource2 = new TaskCompletionSource <string>();
var vmController = new VMController((arg1, arg2, arg3) =>
{
if (!taskCompletionSource1.TrySetResult(arg3))
{
taskCompletionSource2.TrySetResult(arg3);
}
}, vmFactory, serviceScopeFactory.CreateScope())
{
ResponseVMFilter = CreateRespondingVMFilter(hubPipeline, vmId, vmData)
};
var httpCallerContext = InitializeContext(vmController, hubServiceProvider, principalAccessor);
var connectionId = httpCallerContext.ConnectionId;
try
{
var hubContext = new DotNetifyHubContext(httpCallerContext, nameof(Request_VM), vmId, vmArg, BuildHeaders(), httpCallerContext.User);
vmController.RequestVMFilter = CreateVMFilter(hubContext, hubPipeline);
hubPipeline.RunMiddlewares(hubContext, ctx =>
{
vmController.OnRequestVM(connectionId, ctx.VMId, ctx.Data);
return(Task.CompletedTask);
});
}
catch (Exception ex)
{
var finalEx = hubPipeline.RunExceptionMiddleware(httpCallerContext, ex);
if (finalEx is OperationCanceledException == false)
{
taskCompletionSource1.TrySetResult(DotNetifyHub.SerializeException(finalEx));
}
}
await taskCompletionSource1.Task;
try
{
var hubContext = new DotNetifyHubContext(httpCallerContext, nameof(Update_VM), vmId, vmData, BuildHeaders(), httpCallerContext.User);
vmController.UpdateVMFilter = CreateVMFilter(hubContext, hubPipeline);
hubPipeline.RunMiddlewares(hubContext, ctx =>
{
vmController.OnUpdateVM(connectionId, ctx.VMId, ctx.Data as Dictionary <string, object>);
vmController.Dispose();
return(Task.CompletedTask);
});
}
catch (Exception ex)
{
var finalEx = hubPipeline.RunExceptionMiddleware(httpCallerContext, ex);
if (finalEx is OperationCanceledException == false)
{
taskCompletionSource2.TrySetResult(DotNetifyHub.SerializeException(finalEx));
}
}
return(await taskCompletionSource2.Task);
}
