public Test(ComputeType computingType, PortDescription.Category traversalCategory)
{
Cache = new Topology.TraversalCache(0, (uint)traversalCategory);
Nodes = new NativeList <NodeHandle <TNodeType> >(10, Allocator.Temp);
Set = new NodeSet();
m_Options = Topology.CacheAPI.ComputationOptions.Create(computeJobified: computingType == ComputeType.Jobified);
}
private void CallInternalComputeTypes(ComputeType type, object dep)
{
try
{
switch (type)
{
case ComputeType.IaaS:
ExecuteAllActionsForIaaS((ARMDeployment)dep);
break;
case ComputeType.VMSS:
ExecuteAllActionsForVMSS((ARMDeployment)dep);
break;
case ComputeType.PaaS:
ExecuteAllActionsForPaaS((RDFEDeployment)dep);
break;
default:
break;
}
}
catch (Exception ex)
{
Log.Error("Failed to run Compute type {0}.", type);
Log.Exception(ex);
}
}
public Test(ComputeType computingType)
{
Cache = new Topology.TraversalCache(0, Topology.TraversalCache.TraverseAllMask);
Nodes = new NativeList <NodeHandle <TNodeType> >(10, Allocator.Temp);
Set = new NodeSet();
m_Options = Topology.CacheAPI.ComputationOptions.Create(computeJobified: computingType == ComputeType.Jobified);
}
internal AksComputeSecrets(ComputeType computeType, string userKubeConfig, string adminKubeConfig, string imagePullSecretName) : base(computeType)
{
UserKubeConfig = userKubeConfig;
AdminKubeConfig = adminKubeConfig;
ImagePullSecretName = imagePullSecretName;
ComputeType = computeType;
}
internal ComputeTypeGetResponse(
CoreRegistrationModel.ComputeTypeGetResponse internalResponse,
DataFactoryManagementClient client)
: this()
{
DataFactoryOperationUtilities.CopyRuntimeProperties(internalResponse, this);
this.ComputeType = ((ComputeTypeOperations)client.ComputeTypes).Converter.ToWrapperType(internalResponse.ComputeType);
}
public Test(Topology.SortingAlgorithm algo, ComputeType computingType, uint traversalMask, uint alternateMask)
{
Cache = new Topology.TraversalCache(0, traversalMask, alternateMask);
Nodes = new NativeList <Node>(10, Allocator.Temp);
TestDatabase = new TopologyTestDatabase(Allocator.Temp);
m_Options = Topology.CacheAPI.ComputationOptions.Create(computeJobified: computingType == ComputeType.Jobified);
Version = Topology.CacheAPI.VersionTracker.Create();
m_Algorithm = algo;
}
public void ChangeUpdateMethodWithClear(UpdateMethodType type, bool needsImmediately = false)
{
ChangeUpdateMethod(type);
ClearMatrices();
DisableAllParticles();
ComputeType computeType = needsImmediately ? ComputeType.SetupImmediately : ComputeType.Setup;
UpdateAllBuffers(computeType);
Dispatch(computeType);
}
public void TestInternalIndices([Values] Topology.SortingAlgorithm algo, [Values] ComputeType jobified)
{
using (var test = new Test(algo, jobified))
{
var node1 = test.TestDatabase.CreateNode();
var node2 = test.TestDatabase.CreateNode();
var node3 = test.TestDatabase.CreateNode();
test.Nodes.Add(node1);
test.Nodes.Add(node2);
test.Nodes.Add(node3);
Assert.DoesNotThrow(() => test.TestDatabase.Connect(node2, k_OutputOne, node1, k_InputOne));
Assert.DoesNotThrow(() => test.TestDatabase.Connect(node3, k_OutputOne, node1, k_InputThree));
var entryIndex = 0;
foreach (var node in test.GetWalker())
{
if (entryIndex == 0 || entryIndex == 1)
{
Assert.AreEqual(0, node.GetParents().Count);
}
else
{
Assert.AreEqual(2, node.GetParents().Count);
foreach (var parent in node.GetParents())
{
Assert.IsTrue(parent.Vertex == node2 || parent.Vertex == node3);
}
}
if (entryIndex == 0 || entryIndex == 1)
{
Assert.AreEqual(1, node.GetChildren().Count);
foreach (var child in node.GetChildren())
{
Assert.AreEqual(node1, child.Vertex);
}
}
else
{
Assert.AreEqual(0, node.GetChildren().Count);
}
entryIndex++;
}
}
}
private void TestComputeTypeJson(JsonSampleInfo sampleInfo)
{
string json = sampleInfo.Json;
ComputeType computeType = this.ConvertToWrapper(json);
CoreRegistrationModel.ComputeType actual = this.Operations.Converter.ToCoreType(computeType);
string actualJson = Core.DataFactoryManagementClient.SerializeInternalComputeTypeToJson(actual);
JsonComparer.ValidateAreSame(json, actualJson, ignoreDefaultValues: true);
Assert.False(actualJson.Contains("ServiceExtraProperties"));
JObject actualJObject = JObject.Parse(actualJson);
JsonComparer.ValidatePropertyNameCasing(actualJObject, true, string.Empty, sampleInfo.PropertyBagKeys);
}
private int GetKernelID(ComputeType type)
{
switch (type)
{
case ComputeType.Setup:
return(_kernelSetupParticles);
case ComputeType.SetupImmediately:
return(_kernelSetupParticlesImmediately);
case ComputeType.DisableAll:
return(_kernelDisable);
}
return(-1);
}
/// <summary>
/// Initializes a new instance of the
/// ComputeTypeCreateOrUpdateParameters class with required
/// arguments.
/// </summary>
public ComputeTypeCreateOrUpdateParameters(ComputeType computeType)
: this()
{
Ensure.IsNotNull(computeType, "computeType");
this.ComputeType = computeType;
}
public Test(Topology.SortingAlgorithm algo, ComputeType computingType, uint traversalMask)
: this(algo, computingType, traversalMask, traversalMask)
{
}
internal DatabricksComputeSecrets(ComputeType computeType, string databricksAccessToken) : base(computeType)
{
DatabricksAccessToken = databricksAccessToken;
ComputeType = computeType;
}
public Compute(string formula)
{
if (string.IsNullOrEmpty(formula))
{
return;
}
myFormula = formula;
// 检测当前节点的计算类型
if (formula.Contains("-"))
{
computeType = ComputeType.Sub;
}
else if (formula.Contains("+"))
{
computeType = ComputeType.Plus;
}
else if (formula.Contains("/"))
{
computeType = ComputeType.Div;
}
else if (formula.Contains("*"))
{
computeType = ComputeType.Mult;
}
else
{
return;
}
char sign = '\0';
switch (computeType)
{
// 乘
case ComputeType.Mult:
sign = '*';
break;
// 除
case ComputeType.Div:
sign = '/';
break;
// 加
case ComputeType.Plus:
sign = '+';
break;
// 减
case ComputeType.Sub:
sign = '-';
break;
}
var array = formula.Split(sign);
foreach (var item in array)
{
AddCompute(new Compute(item));
}
}
public void RootAndLeafCacheWalker_WalksRootsAndLeaves([Values] Topology.SortingAlgorithm algo, [Values] ComputeType jobified)
{
using (var test = new Test(algo, jobified))
{
for (int i = 0; i < 5; ++i)
{
test.Nodes.Add(test.TestDatabase.CreateNode());
}
test.TestDatabase.Connect(test.Nodes[0], k_OutputOne, test.Nodes[2], k_InputOne);
test.TestDatabase.Connect(test.Nodes[1], k_OutputOne, test.Nodes[2], k_InputTwo);
test.TestDatabase.Connect(test.Nodes[2], k_OutputOne, test.Nodes[3], k_InputOne);
test.TestDatabase.Connect(test.Nodes[2], k_OutputTwo, test.Nodes[4], k_InputOne);
var cache = test.GetUpdatedCache();
Assert.AreEqual(cache.Leaves.Length, 2);
Assert.AreEqual(cache.Roots.Length, 2);
var roots = new List <Node>();
for (int i = 0; i < cache.Leaves.Length; ++i)
{
roots.Add(cache.OrderedTraversal[cache.Roots[i]].Vertex);
}
var leaves = new List <Node>();
for (int i = 0; i < cache.Roots.Length; ++i)
{
leaves.Add(cache.OrderedTraversal[cache.Leaves[i]].Vertex);
}
CollectionAssert.Contains(leaves, test.Nodes[0]);
CollectionAssert.Contains(leaves, test.Nodes[1]);
CollectionAssert.Contains(roots, test.Nodes[3]);
CollectionAssert.Contains(roots, test.Nodes[4]);
}
}
public void TraversalCache_DoesNotInclude_IgnoredTraversalTypes([Values] Topology.SortingAlgorithm algo, [Values] ComputeType computeType, [Values] TraversalType traversalType)
{
using (var test = new Test(algo, computeType, (uint)traversalType))
{
int numParents = traversalType == TraversalType.Different ? 2 : 0;
int numChildren = traversalType == TraversalType.Normal ? 2 : 0;
for (int i = 0; i < 5; ++i)
{
test.Nodes.Add(test.TestDatabase.CreateNode());
}
test.TestDatabase.Connect((uint)TraversalType.Different, test.Nodes[0], k_DifferentOutput, test.Nodes[2], k_DifferentInput);
test.TestDatabase.Connect((uint)TraversalType.Different, test.Nodes[1], k_DifferentOutput, test.Nodes[2], k_DifferentInput);
test.TestDatabase.Connect((uint)TraversalType.Normal, test.Nodes[2], k_OutputOne, test.Nodes[3], k_InputOne);
test.TestDatabase.Connect((uint)TraversalType.Normal, test.Nodes[2], k_OutputOne, test.Nodes[4], k_InputOne);
bool centerNodeWasFound = false;
foreach (var node in test.GetWalker())
{
if (node.Vertex == test.Nodes[2])
{
Assert.AreEqual(0, node.GetParentsByPort(k_InputOne).Count);
Assert.AreEqual(numParents, node.GetParentsByPort(k_DifferentInput).Count);
Assert.AreEqual(0, node.GetChildrenByPort(k_DifferentOutput).Count);
Assert.AreEqual(numChildren, node.GetChildrenByPort(k_OutputOne).Count);
centerNodeWasFound = true;
break;
}
}
Assert.IsTrue(centerNodeWasFound, "Couldn't find middle of graph");
}
}
internal ComputeSecrets(ComputeType computeType)
{
ComputeType = computeType;
}
public void CanFindParentsAndChildren([Values] Topology.SortingAlgorithm algo, [Values] ComputeType jobified)
{
using (var test = new Test(algo, jobified))
{
for (int i = 0; i < 5; ++i)
{
test.Nodes.Add(test.TestDatabase.CreateNode());
}
test.TestDatabase.Connect(test.Nodes[0], k_OutputOne, test.Nodes[2], k_InputOne);
test.TestDatabase.Connect(test.Nodes[1], k_OutputOne, test.Nodes[2], k_InputTwo);
test.TestDatabase.Connect(test.Nodes[2], k_OutputOne, test.Nodes[3], k_InputOne);
test.TestDatabase.Connect(test.Nodes[2], k_OutputTwo, test.Nodes[4], k_InputOne);
bool centerNodeWasFound = false;
foreach (var node in test.GetWalker())
{
if (node.Vertex == test.Nodes[2])
{
var parents = new List <Node>();
foreach (var parent in node.GetParents())
{
parents.Add(parent.Vertex);
}
var children = new List <Node>();
foreach (var child in node.GetChildren())
{
children.Add(child.Vertex);
}
Assert.AreEqual(2, children.Count);
Assert.AreEqual(2, parents.Count);
Assert.IsTrue(parents.Exists(e => e == test.Nodes[0]));
Assert.IsTrue(parents.Exists(e => e == test.Nodes[1]));
Assert.IsTrue(children.Exists(e => e == test.Nodes[3]));
Assert.IsTrue(children.Exists(e => e == test.Nodes[4]));
centerNodeWasFound = true;
break;
}
}
Assert.IsTrue(centerNodeWasFound, "Couldn't find middle of graph");
}
}
/// <summary>
/// Initializes a new instance of the
/// ComputeTypeCreateOrUpdateParameters class with required
/// arguments.
/// </summary>
public ComputeTypeCreateOrUpdateParameters(ComputeType computeType)
: this()
{
Ensure.IsNotNull(computeType, "computeType");
this.ComputeType = computeType;
}
static void CaptureOrReportComputeHashInvocationOperation(OperationAnalysisContext context, MethodHelper methodHelper, DataCollector dataCollector, IInvocationOperation computeHashInvocation, ComputeType computeType)
{
switch (computeHashInvocation.Instance)
{
case ILocalReferenceOperation:
dataCollector.CollectComputeHashInvocation(computeHashInvocation, computeType);
break;
case IInvocationOperation chainedInvocationOperation when methodHelper.IsHashCreateMethod(chainedInvocationOperation):
ReportChainedComputeHashInvocationOperation(chainedInvocationOperation.TargetMethod.ContainingType);
break;
case IObjectCreationOperation chainObjectCreationOperation when methodHelper.IsObjectCreationInheritingHashAlgorithm(chainObjectCreationOperation):
ReportChainedComputeHashInvocationOperation(chainObjectCreationOperation.Type);
break;
}
void ReportChainedComputeHashInvocationOperation(ITypeSymbol originalHashType)
{
if (!methodHelper.TryGetHashDataMethod(originalHashType, computeType, out var staticHashMethod))
{
return;
}
var diagnostics = CreateDiagnostics(computeHashInvocation, staticHashMethod.ContainingType, computeType);
context.ReportDiagnostic(diagnostics);
}
}
public void ParentAndChildConnections_HasCorrectCounts([Values] Topology.SortingAlgorithm algo, [Values] ComputeType jobified)
{
using (var test = new Test(algo, jobified))
{
for (int i = 0; i < 5; ++i)
{
test.Nodes.Add(test.TestDatabase.CreateNode());
}
test.TestDatabase.Connect(test.Nodes[0], k_OutputOne, test.Nodes[2], k_InputOne);
test.TestDatabase.Connect(test.Nodes[1], k_OutputOne, test.Nodes[2], k_InputTwo);
test.TestDatabase.Connect(test.Nodes[2], k_OutputOne, test.Nodes[3], k_InputOne);
test.TestDatabase.Connect(test.Nodes[2], k_OutputTwo, test.Nodes[4], k_InputOne);
bool centerNodeWasFound = false;
foreach (var node in test.GetWalker())
{
if (node.Vertex == test.Nodes[2])
{
Assert.AreEqual(2, node.GetParentConnections().Count);
Assert.AreEqual(1, node.GetParentConnectionsByPort(k_InputOne).Count);
Assert.AreEqual(1, node.GetParentConnectionsByPort(k_InputTwo).Count);
Assert.AreEqual(2, node.GetChildConnections().Count);
Assert.AreEqual(1, node.GetChildConnectionsByPort(k_OutputOne).Count);
Assert.AreEqual(1, node.GetChildConnectionsByPort(k_OutputTwo).Count);
centerNodeWasFound = true;
break;
}
}
Assert.IsTrue(centerNodeWasFound, "Couldn't find middle of graph");
}
}
public void DeepImplicitlyCyclicDataGraph_ProducesDeferredError([Values] Topology.SortingAlgorithm algo, [Values] ComputeType computeType, [Values(0, 1, 10, 13, 100)] int depth)
{
using (var test = new Test(algo, computeType))
{
// create three branches
Node
a = test.TestDatabase.CreateNode(),
b = test.TestDatabase.CreateNode(),
c = test.TestDatabase.CreateNode();
// intertwine
test.TestDatabase.Connect(a, k_OutputOne, b, k_InputOne);
test.TestDatabase.Connect(b, k_OutputOne, c, k_InputOne);
test.Nodes.Add(a);
test.Nodes.Add(b);
test.Nodes.Add(c);
// fork off ->
// o-o-o-o-o-o-o-o ...
// |
// o-o-o-o-o-o-o-o ...
// |
// o-o-o-o-o-o-o-o ...
for (int i = 0; i < depth; ++i)
{
a = test.TestDatabase.CreateNode();
b = test.TestDatabase.CreateNode();
c = test.TestDatabase.CreateNode();
test.TestDatabase.Connect(test.Nodes[i * 3 + 0], k_OutputOne, a, k_InputOne);
test.TestDatabase.Connect(test.Nodes[i * 3 + 1], k_OutputOne, b, k_InputOne);
test.TestDatabase.Connect(test.Nodes[i * 3 + 2], k_OutputOne, c, k_InputOne);
test.Nodes.Add(a);
test.Nodes.Add(b);
test.Nodes.Add(c);
}
// connect very last node to start, forming a cycle
// -> o-o-o-o-o-o-o-o->
// | |
// | o-o-o-o-o-o-o-o->
// | |
// | o-o-o-o-o-o-o-o
// -----------------|
test.TestDatabase.Connect(test.Nodes[test.Nodes.Length - 1], k_OutputOne, test.Nodes[0], k_InputOne);
var cache = test.GetUpdatedCache();
Assert.AreEqual(1, cache.Errors.Length);
Assert.AreEqual(Topology.TraversalCache.Error.Cycles, cache.Errors[0]);
}
}
public void PartlyCyclicDataGraph_ProducesDeferredError([Values] Topology.SortingAlgorithm algo, [Values] ComputeType computeType)
{
using (var test = new Test(algo, computeType))
{
test.Nodes.Add(test.TestDatabase.CreateNode());
test.Nodes.Add(test.TestDatabase.CreateNode());
test.Nodes.Add(test.TestDatabase.CreateNode());
test.TestDatabase.Connect(test.Nodes[0], k_OutputOne, test.Nodes[1], k_InputOne);
test.TestDatabase.Connect(test.Nodes[1], k_OutputOne, test.Nodes[0], k_InputOne);
test.TestDatabase.Connect(test.Nodes[2], k_OutputOne, test.Nodes[0], k_InputOne);
var cache = test.GetUpdatedCache();
Assert.AreEqual(1, cache.Errors.Length);
Assert.AreEqual(Topology.TraversalCache.Error.Cycles, cache.Errors[0]);
}
}
public void AlternateDependencies_CanDiffer_FromTraversal([Values] Topology.SortingAlgorithm algo, [Values] ComputeType computeType)
{
using (var test = new Test(algo, computeType, (uint)TraversalType.Normal, (uint)TraversalType.Different))
{
for (int i = 0; i < 4; ++i)
{
test.Nodes.Add(test.TestDatabase.CreateNode());
}
// Setup normal traversal dependencies
test.TestDatabase.Connect((uint)TraversalType.Normal, test.Nodes[0], k_OutputOne, test.Nodes[2], k_InputOne);
test.TestDatabase.Connect((uint)TraversalType.Normal, test.Nodes[2], k_OutputOne, test.Nodes[3], k_InputOne);
test.TestDatabase.Connect((uint)TraversalType.Normal, test.Nodes[0], k_OutputOne, test.Nodes[3], k_InputOne);
// Setup an alternate dependency hierarchy
test.TestDatabase.Connect((uint)TraversalType.Different, test.Nodes[3], k_OutputOne, test.Nodes[2], k_InputOne);
test.TestDatabase.Connect((uint)TraversalType.Different, test.Nodes[2], k_OutputOne, test.Nodes[1], k_InputOne);
test.TestDatabase.Connect((uint)TraversalType.Different, test.Nodes[1], k_OutputOne, test.Nodes[3], k_InputOne);
foreach (var node in test.GetWalker())
{
if (node.Vertex == test.Nodes[0])
{
Assert.Zero(node.GetParents().Count);
AssertAreSame(new List <Node> {
test.Nodes[2], test.Nodes[3]
}, node.GetChildren());
Assert.Zero(node.GetParents(Topology.TraversalCache.Hierarchy.Alternate).Count);
Assert.Zero(node.GetChildren(Topology.TraversalCache.Hierarchy.Alternate).Count);
}
if (node.Vertex == test.Nodes[1])
{
Assert.Zero(node.GetParents().Count);
Assert.Zero(node.GetChildren().Count);
AssertAreSame(new List <Node> {
test.Nodes[2]
}, node.GetParents(Topology.TraversalCache.Hierarchy.Alternate));
AssertAreSame(new List <Node> {
test.Nodes[3]
}, node.GetChildren(Topology.TraversalCache.Hierarchy.Alternate));
}
if (node.Vertex == test.Nodes[2])
{
AssertAreSame(new List <Node> {
test.Nodes[0]
}, node.GetParents());
AssertAreSame(new List <Node> {
test.Nodes[3]
}, node.GetChildren());
AssertAreSame(new List <Node> {
test.Nodes[3]
}, node.GetParents(Topology.TraversalCache.Hierarchy.Alternate));
AssertAreSame(new List <Node> {
test.Nodes[1]
}, node.GetChildren(Topology.TraversalCache.Hierarchy.Alternate));
}
if (node.Vertex == test.Nodes[3])
{
AssertAreSame(new List <Node> {
test.Nodes[0], test.Nodes[2]
}, node.GetParents());
Assert.Zero(node.GetChildren().Count);
AssertAreSame(new List <Node> {
test.Nodes[1]
}, node.GetParents(Topology.TraversalCache.Hierarchy.Alternate));
AssertAreSame(new List <Node> {
test.Nodes[2]
}, node.GetChildren(Topology.TraversalCache.Hierarchy.Alternate));
}
}
}
}
public void RootsAndLeaves_InternalIndices_AreRegistrered([Values] Topology.SortingAlgorithm algo, [Values] ComputeType jobified)
{
using (var test = new Test(algo, jobified))
{
for (int i = 0; i < 5; ++i)
{
test.Nodes.Add(test.TestDatabase.CreateNode());
}
test.TestDatabase.Connect(test.Nodes[0], k_OutputOne, test.Nodes[2], k_InputOne);
test.TestDatabase.Connect(test.Nodes[1], k_OutputOne, test.Nodes[2], k_InputTwo);
test.TestDatabase.Connect(test.Nodes[2], k_OutputOne, test.Nodes[3], k_InputOne);
test.TestDatabase.Connect(test.Nodes[2], k_OutputTwo, test.Nodes[4], k_InputOne);
var cache = test.GetUpdatedCache();
var rootWalker = new Topology.RootCacheWalker(cache);
var leafWalker = new Topology.LeafCacheWalker(cache);
var roots = new List <Node>();
var leaves = new List <Node>();
Assert.AreEqual(rootWalker.Count, 2);
Assert.AreEqual(leafWalker.Count, 2);
foreach (var nodeCache in rootWalker)
{
roots.Add(nodeCache.Vertex);
}
foreach (var nodeCache in leafWalker)
{
leaves.Add(nodeCache.Vertex);
}
CollectionAssert.Contains(leaves, test.Nodes[0]);
CollectionAssert.Contains(leaves, test.Nodes[1]);
CollectionAssert.Contains(roots, test.Nodes[3]);
CollectionAssert.Contains(roots, test.Nodes[4]);
}
}
public void IslandNodes_RegisterBothAsLeafAndRoot([Values] Topology.SortingAlgorithm algo, [Values] ComputeType jobified)
{
using (var test = new Test(algo, jobified))
{
test.Nodes.Add(test.TestDatabase.CreateNode());
var cache = test.GetUpdatedCache();
Assert.AreEqual(cache.Leaves.Length, 1);
Assert.AreEqual(cache.Roots.Length, 1);
var roots = new List <Node>();
for (int i = 0; i < cache.Leaves.Length; ++i)
{
roots.Add(cache.OrderedTraversal[cache.Roots[i]].Vertex);
}
var leaves = new List <Node>();
for (int i = 0; i < cache.Roots.Length; ++i)
{
leaves.Add(cache.OrderedTraversal[cache.Leaves[i]].Vertex);
}
CollectionAssert.Contains(leaves, test.Nodes[0]);
CollectionAssert.Contains(roots, test.Nodes[0]);
}
}
public void UpdateAllBuffers(ComputeType type)
{
int kernelId = GetKernelID(type);
UpdateAllBuffers(kernelId);
}
public void CanCongaWalkAndDependenciesAreInCorrectOrder([Values] Topology.SortingAlgorithm algo, [Values] ComputeType jobified)
{
using (var test = new Test(algo, jobified))
{
var node1 = test.TestDatabase.CreateNode();
var node2 = test.TestDatabase.CreateNode();
var node3 = test.TestDatabase.CreateNode();
test.Nodes.Add(node1);
test.Nodes.Add(node2);
test.Nodes.Add(node3);
test.TestDatabase.Connect(node1, k_OutputOne, node2, k_InputOne);
test.TestDatabase.Connect(node2, k_OutputOne, node3, k_InputOne);
var index = 0;
foreach (var node in test.GetWalker())
{
Assert.AreEqual(node.CacheIndex, index);
Assert.AreEqual(node.Vertex, test.Nodes[index]);
index++;
}
}
}
internal ComputeNodesInformation(ComputeType computeType, string nextLink)
{
ComputeType = computeType;
NextLink = nextLink;
}
public void Dispatch(ComputeType type)
{
int kernelId = GetKernelID(type);
Dispatch(kernelId);
}
internal VirtualMachineSecrets(ComputeType computeType, VirtualMachineSshCredentials administratorAccount) : base(computeType)
{
AdministratorAccount = administratorAccount;
ComputeType = computeType;
}
public Test(Topology.SortingAlgorithm algo, ComputeType computingType)
: this(algo, computingType, Topology.TraversalCache.TraverseAllMask)
{
}
