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;
}