public ConnectionControllerManager(Configuration configuration, ReceiveRequest<RequestPacket, ResponsePacket> connectionRequestDelegate, ReceiveRequest<RequestPacket, ResponsePacket> peerCoordinationDelegate) { _configuration = configuration; _connectionRequestPort = new OneShotServerPort<RequestPacket, ResponsePacket>(configuration.ServerAddress, configuration.ConnectionRequestLocalPort); _peerCoordinationPort = new OneShotServerPort<RequestPacket, ResponsePacket>(configuration.ServerAddress, configuration.PeerCoordinationLocalPort); _connectionRequestPort.RegisterReceiveRequestDelegate(connectionRequestDelegate); _peerCoordinationPort.RegisterReceiveRequestDelegate(peerCoordinationDelegate); }
public async void DoesNotThrowExceptionIfReceiveRequestIsNull() { // Arrange var handler = new StreamingRequestHandler(new MockBot(), new BotFrameworkHttpAdapter(), Guid.NewGuid().ToString()); ReceiveRequest testRequest = null; // Act var response = await handler.ProcessRequestAsync(testRequest); // Assert Assert.Equal(400, response.StatusCode); }
private void ProcessRequest(Guid id, ReceiveRequest request) { _ = Task.Run(async() => { var streamingResponse = await _receiver.ProcessRequestAsync(request, null).ConfigureAwait(false); await SendResponseAsync(new Header() { Id = id, Type = PayloadTypes.Response }, streamingResponse, _connectionCancellationToken).ConfigureAwait(false); request.Streams.ForEach(s => _streamDefinitions.Remove(s.Id)); }); }
protected override void Execute(CodeActivityContext context) { IOperationActivity receiveRequest = ReceiveRequest.Get(context); Type workflowInterfaceType = WorkflowInterfaceType.Get(context); Type requestResultType = RequestResultType.Get(context); Type responseParameterType = ResponseParameterType.Get(context); if (receiveRequest != null && workflowInterfaceType != null && requestResultType != null && responseParameterType != null) { receiveRequest.OperationNames.Set( typeof(WorkflowInterfaceInfo <>).MakeGenericType(workflowInterfaceType) .GetMethod(nameof(WorkflowInterfaceInfo <object> .GetOperationNames)).Invoke(null, new object[] { requestResultType, responseParameterType }) as IEnumerable <string>); } }
private static async Task <T> ReadOptionalBodyAsJson <T>(ReceiveRequest request) { // The first stream attached to a ReceiveRequest is always the ReceiveRequest body. // Any additional streams must be defined within the body or they will not be // attached properly when processing activities. var contentStream = request.Streams.FirstOrDefault(); if (contentStream != null) { var contentString = await ReadBuffer(contentStream).ConfigureAwait(false); return(JsonConvert.DeserializeObject <T>(contentString)); } return(default(T)); }
public void SerializeToJson_ShouldReturnCorrectReceiveJson_IfSerializationIsCorrect() { // Arrange ReceiveRequest request = new ReceiveRequest() { MessageIndex = 2, UserId = "maria" }; // Act string serializedRequest = request.SerializeToJson(); // Assert Assert.AreEqual(serializedRequest, "{\"cmd\":\"receber\",\"id\":\"maria\",\"msgNr\":2}"); }
//private MPI.Intercommunicator channel; private RequestList synchronize_action(object action_id) { Console.WriteLine("ActionDef.action_ids.Count = " + ActionDef.action_ids.Count); int value = ActionDef.action_ids[action_id]; RequestList request_list = new RequestList(); Trace.WriteLineIf(this.TraceFlag == true, this.ThisFacetInstance + "/" + this.Rank + ": synchronize_action " + action_id + " -1"); Trace.WriteLineIf(this.TraceFlag == true, this.ThisFacetInstance + "/" + this.Rank + ": synchronize_action " + action_id + " 0"); foreach (KeyValuePair <int, IDictionary <string, int> > facet in Channel.UnitSizeInFacet) { if (facet.Key != this.ThisFacetInstance) { foreach (KeyValuePair <string, int> unit_team in facet.Value) { for (int i = 0; i < unit_team.Value; i++) { Trace.WriteLineIf(this.TraceFlag == true, "synchronize_action " + action_id + " LOOP SEND " + facet.Key + "/" + i); Request req = Channel.ImmediateSend <object> (value, new Tuple <int, int> (facet.Key, i), value); request_list.Add(req); } } } } Trace.WriteLineIf(this.TraceFlag == true, this.ThisFacetInstance + "/" + this.Rank + ": synchronize_action " + action_id + " 1"); foreach (KeyValuePair <int, IDictionary <string, int> > facet in Channel.UnitSizeInFacet) { if (facet.Key != this.ThisFacetInstance) { foreach (KeyValuePair <string, int> unit_team in facet.Value) { for (int i = 0; i < unit_team.Value; i++) { Trace.WriteLineIf(this.TraceFlag == true, "synchronize_action " + action_id + " LOOP RECV " + facet.Key + "/" + i); ReceiveRequest req = Channel.ImmediateReceive <object> (new Tuple <int, int> (facet.Key, i), value); request_list.Add(req); } } } } Trace.WriteLineIf(this.TraceFlag == true, this.ThisFacetInstance + "/" + this.Rank + ": synchronize_action " + action_id + " 2"); return(request_list); }
public RoutingControllerManager(Configuration configuration, ReceiveRequest <RequestPacket, ResponsePacket> routeTableQueryDelegate, ReceiveRequest <RequestPacket, ResponsePacket> localTopologyDelegate, ReceiveRequest <RequestPacket, ResponsePacket> networkTopologyDelegate) { _configuration = configuration; _routeTableQueryPort = new OneShotServerPort <RequestPacket, ResponsePacket>(configuration.ServerAddress, configuration.RouteTableQueryLocalPort); _localTopologyPort = new OneShotServerPort <RequestPacket, ResponsePacket>(configuration.ServerAddress, configuration.LocalTopologyLocalPort); _networkTopologyPort = new OneShotServerPort <RequestPacket, ResponsePacket>(configuration.ServerAddress, configuration.NetworkTopologyLocalPort); _routeTableQueryPort.RegisterReceiveRequestDelegate(routeTableQueryDelegate); _localTopologyPort.RegisterReceiveRequestDelegate(localTopologyDelegate); _networkTopologyPort.RegisterReceiveRequestDelegate(networkTopologyDelegate); }
/// <summary> /// Implements transaction for Send /// </summary> /// <param name="parameters"></param> /// <returns>Transaction result</returns> public override ITransactionResult Transaction(object parameters) { var sendParameters = (SendParameters)parameters; TestConfig.TestSettings = new IntegrationTestSettingsModel { AcEnvironment = sendParameters.Environment }; var amtRangeParsed = Enum.TryParse(sendParameters?.AmtRange, true, out AmountRange amtRange); var itemChoiceTypeParsed = Enum.TryParse(sendParameters?.FeeType, true, out ItemChoiceType1 itemChoiceType); var sendRequest = new SendRequest { Environment = sendParameters.Environment, AgentCountryIsoCode = sendParameters.AgentCountryIsoCode, AgentId = sendParameters.AgentId, AgentPos = sendParameters.AgentPos, AgentState = sendParameters.GetAgentState(), Amount = (double)sendParameters.CustomAmount, AmtRange = amtRangeParsed ? amtRange : AmountRange.CustomAmount, Country = sendParameters.Country, State = sendParameters.State, FeeType = itemChoiceTypeParsed ? itemChoiceType : ItemChoiceType1.amountExcludingFee, SendCurr = sendParameters.SendCurr, ServiceOption = sendParameters.ServiceOption, ThirdPartyType = sendParameters.ThirdPartyType }; var receiveAgentState = sendParameters.State.Split('-')[1]; var receiveRequest = new ReceiveRequest { AgentState = receiveAgentState, ThirdPartyType = sendParameters.ThirdPartyType }; var sendData = new SendData(sendRequest); sendData = SendOperations.SendCompleteForNewCustomer(sendData); var receiveData = new ReceiveData(receiveRequest); receiveData.Set(sendData); receiveData = ReceiveOperations.ReceiveCompleteStaged(receiveData); return(new TransactionResult { Result = receiveData }); }
public static ReceiveResponse GetPendingMessages(ReceiveRequest request) { ReceiveResponse response = new ReceiveResponse(); // Get pending messages for this user: response.Data = new PendingMessages(); response.Data.Messages = new List <PendingMessage>(); response.Data.Messages.AddRange(AsyncListener.PendingMessages .Where(m => m.DestinationUserId == request.UserId) .ToPendingMessages()); response.UserId = "0"; // Remove pending messages from buffer: AsyncListener.PendingMessages.RemoveAll(m => m.DestinationUserId == request.UserId); return(response); }
public void ReceiveReversalTransaction_ShouldFailForNonReceivingAgent() { var sendRequest = new SendRequest { AgentState = AgentLocation.MN, Country = Country.Usa, State = State.Ny, SendCurr = Currency.Usd, AmtRange = AmountRange.NoIdsNoThirdParty, FeeType = ItemChoiceType1.amountExcludingFee, ServiceOption = ServiceOptionType.WillCall }; sendRequest.PopulateAgentData(sendRequest.AgentState); var sendData = new SendData(sendRequest); var receiveRequest = new ReceiveRequest { AgentState = AgentLocation.NY, ThirdPartyType = TestThirdPartyType.None }; receiveRequest.PopulateAgentData(receiveRequest.AgentState); var receiveData = new ReceiveData(receiveRequest); sendData = _sendOperations.SendCompleteForExistingCustomer(sendData); receiveData.Set(sendData); _recvOperations.ReceiveComplete(receiveData); var request = new ReceiveReversalOperationRequest { AgentState = AgentLocation.MN, ReferenceNumber = receiveData.SendData.CompleteSessionResp.Payload.ReferenceNumber }; request.PopulateAgentData(request.AgentState); var receiveReversalData = receiveReversalOperations.SingleValidate(request); Assert.IsFalse(receiveReversalData.Errors.Any(), $" {Environment.NewLine}Errors: {Environment.NewLine}{receiveReversalData.Errors?.Log()}"); var lastValidationResponse = receiveReversalData.ValidationResponses.LastOrDefault(); Assert.IsTrue(lastValidationResponse.Errors.Any()); }
public void ReceiveReversalTransaction_Complete() { var sendRequest = new SendRequest { AgentState = AgentLocation.MN, Country = Country.Usa, State = State.Ny, SendCurr = Currency.Usd, AmtRange = AmountRange.UnderOneHundred, FeeType = ItemChoiceType1.amountExcludingFee, ServiceOption = ServiceOptionType.WillCall }; sendRequest.PopulateAgentData(sendRequest.AgentState); var sendData = new SendData(sendRequest); var receiveRequest = new ReceiveRequest { AgentState = AgentLocation.NY, ThirdPartyType = TestThirdPartyType.None }; receiveRequest.PopulateAgentData(receiveRequest.AgentState); var receiveData = new ReceiveData(receiveRequest); sendData = _sendOperations.SendCompleteForExistingCustomer(sendData); receiveData.Set(sendData); _recvOperations.ReceiveComplete(receiveData); //Get the transaction reference number var request = new ReceiveReversalOperationRequest { AgentState = AgentLocation.NY, ReferenceNumber = receiveData.SendData.CompleteSessionResp.Payload.ReferenceNumber }; request.PopulateAgentData(request.AgentState); var receiveReversalData = receiveReversalOperations.ReceiveReversalComplete(request); Assert.IsFalse(receiveReversalData.Errors.Any(), $" {Environment.NewLine}Errors: {Environment.NewLine}{receiveReversalData.Errors?.Log()}"); //Commented out as CompleteSessionResponse does not contain reference number when performing Receive Reversal. The above check for errors is enough. //Assert.IsFalse(string.IsNullOrEmpty(receiveReversalData.CompleteSessionResp.Payload.ReferenceNumber), "there was no reference number on the receive reversal completion response"); }
public void DeserializeFromJson_ShouldReturnCorrectReceiveJson_IfSerializationIsCorrect() { // Arrange ReceiveRequest expectedRequest = new ReceiveRequest() { MessageIndex = 1, UserId = "maria" }; string json = expectedRequest.SerializeToJson(); // Act ReceiveRequest deserializedRequest = json.DeserializeFromJson <ReceiveRequest>(); // Assert Assert.AreEqual(deserializedRequest.CommandName, expectedRequest.CommandName); Assert.AreEqual(deserializedRequest.MessageIndex, expectedRequest.MessageIndex); Assert.AreEqual(deserializedRequest.UserId, expectedRequest.UserId); }
public NetworkCallControllerManager(Configuration configuration, ReceiveRequest <RequestPacket, ResponsePacket> callCoordinationPortDelegate, ReceiveRequest <RequestPacket, ResponsePacket> callTeardownPortDelegate, ReceiveRequest <RequestPacket, ResponsePacket> connectionRequestPortDelegate) { _configuration = configuration; _clientPortAliases = _configuration.ClientPortAliases; _portDomains = _configuration.PortDomains; _domain = _configuration.Domain; _callCoordinationPort = new OneShotServerPort <RequestPacket, ResponsePacket>(_configuration.ServerAddress, _configuration.CallCoordinationLocalPort); _callTeardownPort = new OneShotServerPort <RequestPacket, ResponsePacket>(_configuration.ServerAddress, _configuration.CallTeardownLocalPort); _connectionRequestPort = new OneShotServerPort <RequestPacket, ResponsePacket>(_configuration.ServerAddress, _configuration.ConnectionRequestLocalPort); _callCoordinationPort.RegisterReceiveRequestDelegate(callCoordinationPortDelegate); _callTeardownPort.RegisterReceiveRequestDelegate(callTeardownPortDelegate); _connectionRequestPort.RegisterReceiveRequestDelegate(connectionRequestPortDelegate); }
public override async Task <StreamingResponse> ProcessRequestAsync(ReceiveRequest request, ILogger <RequestHandler> logger, object context = null, CancellationToken cancellationToken = default(CancellationToken)) { if (request.Verb == "POST" && request.Path == _postActivitiesPath) { var activitySet = await ReadOptionalBodyAsJson <ActivitySet>(request).ConfigureAwait(false); if (request.Streams.Count > 1) { var attachmentDictionary = request.Streams.Skip(1).ToDictionary(a => a.Id); int streamsMappedtoActivitiesCount = 0; foreach (var activity in activitySet.Activities) { if (activity.Attachments == null || activity.Attachments.Count == 0) { continue; } for (int i = 0; i < activity.Attachments.Count(); i++) { if (string.Equals(activity.Attachments[i].ContentType, "bf-stream", StringComparison.InvariantCultureIgnoreCase)) { var id = Guid.Parse(activity.Attachments[i].Content.ToString()); var stream = attachmentDictionary[id]; activity.Attachments[i] = new Attachment() { ContentType = stream.ContentType, Content = stream.Stream }; streamsMappedtoActivitiesCount++; } } if (streamsMappedtoActivitiesCount == request.Streams.Count - 1) { break; } } } _receiveActivities(activitySet); return(StreamingResponse.OK()); } return(StreamingResponse.NotFound()); }
/// <summary> /// Method that receives messages /// </summary> private void ReceiveMessages() { while (ContinueExecution) { // Receive next message and handle it ReceiveRequest asyncReceive = null; lock (comm) { // starts an asynchronous receive of the next message // Note: Must be asynchronous otherwise the lock of the comm object may cause a dead lock (unable to send message because we are waiting for one) asyncReceive = comm.ImmediateReceive <Message>(Communicator.anySource, 0); } // Creates a task that waits for the result to arrive. // Note : We must use a task because the Wait function of a task allows for a timeout parameter which we need to validate if the execution is still ongoing Task waitForMessage = new Task(() => { asyncReceive.Wait(); }); waitForMessage.Start(); // waits for a message to be received, stops (within 200ms) if the execution stops while (ContinueExecution && !waitForMessage.Wait(200)) { ; } if (!ContinueExecution) { asyncReceive.Cancel(); // We need to wait for the asyncReceive cancellation because the completion of this thread will close MPI but we need to make sure the cancel is over by then. asyncReceive.Wait(); break; // if the execution is over, the message may not be valid and should be ignored. } messageQueue.Add((Message)asyncReceive.GetValue()); } // Signal the main MapManager thread that this thread is correctly closed and we won't receive any other messages messageQueue.CompleteAdding(); }
public async void DoesNotThrowExceptionIfReceiveRequestHasNoActivity() { // Arrange var handler = new StreamingRequestHandler(new MockBot(), new BotFrameworkHttpAdapter(), Guid.NewGuid().ToString()); var payload = new MemoryStream(); var fakeContentStreamId = Guid.NewGuid(); var fakeContentStream = new FakeContentStream(fakeContentStreamId, "application/json", payload); var testRequest = new ReceiveRequest { Verb = "POST", }; testRequest.Streams.Add(fakeContentStream); // Act var response = await handler.ProcessRequestAsync(testRequest); // Assert Assert.Equal(400, response.StatusCode); }
private async Task ProcessRequest(Stream stream) { using (var textReader = new StreamReader(stream)) { using (var jsonReader = new JsonTextReader(textReader)) { var requestPayload = Serializer.Deserialize <RequestPayload>(jsonReader); var request = new ReceiveRequest() { Verb = requestPayload.Verb, Path = requestPayload.Path, Streams = new List <IContentStream>(), }; if (requestPayload.Streams != null) { foreach (var streamDescription in requestPayload.Streams) { if (!Guid.TryParse(streamDescription.Id, out Guid id)) { throw new InvalidDataException($"Stream description id '{streamDescription.Id}' is not a Guid"); } var streamAssembler = _streamManager.GetPayloadAssembler(id); streamAssembler.ContentType = streamDescription.ContentType; streamAssembler.ContentLength = streamDescription.Length; request.Streams.Add(new ContentStream(id, streamAssembler) { Length = streamDescription.Length, ContentType = streamDescription.ContentType, }); } } await _onCompleted(this.Id, request).ConfigureAwait(false); } } }
public override async Task <Response> ProcessRequestAsync(ReceiveRequest request) { var response = new Response(); var body = request.ReadBodyAsString().Result; if (string.IsNullOrEmpty(body)) { response.StatusCode = 400; return(response); } try { var activity = JsonConvert.DeserializeObject <Activity>(body, SerializationSettings.DefaultDeserializationSettings); var invokeResponse = await this.StreamingAdapter.ProcessActivityAsync(activity, new BotCallbackHandler(this.Bot.OnTurnAsync), CancellationToken.None).ConfigureAwait(false); if (invokeResponse == null) { response.StatusCode = 200; } else { response.StatusCode = invokeResponse.Status; if (invokeResponse.Body != null) { response.SetBody(invokeResponse.Body); } } invokeResponse = (InvokeResponse)null; } catch (Exception) { // TODO: Better exception handling. response.StatusCode = 403; } return(response); }
private async Task <StreamingResponse> ProcessRequest(ReceiveRequest request) { StreamingResponse response = null; if (!_responses.TryGetValue(GetRequestKey(request), out PendingRequest pendingRequest)) { response = new StreamingResponse() { StatusCode = 500, }; } else { response = pendingRequest.Response; if (pendingRequest.ValidateRequest != null) { await pendingRequest.ValidateRequest(request); } } return(response); }
public void Recv_ThirdParty_Org_Complete() { var sendRequest = new SendRequest { AgentState = AgentLocation.MN, Country = Country.Usa, State = State.Ny, SendCurr = Currency.Usd, AmtRange = AmountRange.ThirdParty, FeeType = ItemChoiceType1.amountExcludingFee, ServiceOption = ServiceOptionType.WillCall, ThirdPartyType = TestThirdPartyType.Org }; sendRequest.PopulateAgentData(sendRequest.AgentState); var sendData = new SendData(sendRequest); sendData = SendOperations.SendCompleteForThirdParty(sendData); var receiveRequest = new ReceiveRequest { AgentState = AgentLocation.NY, ThirdPartyType = TestThirdPartyType.Org }; receiveRequest.PopulateAgentData(receiveRequest.AgentState); var receiveData = new ReceiveData(receiveRequest); receiveData.Set(sendData); receiveData = ReceiveOperations.ReceiveComplete(receiveData); var transLookupResponse = TranLookupOperations.TransactionLookupForStatus(receiveRequest.AgentId, receiveRequest.AgentPos, receiveData.SendData.CompleteSessionResp.Payload.ReferenceNumber); // ASSERT ALL THE THINGS Assert.IsFalse(sendData.Errors.Any(), $" {Environment.NewLine}Errors: {Environment.NewLine}{sendData.Errors?.Log()}"); Assert.IsFalse(receiveData.Errors.Any(), $" {Environment.NewLine}Errors: {Environment.NewLine}{sendData.Errors?.Log()}"); Assert.IsTrue(transLookupResponse.TransactionLookupResp.Payload.TransactionStatus == TransactionStatusType.RECVD); }
public override async Task <StreamingResponse> ProcessRequestAsync(ReceiveRequest request, ILogger <RequestHandler> logger = null, object context = null, CancellationToken cancellationToken = default(CancellationToken)) { if (request.Verb == "POST") { var firstActivity = request.ReadBodyAsJson <Activity>(); if (request.Streams.Count > 1) { if (firstActivity == null) { throw new InvalidOperationException("Attachment streams received with activity set, but no activities present in activity set."); } var streamAttachments = new List <Attachment>(); for (int i = 1; i < request.Streams.Count; i++) { var stream = request.Streams[i].Stream; streamAttachments.Add(new Attachment() { ContentType = request.Streams[i].ContentType, Content = request.Streams[i].Stream }); } if (firstActivity.Attachments != null) { firstActivity.Attachments = firstActivity.Attachments.Concat(streamAttachments).ToArray(); } else { firstActivity.Attachments = streamAttachments.ToArray(); } } _receiveActivities(firstActivity); return(StreamingResponse.OK()); } return(StreamingResponse.NotFound()); }
public override async Task <Response> ProcessRequestAsync(ReceiveRequest request, object context = null, ILogger <RequestHandler> logger = null) { var routeContext = _router.Route(request); if (routeContext != null) { try { var responseBody = await routeContext.Action.Action(request, routeContext.RouteData).ConfigureAwait(false); return(Response.OK(new StringContent(JsonConvert.SerializeObject(responseBody, SerializationSettings.DefaultSerializationSettings), Encoding.UTF8, SerializationSettings.ApplicationJson))); } catch { return(Response.InternalServerError()); } } else { return(Response.NotFound()); } }
public async Task RequestHandlerForgetsConversations() { // Arrange var handler = new StreamingRequestHandler(new MockBot(), new BotFrameworkHttpAdapter(), "fakePipe"); var conversationId = "testconvoid"; var membersAdded = new List <ChannelAccount>(); var member = new ChannelAccount { Id = "123", Name = "bot", }; membersAdded.Add(member); var activity = new Activity() { Type = "conversationUpdate", MembersAdded = membersAdded, Conversation = new ConversationAccount(null, null, conversationId, null, null, null, null), }; var payload = new MemoryStream(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(activity, SerializationSettings.DefaultDeserializationSettings))); var fakeContentStreamId = Guid.NewGuid(); var fakeContentStream = new FakeContentStream(fakeContentStreamId, "application/json", payload); var testRequest = new ReceiveRequest { Path = $"/v3/conversations/{activity.Conversation?.Id}/activities/{activity.Id}", Verb = "POST", }; testRequest.Streams.Add(fakeContentStream); // Act _ = await handler.ProcessRequestAsync(testRequest); handler.ForgetConversation(conversationId); // Assert Assert.False(handler.HasConversation(conversationId)); }
public void ReceiveExtensions_ReadBodyAsJson_Streams() { var activity = new Activity { Type = ActivityTypes.Message }; var stringInput = JsonConvert.SerializeObject(activity); var stream = new MemoryStream(Encoding.UTF8.GetBytes(stringInput)); var mockContentStream = new Mock <IContentStream>(); mockContentStream.Setup(e => e.Stream).Returns(stream); var request = new ReceiveRequest { Streams = new List <IContentStream> { mockContentStream.Object } }; var result = request.ReadBodyAsJson <Activity>(); Assert.NotNull(result); Assert.Equal(activity.Type, result.Type); }
public async void RequestHandlerAssignsAServiceUrl() { // Arrange var handler = new StreamingRequestHandler(new MockBot(), new BotFrameworkHttpAdapter(), Guid.NewGuid().ToString()); var conversationId = Guid.NewGuid().ToString(); var serviceUrl = "urn:FakeName:fakeProtocol://fakePath"; var membersAdded = new List <ChannelAccount>(); var member = new ChannelAccount { Id = "123", Name = "bot", }; membersAdded.Add(member); var activity = new Activity() { ServiceUrl = serviceUrl, Type = "conversationUpdate", MembersAdded = membersAdded, Conversation = new ConversationAccount(null, null, conversationId, null, null, null, null), }; var payload = new MemoryStream(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(activity, SerializationSettings.DefaultDeserializationSettings))); var fakeContentStreamId = Guid.NewGuid(); var fakeContentStream = new FakeContentStream(fakeContentStreamId, "application/json", payload); var testRequest = new ReceiveRequest { Path = $"/v3/conversations/{activity.Conversation?.Id}/activities/{activity.Id}", Verb = "POST", }; testRequest.Streams.Add(fakeContentStream); // Act _ = await handler.ProcessRequestAsync(testRequest); // Assert Assert.Equal(serviceUrl, handler.ServiceUrl); }
public void ReceivedRequests() { GlobalDefinitions.wait(60); Actions builder = new Actions(Global.GlobalDefinitions.driver); builder.MoveToElement(ClickManageRequests).Build().Perform(); ClickManageRequests.Click(); GlobalDefinitions.wait(60); WebDriverWait wait = new WebDriverWait(GlobalDefinitions.driver, TimeSpan.FromSeconds(60)); wait.Until(ExpectedConditions.ElementToBeClickable(ReceiveRequest)); ReceiveRequest.Click(); Assert.That(ReceivedTitle.Text, Is.EqualTo("Received Requests")); Base.test.Log(LogStatus.Info, "Sucessully in Received Requests Page"); }
public Task<int> ReceiveAsync(byte[] buffer) { this.ThrowIfDisposed(); Task<int> resultTask; ReceiveRequest requestResult = null; lock (this.excessBuffers) { if (this.pendingReceiveRequest != null) { throw new InvalidOperationException("A receive operation is already in progress"); } this.pendingReceiveRequest = new ReceiveRequest(buffer); resultTask = this.pendingReceiveRequest.ReceiveTask; bool dataSend = this.SendDataToReceiver(); if (dataSend) { requestResult = this.pendingReceiveRequest; /* due to the synchronous continuation execution after SetResult to the pendingReceive task * the SetResult must be after null assignment to this.pendingReceiveRequest * otherwise, the conitnuation task might execute before null assignment to this.pendingReceiveRequest */ this.pendingReceiveRequest = null; } } // to prevent deadlocks, you should generally avoid running arbitrary user code such as event handlers or in this case, continuations (invoked by SetResult), under a lock if (requestResult != null) { requestResult.CompleteRequest(); } return resultTask; }
public void Recv_StageReceive_SmallAmount_NewCustomer() { var sendRequest = new SendRequest { AgentState = AgentLocation.MN, Country = Country.Usa, State = State.Ny, SendCurr = Currency.Usd, AmtRange = AmountRange.UnderOneHundred, FeeType = ItemChoiceType1.amountExcludingFee, ThirdPartyType = TestThirdPartyType.None }; sendRequest.PopulateAgentData(sendRequest.AgentState); var sendData = new SendData(sendRequest); sendData = SendOperations.SendCompleteForNewCustomer(sendData); var receiveRequest = new ReceiveRequest() { AgentState = AgentLocation.NY, ThirdPartyType = TestThirdPartyType.None }; receiveRequest.PopulateAgentData(receiveRequest.AgentState); var receiveData = new ReceiveData(receiveRequest); receiveData.Set(sendData); receiveData = ReceiveOperations.ReceiveCompleteStaged(receiveData); receiveData = ReceiveOperations.TransactionLookupForReceiveCompletion(receiveData); // ASSERT ALL THE THINGS Assert.IsFalse(sendData.Errors.Any(), $" {Environment.NewLine}Errors: {Environment.NewLine}{sendData.Errors?.Log()}"); Assert.IsFalse(receiveData.Errors.Any(), $" {Environment.NewLine}Errors: {Environment.NewLine}{sendData.Errors?.Log()}"); Assert.IsFalse(receiveData.TransactionLookupResponse.Errors.Any(), $" {Environment.NewLine}Errors: {Environment.NewLine}{receiveData.TransactionLookupResponse.Errors?.Log()}"); Assert.IsTrue(receiveData.TransactionLookupResponse.Payload.TransactionStatus == TransactionStatusType.AVAIL); }
public Task <int> ReceiveAsync(byte[] buffer) { Task <int> task; ReceiveRequest receiveToComplete = null; lock (this.excessBuffers) { this.ThrowIfDisposed(); if (this.pendingReceive != null) { throw new InvalidOperationException("A receive operation is already in progress."); } this.pendingReceive = new ReceiveRequest(buffer); task = this.pendingReceive.Task; while ((this.excessBuffers.Count > 0) && (this.pendingReceive.RemainingBytes > 0)) { receiveToComplete = this.pendingReceive; byte[] excess = this.excessBuffers.First.Value; this.excessBuffers.RemoveFirst(); int bytesReceived = this.pendingReceive.AddData(excess); this.AddExcess(excess, bytesReceived, true); } if (receiveToComplete != null) { this.pendingReceive = null; } } if (receiveToComplete != null) { receiveToComplete.Complete(); } return(task); }
public override async Task <StreamingResponse> ProcessRequestAsync(ReceiveRequest request, ILogger <RequestHandler> logger, object context = null, CancellationToken cancellationToken = default) { var routeContext = _router.Route(request); if (routeContext != null) { try { var responseBody = await routeContext.Action.Action(request, routeContext.RouteData).ConfigureAwait(false); return(StreamingResponse.OK(new StringContent(JsonConvert.SerializeObject(responseBody, SerializationSettings.DefaultSerializationSettings), Encoding.UTF8, SerializationSettings.ApplicationJson))); } catch (Exception ex) { _botTelemetryClient.TrackException(ex); return(StreamingResponse.InternalServerError()); } } else { return(StreamingResponse.NotFound()); } }
public void Send(byte[] buffer) { this.ThrowIfDisposed(); ReceiveRequest requestResult = null; lock (this.excessBuffers) { this.excessBuffers = this.excessBuffers.Concat(buffer).ToList(); if (this.pendingReceiveRequest != null) { bool dataSend = this.SendDataToReceiver(); if (dataSend) { requestResult = this.pendingReceiveRequest; /* due to the synchronous continuation execution after SetResult to the pendingReceive task * the SetResult must be after null assignment to this.pendingReceiveRequest * otherwise, the conitnuation task might execute before null assignment to this.pendingReceiveRequest */ this.pendingReceiveRequest = null; } } } // to prevent deadlocks, you should generally avoid running arbitrary user code such as event handlers or in this case, continuations (invoked by SetResult), under a lock if (requestResult != null) { requestResult.CompleteRequest(); } }
static void Main(string[] args) { using (new MPI.Environment(ref args)) { if (args.Length != 1) { return; } const int matrixSize = 50; Intracommunicator comm = Communicator.world; int groupCount = int.Parse(args[0]); if (comm.Rank == 0) { DateTime startTime = DateTime.Now; MatrixMultiply testMultiply = new MatrixMultiply(comm.Size, matrixSize); Matrix result = testMultiply.MultiplyForRank(0); for (int i = 1; i < comm.Size; i++) { result.Append(testMultiply.MultiplyForRank(i)); } DateTime endTime = DateTime.Now; Console.WriteLine("Test multiply" + (startTime - endTime).ToString()); int workers = comm.Size - groupCount - 1; Console.WriteLine("All process count: " + (comm.Size).ToString()); Console.WriteLine("Workers count: " + (workers + groupCount).ToString()); Console.WriteLine("Group count" + (groupCount).ToString()); int workerIndex = groupCount + 1; int managersWithoutWorkers = groupCount; Request[] sendRequest = new Request[groupCount]; for (int i = 0; i < groupCount; i++) { int workersIntheGroup = (int)Math.Floor((double)(workers / managersWithoutWorkers)); MatrixMultiply mp = new MatrixMultiply(workersIntheGroup + 1, matrixSize) { WorkersList = new List<int>(), IsAManager = true }; for (int j = 0; j < workersIntheGroup; j++) { mp.WorkersList.Add(workerIndex); // Console.WriteLine("WorkerID " + workerIndex); workerIndex++; workers--; } managersWithoutWorkers--; Console.WriteLine("Group " + i.ToString() + " has " + (workersIntheGroup + 1).ToString() + "members"); sendRequest[i] = comm.ImmediateSend(mp, i + 1, 0); } Console.WriteLine("Sending the job"); for (int i = 0; i < groupCount; i++) { sendRequest[i].Wait(); } ReceiveRequest[] recieveRequest = new ReceiveRequest[groupCount]; for (int i = 0; i < groupCount; i++) { recieveRequest[i] = comm.ImmediateReceive<Matrix>(i + 1, 0); } Console.WriteLine("Recieve results"); for (int i = 0; i < groupCount; i++) { recieveRequest[i].Wait(); } //for (int i = 0; i < groupCount; i++) // { // var result = recieveRequest[i].GetValue(); // if(result == null) // { // Console.WriteLine("Null get"); // } // Console.WriteLine("Group " + i + " has finished in " + ((TimeSpan)recieveRequest[i].GetValue()).ToString()); //} } else { ReceiveRequest receiveRequest = comm.ImmediateReceive<MatrixMultiply>(Communicator.anySource, 0); receiveRequest.Wait(); MatrixMultiply mp = (MatrixMultiply)receiveRequest.GetValue(); if (mp.IsAManager) { DateTime startTime = DateTime.Now; mp.IsAManager = false; mp.Chef = comm.Rank; Request[] sendRequestToWorker = new Request[mp.WorkersList.Count]; int index = 0; //Console.WriteLine("MAnager " + mp.WorkersList.Count); foreach (int workerId in mp.WorkersList) { mp.workerId = index + 1; sendRequestToWorker[index] = comm.ImmediateSend(mp, workerId, 0); // Console.WriteLine("Worker " + mp.WorkersList.Count + " " + index); index++; } for (int i = 0; i < mp.WorkersList.Count; i++) { sendRequestToWorker[i].Wait(); } var result = mp.MultiplyForRank(0); ReceiveRequest[] receiveRequestFromWorkers = new ReceiveRequest[mp.WorkersList.Count]; for (int i = 0; i < mp.WorkersList.Count; i++) { receiveRequestFromWorkers[i] = comm.ImmediateReceive<Matrix>(mp.WorkersList.ToArray()[i], 0); } for (int i = 0; i < mp.WorkersList.Count; i++) { // Console.WriteLine("Waiting for " + mp.WorkersList.ToArray()[i]); receiveRequestFromWorkers[i].Wait(); } for (int i = 0; i < mp.WorkersList.Count; i++) { result.Append((Matrix)receiveRequestFromWorkers[i].GetValue()); } DateTime finishTime = DateTime.Now; TimeSpan resultTime = (finishTime - startTime); Request sendRequest = comm.ImmediateSend(resultTime, 0, 0); sendRequest.Wait(); Console.WriteLine("Group " + comm.Rank + " has done in " + resultTime); } else { //Console.WriteLine("Worker " + comm.Rank + "manager" + mp.Chef); mp.MultiplyForRank(mp.workerId); Request sendRequest = comm.ImmediateSend(mp.MultiplyForRank(mp.workerId), mp.Chef, 0); sendRequest.Wait(); } } } }
public ReceiveResult Receive(ReceiveRequest request) { List<Channel> requestedChannels = request.Channels .Select( requestedChannel => new { requestedChannel, foundChannel = Channels.FirstOrDefault(c => c.Name == requestedChannel.Name) }) .Where(@t => @t.foundChannel != null) .Select(@t => new Channel { Name = @t.foundChannel.Name, Version = @t.foundChannel.Version, Members = @t.foundChannel.Members, Messages = @t.foundChannel.Messages.Where(m => m.Version > @t.requestedChannel.Version).ToList() }).ToList(); return new ReceiveResult { Result = new ServiceResult<List<Channel>> { ReturnCode = 0, Data = requestedChannels } }; }
/// <summary> /// We can read a string from the StringSocket by doing /// /// ss.BeginReceive(callback, payload) /// /// where callback is a ReceiveCallback (see below) and payload is an arbitrary object. /// This is non-blocking, asynchronous operation. When the StringSocket has read a /// string of text terminated by a newline character from the underlying Socket, or /// failed in the attempt, it invokes the callback. The parameters to the callback are /// a (possibly null) string, a (possibly null) Exception, and the payload. Either the /// string or the Exception will be non-null, but nor both. If the string is non-null, /// it is the requested string (with the newline removed). If the Exception is non-null, /// it is the Exception that caused the send attempt to fail. /// /// This method is non-blocking. This means that it does not wait until a line of text /// has been received before returning. Instead, it arranges for a line to be received /// and then returns. When the line is actually received (at some time in the future), the /// callback is called on another thread. /// /// This method is thread safe. This means that multiple threads can call BeginReceive /// on a shared socket without worrying around synchronization. The implementation of /// BeginReceive must take care of synchronization instead. On a given StringSocket, each /// arriving line of text must be passed to callbacks in the order in which the corresponding /// BeginReceive call arrived. /// /// Note that it is possible for there to be incoming bytes arriving at the underlying Socket /// even when there are no pending callbacks. StringSocket implementations should refrain /// from buffering an unbounded number of incoming bytes beyond what is required to service /// the pending callbacks. /// /// <param name="callback"> The function to call upon receiving the data</param> /// <param name="payload"> /// The payload is "remembered" so that when the callback is invoked, it can be associated /// with a specific Begin Receiver.... /// </param> /// /// <example> /// Here is how you might use this code: /// <code> /// client = new TcpClient("localhost", port); /// Socket clientSocket = client.Client; /// StringSocket receiveSocket = new StringSocket(clientSocket, new UTF8Encoding()); /// receiveSocket.BeginReceive(CompletedReceive1, 1); /// /// </code> /// </example> /// </summary> public void BeginReceive(ReceiveCallback callback, object payload) { // Store the receive request, with its specified callback and payload. ReceiveRequest receiveRequest = new ReceiveRequest(callback, payload); ReceiveQueue.Enqueue(receiveRequest); // Ask the socket to call MessageReceive as soon as up to 1024 bytes arrive. byte[] buffer = new byte[1024];//this should work when this is set to a small number socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, MessageReceived, buffer); }
static void Main(string[] args) { //using (new MPI.Environment(ref args)) //{ // Intracommunicator comm = Communicator.world; // if (comm.Rank == 0) // { // MatrixMultiply mp = new MatrixMultiply(comm.Size, 2); // mp.Show(); // Request sendRequest = comm.ImmediateSend(mp, 1, 0); // Console.WriteLine("Sending MatrixMyltiply"); // Matrix res = mp.MultiplyForRank(comm.Rank); // sendRequest.Wait(); // ReceiveRequest recieveRequest = comm.ImmediateReceive<MatrixMultiply>(Communicator.anySource, 0); // recieveRequest.Wait(); // Console.WriteLine("Recieve MatrixMultiply"); // sendRequest = comm.ImmediateSend(res, 1, 1); // Console.WriteLine("Sending Matrix result"); // sendRequest.Wait(); // recieveRequest = comm.ImmediateReceive<Matrix>(Communicator.anySource, 1); // recieveRequest.Wait(); // res = (Matrix)recieveRequest.GetValue(); // Console.WriteLine("Recieve Matrix result"); // res.Show(); // } // else // { // ReceiveRequest receiveRequest = comm.ImmediateReceive<MatrixMultiply>(comm.Rank - 1, 0); // receiveRequest.Wait(); // MatrixMultiply mp = (MatrixMultiply)receiveRequest.GetValue(); // Request sendRequest = comm.ImmediateSend(mp, (comm.Rank + 1) % comm.Size, 0); // Matrix res = mp.MultiplyForRank(comm.Rank); // sendRequest.Wait(); // receiveRequest = comm.ImmediateReceive<Matrix>(comm.Rank - 1, 1); // receiveRequest.Wait(); // receiveRequest.GetValue(); // sendRequest = comm.ImmediateSend<Matrix>(((Matrix)receiveRequest.GetValue()).Append(res), (comm.Rank + 1) % comm.Size, 1); // sendRequest.Wait(); // } //} using (new MPI.Environment(ref args)) { const int matrixSize = 50; Intracommunicator comm = Communicator.world; if (comm.Rank == 0) { DateTime startTime = DateTime.Now; MatrixMultiply testMultiply = new MatrixMultiply(comm.Size, matrixSize); Matrix result = testMultiply.MultiplyForRank(0); for (int i = 1; i < comm.Size; i++) { result.Append(testMultiply.MultiplyForRank(i)); } DateTime endTime = DateTime.Now; Console.WriteLine("Test multiply" + (startTime - endTime).ToString()); startTime = DateTime.Now; MatrixMultiply mp = new MatrixMultiply(comm.Size, matrixSize); // mp.Show(); Request[] sendRequest = new Request[comm.Size]; for (int i = 1; i < comm.Size; i++) { sendRequest[i] = comm.ImmediateSend(mp, i, 0); } Console.WriteLine("Sending partly MatrixMyltiply"); Matrix res = mp.MultiplyForRank(comm.Rank); for (int i = 1; i < comm.Size; i++) { sendRequest[i].Wait(); } ReceiveRequest[] recieveRequest = new ReceiveRequest[comm.Size]; for (int i = 1; i < comm.Size; i++) { recieveRequest[i] = comm.ImmediateReceive<Matrix>(i, 1); } Console.WriteLine("Recieve partly MatrixMultiply"); for (int i = 1; i < comm.Size; i++) { recieveRequest[i].Wait(); } for (int i = 1; i < comm.Size; i++) { res.Append((Matrix)recieveRequest[i].GetValue()); } //Console.WriteLine("Result is"); // res.Show(); endTime = DateTime.Now; Console.WriteLine("Parallel multiply" + (startTime - endTime).ToString()); } else { ReceiveRequest receiveRequest = comm.ImmediateReceive<MatrixMultiply>(0, 0); receiveRequest.Wait(); MatrixMultiply mp = (MatrixMultiply)receiveRequest.GetValue(); Request sendRequest = comm.ImmediateSend(mp.MultiplyForRank(comm.Rank), 0, 1); sendRequest.Wait(); } } }
/// <summary> /// We can read a string from the StringSocket by doing /// /// ss.BeginReceive(callback, payload) /// /// where callback is a ReceiveCallback (see below) and payload is an arbitrary object. /// This is non-blocking, asynchronous operation. When the StringSocket has read a /// string of text terminated by a newline character from the underlying Socket, or /// failed in the attempt, it invokes the callback. The parameters to the callback are /// a (possibly null) string, a (possibly null) Exception, and the payload. Either the /// string or the Exception will be non-null, but nor both. If the string is non-null, /// it is the requested string (with the newline removed). If the Exception is non-null, /// it is the Exception that caused the send attempt to fail. /// /// This method is non-blocking. This means that it does not wait until a line of text /// has been received before returning. Instead, it arranges for a line to be received /// and then returns. When the line is actually received (at some time in the future), the /// callback is called on another thread. /// /// This method is thread safe. This means that multiple threads can call BeginReceive /// on a shared socket without worrying around synchronization. The implementation of /// BeginReceive must take care of synchronization instead. On a given StringSocket, each /// arriving line of text must be passed to callbacks in the order in which the corresponding /// BeginReceive call arrived. /// /// Note that it is possible for there to be incoming bytes arriving at the underlying Socket /// even when there are no pending callbacks. StringSocket implementations should refrain /// from buffering an unbounded number of incoming bytes beyond what is required to service /// the pending callbacks. /// /// <param name="callback"> The function to call upon receiving the data</param> /// <param name="payload"> /// The payload is "remembered" so that when the callback is invoked, it can be associated /// with a specific Begin Receiver.... /// </param> /// /// <example> /// Here is how you might use this code: /// <code> /// client = new TcpClient("localhost", port); /// Socket clientSocket = client.Client; /// StringSocket receiveSocket = new StringSocket(clientSocket, new UTF8Encoding()); /// receiveSocket.BeginReceive(CompletedReceive1, 1); /// /// </code> /// </example> /// </summary> public void BeginReceive(ReceiveCallback callback, object payload) { // Protect the ReceiveQueue lock (ReceiveQueue) { // Create and store the receive request. ReceiveRequest receiveRequest = new ReceiveRequest(callback, payload); ReceiveQueue.Enqueue(receiveRequest); // If there is no receive ongoing, start receiving. if (ReceiveQueue.Count == 1) { ProcessReceivedMessage(); } } }