static async Task Main(string[] args)
{
await GrpcServer.Run((context, builder) =>
{
builder.RegisterType <DivisionControlService>().As <IGrpcService>();
});
}
public async Task ServiceProviderServiceCallTest()
{
var serverBuilder = new RpcServiceDefinitionsBuilder();
serverBuilder.RegisterService <IServiceProviderService>()
.RegisterService <ISimpleService>();
var host = new GrpcServer(serverBuilder, null, this.options);
host.AddEndPoint(CreateEndPoint());
host.Start();
try
{
var serviceImpl = new ServiceProviderServiceImpl(host.ServicePublisher);
using (var publishScope = host.PublishSingleton <IServiceProviderService>(serviceImpl))
{
var connection = this.CreateGrpcConnection();
var clientService = connection.GetServiceSingleton <IServiceProviderServiceClient>();
var serviceRef = await clientService.GetSimpleServiceAsync();
var simpleService = connection.GetServiceInstance(serviceRef);
int res = await simpleService.AddAsync(8, 9);
Assert.AreEqual(8 + 9, res);
}
}
finally
{
await host.ShutdownAsync();
}
}
public async Task SimpleObjectServiceCallTest()
{
var serverBuilder = new RpcServiceDefinitionsBuilder();
serverBuilder.RegisterService <ISimpleService>();
var host = new GrpcServer(serverBuilder, null, this.options);
host.AddEndPoint(CreateEndPoint());
host.Start();
try
{
var serviceImpl = new TestSimpleServiceImpl();
using (var publishScope = host.PublishInstance(serviceImpl))
{
var objectId = publishScope.Value.ObjectId;
var connection = this.CreateGrpcConnection();
var clientService = connection.GetServiceInstance <ISimpleService>(objectId);
int res = await clientService.AddAsync(8, 9);
Assert.AreEqual(8 + 9, res);
}
}
finally
{
await host.ShutdownAsync();
}
}
public static void Main(string[] args)
{
string host = "0.0.0.0";
int port = 9007;
var dic = Common.GetArgs(args);
if (dic != null && dic.Count > 0)
{
string tempHost;
string tempPort;
if (dic.TryGetValue("host", out tempHost))
{
host = tempHost;
}
if (dic.TryGetValue("port", out tempPort))
{
port = Convert.ToInt32(tempPort);
}
}
GrpcServer server = new GrpcServer
{
Services = { RPCDemoService.BindService(new RPCDemoImpl()) },
Ports = { new ServerPort(host, port, ServerCredentials.Insecure) }
};
Console.WriteLine("Google Grpc Starting");
foreach (var item in server.Ports)
{
Console.WriteLine(string.Format("RPC server {0} listening on port {1}", item.Host, item.Port));
}
server.Run();
}
public async Task Execute(CancellationToken cancellationToken)
{
IGrpcConfig grpcConfig = _api.Config <IGrpcConfig>();
if (grpcConfig.Enabled)
{
ILogger logger = _api.LogManager.GetClassLogger();
GrpcServer grpcServer = new GrpcServer(_api.EthereumJsonSerializer, _api.LogManager);
var grpcRunner = new GrpcRunner(grpcServer, grpcConfig, _api.LogManager);
await grpcRunner.Start(cancellationToken).ContinueWith(x =>
{
if (x.IsFaulted && logger.IsError)
{
logger.Error("Error during GRPC runner start", x.Exception);
}
});
_api.GrpcServer = grpcServer;
GrpcPublisher grpcPublisher = new GrpcPublisher(_api.GrpcServer);
_api.Publishers.Add(grpcPublisher);
_api.DisposeStack.Push(grpcPublisher);
_api.DisposeStack.Push(Disposable.Create(() => grpcRunner.StopAsync())); // do not await
}
}
/// <summary>
/// Starts the server.
/// </summary>
public void Start()
{
GrpcServer.Start();
var port = GrpcServer.Ports.FirstOrDefault();
Logger.Info(LoggerMessages.ServerStartedMessage(port.Host, port.Port));
}
public async Task DeviceServiceTest()
{
var serverBuilder = new RpcServiceDefinitionsBuilder();
serverBuilder.RegisterService <IThermostatService>();
var host = new GrpcServer(serverBuilder, null, this.options);
host.AddEndPoint(CreateEndPoint());
host.Start();
try
{
var serviceImpl = new ThermostatServiceImpl();
using (var publishScope = host.PublishInstance(serviceImpl))
{
var objectId = publishScope.Value.ObjectId;
GrpcConnection connection = this.CreateGrpcConnection();
var clientService = connection.GetServiceInstance <IThermostatServiceClient>(objectId);
var acoId = clientService.DeviceAcoId;
var baseClientService = (IDeviceServiceClient)clientService;
var acoId2 = baseClientService.DeviceAcoId;
Assert.AreEqual(acoId, acoId2);
}
}
finally
{
await host.ShutdownAsync();
}
}
public async Task EventHandlersTest()
{
var serverBuilder = new RpcServiceDefinitionsBuilder();
serverBuilder.RegisterService <ISimpleServiceWithEvents>();
var host = new GrpcServer(serverBuilder, null, this.options);
host.AddEndPoint(CreateEndPoint());
host.Start();
try
{
var serviceImpl = new TestServiceWithEventsImpl();
using (var publishScope = host.PublishInstance(serviceImpl))
{
var objectId = publishScope.Value.ObjectId;
var connection = this.CreateGrpcConnection();
var clientService = connection.GetServiceInstance <ISimpleServiceWithEvents>(objectId);
TaskCompletionSource <ValueChangedEventArgs> detailedTcs = new TaskCompletionSource <ValueChangedEventArgs>();
EventHandler <ValueChangedEventArgs> detailedHandler = (s, e) =>
{
detailedTcs.SetResult(e);
};
clientService.DetailedValueChanged += detailedHandler;
await((IRpcProxy)clientService).WaitForPendingEventHandlersAsync();
clientService.SetValueAsync(12).Forget();
var completedTask = await Task.WhenAny(detailedTcs.Task, Task.Delay(1000));
Assert.AreEqual(detailedTcs.Task, completedTask);
Assert.IsTrue(completedTask.IsCompletedSuccessfully());
var detailedArgs = detailedTcs.Task.Result;
clientService.DetailedValueChanged -= detailedHandler;
await((IRpcProxy)clientService).WaitForPendingEventHandlersAsync();
clientService.SetValueAsync(13).Forget();
await Task.Delay(200);
Assert.IsFalse(serviceImpl.HasDetailedValueChangedHandler);
Assert.IsFalse(serviceImpl.HasValueChangedHandler);
Assert.AreEqual(12, detailedArgs.NewValue);
Assert.AreEqual(0, detailedArgs.OldValue);
}
}
finally
{
await host.ShutdownAsync();
}
}
public void Start()
{
ServerStarted = true;
GrpcServer.Start();
// Can't log before the job manager starts (Master Interpreter looks for the first newline to decide when it's safe to send commands)
//Console.WriteLine("Listening for progress feedback on address {0}", ServerAddress);
}
public void Dispose()
{
CloseServerAction.Invoke();
GrpcServer.ShutdownAsync().Wait();
var port = GrpcServer.Ports.FirstOrDefault();
Logger.Info(message: LoggerMessages.ServerClosedMessage(port.Host, port.Port));
}
/// <summary>
/// Initializes new instance of <see cref="GrpcHostedService"/>
/// </summary>
/// <param name="server">Instance of <see cref="Server"/>.</param>
/// <param name="clientCache" Instance of <see cref="IGrpcClientCache"/>.
/// <param name="definitions">Dictionary that should contain gRPC service implementation that need to be registered with server.</param>
/// <param name="applicationLifetime">Instance of <see cref="IApplicationLifetime"/>.</param>
/// <param name="logger">Instance of <see cref="ILogger"/> that will be configured to use Serilog Splunk or Console sink.</param>
public GrpcHostedService(
IApplicationLifetime applicationLifetime,
GrpcServer server,
Microsoft.Extensions.Logging.ILogger logger)
{
_applicationLifetime = applicationLifetime ?? throw new ArgumentNullException(nameof(applicationLifetime));
_server = server ?? throw new ArgumentNullException(nameof(server));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
/// <summary>
/// 启动服务
/// </summary>
public void Start()
{
GrpcServer server = new GrpcServer(_config.LocalAddress.Split(':')[0], int.Parse(_config.LocalAddress.Split(':')[1]), _config.ClusterToken, new DebugConsole());
server.Register(typeof(IHost), typeof(Host), _host);
server.Start().Wait();
DebugConsole.WriteLine("Raft is Running...");
DebugConsole.WriteLine($"NodeId:{_config.NodeId} name:{_config.NodeName} address:{_config.LocalAddress}...");
}
public static void TestFixtureSetup()
{
AppDomain.CurrentDomain.UnhandledException += AppDomain_UnhandledException;
// collects gRpc traces for tests https://github.com/grpc/grpc/blob/master/TROUBLESHOOTING.md
System.Environment.SetEnvironmentVariable("GRPC_VERBOSITY", "DEBUG");
System.Environment.SetEnvironmentVariable("GRPC_TRACE", "all");
GrpcServer = UnitTestsHelper.StartGrpcServer(Port, true);
}
private static void CreateServer()
{
_grpcServer = new GrpcServer(_service, _auth);
_server = new Grpc.Core.Server
{
Services = { TriathlonService.BindService(_grpcServer) },
Ports = { new ServerPort(GetConfig("serverHost", "localhost"),
GetIntegerConfig("serverPort", 8000),
ServerCredentials.Insecure) }
};
}
private static async Task Main(string[] args)
{
Console.Title = "gRPC Service";
GrpcServer.Start();
Console.WriteLine("gRPC server started.\nPress spacebar to notify item changes or any other key to stop it.");
while (Console.ReadKey().Key == ConsoleKey.Spacebar)
{
RaiseItemsChanged();
}
await GrpcServer.Stop();
}
public static async Task Main(string[] args)
{
// This example shows how to explicitly setup a gRPC RPC server and a Pipelines RPC server
// with a common service publisher.
//
// In a real scenario, it is probably more suitable to use the .NET generic host
// (https://docs.microsoft.com/en-us/aspnet/core/fundamentals/host/generic-host).
//
// The NetGrpcServer example shows what a host setup could look like.
Console.WriteLine("Initializing gRPC server and pipelines server.");
var serviceCollection = new ServiceCollection();
ConfigureServices(serviceCollection);
var serviceProvider = serviceCollection.BuildServiceProvider();
var definitionsBuilder = new RpcServiceDefinitionBuilder();
var rpcPublisher = new RpcServicePublisher(definitionsBuilder);
RegisterServiceDefinitions(definitionsBuilder);
PublishServices(rpcPublisher);
var serializer = new ProtobufSerializer();
var grpcServer = new GrpcServer(rpcPublisher, serviceProvider, serializer);
grpcServer.AllowAutoPublish = true;
grpcServer.AddEndPoint(CreateGrpcEndPoint(50051));
var pipelinesServer = new RpcPipelinesServer(rpcPublisher, serviceProvider, serializer);
pipelinesServer.AllowAutoPublish = true;
pipelinesServer.AddEndPoint(new TcpPipelinesEndPoint("127.0.0.1", 50052, false));
Console.WriteLine("Starting gRPC server and pipelines server.");
// Once the gRPC server is started, it is no longer possible to register service definitions.
grpcServer.Start();
pipelinesServer.Start();
Console.WriteLine("gRPC server and pipelines server are running, press any key to shutdown.");
Console.ReadKey();
Console.WriteLine("Shutting down servers.");
await Task.WhenAll(grpcServer.ShutdownAsync(), pipelinesServer.ShutdownAsync());
Console.WriteLine("Ended");
}
public async Task BlockingServiceCallTest()
{
var serverBuilder = new RpcServiceDefinitionsBuilder();
serverBuilder
.RegisterService <IBlockingService>()
.RegisterService <ISimpleService>();
var host = new GrpcServer(serverBuilder, null, this.options);
host.AddEndPoint(CreateEndPoint());
host.Start();
try
{
var serviceImpl = new TestBlockingSimpleServiceImpl();
using (var publishScope = host.PublishInstance(serviceImpl))
{
var objectId = publishScope.Value.ObjectId;
var connection = this.CreateGrpcConnection();
var clientService = connection.GetServiceInstance <IBlockingServiceClient>(objectId);
int blockingRes = clientService.Add(12, 13);
Assert.AreEqual(12 + 13, blockingRes);
int asyncRes = await clientService.AddAsync(8, 9);
Assert.AreEqual(8 + 9, asyncRes);
clientService.Value = 123.45;
Assert.AreEqual(123.45, await clientService.GetValueAsync());
await clientService.SetValueAsync(543.21);
Assert.AreEqual(543.21, clientService.Value);
}
}
finally
{
await host.ShutdownAsync();
}
}
private async Task InitializeWorkersAsync()
{
var serverImpl = new FunctionRpcService(EventManager, _logger);
var server = new GrpcServer(serverImpl, ScriptOptions.MaxMessageLengthBytes);
using (_metricsLogger.LatencyEvent(MetricEventNames.HostStartupGrpcServerLatency))
{
await server.StartAsync();
}
var processFactory = new DefaultWorkerProcessFactory();
try
{
_processRegistry = ProcessRegistryFactory.Create();
}
catch (Exception e)
{
_logger.LogWarning(e, "Unable to create process registry");
}
CreateChannel channelFactory = (languageWorkerConfig, registrations, attemptCount) =>
{
return(new LanguageWorkerChannel(
ScriptOptions,
EventManager,
processFactory,
_processRegistry,
registrations,
languageWorkerConfig,
server.Uri,
_loggerFactory, // TODO: DI (FACAVAL) Pass appropriate logger. Channel facory should likely be a service.
_metricsLogger,
attemptCount));
};
_functionDispatcher = new FunctionDispatcher(EventManager, server, channelFactory, _workerConfigs, _language);
_eventSubscriptions.Add(EventManager.OfType <WorkerProcessErrorEvent>()
.Subscribe(evt =>
{
HandleHostError(evt.Exception);
}));
}
static void Main(string[] args)
{
Console.WriteLine(Environment.CurrentDirectory);
var options = new GrpcServerOptions()
{
Host = "127.0.0.1",
Port = 3002,
NamespaceName = "Atlantis.Simple",
PackageName = "Atlantis.Simple",
ServiceName = "AtlantisService",
ScanAssemblies = new string[]
{
typeof(IPersonServicer).Assembly.FullName
}
};
var consulSetting = new ConsulSettingOptions()
{
ConsulAddressUrl = "http://192.168.0.251:8500"
};
var serviceOptions = new ConsulServiceOptions()
{
ServiceName = "Atlantis.Test",
Address = "127.0.0.1",
Port = 3002,
TTL = 1000
};
var consulManager = new ConsulManager()
.Init(consulSetting)
.WithServiceOptions(serviceOptions);
consulManager.Service.RegisteAsync().Wait();
//GrpcConfiguration.LoggerFactory=new Loggerfac();
var server = new GrpcServer(options);
ObjectContainer.Register <IPersonServicer, PersonServicer>(LifeScope.Single);
server.Start();
Console.WriteLine("Server is running...");
Console.ReadLine();
}
/// <inheritdoc />
public void Start()
{
try
{
ChannelOption optionReceive = new ChannelOption(ChannelOptions.MaxReceiveMessageLength, GrpcStream.MaxPackageSize);
ChannelOption optionSend = new ChannelOption(ChannelOptions.MaxSendMessageLength, GrpcStream.MaxPackageSize);
if (System.IO.File.Exists("ca.crt"))
{
var cacert = System.IO.File.ReadAllText(@"ca.crt");
var servercert = System.IO.File.ReadAllText(@"server.crt");
var serverkey = System.IO.File.ReadAllText(@"server.key");
var keypair = new KeyCertificatePair(servercert, serverkey);
var sslCredentials = new SslServerCredentials(new List <KeyCertificatePair>()
{
keypair
}, cacert, false);
this.grpcServer = new Server
{
Services = { GrpcServer.BindService(this) },
Ports = { new ServerPort(this.Host.Address.ToString(), this.Host.Port, sslCredentials) }
};
}
else
{
this.grpcServer = new Server(new List <ChannelOption>()
{
optionReceive, optionSend
})
{
Services = { GrpcServer.BindService(this) },
Ports = { new ServerPort(this.Host.Address.ToString(), this.Host.Port, ServerCredentials.Insecure) }
};
}
this.grpcServer.Start();
this.Log(this.ToString(), "GRPC-Server server listening on port " + this.Host.Port, LogLevel.Info);
}
catch (Exception ex)
{
throw new Exception("Grpc server error", ex);
}
}
internal static GrpcServer StartGrpcServer(int port, bool isRetryEnabled)
{
// max 3 times attemps, including the original request.
RetryPolicy retryPolicy = isRetryEnabled ?
new RetryPolicy(3, (float)0.1, 5, 2) :
null;
GrpcServerLegacyQueryHandlerBase mockLegacyQueryHandler = new RetryableLegacyQueryHandler();
//GrpcServerLegacyQueryHandlerBase mockLegacyQueryHandler =
// isRetryEnabled ?
// (GrpcServerLegacyQueryHandlerBase)new MockRetryableLegacyQueryHandler() :
// (GrpcServerLegacyQueryHandlerBase)new MockLegacyQueryHandler();
LegacyQueryService legacyQueryService = GrpcServer.CreateLegacyQueryService(mockLegacyQueryHandler);
GrpcServer grpcServer = new GrpcServer(
port, legacyQueryService, retryPolicy: retryPolicy);
grpcServer.Start();
return(grpcServer);
}
static void Main(string[] args)
{
var logRepository = LogManager.GetRepository(Assembly.GetEntryAssembly());
XmlConfigurator.Configure(logRepository, new FileInfo("log4net.config"));
TripRepository tripRepository = new TripRepository();
TripValidator tripValidator = new TripValidator();
AccountRepository accountRepository = new AccountRepository();
AccountValidator accountValidator = new AccountValidator();
BookingRepository bookingRepository = new BookingRepository();
BookingValidator bookingValidator = new BookingValidator();
ITripServices tripServices = new TripServicesImpl(accountRepository, tripRepository, bookingRepository,
accountValidator, tripValidator, bookingValidator);
TripServicesGrpcImpl tripServicesGrpc = new TripServicesGrpcImpl(tripServices);
GrpcServer server = new GrpcServer(int.Parse(ConfigurationManager.AppSettings["port"]),
ConfigurationManager.AppSettings["host"], tripServicesGrpc);
server.Start();
}
/// <summary>
/// </summary>
static void Init()
{
Console.WriteLine($"Init() called on thread {Thread.CurrentThread.ManagedThreadId}");
MqttTransportSettings mqttSetting = new MqttTransportSettings(TransportType.Mqtt_Tcp_Only)
{
RemoteCertificateValidationCallback =
(sender, certificate, chain, sslPolicyErrors) => true
};
ITransportSettings[] settings = { mqttSetting };
// Open a connection to the Edge runtime
var mcTask = ModuleClient.CreateFromEnvironmentAsync(settings);
mcTask.Wait();
s_moduleClient = mcTask.Result;
s_moduleClient.OpenAsync().Wait();
// Get module twin for initial settings
Task <Twin> twinTask = s_moduleClient.GetTwinAsync();
twinTask.Wait();
Twin twin = twinTask.Result;
OnDesiredPropertiesUpdate(twin.Properties.Desired, s_moduleClient).Wait();
s_moduleClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertiesUpdate, null);
s_grpcServer = new GrpcServer("VideoProcessorModule", OnImageReceived);
Console.WriteLine("Starting gRPC server");
s_grpcServer.Start();
Task processingTask = new Task(ProcessingLoop);
processingTask.Start();
Console.WriteLine("IoT Hub module client initialized.");
}
public override void Start()
{
AppContext.SetSwitch("System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true);
AppContext.SetSwitch("System.Net.Http.SocketsHttpHandler.Http2Support", true);
GrpcEnvironment.SetLogger(new UnityLogger());
Converter?.SetInitTRS(Vector3.zero, Quaternion.identity);
var servicesChain = new IChainable <MapsManagerPb.MapsManagerPbBase>[]
{
new PointsMapManager(_containerTree.Points, Converter),
new ObservationsMapManager(_containerTree.Observations, Converter),
new TrackedObjsMapManager(_containerTree.TrackedObjs, Converter),
new LinesMapManager(_containerTree.Lines, Converter),
new InfinitePlanesMapManager(_containerTree.InfinitePlanes, Converter)
}.BuildChain();
_containerTree.DisplayName = $"From gRPC at port {TypedSettings.Port}";
#if UNITY_EDITOR || UNITY_STANDALONE
Debug.Log($"{TypedSettings.IPAddress}:{TypedSettings.Port}");
#endif
_server = new GrpcServer()
{
Services =
{
MapsManagerPb.BindService(servicesChain),
SceneManagerPb.BindService(new SceneManager(_containerTree)),
ImageManagerPb.BindService(new ImageManager((RawImagePresenter)_containerTree.Image))
},
Ports =
{
new ServerPort("0.0.0.0", TypedSettings.Port, ServerCredentials.Insecure),
},
};
StartServer();
}
/// <summary>
/// TODO: Use factories instead of using this.connnectionType.
/// </summary>
/// <param name="serviceDefinitionsProvider"></param>
/// <param name="proxyDefinitionsProvider"></param>
/// <returns></returns>
protected (IRpcServerHost, IRpcChannel) CreateServerAndConnection(
IRpcServiceDefinitionsProvider serviceDefinitionsProvider = null,
Action <RpcServerOptions> configServerOptions = null,
Action <RpcClientOptions> configClientOptions = null,
Action <IServiceCollection> configureServices = null)
{
var rpcServerId = RpcServerId.NewId();
var serverOptions = new RpcServerOptions {
Serializer = this.serializer
};
var clientOptions = new RpcClientOptions {
Serializer = this.serializer
};
configServerOptions?.Invoke(serverOptions);
configClientOptions?.Invoke(clientOptions);
IServiceProvider services = GetServiceProvider(configureServices);
switch (this.ConnectionType)
{
case RpcConnectionType.LightweightTcp:
case RpcConnectionType.LightweightSslTcp:
{
var host = new LightweightRpcServer(rpcServerId, serviceDefinitionsProvider, services, serverOptions, this.LightweightOptions,
loggerFactory: services.GetService <ILoggerFactory>());
SslServerOptions sslServerOptions = null;
if (this.ConnectionType == RpcConnectionType.LightweightSslTcp)
{
sslServerOptions = new SslServerOptions(new X509Certificate2(TestCertificates.ServerPFXPath, "1111"));
}
host.AddEndPoint(new TcpRpcEndPoint("127.0.0.1", TcpTestPort, false, sslServerOptions));
SslClientOptions sslClientOptions = null;
if (this.ConnectionType == RpcConnectionType.LightweightSslTcp)
{
sslClientOptions = new SslClientOptions {
RemoteCertificateValidationCallback = this.ValidateTestCertificate
};
}
var connection = new TcpRpcConnection(
new RpcConnectionInfo("TCP", new Uri($"lightweight.tcp://127.0.0.1:{TcpTestPort}"), rpcServerId),
sslClientOptions,
clientOptions.AsImmutable(),
this.LightweightOptions);
return(host, connection);
}
case RpcConnectionType.LightweightNamedPipe:
{
var server = new LightweightRpcServer(rpcServerId, serviceDefinitionsProvider, services, serverOptions, this.LightweightOptions,
loggerFactory: services.GetService <ILoggerFactory>());
server.AddEndPoint(new NamedPipeRpcEndPoint("testpipe"));
var connection = new NamedPipeRpcConnection(
new RpcConnectionInfo(new Uri("lightweight.pipe://./testpipe")),
clientOptions.AsImmutable(),
this.LightweightOptions);
return(server, connection);
}
case RpcConnectionType.LightweightInproc:
{
Pipe requestPipe = new Pipe(new PipeOptions(readerScheduler: PipeScheduler.ThreadPool));
Pipe responsePipe = new Pipe(new PipeOptions(readerScheduler: PipeScheduler.Inline));
var host = new LightweightRpcServer(rpcServerId, serviceDefinitionsProvider, services, serverOptions,
loggerFactory: services.GetService <ILoggerFactory>());
host.AddEndPoint(new InprocRpcEndPoint(new DirectDuplexPipe(requestPipe.Reader, responsePipe.Writer)));
var connection = new InprocRpcConnection(new RpcConnectionInfo("Direct", new Uri("direct:localhost"), rpcServerId),
new DirectDuplexPipe(responsePipe.Reader, requestPipe.Writer), clientOptions.AsImmutable());
return(host, connection);
}
case RpcConnectionType.Grpc:
{
var host = new GrpcServer(rpcServerId, serviceDefinitionsProvider, services, serverOptions);
host.AddEndPoint(GrpcCoreFullStackTestsBase.CreateEndPoint());
var connection = new GrpcConnection(
new RpcConnectionInfo("TCP", new Uri($"grpc://localhost:{GrpcCoreFullStackTestsBase.GrpcTestPort}"), rpcServerId),
TestCertificates.GrpcSslCredentials, clientOptions.AsImmutable());
return(host, connection);
}
#if PLAT_NET_GRPC
case RpcConnectionType.NetGrpc:
{
var server = CreateNetGrpcServer(serviceDefinitionsProvider, rpcServerId, serverOptions, configureServices);
//var host = new GrpcServer(rpcServerId, serviceDefinitionsBuilder, null, options);
//host.AddEndPoint(GrpcCoreFullStackTestsBase.CreateEndPoint());
var handler = new System.Net.Http.HttpClientHandler();
handler.ServerCertificateCustomValidationCallback =
(httpRequestMessage, cert, cetChain, policyErrors) =>
{
return(true);
};
var channelOptions = new GrpcNet.Client.GrpcChannelOptions()
{
HttpClient = new System.Net.Http.HttpClient(handler),
DisposeHttpClient = true
};
var connection = new NetGrpcConnection(
new RpcConnectionInfo("net-grpc", new Uri($"grpc://localhost:{GrpcCoreFullStackTestsBase.GrpcTestPort}"), rpcServerId),
clientOptions.AsImmutable(), channelOptions);
return(server, connection);
}
#endif
}
throw new NotSupportedException();
}
static void Main(string[] args)
{
var server = new GrpcServer();
}
protected async Task StartRunners(IConfigProvider configProvider)
{
IInitConfig initConfig = configProvider.GetConfig <IInitConfig>();
IJsonRpcConfig jsonRpcConfig = configProvider.GetConfig <IJsonRpcConfig>();
IMetricsConfig metricsConfig = configProvider.GetConfig <IMetricsConfig>();
NLogManager logManager = new NLogManager(initConfig.LogFileName, initConfig.LogDirectory);
IRpcModuleProvider rpcModuleProvider = jsonRpcConfig.Enabled
? new RpcModuleProvider(configProvider.GetConfig <IJsonRpcConfig>(), logManager)
: (IRpcModuleProvider)NullModuleProvider.Instance;
EthereumJsonSerializer jsonSerializer = new EthereumJsonSerializer();
WebSocketsManager webSocketsManager = new WebSocketsManager();
if (!string.IsNullOrEmpty(metricsConfig.NodeName))
{
logManager.SetGlobalVariable("nodeName", metricsConfig.NodeName);
}
if (metricsConfig.Enabled)
{
Metrics.Version = VersionToMetrics.ConvertToNumber(ClientVersion.Version);
MetricsUpdater metricsUpdater = new MetricsUpdater(metricsConfig);
_monitoringService = new MonitoringService(metricsUpdater, metricsConfig, logManager);
_monitoringService.RegisterMetrics(typeof(Nethermind.Blockchain.Metrics));
_monitoringService.RegisterMetrics(typeof(Nethermind.Db.Metrics));
_monitoringService.RegisterMetrics(typeof(Nethermind.Evm.Metrics));
_monitoringService.RegisterMetrics(typeof(Nethermind.JsonRpc.Metrics));
_monitoringService.RegisterMetrics(typeof(Nethermind.Trie.Metrics));
_monitoringService.RegisterMetrics(typeof(Nethermind.Network.Metrics));
_monitoringService.RegisterMetrics(typeof(Nethermind.Synchronization.Metrics));
_monitoringService.RegisterMetrics(typeof(Nethermind.TxPool.Metrics));
_monitoringService.RegisterMetrics(typeof(Metrics));
await _monitoringService.StartAsync().ContinueWith(x =>
{
if (x.IsFaulted && (_logger?.IsError ?? false))
{
_logger !.Error("Error during starting a monitoring.", x.Exception);
}
});
}
else
{
if (_logger?.IsInfo ?? false)
{
_logger !.Info("Grafana / Prometheus metrics are disabled in configuration");
}
}
IGrpcConfig grpcConfig = configProvider.GetConfig <IGrpcConfig>();
GrpcServer? grpcServer = null;
if (grpcConfig.Enabled)
{
grpcServer = new GrpcServer(jsonSerializer, logManager);
_grpcRunner = new GrpcRunner(grpcServer, grpcConfig, logManager);
await _grpcRunner.Start().ContinueWith(x =>
{
if (x.IsFaulted && (_logger?.IsError ?? false))
{
_logger !.Error("Error during GRPC runner start", x.Exception);
}
});
}
INdmDataPublisher? ndmDataPublisher = null;
INdmConsumerChannelManager?ndmConsumerChannelManager = null;
INdmInitializer? ndmInitializer = null;
INdmConfig ndmConfig = configProvider.GetConfig <INdmConfig>();
bool ndmEnabled = ndmConfig.Enabled;
if (ndmEnabled)
{
ndmDataPublisher = new NdmDataPublisher();
ndmConsumerChannelManager = new NdmConsumerChannelManager();
string initializerName = ndmConfig.InitializerName;
if (_logger?.IsInfo ?? false)
{
_logger !.Info($"NDM initializer: {initializerName}");
}
Type ndmInitializerType = AppDomain.CurrentDomain.GetAssemblies()
.SelectMany(a => a.GetTypes())
.FirstOrDefault(t =>
t.GetCustomAttribute <NdmInitializerAttribute>()?.Name == initializerName);
NdmModule ndmModule = new NdmModule();
NdmConsumersModule ndmConsumersModule = new NdmConsumersModule();
ndmInitializer = new NdmInitializerFactory(ndmInitializerType, ndmModule, ndmConsumersModule, logManager).CreateOrFail();
if (grpcServer != null)
{
ndmConsumerChannelManager.Add(new GrpcNdmConsumerChannel(grpcServer));
}
webSocketsManager.AddModule(new NdmWebSocketsModule(ndmConsumerChannelManager, ndmDataPublisher, jsonSerializer));
}
_ethereumRunner = new EthereumRunner(
rpcModuleProvider,
configProvider,
logManager,
grpcServer,
ndmConsumerChannelManager,
ndmDataPublisher,
ndmInitializer,
webSocketsManager,
jsonSerializer,
_monitoringService);
await _ethereumRunner.Start().ContinueWith(x =>
{
if (x.IsFaulted && (_logger?.IsError ?? false))
{
_logger !.Error("Error during ethereum runner start", x.Exception);
}
});
if (jsonRpcConfig.Enabled)
{
rpcModuleProvider.Register(new SingletonModulePool <IWeb3Module>(new Web3Module(logManager), true));
JsonRpcService jsonRpcService = new JsonRpcService(rpcModuleProvider, logManager);
JsonRpcProcessor jsonRpcProcessor = new JsonRpcProcessor(jsonRpcService, jsonSerializer, jsonRpcConfig, new FileSystem(), logManager);
if (initConfig.WebSocketsEnabled)
{
webSocketsManager.AddModule(new JsonRpcWebSocketsModule(jsonRpcProcessor, jsonSerializer), true);
}
Bootstrap.Instance.JsonRpcService = jsonRpcService;
Bootstrap.Instance.LogManager = logManager;
Bootstrap.Instance.JsonSerializer = jsonSerializer;
_jsonRpcRunner = new JsonRpcRunner(configProvider, rpcModuleProvider, logManager, jsonRpcProcessor, webSocketsManager);
await _jsonRpcRunner.Start().ContinueWith(x =>
{
if (x.IsFaulted && (_logger?.IsError ?? false))
{
_logger !.Error("Error during jsonRpc runner start", x.Exception);
}
});
}
else
{
if (_logger?.IsInfo ?? false)
{
_logger !.Info("Json RPC is disabled");
}
}
}
public void Stop()
{
GrpcServer.ShutdownAsync().Wait();
ServerStarted = false;
}
protected async Task StartRunners(IConfigProvider configProvider)
{
IInitConfig initConfig = configProvider.GetConfig <IInitConfig>();
IJsonRpcConfig jsonRpcConfig = configProvider.GetConfig <IJsonRpcConfig>();
var metricsParams = configProvider.GetConfig <IMetricsConfig>();
var logManager = new NLogManager(initConfig.LogFileName, initConfig.LogDirectory);
IRpcModuleProvider rpcModuleProvider = jsonRpcConfig.Enabled
? new RpcModuleProvider(configProvider.GetConfig <IJsonRpcConfig>(), logManager)
: (IRpcModuleProvider)NullModuleProvider.Instance;
var jsonSerializer = new EthereumJsonSerializer();
var webSocketsManager = new WebSocketsManager();
INdmDataPublisher ndmDataPublisher = null;
INdmConsumerChannelManager ndmConsumerChannelManager = null;
INdmInitializer ndmInitializer = null;
var ndmConfig = configProvider.GetConfig <INdmConfig>();
var ndmEnabled = ndmConfig.Enabled;
if (ndmEnabled)
{
ndmDataPublisher = new NdmDataPublisher();
ndmConsumerChannelManager = new NdmConsumerChannelManager();
var initializerName = ndmConfig.InitializerName;
if (Logger.IsInfo)
{
Logger.Info($"NDM initializer: {initializerName}");
}
var ndmInitializerType = AppDomain.CurrentDomain.GetAssemblies()
.SelectMany(a => a.GetTypes())
.FirstOrDefault(t =>
t.GetCustomAttribute <NdmInitializerAttribute>()?.Name == initializerName);
var ndmModule = new NdmModule();
var ndmConsumersModule = new NdmConsumersModule();
ndmInitializer = new NdmInitializerFactory(ndmInitializerType, ndmModule, ndmConsumersModule,
logManager).CreateOrFail();
}
var grpcConfig = configProvider.GetConfig <IGrpcConfig>();
GrpcServer grpcServer = null;
if (grpcConfig.Enabled)
{
grpcServer = new GrpcServer(jsonSerializer, logManager);
if (ndmEnabled)
{
ndmConsumerChannelManager.Add(new GrpcNdmConsumerChannel(grpcServer));
}
_grpcRunner = new GrpcRunner(grpcServer, grpcConfig, logManager);
await _grpcRunner.Start().ContinueWith(x =>
{
if (x.IsFaulted && Logger.IsError)
{
Logger.Error("Error during GRPC runner start", x.Exception);
}
});
}
if (initConfig.WebSocketsEnabled)
{
if (ndmEnabled)
{
webSocketsManager.AddModule(new NdmWebSocketsModule(ndmConsumerChannelManager, ndmDataPublisher,
jsonSerializer));
}
}
_ethereumRunner = new EthereumRunner(rpcModuleProvider, configProvider, logManager, grpcServer,
ndmConsumerChannelManager, ndmDataPublisher, ndmInitializer, webSocketsManager, jsonSerializer);
await _ethereumRunner.Start().ContinueWith(x =>
{
if (x.IsFaulted && Logger.IsError)
{
Logger.Error("Error during ethereum runner start", x.Exception);
}
});
if (jsonRpcConfig.Enabled)
{
rpcModuleProvider.Register(new SingletonModulePool <IWeb3Module>(new Web3Module(logManager)));
var jsonRpcService = new JsonRpcService(rpcModuleProvider, logManager);
var jsonRpcProcessor = new JsonRpcProcessor(jsonRpcService, jsonSerializer, logManager);
if (initConfig.WebSocketsEnabled)
{
webSocketsManager.AddModule(new JsonRpcWebSocketsModule(jsonRpcProcessor, jsonSerializer));
}
Bootstrap.Instance.JsonRpcService = jsonRpcService;
Bootstrap.Instance.LogManager = logManager;
Bootstrap.Instance.JsonSerializer = jsonSerializer;
_jsonRpcRunner = new JsonRpcRunner(configProvider, rpcModuleProvider, logManager, jsonRpcProcessor,
webSocketsManager);
await _jsonRpcRunner.Start().ContinueWith(x =>
{
if (x.IsFaulted && Logger.IsError)
{
Logger.Error("Error during jsonRpc runner start", x.Exception);
}
});
}
else
{
if (Logger.IsInfo)
{
Logger.Info("Json RPC is disabled");
}
}
if (metricsParams.Enabled)
{
var intervalSeconds = metricsParams.IntervalSeconds;
_monitoringService = new MonitoringService(new MetricsUpdater(intervalSeconds),
metricsParams.PushGatewayUrl, ClientVersion.Description,
metricsParams.NodeName, intervalSeconds, logManager);
await _monitoringService.StartAsync().ContinueWith(x =>
{
if (x.IsFaulted && Logger.IsError)
{
Logger.Error("Error during starting a monitoring.", x.Exception);
}
});
}
else
{
if (Logger.IsInfo)
{
Logger.Info("Monitoring is disabled");
}
}
}
public GrpcServerHostedService(GrpcServer grpcServer,
ILogger <GrpcServerHostedService> logger)
{
_grpcServer = grpcServer ?? throw new ArgumentNullException(nameof(grpcServer));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
