Beispiel #1
0
        public RemoteTaskQueue(ILog logger,
                               ISerializer serializer,
                               IGlobalTime globalTime,
                               ICassandraCluster cassandraCluster,
                               IRtqSettings rtqSettings,
                               IRtqTaskDataRegistry taskDataRegistry,
                               IRtqProfiler rtqProfiler)
        {
            QueueKeyspace    = rtqSettings.QueueKeyspace;
            TaskTtl          = rtqSettings.TaskTtl;
            Logger           = logger.ForContext("CassandraDistributedTaskQueue");
            Serializer       = serializer;
            GlobalTime       = globalTime;
            TaskDataRegistry = taskDataRegistry;
            enableContinuationOptimization = rtqSettings.EnableContinuationOptimization;
            minTicksHolder             = new RtqMinTicksHolder(cassandraCluster, rtqSettings);
            TaskMinimalStartTicksIndex = new TaskMinimalStartTicksIndex(cassandraCluster, serializer, rtqSettings, new OldestLiveRecordTicksHolder(minTicksHolder), Logger);
            var taskMetaStorage = new TaskMetaStorage(cassandraCluster, serializer, rtqSettings, Logger);

            EventLogRepository       = new EventLogRepository(serializer, cassandraCluster, rtqSettings, minTicksHolder);
            childTaskIndex           = new ChildTaskIndex(cassandraCluster, rtqSettings, serializer, taskMetaStorage);
            HandleTasksMetaStorage   = new HandleTasksMetaStorage(taskMetaStorage, TaskMinimalStartTicksIndex, EventLogRepository, GlobalTime, childTaskIndex, taskDataRegistry, Logger);
            TaskDataStorage          = new TaskDataStorage(cassandraCluster, rtqSettings, Logger);
            TaskExceptionInfoStorage = new TaskExceptionInfoStorage(cassandraCluster, serializer, rtqSettings, Logger);
            HandleTaskCollection     = new HandleTaskCollection(HandleTasksMetaStorage, TaskDataStorage, TaskExceptionInfoStorage, rtqProfiler);
            lazyRemoteLockCreator    = new Lazy <IRemoteLockCreator>(() =>
            {
                var remoteLockImplementationSettings = CassandraRemoteLockImplementationSettings.Default(rtqSettings.QueueKeyspace, RtqColumnFamilyRegistry.LocksColumnFamilyName);
                var remoteLockImplementation         = new CassandraRemoteLockImplementation(cassandraCluster, serializer, remoteLockImplementationSettings);
                var remoteLockerMetrics = new RemoteLockerMetrics($"{rtqSettings.QueueKeyspace}_{RtqColumnFamilyRegistry.LocksColumnFamilyName}");
                return(new RemoteLocker(remoteLockImplementation, remoteLockerMetrics, Logger));
            });
            Profiler = rtqProfiler;
        }
        public TestCounterRepository(ILog log,
                                     ICassandraCluster cassandraCluster,
                                     ISerializer serializer,
                                     IGlobalTime globalTime,
                                     IRtqSettings rtqSettings)
        {
            this.serializer = serializer;
            this.globalTime = globalTime;
            var keyspaceName = rtqSettings.QueueKeyspace;

            cfConnection = cassandraCluster.RetrieveColumnFamilyConnection(keyspaceName, ColumnFamilyName);
            var remoteLockImplementationSettings = CassandraRemoteLockImplementationSettings.Default(keyspaceName, RtqColumnFamilyRegistry.LocksColumnFamilyName);
            var remoteLockImplementation         = new CassandraRemoteLockImplementation(cassandraCluster, serializer, remoteLockImplementationSettings);

            remoteLockCreator = new RemoteLocker(remoteLockImplementation, new RemoteLockerMetrics(keyspaceName), log);
        }
Beispiel #3
0
 public HandleTasksMetaStorage(
     ITaskMetaStorage taskMetaStorage,
     ITaskMinimalStartTicksIndex minimalStartTicksIndex,
     IEventLogRepository eventLogRepository,
     IGlobalTime globalTime,
     IChildTaskIndex childTaskIndex,
     IRtqTaskDataRegistry taskDataRegistry,
     ILog logger)
 {
     this.taskMetaStorage        = taskMetaStorage;
     this.minimalStartTicksIndex = minimalStartTicksIndex;
     this.eventLogRepository     = eventLogRepository;
     this.globalTime             = globalTime;
     this.childTaskIndex         = childTaskIndex;
     this.taskDataRegistry       = taskDataRegistry;
     this.logger = logger.ForContext(nameof(HandleTasksMetaStorage));
 }
Beispiel #4
0
 public HandlerManager([NotNull] string queueKeyspace,
                       [NotNull] string taskTopic,
                       int maxRunningTasksCount,
                       ILocalTaskQueue localTaskQueue,
                       IHandleTasksMetaStorage handleTasksMetaStorage,
                       IGlobalTime globalTime,
                       ILog logger)
 {
     JobId                       = $"HandlerManager_{queueKeyspace}_{taskTopic}";
     this.taskTopic              = taskTopic;
     this.maxRunningTasksCount   = maxRunningTasksCount;
     this.localTaskQueue         = localTaskQueue;
     this.handleTasksMetaStorage = handleTasksMetaStorage;
     this.globalTime             = globalTime;
     this.logger                 = logger.ForContext(nameof(HandlerManager));
     allTaskIndexShardKeysToRead = allTaskStatesToRead.Select(x => new TaskIndexShardKey(taskTopic, x)).ToArray();
 }
 public RtqEventFeedGlobalTimeProvider(IGlobalTime globalTime)
 {
     this.globalTime = globalTime;
 }