public Worker(
WorkerSettings settings,
RpcClientFactory rpcClientFactory,
IMapping <TKey, TValueIn> mappingPhase,
IReducing <TKey, TValueIn, TValueOut> reducingPhase,
IPartitioning <TKey, TValueIn> partitioningPhase)
{
_settings = settings;
_mappingPhase = mappingPhase;
_reducingPhase = reducingPhase;
_partitioningPhase = partitioningPhase;
_workerInfoDto = new()
{
WorkerUuid = settings.WorkerUuid
};
_channel = rpcClientFactory.CreateRpcChannel();
_heartBeatTicker = new()
{
Interval = TimeSpan.FromSeconds(4).TotalMilliseconds
};
StartHeartbeat();
}
public void Dispose()
{
_heartBeatTicker.Dispose();
_channel.Dispose();
}
public void Dispose()
{
_cts?.Cancel();
_cts?.Dispose();
_stream?.Dispose();
channel?.Dispose();
}
public void Dispose()
{
if (channel != null)
{
channel.Dispose();
}
}
public async ValueTask DisposeAsync()
{
channelReconnectTimer?.DisposeAsync().ConfigureAwait(false);
channelReconnectTimer = null;
if (m_DuplexStream != null)
{
try
{
await m_DuplexStream.RequestStream.CompleteAsync().ConfigureAwait(false);
}
catch (Exception e)
{
//Completeの例外発生はすでにComplete不可能な状態であることを示しているので、そのままDisposeへ進む
log.Trace($"{nameof(m_DuplexStream)} Complete Exception, {e}");
}
finally
{
m_DuplexStream.Dispose();
m_DuplexStream = null;
}
}
m_Channel?.Dispose();
m_Channel = null;
}
public void Dispose()
{
if (channel != null)
{
channel.Dispose();
}
GC.SuppressFinalize(this);
}
#pragma warning restore CS4014
public Task StopAsync(CancellationToken cancellationToken)
{
_heartbeatClient.StreamHeartbeats(new Empty(),
cancellationToken: new CancellationToken(true));
_channel?.Dispose();
return(Task.CompletedTask);
}
public async ValueTask DisposeAsync()
{
await notifyClient.DisposeAsync();
await channel.ShutdownAsync();
channel.Dispose();
}
internal static void CloseChannel()
{
try
{
ChannelServer.Dispose();
}
catch { } //TODO:!!!!!!!!
}
private void Dispose(bool disposing)
{
if (!_disposed && disposing)
{
_grpcChannel?.Dispose();
_disposed = true;
}
}
public override async Task TeardownAsync(WorkloadContext context)
{
await client.DisposeAsync();
await channel.ShutdownAsync();
channel.Dispose();
}
public void Dispose()
{
if (Disposed)
{
return;
}
_channel.Dispose();
Disposed = true;
}
public void Dispose()
{
if (_disposed)
{
return;
}
_disposed = true;
_channel.Dispose();
}
public void Dispose()
{
_holdingLineRequest?.Dispose();
_channel?.ShutdownAsync().Wait(TimeSpan.FromSeconds(5));
_channel?.Dispose();
StartStreamCallback = default;
StopStreamCallback = default;
CloseApplicationCallback = default;
}
/// <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary>
public void Dispose()
{
if (!disposing)
{
disposing = true;
tickTimer.Dispose();
//reconnector.Dispose();
serverCallbackCancel?.Cancel();
channel.Dispose();
}
}
public void ShutDown()
{
_logger.LogInformation("Shutting down the Grpc channel...");
// as the channel was created on app start, we need to
// dispose it properly when the connection is closed
if (_channel != null)
{
_channel.Dispose();
_channel = null;
}
}
public void Dispose()
{
if (_messageTask != null && !_messageTask.IsCompleted)
{
_messageTask.Dispose();
}
if (_grpcChannel != null)
{
_grpcChannel.Dispose();
}
}
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
_channel.Dispose();
_client.Dispose();
}
disposedValue = true;
}
}
public void StopReceiving()
{
try
{
channel.Dispose();
GrpcEnvironment.ShutdownChannelsAsync();
}
catch (Exception e)
{
OnError?.Invoke(this, $"Error closing gRPC connection to Server: {e}");
}
}
protected virtual void Dispose(bool disposing)
{
if (!_disposedValue)
{
if (disposing)
{
_grpcChannel.Dispose();
}
_disposedValue = true;
}
}
public void Dispose()
{
try
{
_semaphoreSlim.Dispose();
channel?.Dispose();
stream?.Dispose();
}
catch (Exception e)
{
OnError?.Invoke(this, $"Error during dispose: {e}");
}
}
protected virtual void Dispose(bool disposing)
{
if (_disposed)
{
return;
}
if (disposing)
{
_channel?.Dispose();
}
_disposed = true;
}
public void Start(Func <int> portGenerator, IServiceProvider serviceProvider)
{
if (process != null)
{
if (process.HasExited)
{
channel.Dispose();
spawn(portGenerator());
}
}
else
{
spawn(portGenerator());
}
}
private bool disposedValue = false; // To detect redundant calls
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
_channel.Dispose();
}
// TODO: free unmanaged resources (unmanaged objects) and override a finalizer below.
// TODO: set large fields to null.
disposedValue = true;
}
}
public async Task After()
{
await _testServer1?.Host?.StopAsync();
_testServer1?.Dispose();
_grpcChannel1?.Dispose();
TestServer1HttpClient = null;
TestServer1GrpcClient = null;
await _testServer2?.Host?.StopAsync();
_testServer2?.Dispose();
_grpcChannel2?.Dispose();
TestServer2HttpClient = null;
TestServer2GrpcClient = null;
}
private void LeaveChat()
{
if (cts != null)
{
cts.Cancel();
}
if (channel != null)
{
channel.Dispose();
}
ChatTB.Clear();
channel = null;
client = null;
cts = null;
}
// We don't want this handler -- it's only used for JWT-auth, not NKeys
//internal void HandleUserJWTEvent(object source, UserJWTEventArgs ev)
//{
// // Unfortunately, we have to do sync over async :-(
// var task = ResolveUserJwt(source);
// var awaiter = task.ConfigureAwait(false).GetAwaiter();
// ev.JWT = awaiter.GetResult();
//}
internal void Dispose(bool disposing)
{
if (!IsDisposed)
{
if (disposing)
{
// TODO: dispose managed state (managed objects)
DisposeClientResources(disposing);
_grpcChannel?.Dispose();
_grpcChannel = null;
}
// TODO: free unmanaged resources (unmanaged objects) and override finalizer
// TODO: set large fields to null
IsDisposed = true;
}
}
/*/// <summary>
* /// When connection is lost, tries to reconnect to the hub
* /// </summary>
* /// <param name="state">nothing</param>
* private void ReConnect(object? state)
* {
* reconnector.Change(Timeout.Infinite, Timeout.Infinite);
* LogEnvironment.LogDebugEvent("Trying to re-connect...",LogSeverity.Report);
* CleanUp();
* try
* {
* InitHubConnection();
* initialized = true;
* OnOperationalChanged(true);
* }
* catch (Exception ex)
* {
* LogEnvironment.LogEvent($"Reconnect changed: {ex.Message}", LogSeverity.Error);
* reconnector.Change(ReconnectPeriod, Timeout.Infinite);
* }
* }*/
/// <summary>
/// Performs a clean-up from old objects
/// </summary>
private void CleanUp()
{
try
{
channel?.Dispose();
serverCallbackCancel.Cancel();
serverCallbackCancel.Dispose();
}
catch
{
}
finally
{
channel = null;
client = null;
serverCallbackCancel = null;
}
}
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
_timer?.Dispose();
_metricsUpdateChannel?.RequestStream.CompleteAsync().ConfigureAwait(false).GetAwaiter().GetResult();
_heatbeatChannel?.RequestStream.CompleteAsync().ConfigureAwait(false).GetAwaiter().GetResult();
_metricsUpdateChannel?.Dispose();
_heatbeatChannel?.Dispose();
_channel.ShutdownAsync().ConfigureAwait(false).GetAwaiter().GetResult();
_channel.Dispose();
}
disposedValue = true;
}
}
public static void Main(string[] args)
{
//1.建立连接
GrpcChannel grpcChannelClient = GrpcChannel.ForAddress("https://localhost:5001");
//2.创建客户端
GreeterClient greeterClient = new Greeter.GreeterClient(grpcChannelClient);
//开始调用
HelloReply helloReply = greeterClient.SayHello(new HelloRequest {
Name = "qqqqqqqqqqqqqq"
});
//4.打印返回
Console.WriteLine($"打印返回值为：{helloReply.Message}");
//5.释放连接
grpcChannelClient.Dispose();
Console.ReadLine();
//CreateHostBuilder(args).Build().Run();
}
private void InitializeSensorsClient(string sensorsUrl, X509Certificate2 clientCertificate)
{
if (_channel != null)
{
_channel.ShutdownAsync();
_channel.Dispose();
_channel = null;
}
var handler = CreateHandler(sensorsUrl, clientCertificate);
_channel = GrpcChannel.ForAddress(sensorsUrl, new GrpcChannelOptions()
{
HttpHandler = handler,
MaxReceiveMessageSize = 40 * 1024 * 1024,
MaxSendMessageSize = 40 * 1024 * 1024,
});
_sensorsClient = new Sensors.SensorsClient(_channel);
}
