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)
{
}
