public OverseerWatcher(IPoller poller, IWatcher watcher) : base(watcher) { _reportedItems = new HashSet <String>(); _reportedFilesLock = new Object(); InitPollerErrorPolicies(); // Initiating poller _poller = poller; if (_poller.Path != watcher.Path) { _poller.Path = watcher.Path; } EnableRaisingEvents = false; _poller.Created += OnCreatedPolled; _poller.Deleted += OnDeletedPolled; _poller.Error += OnPollerError; // Getting initial directory content by forcing a poll _poller.PollingType = PollingType.Poll; _poller.ForcePoll(); // For the rest of the OverseerWatcher's lifespan, keep the poller as a 'watcher' _poller.PollingType = PollingType.Watch; }
public Supervisor(IPoller<TaskToBeWorked> poller, IRepository repository, IMessagePublisher<TaskToBeWorked> publisher, ILogger<Supervisor> logger) { _poller = poller; _repository = repository; _publisher = publisher; _logger = logger; }
public TSocket(IPoller poller) { this.poller = poller; this.socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); this.innArgs.Completed += this.OnComplete; this.outArgs.Completed += this.OnComplete; }
public OrderLooper(IPoller poller, ISettings settings, IProcessor processor) { _poller = poller; _settings = settings; _processor = processor; _isLooping = false; }
public Supervisor(IPoller <TaskToBeWorked> poller, IDal dal, IMessagePublisher <TaskToBeWorked> publisher, ILogger <Supervisor> logger) { _poller = poller; _dal = dal; _publisher = publisher; _logger = logger; }
public void Unregister(IPoller poller) { Timer timer; if (pollers.TryRemove(poller, out timer)) { timer.Dispose(); } }
private void StoppedPolling(IPoller pollerToStart) { var pollerTaskInfo = runningPollerTasks.FirstOrDefault(x => x.Poller == pollerToStart); if (pollerTaskInfo != null) { runningPollerTasks.Remove(pollerTaskInfo); } }
/// <summary> /// Default Constructor /// </summary> /// <param name="processor">Processor</param> /// <param name="poller">Poller</param> /// <param name="tracker">Tracker</param> /// <param name="minimumPeriodInSeconds">Minimum, time in seconds</param> /// <param name="maximumPeriodInSeconds">Maximum, time in seconds</param> public DequeueBatchDynamic(IPoller <T> poller, IProcessor <T> processor, ITimingTracker tracker, int minimumPeriodInSeconds = BaseTimes.DefaultMinimumTiming, int maximumPeriodInSeconds = BaseTimes.DefaultMaximumTiming) : base(poller, processor, DequeueBatch <T> .MinimumBatchSize, minimumPeriodInSeconds, maximumPeriodInSeconds) { if (null == tracker) { throw new ArgumentNullException("tracker"); } this.tracker = tracker; }
public PollerTaskInfo(Task task, IPoller poller, CancellationTokenSource cancellationTokenSource) { Verify.RequireNotNull(task, "task"); Verify.RequireNotNull(poller, "Poller"); Verify.RequireNotNull(cancellationTokenSource, "cancellationTokenSource"); Task = task; Poller = poller; CancellationTokenSource = cancellationTokenSource; }
public ObservableAdresses(IPoller poller) { var onEvent = Observable.Create<IAddressAndValue>(o => { EventHandler<IAddressAndValue> handler = (_, e) => o.OnNext(e); poller.Read += handler; return Disposable.Create(() => poller.Read -= handler); }).Publish(); _connection = onEvent.Connect(); FastAdresses = new RateAdresses(onEvent, UpdateRate.High); SlowAdresses = new RateAdresses(onEvent, UpdateRate.Low); }
public PepinoQueueWorkerService() { var containerBuilder = new ContainerBuilder(); new ConfigureDatabaseWiring().Task(containerBuilder); new ConfigureAutomapperMappings().Task(containerBuilder); new ConfigureWorkerDependencies().Task(containerBuilder); IContainer container = containerBuilder.Build(); _poller = container.Resolve<IPoller>(); _secondsInterval = Config.GetQueueWorkerPollingIntervalSeconds(); }
public void Register(IPoller poller) { var rp = poller.RecurranceParameters; if (rp == null) { throw new ArgumentNullException("IPoller instance does not have RecurranceParameters set"); } int milliseconds = (int)rp.Interval.TotalMilliseconds; // DOUBLECAST Timer timer = new Timer(OnTimerElapsed, poller, milliseconds, milliseconds); if (!pollers.TryAdd(poller, timer)) throw new DuplicateNotAllowedException(); //poller.RecurranceParameters.Interval }
/// <summary> /// Default Constructor /// </summary> /// <param name="processor">Processor</param> /// <param name="poller">Poller</param> /// <param name="minimumPeriodInSeconds">Minimum, time in seconds</param> /// <param name="maximumPeriodInSeconds">Maximum, time in seconds</param> public Dequeue(IPoller <T> poller, IProcessor <T> processor, int minimumPeriodInSeconds = BaseTimes.DefaultMinimumTiming, int maximumPeriodInSeconds = BaseTimes.DefaultMaximumTiming) { if (null == poller) { throw new ArgumentNullException("poller"); } if (null == processor) { throw new ArgumentNullException("processor"); } this.poller = poller; this.processor = processor; this.MinimumPeriodInSeconds = 0 >= minimumPeriodInSeconds ? BaseTimes.DefaultMinimumTiming : minimumPeriodInSeconds; this.MaximumPeriodInSeconds = minimumPeriodInSeconds >= maximumPeriodInSeconds ? BaseTimes.DefaultMaximumTiming : maximumPeriodInSeconds; }
public PollProcessor(PollProcessorEndpoint endpoint, IPoller poller) { if (endpoint == null) { throw new ArgumentNullException("endpoint"); } if (poller == null) { throw new ArgumentNullException("poller"); } this.Endpoint = endpoint; this.Poller = poller; this.timer = new Timer(this.Endpoint.IntervalSecs * 1000) { AutoReset = true }; this.timer.Elapsed += this.TimerElapsed; }
public override Object Clone() { IPoller clonedPoller = (IPoller)_poller.Clone(); IWatcher clonedEncapsWatcher = (IWatcher)InternalWatcher.Clone(); OverseerWatcher clonedOverseerWatcher = new OverseerWatcher(clonedPoller, clonedEncapsWatcher) { PollerReportsDelay = PollerReportsDelay }; clonedOverseerWatcher.ClearPolicies(); foreach (WatcherErrorHandlingPolicy policy in ErrorHandlingPolicies) { clonedOverseerWatcher.AddPolicy(policy); } return(clonedOverseerWatcher); }
public OverseerWatcher(IPoller poller, FileSystemWatcher watcher) : this(poller, new WatcherAdapter(watcher)) { }
/// <summary> /// Default Constructor /// </summary> /// <param name="processor">Processor</param> /// <param name="poller">Poller</param> /// <param name="batchCount">Number of items to dequeue at a time</param> /// <param name="minimumPeriodInSeconds">Minimum, time in seconds</param> /// <param name="maximumPeriodInSeconds">Maximum, time in seconds</param> public DequeueBatch(IPoller <T> poller, IProcessor <T> processor, byte batchCount = 5, int minimumPeriodInSeconds = BaseTimes.DefaultMinimumTiming, int maximumPeriodInSeconds = BaseTimes.DefaultMaximumTiming) : base(poller, processor, minimumPeriodInSeconds, maximumPeriodInSeconds) { this.batchCount = batchCount == byte.MinValue ? MinimumBatchSize : batchCount; }
public Module1(IPoller poller) { _poller = poller; }
public PollForm() { poller = new Poller(); InitializeComponent(); }
public OverseerWatcher(IPoller poller) : this(poller, new WatcherAdapter(poller.Path, poller.Filter)) { }
public Ref(List <Pair <T> > itemsWithWeight) { this.ItemsWithWeight = itemsWithWeight; this.Poller = new GenericPoller <T>(Items); }