public CatalystNodePoa(IKeySigner keySigner, IPeerService peer, IConsensus consensus, IDfs dfs, ILedger ledger, ILogger logger, IRpcServer rpcServer, IPeerClient peerClient, IPeerSettings peerSettings, IMempool <TransactionBroadcastDao> mempool, IContract contract = null) { _peer = peer; _peerClient = peerClient; _peerSettings = peerSettings; Consensus = consensus; _dfs = dfs; _ledger = ledger; _keySigner = keySigner; _logger = logger; _rpcServer = rpcServer; _mempool = mempool; _contract = contract; _privateKey = keySigner.KeyStore.KeyStoreDecrypt(KeyRegistryTypes.DefaultKey); _publicKey = keySigner.CryptoContext.GetPublicKey(_privateKey); }
public WebHostLanguageWorkerChannelManagerTests() { _eventManager = new ScriptEventManager(); _rpcServer = new TestRpcServer(); _loggerProvider = new TestLoggerProvider(); _loggerFactory = new LoggerFactory(); _testEnvironment = new TestEnvironment(); _loggerFactory.AddProvider(_loggerProvider); _languageWorkerProcess = new Mock <ILanguageWorkerProcess>(); _languageWorkerOptions = new LanguageWorkerOptions { WorkerConfigs = TestHelpers.GetTestWorkerConfigs() }; var applicationHostOptions = new ScriptApplicationHostOptions { IsSelfHost = true, ScriptPath = @"c:\testing\FUNCTIONS-TEST\test$#" }; _optionsMonitor = TestHelpers.CreateOptionsMonitor(applicationHostOptions); _languageWorkerProcessFactory = new Mock <ILanguageWorkerProcessFactory>(); _languageWorkerProcessFactory.Setup(m => m.CreateLanguageWorkerProcess(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())).Returns(_languageWorkerProcess.Object); _languageWorkerChannelFactory = new TestLanguageWorkerChannelFactory(_eventManager, null, _scriptRootPath); _languageWorkerChannelManager = new WebHostLanguageWorkerChannelManager(_eventManager, _testEnvironment, _loggerFactory, _languageWorkerChannelFactory, _optionsMonitor); }
/// <summary> /// 启动RPC服务器 /// </summary> /// <returns></returns> public static bool StartRpcServer(string remoteIp, int remotePort, string localIp, int localPort) { _remoteIp = remoteIp; _remotePort = remotePort; _localIp = localIp; _localPort = localPort; System.Reflection.Assembly.Load("Sys.Safety.WebApi, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"); int rpcModel = Basic.Framework.Configuration.ConfigurationManager.FileConfiguration.GetInt("RpcModel", 1); if (rpcModel == 1) { _rpcModel = RpcModel.WebApiModel; } else if (rpcModel == 2) { _rpcModel = RpcModel.gRPCModel; } _client = RpcFactory.CreateRpcClient(_rpcModel, _remoteIp, _remotePort); _server = RpcFactory.CreateRpcServer(_rpcModel); _server.RegistCallback(OnRpcMessageArrived); _server.Start(_localIp, _localPort); return(true); }
public LanguageWorkerChannelManager(IScriptEventManager eventManager, IEnvironment environment, IRpcServer rpcServer, ILoggerFactory loggerFactory, IOptions <LanguageWorkerOptions> languageWorkerOptions, IOptionsMonitor <ScriptApplicationHostOptions> applicationHostOptions, ILanguageWorkerConsoleLogSource consoleLogSource) { _rpcServer = rpcServer; _environment = environment ?? throw new ArgumentNullException(nameof(environment)); _eventManager = eventManager; _loggerFactory = loggerFactory; _logger = loggerFactory.CreateLogger(ScriptConstants.LogCategoryLanguageWorkerChannelManager); _workerConfigs = languageWorkerOptions.Value.WorkerConfigs; _applicationHostOptions = applicationHostOptions; _consoleLogSource = consoleLogSource; _processFactory = new DefaultWorkerProcessFactory(); try { _processRegistry = ProcessRegistryFactory.Create(); } catch (Exception e) { _logger.LogWarning(e, "Unable to create process registry"); } _shutdownStandbyWorkerChannels = ScheduleShutdownStandbyChannels; _shutdownStandbyWorkerChannels = _shutdownStandbyWorkerChannels.Debounce(5000); _rpcChannelReadySubscriptions = _eventManager.OfType <RpcWebHostChannelReadyEvent>() .Subscribe(AddOrUpdateWorkerChannels); }
static async Task Main(string[] args) { try { Console.WriteLine("Hello World!"); Address _address = new Address(host: "", port: 5672, user: "", password: "", scheme: "amqp"); ConnectionFactory _connFactory = new ConnectionFactory(); //_connFactory.SSL.ClientCertificates Connection _connection = await _connFactory.CreateAsync(_address); var _amqpClient = new AmqpClient(); _amqpClient.InitiateAmqpRpc(connection: _connection); IRpcServer _rpcServer = _amqpClient.CreateAmqpRpcServer(amqpNode: "amq.topic/test"); _rpcServer.Bind(); var _logger = new LoggerConfiguration() .WriteTo.AmqpSink(_connection, new AmqpConfiguration() { QueueName = "amq.topic/test" }, textFormatter: new CustomFormatter(customerId: "Test")) .CreateLogger(); _logger.Information("Hello world, this is my first log line over amqp"); } catch (Exception ex) { Console.WriteLine(ex); } Console.ReadLine(); }
/// <summary> /// Constructor /// </summary> /// <param name="rpc">Rpc</param> /// <param name="blockSigner">Block signer</param> /// <param name="txSigner">Tx signer</param> /// <param name="consoleHandler">Console handler</param> public PromptRpcController(IRpcServer rpc, ISigner <BlockHeader> blockSigner, ISigner <Transaction> txSigner, IConsoleHandler consoleHandler) { _rpc = rpc; _blockSigner = blockSigner; _txSigner = txSigner; _consoleHandler = consoleHandler; }
public void ProcessRequest(HttpContext context) { if (server == null) { lock (lockObj) { if (server == null) { server = new RpcServer(); this.InitRpcServer(server); (server as RpcServer).Start(); } } } IRpcHttpContext ctx = new WebHost.SystemWebHttpContext(context); if (!string.IsNullOrEmpty(ctx.Request.UserAgent) && ctx.Request.UserAgent.IndexOf("RpcOverHttp", StringComparison.OrdinalIgnoreCase) != -1) { context.Response.TrySkipIisCustomErrors = true; server.ProcessRequest(ctx); } else if (ctx.IsWebSocketRequest) { ctx.AcceptWebSocket(server.ProcessWebsocketRequest); } }
public RpcInitializationService(IOptionsMonitor <ScriptApplicationHostOptions> applicationHostOptions, IEnvironment environment, IRpcServer rpcServer, ILanguageWorkerChannelManager languageWorkerChannelManager, ILoggerFactory loggerFactory) { _applicationHostOptions = applicationHostOptions ?? throw new ArgumentNullException(nameof(applicationHostOptions)); _logger = loggerFactory.CreateLogger(ScriptConstants.LogCategoryRpcInitializationService); _rpcServer = rpcServer; _environment = environment; _languageWorkerChannelManager = languageWorkerChannelManager ?? throw new ArgumentNullException(nameof(languageWorkerChannelManager)); }
public static IOwned <RpcObjectRef <TService> > PublishInstance <TService>(this IRpcServer server, IOwned <TService> serviceInstance) where TService : class { if (server is null) { throw new ArgumentNullException(nameof(server)); } return(server.ServicePublisher.PublishInstance(serviceInstance)); }
public static IOwned <RpcObjectRef <TService> > PublishInstance <TService>(this IRpcServer server, TService serviceInstance, bool takeOwnership = false) where TService : class { if (server is null) { throw new ArgumentNullException(nameof(server)); } return(server.ServicePublisher.PublishInstance(takeOwnership ? OwnedObject.Create(serviceInstance) : OwnedObject.CreateUnowned(serviceInstance))); }
public static RpcObjectRef <TService>?GetPublishedServiceInstance <TService>(this IRpcServer server, TService serviceInstance) where TService : class { if (server is null) { throw new ArgumentNullException(nameof(server)); } return(server.ServicePublisher.GetPublishedInstance(serviceInstance)); }
public static void UnpublishSingleton <TService>(this IRpcServer server) where TService : class { if (server is null) { throw new ArgumentNullException(nameof(server)); } server.ServicePublisher.UnpublishSingleton <TService>(); }
public static void UnpublishInstance(this IRpcServer server, RpcObjectId serviceInstanceId) { if (server is null) { throw new ArgumentNullException(nameof(server)); } server.ServicePublisher.UnpublishInstance(serviceInstanceId); }
public RpcInitializationService(IOptionsMonitor <ScriptApplicationHostOptions> applicationHostOptions, IEnvironment environment, IRpcServer rpcServer, IWebHostLanguageWorkerChannelManager languageWorkerChannelManager, ILogger <RpcInitializationService> logger) { _applicationHostOptions = applicationHostOptions ?? throw new ArgumentNullException(nameof(applicationHostOptions)); _logger = logger; _rpcServer = rpcServer; _environment = environment; _languageWorkerChannelManager = languageWorkerChannelManager ?? throw new ArgumentNullException(nameof(languageWorkerChannelManager)); _workerRuntime = _environment.GetEnvironmentVariable(LanguageWorkerConstants.FunctionWorkerRuntimeSettingName); }
public RpcInitializationService(IOptionsMonitor <ScriptApplicationHostOptions> applicationHostOptions, IEnvironment environment, IRpcServer rpcServer, IWebHostRpcWorkerChannelManager rpcWorkerChannelManager, ILogger <RpcInitializationService> logger) { _applicationHostOptions = applicationHostOptions ?? throw new ArgumentNullException(nameof(applicationHostOptions)); _logger = logger; _rpcServer = rpcServer; _environment = environment; _rpcServerShutdownTimeoutInMilliseconds = 5000; _webHostRpcWorkerChannelManager = rpcWorkerChannelManager ?? throw new ArgumentNullException(nameof(rpcWorkerChannelManager)); _workerRuntime = _environment.GetEnvironmentVariable(RpcWorkerConstants.FunctionWorkerRuntimeSettingName); _placeholderLanguageWorkersList = _environment.GetLanguageWorkerListToStartInPlaceholder(); }
public FunctionRegistry( IScriptEventManager manager, IRpcServer server, CreateChannel channelFactory, IEnumerable <WorkerConfig> workers) { _eventManager = manager; _server = server; _channelFactory = channelFactory; _workerConfigs = workers?.ToList() ?? new List <WorkerConfig>(); _workerErrorSubscription = _eventManager.OfType <WorkerErrorEvent>() .Subscribe(WorkerError); }
/// <summary> /// Constructor /// </summary> /// <param name="consoleReaderInit">Console reader init</param> /// <param name="consoleWriterInit">Console writer init</param> /// <param name="logger">Logger</param> /// <param name="networkManagerInit">Network manger init</param> /// <param name="serverInit">Server</param> /// <param name="rpcInit">Rpc server</param> /// <param name="serializer">Binary serializer</param> /// <param name="blockchain">Blockchain</param> public Prompt(IConsoleReader consoleReaderInit, IConsoleWriter consoleWriterInit, ILogger <Prompt> logger, INetworkManager networkManagerInit, IServer serverInit, IRpcServer rpcInit, IBinarySerializer serializer, IBlockchain blockchain) { _consoleReader = consoleReaderInit; _consoleWriter = consoleWriterInit; _logger = logger; _networkManager = networkManagerInit; _server = serverInit; _serializer = serializer; _rpc = rpcInit; _blockchain = blockchain; }
protected bool StartSlave() { // Create Rpc server _slaveServer = new RpcServer().Create(_slaveEndpoint, _port); // Start Rpc server var t = Task.Run(() => _slaveServer.Start()); Task.Delay(TimeSpan.FromSeconds(5)); if (t.IsFaulted) { return(false); } return(true); }
public FunctionDispatcher( IScriptEventManager manager, IRpcServer server, CreateChannel channelFactory, IEnumerable <WorkerConfig> workerConfigs, string language) { _eventManager = manager; _server = server; _channelFactory = channelFactory; _language = language; _workerConfigs = workerConfigs ?? throw new ArgumentNullException("workerConfigs"); _workerErrorSubscription = _eventManager.OfType <WorkerErrorEvent>() .Subscribe(WorkerError); }
public LanguageWorkerProcessFactory(IRpcServer rpcServer, IOptions <LanguageWorkerOptions> languageWorkerOptions, IScriptEventManager eventManager, ILoggerFactory loggerFactory, IWorkerProcessFactory defaultWorkerProcessFactory, IProcessRegistry processRegistry, ILanguageWorkerConsoleLogSource consoleLogSource) { _loggerFactory = loggerFactory; _eventManager = eventManager; _rpcServer = rpcServer; _workerConfigs = languageWorkerOptions.Value.WorkerConfigs; _consoleLogSource = consoleLogSource; _workerProcessFactory = defaultWorkerProcessFactory; _processRegistry = processRegistry; }
public async Task CloseRpcServerAsync(string amqpNode) { IRpcServer _server = null; if (this._serverMap.TryGetValue(amqpNode, out _server)) { if (_server != null) { await _server.DestroyAsync(); } } if (this._serverMap.ContainsKey(amqpNode)) { this._serverMap.Remove(amqpNode); } }
public RpcWorkerProcessFactory(IRpcServer rpcServer, IScriptEventManager eventManager, ILoggerFactory loggerFactory, IWorkerProcessFactory defaultWorkerProcessFactory, IProcessRegistry processRegistry, IWorkerConsoleLogSource consoleLogSource, IMetricsLogger metricsLogger) { _loggerFactory = loggerFactory; _eventManager = eventManager; _rpcServer = rpcServer; _consoleLogSource = consoleLogSource; _workerProcessFactory = defaultWorkerProcessFactory; _processRegistry = processRegistry; _metricsLogger = metricsLogger; }
internal async Task InitializeRpcServiceAsync(IRpcServer rpcService) { _rpcService = rpcService; using (_metricsLogger.LatencyEvent(MetricEventNames.HostStartupGrpcServerLatency)) { try { await _rpcService.StartAsync(); } catch (Exception grpcInitEx) { throw new HostInitializationException($"Failed to start Grpc Service. Check if your app is hitting connection limits.", grpcInitEx); } } }
public RpcInitializationServiceTests() { _rootPath = Path.GetTempPath(); _mockLanguageWorkerChannelManager = new Mock <ILanguageWorkerChannelManager>(); _loggerFactory = new LoggerFactory(); _testRpcServer = new TestRpcServer(); var applicationHostOptions = new ScriptApplicationHostOptions { IsSelfHost = true, ScriptPath = _rootPath }; _optionsMonitor = TestHelpers.CreateOptionsMonitor(applicationHostOptions); _mockLanguageWorkerChannelManager.Setup(m => m.InitializeChannelAsync(It.IsAny <string>())) .Returns(Task.CompletedTask); }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IWebHostEnvironment env, IRpcServer server, IReceiver receiver) { if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } app.UseHttpsRedirection(); app.UseRouting(); app.UseCors(builder => builder.AllowAnyOrigin().AllowAnyHeader().AllowAnyMethod()); app.UseAuthorization(); app.UseEndpoints(endpoints => { endpoints.MapControllers(); }); }
public LanguageWorkerChannelManagerTests() { _eventManager = new ScriptEventManager(); _rpcServer = new TestRpcServer(); _loggerProvider = new TestLoggerProvider(); _loggerFactory = new LoggerFactory(); _testEnvironment = new TestEnvironment(); _loggerFactory.AddProvider(_loggerProvider); _languageWorkerOptions = new LanguageWorkerOptions { WorkerConfigs = TestHelpers.GetTestWorkerConfigs() }; var applicationHostOptions = new ScriptApplicationHostOptions { IsSelfHost = true, ScriptPath = @"c:\testing\FUNCTIONS-TEST\test$#" }; _optionsMonitor = TestHelpers.CreateOptionsMonitor(applicationHostOptions); }
public IRpcServer CreateAmqpRpcServer(string amqpNode) { if (this._connection == null) { throw new Exception("Please initiate connection using InitiateAmqpRpc"); } if (this._session == null) { throw new Exception("Please initiate session using InitiateAmqpRpc"); } IRpcServer _server = null; if (!this._serverMap.TryGetValue(amqpNode, out _server)) { _server = new RpcServer(amqpNode, this._session); _server.Create(); this._serverMap.Add(amqpNode, _server); } return(_server); }
/// <summary> /// 广播消息 /// </summary> /// <param name="request">请求消息</param> /// <param name="requestContext">请求目标集合</param> /// <returns>响应消息集合</returns> public ICollection <RpcTransportMessageResponse> BroadcastMessage( RpcTransportMessageRequest request, IEnumerable <IRpcMessageSenderContext> requestContext, out ICollection <RpcTransportErrorResponse> errorResponse) { List <RpcTransportMessageResponse> allResultMessage = new List <RpcTransportMessageResponse>(); List <RpcTransportErrorResponse> allErrorResponse = new List <RpcTransportErrorResponse>(); foreach (var ctxGrp in requestContext.GroupBy(ctx => ctx.RpcType)) { IRpcServer rpcServer = rpcServers.FirstOrDefault(server => server.RpcType == ctxGrp.Key); IList <IRpcMessageSenderContext> requestContextGroup = ctxGrp.ToList(); ICollection <RpcTransportErrorResponse> errorMessageGroup = null; ICollection <RpcTransportMessageResponse> resultMessageGroup = rpcServer.BroadcastMessage(request, requestContextGroup, out errorMessageGroup); allResultMessage.AddRange(resultMessageGroup); if (errorMessageGroup != null) { allErrorResponse.AddRange(errorMessageGroup); } } errorResponse = allErrorResponse; return(allResultMessage); }
public async Task <int> Execute() { // service mode if (LogLvl.HasValue) { GlobalSettings.LogLevel.Value = LogLvl.Value; } Console.Title = "gsudo Service"; Logger.Instance.Log("Service started", LogLevel.Info); using (IRpcServer server = CreateServer()) { ShutdownTimer = new Timer((o) => server.Close()); server.ConnectionAccepted += async(o, connection) => await AcceptConnection(connection).ConfigureAwait(false); server.ConnectionClosed += (o, cònnection) => EnableTimer(); await server.Listen().ConfigureAwait(false); } Logger.Instance.Log("Service stopped", LogLevel.Info); return(0); }
public async Task <int> Execute() { // service mode if (LogLvl.HasValue) { Settings.LogLevel.Value = LogLvl.Value; } Console.Title = "gsudo Service"; var cacheLifetime = new CredentialsCacheLifetimeManager(AllowedPid); Logger.Instance.Log("Service started", LogLevel.Info); using (IRpcServer server = CreateServer()) { try { cacheLifetime.OnCacheClear += server.Close; ShutdownTimer = new Timer((o) => server.Close(), null, Timeout.Infinite, Timeout.Infinite); // 10 seconds for initial connection or die. server.ConnectionAccepted += (o, connection) => AcceptConnection(connection).ConfigureAwait(false).GetAwaiter().GetResult(); server.ConnectionClosed += (o, connection) => EnableTimer(); Logger.Instance.Log($"Service will shutdown if idle for {CacheDuration}", LogLevel.Debug); EnableTimer(); await server.Listen().ConfigureAwait(false); } catch (System.OperationCanceledException) { } finally { cacheLifetime.OnCacheClear -= server.Close; } } Logger.Instance.Log("Service stopped", LogLevel.Info); return(0); }
public Service(IRpcServer rpcServer) { _rpcServer = rpcServer; }