public override void Execute() { //retrieve ResourceServerId for agent for checking resource pool. this value will be used when retrieving records from queue ResourceServerId = SqlQueryHelper.GetResourceServerByAgentId(EddsDbContext, AgentId); if (ResourceServerId == 0) { TextExtractorLog.RaiseUpdate(string.Format("Resource Server for Agent ID {0} cannot be detected.", AgentId)); return; } TextExtractorLog.RaiseUpdate("Processing Worker Queue Batch."); var workerQueue = new WorkerQueue(SqlQueryHelper, ArtifactQueries, ArtifactFactory, EddsDbContext, ServicesMgr, ExecutionIdentity, AgentId, ResourceServerId, BatchTableName, TextExtractorLog, TextExtractorJobReporting); if (workerQueue.HasRecords) { WorkspaceArtifactId = workerQueue.WorkspaceArtifactId; var extractorSet = ArtifactFactory.GetInstanceOfExtractorSet(ExecutionIdentity.CurrentUser, workerQueue.WorkspaceArtifactId, workerQueue.ExtractorSetArtifactId); //check for ExtractorSet cancellation Boolean isCancelled = CheckForExtractorSetCancellation(extractorSet, true); if (!isCancelled) { //process worker queue records in current batch workerQueue.ProcessAllRecords(); //check for ExtractorSet cancellation CheckForExtractorSetCancellation(extractorSet, false); } } TextExtractorLog.RaiseUpdate("Worker Queue Batch processed."); }
public PoolWorker(WorkerQueue work, DedicatedThreadPool pool, bool errorRecovery) { _work = work; _pool = pool; _workQueue = _work.WorkQueue; _work.ReplacePoolWorker(this, errorRecovery); _thread = new Thread(() => { CurrentWorker = this; foreach (var action in _workQueue.GetConsumingEnumerable()) { try { //bail if shutdown has been requested if (_pool.ShutdownRequested) { return; } action(); } catch (Exception ex) { Failover(true); return; } } }) { IsBackground = _pool.Settings.ThreadType == ThreadType.Background }; _thread.Start(); }
public MessagingRoot(MessagingSerializationGraph serialization, JasperOptions options, HandlerGraph handlers, ISubscriberGraph subscribers, IMessageLogger messageLogger, IContainer container, ITransportLogger transportLogger ) { Options = options; Handlers = handlers; _transportLogger = transportLogger; Subscribers = subscribers; Transports = container.QuickBuildAll <ITransport>().ToArray(); Serialization = serialization; Logger = messageLogger; Pipeline = new HandlerPipeline(Serialization, handlers, Logger, container.QuickBuildAll <IMissingHandler>(), this); Workers = new WorkerQueue(Logger, Pipeline, options); Router = new MessageRouter(this, handlers); _persistence = new Lazy <IEnvelopePersistence>(() => container.GetInstance <IEnvelopePersistence>()); }
public MessagingRoot(MessagingSerializationGraph serialization, JasperOptions settings, HandlerGraph handlers, IDurableMessagingFactory factory, ISubscriberGraph subscribers, IMessageLogger messageLogger, IContainer container, ITransportLogger transportLogger) { Settings = settings; _handlers = handlers; _transportLogger = transportLogger; Factory = factory; Subscribers = subscribers; Transports = container.QuickBuildAll <ITransport>().ToArray(); Serialization = serialization; Logger = messageLogger; Pipeline = new HandlerPipeline(Serialization, handlers, Logger, container.QuickBuildAll <IMissingHandler>(), this); Workers = new WorkerQueue(Logger, Pipeline, settings); Router = new MessageRouter(this, handlers); // TODO -- ZOMG this is horrible, and I admit it. if (Factory is NulloDurableMessagingFactory f) { f.ScheduledJobs = ScheduledJobs; } }
public override void Execute() { foreach (var count in Enumerable.Range(1, 10)) { WorkerQueue.AddMessage(new CloudQueueMessage($"Queued message {count}")); } }
public void Start() { renderQueue = new WorkerQueue(); renderQueue.Start(); generateQueue = new WorkerQueue(); generateQueue.Start(); }
private void Failover(bool errorRecovery = false) { /* request a new thread then shut down */ _pool.RequestThread(_work, errorRecovery); CurrentWorker = null; _work = null; _workQueue = null; _pool = null; }
private void BTN_Exit_Click(object sender, EventArgs e) { WorkerBarber.CancelAsync(); WorkerQueue.CancelAsync(); BTN_Start.Enabled = true; BTN_Exit.Enabled = false; BTN_NewClient.Enabled = false; }
public override void Execute() { var batch = WorkerQueue.GetMessages(10, TimeSpan.FromMinutes(5)); Parallel.ForEach(batch, m => { Console.WriteLine(m.AsString); }); }
static HelpDownloader() { Tasks = new WorkerQueue <HelpCenterRequest>(1, TimeSpan.FromSeconds(60), 1, true); LockObj = new object(); if (!bool.TryParse(WebConfigurationManager.AppSettings["web.help-center.download"] ?? "false", out DownloadEnabled)) { DownloadEnabled = false; } }
/// <summary> /// Complete and dispose of resources /// </summary> public new void Dispose() { WorkerQueue <EventData> worker = Interlocked.Exchange(ref _workerQueue, null); if (worker != null) { worker.OnCompleted(); base.Dispose(); } }
public void Start() { if (!Started) { Started = true; requests = new WorkerQueue <string>(4, TimeSpan.Zero, 10, true); requests.AddRange(urls); requests.Start(LoaderPortalPages); } }
public FileMarkerHelper( IServiceProvider serviceProvider, IOptionsMonitor <ILog> optionsMonitor, WorkerQueueOptionsManager <AsyncTaskData <T> > workerQueueOptionsManager) { ServiceProvider = serviceProvider; Log = optionsMonitor.CurrentValue; Locker = new object(); Tasks = workerQueueOptionsManager.Value; }
private void queue() { if (nClients == 3) { WorkerQueue.ReportProgress(1); return; } nClients++; WorkerQueue.ReportProgress(0); }
public Topic(string name) { name.ArgumentNullException("name"); this.name = name; this.subscribes = new List <Action <IMessage> >(); this.workQueue = new WorkerQueue <IMessage>(DistributionHandler); this.lockSlim = new ReaderWriterLockSlim(); this.workQueue.Start(); }
private void WorkerQueue_DoWork(object sender, DoWorkEventArgs e) { queue(); WorkerQueue.CancelAsync(); if (WorkerQueue.CancellationPending == true) { e.Cancel = true; return; } }
private LogHost() { _hostInfo = HostUtil.GetHostInfo(); _appKey = AppContext.AppKey; _writeLogBatchSize = AppContext.LogMaxMessageCount; _writeLogCoolDownTime = AppContext.LogSendFrequency; _localQueueSize = AppContext.LogMaxQueueSize; _isWriteLocalLog = AppContext.WriteLocalFile; _localLogQueue = new WorkerQueue <LogContent>(_writeLogBatchSize, _writeLogCoolDownTime, _localQueueSize, "LogSDKQueue"); _localLogQueue.Flush += new Action <object, List <LogContent> >(WriteLog); }
public void ExecuteTest() { var sequence = 0; var worker = new WorkerQueue(); worker.Execute(() => { Assert.AreEqual(0, sequence); Thread.Sleep(10); ++sequence; }); worker.Execute(() => { Assert.AreEqual(1, sequence); Thread.Sleep(10); ++sequence; }); worker.Execute(() => { Assert.AreEqual(2, sequence); Thread.Sleep(10); ++sequence; }); worker.Execute(() => { Assert.AreEqual(3, sequence); Thread.Sleep(10); ++sequence; }); worker.Execute(() => { Assert.AreEqual(4, sequence); Thread.Sleep(10); ++sequence; }); Assert.AreEqual(5, sequence); }
/// <remarks> /// This method is thread safe. /// </remarks> public void QueueSync(ChatModel chatModel) { Trace.Call(chatModel); if (chatModel == null) { throw new ArgumentNullException("chatModel"); } WorkerQueue.Enqueue(delegate { SyncWorker(chatModel); }); }
public void Terminate() { try { if (requests != null) { requests.Terminate(); requests = null; } } catch (ThreadAbortException) { } }
public void CurrentThreadOnTest() { var inCheck = false; var outCheck = false; var worker = new WorkerQueue(); worker.Queue(() => { inCheck = worker.CurrentThreadOn(); }); worker.Wait(); outCheck = worker.CurrentThreadOn(); Assert.IsTrue(inCheck); Assert.IsFalse(outCheck); }
public void QueueTest() { var sequence = 0; var worker = new WorkerQueue(); worker.Queue(() => { Assert.AreEqual(0, sequence); Thread.Sleep(100); ++sequence; }); worker.Queue(() => { Assert.AreEqual(1, sequence); Thread.Sleep(10); ++sequence; }); worker.Queue(() => { Assert.AreEqual(2, sequence); Thread.Sleep(0); ++sequence; }); worker.Queue(() => { Assert.AreEqual(3, sequence); Thread.Sleep(50); ++sequence; }); worker.Queue(() => { Assert.AreEqual(4, sequence); Thread.Sleep(150); ++sequence; }); worker.Queue(() => { Assert.AreEqual(5, sequence); Thread.Sleep(1); ++sequence; }); worker.Wait(); Assert.AreEqual(6, sequence); }
/// <summary> /// Enqueue (Helper) | Executes a specific queue of computers to retrieve information, and update database. /// </summary> /// <param name="wq"></param> private static void ExecuteQueue(WorkerQueue wq) { // Check if ready if (wq != null && wq.Computers.Count > 0) { // Tell the rest of the world we are working really hard! wq.isEnqueued = true; // Work the queue. foreach (int id in wq.Computers) { UpdateComputer(id); } // Tell the world we are done. wq.isEnqueued = false; } }
public MessagingRoot(ObjectPoolProvider pooling, MessagingSettings settings, HandlerGraph handlers, Forwarders forwarders, IDurableMessagingFactory factory, IChannelGraph channels, ISubscriptionsRepository subscriptions, IMessageLogger messageLogger, IEnumerable <ISerializerFactory> serializers, IEnumerable <IMessageDeserializer> readers, IEnumerable <IMessageSerializer> writers, ITransport[] transports, IEnumerable <IMissingHandler> missingHandlers, IEnumerable <IUriLookup> lookups, ITransportLogger transportLogger) { Settings = settings; _handlers = handlers; _transportLogger = transportLogger; Replies = new ReplyWatcher(); Factory = factory; Channels = channels; Transports = transports; Lookup = new UriAliasLookup(lookups); Serialization = new MessagingSerializationGraph(pooling, settings, handlers, forwarders, serializers, readers, writers); Logger = messageLogger; Pipeline = new HandlerPipeline(Serialization, handlers, Replies, Logger, missingHandlers, this); Workers = new WorkerQueue(Logger, Pipeline, settings); Router = new MessageRouter(Serialization, channels, subscriptions, handlers, Logger, Lookup, settings); // TODO -- ZOMG this is horrible, and I admit it. if (Factory is NulloDurableMessagingFactory) { Factory.As <NulloDurableMessagingFactory>().ScheduledJobs = ScheduledJobs; } }
public void ClearTest() { var sequence = 0; var blocker = new ManualResetEvent(false); var worker = new WorkerQueue(); worker.Queue(() => { Assert.AreEqual(0, sequence); blocker.WaitOne(); worker.Clear(); ++sequence; }); worker.Queue(() => { Assert.AreEqual(1, sequence); ++sequence; }); worker.Queue(() => { Assert.AreEqual(2, sequence); ++sequence; }); worker.Queue(() => { Assert.AreEqual(3, sequence); ++sequence; }); worker.Queue(() => { Assert.AreEqual(4, sequence); ++sequence; }); worker.Queue(() => { Assert.AreEqual(5, sequence); ++sequence; }); blocker.Set(); Thread.Sleep(50); Assert.AreEqual(1, sequence); }
public override void Execute() { var keepWorking = true; while (keepWorking) { var message = WorkerQueue.GetMessage(TimeSpan.FromMinutes(5)); if (message != null) { Console.WriteLine(message.AsString); } else { keepWorking = false; } } }
public MessagingRoot( ObjectPoolProvider pooling, BusSettings settings, HandlerGraph handlers, Forwarders forwarders, IPersistence persistence, IChannelGraph channels, ISubscriptionsRepository subscriptions, IEnumerable <ISerializerFactory> serializers, IEnumerable <IMessageDeserializer> readers, IEnumerable <IMessageSerializer> writers, IMessageLogger[] loggers, ITransport[] transports, IEnumerable <IMissingHandler> missingHandlers, IEnumerable <IUriLookup> lookups) { _settings = settings; _handlers = handlers; _replies = new ReplyWatcher(); _persistence = persistence; _channels = channels; _transports = transports; Lookup = new UriAliasLookup(lookups); Serialization = new BusMessageSerializationGraph(pooling, settings, handlers, forwarders, serializers, readers, writers); Logger = new CompositeMessageLogger(loggers); Pipeline = new HandlerPipeline(Serialization, handlers, _replies, Logger, missingHandlers, new Lazy <IServiceBus>(Build)); Workers = new WorkerQueue(Logger, Pipeline, settings); Router = new MessageRouter(Serialization, channels, subscriptions, handlers, Logger, Lookup, settings); ScheduledJobs = new InMemoryScheduledJobProcessor(); }
public void ProcessAllRecordsTest() { IntegrationSettings testSettings = new IntegrationSettings(); IntegrationDBContext testDBContext = new IntegrationDBContext(testSettings.DBContextSettings); IntegrationServicesMgr testServiceManager = new IntegrationServicesMgr(testSettings.RsapiSettings); SqlQueryHelper testSqlQueryHelpers = new SqlQueryHelper(); ArtifactQueries artifactQueries = new ArtifactQueries(); ArtifactFactory artifactFactory = new ArtifactFactory(artifactQueries, testServiceManager, null); Int32 agentId = 1016595; Int32 resourceServerId = 1016158; string batchTableName = "[" + Constant.Names.TablePrefix + "Worker_" + Guid.NewGuid() + "_" + agentId + "]"; TextExtractorLog textExtractorLog = new TextExtractorLog(); ExtractorSetReporting extractorSetReporting = new ExtractorSetReporting(artifactQueries, testServiceManager); WorkerQueue workerQueue = new WorkerQueue(testSqlQueryHelpers, artifactQueries, artifactFactory, testDBContext, testServiceManager, ExecutionIdentity.System, agentId, resourceServerId, batchTableName, textExtractorLog, extractorSetReporting); workerQueue.ProcessAllRecords(); }
public MessagingRoot( MessagingSerializationGraph serialization, MessagingSettings settings, HandlerGraph handlers, IDurableMessagingFactory factory, IChannelGraph channels, ISubscriptionsRepository subscriptions, IMessageLogger messageLogger, Lamar.IContainer container, ITransportLogger transportLogger) { Settings = settings; _handlers = handlers; _transportLogger = transportLogger; Replies = new ReplyWatcher(); Factory = factory; Channels = channels; Transports = container.QuickBuildAll <ITransport>().ToArray(); Lookup = new UriAliasLookup(container.QuickBuildAll <IUriLookup>()); Serialization = serialization; Logger = messageLogger; Pipeline = new HandlerPipeline(Serialization, handlers, Replies, Logger, container.QuickBuildAll <IMissingHandler>(), this); Workers = new WorkerQueue(Logger, Pipeline, settings); Router = new MessageRouter(Serialization, channels, subscriptions, handlers, Logger, Lookup, settings); // TODO -- ZOMG this is horrible, and I admit it. if (Factory is NulloDurableMessagingFactory f) { f.ScheduledJobs = ScheduledJobs; } }
public PoolWorker(WorkerQueue work, DedicatedThreadPool pool, bool errorRecovery, int workerNumber) { _work = work; _pool = pool; _workerNumber = workerNumber; _workQueue = _work.WorkQueue; _work.ReplacePoolWorker(this, errorRecovery); _thread = new Thread(() => { Thread.CurrentThread.Name = string.Format("{0}_{1}", pool.Settings.Name, _workerNumber); CurrentWorker = this; foreach (var action in _workQueue.GetConsumingEnumerable()) { try { //bail if shutdown has been requested if (_pool.ShutdownRequested) { return; } action(); } catch (Exception) { Failover(true); return; } } }) { IsBackground = _pool.Settings.ThreadType == ThreadType.Background }; if (_pool.Settings.ApartmentState != ApartmentState.Unknown) { _thread.SetApartmentState(_pool.Settings.ApartmentState); } _thread.Start(); }
public PoolWorker(WorkerQueue work, DedicatedThreadPool pool, bool errorRecovery) { _work = work; _pool = pool; _workQueue = _work.WorkQueue; _work.ReplacePoolWorker(this, errorRecovery); _thread = new Thread(() => { CurrentWorker = this; foreach (var action in _workQueue.GetConsumingEnumerable()) { try { //bail if shutdown has been requested if (_pool.ShutdownRequested) return; action(); } catch (Exception ex) { Failover(true); return; } } }) { IsBackground = _pool.Settings.ThreadType == ThreadType.Background }; _thread.Start(); }
private PoolWorker RequestThread(WorkerQueue unclaimedQueue, bool errorRecovery = false) { var worker = new PoolWorker(unclaimedQueue, this, errorRecovery); return worker; }
public void Start() { if (!Started) { Started = true; requests = new WorkerQueue<string>(4, TimeSpan.Zero, 10, true); requests.AddRange(urls); requests.Start(LoaderPortalPages); } }
public PoolWorker(WorkerQueue work, DedicatedThreadPool pool, bool errorRecovery, int workerNumber) { _work = work; _pool = pool; _workerNumber = workerNumber; _workQueue = _work.WorkQueue; _work.ReplacePoolWorker(this, errorRecovery); _thread = new Thread(() => { Thread.CurrentThread.Name = string.Format("{0}_{1}", pool.Settings.Name, _workerNumber); CurrentWorker = this; foreach (var action in _workQueue.GetConsumingEnumerable()) { try { //bail if shutdown has been requested if (_pool.ShutdownRequested) return; action(); } catch (Exception) { Failover(true); return; } } }) { IsBackground = _pool.Settings.ThreadType == ThreadType.Background }; if (_pool.Settings.ApartmentState != ApartmentState.Unknown) _thread.SetApartmentState(_pool.Settings.ApartmentState); _thread.Start(); }