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