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