private static async Task <int> StartBrokerAsync(StartCliOptions opts) { var brokerOptions = new BrokerOptions(opts.Metadata, opts.Port); var program = new BrokerProgram(brokerOptions); return(await LoadAndRunProgramAsync(program).ConfigureAwait(false)); }
protected virtual void Init(BrokerOptions options) { _service.AddSingleton(options); switch (options.StorageType) { case StorageType.MySql: { _service.AddScoped <INodeService, Services.MySql.NodeService>(); _service.AddScoped <IRunningService, Services.MySql.RunningService>(); _service.AddScoped <IBlockService, Services.MySql.BlockService>(); _service.AddScoped <IRunningHistoryService, Services.MySql.RunningHistoryService>(); _service.AddSingleton <IRequestQueueService, Services.MySql.RequestQueueService>(); break; } case StorageType.SqlServer: { _service.AddScoped <INodeService, Services.NodeService>(); _service.AddScoped <IRunningService, Services.RunningService>(); _service.AddScoped <IBlockService, Services.BlockService>(); _service.AddScoped <IRunningHistoryService, Services.RunningHistoryService>(); _service.AddScoped <IRunningHistoryService, Services.RunningHistoryService>(); _service.AddSingleton <IRequestQueueService, Services.RequestQueueService>(); break; } } _service.AddLogging(); Services = _service.BuildServiceProvider(); }
public RequestQueueController(ILogger <BrokerController> logger, BrokerOptions options, IRequestQueueService requestQueueService, IBlockService blockService) : base(logger, options) { _requestQueueService = requestQueueService; _blockService = blockService; }
public RunningServiceTest() { var options = new BrokerOptions { ConnectionString = "Server=.\\SQLEXPRESS;Database=DotnetSpider_Dev;Integrated Security = SSPI;", StorageType = StorageType.SqlServer, Tokens = new HashSet <string> { "aaa" }, UseToken = false }; Init(options); }
public BrokerReceiver(IActorRef self, BrokerOptions options, string queueName) { _options = options; _self = self; // bind channel to the broker _channel = BindChannel(); // setup queue and exchange SetupQueue(queueName); // setup consumer SetupConsumer(queueName); }
public BrokerReceiverActor(ILogger <BrokerReceiverActor> logger, IOptions <BrokerOptions> options) { _logger = logger; _options = options.Value; _broker = new BrokerReceiver(Self, _options, Guid.NewGuid().ToString()); Receive <MessageReceived>(msg => { _logger.LogDebug("Got MessageReceived"); Context.Parent.Tell(msg); }); }
public static IServiceCollection AddDeviceMessagesProcessor(this IServiceCollection services, string iotConnectionString) { services.AddScoped(provider => { var brokerOptions = new BrokerOptions { ConnectionString = string.Empty, SubscriptionName = iotConnectionString }; var iotMessageProcessorFactory = new IoTEventProcessorFactory <ThermometerValuesUpdated>(brokerOptions); return(iotMessageProcessorFactory.DomainEventProcessorAsync); }); return(services); }
public static ConnectionFactory CreateConnection(BrokerOptions options) { ConnectionFactory factory = new ConnectionFactory() { HostName = options.HostName, Port = AmqpTcpEndpoint.UseDefaultPort, VirtualHost = ConnectionFactory.DefaultVHost }; if (!string.IsNullOrEmpty(options.UserName)) { factory.UserName = options.UserName; } if (!string.IsNullOrEmpty(options.Password)) { factory.Password = options.Password; } return(factory); }
public Broker(BrokerOptions options, IRegistryProvider registryProvider = null) { _workingDir = Directory.GetCurrentDirectory(); var binDir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); var studioDir = Path.Combine(binDir, "studio"); Log.Info("Studio dir: {0}", studioDir); var metadataDir = Path.GetFullPath(options.MetadataDir ?? Path.Combine(_workingDir, "metadata")); Log.Info("Metadata dir: {0}", metadataDir); var metadataFile = Path.Combine(metadataDir, "interop.json"); var webSocketTransmissionServerOptions = new WebSocketTransmissionServerOptions( _workingDir, options.Port, new Dictionary <string, string> { { "/metadata/interop", metadataFile }, { "/studio", studioDir } }); _transportServers = new[] { TransportServerFactory.Instance.Create( PipeTransmissionServerFactory.Instance.Create(_workingDir), DefaultTransportSerializationProvider), TransportServerFactory.Instance.Create( WebSocketTransmissionServerFactory.Instance.Create(webSocketTransmissionServerOptions), DefaultTransportSerializationProvider) }; _connectionListener = new ServerConnectionListener(_transportServers); registryProvider = registryProvider ?? JsonRegistryProvider.Initialize(Path.Combine(metadataDir, "interop.json")); _appLifecycleManager = AppLifecycleManagerFactory.Instance.Create(metadataDir); _brokerProcessor = BrokerProcessorFactory.Instance.Create( _connectionListener.In, registryProvider, DefaultProtocolSerializationProvider, _appLifecycleManager); OnStop(_connectionListener.Stop); }
public BrokerSenderActor(ILogger <BrokerSenderActor> logger, IOptions <BrokerOptions> options, IBrokerSender brokerSender) { try { _logger = logger; _options = options.Value; _brokerSender = brokerSender; _logger.LogDebug("Starting broker sender actor"); Receive <SendMessage>(msg => { _logger.LogDebug("Got SendMessage"); _brokerSender.Publish(msg.Payload); }); } catch (Exception ex) { _logger.LogError(ex, "error while starting brokersenderactor"); } }
public JobController(ILogger <JobController> logger, BrokerOptions options) : base(logger, options) { }
protected RequestQueueService(BrokerOptions options, ILogger <BlockService> logger) : base(options, logger) { }
public BrokerSender(IOptions <BrokerOptions> options) { _options = options.Value; _channel = BindChannel(); }
public BrokerProgram(BrokerOptions options) { _options = options; }
protected BaseService(BrokerOptions options, ILogger <BaseService> logger) { _options = options; _logger = logger; }
public BlockService(BrokerOptions options, IRunningService runningService, IRequestQueueService requestQueueService, ILogger <BlockService> logger) : base(options, logger) { _runningService = runningService; _requestQueueService = requestQueueService; }
public Initializer(BrokerOptions options, IRunningService runningService, IRunningHistoryService runningHistoryService, ILogger <Initializer> logger) : base(options, logger) { _runningService = runningService; _runningHistoryService = runningHistoryService; }
public Broker(BrokerOptions options, IRegistryProvider registryProvider = null) { _features = EnvironmentHelper.GetBrokerFeatures(); Log.Info($"Broker features: {_features}"); var trustedLauncherId = EnvironmentHelper.GetLauncherAppInstanceId(); Log.Info($"App launcher application instance id: {trustedLauncherId}"); if (_features.HasFlag(BrokerFeatures.CheckAppInstanceId) && trustedLauncherId == null) { throw new BrokerException($"{EnvironmentHelper.LauncherId} must be defined if {BrokerFeatures.CheckAppInstanceId} set."); } _workingDir = Directory.GetCurrentDirectory(); var binDir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); var studioDir = Path.Combine(binDir, "studio"); Log.Info("Studio dir: {0}", studioDir); var metadataDir = Path.GetFullPath(options.MetadataDir ?? Path.Combine(_workingDir, "metadata")); Log.Info("Metadata dir: {0}", metadataDir); var metadataFile = Path.Combine(metadataDir, "interop.json"); IReadOnlyDictionary <string, string> staticFileMapping = new Dictionary <string, string> { { "/metadata/interop", metadataFile }, { "/studio", studioDir } }; var webSocketTransmissionServerOptions = new WebSocketTransmissionServerOptions(_workingDir, options.Port, staticFileMapping); var transportServers = new List <ITransportServer> { TransportServerFactory.Instance.Create( TransportType.Pipe, PipeTransmissionServerFactory.Instance.Create(_workingDir), DefaultTransportSerializationProvider), TransportServerFactory.Instance.Create( TransportType.Ws, WebSocketTransmissionServerFactory.Instance.Create(webSocketTransmissionServerOptions), DefaultTransportSerializationProvider), }; if (_features.HasFlag(BrokerFeatures.UseWSS)) { var certificate = GetCertificate(); if (certificate != null) { var wssTransmissionServerOptions = new WebSocketTransmissionServerOptions(_workingDir, options.WssPort, staticFileMapping); var sslProtocols = EnvironmentHelper.GetSslProtocols(); Log.Info($"{EnvironmentHelper.SslProtocols}={sslProtocols}"); transportServers.Add(TransportServerFactory.Instance.Create( TransportType.Wss, WebSocketTransmissionServerFactory.Instance.CreateSecure(wssTransmissionServerOptions, certificate, sslProtocols), DefaultTransportSerializationProvider)); } } _transportServers = transportServers; _connectionListener = new ServerConnectionListener(_transportServers); registryProvider = registryProvider ?? new JsonRegistryProvider(Path.Combine(metadataDir, "interop.json")); _interopContext = InteropContextFactory.Instance.Create(trustedLauncherId ?? default, metadataDir, registryProvider); _brokerProcessor = BrokerProcessorFactory.Instance.Create( _connectionListener.In, DefaultProtocolSerializationProvider, _interopContext, _features); OnStop(_connectionListener.Stop); }
public NodeController(ILogger <NodeController> logger, BrokerOptions options, INodeService nodeService, IBlockService blockService) : base(logger, options) { _nodeService = nodeService; _blockService = blockService; }
public NodeService(BrokerOptions options, ILogger <BlockService> logger) : base(options, logger) { }
public BrokerController(ILogger <BrokerController> logger, BrokerOptions options) { _logger = logger; _options = options; }
public RunningService(BrokerOptions options, ILogger <BlockService> logger) : base(options, logger) { }