private Thread BuildListenerThread()
{
return(new Thread(() =>
{
while (!isDisposing)
{
BasicDeliverEventArgs item = null;
// grab the first item where any of the consumer queues has a value
var queue = Queues
.FirstOrDefault(q => q.TryTake(out item));
// if we're dead and we didn't find an item,
// it means it's time to pack up and go home
if (isDisposing && queue == null)
{
break;
}
// if we're not dead and we didn't find an item
// lets go around again
if (!isDisposing && queue == null)
{
continue;
}
if (item == null)
{
continue;
}
var delivery = new Delivery(
item.DeliveryTag,
item.Body,
item.RoutingKey,
item.Exchange,
item.BasicProperties.ContentType,
item.BasicProperties.CorrelationId,
item.BasicProperties.ReplyTo,
item.BasicProperties.Headers);
// register the queue as a delivery listener on the delivery so that
// we can ack or nack the message depending on whether or not it was processed
delivery.RegisterDeliveryListener(queue);
// deliver the message to the delivery strategy
deliveryStrategy.Deliver(delivery);
}
logger.DebugFormat("Subscription thread terminated for: {0}", this);
}));
}
private IEnumerable <PredefinedQueue> GetQueues()
{
if (Queues != null && Queues.Any())
{
return(Queues.Select(item => Enum.Parse(typeof(PredefinedQueue), item)).Cast <PredefinedQueue>().ToList());
}
IList <PredefinedQueue> queues = Enum.GetValues(typeof(PredefinedQueue)).Cast <PredefinedQueue>().ToList();
queues.Remove(PredefinedQueue.UnknownByClient);
return(queues);
}
public async Task <Queues> AddItem(Queues item)
{
var todaysLastQueueRecord = GetTodaysLastRecord(); //to know the next serial number
item.SerialNumber = todaysLastQueueRecord == null ? 1 : ++todaysLastQueueRecord.SerialNumber;
item.ModifiedOn = item.CreatedOn = DateTime.Now;
item.ModifiedBy = item.CreatedBy = "System";
var result = await _queuesRepository.AddItem(item);
return(result);
}
/// <summary>
/// Add a WorkItemQueue to the shift, starting it if the
/// shift is currently active.
/// </summary>
public void AddQueue(WorkItemQueue queue)
{
log.Debug("{0} shift adding queue {1}", Name, queue.Name);
Queues.Add(queue);
if (IsActive)
{
queue.Start();
}
}
/// <summary>
/// Unregisters the given waypoint with this elevator.
/// </summary>
/// <param name="waypoint">The waypoint to remove from the elevator.</param>
public void UnregisterPoint(Waypoint waypoint)
{
// Remove the connection
_connectedPoints.Remove(waypoint);
_timings.Remove(waypoint);
foreach (var otherWP in _connectedPoints)
{
_timings[otherWP].Remove(waypoint);
}
Queues.Remove(waypoint);
}
private QueueObject GetQueueInternal(string queueName)
{
var returnValue = default(QueueObject);
if (Queues.ContainsKey(queueName))
{
returnValue = Queues[queueName];
}
return(returnValue);
}
public async Task <Queues> UpdateItem(Queues item)
{
var queue = await _queuesRepository.GetItem(item.QueueId);
queue.Status = item.Status;
queue.ModifiedOn = item.ModifiedOn = DateTime.Now;
queue.ModifiedBy = item.ModifiedBy = "System";
await _queuesRepository.UpdateItem(queue);
return(queue);
}
protected override void Given()
{
_queue = CreateSuccessfulTestQueue(Guid.NewGuid().ToString(),
ct => Task.FromResult(new List <Message> {
new TestMessage {
Body = _messageBody
}
}.AsEnumerable()));
Queues.Add(_queue);
}
public PriorityTransactionalRouter(string inputQueueFormatName)
{
Contract.Requires(inputQueueFormatName != null);
if (Queues.IsTransactional(inputQueueFormatName) == QueueTransactional.None)
{
throw new ArgumentException(inputQueueFormatName + " is not a transactional queue");
}
InputQueueFormatName = inputQueueFormatName;
_router = new SubQueueRouter(inputQueueFormatName, RouterByPriority);
}
public void EnqueueMultipleValues()
{
Queues <int> queue = new Queues <int>();
queue.Enqueue(10);
queue.Enqueue(11);
queue.Enqueue(12);
Assert.Equal(12, queue.Rear.Value);
queue.Enqueue(20);
Assert.Equal(10, queue.Front.Value);
}
public WorkCenter(ModelElementBase parent, string name, Distribution serviceTimeDistribution, List <LotStep> lotSteps) : base(parent, name)
{
LotSteps = lotSteps;
ServiceTimeDistribution = serviceTimeDistribution;
LotStepInService = null;
foreach (LotStep lotStep in lotSteps)
{
Queues.Add(lotStep, new CSSLQueue <Lot>(this, name + "_" + lotStep.Name + "_Queue"));
}
}
protected override void Given()
{
_queue = CreateSuccessfulTestQueue(Guid.NewGuid().ToString(), new TestMessage());
Queues.Add(_queue);
MessageLock = new FakeMessageLock();
_handler = new ExactlyOnceSignallingHandler();
Handler = _handler;
}
public void AddFiveElementsAssertCountFive()
{
var queue = new Queues <int>();
for (int i = 0; i < 5; i++)
{
queue.Enqueue(i);
}
Assert.AreEqual(5, queue.Count);
}
public void Dispose()
{
if (disposed)
{
return;
}
Queues.ForEach(Kill);
FinishedProcesses.ForEach(Kill);
FibersMap.Clear();
disposed = true;
}
public void DequeueOnQueue()
{
Queues queue = new Queues();
Node nodeOne = new Node(1);
Node nodeTwo = new Node(2);
queue.Enqueue(nodeOne);
queue.Enqueue(nodeTwo);
Assert.True(queue.Dequeue().Value == nodeOne.Value);
Assert.True(queue.Dequeue().Value == nodeTwo.Value);
Assert.Throws <NullReferenceException>(() => queue.Dequeue());
}
public void EnqueueOnQueue()
{
Queues queue = new Queues();
Node nodeOne = new Node(1);
Node nodeTwo = new Node(2);
queue.Enqueue(nodeOne);
queue.Enqueue(nodeTwo);
Assert.True(queue.front == nodeOne);
Assert.True(queue.rear == nodeTwo);
}
public void EmptyQueueThrowsException()
{
Queues <int> queue = new Queues <int>();
var dequeueResult = Assert.Throws <Exception>(() => queue.Dequeue());
var peekResult = Assert.Throws <Exception>(() => queue.Peek());
string expected = ("The queue is empty");
Assert.Equal(expected, dequeueResult.Message);
Assert.Equal(expected, peekResult.Message);
}
/*
* Method name: enQueue(Q, x)
* parameters: Queue Q and int x
* return : void
* Algorithm:
* 1.Q[Q.tail] = x
* 2.If Q.tail == Q.length
* 3. Q.tail = 1
* 4.else Q.tail = Q.tail + 1
*/
public void enQueue(Queues q, int x)
{
q.Q[q.tail] = x; //insert the new element at the tail
if (q.tail == q.Q.Length - 1)
{
q.tail = 1;
}
else
{
q.tail++;
}
}
public async Task <IResult> Request(
[Parameter(ParameterSource.Form)]
string email
)
{
if (string.IsNullOrWhiteSpace(email))
{
return(Status(BadRequest, "Missing email field"));
}
// Try to not leak information about existence of email address
await Task.Delay(TimeSpan.FromMilliseconds(new Random().Next(600, 1500)));
Database.User user = null;
var rr = await DB.RunInTransactionAsync(db => {
// TODO: Abort if we have multiple accounts with the same email
user = db.SelectSingle <Database.User>(x => string.Equals(x.Email, email, StringComparison.OrdinalIgnoreCase));
if (user != null)
{
var resetreq = db.SelectSingle <Database.ResetPasswordRequest>(x => x.UserID == user.ID);
if (resetreq != null)
{
if ((DateTime.Now - resetreq.Created) > TimeSpan.FromDays(1))
{
resetreq.Created = DateTime.Now;
resetreq.Token = Services.PasswordPolicy.GenerateActivationCode();
db.UpdateItem(resetreq);
return(resetreq);
}
}
else
{
db.InsertItem(resetreq = new Database.ResetPasswordRequest()
{
UserID = user.ID,
Token = Services.PasswordPolicy.GenerateActivationCode()
});
return(resetreq);
}
}
return(null);
});
if (user != null && rr != null)
{
await Queues.SendPasswordResetEmailAsync(user.Name, user.Email, rr.ID, Services.LocaleHelper.GetBestLocale(Ceen.Context.Request));
}
return(OK);
}
public void GetQueries_QueryByName_ReturnListQueueTransactions()
{
//Arrange
returnList.Clear();
returnList.Add(new ResponseQueue());
//Act
Queues queues = new Queues(apiController.Object);
var result = queues.GetQueues(0, "Closed");
//Assert
Assert.That(result.Count, Is.EqualTo(1));
}
public IActionResult SaveTriage()
{
Users user = new Users {
Id = long.Parse(HttpContext.User.FindFirst(ClaimTypes.Actor).Value)
};
Queues queue = IOutpatientService.GetQueue(TriageModel.Queue.Id);
Triage triage = TriageModel.Triage;
triage.Visit = queue.Visit;
triage.Queue = queue;
//Test::Mobility/Trauma/Avpu && convert to int
if (string.IsNullOrEmpty(triage.Mobility.Value))
{
triage.Mobility.Value = "0";
}
if (string.IsNullOrEmpty(triage.Trauma.Value))
{
triage.Trauma.Value = "0";
}
if (string.IsNullOrEmpty(triage.AVPU.Value))
{
triage.AVPU.Value = "0";
}
//Sanitize TextAreas
triage.Situation.Value = triage.Situation.Value.ToValidString();
triage.Background.Value = triage.Background.Value.ToValidString();
triage.Assessment.Value = triage.Assessment.Value.ToValidString();
triage.Recommendation.Value = triage.Recommendation.Value.ToValidString();
triage.Notes = triage.Notes.ToValidString();
//Save Triage
triage.CreatedBy = user;
triage.Save();
if (!queue.StartOn.HasValue)
{
queue.SeenBy = user;
queue.StartEncounter();
}
queue.CompleteEncounter();
var dest = TriageModel.SendTo;
dest.Visit = queue.Visit;
dest.CreatedBy = user;
dest.Save();
return(LocalRedirect("/outpatient/triage.queue" + (queue.CreatedOn.Date.Equals(DateTime.Now.Date) ? "" : "?date=" + TriageModel.Queue.Date)));
}
/// <summary>
/// 互换位置
/// </summary>
/// <param name="index"></param>
/// <param name="target"></param>
public void Move(int index, int target)
{
if (index > -1 && index != target)
{
var item = Queues[index];
Queues.RemoveAt(index);
Queues.InsertAt(target, new Album[] { item });//插入到指定位置
OnMergeQueueChanged(new MergeQueueEventArgs()
{
Mode = QueueChangeMode.Move
});//触发序列更改事件
}
}
/// <summary>
/// 加入拼合
/// </summary>
/// <param name="array"></param>
public void Add(params Album[] array)
{
for (var i = 0; i < array.Length; i++)
{
array[i] = array[i].Clone();
}
Queues.AddRange(array);
OnMergeQueueChanged(new MergeQueueEventArgs()
{
Mode = QueueChangeMode.Add,
Tag = array
});
}
public void Setup()
{
dataFN = Queues.TryCreate(@".\private$\server.data", QueueTransactional.None);
requestFN = Queues.TryCreate(@".\private$\server.control", QueueTransactional.None);
replyFN = Queues.TryCreate(@".\private$\server.client1", QueueTransactional.None);
Queues.Purge(dataFN);
Queues.Purge(requestFN);
Queues.Purge(replyFN);
server = new LabelSubscriptionServer(requestFN, dataFN);
server.StartAsync().Wait();
}
private Queue GetQueue(string name)
{
if (!Queues.Any(x => x.Name == name))
{
var result = new Queue(name);
Queues.Add(result);
return(result);
}
return(Queues.Single(x => x.Name == name));
}
protected override void Given()
{
var queue = CreateSuccessfulTestQueue(Guid.NewGuid().ToString(),
() => new List <Message> {
new TestMessage {
Body = _messageBody
}
});
_sqsClient = queue.FakeClient;
Queues.Add(queue);
}
public void CanDequeueOutOfQueue()
{
Queues <int> queue = new Queues <int>();
queue.Enqueue(10);
queue.Enqueue(11);
queue.Enqueue(12);
Node <int> returned = queue.Dequeue();
int expected = 10;
Assert.Equal(expected, returned.Value);
}
public void Setup()
{
requestQueueFormatName = Queues.TryCreate(requestQueuePath, QueueTransactional.None);
replyQueueFormatName = Queues.TryCreate(replyQueuePath, QueueTransactional.None);
adminQueueFormatName = Queues.TryCreate(adminQueuePath, QueueTransactional.None);
Queues.Purge(requestQueueFormatName);;
Queues.Purge(replyQueueFormatName);;
Queues.Purge(adminQueueFormatName);;
postman = new Postman(adminQueueFormatName);
postman.StartAsync();
}
public void PeekIntoQueueAndSeeExpectedValue()
{
Queues <int> queue = new Queues <int>();
queue.Enqueue(10);
queue.Enqueue(11);
queue.Enqueue(12);
int returned = queue.Peek();
int expected = 10;
Assert.Equal(expected, returned);
}
private void AddQueueAction()
{
Queue newAccount = new Queue
{
Id = Guid.NewGuid(),
Name = QueueName,
IsStartLoadAt = false,
IsStopLoadAt = false,
};
Queues.Add(newAccount);
dataStorage.Save(Queues);
}
/// <summary>
/// Add a message to the given queue.
/// </summary>
/// <param name="queue"></param>
/// <param name="message"></param>
public void AddMessage(Queues queue, object message)
{
//TODO: stubbed method.
var js = new JsonSerializer();
//serialise object.
var smessage = JsonConvert.SerializeObject(message);
var data = Encoding.UTF8.GetBytes(smessage);
//add to queue
//check queue exists
Channel.QueueDeclare(queue.ToString(), false, false, false, null);
//publish
Channel.BasicPublish("", queue.ToString(), null, data);
}
private void Receive(Queues queuesToListenOn)
{
//TODO: When we recieve a message we need to subscibe to notifications from the queue again, this method lets us subscribe to one or both
if (isRunning)
{
if (queuesToListenOn.HasFlag(Queues.Input))
{
inputChannel.BeginReceive(new TimeSpan(0, 0, 0, ConfigurationSettings.PollingTimeout));
}
if (queuesToListenOn.HasFlag(Queues.Control))
{
//TODO: subscribe to messages on the control queue
}
}
}
private void btnProcTestQueue_Click(object sender, EventArgs e)
{
//disable the button
btnProcTestQueue.Enabled = false;
//init the queue
var queue = new Queues(Properties.Settings.Default.AzureConnection, "testqueue");
//build a object to be serialized and sent to the queue
var obj = new QueueObject() {PartitionKey = tbQPartitionKey.Text, RowKey = tbQRowKey.Text };
//add it to the queue
queue.Insert(JsonConvert.SerializeObject(obj), 20);
//lets go ahead and start a task to wait for the queue and process it
var taskList = new List<Task>();
var task = StartThread();
taskList.Add(task);
var context = TaskScheduler.FromCurrentSynchronizationContext();
Task.Factory.ContinueWhenAll(taskList.ToArray(), ThreadsComplete, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, context);
}
/// <summary>
/// Discards message to the Discard queue. Optionally acknowledges message too. Defaults to acknoweldging
/// </summary>
/// <param name="queue"></param>
/// <param name="message"></param>
/// <param name="acknowledge"></param>
public void DiscardMessage(Queues queue, BasicDeliverEventArgs message, bool acknowledge = true)
{
if(acknowledge) Acknowledge(message.DeliveryTag);
AddMessage(Queues.Discards, new Discard { Queue = queue, Message = Encoding.UTF8.GetString(message.Body) });
}
/// <summary>
/// Get a consumer for a queue. Optional acknowedge required.
/// </summary>
/// <param name="queue"></param>
/// <param name="noAck">Defaults to false - i.e you need to ack. </param>
/// <returns></returns>
public QueueingBasicConsumer GetBasicConsumer(Queues queue, bool noAck = false)
{
var ret = new QueueingBasicConsumer(Channel);
Channel.BasicConsume(queue.ToString(), noAck, ret);
return ret;
}
public Subscription GetSubscription(Queues queue)
{
return new Subscription(Channel, queue.ToString());
}
public void DiscardMessage(Queues queue, string message)
{
AddMessage(Queues.Discards, new Discard{Queue = queue, Message = message});
}
private void RunProcess(IProgress<List<string>> progress)
{
//init the queue
var queue = new Queues(Properties.Settings.Default.AzureConnection, "testqueue");
var updateList = new List<string>();
var done = false;
var ctr = 20;
while (!done)
{
//check queue
updateList.Add("Checking for queue");
progress.Report(updateList);
var queueObj = queue.GetNextMessage(TimeSpan.FromSeconds(20));
//process if there was one found
if (queueObj != null)
{
updateList.Add("Queue item found: " + queueObj.AsString);
progress.Report(updateList);
updateList.Add("Process");
progress.Report(updateList);
updateList.Add("De-queue");
progress.Report(updateList);
queue.DeQueue(queueObj);
updateList.Add("Queue finished");
progress.Report(updateList);
done = true;
}
if (!done)
{
Thread.Sleep(5000);
ctr--;
if (ctr == 0)
done = true;
}
}
updateList.Add("done");
progress.Report(updateList);
}
private void Receive(Queues queuesToListenOn)
{
if (isRunning)
{
if (queuesToListenOn.HasFlag(Queues.Input))
{
inputChannel.BeginReceive(new TimeSpan(0, 0, 0, ConfigurationSettings.PollingTimeout));
}
if (queuesToListenOn.HasFlag(Queues.Control))
{
controlChannel.BeginReceive(new TimeSpan(0, 0, 0, ConfigurationSettings.PollingTimeout));
}
}
}
