/// <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);
}
