public MqttWebSocketServerChannel(WebSocket webSocket)
{
_webSocket = webSocket ?? throw new ArgumentNullException(nameof(webSocket));
SendStream = new WebSocketStream(_webSocket);
ReceiveStream = SendStream;
}
public async Task BasicClientServerTest()
{
WebSocketListener server = new WebSocketListener(PORT);
byte[] message = new byte[] { 100, 101, 102, 103 };
server.Start();
Task task = Task.Run(async() => {
Stream socket = await server.AcceptWebSocketAsync();
byte[] buffer = new byte[1024];
int read = await socket.ReadAsync(buffer, 0, buffer.Length);
Assert.Equal(4, read);
Assert.Equal(message, buffer.Take(4).ToArray());
});
Stream client = WebSocketStream.Connect($"ws://localhost:{PORT}");
await client.WriteAsync(message, 0, message.Length);
client.Dispose();
server.Dispose();
await task;
}
public async Task <Connection> EstablishConnectionAsync()
{
SocketWrapper closableWrapper = null;
try
{
Stream stream = null;
#if TARGET_BROWSER
closableWrapper = new SocketWrapper(_listenSocket);
stream = new WebSocketStream(_listenSocket, ownsSocket: true);
#else
var socket = await _listenSocket.AcceptAsync().ConfigureAwait(false);
closableWrapper = new SocketWrapper(socket);
try
{
socket.NoDelay = true;
}
// OSX can throw if socket is in weird state during close or cancellation
catch (SocketException ex) when(ex.SocketErrorCode == SocketError.InvalidArgument && PlatformDetection.IsOSXLike)
{
}
stream = new NetworkStream(socket, ownsSocket: false);
#endif
return(await Connection.CreateAsync(closableWrapper, stream, _options).ConfigureAwait(false));
}
catch (Exception)
{
closableWrapper?.Close();
throw;
}
}
async Task ExecuteRequest(HttpListenerContext listenerContext)
{
// By default we will close the stream to cater for failure scenarios
var keepConnection = false;
var clientName = listenerContext.Request.RemoteEndPoint;
WebSocketStream webSocketStream = null;
try
{
var webSocketContext = await listenerContext.AcceptWebSocketAsync("Octopus");
webSocketStream = new WebSocketStream(webSocketContext.WebSocket);
var req = await webSocketStream.ReadTextMessage(); // Initial message
if (string.IsNullOrEmpty(req))
{
log.Write(EventType.Diagnostic, "Ignoring empty request");
return;
}
if (req.Substring(0, 2) != "MX")
{
log.Write(EventType.Diagnostic, "Appears to be a web browser, sending friendly HTML response");
return;
}
if (await Authorize(listenerContext, clientName))
{
// Delegate the open stream to the protocol handler - we no longer own the stream lifetime
await ExchangeMessages(webSocketStream);
// Mark the stream as delegated once everything has succeeded
keepConnection = true;
}
}
catch (TaskCanceledException)
{
if (!cts.Token.IsCancellationRequested)
{
log.Write(EventType.Error, "A timeout occurred while receiving data");
}
}
catch (Exception ex)
{
log.WriteException(EventType.Error, "Unhandled error when handling request from client: {0}", ex, clientName);
}
finally
{
if (!keepConnection)
{
// Closing an already closed stream or client is safe, better not to leak
webSocketStream?.Dispose();
listenerContext.Response.Close();
}
}
}
public async Task <IActionResult> ConnectAsync([FromQuery] string deviceId, [FromQuery] string?requestData)
{
// TODO: Track the events in AppInsights
var cancellationToken = HttpContext.RequestAborted;
using var requesterSocket = await HttpContext.WebSockets.AcceptWebSocketAsync().ConfigureAwait(false);
string?bridgeToken = null;
try
{
await using var requesterStream = new WebSocketStream(requesterSocket);
bridgeToken = await _streamBridge.RequestBridgeAsync(requesterStream, cancellationToken).ConfigureAwait(false);
_logger.LogDebug("Bridge to device '{DeviceId}' has bridge-token '{BridgeToken}'", deviceId, bridgeToken);
// Send the bridge request to the device
var acceptUrl = $"{_options.ExternalHostname}/bridge/accept?bridgeToken={_urlEncoder.Encode(bridgeToken)}";
var accepted = await _requestBridgeNotifier.RequestBridgeAsync(deviceId, acceptUrl, requestData, cancellationToken).ConfigureAwait(false);
if (!accepted)
{
_logger.LogWarning("Bridge to device '{DeviceId}' with bridge-token '{BridgeToken}' was not accepted.", deviceId, bridgeToken);
return(Conflict());
}
_logger.LogDebug("Bridge to device '{DeviceId}' with bridge-token '{BridgeToken}' is accepted by the device (waiting for bridge to establish).", deviceId, bridgeToken);
// Wait until the device has connected to the bridge too
await using var deviceStream = await _streamBridge.WaitForDeviceStreamAsync(bridgeToken, cancellationToken).ConfigureAwait(false);
_logger.LogDebug("Bridge to device '{DeviceId}' with bridge-token '{BridgeToken}' has been established.", deviceId, bridgeToken);
// Copy all data from the requester to the device (the other side of the bridge copies data the other way)
await requesterStream.CopyToAsync(deviceStream, BufferSize, cancellationToken).ConfigureAwait(false);
// Close our socket
await requesterSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "ok", cancellationToken).ConfigureAwait(false);
_logger.LogDebug("Bridge to device '{DeviceId}' with bridge-token '{BridgeToken}' is closed.", deviceId, bridgeToken);
return(Ok());
}
catch (Exception exc)
{
_logger.LogError(exc, "Bridge to device '{DeviceId}' with bridge-token '{BridgeToken}' encountered an exception and will be terminated.", deviceId, bridgeToken);
if (requesterSocket != null)
{
await requesterSocket.CloseAsync(WebSocketCloseStatus.InternalServerError, "exception", cancellationToken).ConfigureAwait(false);
}
throw;
}
finally
{
await _streamBridge.CancelAsync(bridgeToken).ConfigureAwait(false);
}
}
internal TcpListenerWebSocketContext(
TcpClient client, string protocol, bool secure, X509Certificate cert, Logger logger)
{
_client = client;
_secure = secure;
_stream = WebSocketStream.CreateServerStream (client, secure, cert);
_request = _stream.ReadHandshake<HandshakeRequest> (HandshakeRequest.Parse, 90000);
_uri = createRequestUrl (_request, secure);
_websocket = new WebSocket (this, protocol, logger);
}
private static void summarise(WebSocketStream wss,
int ss, int sr, TimeSpan ts)
{
Console.WriteLine(" "
+ "Duration: {0:h\\:mm\\:ss\\.fff}",
ts);
Console.WriteLine(" Sent frames: {0}",
wss.SentFrames - ss);
Console.WriteLine(" Received frames: {0}",
wss.ReceivedFrames - sr);
}
internal TcpListenerWebSocketContext(
TcpClient client, string protocol, bool secure, X509Certificate cert, Logger logger)
{
_client = client;
_secure = secure;
_stream = WebSocketStream.CreateServerStream(client, secure, cert);
_request = _stream.ReadHandshake <HandshakeRequest> (HandshakeRequest.Parse, 90000);
_uri = HttpUtility.CreateRequestUrl(
_request.RequestUri, _request.Headers ["Host"], _request.IsWebSocketRequest, secure);
_websocket = new WebSocket(this, protocol, logger);
}
/// <summary>
/// Method that contains the business logic to insert a single event to Mongo using the MongoDB.Driver
/// </summary>
/// <param name="webSocketEvent">The WebSocketEvent we need to insert to mongo</param>
/// <returns></returns>
public async Task InsertEventAsync(WebSocketStream webSocketEvent)
{
logger.LogDebug($"InsertEventAsync({webSocketEvent}) using MongoService");
try
{
await GetEventsCollection().InsertOneAsync(webSocketEvent);
}
catch (Exception ex)
{
logger.LogError(ex, $"InsertEventAsync({webSocketEvent}) using MongoService caused error");
}
}
internal const int FragmentLength = 1016; // Max value is int.MaxValue - 14.
#endregion
#region Internal Constructors
// As server
internal WebSocket (HttpListenerWebSocketContext context, string protocol, Logger logger)
{
_context = context;
_protocol = protocol;
_logger = logger;
_closeContext = context.Close;
_secure = context.IsSecureConnection;
_stream = context.Stream;
init ();
}
private void disposeStream()
{
if (_stream == null)
{
return;
}
_inputStream = null;
_outputStream = null;
_websocketStream = null;
_stream.Dispose();
_stream = null;
}
public virtual Stream Connect(Uri uri, bool requireAuthentication)
{
// IIS starts python.exe processes lazily on the first incoming request, and will terminate them after a period
// of inactivity, making it impossible to attach. So before trying to connect to the debugger, "ping" the website
// via HTTP to ensure that we have something to connect to.
try
{
var httpRequest = WebRequest.Create(new UriBuilder(uri)
{
Scheme = "http", Port = -1, Path = "/"
}.Uri);
httpRequest.Method = WebRequestMethods.Http.Head;
httpRequest.Timeout = 5000;
httpRequest.GetResponse().Dispose();
}
catch (WebException)
{
// If it fails or times out, just go ahead and try to connect anyway, and rely on normal error reporting path.
}
var webSocket = new ClientWebSocket();
try
{
webSocket.ConnectAsync(uri, CancellationToken.None).GetAwaiter().GetResult();
WebSocketStream stream = new WebSocketStream(webSocket, ownsSocket: true);
webSocket = null;
return(stream);
}
catch (WebSocketException ex)
{
throw new ConnectionException(ConnErrorMessages.RemoteNetworkError, ex);
}
catch (IOException ex)
{
throw new ConnectionException(ConnErrorMessages.RemoteNetworkError, ex);
}
catch (PlatformNotSupportedException ex)
{
throw new ConnectionException(ConnErrorMessages.RemoteUnsupportedTransport, ex);
}
finally
{
if (webSocket != null)
{
webSocket.Dispose();
}
}
}
public static async Task Run(Control control, Bitmap bitmap)
{
using (var webSocket = new ClientWebSocket())
{
var stream = new WebSocketStream(webSocket);
await webSocket.ConnectAsync(new Uri("ws://localhost:5050/ws"), CancellationToken.None);
await DispatchStartAsync(control, bitmap, stream);
while (true)
{
await DispatchDeltaAsync(control, bitmap, stream);
}
}
}
static async Task test_ssl__()
{
string hostname = "echo.websocket.org";
int port = 443;
using (TcpClient tc = new TcpClient())
{
WriteLine("connecting.");
await tc.ConnectAsync(hostname, port);
WriteLine("connected.");
using (NetworkStream st = tc.GetStream())
{
using (SslStream ssl = new SslStream(st, false, check_cert))
{
WriteLine("start ssl");
await ssl.AuthenticateAsClientAsync(hostname);
WriteLine("end ssl");
using (WebSocketStream s = new WebSocketStream(ssl))
{
await s.OpenAsync("wss://echo.websocket.org");
WriteLine("opened.");
while (true)
{
string hello = "Hello World";
byte[] hello_bytes = hello.AsciiToByteArray();
await s.WriteAsync(hello_bytes.AsMemory());
WriteLine("Sent.");
byte[] recv_buffer = new byte[128];
int recv_ret = await s.ReadAsync(recv_buffer, 0, recv_buffer.Length);
WriteLine($"Recv: \"{recv_buffer.AsSpan(0, recv_ret).ToArray().ByteArrayToAscii()}\"");
}
Thread.Sleep(-1);
}
}
}
}
}
public WebSocketStream GetWebSocketStream()
{
if (_websocketStream != null || _socket == null)
{
return(_websocketStream);
}
lock (_sync) {
if (_socket == null)
{
return(_websocketStream);
}
_websocketStream = new WebSocketStream(_stream, _secure);
return(_websocketStream);
}
}
SecureConnection EstablishNewConnection()
{
log.Write(EventType.OpeningNewConnection, "Opening a new connection");
var client = CreateConnectedClient(serviceEndpoint);
log.Write(EventType.Diagnostic, "Connection established");
var stream = new WebSocketStream(client);
log.Write(EventType.Security, "Performing handshake");
stream.WriteTextMessage("MX");
log.Write(EventType.Security, "Secure connection established. Server at {0} identified by thumbprint: {1}", serviceEndpoint.BaseUri, serviceEndpoint.RemoteThumbprint);
var protocol = new MessageExchangeProtocol(stream, log);
return(new SecureConnection(client, stream, protocol));
}
public async Task ClientServerTest()
{
WebSocketListener server = new WebSocketListener(PORT);
byte[] clientMessage = new byte[] { 100, 101, 102, 103 };
byte[] serverMessage = new byte[] { 80, 81, 82, 83 };
byte[] clientBuffer = new byte[1024];
server.Start();
Task task = Task.Run(async() => {
WebSocketStream socket = await server.AcceptWebSocketAsync();
byte[] serverBuffer = new byte[1024];
int serverRead = await socket.ReadAsync(serverBuffer, 0, serverBuffer.Length);
Assert.Equal(4, serverRead);
Assert.Equal(clientMessage, serverBuffer.Take(4).ToArray());
await socket.WriteAsync(serverMessage, 0, serverMessage.Length);
serverRead = await socket.ReadAsync(serverBuffer, 0, serverBuffer.Length);
Assert.Equal(0, serverRead);
});
WebSocketStream client = WebSocketStream.Connect($"ws://localhost:{PORT}");
await client.WriteAsync(clientMessage, 0, clientMessage.Length);
int clientRead = await client.ReadAsync(clientBuffer, 0, clientBuffer.Length);
Assert.Equal(4, clientRead);
Assert.Equal(serverMessage, clientBuffer.Take(4).ToArray());
await client.CloseAsync();
client.Dispose();
server.Dispose();
await task;
}
public WebSocketNetworkClient(Uri uri)
{
// iisnode starts node.exe processes lazily on the first incoming request, and will terminate them after a period
// of inactivity, making it impossible to attach. So before trying to connect to the debugger, "ping" the website
// via HTTP to ensure that we have something to connect to.
try {
var httpRequest = WebRequest.Create(new UriBuilder(uri)
{
Scheme = "http", Port = -1, Path = "/"
}.Uri);
httpRequest.Method = WebRequestMethods.Http.Head;
httpRequest.Timeout = 5000;
httpRequest.GetResponse().Dispose();
} catch (WebException) {
// If it fails or times out, just go ahead and try to connect anyway, and rely on normal error reporting path.
}
_webSocket = new ClientWebSocket();
_webSocket.ConnectAsync(uri, CancellationToken.None).GetAwaiter().GetResult();
_stream = new WebSocketStream(_webSocket);
}
bool HandleOpcode(byte opcode)
{
switch (opcode)
{
case (byte)OpCode.Handshake:
return(true);
case 0xFE: // SMP ping packet id
// 1.4 - 1.6
string name = Chat.ReplacePercentColorCodes(ConfigKey.ServerName.GetString(), false).Replace('&', '§');
string data = "§1\078\00.30c\0§E" + name + '\0' + Server.CountPlayers(false) + '\0' + ConfigKey.MaxPlayers.GetInt();
SendOldSMPKick(data);
return(false);
case 0x02:
case 0xFA:
SendOldSMPKick("§EPlease join us at §9http://classicube.net/");
Logger.Log(LogType.Warning, "Player.LoginSequence: A player tried connecting with Minecraft Beta client from {0}.", IP);
// ignore SMP pings
return(false);
case (byte)'G': // WoM GET requests
stream = new WebSocketStream(stream);
reader = new PacketReader(stream);
writer = new PacketWriter(stream);
return(reader.ReadByte() == (byte)OpCode.Handshake);
default:
if (CheckModernSMP(opcode))
{
return(false);
}
Logger.Log(LogType.Error, "Player.LoginSequence: Unexpected op code in the first packet from {0}: {1}.", IP, opcode);
KickNow("Incompatible client, or a network error.", LeaveReason.ProtocolViolation);
return(false);
}
}
public async Task AcceptAsync([FromQuery] string bridgeToken)
{
var cancellationToken = HttpContext.RequestAborted;
var deviceSocket = await HttpContext.WebSockets.AcceptWebSocketAsync().ConfigureAwait(false);
try
{
await using var deviceStream = new WebSocketStream(deviceSocket);
_logger.LogDebug("Bridge token '{BridgeToken}' received from device.", bridgeToken);
await using var requesterStream = await _streamBridge.AcceptAsync(bridgeToken, deviceStream, cancellationToken).ConfigureAwait(false);
_logger.LogDebug("Bridge token has been accepted by the device.", bridgeToken);
// Copy all data from the device to the requester (the other side of the bridge copies data the other way)
await deviceStream.CopyToAsync(requesterStream, BufferSize, cancellationToken).ConfigureAwait(false);
await deviceSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "ok", cancellationToken).ConfigureAwait(false);
_logger.LogDebug("Bridge with bridge-token '{BridgeToken}' is closed.", bridgeToken);
}
catch (Exception exc)
{
_logger.LogError(exc, "Bridge with bridge-token '{BridgeToken}' encountered an exception and will be terminated.", bridgeToken);
if (deviceSocket != null)
{
await deviceSocket.CloseAsync(WebSocketCloseStatus.InternalServerError, "exception", cancellationToken).ConfigureAwait(false);
}
throw;
}
finally
{
await _streamBridge.CancelAsync(bridgeToken).ConfigureAwait(false);
}
}
protected override async Task OnSendCoreAsync(Message message, CancellationToken token)
{
Fx.Assert(message != null, "message should not be null.");
WebSocketMessageType outgoingMessageType = GetWebSocketMessageType(message);
if (IsStreamedOutput)
{
WebSocketStream webSocketStream = new WebSocketStream(WebSocket, outgoingMessageType, token);
TimeoutStream timeoutStream = new TimeoutStream(webSocketStream, token);
await MessageEncoder.WriteMessageAsync(message, timeoutStream);
await webSocketStream.WriteEndOfMessageAsync(token);
}
else
{
ArraySegment <byte> messageData = EncodeMessage(message);
bool success = false;
try
{
//if (TD.WebSocketAsyncWriteStartIsEnabled())
//{
// TD.WebSocketAsyncWriteStart(
// this.WebSocket.GetHashCode(),
// messageData.Count,
// this.RemoteAddress != null ? this.RemoteAddress.ToString() : string.Empty);
//}
try
{
await WebSocket.SendAsync(messageData, outgoingMessageType, true, token);
}
catch (Exception ex)
{
if (Fx.IsFatal(ex))
{
throw;
}
WebSocketHelper.ThrowCorrectException(ex, TimeoutHelper.GetOriginalTimeout(token), WebSocketHelper.SendOperation);
}
//if (TD.WebSocketAsyncWriteStopIsEnabled())
//{
// TD.WebSocketAsyncWriteStop(this.webSocket.GetHashCode());
//}
success = true;
}
finally
{
try
{
BufferManager.ReturnBuffer(messageData.Array);
}
catch (Exception ex)
{
if (Fx.IsFatal(ex) || success)
{
throw;
}
Fx.Exception.TraceUnhandledException(ex);
}
}
}
}
public WebSocketStream GetWebSocketStream ()
{
if (_websocketStream != null || _socket == null)
return _websocketStream;
lock (_sync) {
if (_socket == null)
return _websocketStream;
_websocketStream = new WebSocketStream (_stream, _secure);
return _websocketStream;
}
}
private void disposeStream ()
{
if (_stream == null)
return;
_inputStream = null;
_outputStream = null;
_websocketStream = null;
_stream.Dispose ();
_stream = null;
}
Task ExchangeMessages(WebSocketStream stream)
{
log.Write(EventType.Diagnostic, "Begin message exchange");
return(protocolHandler(new MessageExchangeProtocol(stream, log)));
}
protected override void OnSendCore(Message message, TimeSpan timeout)
{
Fx.Assert(message != null, "message should not be null.");
TimeoutHelper helper = new TimeoutHelper(timeout);
WebSocketMessageType outgoingMessageType = GetWebSocketMessageType(message);
if (IsStreamedOutput)
{
WebSocketStream webSocketStream = new WebSocketStream(WebSocket, outgoingMessageType, ((IDefaultCommunicationTimeouts)this).CloseTimeout);
TimeoutStream timeoutStream = new TimeoutStream(webSocketStream, timeout);
MessageEncoder.WriteMessage(message, timeoutStream);
webSocketStream.WriteEndOfMessage();
}
else
{
ArraySegment<byte> messageData = EncodeMessage(message);
bool success = false;
try
{
if (TD.WebSocketAsyncWriteStartIsEnabled())
{
TD.WebSocketAsyncWriteStart(
WebSocket.GetHashCode(),
messageData.Count,
RemoteAddress != null ? RemoteAddress.ToString() : string.Empty);
}
Task task = WebSocket.SendAsync(messageData, outgoingMessageType, true, helper.GetCancellationToken());
task.Wait(helper.RemainingTime(), WebSocketHelper.ThrowCorrectException, WebSocketHelper.SendOperation);
if (TD.WebSocketAsyncWriteStopIsEnabled())
{
TD.WebSocketAsyncWriteStop(_webSocket.GetHashCode());
}
success = true;
}
finally
{
try
{
BufferManager.ReturnBuffer(messageData.Array);
}
catch (Exception ex)
{
if (Fx.IsFatal(ex) || success)
{
throw;
}
FxTrace.Exception.TraceUnhandledException(ex);
}
}
}
}
protected override AsyncCompletionResult StartWritingStreamedMessage(Message message, TimeSpan timeout, Action<object> callback, object state)
{
WebSocketMessageType outgoingMessageType = GetWebSocketMessageType(message);
WebSocketStream webSocketStream = new WebSocketStream(WebSocket, outgoingMessageType, ((IDefaultCommunicationTimeouts)this).CloseTimeout);
_waitCallback = callback;
_state = state;
_webSocketStream = webSocketStream;
IAsyncResult result = MessageEncoder.BeginWriteMessage(message, new TimeoutStream(webSocketStream, timeout), s_streamedWriteCallback, this);
if (!result.CompletedSynchronously)
{
return AsyncCompletionResult.Queued;
}
MessageEncoder.EndWriteMessage(result);
webSocketStream.WriteEndOfMessageAsync(callback, state);
return AsyncCompletionResult.Queued;
}
/// <param name="_wss">WebSocketStream to send output over</param>
public WSOutputSink(WebSocketStream _wss)
{
wss = _wss;
}
private async Task ProcessChanges()
{
using (_requestExecutor.ContextPool.AllocateOperationContext(out var context))
{
while (_cts.IsCancellationRequested == false)
{
var state = new JsonParserState();
using (var stream = new WebSocketStream(_client, _cts.Token))
using (context.GetManagedBuffer(out var buffer))
using (var parser = new UnmanagedJsonParser(context, state, "changes/receive"))
using (var builder = new BlittableJsonDocumentBuilder(context, BlittableJsonDocumentBuilder.UsageMode.None, "readArray/singleResult", parser, state))
using (var peepingTomStream = new PeepingTomStream(stream, context))
{
if (await UnmanagedJsonParserHelper.ReadAsync(peepingTomStream, parser, state, buffer).ConfigureAwait(false) == false)
{
continue;
}
if (state.CurrentTokenType != JsonParserToken.StartArray)
{
continue;
}
while (true)
{
if (await UnmanagedJsonParserHelper.ReadAsync(peepingTomStream, parser, state, buffer).ConfigureAwait(false) == false)
{
continue;
}
if (state.CurrentTokenType == JsonParserToken.EndArray)
{
break;
}
builder.Renew("changes/receive", BlittableJsonDocumentBuilder.UsageMode.None);
await UnmanagedJsonParserHelper.ReadObjectAsync(builder, peepingTomStream, parser, buffer).ConfigureAwait(false);
var json = builder.CreateReader();
try
{
if (json.TryGet("Type", out string type) == false)
{
continue;
}
switch (type)
{
case "Error":
json.TryGet("Exception", out string exceptionAsString);
NotifyAboutError(new Exception(exceptionAsString));
break;
case "Confirm":
if (json.TryGet("CommandId", out int commandId) &&
_confirmations.TryRemove(commandId, out var tcs))
{
tcs.TrySetResult(null);
}
break;
default:
json.TryGet("Value", out BlittableJsonReaderObject value);
NotifySubscribers(type, value, _counters.ValuesSnapshot);
break;
}
}
catch (Exception e)
{
NotifyAboutError(e);
throw new ChangeProcessingException(e);
}
}
}
}
}
}
public WebSocketStreamTest()
{
_uri = new Uri(BinanceWebSocketStream.BaseUri);
_subject = _uri.AbsoluteUri;
_stream = new WebSocketStream(DefaultWebSocketClientTest.CreateWebSocketClient(_message));
}
// As server
private void closeServerResources()
{
if (_closeContext == null)
return;
_closeContext ();
_closeContext = null;
_stream = null;
_context = null;
}
// As client
private void setClientStream()
{
var host = _uri.DnsSafeHost;
var port = _uri.Port;
_tcpClient = new TcpClient (host, port);
_stream = WebSocketStream.CreateClientStream (
_tcpClient, _secure, host, _certValidationCallback);
}
private async Task ProcessChanges()
{
using (_requestExecutor.ContextPool.AllocateOperationContext(out var context))
{
while (_cts.IsCancellationRequested == false)
{
context.Reset();
context.Renew();
var state = new JsonParserState();
using (var stream = new WebSocketStream(_client, _cts.Token))
using (context.GetMemoryBuffer(out JsonOperationContext.MemoryBuffer buffer))
using (var parser = new UnmanagedJsonParser(context, state, "changes/receive"))
using (var builder = new BlittableJsonDocumentBuilder(context, BlittableJsonDocumentBuilder.UsageMode.None, "readArray/singleResult", parser, state))
using (var peepingTomStream = new PeepingTomStream(stream, context))
{
if (await UnmanagedJsonParserHelper.ReadAsync(peepingTomStream, parser, state, buffer).ConfigureAwait(false) == false)
{
continue;
}
if (state.CurrentTokenType != JsonParserToken.StartArray)
{
continue;
}
while (true)
{
builder.Reset();
builder.Renew("changes/receive", BlittableJsonDocumentBuilder.UsageMode.None);
if (await UnmanagedJsonParserHelper.ReadAsync(peepingTomStream, parser, state, buffer).ConfigureAwait(false) == false)
{
continue;
}
if (state.CurrentTokenType == JsonParserToken.EndArray)
{
break;
}
await UnmanagedJsonParserHelper.ReadObjectAsync(builder, peepingTomStream, parser, buffer).ConfigureAwait(false);
using (var json = builder.CreateReader())
{
try
{
if (json.TryGet(nameof(TopologyChange), out bool supports) && supports)
{
GetOrAddConnectionState("Topology", "watch-topology-change", "", "");
await _requestExecutor.UpdateTopologyAsync(new RequestExecutor.UpdateTopologyParameters(_serverNode)
{
TimeoutInMs = 0, ForceUpdate = true, DebugTag = "watch-topology-change"
}).ConfigureAwait(false);
continue;
}
if (json.TryGet("Type", out string type) == false)
{
continue;
}
switch (type)
{
case "Error":
json.TryGet("Exception", out string exceptionAsString);
NotifyAboutError(new Exception(exceptionAsString));
break;
case "Confirm":
if (json.TryGet("CommandId", out int commandId) &&
_confirmations.TryRemove(commandId, out var tcs))
{
tcs.TrySetResult(null);
}
break;
default:
json.TryGet("Value", out BlittableJsonReaderObject value);
NotifySubscribers(type, value, _counters.ForceEnumerateInThreadSafeManner().Select(x => x.Value).ToList());
break;
}
}
catch (Exception e)
{
NotifyAboutError(e);
throw new ChangeProcessingException(e);
}
}
}
}
}
}
}
// As client
private void closeClientResources()
{
if (_stream != null) {
_stream.Dispose ();
_stream = null;
}
if (_tcpClient != null) {
_tcpClient.Close ();
_tcpClient = null;
}
}
