// Copyright Keysight Technologies 2012-2019
|
// This Source Code Form is subject to the terms of the Mozilla Public
|
// License, v. 2.0. If a copy of the MPL was not distributed with this
|
// file, you can obtain one at http://mozilla.org/MPL/2.0/.
|
using System;
|
using System.Collections.Generic;
|
using System.Diagnostics;
|
using System.Linq;
|
using System.Threading.Tasks;
|
using System.Threading;
|
using System.Collections.Concurrent;
|
|
namespace OpenTap
|
{
|
/// <summary>
|
/// Indicates how a IResource property should be handled when being opened or closed.
|
/// </summary>
|
public enum ResourceOpenBehavior
|
{
|
/// <summary>
|
/// The resources pointed to by this property will be opened in sequence, so any referenced resources are open before Open() and until after Close().
|
/// </summary>
|
/// <remarks>This is the default behavior</remarks>
|
Before,
|
/// <summary>
|
/// Indicates that a resource property on a resource can be opened in parallel with the resource itself.
|
/// </summary>
|
InParallel,
|
/// <summary>
|
/// Do not try to open the resource referenced by this property.
|
/// </summary>
|
Ignore
|
}
|
|
/// <summary>
|
/// Indicates how a IResource property should be handled when being opened or closed.
|
/// By default the resources will be opened in sequence, so any referenced resources are open before Open() and until after Close().
|
/// </summary>
|
[AttributeUsage(AttributeTargets.Property)]
|
public class ResourceOpenAttribute : Attribute
|
{
|
/// <summary>
|
/// Behavior of how the resource should be handled.
|
/// </summary>
|
public readonly ResourceOpenBehavior Behavior;
|
|
/// <summary>
|
/// Creates a new ResourceOpen attribute for a resource property.
|
/// </summary>
|
/// <param name="behavior"></param>
|
public ResourceOpenAttribute(ResourceOpenBehavior behavior)
|
{
|
this.Behavior = behavior;
|
}
|
}
|
|
/// <summary>
|
/// This indicates what stage a testplan execution is at.
|
/// </summary>
|
public enum TestPlanExecutionStage
|
{
|
/// <summary>
|
/// Indicates that a testplan is being opened.
|
/// </summary>
|
Open,
|
/// <summary>
|
/// Indicates that a testplan is starting to execute.
|
/// </summary>
|
/// <remarks>Implies that the testplan already is open.</remarks>
|
Execute,
|
|
/// <summary>
|
/// Indicates that a teststep is about to run it's PrePlanRun.
|
/// </summary>
|
PrePlanRun,
|
/// <summary>
|
/// Indicates that a teststep is about to be run.
|
/// </summary>
|
Run,
|
/// <summary>
|
/// Indicates that a teststep is about to run it's PostPlanRun.
|
/// </summary>
|
PostPlanRun,
|
}
|
|
/// <summary>
|
/// A resource manager implements this interface to be able to control how resources are opened and closed during a testplan execution.
|
/// </summary>
|
public interface IResourceManager : ITapPlugin
|
{
|
/// <summary>
|
/// This event is triggered when a resource is opened. The event may block in which case the resource will remain open for the entire call.
|
/// </summary>
|
event Action<IResource> ResourceOpened;
|
|
/// <summary>
|
/// Get a snapshot of all currently opened resources.
|
/// </summary>
|
IEnumerable<IResource> Resources { get; }
|
|
/// <summary>
|
/// Sets the resources that should always be opened when the testplan is.
|
/// </summary>
|
IEnumerable<IResource> StaticResources { get; set; }
|
/// <summary>
|
/// This property should be set to all teststeps that are enabled to be run.
|
/// </summary>
|
List<ITestStep> EnabledSteps { get; set; }
|
|
/// <summary>
|
/// Waits for all the resources that have been signalled to open to be opened.
|
/// </summary>
|
/// <param name="cancellationToken">Used to cancel the wait early.</param>
|
void WaitUntilAllResourcesOpened(CancellationToken cancellationToken);
|
|
/// <summary>
|
/// Waits for the specific resources to be open.
|
/// </summary>
|
/// <param name="cancellationToken">Used to cancel the wait early.</param>
|
/// <param name="targets"></param>
|
void WaitUntilResourcesOpened(CancellationToken cancellationToken, params IResource[] targets);
|
|
/// <summary>
|
/// Signals that an action is beginning.
|
/// </summary>
|
/// <param name="planRun">The planrun for the currently executing testplan.</param>
|
/// <param name="item">The item affected by the current action. This can be either a testplan or a teststep.</param>
|
/// <param name="stage">The stage that is beginning.</param>
|
/// <param name="cancellationToken">Used to cancel the step early.</param>
|
void BeginStep(TestPlanRun planRun, ITestStepParent item, TestPlanExecutionStage stage, CancellationToken cancellationToken);
|
|
/// <summary>
|
/// Signals that an action has completed.
|
/// </summary>
|
/// <param name="item">The item affected by the current action. This can be either a testplan or a teststep.</param>
|
/// <param name="stage">The stage that was just completed.</param>
|
void EndStep(ITestStepParent item, TestPlanExecutionStage stage);
|
}
|
|
/// <summary>
|
/// Utility functions shared by <see cref="ResourceTaskManager"/> and <see cref="LazyResourceManager"/>.
|
/// </summary>
|
internal static class ResourceManagerUtils
|
{
|
struct EnumerableKey
|
{
|
readonly int key;
|
readonly object[] items;
|
public EnumerableKey(object[] items)
|
{
|
this.items = items;
|
key = 3275321;
|
foreach (var item in items)
|
key = ((item?.GetHashCode() ?? 0) + key) * 3275321;
|
}
|
|
public override int GetHashCode() => key;
|
public override bool Equals(object obj)
|
{
|
if (obj is EnumerableKey other)
|
return other.key == key && other.items.SequenceEqual(items);
|
return false;
|
}
|
}
|
|
static List<ResourceNode> GetResourceNodesNoCache(object[] source)
|
{
|
var resources = new ResourceDependencyAnalyzer().GetAllResources(source, out bool analysisError);
|
if (analysisError)
|
{
|
throw new OperationCanceledException("Error while analyzing dependencies between resources.");
|
}
|
return resources;
|
}
|
|
class ResourceNodeCache : ICacheOptimizer
|
{
|
public static readonly ThreadField<Dictionary<EnumerableKey, List<ResourceNode>>> Cache = new ThreadField<Dictionary<EnumerableKey, List<ResourceNode>>>();
|
public void LoadCache() => Cache.Value = new Dictionary<EnumerableKey, List<ResourceNode>>();
|
|
public void UnloadCache() => Cache.Value = null;
|
}
|
|
/// <summary>
|
/// Gets ResourceNodes for all resources. This includes the ones from <see cref="IResourceManager.EnabledSteps"/> and <see cref="IResourceManager.StaticResources"/>.
|
/// </summary>
|
public static List<ResourceNode> GetResourceNodes(IEnumerable<object> _source)
|
{
|
var source = _source.ToArray();
|
var cache = ResourceNodeCache.Cache.Value;
|
if (cache != null)
|
{
|
var key = new EnumerableKey(source);
|
lock (cache)
|
{
|
|
if (cache.TryGetValue(key, out List<ResourceNode> result))
|
return result;
|
result = GetResourceNodesNoCache(source);
|
cache[key] = result;
|
return result;
|
}
|
}
|
|
return GetResourceNodesNoCache(source);
|
}
|
}
|
|
/// <summary>
|
/// Manages the asynchronous opening and closing of <see cref="Resource"/>s in separate threads.
|
/// Resources are opened and closed in order depending on dependencies between them.
|
/// </summary>
|
[Display("Default", Order: 0)]
|
internal class ResourceTaskManager : IResourceManager
|
{
|
/// <summary> Prints a friendly name. </summary>
|
public override string ToString() => "Default Resource Manager";
|
|
static readonly TraceSource log = Log.CreateSource("Resources");
|
|
readonly List<ResourceNode> openedResources = new();
|
readonly LockManager lockManager = new();
|
|
// open tasks is the main work of opening a resource.
|
readonly ConcurrentDictionary<IResource, Task> openTasks = new();
|
|
// finally tasks are for notifying that resources has been opened.
|
readonly ConcurrentDictionary<IResource, Task> finallyTasks = new();
|
|
/// <summary>
|
/// This event is triggered when a resource is opened. The event may block in which case the resource will remain open for the entire call.
|
/// </summary>
|
public event Action<IResource> ResourceOpened;
|
|
internal static TraceSource GetLogSource(IResource res)
|
{
|
return Log.GetOwnedSource(res) ?? Log.CreateSource(res.Name ?? "Resource");
|
}
|
|
void OpenResource(ResourceNode node, WaitHandle canStart)
|
{
|
canStart.WaitOne();
|
var taskArray = node.StrongDependencies.Select(dep => openTasks[dep]).ToArray();
|
Task.WaitAll(taskArray);
|
|
var sw = Stopwatch.StartNew();
|
|
var resourceLog = GetLogSource(node.Resource);
|
|
try
|
{
|
ResourcePreOpenEvent.Invoke(node.Resource);
|
|
node.Resource.Open();
|
|
resourceLog.Info(sw, "Resource \"{0}\" opened.", node.Resource);
|
|
// when there are no weak dependencies just invoke ResourceOpened directly.
|
if (node.WeakDependencies.Count <= 0)
|
{
|
ResourceOpened?.Invoke(node.Resource);
|
return;
|
}
|
|
// ...otherwise, we cannot wait for weak dependencies as part of the 'OpenResource' work.
|
// Doing that will cause a dead-lock with circular resource references.
|
// ResourceOpened should only be invoked after weak dependencies has been opened mostly for legacy reasons.
|
// So we wait for weak deps and call ReosurceOpened in a new worker thread.
|
|
var weakDeps = node.WeakDependencies.Select(dep => openTasks[dep]).ToArray();
|
|
finallyTasks[node.Resource] = TapThread.StartAwaitable(() =>
|
{
|
try
|
{
|
Task.WaitAll(weakDeps);
|
ResourceOpened?.Invoke(node.Resource);
|
}
|
catch (Exception ex)
|
{
|
string msg = $"Error while opening resource \"{node.Resource}\"";
|
throw new ExceptionCustomStackTrace(msg, null, ex);
|
}
|
});
|
|
}
|
catch (Exception ex)
|
{
|
string msg = $"Error while opening resource \"{node.Resource}\"";
|
throw new ExceptionCustomStackTrace(msg, null, ex);
|
}
|
}
|
|
/// <summary> Waits for a specific resource to be open. </summary>
|
/// <param name="cancellationToken">Used to cancel the wait early.</param>
|
/// <param name="targets">The resources that we wait to be opened.</param>
|
public void WaitUntilResourcesOpened(CancellationToken cancellationToken, params IResource[] targets)
|
{
|
try
|
{
|
// successfully completed tasks are not worth waiting for.
|
// waiting for unsuccessfully completed tasks gives us a useful error.
|
|
var waitFor = targets.Select(target => openTasks[target])
|
.Where(task => !task.IsCompleted || task.IsFaulted).ToArray();
|
if (waitFor.Length > 0)
|
{
|
// WaitAll waits until all finish even if an exception occurs in one task.
|
Task.WaitAll(waitFor, cancellationToken);
|
}
|
|
var waitForFinallyTasks = targets
|
.Where(finallyTasks.ContainsKey)
|
.Select(target => finallyTasks[target])
|
.Where(task => !task.IsCompleted || task.IsFaulted).ToArray();
|
if(waitForFinallyTasks.Length > 0)
|
Task.WaitAll(waitForFinallyTasks, cancellationToken);
|
}
|
catch (OperationCanceledException)
|
{
|
}
|
catch (Exception e)
|
{
|
e.RethrowInner();
|
}
|
}
|
|
/// <summary>
|
/// Waits for all the resources to be opened.
|
/// </summary>
|
/// <param name="cancellationToken">Used to cancel the wait early</param>
|
public void WaitUntilAllResourcesOpened(CancellationToken cancellationToken)
|
{
|
WaitUntilResourcesOpened(cancellationToken, openTasks.Keys.ToArray());
|
}
|
|
/// <summary>
|
/// Get a snapshot of all currently opened resources.
|
/// </summary>
|
public IEnumerable<IResource> Resources => openTasks.Keys;
|
|
/// <summary>
|
/// Sets the resources that should always be opened when the test plan is.
|
/// </summary>
|
public IEnumerable<IResource> StaticResources { get; set; }
|
/// <summary>
|
/// This property should be set to all test steps that are enabled to be run.
|
/// </summary>
|
public List<ITestStep> EnabledSteps { get; set; }
|
|
/// <summary>
|
/// Blocks the thread while closing all resources in parallel.
|
/// </summary>
|
void CloseAllResources()
|
{
|
Dictionary<IResource, List<IResource>> dependencies =
|
openedResources.ToDictionary(r => r.Resource,
|
r => new List<IResource>()); // this dictionary will hold resources with dependencies (keys) and what resources depend on them (values)
|
foreach (var n in openedResources)
|
foreach (var dep in n.StrongDependencies)
|
dependencies[dep].Add(n.Resource);
|
|
Dictionary<IResource, Task> closeTasks = new Dictionary<IResource, Task>();
|
|
foreach (var r in openedResources)
|
closeTasks[r.Resource] = new Task(o =>
|
{
|
ResourceNode res = (ResourceNode) o;
|
|
// Wait for the resource to open to open before closing it.
|
// in rare cases, another instrument failing open will cause close to be called.
|
try
|
{
|
openTasks[res.Resource].Wait();
|
}
|
catch
|
{
|
|
}
|
|
// wait for resources that depend on this resource (res) to close before closing this
|
Task.WaitAll(dependencies[res.Resource].Select(x => closeTasks[x]).ToArray());
|
var resourceLog = GetLogSource(res.Resource);
|
Stopwatch timer = Stopwatch.StartNew();
|
try
|
{
|
res.Resource.Close();
|
}
|
catch (Exception e)
|
{
|
|
log.Error("Error while closing \"{0}\": {1}", res.Resource.Name, e.Message);
|
log.Debug(e);
|
|
}
|
|
if (resourceLog != null)
|
resourceLog.Info(timer, "Resource \"{0}\" closed.", res.Resource);
|
}, r);
|
|
var closeTaskArray = closeTasks.Values.ToArray();
|
closeTaskArray.ForEach(t => t.Start());
|
|
void complainAboutWait()
|
{
|
log.Debug("Waiting for resources to close:");
|
foreach (var res in openTasks.Keys)
|
{
|
if (res.IsConnected)
|
log.Debug(" - {0}", res);
|
}
|
}
|
|
using (TimeoutOperation.Create(complainAboutWait))
|
{
|
Task.WaitAll(closeTaskArray);
|
}
|
}
|
|
void BeginOpenResources(List<ResourceNode> resources, CancellationToken cancellationToken)
|
{
|
lockManager.BeforeOpen(resources, cancellationToken);
|
|
{
|
// check if any resources that has been deleted from InstrumentSettings or DutSettings
|
// are still being referred to.
|
var untouched = new IComponentSettingsList[]{InstrumentSettings.Current,
|
DutSettings.Current, ResultSettings.Current}
|
.SelectMany(x => x.GetRemovedAliveResources())
|
.ToHashSet();
|
foreach (var res in resources)
|
{
|
if (untouched.Contains(res.Resource))
|
{
|
if(res.Depender != null)
|
throw new Exception($"Deleted resource '{res.Resource}' is in use by {res.Depender.DeclaringType}.");
|
throw new Exception($"Deleted resource '{res.Resource}' is in use.");
|
}
|
}
|
}
|
|
// Check null resources
|
if (resources.Any(res => res.Resource == null))
|
{
|
EnabledSteps.ForEach(step => step.CheckResources());
|
|
// Now check resources since we know one of them should have a null resource
|
resources.ForEach(res =>
|
{
|
if (res.StrongDependencies.Contains(null) || res.WeakDependencies.Contains(null))
|
throw new Exception(String.Format("Resource property not set on resource {0}. Please configure resource.", res.Resource));
|
});
|
}
|
else
|
{
|
// Open all resources asynchronously
|
var wait = new ManualResetEventSlim(false);
|
foreach (ResourceNode r in resources)
|
{
|
if (openTasks.ContainsKey(r.Resource)) continue;
|
|
openedResources.Add(r);
|
|
// async used to avoid blocking the thread while waiting for tasks.
|
openTasks[r.Resource] = TapThread.StartAwaitable(() => OpenResource(r, wait.WaitHandle));
|
}
|
wait.Set();
|
}
|
}
|
|
/// <summary>
|
/// Signals that an action is beginning.
|
/// </summary>
|
/// <param name="planRun">The planrun for the currently executing testplan.</param>
|
/// <param name="item">The item affected by the current action. This can be either a testplan or a teststep.</param>
|
/// <param name="stage">The stage that is beginning.</param>
|
/// <param name="cancellationToken">Used to cancel the step early.</param>
|
public void BeginStep(TestPlanRun planRun, ITestStepParent item, TestPlanExecutionStage stage, CancellationToken cancellationToken)
|
{
|
switch (stage)
|
{
|
case TestPlanExecutionStage.Execute:
|
if (item is TestPlan testPlan)
|
{
|
var resources = ResourceManagerUtils.GetResourceNodes(StaticResources.Cast<object>().Concat(EnabledSteps));
|
|
// Proceed to open resources in case they have been changed or closed since last opening/executing the testplan.
|
// In case any are null, we need to do this before the resource prompt to allow a ILockManager implementation to
|
// set the resource first.
|
if (resources.Any(r => r.Resource == null))
|
BeginOpenResources(resources, cancellationToken);
|
|
testPlan.StartResourcePromptAsync(planRun, resources.Select(res => res.Resource));
|
|
if (resources.Any(r => openTasks.ContainsKey(r.Resource) == false))
|
BeginOpenResources(resources, cancellationToken);
|
}
|
break;
|
case TestPlanExecutionStage.Open:
|
if (item is TestPlan)
|
{
|
var resources = ResourceManagerUtils.GetResourceNodes(StaticResources.Cast<object>().Concat(EnabledSteps));
|
BeginOpenResources(resources, cancellationToken);
|
}
|
break;
|
case TestPlanExecutionStage.Run:
|
case TestPlanExecutionStage.PrePlanRun:
|
{
|
bool openCompletedWithSuccess = openTasks.Values.All(x => x.Status == TaskStatus.RanToCompletion);
|
if (!openCompletedWithSuccess)
|
{ // open did not complete or threw an exception.
|
|
using (TimeoutOperation.Create(() => TestPlan.PrintWaitingMessage(Resources)))
|
WaitUntilAllResourcesOpened(cancellationToken);
|
}
|
break;
|
}
|
case TestPlanExecutionStage.PostPlanRun: break;
|
}
|
}
|
|
/// <summary>
|
/// Signals that an action has completed.
|
/// </summary>
|
/// <param name="item">The item affected by the current action. This can be either a testplan or a teststep.</param>
|
/// <param name="stage">The stage that was just completed.</param>
|
public void EndStep(ITestStepParent item, TestPlanExecutionStage stage)
|
{
|
switch (stage)
|
{
|
case TestPlanExecutionStage.Open:
|
if (item is TestPlan)
|
{
|
try
|
{
|
CloseAllResources();
|
}
|
finally
|
{
|
lockManager.AfterClose(openedResources, CancellationToken.None);
|
}
|
}
|
break;
|
}
|
}
|
}
|
|
|
/// <summary>
|
/// Opens resources in a lazy way only before teststeps or global plan resources actually need them.
|
/// </summary>
|
[Display("Short Lived Connections", "Opens resources only right before they are needed (e.g. before an individual test step starts). And closes them again immediately after.", Order: 1)]
|
internal class LazyResourceManager : IResourceManager
|
{
|
/// <summary> Prints a friendly name. </summary>
|
/// <returns></returns>
|
public override string ToString() => "Short Lived Connections";
|
|
/// <summary> Manages the state for a single resource. For example an Instrument or Result Listener. </summary>
|
class ResourceInfo
|
{
|
enum ResourceState
|
{
|
Reset,
|
Opening,
|
Open,
|
Closing
|
}
|
|
ResourceState state { get; set; } = ResourceState.Reset;
|
|
// counts up on open and down on close. When it reaches 0, it can finally be closed.
|
int referenceCount;
|
|
// lock used for managing local state. For example reference count.
|
readonly object lockObj = new object();
|
|
Task openTask = Task.CompletedTask;
|
Task closeTask = Task.CompletedTask;
|
|
public ResourceNode ResourceNode { get; }
|
|
public ResourceInfo(ResourceNode resourceNode)
|
{
|
ResourceNode = resourceNode;
|
}
|
|
public Task RequestSteady()
|
{
|
lock (lockObj)
|
switch(state)
|
{
|
case ResourceState.Opening:
|
return openTask;
|
default:
|
return Task.CompletedTask;
|
}
|
}
|
|
public bool ShouldBeOpen()
|
{
|
lock (lockObj)
|
return referenceCount > 0;
|
}
|
|
void OpenResource(LazyResourceManager requester, CancellationToken cancellationToken)
|
{
|
var node = ResourceNode;
|
foreach (var dep in node.StrongDependencies)
|
{
|
if (dep == null) continue;
|
requester.RequestResourceOpen(dep, cancellationToken).Wait(cancellationToken);
|
}
|
|
var sw = Stopwatch.StartNew();
|
|
var resourceLog = ResourceTaskManager.GetLogSource(node.Resource);
|
|
try
|
{
|
try
|
{
|
ResourcePreOpenEvent.Invoke(node.Resource);
|
|
node.Resource.Open();
|
resourceLog.Info(sw, "Resource \"{0}\" opened.", node.Resource);
|
}
|
finally
|
{
|
lock (lockObj)
|
if (state == ResourceState.Opening)
|
state = ResourceState.Open;
|
}
|
|
foreach (var dep in node.WeakDependencies)
|
{
|
if (dep == null) continue;
|
requester.RequestResourceOpen(dep, cancellationToken).Wait(cancellationToken);
|
}
|
}
|
catch (Exception ex)
|
{
|
string msg = $"Error while opening resource \"{node.Resource}\"";
|
throw new ExceptionCustomStackTrace(msg, null, ex);
|
}
|
requester.ResourceOpenedCallback(node.Resource);
|
}
|
|
public Task RequestOpen(LazyResourceManager requester, CancellationToken cancellationToken)
|
{
|
lock (lockObj)
|
{
|
referenceCount++;
|
|
switch (state)
|
{
|
case ResourceState.Reset:
|
state = ResourceState.Opening;
|
|
return openTask =
|
TapThread.StartAwaitable(() => OpenResource(requester, cancellationToken));
|
case ResourceState.Opening:
|
return openTask;
|
case ResourceState.Open:
|
return Task.CompletedTask;
|
case ResourceState.Closing:
|
return closeTask.ContinueWith(t => RequestOpen(requester, cancellationToken).Wait());
|
}
|
|
return Task.CompletedTask;
|
}
|
}
|
|
public Task RequestClose(LazyResourceManager requester)
|
{
|
lock (lockObj)
|
{
|
referenceCount--;
|
|
if (referenceCount == 0)
|
switch (state)
|
{
|
case ResourceState.Reset:
|
case ResourceState.Closing:
|
throw new Exception("Should never happen");
|
case ResourceState.Opening:
|
case ResourceState.Open:
|
{
|
state = ResourceState.Closing;
|
|
return closeTask = TapThread.StartAwaitable(() =>
|
{
|
try
|
{
|
// wait for the resource to open before close.
|
requester.resources[ResourceNode.Resource].openTask?.Wait();
|
}
|
catch
|
{
|
|
}
|
|
Task.WaitAll(ResourceNode.WeakDependencies.Select(requester.RequestResourceClose).ToArray());
|
var reslog = ResourceTaskManager.GetLogSource(ResourceNode.Resource);
|
Stopwatch timer = Stopwatch.StartNew();
|
try
|
{
|
ResourceNode.Resource.Close();
|
}
|
catch (Exception e)
|
{
|
reslog.Error("Error while closing \"{0}\": {1}", ResourceNode.Resource.Name, e.Message);
|
reslog.Debug(e);
|
}
|
reslog.Info(timer, "Resource \"{0}\" closed.", ResourceNode.Resource);
|
|
Task.WaitAll(ResourceNode.StrongDependencies.Select(requester.RequestResourceClose).ToArray());
|
|
state = ResourceState.Reset;
|
});
|
}
|
}
|
|
return Task.CompletedTask;
|
}
|
}
|
}
|
|
readonly object resourceLock = new object();
|
readonly Dictionary<IResource, ResourceInfo> resources = new Dictionary<IResource, ResourceInfo>();
|
readonly Dictionary<ITestStep, List<IResource>> resourceDependencies = new Dictionary<ITestStep, List<IResource>>();
|
readonly List<ResourceNode> resourceWithBeforeOpenCalled = new List<ResourceNode>();
|
readonly LockManager lockManager = new LockManager();
|
|
void OpenResources(List<ResourceNode> toOpen, CancellationToken cancellationToken)
|
{
|
toOpen.RemoveAll(x => x.Resource == null);
|
|
lock (resourceLock)
|
foreach (var extra in toOpen)
|
if (!resources.ContainsKey(extra.Resource))
|
resources[extra.Resource] = new ResourceInfo(extra);
|
|
try
|
{
|
Task.WaitAll(toOpen.Select(res => RequestResourceOpen(res.Resource, cancellationToken)).ToArray(), cancellationToken);
|
}
|
catch(OperationCanceledException)
|
{
|
|
}
|
}
|
|
void CloseResources(IEnumerable<IResource> toClose)
|
{
|
if (toClose.Any())
|
{
|
Task.WaitAll(toClose.Select(RequestResourceClose).ToArray());
|
lock (resourceWithBeforeOpenCalled)
|
{
|
var nodes = resourceWithBeforeOpenCalled.Where(rn => toClose.Contains(rn.Resource)).ToArray();
|
lockManager.AfterClose(nodes, CancellationToken.None);
|
foreach (var node in nodes)
|
resourceWithBeforeOpenCalled.Remove(node);
|
}
|
}
|
}
|
|
/// <summary>
|
/// This property should be set to all test steps that are enabled to be run.
|
/// </summary>
|
public List<ITestStep> EnabledSteps { get; set; }
|
|
/// <summary>
|
/// This event is triggered when a resource is opened. The event may block in which case the resource will remain open for the entire call.
|
/// </summary>
|
public event Action<IResource> ResourceOpened;
|
|
/// <summary>
|
/// Get a snapshot of all currently opened resources.
|
/// </summary>
|
public IEnumerable<IResource> Resources
|
{
|
get
|
{
|
lock (resourceLock)
|
return resources.Where(x => x.Value.ShouldBeOpen()).Select(x => x.Key).ToList();
|
}
|
}
|
|
/// <summary>
|
/// Sets the resources that should always be opened when the testplan is.
|
/// </summary>
|
public IEnumerable<IResource> StaticResources { get; set; }
|
|
/// <summary>
|
/// Signals that an action is beginning.
|
/// </summary>
|
/// <param name="planRun">The planrun for the currently executing testplan.</param>
|
/// <param name="item">The item affected by the current action. This can be either a testplan or a teststep.</param>
|
/// <param name="stage">The stage that is beginning.</param>
|
/// <param name="cancellationToken">Used to cancel the step early.</param>
|
public void BeginStep(TestPlanRun planRun, ITestStepParent item, TestPlanExecutionStage stage, CancellationToken cancellationToken)
|
{
|
switch (stage)
|
{
|
case TestPlanExecutionStage.Open:
|
case TestPlanExecutionStage.Execute:
|
{
|
var resources = ResourceManagerUtils.GetResourceNodes(StaticResources);
|
|
if (item is TestPlan plan && stage == TestPlanExecutionStage.Execute)
|
{
|
// Prompt for metadata for all resources, not only static ones.
|
var testPlanResources = ResourceManagerUtils.GetResourceNodes(EnabledSteps);
|
plan.StartResourcePromptAsync(planRun, resources.Concat(testPlanResources).Select(res => res.Resource));
|
}
|
|
if (resources.All(r => r.Resource?.IsConnected ?? false))
|
return;
|
|
// Call ILockManagers before checking for null
|
try
|
{
|
lockManager.BeforeOpen(resources, cancellationToken);
|
}
|
finally
|
{
|
lock (resourceWithBeforeOpenCalled)
|
{
|
resourceWithBeforeOpenCalled.AddRange(resources);
|
}
|
}
|
|
try
|
{
|
// Check null resources
|
if (resources.Any(res => res.Resource == null))
|
{
|
// Now check resources since we know one of them should have a null resource
|
resources.ForEach(res =>
|
{
|
if (res.StrongDependencies.Contains(null) || res.WeakDependencies.Contains(null))
|
throw new Exception(String.Format("Resource property not set on resource {0}. Please configure resource.", res.Resource));
|
});
|
}
|
}
|
finally
|
{
|
OpenResources(resources, cancellationToken);
|
}
|
break;
|
}
|
|
case TestPlanExecutionStage.Run:
|
if (item is ITestStep step)
|
{
|
var resources = ResourceManagerUtils.GetResourceNodes(new List<object> { step });
|
if (resources.Any())
|
{
|
// Call ILockManagers before checking for null
|
try
|
{
|
lockManager.BeforeOpen(resources, cancellationToken);
|
}
|
finally
|
{
|
lock (resourceWithBeforeOpenCalled)
|
{
|
resourceWithBeforeOpenCalled.AddRange(resources);
|
}
|
}
|
|
try
|
{
|
// Check null resources
|
if (resources.Any(res => res.Resource == null))
|
{
|
step.CheckResources();
|
|
// Now check resources since we know one of them should have a null resource
|
resources.ForEach(res =>
|
{
|
if (res.StrongDependencies.Contains(null) || res.WeakDependencies.Contains(null))
|
throw new Exception(String.Format("Resource property not set on resource {0}. Please configure resource.", res.Resource));
|
});
|
}
|
}
|
finally
|
{
|
lock (resourceLock)
|
{
|
resourceDependencies[step] = resources.Select(x => x.Resource).ToList();
|
}
|
|
OpenResources(resources, cancellationToken);
|
}
|
WaitHandle.WaitAny(new[] { planRun.PromptWaitHandle, planRun.MainThread.AbortToken.WaitHandle });
|
}
|
}
|
break;
|
}
|
}
|
|
/// <summary>
|
/// Signals that an action has completed.
|
/// </summary>
|
/// <param name="item">The item affected by the current action. This can be either a testplan or a teststep.</param>
|
/// <param name="stage">The stage that was just completed.</param>
|
public void EndStep(ITestStepParent item, TestPlanExecutionStage stage)
|
{
|
switch (stage)
|
{
|
case TestPlanExecutionStage.Open:
|
case TestPlanExecutionStage.Execute:
|
lock (resourceLock)
|
CloseResources(Resources);
|
break;
|
|
case TestPlanExecutionStage.Run:
|
if (item is ITestStep step)
|
{
|
if (resourceDependencies.TryGetValue(step, out List<IResource> usedResourcesRaw))
|
{
|
var usedResources = usedResourcesRaw.Where(r => r is IResource).ToArray();
|
lock (resourceLock)
|
{
|
resourceDependencies.Remove(step);
|
}
|
|
CloseResources(usedResources);
|
}
|
}
|
break;
|
}
|
}
|
|
private void WaitFor(CancellationToken cancellationToken, IEnumerable<IResource> targets)
|
{
|
try
|
{
|
Task[] steadyTasks;
|
lock(resourceLock)
|
steadyTasks = targets.Select(x => resources[x].RequestSteady()).ToArray();
|
|
Task.WaitAll(steadyTasks, cancellationToken);
|
}
|
catch (OperationCanceledException)
|
{
|
// Just exit since the abort exception will be handled elsewhere.
|
}
|
catch (KeyNotFoundException)
|
{
|
foreach (var target in targets)
|
{
|
if (resources.ContainsKey(target) == false)
|
{
|
throw new ArgumentException($"Resource '{target}' is not used in the test plan.", "targets");
|
}
|
}
|
throw;
|
}
|
}
|
|
/// <summary>
|
/// Waits for all the resources that have been signalled to open to be opened.
|
/// </summary>
|
/// <param name="cancellationToken">Used to cancel the wait early.</param>
|
public void WaitUntilAllResourcesOpened(CancellationToken cancellationToken)
|
{
|
WaitFor(cancellationToken, Resources);
|
}
|
|
/// <summary>
|
/// Waits for the specific resources to be open.
|
/// </summary>
|
/// <param name="cancellationToken">Used to cancel the wait early.</param>
|
/// <param name="targets"></param>
|
public void WaitUntilResourcesOpened(CancellationToken cancellationToken, params IResource[] targets)
|
{
|
WaitFor(cancellationToken, targets);
|
}
|
|
Task RequestResourceOpen(IResource resource, CancellationToken cancellationToken)
|
{
|
lock (resourceLock)
|
return resources[resource].RequestOpen(this, cancellationToken);
|
}
|
|
Task RequestResourceClose(IResource resource)
|
{
|
lock (resourceLock)
|
return resources[resource].RequestClose(this);
|
}
|
|
void ResourceOpenedCallback(IResource resource)
|
{
|
ResourceOpened?.Invoke(resource);
|
}
|
}
|
}
|
