public void MessagesPerScaleUnit(QueuePriority priority, ushort expected) { var s = new QueueThroughput(); var data = s.MessagesPerScaleUnit(priority); Assert.AreEqual(expected, data); }
public void MaximumScale(QueuePriority priority, byte expected) { var s = new QueueThroughput(); var data = s.Scale(priority); Assert.AreEqual(expected, data.Maximum); }
public void MinimumFrequency(QueuePriority priority, byte expected) { var s = new QueueThroughput(); var data = s.Frequency(priority); Assert.AreEqual(expected, data.Minimum); }
public void CheckScaleEvery(QueuePriority priority, byte expected) { var s = new QueueThroughput(); var data = s.CheckScaleEvery(priority); Assert.AreEqual(expected, data); }
/// <summary> /// Gets the hash code /// </summary> /// <returns>Hash code</returns> public override int GetHashCode() { unchecked // Overflow is fine, just wrap { var hashCode = 41; // Suitable nullity checks etc, of course :) if (QueueName != null) { hashCode = hashCode * 59 + QueueName.GetHashCode(); } if (QueueTopics != null) { hashCode = hashCode * 59 + QueueTopics.GetHashCode(); } if (QueueType != null) { hashCode = hashCode * 59 + QueueType.GetHashCode(); } if (QueuePriority != null) { hashCode = hashCode * 59 + QueuePriority.GetHashCode(); } if (QueueRetries != null) { hashCode = hashCode * 59 + QueueRetries.GetHashCode(); } if (QueueRetrydelay != null) { hashCode = hashCode * 59 + QueueRetrydelay.GetHashCode(); } if (QueueMaxparallel != null) { hashCode = hashCode * 59 + QueueMaxparallel.GetHashCode(); } if (QueueKeepJobs != null) { hashCode = hashCode * 59 + QueueKeepJobs.GetHashCode(); } if (QueuePreferRunOnCreationInstance != null) { hashCode = hashCode * 59 + QueuePreferRunOnCreationInstance.GetHashCode(); } if (QueueThreadPoolSize != null) { hashCode = hashCode * 59 + QueueThreadPoolSize.GetHashCode(); } if (ServiceRanking != null) { hashCode = hashCode * 59 + ServiceRanking.GetHashCode(); } return(hashCode); } }
public void Enqueue(T queueItem, QueuePriority priority) { _queue.Enqueue(queueItem, (float)priority); try { _wh.Set(); } catch (ObjectDisposedException) { } }
/// <summary> /// Frequency to check Queue /// </summary> /// <param name="priority">Priority</param> /// <returns>Frequency Range</returns> public virtual Range<byte> Frequency(QueuePriority priority = QueuePriority.Low) { switch (priority) { case QueuePriority.High: return new Range<byte>(1, BaseTimes.MinimumStorageTiming); case QueuePriority.Medium: return new Range<byte>(5, 60); default: return new Range<byte>(BaseTimes.MinimumStorageTiming, BaseTimes.MaximumStorageTiming); } }
/// <summary> /// Check Scale every (in minutes) /// </summary> /// <remarks> /// Should be kept under 5 min, as Auto-Scale servers should be in place /// </remarks> /// <param name="priority">Priority</param> /// <returns>Check Scale every (in minutes)</returns> public virtual byte CheckScaleEvery(QueuePriority priority = QueuePriority.Low) { switch (priority) { case QueuePriority.High: return 2; case QueuePriority.Medium: return 3; default: return 4; } }
/// <summary> /// Scale (threads) /// </summary> /// <param name="priority">Priority</param> /// <returns>Scale</returns> public virtual Range<byte> Scale(QueuePriority priority = QueuePriority.Low) { switch (priority) { case QueuePriority.High: return new Range<byte>(2, 5); case QueuePriority.Medium: return new Range<byte>(1, 4); default: return new Range<byte>(1, 2); } }
/// <summary> /// Messages per Scale-unit /// </summary> /// <remarks> /// Targeting ~1 minute per dequeuer to catch up to Queue Count /// </remarks> /// <param name="priority">Priority</param> /// <returns>Number of messages per scale unit</returns> public virtual ushort MessagesPerScaleUnit(QueuePriority priority = QueuePriority.Low) { switch (priority) { case QueuePriority.High: return 9500; case QueuePriority.Medium: return 1400; default: return QueueScaler<object>.MessagesPerScaleUnitDefault; } }
public void Extract_NewValue() { var collection = new int[] { 5, 1, 2, 8, 7, 3, 4, 9, 6, 4, 0 }; var testClass = new QueuePriority <int>(collection); testClass.ExtractValue().Should().Be(0); testClass.ExtractValue().Should().Be(1); testClass.ExtractValue().Should().Be(2); testClass.ExtractValue().Should().Be(3); testClass.ExtractValue().Should().Be(4); testClass.ExtractValue().Should().Be(4); testClass.ExtractValue().Should().Be(5); testClass.ExtractValue().Should().Be(6); }
/// <summary> /// Messages per Scale-unit /// </summary> /// <remarks> /// Targeting ~1 minute per dequeuer to catch up to Queue Count /// </remarks> /// <param name="priority">Priority</param> /// <returns>Number of messages per scale unit</returns> public virtual ushort MessagesPerScaleUnit(QueuePriority priority = QueuePriority.Low) { switch (priority) { case QueuePriority.High: return(9500); case QueuePriority.Medium: return(1400); default: return(QueueScaler <object> .MessagesPerScaleUnitDefault); } }
/// <summary> /// Scale (threads) /// </summary> /// <param name="priority">Priority</param> /// <returns>Scale</returns> public virtual Range <byte> Scale(QueuePriority priority = QueuePriority.Low) { switch (priority) { case QueuePriority.High: return(new Range <byte>(2, 5)); case QueuePriority.Medium: return(new Range <byte>(1, 4)); default: return(new Range <byte>(1, 2)); } }
/// <summary> /// Frequency to check Queue /// </summary> /// <param name="priority">Priority</param> /// <returns>Frequency Range</returns> public virtual Range <byte> Frequency(QueuePriority priority = QueuePriority.Low) { switch (priority) { case QueuePriority.High: return(new Range <byte>(1, 5)); case QueuePriority.Medium: return(new Range <byte>(5, 15)); default: return(new Range <byte>(BaseTimes.DefaultMinimumTiming, BaseTimes.DefaultMaximumTiming)); } }
/// <summary> /// Check Scale every (in minutes) /// </summary> /// <remarks> /// Should be kept under 5 min, as Auto-Scale servers should be in place /// </remarks> /// <param name="priority">Priority</param> /// <returns>Check Scale every (in minutes)</returns> public virtual byte CheckScaleEvery(QueuePriority priority = QueuePriority.Low) { switch (priority) { case QueuePriority.High: return(2); case QueuePriority.Medium: return(3); default: return(4); } }
/// <summary> /// Dequeue Task Set /// </summary> /// <typeparam name="Y">Processor</typeparam> /// <typeparam name="T">Model</typeparam> /// <param name="name">Queue Name</param> /// <param name="priority">Priority</param> /// <returns>Dequeue Tasks</returns> public virtual IEnumerable <IRunnable> Dequeue <T, Y>(string name, QueuePriority priority = QueuePriority.Low) where T : IProcessor <Y>, new() { if (string.IsNullOrWhiteSpace(name)) { throw new ArgumentException("name"); } return(this.Tasks <Y>(new QueueSetupProcessor <T, Y> { Priority = priority, Name = name, })); }
public void InsertValue_Sorting() { var testClass = new QueuePriority <int>(); testClass.InsertValue(5); testClass.InsertValue(9); testClass.InsertValue(1); testClass.InsertValue(4); testClass.InsertValue(3); testClass.ExtractValue().Should().Be(1); testClass.ExtractValue().Should().Be(3); testClass.ExtractValue().Should().Be(4); testClass.ExtractValue().Should().Be(5); testClass.ExtractValue().Should().Be(9); }
public MessageQueueItem Enqueue(MessageQueueItem message, QueuePriority priority = QueuePriority.Medium, QueueLocation location = QueueLocation.Back) { lock (SyncRoot) { if (location == QueueLocation.Back) { m_queue[(int)priority].Add(message); } else { m_queue[(int)priority].Insert(0, message); } } return(message); }
public MessageQueueItem Enqueue(MessageQueueItem message, QueuePriority priority = QueuePriority.Medium, QueueLocation location = QueueLocation.Back) { lock(SyncRoot) { if(location == QueueLocation.Back) { m_queue[(int)priority].Add(message); } else { m_queue[(int)priority].Insert(0, message); } } return message; }
public void EnqueueCommand(string command, QueuePriority priority) { switch (priority) { case QueuePriority.Low: _lowPriorityQueue.Enqueue(command); break; case QueuePriority.High: _highPriorityQueue.Enqueue(command); break; default: _normalPriorityQueue.Enqueue(command); break; } CommandQueued?.Invoke(this, EventArgs.Empty); }
/// <summary> /// Enqueues the specified item. /// </summary> /// <param name="item">The item.</param> /// <param name="priority">Queue priority.</param> public void BlockEnqueue(T item, QueuePriority priority = QueuePriority.Standard) { switch (priority) { case QueuePriority.Low: _lowPriorityCollection.Add(item); break; case QueuePriority.Standard: _standardPriorityCollection.Add(item); break; case QueuePriority.High: _highPriorityCollection.Add(item); break; } }
/// <summary> /// Add work to be performed by the threadpool. /// Can throw ArgumentNullException and InvalidOperationException. /// </summary> /// <param name="work">Work object to process</param> /// <param name="queuePriority">QueuePriority for this work</param> public void Add(Work work, QueuePriority queuePriority) { if (work == null) { throw new ArgumentNullException("work", "cannot be null"); } IWork w = work as IWork; if (w != null) { Add(w, queuePriority); } else { throw new InvalidOperationException("Work does not implement IWork interface"); } }
public static Task <bool> EnqueueAction <T>(T arguments, Func <T, bool> action, QueuePriority priority = QueuePriority.Low, bool delaySend = true, CancellationToken cancellationToken = default) { lock ( _actionPacketQueueLock ) { ActionQueueItem actionQueueItem = new ActionQueueItem(e => !cancellationToken.IsCancellationRequested && action((T)e)) { DelaySend = delaySend, Token = cancellationToken, Arguments = arguments }; _actionPacketQueue.Enqueue(actionQueueItem, priority); return(actionQueueItem.WaitHandle.ToTask(() => actionQueueItem.Result)); } }
public static Task EnqueuePacket(PacketQueueItem packetQueueItem, QueuePriority priority) { lock ( _actionPacketQueueLock ) { if (_actionPacketQueue.Count() > Options.CurrentOptions.UseObjectQueueAmount) { Commands.SystemMessage(Strings.Object_queue_full, (int)Commands.SystemMessageHues.Yellow, true, true); return(Task.CompletedTask); } _actionPacketQueue.Enqueue(packetQueueItem, priority); return(packetQueueItem.WaitHandle.ToTask()); } }
protected Queue <IWork> GetQueue(QueuePriority priority) { switch (priority) { case QueuePriority.High: return(_highQueue); case QueuePriority.Normal: return(_lowQueue); case QueuePriority.Low: return(_lowQueue); default: return(_normalQueue); } }
/// <summary> /// Runner /// </summary> /// <param name="runs">Runs</param> /// <param name="priority">Priority</param> /// <returns>Scalable</returns> public virtual IScalable Runner(IDynamicRuns runs, QueuePriority priority = QueuePriority.Low) { if (null == runs) { throw new ArgumentNullException("runs"); } switch (priority) { case QueuePriority.High: case QueuePriority.Medium: return(new BackoffRunner(runs, Strategy.Linear)); default: return(new AdaptiveRunner(runs, Strategy.Exponential)); } }
//TODO Change to ActionQueueItem with CancellationToken public static Task EnqueueDragDropGround(int serial, int amount, int x, int y, int z, QueuePriority priority = QueuePriority.Low, bool delaySend = true) { lock ( _actionPacketQueueLock ) { byte[] dragPacket = new DragItem(serial, amount).ToArray(); byte[] dropItem = new DropItem(serial, -1, x, y, z).ToArray(); PacketQueueItem dragPacketQueueItem = new PacketQueueItem(dragPacket, dragPacket.Length, delaySend); _actionPacketQueue.Enqueue(dragPacketQueueItem, priority); PacketQueueItem dropPacketQueueItem = new PacketQueueItem(dropItem, dropItem.Length, delaySend); _actionPacketQueue.Enqueue(dropPacketQueueItem, priority); return(new[] { dragPacketQueueItem.WaitHandle, dropPacketQueueItem.WaitHandle }.ToTask()); } }
public static Task EnqueueDragDrop(int serial, int amount, int containerSerial, QueuePriority priority = QueuePriority.Low, bool checkRange = false, bool checkExisting = false, bool delaySend = true, int x = -1, int y = -1) { lock ( _actionPacketQueueLock ) { if (checkExisting && _actionPacketQueue.Contains(e => e is ActionQueueItem aqi && aqi.Serial == serial)) { return(Task.CompletedTask); } ActionQueueItem actionQueueItem = new ActionQueueItem(check => { if (check) { Item item = Engine.Items.GetItem(serial); if (item == null || item.Distance >= DRAG_DROP_DISTANCE) { if (!MacroManager.QuietMode) { Commands.SystemMessage(Strings.Item_out_of_range___); } return(false); } } Engine.SendPacketToServer(new DragItem(serial, amount)); Thread.Sleep(50); Engine.SendPacketToServer(new DropItem(serial, containerSerial, x, y, 0)); return(true); }) { CheckRange = checkRange, DelaySend = delaySend, Serial = serial }; _actionPacketQueue.Enqueue(actionQueueItem, priority); return(actionQueueItem.WaitHandle.ToTask()); } }
/// <summary> /// Queues the patient. /// </summary> /// <param name="patientId">The patient identifier.</param> /// <param name="QueueId">The queue identifier.</param> /// <param name="queueStatus">The queue status.</param> /// <param name="priority">The priority.</param> /// <param name="ModuleId">The module identifier.</param> /// <param name="UserId">The user identifier.</param> /// <returns></returns> public int QueuePatient(int patientId, int QueueId, QueueStatus queueStatus, QueuePriority priority, int ModuleId, int UserId) { lock (this) { ClsUtility.Init_Hashtable(); ClsUtility.AddExtendedParameters("@PatientId", SqlDbType.Int, patientId); ClsUtility.AddExtendedParameters("@QueueId", SqlDbType.Int, QueueId); ClsUtility.AddExtendedParameters("@Priority", SqlDbType.Int, (int)priority); ClsUtility.AddExtendedParameters("@QueueStatus", SqlDbType.Int, queueStatus); ClsUtility.AddExtendedParameters("@ModuleId", SqlDbType.Int, ModuleId); ClsUtility.AddExtendedParameters("@UserId", SqlDbType.Int, UserId); ClsObject BillManager = new ClsObject(); DataRow row = (DataRow)BillManager.ReturnObject(ClsUtility.theParams, "WaitingList_QueuePatient", ClsUtility.ObjectEnum.DataRow); if (null != row) { return(Convert.ToInt32(row[0])); } return(-1); } }
public static Task EnqueueActionPackets(IEnumerable <BasePacket> packets, QueuePriority priority = QueuePriority.Low, bool delaySend = true) { lock ( _actionPacketQueueLock ) { List <EventWaitHandle> handles = new List <EventWaitHandle>(); foreach (BasePacket packet in packets) { byte[] data = packet.ToArray(); ActionPacketQueueItem queueItem = new ActionPacketQueueItem(data, data.Length, delaySend); handles.Add(queueItem.WaitHandle); _actionPacketQueue.Enqueue(queueItem, priority); } return(handles.ToTask()); } }
public async Task <ActionResult> Create([Bind(Include = "FileTypeID")] QueuePriority queuePriority, string QueueID) { queuePriority.QueueID = short.Parse(QueueID); if (db.QueuePriority.Where(q => q.QueueID == queuePriority.QueueID && q.FileTypeID == queuePriority.FileTypeID).ToList().Count == 1) { return(RedirectToAction("Index", new { QueueID = QueueID })); } queuePriority.QPOrder = (byte)db.QueuePriority.Where(q => q.QueueID == queuePriority.QueueID).ToList().Count; if (ModelState.IsValid) { db.QueuePriority.Add(queuePriority); await db.SaveChangesAsync(); return(RedirectToAction("Index", new { QueueID = QueueID })); } ViewBag.FileTypeID = new SelectList(db.FileType, "FileTypeID", "TypeDescription", queuePriority.FileTypeID); ViewBag.QueueID = new SelectList(db.Queue, "QueueID", "QueueDescription", queuePriority.QueueID); return(View(queuePriority)); }
public async Task <ActionResult> DeleteConfirmed([Bind(Include = "QueueID,FileTypeID,QPOrder")] QueuePriority queuePriority) { var Q = db.Queue.Find(queuePriority.QueueID); List <QueuePriority> newList = new List <QueuePriority>(); byte i = 0; foreach (var item in Q.QueuePriority) { if (item.QPOrder != queuePriority.QPOrder) { item.QPOrder = i; newList.Add(item); i++; } } Q.QueuePriority = newList; db.Entry(Q).State = EntityState.Modified; await db.SaveChangesAsync(); return(RedirectToAction("Index", Q.QueueID)); }
public void Add(IWork work, QueuePriority priority) { lock (_queueMutex) { bool mustQueue = true; while (_workWaiters.Count > 0) { WorkWaiter waiter = _workWaiters[0]; _workWaiters.Remove(waiter); if (waiter.Signal(work)) { mustQueue = false; break; } } if (mustQueue) { Queue<IWork> queue = GetQueue(priority); queue.Enqueue(work); _queueItemCount++; } } }
public static Task EquipItem(int serial, Layer layer, QueuePriority queuePriority = QueuePriority.Medium) { int containerSerial = Engine.Player?.Serial ?? 0; if (containerSerial == 0 || containerSerial == -1) { return(Task.CompletedTask); } if (layer == Layer.Invalid) { SystemMessage(Strings.Invalid_layer_value___, (int)SystemMessageHues.Red); return(Task.CompletedTask); } return(ActionPacketQueue.EnqueueAction(serial, i => { Engine.SendPacketToServer(new DragItem(i, 1)); Thread.Sleep(50); Engine.SendPacketToServer(new EquipRequest(i, layer, containerSerial)); return true; }, queuePriority)); }
public void Add(IWork work, QueuePriority priority) { lock (_queueMutex) { bool mustQueue = true; while (_workWaiters.Count > 0) { WorkWaiter waiter = _workWaiters[0]; _workWaiters.Remove(waiter); if (waiter.Signal(work)) { mustQueue = false; break; } } if (mustQueue) { Queue <IWork> queue = GetQueue(priority); queue.Enqueue(work); _queueItemCount++; } } }
private CloudQueue GetAzureQueue(QueuePriority priority, bool createIfNotExists) { if (!queues.ContainsKey(priority)) { // Retrieve storage account from connection string CloudStorageAccount storageAccount = CloudStorageAccount.Parse(connectionString); // Create the queue client CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient(); string queueName = GetQueueName(this.queueNameBase, priority); // Retrieve a reference to a queue CloudQueue queue = queueClient.GetQueueReference(queueName); // Create the queue if it doesn't already exist and the flag is set if (createIfNotExists) { queue.CreateIfNotExists(); } if (queue.Exists()) { queues.Add(priority, queue); return(queue); } else { return(null); } } else { return(queues[priority]); } }
public void SetQueuedBuildPriority(QueuePriority priority) { try { var items = this.view.SelectedActiveBuilds.ToList(); if (!items.Any()) { return; } using (new WaitCursor()) { this.repository.SetQueuedBuildPriority(items.Select(b => b.BuildDefinitionUri), priority); this.OnRefresh(new EventArgs()); } } catch (Exception ex) { this.view.DisplayError(ex); } }
private Queue<IWork> GetQueue(QueuePriority priority) { switch (priority) { case QueuePriority.High: return _highQueue; case QueuePriority.Normal: return _lowQueue; case QueuePriority.Low: return _lowQueue; default: return _normalQueue; } }
public static string GetQueueNameSuffix(QueuePriority priority = QueuePriority.Normal) { return((priority == QueuePriority.Normal) ? "" : $"-{priority.ToString().ToLower()}"); }
public IWork Add(DoWorkHandler work, string description, QueuePriority queuePriority, ThreadPriority threadPriority, WorkEventHandler workCompletedHandler) { IWork w = new Work(work, description, threadPriority, workCompletedHandler); return Add(w, queuePriority) ? w : null; }
public bool Add(IWork work, QueuePriority queuePriority) { if (!_run) return false; if (_startInfo.DelayedInit) { _startInfo.DelayedInit = false; Init(); } if (work == null) throw new ArgumentNullException("work", "cannot be null"); if (work.State != WorkState.INIT) throw new InvalidOperationException(String.Format("WorkState must be {0}", WorkState.INIT)); if (!_run) throw new InvalidOperationException("Threadpool is already (being) stopped"); work.State = WorkState.INQUEUE; _workQueue.Add(work, queuePriority); CheckThreadIncrementRequired(); return true; }
public IWork Add(DoWorkHandler work, string description, QueuePriority queuePriority) { IWork w = new Work(work, description, _startInfo.DefaultThreadPriority); return Add(w, queuePriority) ? w : null; }
public void EnqueueCommand(string command, QueuePriority priority) { _queue.Enqueue(command); }
/// <summary> /// Runner /// </summary> /// <param name="runs">Runs</param> /// <param name="priority">Priority</param> /// <returns>Scalable</returns> public virtual IScalable Runner(IDynamicRuns runs, QueuePriority priority = QueuePriority.Low) { if (null == runs) { throw new ArgumentNullException("runs"); } switch (priority) { case QueuePriority.High: case QueuePriority.Medium: return new BackoffRunner(runs, Strategy.Linear); default: return new AdaptiveRunner(runs, Strategy.Exponential); } }
/// <summary> /// Add work to be performed by the threadpool. /// Can throw ArgumentNullException and InvalidOperationException. /// </summary> /// <param name="work">DoWorkHandler which contains the work to perform</param> /// <param name="queuePriority">QueuePriority for this work</param> /// <returns>IWork reference to work object</returns> public IWork Add(DoWorkHandler work, QueuePriority queuePriority) { IWork w = new Work(work, _startInfo.DefaultThreadPriority); Add(w, queuePriority); return w; }
public static Task <bool> EnqueueDragDrop(int serial, int amount, int containerSerial, QueuePriority priority = QueuePriority.Low, bool checkRange = false, bool checkExisting = false, bool delaySend = true, int x = -1, int y = -1, CancellationToken cancellationToken = default, bool requeueOnFailure = false, Func <int, int, bool> successPredicate = null, int attempt = 0) { lock ( _actionPacketQueueLock ) { if (checkExisting && _actionPacketQueue.Contains(e => e is ActionQueueItem aqi && aqi.Serial == serial)) { return(Task.FromResult(true)); } ActionQueueItem actionQueueItem = new ActionQueueItem(param => { if (cancellationToken.IsCancellationRequested) { return(false); } if (param is bool check && check) { Item item = Engine.Items.GetItem(serial); if (item == null || item.Distance >= DRAG_DROP_DISTANCE) { Commands.SystemMessage(Strings.Item_out_of_range___, true); return(false); } } Engine.SendPacketToServer(new DragItem(serial, amount)); Thread.Sleep(DROP_DELAY); Engine.SendPacketToServer(new DropItem(serial, containerSerial, x, y, 0)); if (!requeueOnFailure || successPredicate == null || attempt >= MAX_ATTEMPTS) { return(true); } Stopwatch stopWatch = new Stopwatch(); stopWatch.Start(); Commands.WaitForContainerContents(containerSerial, Options.CurrentOptions.ActionDelayMS); bool result = successPredicate.Invoke(serial, containerSerial); if (result) { return(true); } #if DEBUG Commands.SystemMessage($"Requeue: 0x{serial:x8}"); #endif EnqueueDragDrop(serial, amount, containerSerial, priority, checkRange, checkExisting, delaySend, x, y, cancellationToken, true, successPredicate, attempt++); stopWatch.Stop(); int delayRemaining = Options.CurrentOptions.ActionDelayMS - (int)stopWatch.ElapsedMilliseconds; if (delayRemaining > 0) { Thread.Sleep(delayRemaining); } // Return false so we don't rewait the action delay return(false); }) { CheckRange = checkRange, DelaySend = delaySend, Serial = serial, Arguments = checkRange }; _actionPacketQueue.Enqueue(actionQueueItem, priority); return(actionQueueItem.WaitHandle.ToTask(() => actionQueueItem.Result)); } }
public void SetQueuedBuildPriority(IEnumerable<Uri> buildDefinitionUris, QueuePriority queuePriority) { var queuedBuildSpec = this.buildServer.CreateBuildQueueSpec(buildDefinitionUris); foreach (var build in this.buildServer.QueryQueuedBuilds(queuedBuildSpec).QueuedBuilds) { build.Priority = queuePriority; build.Save(); } }
public IWork Add(DoWorkHandler work, string description, QueuePriority queuePriority) { IWork w = new Work(work, description, _startInfo.DefaultThreadPriority); return(Add(w, queuePriority) ? w : null); }
/// <summary> /// Add work to be performed by the threadpool. /// Can throw ArgumentNullException and InvalidOperationException. /// </summary> /// <param name="work">DoWorkHandler which contains the work to perform</param> /// <param name="description">description for this work</param> /// <param name="queuePriority">QueuePriority for this work</param> /// <param name="threadPriority">System.Threading.ThreadPriority for this work</param> /// <returns>IWork reference to work object</returns> public IWork Add(DoWorkHandler work, string description, QueuePriority queuePriority, ThreadPriority threadPriority) { IWork w = new Work(work, description, threadPriority); Add(w, queuePriority); return w; }
public static string GetQueueName <T>(QueuePriority priority = QueuePriority.Normal) where T : class, IConsumer { return(KebabCaseEndpointNameFormatter.Instance.Consumer <T>() + GetQueueNameSuffix(priority)); }
public IWork Add(DoWorkHandler work, string description, QueuePriority queuePriority, ThreadPriority threadPriority, WorkEventHandler workCompletedHandler) { IWork w = new Work(work, description, threadPriority, workCompletedHandler); return(Add(w, queuePriority) ? w : null); }