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