private void CompressorAction(
string inputFile,
string outputFile,
IBlockWorker <ByteBlock> blockReader,
IBlockCompressor <ByteBlock> blockCompressor,
IBlockWorker <ByteBlock> blockWriter)
{
var inputQueue = new SharedQueue <ByteBlock>(new SimpleQueue <ByteBlock>(), _inputQueueSize);
var outputQueue = new SharedQueue <ByteBlock>(new SortedQueue <ByteBlock>(), _outputQueueSize, _compressorsNumber);
using (var inputStream = File.Open(Path.GetFullPath(inputFile), FileMode.Open, FileAccess.Read))
{
ThreadStarter.StartThread(() => blockReader.Start(inputStream, inputQueue));
foreach (var _ in Enumerable.Range(0, _compressorsNumber))
{
ThreadStarter.StartThread(() => blockCompressor.Start(inputQueue, outputQueue));
}
using (var outputStream = File.Open(Path.GetFullPath(outputFile), FileMode.Create, FileAccess.Write))
{
blockWriter.Start(outputStream, outputQueue);
}
}
}
public void Given_Valid_Arguments_When_Process_Invoked_Then_true_Asserted()
{
Thread thread = new Thread(new ThreadStart(m_processor.Process));
thread.Start();
int count = vitalsRepo.ReadAllVitals("Pat111").Count;
PatientVitals vitals = new PatientVitals
{
PatientId = "Pat111",
Vitals = new List <Vitals>()
};
vitals.Vitals.Add(new Vitals
{
DeviceId = "Dev111",
Value = 51
});
SharedQueue queue = SharedQueue.Instance;
queue.Enqueue(vitals);
Thread.Sleep(10000);
Assert.AreEqual(count + 1, vitalsRepo.ReadAllVitals("Pat111").Count);
thread.Abort();
File.Delete("C:\\VitalsDB\\TestDatabase\\Pat111.txt");
}
public void TestRecoverAfterCancel_()
{
UTF8Encoding enc = new UTF8Encoding();
Channel.BasicPublish("", Queue, null, enc.GetBytes("message"));
EventingBasicConsumer Consumer = new EventingBasicConsumer(Channel);
SharedQueue <BasicDeliverEventArgs> EventQueue = new SharedQueue <BasicDeliverEventArgs>();
Consumer.Received += (_, e) => EventQueue.Enqueue(e);
string CTag = Channel.BasicConsume(Queue, false, Consumer);
BasicDeliverEventArgs Event = EventQueue.Dequeue();
Channel.BasicCancel(CTag);
Channel.BasicRecover(true);
EventingBasicConsumer Consumer2 = new EventingBasicConsumer(Channel);
SharedQueue <BasicDeliverEventArgs> EventQueue2 = new SharedQueue <BasicDeliverEventArgs>();
Consumer2.Received += (_, e) => EventQueue2.Enqueue(e);
Channel.BasicConsume(Queue, false, Consumer2);
BasicDeliverEventArgs Event2 = EventQueue2.Dequeue();
CollectionAssert.AreEqual(Event.Body.ToArray(), Event2.Body.ToArray());
Assert.IsFalse(Event.Redelivered);
Assert.IsTrue(Event2.Redelivered);
}
public void CloseBehviour()
{
var queue = new SharedQueue();
queue.Enqueue("Hello World");
//queue.Close();
var item = queue.Dequeue().ToString();
Console.Out.WriteLine("item = {0}", item);
ThreadPool.QueueUserWorkItem(state =>
{
// expect the queue to block here
Console.WriteLine("Dequeue in thread");
try
{
var item2 = queue.Dequeue().ToString();
}
catch (Exception e)
{
Console.WriteLine("Exception in thread\n{0}", e.ToString());
}
});
Thread.Sleep(100);
Console.WriteLine("Closing queue");
queue.Close();
Console.WriteLine("Done");
}
public void TestEnumerator()
{
SharedQueue q = new SharedQueue();
VolatileInt c1 = new VolatileInt();
VolatileInt c2 = new VolatileInt();
Thread t1 = new Thread(delegate() {
foreach (int v in q)
{
c1.v += v;
}
});
Thread t2 = new Thread(delegate() {
foreach (int v in q)
{
c2.v += v;
}
});
t1.Start();
t2.Start();
q.Enqueue(1);
q.Enqueue(2);
q.Enqueue(3);
q.Close();
t1.Join();
t2.Join();
Assert.AreEqual(6, c1.v + c2.v);
}
public void tcp_frontend_inproc_backend()
{
const string FrontEndpoint = "tcp://127.0.0.1:10001";
const string BackEndpoint = "inproc://sharedq1";
using (var queue = new SharedQueue(base.Context, FrontEndpoint, BackEndpoint))
{
queue.Start();
// to test it, we need to send something to the front, and get it at the back
using (var request = base.Context.Req())
using (var reply = base.Context.Rep())
{
reply.Connect(BackEndpoint);
request.Connect(FrontEndpoint);
const string reqData = "Can I get a grande, non-fat, no whip Mocha, please?";
request.Send(reqData);
var rcData = reply.RecvString();
Assert.AreEqual(reqData, rcData);
const string replyData = "Here's your drink";
reply.Send(replyData);
var result = request.RecvString();
Assert.AreEqual(replyData, result);
}
}
}
public void TestEnumerator()
{
var queue = new SharedQueue();
var c1 = new VolatileInt();
var c2 = new VolatileInt();
var thread1 = new Thread(() => { foreach (int v in queue)
{
c1.v += v;
}
});
var thread2 = new Thread(() => { foreach (int v in queue)
{
c2.v += v;
}
});
thread1.Start();
thread2.Start();
queue.Enqueue(1);
queue.Enqueue(2);
queue.Enqueue(3);
queue.Close();
thread1.Join();
thread2.Join();
Assert.AreEqual(6, c1.v + c2.v);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="timeout">Timeout for publishing an event</param>
internal PublishManager(UInt32 timeout)
{
this.timeout = timeout;
this.retryAttempts = 3u;
this.retryPause = 1000u;
try
{
eventQueue = new SharedQueue(eventQueueName, 100);
if (eventQueue == null)
{
throw new PubSubConnectionFailedException("Connection to the Event System failed");
}
}
catch (SharedQueueDoesNotExistException e)
{
throw new PubSubQueueDoesNotExistException(e.Message, e.InnerException);
}
catch (SharedQueueInsufficientMemoryException e)
{
throw new PubSubInsufficientMemoryException(e.Message, e.InnerException);
}
catch (SharedQueueInitializationException e)
{
throw new PubSubInitializationException(e.Message, e.InnerException);
}
}
public ProcessingUnit(IVitalsRepository vitalsRepo, IAlertManager alertManager, IVitalsAlertManager vitalsManager, IAdmissionRepository admissionRepository)
{
m_queue = SharedQueue.Instance;
m_vitalsRepository = vitalsRepo;
m_validator = new VitalsRangeValidator(admissionRepository);
m_alertManager = alertManager;
m_vitalsManager = vitalsManager;
}
private void MakeQueueSet(int staleTime)
{
_queueSet = new SharedQueueSet <int>("QueueSet", staleTime);
_queue1 = _queueSet.NewQueue("Queue1");
_queue2 = _queueSet.NewQueue("Queue2");
_queue3 = _queueSet.NewQueue("Queue3/4");
_queue4 = _queueSet.NewQueue("Queue3/4");
}
public void TestDequeueNoWait2()
{
var q = new SharedQueue();
q.Enqueue(1);
Assert.AreEqual(1, q.Dequeue());
Assert.AreEqual(0, q.DequeueNoWait(0));
}
public void Setup()
{
sut = new ResequencingDeduplicationFilter();
output = new SharedQueue();
input = new SharedQueue();
model = Substitute.For <IModel>();
StartFiltering().WaitForStart();
}
public void TestDequeueNoWait1()
{
var queue = new SharedQueue();
queue.Enqueue(1);
Assert.AreEqual(1, queue.DequeueNoWait(0));
Assert.AreEqual(0, queue.DequeueNoWait(0));
}
public static void MyShowInThread(IAcquirerParam param, SharedQueue <Object> objs)
{
_objs = objs;
_param = param;
ThreadStart start = new ThreadStart(func);
Thread th = new Thread(start);
th.Start();
}
public override void Start()
{
if (eventQueue == null)
{
eventQueue = new SharedQueue(localPublish.EventQueueName, localPublish.EventQueueSize, (uint)localPublish.AverageEventSize);
}
ListenToEvents();
}
public void TestTimeoutNegative()
{
var q = new SharedQueue();
ResetTimer();
bool r = q.Dequeue(TimeSpan.FromMilliseconds(-10000), out object v);
Assert.Greater(SafetyMargin, ElapsedMs());
Assert.IsTrue(!r);
Assert.AreEqual(null, v);
}
public void TestTimeoutLong()
{
var q = new SharedQueue();
ResetTimer();
bool r = q.Dequeue(TimingInterval, out object v);
Assert.Less(TimingInterval - SafetyMargin, ElapsedMs());
Assert.IsTrue(!r);
Assert.AreEqual(null, v);
}
public void ClearConsumers()
{
sharedQueue.Close(); // Dequeue will stop blocking and throw an EndOfStreamException
lock (sharedQueueLock)
{
logger.DebugWrite("Clearing consumer subscriptions");
sharedQueue = new SharedQueue();
subscriptions.Clear();
}
}
public void TestDelayedEnqueue()
{
var q = new SharedQueue();
ResetTimer();
EnqueueAfter(TimingInterval, q, 1);
Assert.AreEqual(0, q.DequeueNoWait(0));
Assert.Greater(TimingInterval - SafetyMargin, ElapsedMs());
Assert.AreEqual(1, q.Dequeue());
Assert.Less(TimingInterval - SafetyMargin, ElapsedMs());
}
public ImageScaner(IAcquirerParam param, SharedQueue <Object> objs)
{
// _msgs = objs;
InitializeComponent();
twainDevice = new twain();
twainDevice.Init(this.Handle);
this.ShowInTaskbar = false;
this.DialogResult = DialogResult.Cancel;
this.Text = "扫描";
// this.HandleDestroyed += ImageScaner_HandleDestroyed;
// this.TopLevel = true;
}
public void TestTimeoutNegative()
{
var q = new SharedQueue();
ResetTimer();
object v;
bool r = q.Dequeue(-10000, out v);
Assert.Greater(SafetyMargin, ElapsedMs());
Assert.IsTrue(!r);
Assert.AreEqual(null, v);
}
public void TestCloseWhenWaiting()
{
var q = new SharedQueue();
var de = new DelayedEnqueuer(q, 0, null);
var t =
new Thread(de.BackgroundEofExpectingDequeue);
t.Start();
Thread.Sleep(SafetyMargin);
q.Close();
t.Join();
}
private void DismissComplete(bool cleanup)
{
this._IsVisible = false;
this.TearDown();
SetCurrentAlertView(null);
SIAlertView nextAlertView = null;
int index = SharedQueue.IndexOf(this);
if (index > -1 && index < SharedQueue.Count() - 1)
{
nextAlertView = SharedQueue[index + 1];
}
if (cleanup)
{
SharedQueue.Remove(this);
}
SetAnimating(false);
if (_IsVisible)
{
if (this.DidDismissHandler != null)
{
this.DidDismissHandler.Invoke(this);
}
NSNotificationCenter.DefaultCenter.PostNotificationName(Constants.SIAlertViewDidDismissNotification, this, null);
}
// check if we should show next alert
if (_IsVisible)
{
return;
}
if (nextAlertView != null)
{
nextAlertView.Show();
}
else
{
// show last alert view
if (SharedQueue.Count > 0)
{
SIAlertView alert = SharedQueue.Last();
alert.Show();
}
}
}
public void TestTimeoutInfinite()
{
var q = new SharedQueue();
EnqueueAfter(TimingInterval, q, 123);
ResetTimer();
bool r = q.Dequeue(Timeout.InfiniteTimeSpan, out object v);
Assert.Less(TimingInterval - SafetyMargin, ElapsedMs());
Assert.IsTrue(r);
Assert.AreEqual(123, v);
}
public void TestTimeoutShort()
{
var q = new SharedQueue();
q.Enqueue(123);
ResetTimer();
bool r = q.Dequeue(TimingInterval, out object v);
Assert.Greater(SafetyMargin, ElapsedMs());
Assert.IsTrue(r);
Assert.AreEqual(123, v);
}
public void TestBgLong()
{
var q = new SharedQueue();
EnqueueAfter(TimingInterval * 2, q, 123);
ResetTimer();
bool r = q.Dequeue(TimingInterval, out object v);
Assert.Greater(TimingInterval + SafetyMargin, ElapsedMs());
Assert.IsTrue(!r);
Assert.AreEqual(null, v);
}
public void TestBgShort()
{
var q = new SharedQueue();
EnqueueAfter(TimingInterval, q, 123);
ResetTimer();
object v;
bool r = q.Dequeue(TimingInterval * 2, out v);
Assert.Less(TimingInterval - SafetyMargin, ElapsedMs());
Assert.IsTrue(r);
Assert.AreEqual(123, v);
}
/// <summary>
/// Dispose for SubscriptionManager
/// </summary>
/// <param name="disposing">True if disposing.</param>
protected virtual void Dispose(bool disposing)
{
if (!disposed)
{
try
{
lock (lockObject)
{
foreach (Dictionary <string, Subscription> subs in subscriptions.Values)
{
foreach (Subscription sub in subs.Values)
{
RemoveSubscription(sub.SubscriptionEventType, sub.LocalOnly, sub.MethodBody, sub.UsingLibraries, sub.ReferencedAssemblies);
}
}
eventQueue.Dispose();
eventQueue = null;
publishMgrRefCount--;
if (publishMgrRefCount == 0)
{
publishMgr.Dispose();
publishMgr = null;
}
}
}
catch
{
// intentionally left empty
}
finally
{
disposed = true;
if (disposing)
{
GC.SuppressFinalize(this);
}
}
}
}
public void TestCloseWhenFull()
{
var q = new SharedQueue();
q.Enqueue(1);
q.Enqueue(2);
q.Enqueue(3);
q.Close();
var de = new DelayedEnqueuer(q, 0, 4);
ExpectEof(de.EnqueueValue);
Assert.AreEqual(1, q.Dequeue());
Assert.AreEqual(2, q.DequeueNoWait(0));
bool r = q.Dequeue(TimeSpan.FromMilliseconds(1), out object v);
Assert.IsTrue(r);
Assert.AreEqual(3, v);
ExpectEof(de.Dequeue);
}
public void TestCloseWhenFull()
{
SharedQueue q = new SharedQueue();
object v;
q.Enqueue(1);
q.Enqueue(2);
q.Enqueue(3);
q.Close();
DelayedEnqueuer de = new DelayedEnqueuer(q, 0, 4);
ExpectEof(new Thunk(de.EnqueueValue));
Assert.AreEqual(1, q.Dequeue());
Assert.AreEqual(2, q.DequeueNoWait(0));
bool r = q.Dequeue(1, out v);
Assert.IsTrue(r);
Assert.AreEqual(3, v);
ExpectEof(new Thunk(de.Dequeue));
}
public QueueingNoAckBasicConsumer(IModel model, SharedQueue<BasicDeliverEventArgs> queue)
: base(model, queue)
{
}
public TransactionalQueueConsumer(IModel model, SharedQueue<BasicDeliverEventArgs> queue)
: base(model, queue)
{
}
///<summary>Creates a fresh QueueingBasicConsumer,
///initializing the Model and Queue properties to the given
///values.</summary>
protected QueueingBasicConsumerBase(IModel model, SharedQueue<BasicDeliverEventArgs> queue)
: base(model)
{
_queue = queue;
}
