Beispiel #1
0
        public StreamFlowInvokeResponse Invoke(StreamFlowMessageBO request)
        {
            var entity = new InvokeMethodQuery()
            {
                Context      = Context,
                MessageQueue = request
            };
            var response = _mediator.Send(entity).Result;

            return(response.Response);
        }
Beispiel #2
0
        public async Task <QueryResponseBO <StreamFlowInvokeResponse> > Handle(InvokeMethodQuery request, CancellationToken cancellationToken)
        {
            // Check if Client is Registered
            var client = _cachingService.Clients.FirstOrDefault(x => x.StreamId == request.Context.ConnectionId);

            if (client == null)
            {
                Console.WriteLine($"Unknown or unauthorized client detected");
                await _hubContext.Clients.Client(request.Context.ConnectionId).SendAsync("TelemetryCall", "Client Unknown or Unauthorized");

                return(new()
                {
                    HttpStatusCode = HttpStatusCode.Forbidden
                });
            }

            request.RequestServer = new()
            {
                RequestId = client.Guid,
                Name      = client.Name
            };

            var telemetry = new StreamFlowTelemetryBO
            {
                ClientGuid   = client.Guid,
                RequestGuid  = request.MessageQueue.RequestGuid,
                ConsumerGuid = request.MessageQueue.ConsumerGuid
            };

            var c = _cachingService.Clients.FirstOrDefault(x => x.Guid == request.MessageQueue.Recipient);

            if (c != null)
            {
                _helperService.StopWatch.Start("Invoked Method");
                var methodCallCompletionSource = new TaskCompletionSource <StreamFlowMessageBO>();
                //methodCallCompletionSource.RunContinuationsAsynchronously();
                if (!_cachingService.PendingMethodCalls.TryAdd(request.MessageQueue.RequestGuid, methodCallCompletionSource))
                {
                    return(new()
                    {
                        HttpStatusCode = HttpStatusCode.InternalServerError,
                        Message = $"Error while invoking method '{request.MessageQueue.CommandName}' on {request.MessageQueue.Recipient}"
                    });
                }

                await _hubContext.Clients.Client(c.StreamId).SendAsync(request.MessageQueue.CommandName, request.MessageQueue.Data, request.MessageQueue.Message, telemetry, cancellationToken);

                var response = await methodCallCompletionSource.Task.ConfigureAwait(false);

                _helperService.StopWatch.Stop("Invoke Response Received");
                return(new()
                {
                    HttpStatusCode = HttpStatusCode.Accepted,
                    Response = new ()
                    {
                        HttpStatusCode = response.Adapt <CmdResponseBO>().HttpStatusCode,
                        Response = response.Data
                    }
                });
            }

            if (_cachingService.AbsoluteClients.All(x => x.Guid != request.MessageQueue.Recipient))
            {
                Console.WriteLine($"Connection with ID {request.RequestServer.RequestId} : {request.RequestServer.Name} has invalid recipient");
                return(new()
                {
                    HttpStatusCode = HttpStatusCode.NotFound,
                    Response = new()
                    {
                        HttpStatusCode = HttpStatusCode.NotFound
                    }
                });
            }


            Console.WriteLine($"Message from connection with ID {request.RequestServer.RequestId} : {request.RequestServer.Name} has been dropped; Recipient unavailable");
            return(new()
            {
                HttpStatusCode = HttpStatusCode.ServiceUnavailable,
                Response = new()
                {
                    HttpStatusCode = HttpStatusCode.NotFound
                }
            });
        }
    }