public void ShutDownShouldNotBlockDequeueWhenThereAreWorkItemsInTheQueue()
{
ManualResetEvent manualResetEvent = new ManualResetEvent(false);
const int workItemWaiterTimeOutInMilliSeconds = 1000;
WorkItemQueue workItemQueue = new WorkItemQueue(workItemWaiterTimeOutInMilliSeconds);
IWorkItem workItem = Substitute.For <IWorkItem>();
workItemQueue.Enqueue(workItem);
new Thread(
() =>
{
manualResetEvent.Set();
manualResetEvent.Reset();
manualResetEvent.WaitOne(300);
IWorkItem dequeuedWorkItem = workItemQueue.Dequeue();
Assert.AreEqual(workItem, dequeuedWorkItem);
}).Start();
manualResetEvent.WaitOne(300);
workItemQueue.ShutDown();
manualResetEvent.Set();
}
public void Test_RefreshWorkItemStatus_UntilFail()
{
DummyLogger mockedLogger = new DummyLogger();
WorkItemQueue queue = new WorkItemQueue(10, mockedLogger);
WorkItemProgress progress = new WorkItemProgress();
LookupWorkItem workItem = new LookupWorkItem(progress);
progress.Progress = Progress.NotStarted;
queue.AddWorkItem(workItem);
Assert.AreEqual(1, queue.PendingItemsNum);
Assert.AreEqual(1, mockedLogger.AddLogged);
queue.Refresh();
Assert.AreEqual(Progress.Running, progress.Progress);
Assert.AreEqual(0, queue.PendingItemsNum);
Assert.AreEqual(1, queue.ActiveItemsNum);
Assert.AreEqual(1, queue.RunningItemsNum);
queue.Refresh();
queue.Refresh();
Assert.AreEqual(0, queue.PendingItemsNum);
Assert.AreEqual(1, queue.ActiveItemsNum);
Assert.AreEqual(1, queue.RunningItemsNum);
Assert.AreEqual(0, mockedLogger.CompletedLogged);
progress.Progress = Progress.Failed;
queue.Refresh();
Assert.AreEqual(0, queue.ActiveItemsNum);
Assert.AreEqual(0, mockedLogger.CompletedLogged);
Assert.AreEqual(1, mockedLogger.FailedLogged);
}
public void ShutDownShouldNotWaitMoreThanWaiterTimeOutWhenThereIsNoWorkItemsInTheQueue()
{
AutoResetEvent autoResetEvent = new AutoResetEvent(false);
const int workItemWaiterTimeOutInMilliSeconds = 1000;
WorkItemQueue workItemQueue = new WorkItemQueue(workItemWaiterTimeOutInMilliSeconds);
new Thread(
() =>
{
Thread.Sleep(100);
autoResetEvent.Set();
IWorkItem workItem = workItemQueue.Dequeue();
autoResetEvent.Set();
Assert.AreEqual(null, workItem);
}).Start();
autoResetEvent.WaitOne(500);
Stopwatch stopwatch = Stopwatch.StartNew();
workItemQueue.ShutDown();
autoResetEvent.WaitOne(workItemWaiterTimeOutInMilliSeconds + 100);
stopwatch.Stop();
Assert.Less(stopwatch.ElapsedMilliseconds, workItemWaiterTimeOutInMilliSeconds);
}
public void EnqueueTrySignalMethodShouldBeCalledWhenWaitingStackIsNotEmpty()
{
IWorkItemWaiterEntry workItemWaiterEntry = Substitute.For <IWorkItemWaiterEntry>();
IWorkItemWaiterEntryStack workItemWaiterEntryStack = Substitute.For <IWorkItemWaiterEntryStack>();
int count = 1;
workItemWaiterEntryStack.Count.Returns(x => count);
workItemWaiterEntryStack.Pop().Returns(
x =>
{
if (count == 1)
{
count = 0;
return(workItemWaiterEntry);
}
return(null);
});
WorkItemQueue workItemQueue = new WorkItemQueue(1 * 1000, workItemWaiterEntryStack);
IWorkItem workItem = Substitute.For <IWorkItem>();
workItemQueue.Enqueue(workItem);
workItemWaiterEntry.Received(1).TrySignal(workItem);
}
public void EnqueueShouldThrowExceptionWhenItIsCalledAfterShutDown()
{
WorkItemQueue workItemQueue = new WorkItemQueue(1 * 300);
workItemQueue.ShutDown();
Assert.Throws <LaboThreadingException>(() => workItemQueue.Enqueue(Substitute.For <IWorkItem>()));
}
internal async override Task InitializeAsync()
{
this.BackupMappingStore = await BackupMappingStore.CreateOrGetBackupMappingStore(this.StatefulService).ConfigureAwait(false);
this.BackupPolicyStore = await BackupPolicyStore.CreateOrGetBackupPolicyStore(this.StatefulService).ConfigureAwait(false);
this.WorkItemQueue = await WorkItemQueue.CreateOrGetWorkItemQueue(this.StatefulService).ConfigureAwait(false);
}
private async Task UpdateSecretsAsync(string thumbprintFromManifest, string x509StoreNameFromManifest, CancellationToken cancellationToken)
{
BackupRestoreTrace.TraceSource.WriteInfo(TraceType, String.Format("Updating secrets using the new thumbprint {0}", thumbprintFromManifest));
using (var transaction = this.StateManager.CreateTransaction())
{
try
{
var policyStore = await BackupPolicyStore.CreateOrGetBackupPolicyStore(this);
var workItemQueue = await WorkItemQueue.CreateOrGetWorkItemQueue(this);
var policies = await policyStore.GetValuesAsync(Common.Constants.StoreTimeOut, cancellationToken, transaction);
foreach (var policy in policies)
{
cancellationToken.ThrowIfCancellationRequested();
var updatedStorage = this.UpdateSecretInStorage(policy.Storage, thumbprintFromManifest, x509StoreNameFromManifest, cancellationToken);
var newPolicy = policy.ToBuilder()
.WithBackupStorage(updatedStorage)
.UpdateUniqueId()
.Build();
if (!await policyStore.UpdateValueAsync(policy.Name, policy, newPolicy, Common.Constants.StoreTimeOut, cancellationToken, transaction))
{
throw new InvalidOperationException(String.Format("Failed to update secret for policy with name {0}", newPolicy.Name));
}
if (newPolicy.BackupEnabledSet.Count > 0)
{
await workItemQueue.AddWorkItem(
new UpdateEnablementWorkItem(newPolicy.BackupEnabledSet.ToList(),
new WorkItemInfo
{
WorkItemType = WorkItemPropogationType.UpdateBackupPolicy,
BackupPolicyUpdateGuid = newPolicy.UniqueId
}), Common.Constants.StoreTimeOut, cancellationToken, transaction);
}
}
// Update the config store
var configStore = await ConfigStore.CreateOrGetConfigStore(this);
await configStore.UpdateValueAsync(Common.Constants.SecretUpdateInProgress, String.Empty, Common.Constants.StoreTimeOut, cancellationToken, transaction);
await configStore.UpdateValueAsync(Common.Constants.EncryptionCertThumbprintKey, thumbprintFromManifest, Common.Constants.StoreTimeOut, cancellationToken, transaction);
await transaction.CommitAsync();
BackupRestoreTrace.TraceSource.WriteInfo(TraceType, "All secrets updated with manifest {0}", thumbprintFromManifest);
FabricEvents.Events.BRSSecretsUpdated(TraceType, thumbprintFromManifest);
}
catch (Exception ex)
{
BackupRestoreTrace.TraceSource.WriteExceptionAsWarning(TraceType, ex, "Exception encountered while updating secrets");
throw;
}
}
}
public void DefaultConstructorShouldSetTheDefaultWorkerThreadIdleTimeout()
{
WorkerThreadPool workerThreadPool = new WorkerThreadPool();
WorkItemQueue workItemQueue = (WorkItemQueue)workerThreadPool.WorkItemQueue;
Assert.AreEqual(WorkerThreadPool.DEFAULT_WORKER_THREAD_IDLE_TIMEOUT, workItemQueue.WorkItemWaiterTimeOutInMilliSeconds);
workerThreadPool.Shutdown(true, 500);
}
public void DequeueShouldReturnQueuedWorkItemWhenQueueIsNotEmpty()
{
WorkItemQueue workItemQueue = new WorkItemQueue(1 * 1000);
IWorkItem workItemFirst = Substitute.For <IWorkItem>();
IWorkItem workItemLast = Substitute.For <IWorkItem>();
workItemQueue.Enqueue(workItemFirst);
workItemQueue.Enqueue(workItemLast);
Assert.AreEqual(workItemFirst, workItemQueue.Dequeue());
Assert.AreEqual(workItemLast, workItemQueue.Dequeue());
}
internal override async Task <HttpResponseMessage> RunAsync(TimeSpan timeout, CancellationToken cancellationToken)
{
this.ThrowInvalidArgumentIfNull(this.backupPolicy);
if (string.IsNullOrEmpty(this.backupPolicyName))
{
throw new ArgumentException();
}
var workItemQueue = await WorkItemQueue.CreateOrGetWorkItemQueue(this.StatefulService);
var modelBackupPolicy = BackupPolicyModel.FromBackupPolicyView(this.backupPolicy);
var policyBuilder = modelBackupPolicy.ToBuilder()
.WithName(this.backupPolicyName);
RetentionManager retentionManager = await RetentionManager.CreateOrGetRetentionManager(this.StatefulService);
using (var transaction = this.StatefulService.StateManager.CreateTransaction())
{
var existingBackupPolicy = await this.BackupPolicyStore.GetValueWithUpdateLockModeAsync(this.backupPolicyName, timeout, cancellationToken, transaction);
if (existingBackupPolicy == null)
{
throw new FabricException(StringResources.BackupPolicyDoesNotExist, FabricErrorCode.BackupPolicyDoesNotExist);
}
var existingEnablementSet = existingBackupPolicy.BackupEnabledSet;
policyBuilder.WithBackupEnabledSet(existingEnablementSet);
var updatedBackupPolicy = policyBuilder.Build();
await this.BackupPolicyStore.UpdateValueAsync(this.backupPolicyName, existingBackupPolicy, updatedBackupPolicy, timeout, cancellationToken, transaction);
if (existingEnablementSet.Count > 0)
{
await
workItemQueue.AddWorkItem(
new UpdateEnablementWorkItem(existingEnablementSet.ToList(),
new WorkItemInfo {
WorkItemType = WorkItemPropogationType.UpdateBackupPolicy,
BackupPolicyUpdateGuid = updatedBackupPolicy.UniqueId
} ), timeout, cancellationToken, transaction);
}
await retentionManager.UpdatePolicyAsync(this.backupPolicyName, timeout, cancellationToken, transaction);
await transaction.CommitAsync();
}
return(new HttpResponseMessage(HttpStatusCode.OK));
}
public async Task RestoreOperationResultAsync(RestoreOperationResult operationResult, TimeSpan timeout,
CancellationToken cancellationToken)
{
BackupRestoreTrace.TraceSource.WriteInfo(TraceType, "RestoreOperationResultAsync invoked for partition {0}, ErrorCode {1}, message {2}",
operationResult.PartitionId, operationResult.ErrorCode, operationResult.Message);
var restoreStore = await RestoreStore.CreateOrGetRestoreStatusStore(this.statefulService);
var workItemQueue = await WorkItemQueue.CreateOrGetWorkItemQueue(this.statefulService);
string brsServiceUri = await UtilityHelper.GetCustomServiceUri(operationResult.ServiceName, timeout, cancellationToken);
var fabricUri = UtilityHelper.GetBackupMappingKey(brsServiceUri, operationResult.PartitionId.ToString());
WorkItem pushPolicyAfterRestore = new SendToServiceNodeWorkItem(brsServiceUri, operationResult.PartitionId.ToString(), new WorkItemInfo()
{
WorkItemType = WorkItemPropogationType.UpdatePolicyAfterRestore,
});
await UtilityHelper.InvokeWithRetry(async() =>
{
BackupRestoreTrace.TraceSource.WriteInfo(TraceType, "Trying to Update the Restore request for partition {0}", operationResult.PartitionId);
using (ITransaction transaction = this.statefulService.StateManager.CreateTransaction())
{
var restoreStatus = await restoreStore.GetValueWithUpdateLockModeAsync(fabricUri, timeout, cancellationToken, transaction);
if ((restoreStatus != null) &&
(restoreStatus.RestoreStatusState == RestoreState.RestoreInProgress ||
restoreStatus.RestoreStatusState == RestoreState.Accepted) &&
(restoreStatus.RestoreRequestGuid.Equals(operationResult.OperationId)))
//TODO: Add check for each request by Guid
{
var updatedRestoreStatus = restoreStatus.ToBuilder()
.WithState(operationResult.ErrorCode != 0 ? RestoreState.Failure : RestoreState.Success)
.WithErrorCode(operationResult.ErrorCode)
.WithMessage(operationResult.Message)
.WithTimeStampUtc(operationResult.TimeStampUtc)
.Build();
await restoreStore.UpdateValueAsync(fabricUri, updatedRestoreStatus, timeout, cancellationToken, transaction);
await workItemQueue.AddWorkItem(pushPolicyAfterRestore, timeout, cancellationToken, transaction);
await transaction.CommitAsync();
BackupRestoreTrace.TraceSource.WriteInfo(TraceType, "Updated the Restore request for partition {0}", operationResult.PartitionId);
}
else
{
transaction.Abort();
}
}
});
}
public void EnqueueShouldAddWorkItemsToQueueWhenThereAreNoWaiters()
{
IWorkItem workItem = Substitute.For<IWorkItem>();
WorkItemQueue workItemQueue = new WorkItemQueue(1 * 100);
IList<Task> tasks = new List<Task>
{
Task.Factory.StartNew(() => workItemQueue.Enqueue(workItem)),
Task.Factory.StartNew(() => workItemQueue.Enqueue(workItem)),
Task.Factory.StartNew(() => workItemQueue.Enqueue(workItem))
};
Task.WaitAll(tasks.ToArray());
Assert.AreEqual(3, workItemQueue.Count);
}
public void EnqueueTrySignalMethodShouldNotBeCalledWhenWaitingStackIsEmpty()
{
IWorkItemWaiterEntry workItemWaiterEntry = Substitute.For <IWorkItemWaiterEntry>();
IWorkItemWaiterEntryStack workItemWaiterEntryStack = Substitute.For <IWorkItemWaiterEntryStack>();
workItemWaiterEntryStack.Count.Returns(0);
WorkItemQueue workItemQueue = new WorkItemQueue(1 * 1000, workItemWaiterEntryStack);
IWorkItem workItem = Substitute.For <IWorkItem>();
workItemQueue.Enqueue(workItem);
workItemWaiterEntry.DidNotReceiveWithAnyArgs().TrySignal(workItem);
}
public void EnqueueShouldNotAddWorkItemToQueueWhenWaiterIsSignaled()
{
IWorkItem workItem = Substitute.For<IWorkItem>();
IWorkItemWaiterEntry workItemWaiterEntry = Substitute.For<IWorkItemWaiterEntry>();
workItemWaiterEntry.TrySignal(workItem).Returns(true);
IWorkItemWaiterEntryStack workItemWaiterEntryStack = Substitute.For<IWorkItemWaiterEntryStack>();
workItemWaiterEntryStack.Count.Returns(1);
workItemWaiterEntryStack.Pop().Returns(workItemWaiterEntry);
WorkItemQueue workItemQueue = new WorkItemQueue(1 * 1000, workItemWaiterEntryStack);
workItemQueue.Enqueue(workItem);
Assert.AreEqual(0, workItemQueue.Count);
}
public void EnqueueShouldAddWorkItemsToQueueWhenThereAreNoWaiters()
{
IWorkItem workItem = Substitute.For <IWorkItem>();
WorkItemQueue workItemQueue = new WorkItemQueue(1 * 100);
IList <Task> tasks = new List <Task>
{
Task.Factory.StartNew(() => workItemQueue.Enqueue(workItem)),
Task.Factory.StartNew(() => workItemQueue.Enqueue(workItem)),
Task.Factory.StartNew(() => workItemQueue.Enqueue(workItem))
};
Task.WaitAll(tasks.ToArray());
Assert.AreEqual(3, workItemQueue.Count);
}
public void EnqueueShouldAddWorkItemToQueueWhenAllWaitersTimedOut()
{
Stack<IWorkItemWaiterEntry> workItemWaiterEntries = new Stack<IWorkItemWaiterEntry>();
workItemWaiterEntries.Push(CreateNotSignalableWorkItemWaiterEntry());
workItemWaiterEntries.Push(CreateNotSignalableWorkItemWaiterEntry());
IWorkItemWaiterEntryStack workItemWaiterEntryStack = Substitute.For<IWorkItemWaiterEntryStack>();
workItemWaiterEntryStack.Count.Returns(x => workItemWaiterEntries.Count);
workItemWaiterEntryStack.Pop().Returns(x => workItemWaiterEntries.Pop());
WorkItemQueue workItemQueue = new WorkItemQueue(1 * 1000, workItemWaiterEntryStack);
IWorkItem workItem = Substitute.For<IWorkItem>();
workItemQueue.Enqueue(workItem);
Assert.AreEqual(1, workItemQueue.Count);
}
/// <summary>
/// Initializes a new instance of the BASS player controller.
/// </summary>
/// <param name="player">BASS player instance which contains this controller instance.</param>
/// <param name="playerMainDirectory">Directory where the BASS player is located. Plugins will be searched relative
/// to this directory.</param>
public Controller(BassPlayer player, string playerMainDirectory)
{
Log.Debug("Initializing BASS controller");
_player = player;
_bassLibraryManager = BassLibraryManager.Get(Path.Combine(playerMainDirectory, InternalSettings.PluginsPath));
_playbackProcessor = new PlaybackProcessor(this);
_outputDeviceManager = new OutputDeviceManager(this);
_mainThreadTerminated = false;
_workItemQueue = new WorkItemQueue();
_playerThread = new Thread(PlayerThreadMain) {Name = "BassPlay"};
_playerThread.Start();
SetVolume_Async(100);
}
public void EnqueueShouldNotAddWorkItemToQueueWhenWaiterIsSignaled()
{
IWorkItem workItem = Substitute.For <IWorkItem>();
IWorkItemWaiterEntry workItemWaiterEntry = Substitute.For <IWorkItemWaiterEntry>();
workItemWaiterEntry.TrySignal(workItem).Returns(true);
IWorkItemWaiterEntryStack workItemWaiterEntryStack = Substitute.For <IWorkItemWaiterEntryStack>();
workItemWaiterEntryStack.Count.Returns(1);
workItemWaiterEntryStack.Pop().Returns(workItemWaiterEntry);
WorkItemQueue workItemQueue = new WorkItemQueue(1 * 1000, workItemWaiterEntryStack);
workItemQueue.Enqueue(workItem);
Assert.AreEqual(0, workItemQueue.Count);
}
public void DequeueShouldReturnQueuedWorkItemWhenTheWaiterIsNotTimedOut()
{
IWorkItem workItem = Substitute.For <IWorkItem>();
WorkItemQueue workItemQueue = new WorkItemQueue(1 * 1000);
new Thread(
() =>
{
Thread.Sleep(200);
workItemQueue.Enqueue(workItem);
}).Start();
Assert.AreEqual(workItem, workItemQueue.Dequeue());
Assert.AreEqual(0, workItemQueue.Count);
Assert.AreEqual(0, workItemQueue.WorkItemWaiterEntryStack.Count);
}
public void EnqueueShouldAddWorkItemToQueueWhenAllWaitersTimedOut()
{
Stack <IWorkItemWaiterEntry> workItemWaiterEntries = new Stack <IWorkItemWaiterEntry>();
workItemWaiterEntries.Push(CreateNotSignalableWorkItemWaiterEntry());
workItemWaiterEntries.Push(CreateNotSignalableWorkItemWaiterEntry());
IWorkItemWaiterEntryStack workItemWaiterEntryStack = Substitute.For <IWorkItemWaiterEntryStack>();
workItemWaiterEntryStack.Count.Returns(x => workItemWaiterEntries.Count);
workItemWaiterEntryStack.Pop().Returns(x => workItemWaiterEntries.Pop());
WorkItemQueue workItemQueue = new WorkItemQueue(1 * 1000, workItemWaiterEntryStack);
IWorkItem workItem = Substitute.For <IWorkItem>();
workItemQueue.Enqueue(workItem);
Assert.AreEqual(1, workItemQueue.Count);
}
/// <summary>
/// Initializes a new instance of the BASS player controller.
/// </summary>
/// <param name="player">BASS player instance which contains this controller instance.</param>
public Controller(BassPlayer player)
{
Log.Debug("Initializing BASS controller");
_player = player;
_bassLibraryManager = BassLibraryManager.Get();
_playbackProcessor = new PlaybackProcessor(this);
_outputDeviceManager = new OutputDeviceManager(this);
_mainThreadTerminated = false;
_workItemQueue = new WorkItemQueue();
_playerThread = new Thread(PlayerThreadMain)
{
Name = "BassPlay"
};
_playerThread.Start();
SetVolume_Async(100);
}
public void DequeueShouldReturnNullWhenTheWaiterIsTimedOut()
{
IWorkItem workItem = Substitute.For <IWorkItem>();
AutoResetEvent autoResetEvent = new AutoResetEvent(false);
WorkItemQueue workItemQueue = new WorkItemQueue(1 * 300);
new Thread(
() =>
{
Thread.Sleep(1000);
workItemQueue.Enqueue(workItem);
autoResetEvent.Set();
}).Start();
Assert.AreEqual(null, workItemQueue.Dequeue());
autoResetEvent.WaitOne();
Assert.AreEqual(1, workItemQueue.Count);
Assert.AreEqual(0, workItemQueue.WorkItemWaiterEntryStack.Count);
}
public void EnqueueTrySignalMethodShouldNotBeCalledWhenWaitingStackIsEmpty()
{
IWorkItemWaiterEntry workItemWaiterEntry = Substitute.For<IWorkItemWaiterEntry>();
IWorkItemWaiterEntryStack workItemWaiterEntryStack = Substitute.For<IWorkItemWaiterEntryStack>();
workItemWaiterEntryStack.Count.Returns(0);
WorkItemQueue workItemQueue = new WorkItemQueue(1 * 1000, workItemWaiterEntryStack);
IWorkItem workItem = Substitute.For<IWorkItem>();
workItemQueue.Enqueue(workItem);
workItemWaiterEntry.DidNotReceiveWithAnyArgs().TrySignal(workItem);
}
public void EnqueueTrySignalMethodShouldBeCalledWhenWaitingStackIsNotEmpty()
{
IWorkItemWaiterEntry workItemWaiterEntry = Substitute.For<IWorkItemWaiterEntry>();
IWorkItemWaiterEntryStack workItemWaiterEntryStack = Substitute.For<IWorkItemWaiterEntryStack>();
int count = 1;
workItemWaiterEntryStack.Count.Returns(x => count);
workItemWaiterEntryStack.Pop().Returns(
x =>
{
if (count == 1)
{
count = 0;
return workItemWaiterEntry;
}
return null;
});
WorkItemQueue workItemQueue = new WorkItemQueue(1 * 1000, workItemWaiterEntryStack);
IWorkItem workItem = Substitute.For<IWorkItem>();
workItemQueue.Enqueue(workItem);
workItemWaiterEntry.Received(1).TrySignal(workItem);
}
public void ShutDownShouldNotBlockDequeueWhenThereAreWorkItemsInTheQueue()
{
ManualResetEvent manualResetEvent = new ManualResetEvent(false);
const int workItemWaiterTimeOutInMilliSeconds = 1000;
WorkItemQueue workItemQueue = new WorkItemQueue(workItemWaiterTimeOutInMilliSeconds);
IWorkItem workItem = Substitute.For<IWorkItem>();
workItemQueue.Enqueue(workItem);
new Thread(
() =>
{
manualResetEvent.Set();
manualResetEvent.Reset();
manualResetEvent.WaitOne(300);
IWorkItem dequeuedWorkItem = workItemQueue.Dequeue();
Assert.AreEqual(workItem, dequeuedWorkItem);
}).Start();
manualResetEvent.WaitOne(300);
workItemQueue.ShutDown();
manualResetEvent.Set();
}
public void EnqueueShouldThrowExceptionWhenWorkItemIsEmpty()
{
WorkItemQueue workItemQueue = new WorkItemQueue(1 * 1000, Substitute.For<IWorkItemWaiterEntryStack>());
Assert.Throws<ArgumentNullException>(() => workItemQueue.Enqueue(null));
}
public void EnqueueShouldThrowExceptionWhenItIsCalledAfterShutDown()
{
WorkItemQueue workItemQueue = new WorkItemQueue(1 * 300);
workItemQueue.ShutDown();
Assert.Throws<LaboThreadingException>(() => workItemQueue.Enqueue(Substitute.For<IWorkItem>()));
}
public void DisposeShouldNotExplode()
{
WorkItemQueue workItemQueue = new WorkItemQueue(300);
Assert.DoesNotThrow(() => workItemQueue.Dispose());
}
/// <summary>
/// Initializes a new instance of the BASS player controller.
/// </summary>
/// <param name="player">BASS player instance which contains this controller instance.</param>
/// <param name="playerMainDirectory">Directory where the BASS player is located. Plugins will be searched relative
/// to this directory.</param>
public Controller(BassPlayer player, string playerMainDirectory)
{
Log.Debug("Initializing BASS controller");
_player = player;
_bassLibraryManager = BassLibraryManager.Get(Path.Combine(playerMainDirectory, InternalSettings.PluginsPath));
_playbackProcessor = new PlaybackProcessor(this);
_outputDeviceManager = new OutputDeviceManager(this);
_mainThreadTerminated = false;
_workItemQueue = new WorkItemQueue();
_playerThread = new Thread(PlayerThreadMain) {Name = "BassPlay"};
_playerThread.Start();
SetVolume_Async(100);
}
public void DequeueShouldReturnQueuedWorkItemWhenQueueIsNotEmpty()
{
WorkItemQueue workItemQueue = new WorkItemQueue(1 * 1000);
IWorkItem workItemFirst = Substitute.For<IWorkItem>();
IWorkItem workItemLast = Substitute.For<IWorkItem>();
workItemQueue.Enqueue(workItemFirst);
workItemQueue.Enqueue(workItemLast);
Assert.AreEqual(workItemFirst, workItemQueue.Dequeue());
Assert.AreEqual(workItemLast, workItemQueue.Dequeue());
}
public void DisposeShouldNotExplode()
{
WorkItemQueue workItemQueue = new WorkItemQueue(300);
Assert.DoesNotThrow(() => workItemQueue.Dispose());
}
public void ShutDownShouldNotWaitMoreThanWaiterTimeOutWhenThereIsNoWorkItemsInTheQueue()
{
AutoResetEvent autoResetEvent = new AutoResetEvent(false);
const int workItemWaiterTimeOutInMilliSeconds = 1000;
WorkItemQueue workItemQueue = new WorkItemQueue(workItemWaiterTimeOutInMilliSeconds);
new Thread(
() =>
{
Thread.Sleep(100);
autoResetEvent.Set();
IWorkItem workItem = workItemQueue.Dequeue();
autoResetEvent.Set();
Assert.AreEqual(null, workItem);
}).Start();
autoResetEvent.WaitOne(500);
Stopwatch stopwatch = Stopwatch.StartNew();
workItemQueue.ShutDown();
autoResetEvent.WaitOne(workItemWaiterTimeOutInMilliSeconds + 100);
stopwatch.Stop();
Assert.Less(stopwatch.ElapsedMilliseconds, workItemWaiterTimeOutInMilliSeconds);
}
public void DequeueShouldReturnQueuedWorkItemWhenTheWaiterIsNotTimedOut()
{
IWorkItem workItem = Substitute.For<IWorkItem>();
WorkItemQueue workItemQueue = new WorkItemQueue(1 * 1000);
new Thread(
() =>
{
Thread.Sleep(200);
workItemQueue.Enqueue(workItem);
}).Start();
Assert.AreEqual(workItem, workItemQueue.Dequeue());
Assert.AreEqual(0, workItemQueue.Count);
Assert.AreEqual(0, workItemQueue.WorkItemWaiterEntryStack.Count);
}
public void DequeueShouldReturnNullWhenTheWaiterIsTimedOut()
{
IWorkItem workItem = Substitute.For<IWorkItem>();
AutoResetEvent autoResetEvent = new AutoResetEvent(false);
WorkItemQueue workItemQueue = new WorkItemQueue(1 * 300);
new Thread(
() =>
{
Thread.Sleep(1000);
workItemQueue.Enqueue(workItem);
autoResetEvent.Set();
}).Start();
Assert.AreEqual(null, workItemQueue.Dequeue());
autoResetEvent.WaitOne();
Assert.AreEqual(1, workItemQueue.Count);
Assert.AreEqual(0, workItemQueue.WorkItemWaiterEntryStack.Count);
}
public void EnqueueShouldThrowExceptionWhenWorkItemIsEmpty()
{
WorkItemQueue workItemQueue = new WorkItemQueue(1 * 1000, Substitute.For <IWorkItemWaiterEntryStack>());
Assert.Throws <ArgumentNullException>(() => workItemQueue.Enqueue(null));
}
async Task <AzureStorageOrchestrationService> EnsureTaskHubAsync(
string testName,
bool testDeletion,
bool deleteBeforeCreate = true,
string workerId = "test")
{
string storageConnectionString = TestHelpers.GetTestStorageAccountConnectionString();
var storageAccount = CloudStorageAccount.Parse(storageConnectionString);
string taskHubName = testName;
var settings = new AzureStorageOrchestrationServiceSettings
{
TaskHubName = taskHubName,
StorageConnectionString = storageConnectionString,
WorkerId = workerId,
};
Trace.TraceInformation($"Task Hub name: {taskHubName}");
var service = new AzureStorageOrchestrationService(settings);
if (deleteBeforeCreate)
{
await service.CreateAsync();
}
else
{
await service.CreateIfNotExistsAsync();
}
// Control queues
Assert.IsNotNull(service.AllControlQueues, "Control queue collection was not initialized.");
ControlQueue[] controlQueues = service.AllControlQueues.ToArray();
Assert.AreEqual(4, controlQueues.Length, "Expected to see the default four control queues created.");
foreach (ControlQueue queue in controlQueues)
{
Assert.IsTrue(await queue.InnerQueue.ExistsAsync(), $"Queue {queue.Name} was not created.");
}
// Work-item queue
WorkItemQueue workItemQueue = service.WorkItemQueue;
Assert.IsNotNull(workItemQueue, "Work-item queue client was not initialized.");
Assert.IsTrue(await workItemQueue.InnerQueue.ExistsAsync(), $"Queue {workItemQueue.Name} was not created.");
// TrackingStore
ITrackingStore trackingStore = service.TrackingStore;
Assert.IsNotNull(trackingStore, "Tracking Store was not initialized.");
try
{
Assert.IsTrue(trackingStore.ExistsAsync().Result, $"Tracking Store was not created.");
}
catch (NotSupportedException)
{ }
string expectedContainerName = taskHubName.ToLowerInvariant() + "-leases";
CloudBlobContainer taskHubContainer = storageAccount.CreateCloudBlobClient().GetContainerReference(expectedContainerName);
Assert.IsTrue(await taskHubContainer.ExistsAsync(), $"Task hub blob container {expectedContainerName} was not created.");
// Task Hub config blob
CloudBlob infoBlob = taskHubContainer.GetBlobReference("taskhub.json");
Assert.IsTrue(await infoBlob.ExistsAsync(), $"The blob {infoBlob.Name} was not created.");
// Task Hub lease container
CloudBlobDirectory leaseDirectory = taskHubContainer.GetDirectoryReference("default");
IListBlobItem[] leaseBlobs = (await this.ListBlobsAsync(leaseDirectory)).ToArray();
Assert.AreEqual(controlQueues.Length, leaseBlobs.Length, "Expected to see the same number of control queues and lease blobs.");
foreach (IListBlobItem blobItem in leaseBlobs)
{
string path = blobItem.Uri.AbsolutePath;
Assert.IsTrue(
controlQueues.Where(q => path.Contains(q.Name)).Any(),
$"Could not find any known control queue name in the lease name {path}");
}
if (testDeletion)
{
await service.DeleteAsync();
foreach (ControlQueue queue in controlQueues)
{
Assert.IsFalse(await queue.InnerQueue.ExistsAsync(), $"Queue {queue.Name} was not deleted.");
}
Assert.IsFalse(await workItemQueue.InnerQueue.ExistsAsync(), $"Queue {workItemQueue.Name} was not deleted.");
try
{
Assert.IsFalse(trackingStore.ExistsAsync().Result, $"Tracking Store was not deleted.");
}
catch (NotSupportedException)
{ }
Assert.IsFalse(await taskHubContainer.ExistsAsync(), $"Task hub blob container {taskHubContainer.Name} was not deleted.");
}
return(service);
}
/// <summary>
/// Initializes a new instance of the BASS player controller.
/// </summary>
/// <param name="player">BASS player instance which contains this controller instance.</param>
public Controller(BassPlayer player)
{
Log.Debug("Initializing BASS controller");
_player = player;
_bassLibraryManager = BassLibraryManager.Get();
_playbackProcessor = new PlaybackProcessor(this);
_outputDeviceManager = new OutputDeviceManager(this);
_mainThreadTerminated = false;
_workItemQueue = new WorkItemQueue();
_playerThread = new Thread(PlayerThreadMain) {Name = "BassPlay"};
_playerThread.Start();
SetVolume_Async(100);
}
