public bool Wait(TimeSpan timeout)
{
SpinWait s = new SpinWait();
bool waitResult = true;
while (m_state == 0)
{
if (s.Spin() >= s_spinCount)
{
if (m_eventObj == null)
{
ManualResetEvent newEvent =
new ManualResetEvent(m_state == 1);
if (Interlocked.CompareExchange<EventWaitHandle>(
ref m_eventObj, newEvent, null) == null)
{
// If someone set the flag before seeing the new
// event obj, we must ensure it’s been set.
if (m_state == 1)
m_eventObj.Set();
}
else
{
// Lost the race w/ another thread. Just use
// its event.
newEvent.Close();
}
}
waitResult = m_eventObj.WaitOne(timeout);
}
}
return waitResult;
}
public static void Run()
{
var queue = new ConcurrentQueue<int>();
// begin
var producer = Task.Run(() =>
{
foreach (var value in Enumerable.Range(1, 10000))
{
queue.Enqueue(value);
}
});
var consumer = Task.Run(() =>
{
var spinWait = new SpinWait();
var value = 0;
while (value != 10000)
{
if (!queue.TryDequeue(out value))
{
spinWait.SpinOnce();
continue;
}
Logger.Log("Value: {0}", value);
}
});
Task.WaitAll(producer, consumer);
// end
}
public void Clear()
{
lock (clearLock)
{
isSend = false;
if (sendDataQueue.Count > 0)
{
SendData cmd;
if (!sendDataQueue.TryDequeue(out cmd))
{
SpinWait spinWait = new SpinWait();
while (sendDataQueue.TryDequeue(out cmd))
{
spinWait.SpinOnce();
}
}
}
if (InterimPacketBuffer != null)
{
Session.Pool.FixedBufferPool.Push(InterimPacketBuffer);
InterimPacketBuffer = null;
}
while (ReceiveBuffers.Count > 0)
{
var packetBuffer = ReceiveBuffers.Dequeue();
Session.Pool.FixedBufferPool.Push(packetBuffer);
}
}
SendBuffer.Clear();
NoComplateCmd = null;
alreadyReceivePacketLength = 0;
needReceivePacketLenght = 0;
}
public static void RunSpinWaitTests()
{
SpinWait spinner = new SpinWait();
spinner.SpinOnce();
Assert.Equal(spinner.Count, 1);
}
public void Enter() {
// If calling thread already owns the lock, increment recursion count and return
Int32 threadId = Thread.CurrentThread.ManagedThreadId;
if (threadId == m_owningThreadId) { m_recursion++; return; }
// The calling thread doesn't own the lock, try to get it
SpinWait spinwait = new SpinWait();
for (Int32 spinCount = 0; spinCount < m_spincount; spinCount++) {
// If the lock was free, this thread got it; set some state and return
if (Interlocked.CompareExchange(ref m_waiters, 1, 0) == 0) goto GotLock;
// Black magic: give other threads a chance to run
// in hopes that the lock will be released
spinwait.SpinOnce();
}
// Spinning is over and the lock was still not obtained, try one more time
if (Interlocked.Increment(ref m_waiters) > 1) {
// Still contention, this thread must wait
m_waiterLock.WaitOne(); // Wait for the lock; performance hit
// When this thread wakes, it owns the lock; set some state and return
}
GotLock:
// When a thread gets the lock, we record its ID and
// indicate that the thread owns the lock once
m_owningThreadId = threadId; m_recursion = 1;
}
internal bool SlowEnter (StCancelArgs cargs)
{
int lastTime = (cargs.Timeout != Timeout.Infinite) ? Environment.TickCount : 0;
StWaitBlock wb = null;
do {
int sc = spinCount;
#if NET_4_0
var spinWait = new SpinWait ();
#endif
do {
if (state == FREE &&
Interlocked.CompareExchange (ref state, BUSY, FREE) == FREE) {
return true;
}
if (top != null || sc-- <= 0) {
break;
}
#if NET_4_0
spinWait.SpinOnce ();
#else
Thread.SpinWait (1);
#endif
} while (true);
if (wb == null) {
wb = new StWaitBlock (1);
} else {
wb.parker.Reset ();
}
do {
StWaitBlock t;
wb.next = t = top;
if (Interlocked.CompareExchange (ref top, wb, t) == t) {
break;
}
} while (true);
if (TryEnter ()) {
wb.parker.SelfCancel ();
return true;
}
int ws = wb.parker.Park (cargs);
if (ws != StParkStatus.Success) {
cargs.ThrowIfException (ws);
return false;
}
if (TryEnter ()) {
return true;
}
if (!cargs.AdjustTimeout (ref lastTime)) {
return false;
}
} while (true);
}
public void ParticipateUntil (Func<bool> predicate)
{
SpinWait sw = new SpinWait ();
while (!predicate ())
sw.SpinOnce ();
}
public PowerRegulator()
{
_Sample = 1.0f;
_SpinWait = new SpinWait();
_SpinCount = 0;
_WorkCount = 0;
_Busy = 0;
_TimeCount = new TimeCounter();
_FPS = new FPSCounter();
}
public void ParallelForTestCase ()
{
ParallelTestHelper.Repeat (() => {
int[] expected = Enumerable.Range (1, 1000).Select ((e) => e * 2).ToArray ();
int[] actual = Enumerable.Range (1, 1000).ToArray ();
SpinWait sw = new SpinWait ();
Parallel.For (0, actual.Length, (i) => { actual[i] *= 2; sw.SpinOnce (); });
CollectionAssert.AreEquivalent (expected, actual, "#1, same");
CollectionAssert.AreEqual (expected, actual, "#2, in order");
});
}
public static bool SpinUntil (Func<bool> condition, int millisecondsTimeout)
{
SpinWait sw = new SpinWait ();
Watch watch = Watch.StartNew ();
while (!condition ()) {
if (watch.ElapsedMilliseconds > millisecondsTimeout)
return false;
sw.SpinOnce ();
}
return true;
}
private void run(CancellationToken token)
{
var list = new List<Entry>(_maxBatchSize);
Logger.Info("[StorageWriter] Entering main loop. {0}", _maxBatchSize);
var spinWait = new SpinWait();
while (token.IsCancellationRequested == false)
{
try
{
while (list.Count < _maxBatchSize)
{
Entry entry;
if (_queue.TryDequeue(out entry) == false)
{
break;
}
Logger.Debug("[StorageWriter] Got something to write...");
if (entry.ShouldDrop())
{
Logger.Debug("[StorageWriter] Dropping message....too old.");
entry.Harikiri();
}
else
list.Add(entry);
}
if (list.Count > 0)
{
store(list.ToArray());
list.Clear();
}
else
{
spinWait.SpinOnce();
}
}
catch (Exception e)
{
Logger.Warn("[StorageWriter] Error in mainloop.", e);
}
_spinwait.SpinOnce();
}
Logger.Info("[StorageWriter] Exiting. No more spinning for me today...");
}
public void EnterReadLock()
{
SpinWait sw = new SpinWait();
do
{
while ((rwlock & (RwWrite | RwWait)) > 0)
sw.SpinOnce();
if ((Interlocked.Add(ref rwlock, RwRead) & (RwWait | RwWait)) == 0)
return;
Interlocked.Add(ref rwlock, -RwRead);
} while (true);
}
/// <summary>
/// 循环工作
/// </summary>
private static void LoopWork()
{
var spinWait = new SpinWait();
while (true)
{
lock (syncRoot)
{
foreach (var item in actions)
{
item.Invoke();
}
}
spinWait.SpinOnce();
}
}
/// <summary>在指定条件得到满足或指定超时过期之前自旋。</summary>
/// <returns>如果条件在超时时间内得到满足，则为 true；否则为 false</returns>
/// <param name="condition">在返回 true 之前重复执行的委托。</param>
/// <param name="millisecondsTimeout">等待的毫秒数，或为 <see cref="F:System.Threading.Timeout.Infinite" /> (-1)，表示无限期等待。</param>
/// <exception cref="T:System.ArgumentNullException"><paramref name="condition" /> 参数为 null。</exception>
/// <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="millisecondsTimeout" /> 是一个非 -1 的负数，而 -1 表示无限期超时。</exception>
public static bool SpinUntil(Func<bool> condition, int millisecondsTimeout)
{
if (millisecondsTimeout < -1) throw new ArgumentOutOfRangeException("millisecondsTimeout");
if (condition == null) throw new ArgumentNullException("condition");
long ticks = 0;
if (millisecondsTimeout != 0 && millisecondsTimeout != -1) ticks = DateTime.UtcNow.Ticks;
SpinWait wait = new SpinWait();
while (!condition())
{
if (millisecondsTimeout == 0) return false;
wait.SpinOnce();
if (millisecondsTimeout != -1 && wait.NextSpinWillYield && millisecondsTimeout <= (DateTime.UtcNow.Ticks - ticks) / 10000) return false;
}
return true;
}
public override Event Dequeue()
{
Event result = null;
SpinWait spinWait = new SpinWait();
while (!closing)
{
if (queue.TryDequeue(out result))
{
break;
}
spinWait.SpinOnce();
}
return result;
}
public static int SendWithTimeout(this ZmqSocket socket, byte[] buffer, int length, TimeSpan timeout)
{
var stopwatch = Stopwatch.StartNew();
var spinWait = new SpinWait();
int result;
do
{
result = socket.Send(buffer, length, SocketFlags.DontWait);
if (socket.SendStatus != SendStatus.TryAgain)
break;
spinWait.SpinOnce();
}
while (stopwatch.Elapsed <= timeout);
return result;
}
public static bool SpinWaitForCondition(Func<bool> predicate, int timeout)
{
Thread.MemoryBarrier();
var sw = new Stopwatch();
var spin = new SpinWait();
sw.Start();
while (sw.ElapsedMilliseconds < timeout)
{
if (predicate())
{
sw.Stop();
return true;
}
spin.SpinOnce();
}
sw.Stop();
return false;
}
protected override void ConsumeItems( int count )
{
SpinWait spinWait = new SpinWait();
int value;
for ( int i = 0; i < count; )
{
if ( this.queue.TryDequeue( out value ) )
{
i++;
spinWait.Reset();
}
else
{
spinWait.SpinOnce();
}
}
}
public void EnterWriteLock()
{
SpinWait sw = new SpinWait();
do
{
int state = rwlock;
if (state < RwWrite)
{
if (Interlocked.CompareExchange(ref rwlock, RwWrite, state) == state)
return;
state = rwlock;
}
// We register our interest in taking the Write lock (if upgradeable it's already done)
while ((state & RwWait) == 0 && Interlocked.CompareExchange(ref rwlock, state | RwWait, state) != state)
state = rwlock;
// Before falling to sleep
while (rwlock > RwWait)
sw.SpinOnce();
} while (true);
}
public void EnterReadLock (ref bool taken)
{
if (taken)
throw new ArgumentException ("taken", "taken needs to be set to false");
SpinWait sw = new SpinWait ();
bool cont = true;
do {
while ((rwlock & (RwWrite | RwWait)) > 0)
sw.SpinOnce ();
try {}
finally {
if ((Interlocked.Add (ref rwlock, RwRead) & (RwWait | RwWait)) == 0) {
taken = true;
cont = false;
} else {
Interlocked.Add (ref rwlock, -RwRead);
}
}
} while (cont);
}
private void ProcessQueue()
{
// We cannot do a CAS and exit the method is this.currentThread is not null, because this field is set
// after the this.workItemsCount field is decremented. Field this.workItemsCount, and not this.currentThread,
// guarantees there is a single running thread.
this.currentThread = Thread.CurrentThread;
// Set the SynchronizationContext to ensure await goes back to the right context.
SynchronizationContext oldSynchronizationContext = SynchronizationContext.Current;
SynchronizationContext.SetSynchronizationContext( this.SynchronizationContext );
try
{
SpinWait spinWait = new SpinWait();
do
{
IAction action;
while ( !this.workItems.TryDequeue( out action ) )
{
spinWait.SpinOnce();
}
// TODO: Cooperative multitasking: Avoid processing the whole queue if it's very long.
// Rather interrupt and requeue a ProcessQueue task. Use Stopwatch
action.Invoke();
#pragma warning disable 420
} while ( Interlocked.Decrement( ref this.workItemsCount ) > 0 );
#pragma warning restore 420
}
finally
{
this.currentThread = null;
SynchronizationContext.SetSynchronizationContext( oldSynchronizationContext );
}
}
// Helper method to avoid repeating Break() logic between ParallelState64 and ParallelState64<TLocal>
internal static void Break(long iteration, ParallelLoopStateFlags64 pflags)
{
int oldValue = ParallelLoopStateFlags.PLS_NONE;
// Attempt to change state from "not stopped or broken or canceled or exceptional" to "broken".
if (!pflags.AtomicLoopStateUpdate(ParallelLoopStateFlags.PLS_BROKEN,
ParallelLoopStateFlags.PLS_STOPPED | ParallelLoopStateFlags.PLS_EXCEPTIONAL | ParallelLoopStateFlags.PLS_CANCELED,
ref oldValue))
{
// If we were already stopped, we have a problem
if ((oldValue & ParallelLoopStateFlags.PLS_STOPPED) != 0)
{
throw new InvalidOperationException(
Environment.GetResourceString("ParallelState_Break_InvalidOperationException_BreakAfterStop"));
}
else
{
// Apparently we previously got cancelled or became exceptional. No action necessary
return;
}
}
// replace shared LowestBreakIteration with CurrentIteration, but only if CurrentIteration
// is less than LowestBreakIteration.
long oldLBI = pflags.LowestBreakIteration;
if (iteration < oldLBI)
{
SpinWait wait = new SpinWait();
while (Interlocked.CompareExchange(
ref pflags.m_lowestBreakIteration,
iteration,
oldLBI) != oldLBI)
{
wait.SpinOnce();
oldLBI = pflags.LowestBreakIteration;
if (iteration > oldLBI) break;
}
}
}
public bool Wait(int millisecondsTimeout, CancellationToken cancellationToken) {
if (millisecondsTimeout < -1)
throw new ArgumentOutOfRangeException("millisecondsTimeout");
ThrowIfDisposed();
if (!IsSet) {
var wait = new SpinWait();
while (!IsSet) {
if (wait.Count < spinCount) {
wait.SpinOnce();
continue;
}
break;
}
cancellationToken.ThrowIfCancellationRequested();
if (IsSet)
return true;
WaitHandle handle = WaitHandle;
if (cancellationToken.CanBeCanceled) {
int result = WaitHandle.WaitAny(new[] {handle, cancellationToken.WaitHandle}, millisecondsTimeout, false);
if (result == 1)
throw new OperationCanceledException(cancellationToken.ToString());
if (result == WaitHandle.WaitTimeout)
return false;
} else {
if (!handle.WaitOne(millisecondsTimeout, false))
return false;
}
}
return true;
}
public async Task can_backup_to_directory_multiple_backups_with_long_interval()
{
var backupPath = NewDataPath(suffix: "BackupFolder");
using (var store = GetDocumentStore())
{
var periodicBackupRunner = (await GetDocumentDatabaseInstanceFor(store)).PeriodicBackupRunner;
// get by reflection the maxTimerTimeoutInMilliseconds field
// this field is the maximum interval acceptable in .Net's threading timer
// if the requested backup interval is bigger than this maximum interval,
// a timer with maximum interval will be used several times until the interval cumulatively
// will be equal to requested interval
typeof(PeriodicBackupRunner)
.GetField(nameof(PeriodicBackupRunner.MaxTimerTimeout), BindingFlags.Instance | BindingFlags.Public)
.SetValue(periodicBackupRunner, TimeSpan.FromMilliseconds(100));
using (var session = store.OpenAsyncSession())
{
await session.StoreAsync(new User { Name = "oren" }, "users/1");
await session.SaveChangesAsync();
}
var config = new PeriodicBackupConfiguration
{
LocalSettings = new LocalSettings
{
FolderPath = backupPath
},
IncrementalBackupFrequency = "* * * * *" //every minute
};
var backupTaskId = (await store.Maintenance.SendAsync(new UpdatePeriodicBackupOperation(config))).TaskId;
await store.Maintenance.SendAsync(new StartBackupOperation(true, backupTaskId));
var operation = new GetPeriodicBackupStatusOperation(backupTaskId);
SpinWait.SpinUntil(() =>
{
var getPeriodicBackupResult = store.Maintenance.Send(operation);
return(getPeriodicBackupResult.Status?.LastEtag > 0);
}, TimeSpan.FromSeconds(15));
var etagForBackups = store.Maintenance.Send(operation).Status.LastEtag;
using (var session = store.OpenAsyncSession())
{
await session.StoreAsync(new User { Name = "ayende" }, "users/2");
await session.SaveChangesAsync();
}
await store.Maintenance.SendAsync(new StartBackupOperation(false, backupTaskId));
SpinWait.SpinUntil(() =>
{
var newLastEtag = store.Maintenance.Send(operation).Status.LastEtag;
return(newLastEtag != etagForBackups);
}, TimeSpan.FromSeconds(15));
}
using (var store = GetDocumentStore(new Options
{
ModifyDatabaseName = s => $"{s}_2"
}))
{
await store.Smuggler.ImportIncrementalAsync(new DatabaseSmugglerImportOptions(),
Directory.GetDirectories(backupPath).First());
using (var session = store.OpenAsyncSession())
{
var users = await session.LoadAsync <User>(new[] { "users/1", "users/2" });
Assert.True(users.Any(x => x.Value.Name == "oren"));
Assert.True(users.Any(x => x.Value.Name == "ayende"));
}
}
}
/// <summary>
/// Processes all synchronous events that must take place before the next time loop for the algorithm
/// </summary>
public virtual void ProcessSynchronousEvents()
{
// how to do synchronous market orders for real brokerages?
// in backtesting we need to wait for orders to be removed from the queue and finished processing
if (!_algorithm.LiveMode)
{
var spinWait = new SpinWait();
while (!_orderRequestQueue.IsEmpty)
{
// spin wait until the queue is empty
spinWait.SpinOnce();
}
// now wait for completed processing to signal
_processingCompletedEvent.Wait();
return;
}
Log.Debug("BrokerageTransactionHandler.ProcessSynchronousEvents(): Enter");
// every morning flip this switch back
if (_syncedLiveBrokerageCashToday && DateTime.Now.Date != LastSyncDate)
{
_syncedLiveBrokerageCashToday = false;
}
// we want to sync up our cash balance before market open
if (_algorithm.LiveMode && !_syncedLiveBrokerageCashToday && DateTime.Now.TimeOfDay >= _liveBrokerageCashSyncTime)
{
try
{
// only perform cash syncs if we haven't had a fill for at least 10 seconds
if (TimeSinceLastFill > TimeSpan.FromSeconds(10))
{
PerformCashSync();
}
}
catch (Exception err)
{
Log.Error(err, "Updating cash balances");
}
}
// we want to remove orders older than 10k records, but only in live mode
const int maxOrdersToKeep = 10000;
if (_orders.Count < maxOrdersToKeep + 1)
{
Log.Debug("BrokerageTransactionHandler.ProcessSynchronousEvents(): Exit");
return;
}
int max = _orders.Max(x => x.Key);
int lowestOrderIdToKeep = max - maxOrdersToKeep;
foreach (var item in _orders.Where(x => x.Key <= lowestOrderIdToKeep))
{
Order value;
OrderTicket ticket;
_orders.TryRemove(item.Key, out value);
_orderTickets.TryRemove(item.Key, out ticket);
}
Log.Debug("BrokerageTransactionHandler.ProcessSynchronousEvents(): Exit");
}
public async Task PushServiceBadAetTest()
{
var testAETConfigModel = GetTestAETConfigModel();
var destination = testAETConfigModel.AETConfig.Destination;
var tempFolder = CreateTemporaryDirectory();
// Grab a structure set file
var file = new FileInfo(@"Images\LargeSeriesWithContour\rtstruct.dcm");
file.CopyTo(Path.Combine(tempFolder.FullName, file.Name));
var resultDirectory = CreateTemporaryDirectory();
// Create a Data receiver to receive the RT struct result
using (var dicomDataReceiver = new ListenerDataReceiver(new ListenerDicomSaver(resultDirectory.FullName)))
{
var eventCount = 0;
var folderPath = string.Empty;
dicomDataReceiver.DataReceived += (sender, e) =>
{
folderPath = e.FolderPath;
Interlocked.Increment(ref eventCount);
};
StartDicomDataReceiver(dicomDataReceiver, destination.Port);
var dataSender = new DicomDataSender();
var echoResult = await dataSender.DicomEchoAsync(
"RListener",
destination.Title,
destination.Port,
destination.Ip);
// Check echo
Assert.IsTrue(echoResult == DicomOperationResult.Success);
using (var deleteService = CreateDeleteService())
using (var pushService = CreatePushService())
using (var pushQueue = pushService.PushQueue)
{
deleteService.Start();
pushService.Start();
TransactionalEnqueue(
pushQueue,
new PushQueueItem(
destinationApplicationEntity: new GatewayApplicationEntity("", -1, "ababa"),
calledApplicationEntityTitle: testAETConfigModel.CalledAET,
callingApplicationEntityTitle: testAETConfigModel.CallingAET,
associationGuid: Guid.NewGuid(),
associationDateTime: DateTime.UtcNow,
filePaths: tempFolder.GetFiles().Select(x => x.FullName).ToArray()));
// Wait for all events to finish on the data received
SpinWait.SpinUntil(() => eventCount >= 3, TimeSpan.FromMinutes(3));
SpinWait.SpinUntil(() => new DirectoryInfo(tempFolder.FullName).Exists == false, TimeSpan.FromSeconds(30));
Assert.IsFalse(new DirectoryInfo(tempFolder.FullName).Exists);
}
}
}
internal void RemoveCallback(CancellationTokenRegistration tokenReg)
{
if (!canceled) {
lock (syncRoot) {
if (!canceled) {
callbacks.Remove (tokenReg);
return;
}
}
}
SpinWait sw = new SpinWait ();
while (!processed)
sw.SpinOnce ();
}
public async Task DoesReadBalancerAndMaxNumberOfRequestsClietnConfigurationTakeEffectOnCurrentRequestExecutor()
{
var nodesCount = 3;
var db = GetDatabaseName();
var leader = await CreateRaftClusterAndGetLeader(nodesCount);
var result = await CreateDatabaseInCluster(db, nodesCount, leader.WebUrl);
using (var store =
new DocumentStore
{
Urls = new[] { leader.WebUrl },
Database = db,
Conventions = new Raven.Client.Documents.Conventions.DocumentConventions
{
ReadBalanceBehavior = Raven.Client.Http.ReadBalanceBehavior.RoundRobin,
MaxNumberOfRequestsPerSession = 5
}
}.Initialize())
{
SpinWait.SpinUntil(() =>
{
using (leader.ServerStore.ContextPool.AllocateOperationContext(out TransactionOperationContext ctx))
using (ctx.OpenReadTransaction())
{
var record = leader.ServerStore.Cluster.ReadDatabase(ctx, db);
return(record.Topology.Members.Count == nodesCount);
}
}, TimeSpan.FromSeconds(10));
using (var session = store.OpenSession())
{
session.Store(new User
{
Name = "Samson"
});
session.SaveChanges();
}
await Assert.ThrowsAsync <InvalidOperationException>(async() =>
{
using (var session = store.OpenAsyncSession())
{
for (int i = 0; i < 6; i++)
{
await session.StoreAsync(new User
{
Name = "Samson"
});
await session.SaveChangesAsync();
}
}
});
HashSet <string> usedUrls = new HashSet <string>();
for (var i = 0; i < nodesCount; i++)
{
using (var session = store.OpenSession())
{
Raven.Client.Http.ServerNode serverNode = await session.Advanced.GetCurrentSessionNode();
Assert.True(usedUrls.Add(serverNode.Url.ToLower()));
}
}
Assert.Equal(nodesCount, usedUrls.Count);
// now, we modify the values and make sure that we received them
store.Maintenance.Server.Send(
new PutServerWideClientConfigurationOperation(
#pragma warning disable 618
new ClientConfiguration {
MaxNumberOfRequestsPerSession = 10, PrettifyGeneratedLinqExpressions = false, ReadBalanceBehavior = Raven.Client.Http.ReadBalanceBehavior.None
}));
#pragma warning restore 618
Assert.True(SpinWait.SpinUntil(() =>
{
using (var session = store.OpenSession())
{
session.Load <User>("users/1"); // we need this to "pull" the new config
return(session.Advanced.RequestExecutor.Conventions.MaxNumberOfRequestsPerSession == 10);
}
}, TimeSpan.FromSeconds(10)));
using (var session = store.OpenAsyncSession())
{
for (int i = 0; i < 6; i++)
{
await session.StoreAsync(new User
{
Name = "Samson"
});
await session.SaveChangesAsync();
}
}
usedUrls.Clear();
for (var i = 0; i < nodesCount; i++)
{
using (var session = store.OpenSession())
{
Raven.Client.Http.ServerNode serverNode1 = await session.Advanced.GetCurrentSessionNode();
usedUrls.Add(serverNode1.Url.ToLower());
}
}
Assert.Equal(1, usedUrls.Count);
// now we want to disable the client configuration and use the "default" ones
store.Maintenance.Server.Send(
new PutServerWideClientConfigurationOperation(
#pragma warning disable 618
new ClientConfiguration {
MaxNumberOfRequestsPerSession = 10, PrettifyGeneratedLinqExpressions = false, ReadBalanceBehavior = Raven.Client.Http.ReadBalanceBehavior.None, Disabled = true
}));
#pragma warning restore 618
using (var session = store.OpenSession())
{
session.Store(new User
{
Name = "Samson"
});
session.SaveChanges();
}
Assert.True(SpinWait.SpinUntil(() =>
{
using (var session = store.OpenSession())
{
session.Load <User>("users/1"); // we need this to "pull" the new config
return(session.Advanced.RequestExecutor.Conventions.MaxNumberOfRequestsPerSession == 5);
}
}, TimeSpan.FromSeconds(10)));
await Assert.ThrowsAsync <InvalidOperationException>(async() =>
{
using (var session = store.OpenAsyncSession())
{
for (int i = 0; i < 6; i++)
{
await session.StoreAsync(new User
{
Name = "Samson"
});
await session.SaveChangesAsync();
}
}
});
usedUrls.Clear();
for (var i = 0; i < nodesCount; i++)
{
using (var session = store.OpenSession())
{
Assert.True(usedUrls.Add((await session.Advanced.GetCurrentSessionNode()).Url.ToLower()));
}
}
Assert.Equal(nodesCount, usedUrls.Count);
}
}
/// <summary>
/// Removes the first element from the queue and returns it (or <c>null</c>).
/// </summary>
/// <param name="blockWhenEmpty">
/// If <c>true</c> and the queue is empty, the calling thread is blocked until
/// either an element is enqueued, or <see cref="Stop"/> is called.
/// </param>
/// <returns>
/// <list type="bullet">
/// <item>
/// <term>If the queue not empty</term>
/// <description>the first element.</description>
/// </item>
/// <item>
/// <term>otherwise, if <paramref name="blockWhenEmpty"/>==<c>false</c>
/// or <see cref="Stop"/> has been called</term>
/// <description><c>null</c>.</description>
/// </item>
/// </list>
/// </returns>
public Event Dequeue(bool blockWhenEmpty)
{
SpinWait sw = new SpinWait();
do
{
int cachedRemoveId = _removeId;
int cachedAddId = _addId;
// Empty case
if (cachedRemoveId == cachedAddId)
{
if (!blockWhenEmpty || _stopped != 0)
{
return(null);
}
// Spin a few times to see if something changes
if (sw.Count <= spinCount)
{
sw.SpinOnce();
}
else
{
// Reset to wait for an enqueue
_mreAdd.Reset();
// Recheck for an enqueue to avoid a Wait
if (cachedRemoveId != _removeId || cachedAddId != _addId)
{
// Queue is not empty, set the event
_mreAdd.Set();
continue;
}
// Wait for something to happen
_mreAdd.Wait(500);
}
continue;
}
// Validate that we are the current dequeuer
if (Interlocked.CompareExchange(ref _removeId, cachedRemoveId + 1, cachedRemoveId) != cachedRemoveId)
{
continue;
}
// Dequeue our work item
Event e;
while (!_queue.TryDequeue(out e))
{
if (!blockWhenEmpty || _stopped != 0)
{
return(null);
}
}
return(e);
} while (true);
}
void RunRenderWindow()
{
bool winStarted = false;
Task winthread = new Task(() =>
{
win = new RenderWindow(renderer, midifile, settings);
winStarted = true;
win.Run();
});
winthread.Start();
SpinWait.SpinUntil(() => winStarted);
double time = 0;
int nc = -1;
long maxRam = 0;
long avgRam = 0;
long ramSample = 0;
Stopwatch timewatch = new Stopwatch();
timewatch.Start();
IPluginRender render = null;
double lastWinTime = double.NaN;
bool tryToParse()
{
lock (midifile)
{
return((midifile.ParseUpTo(
(win.midiTime + win.lastDeltaTimeOnScreen +
(win.tempoFrameStep * 20 * settings.tempoMultiplier * (win.lastMV > 1 ? win.lastMV : 1)))) ||
nc != 0) && settings.running);
}
}
try
{
while (tryToParse())
{
//SpinWait.SpinUntil(() => lastWinTime != win.midiTime || render != renderer.renderer || !settings.running);
if (!settings.running)
{
break;
}
Note n;
double cutoffTime = win.midiTime;
bool manualDelete = false;
double noteCollectorOffset = 0;
bool receivedInfo = false;
while (!receivedInfo)
{
try
{
render = renderer.renderer;
receivedInfo = true;
}
catch
{ }
}
manualDelete = render.ManualNoteDelete;
noteCollectorOffset = render.NoteCollectorOffset;
cutoffTime += noteCollectorOffset;
if (!settings.running)
{
break;
}
lock (midifile.globalDisplayNotes)
{
var i = midifile.globalDisplayNotes.Iterate();
if (manualDelete)
{
while (i.MoveNext(out n))
{
if (n.delete)
{
i.Remove();
}
else
{
nc++;
}
}
}
else
{
while (i.MoveNext(out n))
{
if (n.hasEnded && n.end < cutoffTime)
{
i.Remove();
}
if (n.start > cutoffTime)
{
break;
}
}
}
GC.Collect();
}
try
{
double progress = win.midiTime / midifile.maxTrackTime;
if (settings.timeBasedNotes)
{
progress = win.midiTime / 1000 / midifile.info.secondsLength;
}
Console.WriteLine(
Math.Round(progress * 10000) / 100 +
"\tNotes drawn: " + renderer.renderer.LastNoteCount +
"\tRender FPS: " + Math.Round(settings.liveFps) +
"\tNotes drawn: " + renderer.renderer.LastNoteCount
);
}
catch
{
}
long ram = Process.GetCurrentProcess().PrivateMemorySize64;
if (maxRam < ram)
{
maxRam = ram;
}
avgRam = (long)((double)avgRam * ramSample + ram) / (ramSample + 1);
ramSample++;
lastWinTime = win.midiTime;
Stopwatch s = new Stopwatch();
s.Start();
SpinWait.SpinUntil(() =>
(
(s.ElapsedMilliseconds > 1000.0 / settings.fps * 30 && false) ||
(win.midiTime + win.lastDeltaTimeOnScreen +
(win.tempoFrameStep * 10 * settings.tempoMultiplier * (win.lastMV > 1 ? win.lastMV : 1))) > midifile.currentSyncTime ||
lastWinTime != win.midiTime || render != renderer.renderer || !settings.running
)
);;
}
}
catch (Exception ex)
{
MessageBox.Show("An error occurred while opeining render window. Please try again.\n\n" + ex.Message + "\n" + ex.StackTrace);
settings.running = false;
}
winthread.GetAwaiter().GetResult();
settings.running = false;
Console.WriteLine("Reset midi file");
midifile.Reset();
win.Dispose();
win = null;
GC.Collect();
GC.WaitForFullGCComplete();
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine(
"Finished render\nRAM usage (Private bytes)\nPeak: " + Math.Round((double)maxRam / 1000 / 1000 / 1000 * 100) / 100 +
"GB\nAvg: " + Math.Round((double)avgRam / 1000 / 1000 / 1000 * 100) / 100 +
"GB\nMinutes to render: " + Math.Round((double)timewatch.ElapsedMilliseconds / 1000 / 60 * 100) / 100);
Console.ResetColor();
Dispatcher.Invoke(() =>
{
Resources["notRendering"] = true;
Resources["notPreviewing"] = true;
});
}
/// <summary>Wait until process exits.</summary>
public void WaitForExit()
{
process.WaitForExit();
SpinWait.SpinUntil(() => finished);
}
//[Fact(Skip = "Outerloop")]
public void RunActionBlockConformanceTests()
{
// SYNC
// Do everything twice - once through OfferMessage and Once through Post
for (FeedMethod feedMethod = FeedMethod._First; feedMethod < FeedMethod._Count; feedMethod++)
{
Func <DataflowBlockOptions, TargetProperties <int> > actionBlockFactory =
options =>
{
ITargetBlock <int> target = new ActionBlock <int>(i => TrackCaptures(i), (ExecutionDataflowBlockOptions)options);
return(new TargetProperties <int> {
Target = target, Capturer = target, ErrorVerifyable = true
});
};
CancellationTokenSource cancellationSource = new CancellationTokenSource();
var defaultOptions = new ExecutionDataflowBlockOptions();
var dopOptions = new ExecutionDataflowBlockOptions {
MaxDegreeOfParallelism = Environment.ProcessorCount
};
var mptOptions = new ExecutionDataflowBlockOptions {
MaxDegreeOfParallelism = Environment.ProcessorCount, MaxMessagesPerTask = 1
};
var cancellationOptions = new ExecutionDataflowBlockOptions {
MaxDegreeOfParallelism = Environment.ProcessorCount, MaxMessagesPerTask = 1, CancellationToken = cancellationSource.Token
};
var spscOptions = new ExecutionDataflowBlockOptions {
SingleProducerConstrained = true
};
var spscMptOptions = new ExecutionDataflowBlockOptions {
SingleProducerConstrained = true, MaxMessagesPerTask = 10
};
Assert.True(FeedTarget(actionBlockFactory, defaultOptions, 1, Intervention.None, null, feedMethod, true));
Assert.True(FeedTarget(actionBlockFactory, dopOptions, 1, Intervention.None, null, feedMethod, true));
Assert.True(FeedTarget(actionBlockFactory, mptOptions, 1, Intervention.None, null, feedMethod, true));
Assert.True(FeedTarget(actionBlockFactory, mptOptions, 1, Intervention.Complete, null, feedMethod, true));
Assert.True(FeedTarget(actionBlockFactory, cancellationOptions, 1, Intervention.Cancel, cancellationSource, feedMethod, true));
Assert.True(FeedTarget(actionBlockFactory, spscOptions, 1, Intervention.None, null, feedMethod, true));
Assert.True(FeedTarget(actionBlockFactory, spscOptions, 1, Intervention.Complete, null, feedMethod, true));
Assert.True(FeedTarget(actionBlockFactory, spscMptOptions, 1, Intervention.None, null, feedMethod, true));
Assert.True(FeedTarget(actionBlockFactory, spscMptOptions, 1, Intervention.Complete, null, feedMethod, true));
}
// Test scheduler usage
{
bool localPassed = true;
for (int trial = 0; trial < 2; trial++)
{
var sts = new SimpleTaskScheduler();
var options = new ExecutionDataflowBlockOptions {
TaskScheduler = sts, MaxDegreeOfParallelism = DataflowBlockOptions.Unbounded, MaxMessagesPerTask = 1
};
if (trial == 0)
{
options.SingleProducerConstrained = true;
}
var ab = new ActionBlock <int>(i => localPassed &= TaskScheduler.Current.Id == sts.Id, options);
for (int i = 0; i < 2; i++)
{
ab.Post(i);
}
ab.Complete();
ab.Completion.Wait();
}
Assert.True(localPassed, string.Format("{0}: Correct scheduler usage", localPassed ? "Success" : "Failure"));
}
// Test count
{
bool localPassed = true;
for (int trial = 0; trial < 2; trial++)
{
var barrier1 = new Barrier(2);
var barrier2 = new Barrier(2);
var ab = new ActionBlock <int>(i =>
{
barrier1.SignalAndWait();
barrier2.SignalAndWait();
}, new ExecutionDataflowBlockOptions {
SingleProducerConstrained = (trial == 0)
});
for (int iter = 0; iter < 2; iter++)
{
for (int i = 1; i <= 2; i++)
{
ab.Post(i);
}
for (int i = 1; i >= 0; i--)
{
barrier1.SignalAndWait();
localPassed &= i == ab.InputCount;
barrier2.SignalAndWait();
}
}
}
Assert.True(localPassed, string.Format("{0}: InputCount", localPassed ? "Success" : "Failure"));
}
// Test ordering
{
bool localPassed = true;
for (int trial = 0; trial < 2; trial++)
{
int prev = -1;
var ab = new ActionBlock <int>(i =>
{
if (prev + 1 != i)
{
localPassed &= false;
}
prev = i;
}, new ExecutionDataflowBlockOptions {
SingleProducerConstrained = (trial == 0)
});
for (int i = 0; i < 2; i++)
{
ab.Post(i);
}
ab.Complete();
ab.Completion.Wait();
}
Assert.True(localPassed, string.Format("{0}: Correct ordering", localPassed ? "Success" : "Failure"));
}
// Test non-greedy
{
bool localPassed = true;
var barrier = new Barrier(2);
var ab = new ActionBlock <int>(i =>
{
barrier.SignalAndWait();
}, new ExecutionDataflowBlockOptions {
BoundedCapacity = 1
});
ab.SendAsync(1);
Task.Delay(200).Wait();
var sa2 = ab.SendAsync(2);
localPassed &= !sa2.IsCompleted;
barrier.SignalAndWait(); // for SendAsync(1)
barrier.SignalAndWait(); // for SendAsync(2)
localPassed &= sa2.Wait(100);
int total = 0;
ab = new ActionBlock <int>(i =>
{
Interlocked.Add(ref total, i);
Task.Delay(1).Wait();
}, new ExecutionDataflowBlockOptions {
BoundedCapacity = 1
});
for (int i = 1; i <= 100; i++)
{
ab.SendAsync(i);
}
SpinWait.SpinUntil(() => total == ((100 * 101) / 2), 30000);
localPassed &= total == ((100 * 101) / 2);
Assert.True(localPassed, string.Format("total={0} (must be {1})", total, (100 * 101) / 2));
Assert.True(localPassed, string.Format("{0}: Non-greedy support", localPassed ? "Success" : "Failure"));
}
// Test that OperationCanceledExceptions are ignored
{
bool localPassed = true;
for (int trial = 0; trial < 2; trial++)
{
int sumOfOdds = 0;
var ab = new ActionBlock <int>(i =>
{
if ((i % 2) == 0)
{
throw new OperationCanceledException();
}
sumOfOdds += i;
}, new ExecutionDataflowBlockOptions {
SingleProducerConstrained = (trial == 0)
});
for (int i = 0; i < 4; i++)
{
ab.Post(i);
}
ab.Complete();
ab.Completion.Wait();
localPassed = sumOfOdds == (1 + 3);
}
Assert.True(localPassed, string.Format("{0}: OperationCanceledExceptions are ignored", localPassed ? "Success" : "Failure"));
}
// Test using a precanceled token
{
bool localPassed = true;
try
{
var cts = new CancellationTokenSource();
cts.Cancel();
var dbo = new ExecutionDataflowBlockOptions {
CancellationToken = cts.Token
};
var ab = new ActionBlock <int>(i => { }, dbo);
localPassed &= ab.Post(42) == false;
localPassed &= ab.InputCount == 0;
localPassed &= ab.Completion != null;
ab.Complete();
}
catch (Exception)
{
localPassed = false;
}
Assert.True(localPassed, string.Format("{0}: Precanceled tokens work correctly", localPassed ? "Success" : "Failure"));
}
// Test faulting
{
bool localPassed = true;
for (int trial = 0; trial < 2; trial++)
{
var ab = new ActionBlock <int>(i => { throw new InvalidOperationException(); },
new ExecutionDataflowBlockOptions {
SingleProducerConstrained = (trial == 0)
});
ab.Post(42);
ab.Post(1);
ab.Post(2);
ab.Post(3);
try { localPassed &= ab.Completion.Wait(5000); }
catch { }
localPassed &= ab.Completion.IsFaulted;
localPassed &= SpinWait.SpinUntil(() => ab.InputCount == 0, 500);
localPassed &= ab.Post(4) == false;
}
Assert.True(localPassed, string.Format("{0}: Faulted handled correctly", localPassed ? "Success" : "Failure"));
}
// ASYNC (a copy of the sync but with constructors returning Task instead of void
// Do everything twice - once through OfferMessage and Once through Post
for (FeedMethod feedMethod = FeedMethod._First; feedMethod < FeedMethod._Count; feedMethod++)
{
Func <DataflowBlockOptions, TargetProperties <int> > actionBlockFactory =
options =>
{
ITargetBlock <int> target = new ActionBlock <int>(i => TrackCapturesAsync(i), (ExecutionDataflowBlockOptions)options);
return(new TargetProperties <int> {
Target = target, Capturer = target, ErrorVerifyable = true
});
};
CancellationTokenSource cancellationSource = new CancellationTokenSource();
var defaultOptions = new ExecutionDataflowBlockOptions();
var dopOptions = new ExecutionDataflowBlockOptions {
MaxDegreeOfParallelism = Environment.ProcessorCount
};
var mptOptions = new ExecutionDataflowBlockOptions {
MaxDegreeOfParallelism = Environment.ProcessorCount, MaxMessagesPerTask = 10
};
var cancellationOptions = new ExecutionDataflowBlockOptions {
MaxDegreeOfParallelism = Environment.ProcessorCount, MaxMessagesPerTask = 100, CancellationToken = cancellationSource.Token
};
Assert.True(FeedTarget(actionBlockFactory, defaultOptions, 1, Intervention.None, null, feedMethod, true));
Assert.True(FeedTarget(actionBlockFactory, defaultOptions, 10, Intervention.None, null, feedMethod, true));
Assert.True(FeedTarget(actionBlockFactory, dopOptions, 1000, Intervention.None, null, feedMethod, true));
Assert.True(FeedTarget(actionBlockFactory, mptOptions, 10000, Intervention.None, null, feedMethod, true));
Assert.True(FeedTarget(actionBlockFactory, mptOptions, 10000, Intervention.Complete, null, feedMethod, true));
Assert.True(FeedTarget(actionBlockFactory, cancellationOptions, 10000, Intervention.Cancel, cancellationSource, feedMethod, true));
}
// Test scheduler usage
{
bool localPassed = true;
var sts = new SimpleTaskScheduler();
var ab = new ActionBlock <int>(i =>
{
localPassed &= TaskScheduler.Current.Id == sts.Id;
return(Task.Factory.StartNew(() => { }));
}, new ExecutionDataflowBlockOptions {
TaskScheduler = sts, MaxDegreeOfParallelism = -1, MaxMessagesPerTask = 10
});
for (int i = 0; i < 2; i++)
{
ab.Post(i);
}
ab.Complete();
ab.Completion.Wait();
Assert.True(localPassed, string.Format("{0}: Correct scheduler usage", localPassed ? "Success" : "Failure"));
}
// Test count
{
bool localPassed = true;
var barrier1 = new Barrier(2);
var barrier2 = new Barrier(2);
var ab = new ActionBlock <int>(i => Task.Factory.StartNew(() =>
{
barrier1.SignalAndWait();
barrier2.SignalAndWait();
}));
for (int iter = 0; iter < 2; iter++)
{
for (int i = 1; i <= 2; i++)
{
ab.Post(i);
}
for (int i = 1; i >= 0; i--)
{
barrier1.SignalAndWait();
localPassed &= i == ab.InputCount;
barrier2.SignalAndWait();
}
}
Assert.True(localPassed, string.Format("{0}: InputCount", localPassed ? "Success" : "Failure"));
}
// Test ordering
{
bool localPassed = true;
int prev = -1;
var ab = new ActionBlock <int>(i =>
{
return(Task.Factory.StartNew(() =>
{
if (prev + 1 != i)
{
localPassed &= false;
}
prev = i;
}));
});
for (int i = 0; i < 2; i++)
{
ab.Post(i);
}
ab.Complete();
ab.Completion.Wait();
Assert.True(localPassed, string.Format("{0}: Correct ordering", localPassed ? "Success" : "Failure"));
}
// Test non-greedy
{
bool localPassed = true;
var barrier = new Barrier(2);
var ab = new ActionBlock <int>(i =>
{
return(Task.Factory.StartNew(() =>
{
barrier.SignalAndWait();
}));
}, new ExecutionDataflowBlockOptions {
BoundedCapacity = 1
});
ab.SendAsync(1);
Task.Delay(200).Wait();
var sa2 = ab.SendAsync(2);
localPassed &= !sa2.IsCompleted;
barrier.SignalAndWait(); // for SendAsync(1)
barrier.SignalAndWait(); // for SendAsync(2)
localPassed &= sa2.Wait(100);
int total = 0;
ab = new ActionBlock <int>(i =>
{
return(Task.Factory.StartNew(() =>
{
Interlocked.Add(ref total, i);
Task.Delay(1).Wait();
}));
}, new ExecutionDataflowBlockOptions {
BoundedCapacity = 1
});
for (int i = 1; i <= 100; i++)
{
ab.SendAsync(i);
}
SpinWait.SpinUntil(() => total == ((100 * 101) / 2), 30000);
localPassed &= total == ((100 * 101) / 2);
Assert.True(localPassed, string.Format("total={0} (must be {1})", total, (100 * 101) / 2));
Assert.True(localPassed, string.Format("{0}: Non-greedy support", localPassed ? "Success" : "Failure"));
}
// Test that OperationCanceledExceptions are ignored
{
bool localPassed = true;
int sumOfOdds = 0;
var ab = new ActionBlock <int>(i =>
{
if ((i % 2) == 0)
{
throw new OperationCanceledException();
}
return(Task.Factory.StartNew(() => { sumOfOdds += i; }));
});
for (int i = 0; i < 4; i++)
{
ab.Post(i);
}
ab.Complete();
ab.Completion.Wait();
localPassed = sumOfOdds == (1 + 3);
Assert.True(localPassed, string.Format("{0}: OperationCanceledExceptions are ignored", localPassed ? "Success" : "Failure"));
}
// Test that null task is ignored
{
bool localPassed = true;
int sumOfOdds = 0;
var ab = new ActionBlock <int>(i =>
{
if ((i % 2) == 0)
{
return(null);
}
return(Task.Factory.StartNew(() => { sumOfOdds += i; }));
});
for (int i = 0; i < 4; i++)
{
ab.Post(i);
}
ab.Complete();
ab.Completion.Wait();
localPassed = sumOfOdds == (1 + 3);
Assert.True(localPassed, string.Format("{0}: null tasks are ignored", localPassed ? "Success" : "Failure"));
}
// Test faulting from the delegate
{
bool localPassed = true;
var ab = new ActionBlock <int>(new Func <int, Task>(i => { throw new InvalidOperationException(); }));
ab.Post(42);
ab.Post(1);
ab.Post(2);
ab.Post(3);
try { localPassed &= ab.Completion.Wait(100); }
catch { }
localPassed &= ab.Completion.IsFaulted;
localPassed &= SpinWait.SpinUntil(() => ab.InputCount == 0, 500);
localPassed &= ab.Post(4) == false;
Assert.True(localPassed, string.Format("{0}: Faulted from delegate handled correctly", localPassed ? "Success" : "Failure"));
}
// Test faulting from the task
{
bool localPassed = true;
var ab = new ActionBlock <int>(i => Task.Factory.StartNew(() => { throw new InvalidOperationException(); }));
ab.Post(42);
ab.Post(1);
ab.Post(2);
ab.Post(3);
try { localPassed &= ab.Completion.Wait(100); }
catch { }
localPassed &= ab.Completion.IsFaulted;
localPassed &= SpinWait.SpinUntil(() => ab.InputCount == 0, 500);
localPassed &= ab.Post(4) == false;
Assert.True(localPassed, string.Format("{0}: Faulted from task handled correctly", localPassed ? "Success" : "Failure"));
}
}
private void ProcessMeasurements()
{
List <IMeasurement> measurements = new List <IMeasurement>((int)(Ticks.ToSeconds(GapThreshold) * m_sampleRate * m_channels * 1.1D));
LittleBinaryValue[] sample;
while (Enabled)
{
try
{
SpinWait spinner = new SpinWait();
// Determine what time it is now
long now = DateTime.UtcNow.Ticks;
// Assign a timestamp to the next sample based on its location
// in the file relative to the other samples in the file
long timestamp = m_startTime + (m_dataIndex * Ticks.PerSecond / m_sampleRate);
if (now - timestamp > GapThreshold)
{
// Reset the start time and delay next transmission in an attempt to catch up
m_startTime = now - (m_dataIndex * Ticks.PerSecond / m_sampleRate) + Ticks.FromSeconds(RecoveryDelay);
timestamp = now;
OnStatusMessage(MessageLevel.Info, "Start time reset.");
}
// Keep generating measurements until
// we catch up to the current time.
while (timestamp < now)
{
sample = m_dataReader.GetNextSample();
// If the sample is null, we've reached the end of the file - close and reopen,
// resetting the data index and start time
if (sample == null)
{
m_dataReader.Close();
m_dataReader.Dispose();
m_dataReader = OpenWaveDataReader();
m_dataIndex = 0;
m_startTime = timestamp;
sample = m_dataReader.GetNextSample();
}
// Create new measurements, one for each channel, and add them to the measurements list
for (int i = 0; i < m_channels; i++)
{
measurements.Add(Measurement.Clone(OutputMeasurements[i], sample[i].ConvertToType(TypeCode.Double), timestamp));
}
// Update the data index and recalculate the assigned timestamp for the next sample
m_dataIndex++;
timestamp = m_startTime + (m_dataIndex * Ticks.PerSecond / m_sampleRate);
}
OnNewMeasurements(measurements);
measurements.Clear();
while (DateTime.UtcNow.Ticks - timestamp <= GapThreshold / 100)
{
// Ahead of schedule -- pause for a moment
spinner.SpinOnce();
}
}
catch (Exception ex)
{
OnProcessException(MessageLevel.Warning, ex);
}
}
}
public async Task PushServiceTest()
{
var tempFolder = CreateTemporaryDirectory();
// Copy all files in the P4_Prostate directory to the temporary directory
Directory.EnumerateFiles(@"Images\1ValidSmall\")
.Select(x => new FileInfo(x))
.ToList()
.ForEach(x => x.CopyTo(Path.Combine(tempFolder.FullName, x.Name)));
var applicationEntity = new GatewayApplicationEntity("RListenerTest", 108, "127.0.0.1");
var resultDirectory = CreateTemporaryDirectory();
// Create a Data receiver to receive the RT struct result
using (var dicomDataReceiver = new ListenerDataReceiver(new ListenerDicomSaver(resultDirectory.FullName)))
{
var eventCount = 0;
dicomDataReceiver.DataReceived += (sender, e) =>
{
Interlocked.Increment(ref eventCount);
};
StartDicomDataReceiver(dicomDataReceiver, applicationEntity.Port);
var dataSender = new DicomDataSender();
var echoResult = await dataSender.DicomEchoAsync("RListener", applicationEntity.Title, applicationEntity.Port, applicationEntity.IpAddress);
// Check echo
Assert.IsTrue(echoResult == DicomOperationResult.Success);
var testAETConfigModel = GetTestAETConfigModel();
using (var deleteService = CreateDeleteService())
using (var pushService = CreatePushService())
using (var pushQueue = pushService.PushQueue)
{
deleteService.Start();
pushService.Start();
TransactionalEnqueue(
pushQueue,
new PushQueueItem(
destinationApplicationEntity: applicationEntity,
calledApplicationEntityTitle: testAETConfigModel.CalledAET,
callingApplicationEntityTitle: applicationEntity.Title,
associationGuid: Guid.NewGuid(),
associationDateTime: DateTime.UtcNow,
filePaths: tempFolder.GetFiles().Select(x => x.FullName).ToArray()));
// Wait for all events to finish on the data received
SpinWait.SpinUntil(() => eventCount >= 3, TimeSpan.FromMinutes(3));
SpinWait.SpinUntil(() => new DirectoryInfo(tempFolder.FullName).Exists == false, TimeSpan.FromSeconds(30));
Assert.IsFalse(new DirectoryInfo(tempFolder.FullName).Exists);
Assert.AreEqual(20, resultDirectory.GetDirectories()[0].GetFiles().Length);
}
}
}
public void Flush()
{
SpinWait.SpinUntil(() => this.TrySendDisposition());
}
/// <summary>
/// Builds the specified project.
/// </summary>
/// <param name="project">The project to build.</param>
/// <param name="cancellation">Cancellation token to cancel the wait for the build to finish.</param>
/// <param name="timeout">A maximum time to wait for the build to finish.</param>
/// <exception cref="System.ArgumentException">The project has no <see cref="ISolutionExplorerNode.OwningSolution"/>.</exception>
/// <returns><see langword="true"/> if the build succeeded; <see langword="false"/> otherwise.</returns>
public static Task <bool> Build(this IProjectNode project, CancellationToken cancellation, TimeSpan timeout)
{
Guard.NotNull(() => project, project);
Guard.NotNull(() => cancellation, cancellation);
var solution = project.OwningSolution;
if (solution == null)
{
throw new ArgumentException(Strings.IProjectNodeExtensions.BuildNoSolution(project.DisplayName));
}
var sln = solution.As <EnvDTE.Solution>();
if (sln == null)
{
throw new ArgumentException(Strings.IProjectNodeExtensions.BuildNoSolution(project.DisplayName));
}
return(System.Threading.Tasks.Task.Factory.StartNew <bool>(() =>
{
try
{
// Let build run async.
sln.SolutionBuild.BuildProject(sln.SolutionBuild.ActiveConfiguration.Name, project.As <EnvDTE.Project>().UniqueName, false);
// First wait until it becomes in progress. We give it
// a maximum of 2 seconds for VS to start building. If this doesn't
// happen in that time, something really weird must be going on.
var inProgress = SpinWait.SpinUntil(() =>
cancellation.IsCancellationRequested ||
sln.SolutionBuild.BuildState == EnvDTE.vsBuildState.vsBuildStateInProgress,
2000);
// If the build did not start in under 2 seconds, something weird happened,
// so return quickly and with false.
// Note that this may be the case when the token is cancelled.
if (!inProgress)
{
return false;
}
// Next wait until it's done.
// This could be a remote build, complex one, etc., so we specify 10 minutes as a
// conservative wait.
var isDone = SpinWait.SpinUntil(() =>
cancellation.IsCancellationRequested ||
sln.SolutionBuild.BuildState == EnvDTE.vsBuildState.vsBuildStateDone,
timeout);
// LastBuildInfo == # of projects that failed to build.
// We'll return false if the build wait was cancelled.
return !cancellation.IsCancellationRequested && isDone && sln.SolutionBuild.LastBuildInfo == 0;
}
catch (Exception ex)
{
tracer.Error(ex, Strings.IProjectNodeExtensions.BuildException);
return false;
}
}, cancellation, TaskCreationOptions.None, TaskScheduler.Default));
}
void UIthread()
{
while (true)
{
Action dele = delegate()
{
UpdateUI();
//prevent maximizing
if (this.WindowState != WindowState.Maximized)
{
this.WindowState = WindowState.Normal;
}
//get window information
if (recorder.Capturing())
{
if (graph.GetIntPtr() != IntPtr.Zero)
{
try
{
displayer.ImageBox.Source = Imaging.CreateBitmapSourceFromHBitmap(graph.GetIntPtr(), IntPtr.Zero, Int32Rect.Empty, BitmapSizeOptions.FromEmptyOptions());
graph.DeleteIntPtr();
}
catch { }
}
if (area_window.IsVisible)
{
graph.Shift(area_window.Left, area_window.Top);
}
if (recorder.Recording())
{
if (appmani.IsTargetActive())
{
RecordButton.Background = Brushes.Red;
if (ffmpeg.IsWrited())
{
notify.Icon = Properties.Resources.notify_writing;
}
else
{
notify.Icon = Properties.Resources.notify_capturing;
}
}
else
{
RecordButton.Background = Brushes.IndianRed;
notify.Icon = Properties.Resources.notify_norm;
}
}
}
else if (!appmani.Lock())
{
appmani.SetTargetToNextWindow();
}
};
Dispatcher.Invoke(dele);
//Thread.Sleep(65);
SpinWait.SpinUntil(() => false, 65);
}
}
public void Authenticate_should_not_throw_when_authentication_succeeds(
[Values(false, true)] bool useSpeculativeAuthenticate,
[Values(false, true)] bool useLongAuthentication,
[Values(false, true)] bool async)
{
var randomStringGenerator = new ConstantRandomStringGenerator(_clientNonce);
var subject = new ScramSha256Authenticator(__credential, randomStringGenerator, serverApi: null);
var saslStartReply = MessageHelper.BuildReply <RawBsonDocument>(RawBsonDocumentHelper.FromJson(
@"{ conversationId : 1," +
$" payload : BinData(0,'{ToUtf8Base64(__serverResponse1)}')," +
@" done : false,
ok : 1 }"));
var saslContinueReply = MessageHelper.BuildReply <RawBsonDocument>(RawBsonDocumentHelper.FromJson(
@"{ conversationId : 1," +
$" payload : BinData(0,'{ToUtf8Base64(__serverResponse2)}')," +
$" done : {new BsonBoolean(!useLongAuthentication)}," +
@" ok : 1 }"));
var saslLastStepReply = MessageHelper.BuildReply <RawBsonDocument>(RawBsonDocumentHelper.FromJson(
@"{ conversationId : 1," +
$" payload : BinData(0,'{ToUtf8Base64(__serverOptionalFinalResponse)}')," +
@" done : true,
ok : 1 }"));
var connection = new MockConnection(__serverId);
var isMasterResult = (BsonDocument)__descriptionQueryWireProtocol.IsMasterResult.Wrapped.Clone();
if (useSpeculativeAuthenticate)
{
isMasterResult.Add("speculativeAuthenticate", saslStartReply.Documents[0].ToBsonDocument());
}
/* set buildInfoResult to 3.4 to force authenticator to use Query Message Wire Protocol because MockConnection
* does not support OP_MSG */
connection.Description = new ConnectionDescription(
__descriptionQueryWireProtocol.ConnectionId,
new IsMasterResult(isMasterResult),
new BuildInfoResult(new BsonDocument("version", "3.4")));
BsonDocument isMasterCommand = null;
if (useSpeculativeAuthenticate)
{
// We must call CustomizeIsMasterCommand so that the authenticator thinks its started to speculatively
// authenticate
isMasterCommand = subject.CustomizeInitialIsMasterCommand(new BsonDocument {
{ "isMaster", 1 }
});
}
else
{
connection.EnqueueReplyMessage(saslStartReply);
}
connection.EnqueueReplyMessage(saslContinueReply);
if (useLongAuthentication)
{
connection.EnqueueReplyMessage(saslLastStepReply);
}
var expectedRequestId = RequestMessage.CurrentGlobalRequestId + 1;
Exception exception;
if (async)
{
exception = Record.Exception(
() => subject.AuthenticateAsync(connection, connection.Description, CancellationToken.None)
.GetAwaiter().GetResult());
}
else
{
exception = Record.Exception(
() => subject.Authenticate(connection, connection.Description, CancellationToken.None));
}
exception.Should().BeNull();
var expectedSentMessageCount = 3 - (useLongAuthentication ? 0 : 1) - (useSpeculativeAuthenticate ? 1 : 0);
SpinWait.SpinUntil(
() => connection.GetSentMessages().Count >= expectedSentMessageCount,
TimeSpan.FromSeconds(5)
).Should().BeTrue();
var sentMessages = MessageHelper.TranslateMessagesToBsonDocuments(connection.GetSentMessages());
sentMessages.Count.Should().Be(expectedSentMessageCount);
var actualRequestIds = sentMessages.Select(m => m["requestId"].AsInt32).ToList();
for (var i = 0; i != actualRequestIds.Count; ++i)
{
actualRequestIds[i].Should().BeInRange(expectedRequestId + i, expectedRequestId + 10 + i);
}
var expectedMessages = new List <BsonDocument>();
var saslStartMessage = BsonDocument.Parse(
@"{ opcode : 'query'," +
$" requestId : {actualRequestIds[0]}," +
@" database : 'source',
collection : '$cmd',
batchSize : -1,
slaveOk : true,
query : { saslStart : 1,
mechanism : 'SCRAM-SHA-256'," +
$" payload : new BinData(0, '{ToUtf8Base64(__clientRequest1)}')" +
@" options : { skipEmptyExchange: true }}}");
if (!useSpeculativeAuthenticate)
{
expectedMessages.Add(saslStartMessage);
}
var saslContinueMessage = BsonDocument.Parse(
@"{ opcode : 'query'," +
$" requestId : {(useSpeculativeAuthenticate ? actualRequestIds[0] : actualRequestIds[1])}," +
@" database : 'source',
collection : '$cmd',
batchSize : -1,
slaveOk : true,
query : { saslContinue : 1,
conversationId : 1, " +
$" payload : new BinData(0, \"{ToUtf8Base64(__clientRequest2)}\")}}}}");
expectedMessages.Add(saslContinueMessage);
if (useLongAuthentication)
{
var saslOptionalFinalMessage = BsonDocument.Parse(
@"{ opcode : 'query'," +
$" requestId : {(useSpeculativeAuthenticate ? actualRequestIds[1] : actualRequestIds[2])}," +
@" database : 'source',
collection : '$cmd',
batchSize : -1,
slaveOk : true,
query : { saslContinue : 1,
conversationId : 1, " +
$" payload : new BinData(0, '{ToUtf8Base64(__clientOptionalFinalRequest)}')}}}}");
expectedMessages.Add(saslOptionalFinalMessage);
}
sentMessages.Should().Equal(expectedMessages);
if (useSpeculativeAuthenticate)
{
isMasterCommand.Should().Contain("speculativeAuthenticate");
var speculativeAuthenticateDocument = isMasterCommand["speculativeAuthenticate"].AsBsonDocument;
var expectedSpeculativeAuthenticateDocument =
saslStartMessage["query"].AsBsonDocument.Add("db", __credential.Source);
speculativeAuthenticateDocument.Should().Be(expectedSpeculativeAuthenticateDocument);
}
}
/// <summary>
/// Wait until page initialization
/// </summary>
private void PageInitialize()
{
SpinWait.SpinUntil(() => Page.IsBrowserInitialized);
}
private void RunTestIteration(SqlConnection con, SqlRandomizer rand, SqlRandomTable table, string tableName)
{
// random list of columns
int columnCount = table.Columns.Count;
int[] columnIndices = rand.NextIndices(columnCount);
int selectedCount = rand.NextIntInclusive(1, maxValueInclusive: columnCount);
StringBuilder selectBuilder = new StringBuilder();
table.GenerateSelectFromTableTSql(tableName, selectBuilder, columnIndices, 0, selectedCount);
SqlCommand cmd = con.CreateCommand();
cmd.CommandType = CommandType.Text;
cmd.CommandText = selectBuilder.ToString();
bool cancel = rand.Next(100) == 0; // in 1% of the cases, call Cancel
if (cancel)
{
int cancelAfterMilliseconds = rand.Next(5);
int cancelAfterSpinCount = rand.Next(1000);
ThreadPool.QueueUserWorkItem((object state) =>
{
for (int i = 0; cancel && i < cancelAfterMilliseconds; i++)
{
Thread.Sleep(1);
}
if (cancel && cancelAfterSpinCount > 0)
{
SpinWait.SpinUntil(() => false, new TimeSpan(cancelAfterSpinCount));
}
if (cancel)
{
cmd.Cancel();
}
});
}
int readerRand = rand.NextIntInclusive(0, maxValueInclusive: 256);
CommandBehavior readerBehavior = CommandBehavior.Default;
if (readerRand % 10 == 0)
{
readerBehavior = CommandBehavior.SequentialAccess;
}
try
{
using (SqlDataReader reader = cmd.ExecuteReader(readerBehavior))
{
int row = 0;
while (reader.Read())
{
int rowRand = rand.NextIntInclusive();
if (rowRand % 1000 == 0)
{
// abandon this reader
break;
}
else if (rowRand % 25 == 0)
{
// skip the row
row++;
continue;
}
IList <object> expectedRow = table[row];
for (int c = 0; c < reader.FieldCount; c++)
{
if (rand.NextIntInclusive(0, maxValueInclusive: 10) == 0)
{
// skip the column
continue;
}
int expectedTableColumn = columnIndices[c];
object expectedValue = expectedRow[expectedTableColumn];
if (table.Columns[expectedTableColumn].CanCompareValues)
{
Assert.True(expectedValue != null, "FAILED: Null is expected with CanCompareValues");
// read the value same way it was written
object actualValue = table.Columns[expectedTableColumn].Read(reader, c, expectedValue.GetType());
Assert.True(table.Columns[expectedTableColumn].CompareValues(expectedValue, actualValue),
string.Format("FAILED: Data Comparison Failure:\n{0}", table.Columns[expectedTableColumn].BuildErrorMessage(expectedValue, actualValue)));
}
}
row++;
}
}
// keep last - this will stop the cancel task, if it is still active
cancel = false;
}
catch (SqlException e)
{
if (!cancel)
{
throw;
}
bool expected = false;
foreach (SqlError error in e.Errors)
{
if (error.Message == _operationCanceledErrorMessage)
{
// ignore this one - expected if canceled
expected = true;
break;
}
else if (error.Message == _severeErrorMessage)
{
// A severe error occurred on the current command. The results, if any, should be discarded.
expected = true;
break;
}
}
if (!expected)
{
// rethrow to the user
foreach (SqlError error in e.Errors)
{
Console.WriteLine("{0} {1}", error.Number, error.Message);
}
throw;
}
}
catch (InvalidOperationException e)
{
bool expected = false;
if (e.Message == _operationCanceledErrorMessage)
{
// "Operation canceled" exception is raised as a SqlException (as one of SqlError objects) and as InvalidOperationException
expected = true;
}
if (!expected)
{
throw;
}
}
}
private void Cleanup()
{
while (true)
{
if (!this._cts.IsCancellationRequested)
{
//Thread.Sleep(10);
}
Segment oldSegment = (Segment)this._currentSegment;
if (Thread.VolatileRead(ref oldSegment.Count) > 100 || this._cts.IsCancellationRequested)
{
bool isCancellationRequested = this._cts.IsCancellationRequested;
Segment newSegment = new Segment();
Thread.VolatileWrite(ref this._currentSegment, newSegment);
this.Exchanges++;
using (FileStream fs = new FileStream(this._fileName, FileMode.Append, FileAccess.Write, FileShare.None, 1024 * 1024, FileOptions.WriteThrough))
{
using (StreamWriter sw = new StreamWriter(fs))
{
string msg;
while (oldSegment.Queue.TryDequeue(out msg))
{
sw.WriteLine(msg);
this.RecordsWritten++;
}
if (Thread.VolatileRead(ref oldSegment.RefCount) > 0)
{
//this.RefCount1++;
SpinWait.SpinUntil(() => { return(Thread.VolatileRead(ref oldSegment.RefCount) == 0); }, 10);
if (Thread.VolatileRead(ref oldSegment.RefCount) > 0)
{
//this.RefCount2++;
Thread.Yield();
if (Thread.VolatileRead(ref oldSegment.RefCount) > 0)
{
//this.RefCount3++;
SpinWait.SpinUntil(() => { return(Thread.VolatileRead(ref oldSegment.RefCount) == 0); });
}
}
while (oldSegment.Queue.TryDequeue(out msg))
{
sw.WriteLine(msg);
this.RecordsWritten++;
}
}
sw.Flush();
fs.Flush();
}
}
if (this._cts.IsCancellationRequested && isCancellationRequested)
{
break;
}
}
}
}
static void Main(string[] args)
{
Directory.CreateDirectory(Path.GetDirectoryName(System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName) + "\\Log");
var storeMore = "";
int tCnt = _thread;
log.Info("***************************************************");
log.Info("Server Host Address: " + _storeServerHost);
log.Info("Server Port: " + _storeServerPort);
log.Info("Server AE Title: " + _storeServerAET);
log.Info("Client AE Title: " + _aet);
log.Info("Test count: " + _count);
log.Info("Test interval: " + _interval);
log.Info("Test thread: " + _thread);
log.Info("Test dicom: " + _testDICOMPath);
log.Info("***************************************************");
if (_manual == "Y")
{
tCnt = 1;
log.Info("To start test, enter \"y\"; Othersie, press any key to exit: ");
storeMore = Console.ReadLine().Trim();
if (storeMore.Length > 0 && storeMore.ToLower()[0] == 'y')
{
}
else
{
Environment.Exit(0);
}
}
Thread[] workerThreads = new Thread[tCnt];
for (int i = 0; i < workerThreads.Length; i++)
{
int tNum = i;
workerThreads[i] = new Thread(new ThreadStart(async() =>
{
//var client = new DicomClient(_storeServerHost, _storeServerPort, false, _aet, _storeServerAET);
//Add a handler to be notified of any association rejections
//client.AssociationRejected += (sender, e) => {
// log.Warn($"Association was rejected. Rejected Reason:{e.Reason}");
//};
//Add a handler to be notified of any association information on successful connections
//client.AssociationAccepted += (sender, e) =>
//{
// log.Info(($"Association was accepted by:{e.Association.RemoteHost}");
//};
//Add a handler to be notified when association is successfully released - this can be triggered by the remote peer as well
//client.AssociationReleased += (sender, e) => {
// log.Info("Association was released. BYE BYE!");
//};
//client.RequestTimedOut += (sender, e) =>
//{
// log.Warn($"Send PACS error exception:{e.Request} {e.Timeout}");
// throw new NotImplementedException();
//};
//client.NegotiateAsyncOps();
int count = 0;
while ((_manual == "Y" && storeMore.Length > 0 && storeMore.ToLower()[0] == 'y') || (_manual != "Y" && count < _count))
{
try
{
var client = new DicomClient(_storeServerHost, _storeServerPort, false, _aet, _storeServerAET);
client.NegotiateAsyncOps();
string dicomFile = _testDICOMPath;
if (_manual == "Y")
{
while (!File.Exists(dicomFile))
{
log.Warn("Invalid file path, enter the path for a DICOM file or press Enter to Exit:");
dicomFile = Console.ReadLine();
if (string.IsNullOrWhiteSpace(dicomFile))
{
return;
}
}
}
else
{
if (!File.Exists(dicomFile))
{
log.Warn("Invalid file path, check test dicom file: " + _testDICOMPath);
return;
}
}
if (_manual != "Y")
{
log.Info("Test " + tNum + "-[" + (count + 1) + "]");
}
var request = new DicomCStoreRequest(dicomFile);
request.OnResponseReceived += (req, response) =>
{
if (_manual == "Y")
{
log.Info("C-Store Response Received, Status: " + response.Status);
log.Info("To test again, enter \"y\"; Othersie, press any key to exit: ");
storeMore = Console.ReadLine().Trim();
if (storeMore.Length > 0 && storeMore.ToLower()[0] == 'y')
{
}
else
{
Environment.Exit(0);
}
}
else
{
log.Info(tNum + "-[" + (count + 1) + "] " + "C-Store Response Received, Status: " + response.Status);
if (count < (_count - 1))
{
int fortimerinterval = 0;
if (_interval == "random")
{
fortimerinterval = rand.Next(_randomIntervalmin, _randomIntervalmax);
}
else
{
fortimerinterval = Int32.Parse(_interval);
}
log.Info(tNum + "-[" + (count + 1) + "] " + "Time interval " + fortimerinterval / 1000 + " seconds");
count++;
Thread.Sleep(fortimerinterval);
}
else
{
bool allDone = true;
foreach (var workerThread in workerThreads)
{
if (workerThread.IsAlive)
{
allDone = false;
break;
}
}
if (allDone)
{
Thread.Sleep(15000);
Environment.Exit(0);
}
}
}
};
await client.AddRequestAsync(request);
await client.SendAsync();
}
catch (DicomAssociationRejectedException assoRejectEx)
{
log.Warn("----------------------------------------------------");
log.Warn(tNum + "-[" + (count + 1) + "] " + assoRejectEx.Message);
log.Warn("----------------------------------------------------");
}
catch (Exception exception)
{
log.Error("----------------------------------------------------");
log.Error(tNum + "-[" + (count + 1) + "] " + exception.ToString());
log.Error("----------------------------------------------------");
}
}
}
))
{
IsBackground = true,
Name = $"SenderThread #{i}",
Priority = ThreadPriority.AboveNormal
};
workerThreads[i].Start();
}
// Await all background threads
foreach (var workerThread in workerThreads)
{
workerThread.Join(600000); // 10 minutes thread timeout
}
SpinWait.SpinUntil(() => false);
}
public void CanBackupToDirectory_MultipleBackups()
{
var backupPath = NewDataPath("BackupFolder");
using (var store = NewDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(new User {
Name = "oren"
});
var periodicBackupSetup = new PeriodicExportSetup
{
LocalFolderName = backupPath,
IntervalMilliseconds = 25
};
session.Store(periodicBackupSetup, PeriodicExportSetup.RavenDocumentKey);
session.SaveChanges();
}
SpinWait.SpinUntil(() =>
{
var jsonDocument = store.DatabaseCommands.Get(PeriodicExportStatus.RavenDocumentKey);
if (jsonDocument == null)
{
return(false);
}
var periodicBackupStatus = jsonDocument.DataAsJson.JsonDeserialization <PeriodicExportStatus>();
return(periodicBackupStatus.LastDocsEtag != Etag.Empty && periodicBackupStatus.LastDocsEtag != null);
});
var etagForBackups = store.DatabaseCommands.Get(PeriodicExportStatus.RavenDocumentKey).Etag;
using (var session = store.OpenSession())
{
session.Store(new User {
Name = "ayende"
});
session.SaveChanges();
}
SpinWait.SpinUntil(() =>
store.DatabaseCommands.Get(PeriodicExportStatus.RavenDocumentKey).Etag != etagForBackups);
}
using (var store = NewDocumentStore())
{
var dataDumper = new DataDumper(store.SystemDatabase)
{
SmugglerOptions = { Incremental = true }
};
dataDumper.ImportData(new SmugglerImportOptions {
FromFile = backupPath
}).Wait();
using (var session = store.OpenSession())
{
Assert.Equal("oren", session.Load <User>(1).Name);
Assert.Equal("ayende", session.Load <User>(2).Name);
}
}
IOExtensions.DeleteDirectory(backupPath);
}
private void Test(Func<long> generate, int threadCount, int generatedIdCount)
{
var waitingThreadCount = 0;
var starterGun = new ManualResetEvent(false);
var results = new long[generatedIdCount];
var threads = Enumerable.Range(0, threadCount).Select(threadNumber => new Thread(() =>
{
// Wait for all threads to be ready
Interlocked.Increment(ref waitingThreadCount);
starterGun.WaitOne();
for (int i = threadNumber; i < generatedIdCount; i += threadCount)
results[i] = generate();
})).ToArray();
foreach (var t in threads)
t.Start();
// Wait for all tasks to reach the waiting stage
var wait = new SpinWait();
while (waitingThreadCount < threadCount)
wait.SpinOnce();
// Start all the threads at the same time
starterGun.Set();
foreach (var t in threads)
t.Join();
var ids = new HashSet<long>();
foreach (var value in results)
{
if (!ids.Add(value))
{
throw new AssertException("Id " + value + " was generated more than once, in indices "
+ string.Join(", ", results.Select(Tuple.Create<long, int>).Where(x => x.Item1 == value).Select(x => x.Item2)));
}
}
for (long i = 1; i <= GeneratedIdCount; i++)
Assert.True(ids.Contains(i), "Id " + i + " was not generated.");
}
/// <summary>
/// 接收CAN总线上的数据
/// </summary>
private void DeviceReceive()
{
VCI_ERR_INFO pErrInfo = new VCI_ERR_INFO();
while (true)
{
SpinWait.SpinUntil(() => false, 1);//80
//返回接收缓冲区中尚未被读取的帧数
UInt32 num = VCI_GetReceiveNum(devType, devIndex, devChannel);
if (num == 0)
{
continue;
}
//分配一次最多接收VCI_GetReceiveNum函数返回值的帧数的数据存储内存空间
IntPtr pt = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(VCI_CAN_OBJ)) * (int)num);
//返回实际读到的帧数，如返回的为0xFFFFFFFF，则读取数据失败，有错误发生。
UInt32 len = VCI_Receive(devType, devIndex, devChannel, pt, num, -1);
if (len == 0xFFFFFFFF)
{
VCI_ReadErrInfo(devType, devIndex, devChannel, ref pErrInfo);
//释放分配的内存空间
Marshal.FreeHGlobal(pt);
continue;
}
//获取CAN总线上的数据并触发事件
for (int i = 0; i < len; i++)
{
VCI_CAN_OBJ receData = (VCI_CAN_OBJ)Marshal.PtrToStructure((IntPtr)((UInt32)pt + i * Marshal.SizeOf(typeof(VCI_CAN_OBJ))), typeof(VCI_CAN_OBJ));
string _data = String.Empty;
byte[] temp = receData.Data;
for (int j = 0; j < receData.DataLen; j++)
{
_data += String.Format("{0:X2}", temp[j]) + " ";
}
//将接收的数据添加到table中
lock (DataBase)
{
DataRow _dr = DataBase.NewRow();
_dr["dttype"] = 1;
_dr["id"] = "0x" + string.Format("{0:X}", receData.ID);
_dr["direction"] = (string)Application.Current.Resources["teReceive"];
_dr["type"] = receData.ExternFlag == 0 ? (string)Application.Current.Resources["teStandardFrame"] : (string)Application.Current.Resources["teExtendedFrame"];
_dr["time"] = DateTime.Now.ToString("MM/dd HH:mm:ss:ffff");//((double)receData.TimeStamp / 10000).ToString().PadRight(9, '0');
_dr["data"] = _data.Trim();
_dr["signal"] = 0;
DataBase.Rows.Add(_dr);
if (DataBase.Rows.Count > 1000)
{
for (int n = 0; n < DataBase.Rows.Count - 1000; n++)
{
DataBase.Rows.RemoveAt(0);
}
}
}
}
Marshal.FreeHGlobal(pt);
}
}
public void TickCountTest()
{
int start = Environment.TickCount;
Assert.True(SpinWait.SpinUntil(() => Environment.TickCount - start > 0, TimeSpan.FromSeconds(1)));
}
public static void SpinUntil (Func<bool> condition)
{
SpinWait sw = new SpinWait ();
while (!condition ())
sw.SpinOnce ();
}
public static void AssertIsFalseEventually(Func <bool> condition, TimeSpan?timeout = null)
{
timeout = timeout ?? TimeSpan.FromSeconds(10);
Assert.IsTrue(SpinWait.SpinUntil(() => !condition(), timeout.Value));
}
public async void Play(object sender, EventArgs e)
{
ExecuteTimer.Stop();
//Globals.FailSafe = 1; //Force failsafe
//Check for failsafe
if (Globals.PlayerTurn == 0 || Globals.FailSafe == 1 || Globals.PlayerTurn > PlayersAmount.Maximum || PlayersAmount.Value == 0 || Globals.NotEnoughCards == 1)
{
GamesAmount.Value = GamesAmount.Minimum;
DebugBox.Text = "";
Status.Text = "Status: Simulation Ended ----> Error (either the card distribution is wrong or memory is corrupted) check debug box";
DebugBox.AppendText("PlayerTurn ----> " + Globals.PlayerTurn + Environment.NewLine);
if (Globals.FailSafe == 1)
{
DebugBox.AppendText("FailSafe is set to 1 ---> Try using a set seed." + Environment.NewLine);
}
if (Globals.PlayerTurn > PlayersAmount.Maximum)
{
DebugBox.AppendText("PlayerTurn > PlayersAmount.Maximum ----> Are you editing memory? Wrong value to edit" + Environment.NewLine);
}
if (PlayersAmount.Value == 0)
{
DebugBox.AppendText("PlayersAmount.Value == 0 ----> Are you editing memory? Wrong value to edit" + Environment.NewLine);
}
if (Globals.NotEnoughCards == 1)
{
DebugBox.AppendText("Globals.NotEnoughCards ----> You need to add more cards" + Environment.NewLine);
}
DebugBox.AppendText(Environment.NewLine + "Open an issue on my GitHub and paste this output if you don't know how to solve this issue");
}
else
{
var watch = System.Diagnostics.Stopwatch.StartNew();
Status.Text = "Status: Running simulation...";
//var TempPlayerArray[] =
//Alpha is the id of the game being simulated
for (int alpha = 1; alpha <= GamesAmount.Value; alpha++)
{
NewGame();
//Set game to on
Globals.isGameOn = true;
//Used to check if player can play or not
//var ALLOW_TURN_EDIT = 1;
//Display current game in Main
CurrentGameLabel.Text = "Current game: " + alpha + "/" + GamesAmount.Value;
//While game is on
// {{{{{{{{ NOTE: THIS IS BASICALLY THE BEGINNING OF THE AI }}}}}}}}
while (Globals.isGameOn)
{
//Add a tiny-tiny delay
await PutTaskDelay(1);
//Reset personal flags
Globals.DoIHaveSameColors = false;
Globals.DoIHaveSameNumbers = false;
Globals.DoIHaveSameID = false;
Globals.DoIHaveWild = false;
//Fix stepping, as it doesn't really work.
if (Stepping.Checked)
{
SpinWait.SpinUntil(() => Globals.DebugWait == false, 50); //This can be used to slow down the calculation
if (Globals.DebugWait == false)
{
Globals.DebugWait = true;
Globals.isGameOn = false;
}
}
/*
*
* We should consider a setting up a risk score first, then choose what to play based on that
*
* But before that, check who's playing next.
*
*
*/
// {{{{{{{{ EVALUATION }}}}}}}}
// {{{{{{{{ WHO'S NEXT ? }}}}}}}}
JObject rss = JObject.Parse(Globals.JsonGame);
JObject game = rss["Game"] as JObject;
//Who's playing next?
// Json: Game --> Next_Player
Globals.PlayerTurn = (int)rss["Game"]["Next_Player"];
if (Globals.Clockwise == true)
{
if (Globals.PlayerTurn + 1 > PlayersAmount.Value)
{
game["Next_Player"] = 1;
Globals.PlayerTurn = 1;
}
else
{
game["Next_Player"] = Globals.PlayerTurn + 1;
Globals.PlayerTurn = Globals.PlayerTurn + 1;
}
}
else
{
if (Globals.PlayerTurn - 1 == 0)
{
game["Next_Player"] = PlayersAmount.Value;
Globals.PlayerTurn = Convert.ToInt32(PlayersAmount.Value);
}
else
{
game["Next_Player"] = Globals.PlayerTurn - 1;
Globals.PlayerTurn = Globals.PlayerTurn - 1;
}
}
// {{{{{{{{ GET TOP CARD }}}}}}}}
//Get top card
Scoreboard.Text = Globals.JsonGame; //debug
Globals.DoIHaveSameColors = false;
Globals.DoIHaveSameID = false;
//Get identity of deck (current player turn)
JArray decks = (JArray)game["Player_Decks"][Globals.PlayerTurn.ToString()];
//Check if I have the same color
string color_to_check = (string)rss["Game"]["TopCard_Color"];
for (int i = 0; i < decks.Count; i++)
{
if (Globals.DoIHaveSameColors == false && color_to_check == decks[i].ToString().Split('_').Last())
{
//Set top card color
//Top should be: 0_Green
//Seed 0 --> Deck: Contains 1_Green. so it's true (last is 9_blue)
Globals.DoIHaveSameColors = true;
//Scoreboard.Text = "Top: "+color_to_check+ ", my: "+decks[i].ToString().Split('_').Last(); //debug
}
}
//Check if I have the same id
//It can be a number, trap, wild, ecc.. Same card ignoring color
string id_to_check = (string)rss["Game"]["TopCard_ID"];
for (int i = 0; i < decks.Count; i++)
{
if (Globals.DoIHaveSameID == false && id_to_check == decks[i].ToString().Split('_').First())
{
if (decks[i].ToString().Split('_').First() == "Wild")
{
Globals.DoIHaveWild = true;
}
Globals.DoIHaveSameID = true;
}
}
/* Calculate end game
*
* -We can check if any player has no cards, that means someone has won
* Better add this check after a placement/usage of card and then we set a flag or simply set "isGameOn" to true
*
*/
//Atm I have no idea if the turn change works, as there's nothing that checks if a game must go on.
//Once code gets executed here, game just ends (thinking of including a score check for "isGameOn")
//Change turn
//End of game
if (Stepping.Checked == false)
{
Globals.isGameOn = false;
}
}
}
Status.Text = "Status: Simulation Ended";
// the code that you want to measure comes here
watch.Stop();
var elapsedMs = watch.ElapsedMilliseconds;
EmulationLabel.Text = "Emulation time taken: " + elapsedMs.ToString() + "ms";
}
//END OF SIMULATION
}
private void RegularUpdateRealTimeCarInfo(IMaintainDevice mtx, AVEHICLE carOurVh)
{
do
{
UInt16 car_id = (ushort)carOurVh.Num;
UInt16 action_mode = 0;
if (carOurVh.ACT_STATUS == ProtocolFormat.OHTMessage.VHActionStatus.Commanding)
{
if (!SCUtility.isEmpty(carOurVh.MCS_CMD))
{
action_mode = CAR_ACTION_MODE_ACTION_FOR_MCS_COMMAND;
}
else
{
action_mode = CAR_ACTION_MODE_ACTION;
}
}
else
{
action_mode = CAR_ACTION_MODE_NO_ACTION;
}
UInt16 cst_exist = (ushort)carOurVh.HAS_CST;
UInt16 current_section_id = 0;
UInt16.TryParse(carOurVh.CUR_SEC_ID, out current_section_id);
UInt16 current_address_id = 0;
UInt16.TryParse(carOurVh.CUR_ADR_ID, out current_address_id);
UInt32 buffer_distance = 0;
UInt16 speed = (ushort)carOurVh.Speed;
mtx.CurrentPreCarOurID = car_id;
mtx.CurrentPreCarOurActionMode = action_mode;
mtx.CurrentPreCarOurCSTExist = cst_exist;
mtx.CurrentPreCarOurSectionID = current_section_id;
mtx.CurrentPreCarOurAddressID = current_address_id;
mtx.CurrentPreCarOurDistance = buffer_distance;
mtx.CurrentPreCarOurSpeed = speed;
mtx.setCarRealTimeInfo(car_id, action_mode, cst_exist, current_section_id, current_address_id, buffer_distance, speed);
//如果在移動過程中，MTx突然變成手動模式的話，則要將原本在移動的車子取消命令
if (mtx.MTxMode == MTxMode.Manual || !mtx.CarOutSafetyCheck)
{
carOutRequestCancle(mtx, true);
LogHelper.Log(logger: logger, LogLevel: LogLevel.Warn, Class: nameof(MTLService), Device: SCAppConstants.DeviceName.DEVICE_NAME_MTx,
Data: $"Device:{mtx.DeviceID} mtx mode suddenly turned mode:{mtx.MTxMode} or car out safety check change:{mtx.CarOutSafetyCheck}, " +
$"so urgent cancel vh:{mtx.PreCarOutVhID} of command.",
XID: mtx.DeviceID);
break;
}
//如果是MTL的話，要去檢查他的Doking device(MTS)是否狀態有變化，有的話也要將命令給取消
if (mtx is MaintainLift)
{
IMaintainDevice dokingMaintainDevice = (mtx as MaintainLift).DokingMaintainDevice;
if (dokingMaintainDevice != null)
{
if (!SCUtility.isMatche(dokingMaintainDevice.DeviceSegment, carOurVh.CUR_SEG_ID) &&
(dokingMaintainDevice.MTxMode == MTxMode.Manual || !dokingMaintainDevice.CarOutSafetyCheck))
{
carOutRequestCancle(mtx, true);
LogHelper.Log(logger: logger, LogLevel: LogLevel.Warn, Class: nameof(MTLService), Device: SCAppConstants.DeviceName.DEVICE_NAME_MTx,
Data: $"Device:{dokingMaintainDevice.DeviceID} of mtx mode suddenly turned mode:{dokingMaintainDevice.MTxMode} or car out safety check change:{dokingMaintainDevice.CarOutSafetyCheck}, " +
$"so urgent cancel vh:{mtx.PreCarOutVhID} of command.",
XID: dokingMaintainDevice.DeviceID);
break;
}
}
}
SpinWait.SpinUntil(() => false, 200);
} while (!mtx.CancelCarOutRequest && !mtx.CarOurSuccess);
//mtx.setCarRealTimeInfo(0, 0, 0, 0, 0, 0, 0);
}
public async Task restore_settings_tests()
{
var backupPath = NewDataPath(suffix: "BackupFolder");
using (var store = GetDocumentStore(new Options
{
ModifyDatabaseName = s => $"{s}_2"
}))
{
var restoreConfiguration = new RestoreBackupConfiguration();
var restoreBackupTask = new RestoreBackupOperation(restoreConfiguration);
var e = Assert.Throws <RavenException>(() => store.Maintenance.Server.Send(restoreBackupTask));
Assert.Contains("Database name can't be null or empty", e.InnerException.Message);
restoreConfiguration.DatabaseName = store.Database;
restoreBackupTask = new RestoreBackupOperation(restoreConfiguration);
e = Assert.Throws <RavenException>(() => store.Maintenance.Server.Send(restoreBackupTask));
Assert.Contains("Cannot restore data to an existing database", e.InnerException.Message);
restoreConfiguration.DatabaseName = "test";
restoreBackupTask = new RestoreBackupOperation(restoreConfiguration);
e = Assert.Throws <RavenException>(() => store.Maintenance.Server.Send(restoreBackupTask));
Assert.Contains("Backup location can't be null or empty", e.InnerException.Message);
restoreConfiguration.BackupLocation = "this-path-doesn't-exist\\";
restoreBackupTask = new RestoreBackupOperation(restoreConfiguration);
e = Assert.Throws <RavenException>(() => store.Maintenance.Server.Send(restoreBackupTask));
Assert.Contains("Backup location doesn't exist", e.InnerException.Message);
using (var session = store.OpenAsyncSession())
{
await session.StoreAsync(new User { Name = "oren" }, "users/1");
await session.SaveChangesAsync();
}
var config = new PeriodicBackupConfiguration
{
BackupType = BackupType.Backup,
LocalSettings = new LocalSettings
{
FolderPath = backupPath
},
IncrementalBackupFrequency = "* * * * *" //every minute
};
var backupTaskId = (await store.Maintenance.SendAsync(new UpdatePeriodicBackupOperation(config))).TaskId;
await store.Maintenance.SendAsync(new StartBackupOperation(true, backupTaskId));
var operation = new GetPeriodicBackupStatusOperation(backupTaskId);
SpinWait.SpinUntil(() =>
{
var getPeriodicBackupResult = store.Maintenance.Send(operation);
return(getPeriodicBackupResult.Status?.LastEtag > 0);
}, TimeSpan.FromSeconds(15));
restoreConfiguration.BackupLocation = backupPath;
restoreConfiguration.DataDirectory = backupPath;
restoreBackupTask = new RestoreBackupOperation(restoreConfiguration);
e = Assert.Throws <RavenException>(() => store.Maintenance.Server.Send(restoreBackupTask));
Assert.Contains("New data directory must be empty of any files or folders", e.InnerException.Message);
var emptyFolder = NewDataPath(suffix: "BackupFolderRestore");
restoreConfiguration.BackupLocation = backupPath;
restoreConfiguration.DataDirectory = emptyFolder;
}
}
public void processCarInScenario(MaintainSpace mts)
{
CarInStart(mts);
//在收到MTL的 Car in safety check後，就可以叫Vh移動至Car in 的buffer區(MTL Home)
//不過要先判斷vh是否已經在Auto模式下如果是則先將它變成AutoLocal的模式
if (!SpinWait.SpinUntil(() => mts.CarInSafetyCheck && mts.MTxMode == MTxMode.Auto, 10000))
{
LogHelper.Log(logger: logger, LogLevel: LogLevel.Warn, Class: nameof(MTLService), Device: SCAppConstants.DeviceName.DEVICE_NAME_MTx,
Data: $"mts:{mts.DeviceID}, status not ready CarInSafetyCheck:{mts.CarInSafetyCheck},Mode:{mts.MTxMode} ,can't excute car in",
XID: mts.DeviceID);
CarInFinish(mts);
return;
}
//在車子要Car In的時候，要判斷MTS的前門是否已經開啟
if (!SpinWait.SpinUntil(() => mts.MTSFrontDoorStatus == MTSDoorStatus.Open, MTS_DOOR_OPEN_TIME_OUT_ms))
{
LogHelper.Log(logger: logger, LogLevel: LogLevel.Info, Class: nameof(MTLService), Device: SCAppConstants.DeviceName.DEVICE_NAME_MTx,
Data: $"mts:{mts.DeviceID}, status not ready {nameof(mts.MTSFrontDoorStatus)}:{ mts.MTSFrontDoorStatus} ,can't excute car in",
XID: mts.DeviceID);
CarInFinish(mts);
return;
}
AVEHICLE car_in_vh = vehicleBLL.cache.getVhByAddressID(mts.MTS_ADDRESS);
//if (car_in_vh != null && car_in_vh.isTcpIpConnect)
if (car_in_vh != null)
{
if (car_in_vh.isTcpIpConnect)
{
if (car_in_vh.MODE_STATUS == ProtocolFormat.OHTMessage.VHModeStatus.Manual)
{
VehicleService.ModeChangeRequest(car_in_vh.VEHICLE_ID, ProtocolFormat.OHTMessage.OperatingVHMode.OperatingAuto);
if (SpinWait.SpinUntil(() => car_in_vh.MODE_STATUS == VHModeStatus.AutoMts, 10000))
{
//mts.SetCarInMoving(true);
VehicleService.doAskVhToSystemInAddress(car_in_vh.VEHICLE_ID, mts.MTS_SYSTEM_IN_ADDRESS);
}
else
{
LogHelper.Log(logger: logger, LogLevel: LogLevel.Info, Class: nameof(MTLService), Device: SCAppConstants.DeviceName.DEVICE_NAME_MTx,
Data: $"Process car in scenario:{mts.DeviceID} fail. ask vh change to auto mode time out",
XID: mts.DeviceID,
VehicleID: car_in_vh.VEHICLE_ID);
CarInFinish(mts);
}
}
else if (car_in_vh.MODE_STATUS == ProtocolFormat.OHTMessage.VHModeStatus.AutoMts)
{
//mts.SetCarInMoving(true);
VehicleService.doAskVhToSystemInAddress(car_in_vh.VEHICLE_ID, mts.MTS_SYSTEM_IN_ADDRESS);
}
}
else
{
LogHelper.Log(logger: logger, LogLevel: LogLevel.Info, Class: nameof(MTLService), Device: SCAppConstants.DeviceName.DEVICE_NAME_MTx,
Data: $"Process car in scenario fail, mts:{mts.DeviceID}. because on mts of vh:{car_in_vh.VEHICLE_ID} is disconnect ",
XID: mts.DeviceID,
VehicleID: car_in_vh.VEHICLE_ID);
//mts.SetCarInMoving(false);
CarInFinish(mts);
}
}
else
{
LogHelper.Log(logger: logger, LogLevel: LogLevel.Info, Class: nameof(MTLService), Device: SCAppConstants.DeviceName.DEVICE_NAME_MTx,
Data: $"Process car in scenario fail, mts:{mts.DeviceID}. because no vh in mts",
XID: mts.DeviceID);
//mts.SetCarInMoving(false);
CarInFinish(mts);
}
}
internal bool AtomicLoopStateUpdate(int newState, int illegalStates, ref int oldState)
{
SpinWait sw = new SpinWait();
do
{
oldState = m_LoopStateFlags;
if ((oldState & illegalStates) != 0) return false;
if (Interlocked.CompareExchange(ref m_LoopStateFlags, oldState | newState, oldState) == oldState)
{
return true;
}
sw.SpinOnce();
} while (true);
}
private void CheckTrackNotesWithOutputDevice(
ICollection <EventToSend> eventsToSend,
ICollection <EventToSend> eventsWillBeSent,
TimeSpan moveFrom,
TimeSpan moveTo,
IEnumerable <int> notesWillBeStarted,
IEnumerable <int> notesWillBeFinished)
{
var playbackContext = new PlaybackContext();
var receivedEvents = playbackContext.ReceivedEvents;
var sentEvents = playbackContext.SentEvents;
var stopwatch = playbackContext.Stopwatch;
var tempoMap = playbackContext.TempoMap;
var eventsForPlayback = GetEventsForPlayback(eventsToSend, tempoMap);
var notes = eventsForPlayback.GetNotes().ToArray();
var notesStarted = new List <Note>();
var notesFinished = new List <Note>();
using (var outputDevice = OutputDevice.GetByName(SendReceiveUtilities.DeviceToTestOnName))
{
SendReceiveUtilities.WarmUpDevice(outputDevice);
outputDevice.EventSent += (_, e) => sentEvents.Add(new SentEvent(e.Event, stopwatch.Elapsed));
using (var playback = new Playback(eventsForPlayback, tempoMap, outputDevice))
{
playback.TrackNotes = true;
playback.NotesPlaybackStarted += (_, e) => notesStarted.AddRange(e.Notes);
playback.NotesPlaybackFinished += (_, e) => notesFinished.AddRange(e.Notes);
using (var inputDevice = InputDevice.GetByName(SendReceiveUtilities.DeviceToTestOnName))
{
inputDevice.EventReceived += (_, e) =>
{
lock (playbackContext.ReceivedEventsLockObject)
{
receivedEvents.Add(new ReceivedEvent(e.Event, stopwatch.Elapsed));
}
};
inputDevice.StartEventsListening();
stopwatch.Start();
playback.Start();
SpinWait.SpinUntil(() => stopwatch.Elapsed >= moveFrom);
playback.MoveToTime((MetricTimeSpan)moveTo);
var timeout = TimeSpan.FromTicks(eventsWillBeSent.Sum(e => e.Delay.Ticks)) + SendReceiveUtilities.MaximumEventSendReceiveDelay;
var areEventsReceived = SpinWait.SpinUntil(() => receivedEvents.Count == eventsWillBeSent.Count, timeout);
Assert.IsTrue(areEventsReceived, $"Events are not received for timeout {timeout}.");
stopwatch.Stop();
var playbackStopped = SpinWait.SpinUntil(() => !playback.IsRunning, SendReceiveUtilities.MaximumEventSendReceiveDelay);
Assert.IsTrue(playbackStopped, "Playback is running after completed.");
}
}
}
CompareSentReceivedEvents(sentEvents, receivedEvents, eventsWillBeSent.ToList());
MidiAsserts.AreEqual(notesStarted, notesWillBeStarted.Select(i => notes[i]), "Invalid notes started.");
MidiAsserts.AreEqual(notesFinished, notesWillBeFinished.Select(i => notes[i]), "Invalid notes finished.");
}
protected virtual void Dispose(bool disposing) {
if (!disposed.TryRelaxedSet())
return;
if (handle != null) {
ManualResetEvent tmpHandle = Interlocked.Exchange(ref handle, null);
if (used > 0) {
// A tiny wait (just a few cycles normally) before releasing
var wait = new SpinWait();
while (used > 0)
wait.SpinOnce();
}
tmpHandle.Close();
}
}
private void CheckPlaybackStop(
ICollection <EventToSend> eventsToSend,
ICollection <EventToSend> eventsWillBeSent,
TimeSpan stopAfter,
TimeSpan stopPeriod,
PlaybackAction setupPlayback,
PlaybackAction afterStart,
PlaybackAction afterStop,
PlaybackAction afterResume,
IEnumerable <Tuple <TimeSpan, PlaybackAction> > runningAfterResume = null,
ICollection <TimeSpan> explicitExpectedTimes = null,
double speed = 1.0,
ICollection <ReceivedEvent> expectedReceivedEvents = null,
ICollection <ReceivedEvent> expectedPlayedEvents = null)
{
var playbackContext = new PlaybackContext();
var playedEvents = new List <ReceivedEvent>();
var receivedEvents = playbackContext.ReceivedEvents;
var sentEvents = playbackContext.SentEvents;
var stopwatch = playbackContext.Stopwatch;
var tempoMap = playbackContext.TempoMap;
var eventsForPlayback = GetEventsForPlayback(eventsToSend, tempoMap);
var expectedTimes = playbackContext.ExpectedTimes;
if (explicitExpectedTimes != null || expectedReceivedEvents != null || expectedPlayedEvents != null)
{
expectedTimes.AddRange(explicitExpectedTimes ?? (expectedReceivedEvents?.Select(e => e.Time) ?? expectedPlayedEvents.Select(e => e.Time)));
}
else
{
var currentTime = TimeSpan.Zero;
foreach (var eventWillBeSent in eventsWillBeSent)
{
currentTime += eventWillBeSent.Delay;
var scaledCurrentTime = ScaleTimeSpan(currentTime, 1.0 / speed);
expectedTimes.Add(currentTime > stopAfter ? scaledCurrentTime + stopPeriod : scaledCurrentTime);
}
}
using (var outputDevice = OutputDevice.GetByName(SendReceiveUtilities.DeviceToTestOnName))
{
SendReceiveUtilities.WarmUpDevice(outputDevice);
outputDevice.EventSent += (_, e) => sentEvents.Add(new SentEvent(e.Event, stopwatch.Elapsed));
using (var playback = new Playback(eventsForPlayback, tempoMap, outputDevice))
{
playback.Speed = speed;
setupPlayback(playbackContext, playback);
if (expectedPlayedEvents != null)
{
playback.EventPlayed += (_, e) => playedEvents.Add(new ReceivedEvent(e.Event, stopwatch.Elapsed));
}
using (var inputDevice = InputDevice.GetByName(SendReceiveUtilities.DeviceToTestOnName))
{
inputDevice.EventReceived += (_, e) =>
{
lock (playbackContext.ReceivedEventsLockObject)
{
receivedEvents.Add(new ReceivedEvent(e.Event, stopwatch.Elapsed));
}
};
inputDevice.StartEventsListening();
stopwatch.Start();
playback.Start();
afterStart(playbackContext, playback);
SpinWait.SpinUntil(() => stopwatch.Elapsed >= stopAfter);
playback.Stop();
afterStop(playbackContext, playback);
Thread.Sleep(stopPeriod);
playback.Start();
afterResume(playbackContext, playback);
if (runningAfterResume != null)
{
foreach (var check in runningAfterResume)
{
Thread.Sleep(check.Item1);
check.Item2(playbackContext, playback);
}
}
var timeout = expectedTimes.Last() + SendReceiveUtilities.MaximumEventSendReceiveDelay;
var areEventsReceived = SpinWait.SpinUntil(() => receivedEvents.Count == expectedTimes.Count, timeout);
Assert.IsTrue(areEventsReceived, $"Events are not received for timeout {timeout}.");
stopwatch.Stop();
var playbackStopped = SpinWait.SpinUntil(() => !playback.IsRunning, SendReceiveUtilities.MaximumEventSendReceiveDelay);
Assert.IsTrue(playbackStopped, "Playback is running after completed.");
}
}
}
CompareSentReceivedEvents(sentEvents, receivedEvents, expectedTimes);
if (expectedReceivedEvents != null)
{
CompareReceivedEvents(receivedEvents, expectedReceivedEvents.ToList());
}
if (expectedPlayedEvents != null)
{
CompareReceivedEvents(playedEvents, expectedPlayedEvents.ToList());
}
}
/// <summary>
/// Spins until the specified condition is satisfied or until the specified timeout is expired.
/// </summary>
/// <param name="condition">A delegate to be executed over and over until it returns true.</param>
/// <param name="millisecondsTimeout">
/// The number of milliseconds to wait, or
/// <see
/// cref="System.Threading.Timeout.Infinite" />
/// (-1) to wait indefinitely.
/// </param>
/// <returns>True if the condition is satisfied within the timeout; otherwise, false</returns>
/// <exception cref="ArgumentNullException">The <paramref name="condition" /> argument is null.</exception>
/// <exception cref="T:System.ArgumentOutOfRangeException">
/// <paramref name="millisecondsTimeout" /> is a
/// negative number other than -1, which represents an infinite time-out.
/// </exception>
public static bool SpinUntil(Func<bool> condition, int millisecondsTimeout) {
if (millisecondsTimeout < Timeout.Infinite) {
throw new ArgumentOutOfRangeException("millisecondsTimeout", millisecondsTimeout, "SpinWait_SpinUntil_TimeoutWrong");
}
if (condition == null) {
throw new ArgumentNullException("condition", "SpinWait_SpinUntil_ArgumentNull");
}
long startTicks = 0;
;
if (millisecondsTimeout != 0 && millisecondsTimeout != Timeout.Infinite) {
startTicks = DateTime.UtcNow.Ticks;
}
var spinner = new SpinWait();
while (!condition()) {
if (millisecondsTimeout == 0) {
return false;
}
spinner.SpinOnce();
if (millisecondsTimeout != Timeout.Infinite && spinner.NextSpinWillYield) {
if (millisecondsTimeout <= (DateTime.UtcNow.Ticks - startTicks)/TimeSpan.TicksPerMillisecond) {
return false;
}
}
}
return true;
}
public async Task GrpcOpenCensusInputTests_StopsAndRestarts()
{
// ARRANGE
int batchesReceived = 0;
ExportTraceServiceRequest receivedBatch = null;
int port = GetPort();
var input = new GrpcOpenCensusInput("localhost", port);
input.Start(
(exportSpanRequest, callContext) =>
{
batchesReceived++;
receivedBatch = exportSpanRequest;
},
(configRequest, callContext) => ConfigResponse);
Assert.IsTrue(SpinWait.SpinUntil(() => input.IsRunning, GrpcOpenCensusInputTests.DefaultTimeout));
var grpcWriter = new GrpcWriter(false, port);
ExportTraceServiceRequest batch = new ExportTraceServiceRequest();
batch.Spans.Add(new Span()
{
Name = new TruncatableString()
{
Value = "Event1"
}
});
await grpcWriter.Write(batch).ConfigureAwait(false);
Common.AssertIsTrueEventually(
() => input.GetStats().BatchesReceived == 1 && batchesReceived == 1 &&
receivedBatch.Spans.Single().Name.Value == "Event1", GrpcOpenCensusInputTests.DefaultTimeout);
// ACT
input.Stop();
Common.AssertIsTrueEventually(
() => !input.IsRunning && input.GetStats().BatchesReceived == 1 && batchesReceived == 1 &&
receivedBatch.Spans.Single().Name.Value == "Event1", GrpcOpenCensusInputTests.DefaultTimeout);
input.Start(
(exportSpanRequest, callContext) =>
{
batchesReceived++;
receivedBatch = exportSpanRequest;
},
(configRequest, callContext) => ConfigResponse);
Assert.IsTrue(SpinWait.SpinUntil(() => input.IsRunning, GrpcOpenCensusInputTests.DefaultTimeout));
grpcWriter = new GrpcWriter(false, port);
batch.Spans.Single().Name.Value = "Event2";
await grpcWriter.Write(batch).ConfigureAwait(false);
// ASSERT
Common.AssertIsTrueEventually(
() => input.IsRunning && input.GetStats().BatchesReceived == 1 && batchesReceived == 2 &&
receivedBatch.Spans.Single().Name.Value == "Event2", GrpcOpenCensusInputTests.DefaultTimeout);
}
public static void AssertIsFalseEventually(Func <bool> condition, TimeSpan?timeout = null)
{
timeout = timeout ?? Timeout.InfiniteTimeSpan;
Assert.IsFalse(SpinWait.SpinUntil(condition, timeout.Value));
}
public void Authenticate_should_not_throw_when_authentication_succeeds(
[Values(false, true)] bool async)
{
var randomStringGenerator = new ConstantRandomStringGenerator(_clientNonce);
var subject = new ScramSha256Authenticator(__credential, randomStringGenerator);
var saslStartReply = MessageHelper.BuildReply <RawBsonDocument>(RawBsonDocumentHelper.FromJson(
@"{conversationId: 1," +
$" payload: BinData(0,\"{ToUtf8Base64(_serverResponse1)}\")," +
@" done: false,
ok: 1}"));
var saslContinueReply = MessageHelper.BuildReply <RawBsonDocument>(RawBsonDocumentHelper.FromJson(
@"{conversationId: 1," +
$" payload: BinData(0,\"{ToUtf8Base64(_serverReponse2)}\")," +
@" done: true,
ok: 1}"));
var connection = new MockConnection(__serverId);
connection.EnqueueReplyMessage(saslStartReply);
connection.EnqueueReplyMessage(saslContinueReply);
var expectedRequestId = RequestMessage.CurrentGlobalRequestId + 1;
Action act;
if (async)
{
act = () => subject.AuthenticateAsync(connection, __description, CancellationToken.None).GetAwaiter().GetResult();
}
else
{
act = () => subject.Authenticate(connection, __description, CancellationToken.None);
}
var exception = Record.Exception(act);
exception.Should().BeNull();
SpinWait.SpinUntil(() => connection.GetSentMessages().Count >= 2, TimeSpan.FromSeconds(5)).Should().BeTrue();
var sentMessages = MessageHelper.TranslateMessagesToBsonDocuments(connection.GetSentMessages());
sentMessages.Count.Should().Be(2);
var actualRequestId0 = sentMessages[0]["requestId"].AsInt32;
var actualRequestId1 = sentMessages[1]["requestId"].AsInt32;
actualRequestId0.Should().BeInRange(expectedRequestId, expectedRequestId + 10);
actualRequestId1.Should().BeInRange(actualRequestId0 + 1, actualRequestId0 + 11);
sentMessages[0].Should().Be(
@"{opcode: ""query""," +
$" requestId: {actualRequestId0}," +
@" database: ""source"",
collection: ""$cmd"",
batchSize: -1,
slaveOk: true,
query: {saslStart: 1,
mechanism: ""SCRAM-SHA-256""," +
$" payload: new BinData(0, \"{ToUtf8Base64(_clientRequest1)}\")}}}}");
sentMessages[1].Should().Be(
@"{opcode: ""query""," +
$" requestId: {actualRequestId1}," +
@" database: ""source"",
collection: ""$cmd"",
batchSize: -1,
slaveOk: true,
query: {saslContinue: 1,
conversationId: 1, " +
$" payload: new BinData(0, \"{ToUtf8Base64(_clientRequest2)}\")}}}}");
}
