/// <summary> /// Sends a <see cref="StreamingRequest"/> to the connected streaming channel. /// </summary> /// <param name="request">The request to send.</param> /// <param name="cancellationToken">A cancellation token.</param> /// <returns>A task that resolves to a <see cref="ReceiveResponse"/>.</returns> public async Task <ReceiveResponse> SendStreamingRequestAsync(StreamingRequest request, CancellationToken cancellationToken = default) { try { if (!_serverIsConnected) { throw new Exception("Error while attempting to send: Streaming transport is disconnected."); } var serverResponse = await _server.SendAsync(request, cancellationToken).ConfigureAwait(false); if (serverResponse.StatusCode == (int)HttpStatusCode.OK) { return(serverResponse.ReadBodyAsJson <ReceiveResponse>()); } } #pragma warning disable CA1031 // Do not catch general exception types (this should probably be addressed later, but for now we just log the error and continue the execution) catch (Exception ex) #pragma warning restore CA1031 // Do not catch general exception types { _logger.LogError(ex.Message); } return(null); }
public async Task SendRequestAsync_WaitsTillAllDataSent() { var payLoadSender = new PayloadSender(); var tcs = new TaskCompletionSource <bool>(); DisconnectedEventHandler eventHandler = (sender, args) => { tcs.TrySetException(new Exception(args.Reason)); }; payLoadSender.Disconnected += eventHandler; payLoadSender.Connect(GetMockedTransportSender(tcs, TransportConstants.MaxPayloadLength * 4)); var sendOperations = new SendOperations(payLoadSender); try { using (var stream = GetMockedStream(TransportConstants.MaxPayloadLength * 4)) { var request = new StreamingRequest(); request.AddStream(new StreamContent(stream)); await sendOperations.SendRequestAsync(Guid.NewGuid(), request); } await tcs.Task; } finally { payLoadSender.Disconnected -= eventHandler; } }
public override async Task <ResourceResponse> UpdateActivityAsync(ITurnContext turnContext, Activity activity, CancellationToken cancellationToken) { var requestPath = $"/activities/{activity.Id}"; var request = StreamingRequest.CreatePut(requestPath); // set callerId to empty so it's not sent over the wire activity.CallerId = null; request.SetBody(activity); var response = default(ResourceResponse); _botTelemetryClient.TrackTrace($"Updating activity. activity id: {activity.Id}", Severity.Information, null); var stopWatch = new Diagnostics.Stopwatch(); try { stopWatch.Start(); response = await SendRequestAsync <ResourceResponse>(request, cancellationToken).ConfigureAwait(false); stopWatch.Stop(); } catch (Exception ex) { throw new SkillWebSocketCallbackException($"Callback failed. Verb: PUT, Path: {requestPath}", ex); } _botTelemetryClient.TrackEvent("SkillWebSocketUpdateActivityLatency", null, new Dictionary <string, double> { { "Latency", stopWatch.ElapsedMilliseconds }, }); return(response); }
public async Task SubscribeOnOrderBook(string currencyPairId, Action <IList <OrderBookItem> > callback) { Connect(); var innerExistingOrderbook = await _connection.Context.MarketOrderbookAsync(currencyPairId, 30); var existingOrderBook = innerExistingOrderbook.ToOuterModel(); callback(existingOrderBook); var subscription = new Subscription { SubscribeRequest = StreamingRequest.SubscribeOrderbook(currencyPairId, 30), UnsubscribeRequest = StreamingRequest.UnsubscribeOrderbook(currencyPairId, 30), EventHandler = (o, e) => { if (!(e.Response is OrderbookResponse orderbookResponse) || orderbookResponse.Payload.Figi != currencyPairId) { return; } var orderBook = orderbookResponse.Payload.ToOuterModel(); callback(orderBook); } }; _connection.StreamingEventReceived += (o, e) => subscription.EventHandler(o, e); await _connection.Context.SendStreamingRequestAsync(subscription.SubscribeRequest); }
public static StreamingRequest GetStreamingRequestWithoutAttachments(string conversationId) { var conId = string.IsNullOrWhiteSpace(conversationId) ? Guid.NewGuid().ToString() : conversationId; var request = new StreamingRequest() { Verb = "POST", Path = $"/v3/directline/conversations/{conId}/activities", }; var activity = new Schema.Activity() { Type = "message", Text = "hello", ServiceUrl = "urn:test:namedpipe:testPipes", From = new Schema.ChannelAccount() { Id = "123", Name = "Fred", }, Conversation = new Schema.ConversationAccount(null, null, conId, null, null, null, null), }; request.SetBody(activity); return(request); }
public static StreamingRequest GetStreamingRequestWithAttachment(string conversationId) { var conId = string.IsNullOrWhiteSpace(conversationId) ? Guid.NewGuid().ToString() : conversationId; var attachmentData = "blah blah i am a stream!"; var streamContent = new MemoryStream(Encoding.UTF8.GetBytes(attachmentData)); var attachmentStream = new AttachmentStream("botframework-stream", streamContent); var request = new StreamingRequest() { Verb = "POST", Path = $"/v3/directline/conversations/{conId}/activities", }; var activity = new Schema.Activity() { Type = "message", Text = "hello", ServiceUrl = "urn:test:namedpipe:testPipes", From = new Schema.ChannelAccount() { Id = "123", Name = "Fred", }, Conversation = new Schema.ConversationAccount(null, null, conId, null, null, null, null), }; request.SetBody(activity); var contentStream = new StreamContent(attachmentStream.ContentStream); contentStream.Headers.TryAddWithoutValidation(HeaderNames.ContentType, attachmentStream.ContentType); request.AddStream(contentStream); return(request); }
public void Request_NullProperties() { var r = new StreamingRequest(); Assert.IsNull(r.Verb); Assert.IsNull(r.Path); }
protected override async Task OnMembersAddedAsync(IList <ChannelAccount> membersAdded, ITurnContext <IConversationUpdateActivity> turnContext, CancellationToken cancellationToken) { foreach (var member in membersAdded) { if (member.Id != turnContext.Activity.Recipient.Id) { if (!_turnContexts.ContainsKey(turnContext.Activity.Conversation.Id)) { _turnContexts.TryAdd(turnContext.Activity.Conversation.Id, turnContext); } var request = new StreamingRequest() { Verb = "POST", Path = "/api/messages" }; turnContext.Activity.ServiceUrl = "urn:BridgeBot:ws://localhost"; request.SetBody(turnContext.Activity); if (_useNamedPipes) { await _namedPipeClient.SendAsync(request).ConfigureAwait(false); } if (_useWebSockets) { await _webSocketClient.SendAsync(request).ConfigureAwait(false); } } } }
public async Task <Conversation> StartConversationAsync(TokenParameters tokenParameters = null, CancellationToken cancellationToken = default(CancellationToken)) { if (SocketClient == null) { throw new InvalidOperationException("Connection is not opened."); } var request = new StreamingRequest() { Verb = "POST", Path = "/v3/directline/conversations" }; if (tokenParameters != null) { request.SetBody(tokenParameters); } var response = await SocketClient.SendAsync(request).ConfigureAwait(false); if (response.StatusCode != 200 && response.StatusCode != 201) { var body = response.ReadBodyAsStringAsync().ConfigureAwait(false); var ex = new OperationException( $"Operation returned an invalid status code '{response.StatusCode}'", response.StatusCode, body); throw ex; } var conversation = await response.ReadBodyAsJsonAsync <Conversation>().ConfigureAwait(false); return(conversation); }
public async Task <ResourceResponse> UpdateActivityAsync(string conversationId, string activityId, Activity activity, CancellationToken cancellationToken = default(CancellationToken)) { if (SocketClient == null) { throw new InvalidOperationException("Connection is not opened."); } var request = new StreamingRequest() { Verb = "PUT", Path = $"/v3/directline/conversations/{conversationId}/activities/{activityId}" }; request.SetBody(activity); var response = await SocketClient.SendAsync(request).ConfigureAwait(false); if (response.StatusCode != 200) { var body = await response.ReadBodyAsStringAsync().ConfigureAwait(false); var ex = new OperationException( $"Operation returned an invalid status code '{response.StatusCode}'", response.StatusCode, body); throw ex; } var resourceResponse = await response.ReadBodyAsJsonAsync <ResourceResponse>().ConfigureAwait(false); return(resourceResponse); }
public void CanSendStreamingRequest() { var socket = new TestWebSocket(); var requestHandler = new TestRequestHandler(); using (var sut = new TestLegacyStreamingConnection(socket, NullLogger.Instance)) { sut.ListenAsync(requestHandler).Wait(); var request = new StreamingRequest { Verb = "POST", Path = "/api/messages", Streams = new List <ResponseMessageStream> { new ResponseMessageStream { Content = new StringContent("foo") } } }; var response = sut.SendStreamingRequestAsync(request).Result; Assert.Equal(request.Streams.Count, response.Streams.Count); Assert.Equal(request.Streams[0].Id, response.Streams[0].Id); } }
public async void WebSocketClient_SendAsync_With_No_Connected_Client() { var client = new WebSocketClient("url"); var message = new StreamingRequest(); await Assert.ThrowsAsync <InvalidOperationException>(() => client.SendAsync(message)); }
public override async Task DeleteActivityAsync(ITurnContext turnContext, ConversationReference reference, CancellationToken cancellationToken) { var requestPath = $"/activities/{reference.ActivityId}"; var request = StreamingRequest.CreateDelete(requestPath); _botTelemetryClient.TrackTrace($"Deleting activity. activity id: {reference.ActivityId}", Severity.Information, null); var stopWatch = new Diagnostics.Stopwatch(); try { stopWatch.Start(); await SendRequestAsync <ResourceResponse>(request, cancellationToken).ConfigureAwait(false); stopWatch.Stop(); } catch (Exception ex) { throw new SkillWebSocketCallbackException($"Callback failed. Verb: DELETE, Path: {requestPath}", ex); } _botTelemetryClient.TrackEvent("SkillWebSocketDeleteActivityLatency", null, new Dictionary <string, double> { { "Latency", stopWatch.ElapsedMilliseconds }, }); }
public async Task Integration_KeepAlive() { // TODO: Transform this test into a theory and do multi-message, multi-thread, multi-client, etc. var logger = XUnitLogger.CreateLogger(_outputHelper); var cts = new CancellationTokenSource(); using (var webSocketFeature = new TestWebSocketConnectionFeature()) { // Bot / server setup var botRequestHandler = new Mock <RequestHandler>(); botRequestHandler .Setup(r => r.ProcessRequestAsync(It.IsAny <ReceiveRequest>(), null, null, CancellationToken.None)) .ReturnsAsync(() => new StreamingResponse() { StatusCode = 200 }); var socket = await webSocketFeature.AcceptAsync().ConfigureAwait(false); var connection = new WebSocketStreamingConnection(socket, logger); var serverTask = connection.ListenAsync(botRequestHandler.Object, cts.Token); // Client / channel setup var clientRequestHandler = new Mock <RequestHandler>(); clientRequestHandler .Setup(r => r.ProcessRequestAsync(It.IsAny <ReceiveRequest>(), null, null, CancellationToken.None)) .ReturnsAsync(() => new StreamingResponse() { StatusCode = 200 }); var client = new WebSocketClient(webSocketFeature.Client, "wss://test", clientRequestHandler.Object, logger: logger, closeTimeOut: TimeSpan.FromSeconds(10), keepAlive: TimeSpan.FromMilliseconds(200)); var clientTask = client.ConnectInternalAsync(CancellationToken.None); // Send request bot (server) -> channel (client) const string path = "api/version"; const string botToClientPayload = "Hello human, I'm Bender!"; var request = StreamingRequest.CreatePost(path, new StringContent(botToClientPayload)); var responseFromClient = await connection.SendStreamingRequestAsync(request).ConfigureAwait(false); Assert.Equal(200, responseFromClient.StatusCode); const string clientToBotPayload = "Hello bot, I'm Calculon!"; var clientRequest = StreamingRequest.CreatePost(path, new StringContent(clientToBotPayload)); // Send request bot channel (client) -> (server) var clientToBotResult = await client.SendAsync(clientRequest).ConfigureAwait(false); Assert.Equal(200, clientToBotResult.StatusCode); await Task.Delay(TimeSpan.FromSeconds(3)).ConfigureAwait(false); Assert.True(client.IsConnected); } }
public async Task <Activity> ForwardToSkillAsync(SkillManifest skillManifest, IServiceClientCredentials serviceClientCredentials, ITurnContext turnContext, Activity activity, Action <Activity> tokenRequestHandler = null, Action <Activity> fallbackHandler = null) { if (_streamingTransportClient == null) { // establish websocket connection _streamingTransportClient = new WebSocketClient( EnsureWebSocketUrl(skillManifest.Endpoint.ToString()), new SkillCallingRequestHandler( turnContext, _botTelemetryClient, GetTokenCallback(turnContext, tokenRequestHandler), GetFallbackCallback(turnContext, fallbackHandler), GetHandoffActivityCallback())); } // acquire AAD token MicrosoftAppCredentials.TrustServiceUrl(skillManifest.Endpoint.AbsoluteUri); var token = await serviceClientCredentials.GetTokenAsync(); // put AAD token in the header var headers = new Dictionary <string, string>(); headers.Add("Authorization", $"Bearer {token}"); await _streamingTransportClient.ConnectAsync(headers); // set recipient to the skill var recipientId = activity.Recipient.Id; activity.Recipient.Id = skillManifest.MSAappId; // Serialize the activity and POST to the Skill endpoint var body = new StringContent(JsonConvert.SerializeObject(activity, SerializationSettings.BotSchemaSerializationSettings), Encoding.UTF8, SerializationSettings.ApplicationJson); var request = StreamingRequest.CreatePost(string.Empty, body); // set back recipient id to make things consistent activity.Recipient.Id = recipientId; var stopWatch = new System.Diagnostics.Stopwatch(); stopWatch.Start(); await _streamingTransportClient.SendAsync(request); stopWatch.Stop(); _botTelemetryClient.TrackEvent( "SkillWebSocketTurnLatency", new Dictionary <string, string> { { "SkillName", skillManifest.Name }, { "SkillEndpoint", skillManifest.Endpoint.ToString() }, }, new Dictionary <string, double> { { "Latency", stopWatch.ElapsedMilliseconds }, }); return(_handoffActivity); }
public void Request_Create_Put_Success() { var r = StreamingRequest.CreatePut(); Assert.Equal(StreamingRequest.PUT, r.Verb); Assert.Null(r.Path); Assert.Empty(r.Streams); }
public async void NamedPipeClient_SendAsync_With_No_Connected_Client() { var pipeName = Guid.NewGuid().ToString().Substring(0, 18); var pipe = new NamedPipeClient(pipeName); var message = new StreamingRequest(); await Assert.ThrowsAsync <InvalidOperationException>(() => pipe.SendAsync(message)); }
public Task <ReceiveResponse> SendAsync(StreamingRequest request, CancellationToken cancellationToken = default(CancellationToken)) { return(Task.FromResult(new ReceiveResponse { StatusCode = 200, Streams = new List <IContentStream>(request.Streams.Select(s => new TestContentStream(s.Id))) })); }
private async void TimerCandleSubscribe(object obj) { var candleSubscribe = (CandleSubscribe)obj; var contextApi = candleSubscribe.contextApi; var figi = candleSubscribe.figi; var candleInterval = candleSubscribe.candleInterval; await contextApi.SendStreamingRequestAsync(StreamingRequest.SubscribeCandle(figi, candleInterval)); }
public void Request_Create_Get_Success() { var r = StreamingRequest.CreateGet(); Assert.AreEqual(StreamingRequest.GET, r.Verb); Assert.IsNull(r.Path); Assert.IsNull(r.Streams); }
public void Request_Create_Delete_Success() { var r = StreamingRequest.CreateDelete(); Assert.AreEqual(StreamingRequest.DELETE, r.Verb); Assert.IsNull(r.Path); Assert.IsNull(r.Streams); }
public async Task Integration_Interop_LegacyClient() { // TODO: Transform this test into a theory and do multi-message, multi-thread, multi-client, etc. var logger = XUnitLogger.CreateLogger(_outputHelper); using (var webSocketFeature = new TestWebSocketConnectionFeature()) { // Bot / server setup var botRequestHandler = new Mock <RequestHandler>(); botRequestHandler .Setup(r => r.ProcessRequestAsync(It.IsAny <ReceiveRequest>(), null, null, CancellationToken.None)) .ReturnsAsync(() => new StreamingResponse() { StatusCode = 200 }); var socket = await webSocketFeature.AcceptAsync().ConfigureAwait(false); var connection = new WebSocketStreamingConnection(socket, logger); var serverTask = Task.Run(() => connection.ListenAsync(botRequestHandler.Object)); // Client / channel setup var clientRequestHandler = new Mock <RequestHandler>(); clientRequestHandler .Setup(r => r.ProcessRequestAsync(It.IsAny <ReceiveRequest>(), null, null, CancellationToken.None)) .ReturnsAsync(() => new StreamingResponse() { StatusCode = 200 }); using (var client = new Microsoft.Bot.Streaming.Transport.WebSockets.WebSocketClient("wss://test", clientRequestHandler.Object)) { await client.ConnectInternalAsync(webSocketFeature.Client).ConfigureAwait(false); // Send request bot (server) -> channel (client) const string path = "api/version"; const string botToClientPayload = "Hello human, I'm Bender!"; var request = StreamingRequest.CreatePost(path, new StringContent(botToClientPayload)); var responseFromClient = await connection.SendStreamingRequestAsync(request).ConfigureAwait(false); Assert.Equal(200, responseFromClient.StatusCode); const string clientToBotPayload = "Hello bot, I'm Calculon!"; var clientRequest = StreamingRequest.CreatePost(path, new StringContent(clientToBotPayload)); // Send request bot channel (client) -> (server) var clientToBotResult = await client.SendAsync(clientRequest).ConfigureAwait(false); Assert.Equal(200, clientToBotResult.StatusCode); client.Disconnect(); } await serverTask.ConfigureAwait(false); } }
public void Request_AddStream_Null_Throws() { var r = new StreamingRequest(); Assert.ThrowsException <ArgumentNullException>(() => { r.AddStream(null); }); }
public async void NamedPipeServer_SendAsync_With_No_Connected_Client() { var pipeName = Guid.NewGuid().ToString().Substring(0, 18); var requestHandler = new StreamingRequestHandler(new MockBot(), new BotFrameworkHttpAdapter(), pipeName); var pipe = new NamedPipeServer(pipeName, requestHandler); var message = new StreamingRequest(); await Assert.ThrowsAsync <InvalidOperationException>(() => pipe.SendAsync(message)); }
/** * Cancel current streaming by aborting connection **/ public void CloseStreaming() { if (mStreamRequest != null) { mStreamRequest.Abort(); //close connection and terminate thread } mStreamRequest = null; mIsStream = false; }
public async void WebSocketServer_SendAsync_With_No_Connected_Client() { var socketMock = new Mock <WebSocket>(); var requestHandlerMock = new Mock <RequestHandler>(); var server = new WebSocketServer(socketMock.Object, requestHandlerMock.Object); var message = new StreamingRequest(); await Assert.ThrowsAsync <InvalidOperationException>(() => server.SendAsync(message)); }
private void RunStreamingCrashTest(Action <WebSocket, TestWebSocketConnectionFeature.WebSocketChannel, WebSocketClient, CancellationTokenSource, CancellationTokenSource> induceCrash) { var logger = XUnitLogger.CreateLogger(_testOutput); var serverCts = new CancellationTokenSource(); var clientCts = new CancellationTokenSource(); using (var connection = new TestWebSocketConnectionFeature()) { var webSocket = connection.AcceptAsync().Result; var clientWebSocket = connection.Client; var bot = new StreamingTestBot((turnContext, cancellationToken) => Task.CompletedTask); var server = new CloudAdapter(new StreamingTestBotFrameworkAuthentication(), logger); var serverRunning = server.ProcessAsync(CreateWebSocketUpgradeRequest(webSocket), new Mock <HttpResponse>().Object, bot, serverCts.Token); var clientRequestHandler = new Mock <RequestHandler>(); clientRequestHandler .Setup(h => h.ProcessRequestAsync(It.IsAny <ReceiveRequest>(), It.IsAny <ILogger <RequestHandler> >(), It.IsAny <object>(), It.IsAny <CancellationToken>())) .Returns(Task.FromResult(StreamingResponse.OK())); using (var client = new WebSocketClient("wss://test", clientRequestHandler.Object, logger: logger)) { var clientRunning = client.ConnectInternalAsync(clientWebSocket, clientCts.Token); var activity = new Activity { Id = Guid.NewGuid().ToString("N"), Type = ActivityTypes.Message, From = new ChannelAccount { Id = "testUser" }, Conversation = new ConversationAccount { Id = Guid.NewGuid().ToString("N") }, Recipient = new ChannelAccount { Id = "testBot" }, ServiceUrl = "wss://InvalidServiceUrl/api/messages", ChannelId = "test", Text = "hi" }; var content = new StringContent(JsonConvert.SerializeObject(activity), Encoding.UTF8, "application/json"); var response = client.SendAsync(StreamingRequest.CreatePost("/api/messages", content)).Result; Assert.Equal(200, response.StatusCode); induceCrash(webSocket, clientWebSocket, client, serverCts, clientCts); clientRunning.Wait(); Assert.True(clientRunning.IsCompletedSuccessfully); } serverRunning.Wait(); Assert.True(serverRunning.IsCompletedSuccessfully); } }
/// <inheritdoc /> public override async Task <ReceiveResponse> SendStreamingRequestAsync(StreamingRequest request, CancellationToken cancellationToken = default) { if (!_serverIsConnected) { throw new InvalidOperationException("Error while attempting to send: Streaming transport is disconnected."); } return(await _server.SendAsync(request, cancellationToken).ConfigureAwait(false)); }
/** * Send the next request to the server * Use GetHTTPResponse() to retrieve the response **/ public void Execute() { if (mWebRequest != null) { mWebRequest.webRequest.Dispose(); } mWebRequest = null; if (mStreamRequest != null) { mStreamRequest.Abort(); } mStreamRequest = null; try { byte[] postData = System.Text.Encoding.UTF8.GetBytes(mData.ToCharArray()); if (mIsStream) // Streaming request { mStreamRequest = new StreamingRequest(mIPAdress + mCommand, mData); Debug.Log("Streaming:" + mIPAdress + mCommand + " : " + mData); } else { DownloadHandlerBuffer dlHandler = new DownloadHandlerBuffer(); if (mType == RequestType.POST) //POST request { UploadHandler upHandler = new UploadHandlerRaw(postData); UnityWebRequest www = new UnityWebRequest(mIPAdress + mCommand, UnityWebRequest.kHttpVerbPOST, dlHandler, upHandler); www.useHttpContinue = false; www.timeout = mTimeout; www.SetRequestHeader("Content-Type", "application/json"); mWebRequest = www.SendWebRequest(); Debug.Log("POST:" + mIPAdress + mCommand + ":" + mData); mData = ""; // Reset data buffer } else //GET request { UnityWebRequest www = new UnityWebRequest(mIPAdress + mCommand); www.downloadHandler = dlHandler; www.useHttpContinue = false; www.timeout = mTimeout * 10; //allowing more time to download files mWebRequest = www.SendWebRequest(); Debug.Log("GET:" + mIPAdress + mCommand); } } } catch (UnityException ex) { Debug.Log(ex.Message); } }
public void Request_AddStream_Success() { var r = new StreamingRequest(); var s = new StringContent("hi"); r.AddStream(s); Assert.IsNotNull(r.Streams); Assert.AreEqual(1, r.Streams.Count); Assert.AreEqual(s, r.Streams[0].Content); }