コード例 #1
0
        private IEnumerable <ModuleType> GetModules(string[] moduleNames)
        {
            if (moduleNames == null || !moduleNames.Any())
            {
                return(null);
            }

            var modules = new List <ModuleType>();

            foreach (var moduleName in moduleNames)
            {
                if (Enum.TryParse(moduleName.Trim(), true, out ModuleType moduleType))
                {
                    modules.Add(moduleType);
                }
                else
                {
                    if (_logger.IsWarn)
                    {
                        _logger.Warn($"Incorrect JSON RPC module: {moduleName}");
                    }
                }
            }

            return(modules);
        }
コード例 #2
0
        public Task Start(CancellationToken cancellationToken)
        {
            IEnumerable <string> GetUrls()
            {
                const string nethermindUrlVariable = "NETHERMIND_URL";
                string       host        = _jsonRpcConfig.Host;
                string       scheme      = "http";
                var          defaultUrl  = $"{scheme}://{host}:{_jsonRpcConfig.Port}";
                var          urlVariable = Environment.GetEnvironmentVariable(nethermindUrlVariable);
                string       url         = defaultUrl;

                if (!string.IsNullOrWhiteSpace(urlVariable))
                {
                    if (Uri.TryCreate(urlVariable, UriKind.Absolute, out var uri))
                    {
                        url    = urlVariable;
                        host   = uri.Host;
                        scheme = uri.Scheme;
                    }
                    else
                    {
                        if (_logger.IsWarn)
                        {
                            _logger.Warn($"Environment variable '{nethermindUrlVariable}' value '{urlVariable}' is not valid JSON RPC URL, using default url : '{defaultUrl}'");
                        }
                    }
                }

                yield return(url);

                if (_initConfig.WebSocketsEnabled && _jsonRpcConfig.WebSocketsPort != _jsonRpcConfig.Port)
                {
                    yield return($"{scheme}://{host}:{_jsonRpcConfig.WebSocketsPort}");
                }
            }

            if (_logger.IsDebug)
            {
                _logger.Debug("Initializing JSON RPC");
            }
            var urls    = GetUrls().ToArray();
            var webHost = WebHost.CreateDefaultBuilder()
                          .ConfigureServices(s =>
            {
                s.AddSingleton(_configurationProvider);
                s.AddSingleton(_jsonRpcProcessor);
                s.AddSingleton(_webSocketsManager);
            })
                          .UseStartup <Startup>()
                          .UseUrls(urls)
                          .ConfigureLogging(logging =>
            {
                logging.SetMinimumLevel(LogLevel.Information);
                logging.ClearProviders();
                logging.AddProvider(new CustomMicrosoftLoggerProvider(_logManager));
            })
                          .Build();

            string urlsString = string.Join(" ; ", urls);

            ThisNodeInfo.AddInfo("JSON RPC     :", $"{urlsString}");
            ThisNodeInfo.AddInfo("RPC modules  :", $"{string.Join(", ", _moduleProvider.Enabled.OrderBy(x => x))}");

            _webHost = webHost;

            if (!cancellationToken.IsCancellationRequested)
            {
                _webHost.Start();
                if (_logger.IsDebug)
                {
                    _logger.Debug($"JSON RPC     : {urlsString}");
                }
                if (_logger.IsDebug)
                {
                    _logger.Debug($"RPC modules  : {string.Join(", ", _moduleProvider.Enabled.OrderBy(x => x))}");
                }
            }

            return(Task.CompletedTask);
        }