public RequestManager(IConnectionFactory connectionFactory, ISenderProcessor senderProcessor, ISubscriptionFactory subsctiptionFactory, int timeToWait)
{
_connectionFactory = connectionFactory;
_senderProcessor = senderProcessor;
_subsctiptionFactory = subsctiptionFactory;
_timeToWait = timeToWait;
}
/// <summary>
/// Instantiates a <see cref="SubscriptionManager"/>
/// </summary>
/// <param name="logger"></param>
/// <param name="repository"></param>
/// <param name="subscriptionFactory"></param>
public SubscriptionManager(ILog logger, IMarketDataRepository repository, ISubscriptionFactory subscriptionFactory)
{
_logger = logger;
_repository = repository;
_subscriptionFactory = subscriptionFactory;
// set up timer - wait five minutes, then update data every minute
_dataUpdateTimer = new Timer(UpdateSubscriptionData);
}
/// <summary>
/// Instantiates a <see cref="SubscriptionManager"/>
/// </summary>
/// <param name="logger"></param>
/// <param name="repository"></param>
/// <param name="subscriptionFactory"></param>
public SubscriptionManager(ILog logger, IMarketDataRepository repository, ISubscriptionFactory subscriptionFactory)
{
_logger = logger;
_repository = repository;
_subscriptionFactory = subscriptionFactory;
// set up timer - wait five minutes, then update data every minute
_dataUpdateTimer = new Timer(UpdateSubscriptionData);
}
internal ParseLiveQueryClient(Uri hostUri, WebSocketClientFactory webSocketClientFactory,
ISubscriptionFactory subscriptionFactory, ITaskQueue taskQueue)
{
_hostUri = hostUri;
_applicationId = ParseClient.CurrentConfiguration.ApplicationId;
_webSocketClientFactory = webSocketClientFactory;
_webSocketClientCallback = new WebSocketClientCallback(this);
_subscriptionFactory = subscriptionFactory;
_taskQueue = taskQueue;
}
internal ParseLiveQueryClient(Uri hostUri, WebSocketClientFactory webSocketClientFactory,
ISubscriptionFactory subscriptionFactory, ITaskQueue taskQueue)
{
_hostUri = hostUri;
_applicationId = ParseClient.Instance.Services.ServerConnectionData.ApplicationID;
_webSocketClientFactory = webSocketClientFactory;
_webSocketClientCallback = new WebSocketClientCallback(this);
_subscriptionFactory = subscriptionFactory;
_taskQueue = taskQueue;
}
public BusConfigurationBuilder(IQueueFactory queueFactory, ITopicFactory topicFactory, ISubscriptionFactory subscriptionFactory)
{
_queueFactory = queueFactory;
_topicFactory = topicFactory;
_subscriptionFactory = subscriptionFactory;
_queuesRequiringCreation = new List <IQueueInstance>();
_eventsRequiringCreation = new List <Type>();
_eventSubscriptions = new List <EventSubscription>();
}
public SubscriptionObservable(ILogger <ManagedObservable <T> > logger,
ISubscriptionFactory <T> subscriptionFactory) : base(logger)
{
if (subscriptionFactory == null)
{
throw new ArgumentNullException(nameof(subscriptionFactory));
}
_subscriptionClient = subscriptionFactory.Create();
_subscriptionClient.RegisterCallback(Notify);
}
public Bus(
IModelFactory modelFactory,
IConsumerFactory consumerFactory,
IRequesterFactory requesterFactory,
IPublisherFactory publisherFactory,
ISubscriptionFactory subscriptionFactory)
{
this.modelFactory = modelFactory;
this.publisherFactory = publisherFactory;
this.requesterFactory = requesterFactory;
this.subscriptionFactory = subscriptionFactory;
this.consumerFactory = consumerFactory;
}
public static async Task <Subscriptions> ForAsync(ISubscriptionFactory subscriptionFactory, IList <EventSubscription> eventSubscriptions)
{
var tasks = eventSubscriptions
.Select(e => subscriptionFactory.FromAsync(e.EventType, e.SubscriptionName))
.ToList();
await Task.WhenAll(tasks);
var subscriptions = tasks
.Select(task => task.Result)
.ToList();
return(new Subscriptions(subscriptions));
}
public SubscriptionStartCommandFromApi(
NewSubscriptionParametersDto parameters,
AssetAccessAuthorization authorizationStructure,
SubscriptionStartResponseBuilder responseBuilder,
ISubscriptionFactory subscriptionFactory,
SubscriptionsModifyOperations subscriptions,
List <AssetQuery> assetQueries)
{
_parameters = parameters;
_authorizationStructure = authorizationStructure;
_responseBuilder = responseBuilder;
_subscriptionFactory = subscriptionFactory;
_subscriptions = subscriptions;
_assetQueries = assetQueries;
}
public CommandFactory(
SubscriptionsModifyOperations subscriptions,
AuthorizationStructure authorizationStructure,
ISubscriptionFactory subscriptionFactory,
SubscriptionDataCorrectnessCriteria dataCorrectnessCriteria,
IAssetQueriesFactory assetQueriesFactory,
Log log)
{
_subscriptions = subscriptions;
_authorizationStructure = authorizationStructure;
_subscriptionFactory = subscriptionFactory;
_dataCorrectnessCriteria = dataCorrectnessCriteria;
_assetQueriesFactory = assetQueriesFactory;
_log = log;
}
private void AttachEventHandlers(ISubscriptionFactory factory, SubscriptionDataSource source)
{
// handle missing files
factory.InvalidSource += (sender, args) =>
{
switch (args.Source.TransportMedium)
{
case SubscriptionTransportMedium.LocalFile:
// the local uri doesn't exist, write an error and return null so we we don't try to get data for today
Log.Trace(string.Format("SubscriptionDataReader.GetReader(): Could not find QC Data, skipped: {0}", source));
_resultHandler.SamplePerformance(_tradeableDates.Current, 0);
break;
case SubscriptionTransportMedium.RemoteFile:
_resultHandler.ErrorMessage(string.Format("Error downloading custom data source file, skipped: {0} Error: {1}", source, args.Exception.Message), args.Exception.StackTrace);
_resultHandler.SamplePerformance(_tradeableDates.Current.Date, 0);
break;
case SubscriptionTransportMedium.Rest:
break;
default:
throw new ArgumentOutOfRangeException();
}
};
if (factory is TextSubscriptionFactory)
{
// handle empty files/instantiation errors
var textSubscriptionFactory = (TextSubscriptionFactory)factory;
textSubscriptionFactory.CreateStreamReaderError += (sender, args) =>
{
Log.Error(string.Format("Failed to get StreamReader for data source({0}), symbol({1}). Skipping date({2}). Reader is null.", args.Source.Source, _mappedSymbol, args.Date.ToShortDateString()));
if (_config.IsCustomData)
{
_resultHandler.ErrorMessage(string.Format("We could not fetch the requested data. This may not be valid data, or a failed download of custom data. Skipping source ({0}).", args.Source.Source));
}
};
// handle parser errors
textSubscriptionFactory.ReaderError += (sender, args) =>
{
_resultHandler.RuntimeError(string.Format("Error invoking {0} data reader. Line: {1} Error: {2}", _config.Symbol, args.Line, args.Exception.Message), args.Exception.StackTrace);
};
}
}
public SharedClusterWorker(
ILogger <SharedClusterWorker> logger,
IClusterSettings clusterSettings,
IDescriptorProvider descriptorProvider,
ISharedClusterProviderFactory clusterProvider,
ISharedSetupRootActors setupRootActors = default,
ISubscriptionFactory subscriptionFactory = default,
IMainWorker mainWorker = default,
IMetricsProvider metricsProvider = default
)
{
_logger = logger;
_setupRootActors = setupRootActors;
_clusterSettings = clusterSettings;
_mainWorker = mainWorker;
_descriptorProvider = descriptorProvider;
_clusterProvider = clusterProvider;
_subscriptionFactory = subscriptionFactory;
_metricsProvider = metricsProvider;
_cancellationTokenSource = new CancellationTokenSource();
}
public SubscriptionService(IRepository <Subscription> repository,
IUnitOfWork unitOfWork,
ISubscriptionFactory factory)
{
if (repository == null)
{
throw new ArgumentNullException(nameof(repository));
}
if (unitOfWork == null)
{
throw new ArgumentNullException(nameof(unitOfWork));
}
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
this.repository = repository;
this.unitOfWork = unitOfWork;
this.factory = factory;
}
public SubscriptionService(IEventBus bus, ISubscriptionFactory factory, ISpaceRepo spaceRepo, ISubscriptionRepo repo) {
this.bus = bus;
this.factory = factory;
this.spaceRepo = spaceRepo;
this.repo = repo;
}
public SubscriptionRepo(IDatabase database, ISubscriptionFactory factory) : base(database)
{
this.factory = factory;
}
public UserRegisterEventHandler(ISpaceRepo spaceRepo, ISubscriptionRepo subscriptionRepo, ISubscriptionFactory subscriptionFactory)
{
this.spaceRepo = spaceRepo;
this.subscriptionRepo = subscriptionRepo;
this.subscriptionFactory = subscriptionFactory;
}
public Broker(IMessageQueueSubscriptionManager subscriptionManager, ISubscriptionFactory subscriptionFactory)
{
_subscriptionManager = subscriptionManager;
_subscriptionFactory = subscriptionFactory;
}
public Task InitRpcModules()
{
if (_accountAbstractionConfig.Enabled)
{
(IApiWithNetwork getFromApi, _) = _nethermindApi !.ForRpc;
// init all relevant objects if not already initialized
foreach (Address entryPoint in _entryPointContractAddresses)
{
UserOperationPool(entryPoint);
UserOperationSimulator(entryPoint);
UserOperationTxBuilder(entryPoint);
}
IJsonRpcConfig rpcConfig = getFromApi.Config <IJsonRpcConfig>();
rpcConfig.EnableModules(ModuleType.AccountAbstraction);
AccountAbstractionModuleFactory accountAbstractionModuleFactory = new(_userOperationPools, _entryPointContractAddresses.ToArray());
ILogManager logManager = _nethermindApi.LogManager ??
throw new ArgumentNullException(nameof(_nethermindApi.LogManager));
getFromApi.RpcModuleProvider !.RegisterBoundedByCpuCount(accountAbstractionModuleFactory, rpcConfig.Timeout);
ISubscriptionFactory subscriptionFactory = _nethermindApi.SubscriptionFactory;
//Register custom UserOperation websocket subscription types in the SubscriptionFactory.
subscriptionFactory.RegisterSubscriptionType <UserOperationSubscriptionParam?>(
"newPendingUserOperations",
(jsonRpcDuplexClient, param) => new NewPendingUserOpsSubscription(
jsonRpcDuplexClient,
_userOperationPools,
logManager,
param)
);
subscriptionFactory.RegisterSubscriptionType <UserOperationSubscriptionParam?>(
"newReceivedUserOperations",
(jsonRpcDuplexClient, param) => new NewReceivedUserOpsSubscription(
jsonRpcDuplexClient,
_userOperationPools,
logManager,
param)
);
if (BundleMiningEnabled && MevPluginEnabled)
{
if (_logger !.IsInfo)
{
_logger.Info("Both AA and MEV Plugins enabled, sending user operations to mev bundle pool instead");
}
_bundler = new MevBundler(
new OnNewBlockBundleTrigger(_nethermindApi.BlockTree !, _logger),
UserOperationTxSource, MevPlugin.BundlePool,
_logger
);
}
if (_logger !.IsInfo)
{
_logger.Info("Account Abstraction RPC plugin enabled");
}
}
else
{
if (_logger !.IsWarn)
{
_logger.Info("Skipping Account Abstraction RPC plugin");
}
}
return(Task.CompletedTask);
}
protected SubscriptionManager(ISubscriptionFactory <TClient, TSubscribeParameters> subscriptionFactory)
{
_subscriptionFactory = subscriptionFactory;
}
