/// <summary> Connects an asynchronous. </summary>
/// <remarks> 19.09.2020. </remarks>
/// <param name="token"> A token that allows processing to be cancelled. </param>
/// <returns> An asynchronous result. </returns>
public async Task ConnectAsync(CancellationToken token)
{
if (_socket != null && _socket.State == WebSocketState.Open)
{
return;
}
if (_socket == null || _socket.State != WebSocketState.None)
{
_jsonRpc?.Dispose();
_socket?.Dispose();
_socket = new ClientWebSocket();
}
_connectTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(30));
var linkedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(token, _connectTokenSource.Token);
await _socket.ConnectAsync(_uri, linkedTokenSource.Token);
linkedTokenSource.Dispose();
_connectTokenSource.Dispose();
_connectTokenSource = null;
Logger.Debug("Connected to Websocket.");
var formatter = new JsonMessageFormatter();
formatter.JsonSerializer.Converters.Add(_hashTypeConverter);
formatter.JsonSerializer.Converters.Add(_extrinsicJsonConverter);
formatter.JsonSerializer.Converters.Add(_extrinsicStatusJsonConverter);
_jsonRpc = new JsonRpc(new WebSocketMessageHandler(_socket, formatter));
_jsonRpc.TraceSource.Listeners.Add(new NLogTraceListener());
_jsonRpc.TraceSource.Switch.Level = SourceLevels.All;
_jsonRpc.AddLocalRpcTarget(Listener, new JsonRpcTargetOptions()
{
AllowNonPublicInvocation = false
});
_jsonRpc.StartListening();
Logger.Debug("Listening to websocket.");
var result = await State.GetMetaDataAsync(token);
var metaDataParser = new MetaDataParser(_uri.OriginalString, result);
MetaData = metaDataParser.MetaData;
Logger.Debug("MetaData parsed.");
GenesisHash = await Chain.GetBlockHashAsync(0, token);
Logger.Debug("Genesis hash parsed.");
}
public void Dispose()
{
sourceFiles.Clear();
rpc.Dispose();
disconnectEvent.Dispose();
waitForInit?.Dispose();
}
public void Dispose()
{
OnDisposed();
_rpc.Dispose();
_stream.Dispose();
}
public void Dispose()
{
Rpc.Dispose();
Dispose(false);
Logger.TraceInformation($"{DebugInstanceString} Service instance disposed");
}
protected override void OnDisconnected()
{
// we are asked to disconnect. unsubscribe and dispose to disconnect.
// there are 2 ways to get disconnected. one is Roslyn decided to disconnect with RemoteHost (ex, cancellation or recycle OOP) and
// the other is external thing disconnecting remote host from us (ex, user killing OOP process).
// the Disconnected event we subscribe is to detect #2 case. and this method is for #1 case. so when we are willingly disconnecting
// we don't need the event, otherwise, Disconnected event will be called twice.
_rpc.Disconnected -= OnRpcDisconnected;
_rpc.Dispose();
}
public void IsDisposedReturnsTrueWhenJsonRpcIsDisposed()
{
JsonRpc jsonRpc = ((IJsonRpcClientProxy)this.clientRpc).JsonRpc;
jsonRpc.Dispose();
var disposableClient = (IDisposableObservable)this.clientRpc;
Assert.True(disposableClient.IsDisposed);
}
public virtual void Dispose()
{
try
{
_stream?.Dispose();
_rpc?.Dispose();
}
catch
{
// this shouldn't throw but it does in netcore
}
}
protected override void OnStopped()
{
// we are asked to stop. unsubscribe and dispose to disconnect.
// there are 2 ways to get disconnected. one is Roslyn decided to disconnect with RemoteHost (ex, cancellation or recycle OOP) and
// the other is external thing disconnecting remote host from us (ex, user killing OOP process).
// the Disconnected event we subscribe is to detect #2 case. and this method is for #1 case. so when we are willingly disconnecting
// we don't need the event, otherwise, Disconnected event will be called twice.
UnregisterGlobalOperationNotifications();
UnregisterPersistentStorageLocationServiceChanges();
_rpc.Disconnected -= OnRpcDisconnected;
_rpc.Dispose();
_connectionManager.Shutdown();
}
private void ExitImpl()
{
try
{
ShutdownRequestQueue();
_jsonRpc.Dispose();
}
catch (Exception e) when(FatalError.ReportAndCatch(e))
{
// Swallow exceptions thrown by disposing our JsonRpc object. Disconnected events can potentially throw their own exceptions so
// we purposefully ignore all of those exceptions in an effort to shutdown gracefully.
}
}
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
m_cts.Dispose();
m_JsonRpc.Dispose();
m_TcpClient.Close();
}
disposedValue = true;
}
}
public void Dispose()
{
try
{
if (!_jsonRpc.IsDisposed)
{
_jsonRpc.Dispose();
}
}
catch (Exception)
{
// Swallow exceptions thrown by disposing our JsonRpc object. Disconnected events can potentially throw their own exceptions so
// we purposefully ignore all of those exceptions in an effort to shutdown gracefully.
}
}
public Task ExitAsync(CancellationToken _)
{
try
{
ShutdownRequestQueue();
_jsonRpc.Dispose();
}
catch (Exception e) when(FatalError.ReportAndCatch(e))
{
// Swallow exceptions thrown by disposing our JsonRpc object. Disconnected events can potentially throw their own exceptions so
// we purposefully ignore all of those exceptions in an effort to shutdown gracefully.
}
return(Task.CompletedTask);
}
public Task ExitAsync(CancellationToken _)
{
Contract.ThrowIfFalse(_shuttingDown, "Shutdown has not been called yet.");
try
{
_jsonRpc.Dispose();
}
catch (Exception e) when(FatalError.ReportWithoutCrash(e))
{
// Swallow exceptions thrown by disposing our JsonRpc object. Disconnected events can potentially throw their own exceptions so
// we purposefully ignore all of those exceptions in an effort to shutdown gracefully.
}
return(Task.CompletedTask);
}
public async Task Connect()
{
this.stream = GetStream();
await this.stream.ConnectAsync();
rpc = new JsonRpc(this.stream);
this.Instance = this.rpc.Attach <T>();
rpc.StartListening();
rpc.Disconnected += (_, _) =>
{
this.stream.Dispose();
Disconnected?.Invoke(this, null);
rpc.Dispose();
};
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
public void Dispose()
{
m_ConnectionCheckCancellationTokenSource.Cancel();
if (m_ConnectionCheckTask != null)
{
if (m_ConnectionCheckTask.Status == TaskStatus.RanToCompletion
|| m_ConnectionCheckTask.Status == TaskStatus.Faulted
|| m_ConnectionCheckTask.Status == TaskStatus.Canceled)
m_ConnectionCheckTask.Dispose();
}
m_JsonRpc.Dispose();
m_Stream.Dispose();
m_TcpClient.Dispose();
this.Dispose(true);
GC.SuppressFinalize(this);
}
public void Dispose()
{
if (_disposed)
{
// guard us from double disposing. this can happen in unit test
// due to how we create test mock service hub stream that tied to
// remote host service
return;
}
_disposed = true;
_rpc.Dispose();
Dispose(disposing: true);
Logger.TraceInformation($"{DebugInstanceString} Service instance disposed");
}
void Dispose()
{
try {
if (jsonRpc != null)
{
jsonRpc.Dispose();
jsonRpc = null;
}
if (connection != null)
{
connection.Dispose();
connection = null;
}
} catch (IOException ex) {
// Ignore.
LanguageClientLoggingService.LogError("JsonRpc.Dispose error.", ex);
}
}
public async Task SendMessageWithEncoding(string encodingName)
{
var messageHandler = new HeaderDelimitedMessageHandler(this.clientStream, this.clientStream);
var rpcClient = new JsonRpc(messageHandler);
messageHandler.Encoding = Encoding.GetEncoding(encodingName);
await rpcClient.NotifyAsync("Foo").WithCancellation(this.TimeoutToken);
rpcClient.Dispose();
MemoryStream seekableServerStream = await this.GetSeekableServerStream();
int bytesRead = 0;
var reader = new StreamReader(seekableServerStream, Encoding.ASCII);
var headerLines = new List <string>();
string?line;
while ((line = await reader.ReadLineAsync().WithCancellation(this.TimeoutToken)) != string.Empty)
{
Assumes.NotNull(line);
headerLines.Add(line);
bytesRead += line.Length + 2; // + CRLF
}
bytesRead += 2; // final CRLF
this.Logger.WriteLine(string.Join(Environment.NewLine, headerLines));
// utf-8 headers may not be present because they are the default, per the protocol spec.
if (encodingName != "utf-8")
{
Assert.Contains(headerLines, l => l.Contains($"charset={encodingName}"));
}
// Because the first StreamReader probably read farther (to fill its buffer) than the end of the headers,
// we need to reposition the stream at the start of the content to create a new StreamReader.
seekableServerStream.Position = bytesRead;
reader = new StreamReader(seekableServerStream, Encoding.GetEncoding(encodingName));
string json = await reader.ReadToEndAsync().WithCancellation(this.TimeoutToken);
Assert.Equal('{', json[0]);
}
protected override void OnDisconnected()
{
_rpc.Dispose();
}
protected void Disconnect()
{
_rpc.Dispose();
}
public void Dispose()
{
_rpc.Disconnected -= OnDisconnected;
_rpc.Dispose();
}
public void Dispose()
{
_jsonRpc.Dispose();
}
public void Dispose()
{
rpc?.Dispose();
this.connection?.Dispose();
}
public void Disconnect()
{
_jsonRpc.Dispose();
_pipeStream.Dispose();
}
public void Dispose()
{
_rpc.Dispose();
_process.Kill(true);
_process.Dispose();
}
public virtual void Dispose()
{
_stream?.Dispose();
_rpc?.Dispose();
}