internal AsyncListComputeNodeExtensionsEnumerator(PoolOperations parentPoolOperations, string poolId, string nodeId, BehaviorManager behaviorMgr, DetailLevel detailLevel)
: base(behaviorMgr, detailLevel)
{
_parentPoolOperations = parentPoolOperations;
_poolId = poolId;
_nodeId = nodeId;
}
/// <summary>
/// Deletes the specified file from its compute node.
/// </summary>
/// <param name="recursive">If the file-path parameter represents a directory instead of a file, you can set the optional
/// recursive parameter to true to delete the directory and all of the files and subdirectories in it. If recursive is false
/// then the directory must be empty or deletion will fail..</param>
/// <param name="parameters">Specifies which node file to delete.</param>
public void DeleteNodeFile(bool?recursive, NodeFileOperationParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
switch (parameters.NodeFileType)
{
case PSNodeFileType.Task:
{
JobOperations jobOperations = parameters.Context.BatchOMClient.JobOperations;
jobOperations.DeleteNodeFile(parameters.JobId, parameters.TaskId, parameters.NodeFileName, recursive: recursive, additionalBehaviors: parameters.AdditionalBehaviors);
break;
}
case PSNodeFileType.ComputeNode:
{
PoolOperations poolOperations = parameters.Context.BatchOMClient.PoolOperations;
poolOperations.DeleteNodeFile(parameters.PoolId, parameters.ComputeNodeId, parameters.NodeFileName, recursive: recursive, additionalBehaviors: parameters.AdditionalBehaviors);
break;
}
case PSNodeFileType.PSNodeFileInstance:
{
parameters.NodeFile.omObject.Delete(recursive: recursive, additionalBehaviors: parameters.AdditionalBehaviors);
break;
}
default:
{
throw new ArgumentException(Resources.NoNodeFile);
}
}
}
internal AsyncListPoolUsageMetricsEnumerator(PoolOperations parentPoolOperations, DateTime?startTime, DateTime?endTime, BehaviorManager behaviorMgr, DetailLevel detailLevel)
: base(behaviorMgr, detailLevel)
{
_parentPoolOperations = parentPoolOperations;
_startTime = startTime;
_endTime = endTime;
}
/// <summary>
/// Creates a new compute node user.
/// </summary>
/// <param name="options">The options to use when creating the compute node user.</param>
public void CreateComputeNodeUser(NewComputeNodeUserParameters options)
{
if (options == null)
{
throw new ArgumentNullException("options");
}
ComputeNodeUser user = null;
string computeNodeId = null;
if (options.ComputeNode != null)
{
user = options.ComputeNode.omObject.CreateComputeNodeUser();
computeNodeId = options.ComputeNode.Id;
}
else
{
PoolOperations poolOperations = options.Context.BatchOMClient.PoolOperations;
user = poolOperations.CreateComputeNodeUser(options.PoolId, options.ComputeNodeId);
computeNodeId = options.ComputeNodeId;
}
user.Name = options.ComputeNodeUserName;
user.Password = options.Password;
user.ExpiryTime = options.ExpiryTime;
user.IsAdmin = options.IsAdmin;
WriteVerbose(string.Format(Resources.CreatingComputeNodeUser, user.Name, computeNodeId));
user.Commit(ComputeNodeUserCommitSemantics.AddUser, options.AdditionalBehaviors);
}
/// <summary>
/// Creates a new pool.
/// </summary>
/// <param name="parameters">The parameters to use when creating the pool.</param>
public void CreatePool(NewPoolParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
PoolOperations poolOperations = parameters.Context.BatchOMClient.PoolOperations;
CloudPool pool = poolOperations.CreatePool(poolId: parameters.PoolId, osFamily: parameters.OSFamily, virtualMachineSize: parameters.VirtualMachineSize);
pool.DisplayName = parameters.DisplayName;
pool.ResizeTimeout = parameters.ResizeTimeout;
pool.MaxTasksPerComputeNode = parameters.MaxTasksPerComputeNode;
pool.InterComputeNodeCommunicationEnabled = parameters.InterComputeNodeCommunicationEnabled;
pool.TargetOSVersion = parameters.TargetOSVersion;
if (!string.IsNullOrEmpty(parameters.AutoScaleFormula))
{
pool.AutoScaleEnabled = true;
pool.AutoScaleEvaluationInterval = parameters.AutoScaleEvaluationInterval;
pool.AutoScaleFormula = parameters.AutoScaleFormula;
}
else if (parameters.TargetDedicated.HasValue)
{
pool.TargetDedicated = parameters.TargetDedicated;
}
if (parameters.TaskSchedulingPolicy != null)
{
pool.TaskSchedulingPolicy = parameters.TaskSchedulingPolicy.omObject;
}
if (parameters.StartTask != null)
{
Utils.Utils.StartTaskSyncCollections(parameters.StartTask);
pool.StartTask = parameters.StartTask.omObject;
}
if (parameters.Metadata != null)
{
pool.Metadata = new List <MetadataItem>();
foreach (DictionaryEntry m in parameters.Metadata)
{
pool.Metadata.Add(new MetadataItem(m.Key.ToString(), m.Value.ToString()));
}
}
if (parameters.CertificateReferences != null)
{
pool.CertificateReferences = new List <CertificateReference>();
foreach (PSCertificateReference c in parameters.CertificateReferences)
{
pool.CertificateReferences.Add(c.omObject);
}
}
WriteVerbose(string.Format(Resources.CreatingPool, parameters.PoolId));
pool.Commit(parameters.AdditionalBehaviors);
}
internal AsyncListNodeFilesByNodeEnumerator(PoolOperations parentPoolOperations, string poolId, string computeNodeId, bool?recursive, BehaviorManager behaviorMgr, DetailLevel detailLevel)
: base(behaviorMgr, detailLevel)
{
_parentPoolOperations = parentPoolOperations;
_poolId = poolId;
_computeNodeId = computeNodeId;
_recursive = recursive;
}
public PSPoolStatistics ListAllPoolsLifetimeStatistics(BatchAccountContext context, IEnumerable <BatchClientBehavior> additionBehaviors = null)
{
PoolOperations poolOperations = context.BatchOMClient.PoolOperations;
PoolStatistics poolStatistics = poolOperations.GetAllPoolsLifetimeStatistics(additionBehaviors);
PSPoolStatistics psPoolStatistics = new PSPoolStatistics(poolStatistics);
return(psPoolStatistics);
}
internal AsyncListSupportedImagesEnumerator(
PoolOperations parentPoolOps,
BehaviorManager behaviorMgr,
DetailLevel detailLevel)
{
_parentPoolOps = parentPoolOps;
_behaviorMgr = behaviorMgr;
_detailLevel = detailLevel;
}
internal AsyncListNodeAgentSkusEnumerator(
PoolOperations parentPoolOps,
BehaviorManager behaviorMgr,
DetailLevel detailLevel)
{
_parentPoolOps = parentPoolOps;
_behaviorMgr = behaviorMgr;
_detailLevel = detailLevel;
}
internal AsyncListPoolNodeCountsEnumerator(
PoolOperations parentPoolOperations,
BehaviorManager behaviorMgr,
DetailLevel detailLevel)
{
_parentPoolOperations = parentPoolOperations;
_behaviorMgr = behaviorMgr;
_detailLevel = detailLevel;
}
/// <summary>
/// Deletes the specified pool.
/// </summary>
/// <param name="context">The account to use.</param>
/// <param name="poolId">The id of the pool to delete.</param>
/// <param name="additionBehaviors">Additional client behaviors to perform.</param>
public void DeletePool(BatchAccountContext context, string poolId, IEnumerable <BatchClientBehavior> additionBehaviors = null)
{
if (string.IsNullOrWhiteSpace(poolId))
{
throw new ArgumentNullException("poolId");
}
PoolOperations poolOperations = context.BatchOMClient.PoolOperations;
poolOperations.DeletePool(poolId, additionBehaviors);
}
internal ComputeNodeFile(
PoolOperations poolOperations,
string poolId,
string computeNodeId,
Models.NodeFile boundToThis,
IEnumerable <BatchClientBehavior> inheritTheseBehaviors) : base(boundToThis, inheritTheseBehaviors)
{
_poolOperations = poolOperations;
_poolId = poolId;
_computeNodeId = computeNodeId;
}
internal AsyncListComputeNodesEnumerator(
PoolOperations parentPoolOps,
string poolId,
BehaviorManager behaviorMgr,
DetailLevel detailLevel)
{
_parentPoolOps = parentPoolOps;
_poolId = poolId;
_behaviorMgr = behaviorMgr;
_detailLevel = detailLevel;
}
/// <summary>
/// Deletes the specified compute node user.
/// </summary>
/// <param name="parameters">The parameters indicating which compute node user to delete.</param>
public void DeleteComputeNodeUser(ComputeNodeUserOperationParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
PoolOperations poolOperations = parameters.Context.BatchOMClient.PoolOperations;
poolOperations.DeleteComputeNodeUser(parameters.PoolId, parameters.ComputeNodeId, parameters.ComputeNodeUserName, parameters.AdditionalBehaviors);
}
/// <summary>
/// Gets all pools lifetime summary statistics
/// </summary>
/// <param name="context">The account to use.</param>
/// <param name="additionBehaviors">Additional client behaviors to perform.</param>
public PSPoolStatistics GetAllPoolsLifetimeStatistics(BatchAccountContext context, IEnumerable <BatchClientBehavior> additionBehaviors = null)
{
PoolOperations poolOperations = context.BatchOMClient.PoolOperations;
WriteVerbose(string.Format(Resources.GetAllPoolsLifetimeStatistics));
PoolStatistics poolStatistics = poolOperations.GetAllLifetimeStatistics(additionBehaviors);
PSPoolStatistics psPoolStatistics = new PSPoolStatistics(poolStatistics);
return(psPoolStatistics);
}
/// <summary>
/// Stops the resize operation on the specified pool.
/// </summary>
/// <param name="context">The account to use.</param>
/// <param name="poolId">The id of the pool.</param>
/// <param name="additionalBehaviors">Additional client behaviors to perform.</param>
public void StopResizePool(BatchAccountContext context, string poolId, IEnumerable <BatchClientBehavior> additionalBehaviors = null)
{
if (string.IsNullOrWhiteSpace(poolId))
{
throw new ArgumentNullException("poolId");
}
WriteVerbose(string.Format(Resources.StopResizingPool, poolId));
PoolOperations poolOperations = context.BatchOMClient.PoolOperations;
poolOperations.StopResizePool(poolId, additionalBehaviors);
}
public void Bug1965363_2384616_Wat7OSVersionFeatures()
{
Action test = () =>
{
using (BatchClient batchCli = TestUtilities.OpenBatchClientAsync(TestUtilities.GetCredentialsFromEnvironment()).Result)
{
PoolOperations poolOperations = batchCli.PoolOperations;
try
{
this.testOutputHelper.WriteLine("Listing OS Versions:");
// create pool tests
// forget to set CloudServiceConfiguration on Create, get error
{
CloudPool noArgs = poolOperations.CreatePool("Bug1965363ButNoOSFamily-" + TestUtilities.GetMyName(), PoolFixture.VMSize, default(CloudServiceConfiguration), targetDedicatedComputeNodes: 0);
BatchException ex = TestUtilities.AssertThrows <BatchException>(() => noArgs.Commit());
string exStr = ex.ToString();
// we are expecting an exception, assert if the exception is not the correct one.
Assert.Contains("cloudServiceConfiguration", exStr);
}
// create a pool WITH an osFamily
{
string poolIdHOSF = "Bug1965363HasOSF-" + TestUtilities.GetMyName();
try
{
CloudPool hasOSF = poolOperations.CreatePool(poolIdHOSF, PoolFixture.VMSize, new CloudServiceConfiguration(PoolFixture.OSFamily), targetDedicatedComputeNodes: 0);
hasOSF.Commit();
}
finally
{
poolOperations.DeletePool(poolIdHOSF);
}
}
}
catch (Exception ex)
{
// special case os version beacuse it is a common failure and requires human intervention/editing
// test for expired os version
Assert.DoesNotContain("The specified OS Version does not exists", ex.ToString());
throw;
}
}
};
SynchronizationContextHelper.RunTest(test, TestTimeout);
}
private void CopyRDPStream(Stream destinationStream, Microsoft.Azure.Batch.BatchClient client, string poolId, string computeNodeId,
PSComputeNode computeNode, IEnumerable <BatchClientBehavior> additionalBehaviors = null)
{
if (computeNode == null)
{
PoolOperations poolOperations = client.PoolOperations;
poolOperations.GetRDPFile(poolId, computeNodeId, destinationStream, additionalBehaviors);
}
else
{
computeNode.omObject.GetRDPFile(destinationStream, additionalBehaviors);
}
}
public void Bug1771163TestGetComputeNode_RefreshComputeNode()
{
Action test = () =>
{
using (BatchClient batchCli = TestUtilities.OpenBatchClientAsync(TestUtilities.GetCredentialsFromEnvironment()).Result)
{
PoolOperations poolOperations = batchCli.PoolOperations;
List <ComputeNode> computeNodeList = poolOperations.ListComputeNodes(this.poolFixture.PoolId).ToList();
ComputeNode computeNodeToGet = computeNodeList.First();
string computeNodeId = computeNodeToGet.Id;
//
// Get compute node via the manager
//
ComputeNode computeNodeFromManager = poolOperations.GetComputeNode(this.poolFixture.PoolId, computeNodeId);
CompareComputeNodeObjects(computeNodeToGet, computeNodeFromManager);
//
// Get compute node via the pool
//
CloudPool pool = poolOperations.GetPool(this.poolFixture.PoolId);
ComputeNode computeNodeFromPool = pool.GetComputeNode(computeNodeId);
CompareComputeNodeObjects(computeNodeToGet, computeNodeFromPool);
//
// Refresh compute node
//
//Refresh with a detail level
computeNodeToGet.Refresh(new ODATADetailLevel()
{
SelectClause = "affinityId,id"
});
//Confirm we have the reduced detail level
Assert.Equal(computeNodeToGet.AffinityId, computeNodeFromManager.AffinityId);
Assert.Null(computeNodeToGet.IPAddress);
Assert.Null(computeNodeToGet.LastBootTime);
Assert.Null(computeNodeToGet.State);
Assert.Null(computeNodeToGet.StartTaskInformation);
//Refresh again with increased detail level
computeNodeToGet.Refresh();
CompareComputeNodeObjects(computeNodeToGet, computeNodeFromManager);
}
};
SynchronizationContextHelper.RunTest(test, TestTimeout);
}
/// <summary>
/// Resizes the specified pool.
/// </summary>
/// <param name="parameters">The parameters to use when resizing the pool.</param>
public void ResizePool(PoolResizeParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
string poolId = parameters.Pool == null ? parameters.PoolId : parameters.Pool.Id;
WriteVerbose(string.Format(Resources.ResizingPool, poolId, parameters.TargetDedicated));
PoolOperations poolOperations = parameters.Context.BatchOMClient.PoolOperations;
poolOperations.ResizePool(poolId, parameters.TargetDedicated, parameters.ResizeTimeout, parameters.ComputeNodeDeallocationOption, parameters.AdditionalBehaviors);
}
/// <summary>
/// Changes the operating system version of the specified pool.
/// </summary>
/// <param name="parameters">The parameters specifying the pool and target OS version.</param>
public void ChangeOSVersion(ChangeOSVersionParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
string poolId = parameters.Pool == null ? parameters.PoolId : parameters.Pool.Id;
WriteVerbose(string.Format(Resources.ChangeOSVersion, poolId, parameters.TargetOSVersion));
PoolOperations poolOperations = parameters.Context.BatchOMClient.PoolOperations;
poolOperations.ChangeOSVersion(poolId, parameters.TargetOSVersion, parameters.AdditionalBehaviors);
}
/// <summary>
/// Disables automatic scaling on the specified pool.
/// </summary>
/// <param name="parameters">The parameters specifying the target pool.</param>
public void DisableAutoScale(PoolOperationParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
string poolId = parameters.Pool == null ? parameters.PoolId : parameters.Pool.Id;
WriteVerbose(string.Format(Resources.DisableAutoScale, poolId));
PoolOperations poolOperations = parameters.Context.BatchOMClient.PoolOperations;
poolOperations.DisableAutoScale(poolId, parameters.AdditionalBehaviors);
}
/// <summary>
/// Lists the node agent SKUs matching the specified filter options.
/// </summary>
/// <param name="context">The account to use.</param>
/// <param name="filterClause">The level of detail</param>
/// <param name="maxCount">The number of results.</param>
/// <param name="additionalBehaviors">Additional client behaviors to perform.</param>
/// <returns>The node agent SKUs matching the specified filter.</returns>
public IEnumerable <PSImageInformation> ListSupportedImages(
BatchAccountContext context,
string filterClause = default(string),
int maxCount = default(int),
IEnumerable <BatchClientBehavior> additionalBehaviors = null)
{
PoolOperations poolOperations = context.BatchOMClient.PoolOperations;
ODATADetailLevel filterLevel = new ODATADetailLevel(filterClause: filterClause);
IPagedEnumerable <ImageInformation> supportedImages = poolOperations.ListSupportedImages(filterLevel, additionalBehaviors);
Func <ImageInformation, PSImageInformation> mappingFunction = p => { return(new PSImageInformation(p)); };
return(PSPagedEnumerable <PSImageInformation, ImageInformation> .CreateWithMaxCount(supportedImages, mappingFunction,
maxCount, () => WriteVerbose(string.Format(Resources.MaxCount, maxCount))));
}
/// <summary>
/// Gets the result of evaluating an automatic scaling formula on the specified pool.
/// </summary>
/// <param name="parameters">The parameters specifying the pool and autoscale formula.</param>
public PSAutoScaleEvaluation EvaluateAutoScale(AutoScaleParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
string poolId = parameters.Pool == null ? parameters.PoolId : parameters.Pool.Id;
WriteVerbose(string.Format(Resources.EvaluateAutoScale, poolId, parameters.AutoScaleFormula));
PoolOperations poolOperations = parameters.Context.BatchOMClient.PoolOperations;
AutoScaleEvaluation evaluation = poolOperations.EvaluateAutoScale(poolId, parameters.AutoScaleFormula, parameters.AdditionalBehaviors);
return(new PSAutoScaleEvaluation(evaluation));
}
/// <summary>
/// Lists the compute nodes matching the specified filter options.
/// </summary>
/// <param name="options">The options to use when querying for compute nodes.</param>
/// <returns>The compute nodes matching the specified filter options.</returns>
public IEnumerable <PSComputeNode> ListComputeNodes(ListComputeNodeOptions options)
{
if (options == null)
{
throw new ArgumentNullException("options");
}
string poolId = options.Pool == null ? options.PoolId : options.Pool.Id;
// Get the single compute node matching the specified id
if (!string.IsNullOrEmpty(options.ComputeNodeId))
{
WriteVerbose(string.Format(Resources.GetComputeNodeById, options.ComputeNodeId, poolId));
PoolOperations poolOperations = options.Context.BatchOMClient.PoolOperations;
ODATADetailLevel getDetailLevel = new ODATADetailLevel(selectClause: options.Select);
ComputeNode computeNode = poolOperations.GetComputeNode(poolId, options.ComputeNodeId, detailLevel: getDetailLevel, additionalBehaviors: options.AdditionalBehaviors);
PSComputeNode psComputeNode = new PSComputeNode(computeNode);
return(new PSComputeNode[] { psComputeNode });
}
// List compute nodes using the specified filter
else
{
string verboseLogString = null;
ODATADetailLevel listDetailLevel = new ODATADetailLevel(selectClause: options.Select);
if (!string.IsNullOrEmpty(options.Filter))
{
verboseLogString = string.Format(Resources.GetComputeNodeByOData, poolId);
listDetailLevel.FilterClause = options.Filter;
}
else
{
verboseLogString = string.Format(Resources.GetComputeNodeNoFilter, poolId);
}
WriteVerbose(verboseLogString);
PoolOperations poolOperations = options.Context.BatchOMClient.PoolOperations;
IPagedEnumerable <ComputeNode> computeNodes = poolOperations.ListComputeNodes(poolId, listDetailLevel, options.AdditionalBehaviors);
return(PSPagedEnumerable <PSComputeNode, ComputeNode> .CreateWithMaxCount
(
computeNodes,
c => { return new PSComputeNode(c); },
options.MaxCount,
() => WriteMaxCount(options.MaxCount)
));
}
}
/// <summary>
/// Removes the specified compute nodes from the specified pool.
/// </summary>
/// <param name="parameters">The parameters specifying the pool and the compute nodes.</param>
public void RemoveComputeNodesFromPool(RemoveComputeNodeParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
if (parameters.ComputeNode != null)
{
parameters.ComputeNode.omObject.RemoveFromPool(parameters.DeallocationOption, parameters.ResizeTimeout, parameters.AdditionalBehaviors);
}
else
{
PoolOperations poolOperations = parameters.Context.BatchOMClient.PoolOperations;
poolOperations.RemoveFromPool(parameters.PoolId, parameters.ComputeNodeIds, parameters.DeallocationOption, parameters.ResizeTimeout, parameters.AdditionalBehaviors);
}
}
/// <summary>
/// Initializes client properties.
/// </summary>
private void Initialize()
{
Application = new ApplicationOperations(this);
Pool = new PoolOperations(this);
Account = new AccountOperations(this);
Job = new JobOperations(this);
Certificate = new CertificateOperations(this);
File = new FileOperations(this);
JobSchedule = new JobScheduleOperations(this);
Task = new TaskOperations(this);
ComputeNode = new ComputeNodeOperations(this);
ComputeNodeExtension = new ComputeNodeExtensionOperations(this);
BaseUri = "{batchUrl}";
ApiVersion = "2021-06-01.14.0";
AcceptLanguage = "en-US";
LongRunningOperationRetryTimeout = 30;
GenerateClientRequestId = true;
SerializationSettings = new JsonSerializerSettings
{
Formatting = Newtonsoft.Json.Formatting.Indented,
DateFormatHandling = Newtonsoft.Json.DateFormatHandling.IsoDateFormat,
DateTimeZoneHandling = Newtonsoft.Json.DateTimeZoneHandling.Utc,
NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore,
ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Serialize,
ContractResolver = new ReadOnlyJsonContractResolver(),
Converters = new List <JsonConverter>
{
new Iso8601TimeSpanConverter()
}
};
DeserializationSettings = new JsonSerializerSettings
{
DateFormatHandling = Newtonsoft.Json.DateFormatHandling.IsoDateFormat,
DateTimeZoneHandling = Newtonsoft.Json.DateTimeZoneHandling.Utc,
NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore,
ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Serialize,
ContractResolver = new ReadOnlyJsonContractResolver(),
Converters = new List <JsonConverter>
{
new Iso8601TimeSpanConverter()
}
};
CustomInitialize();
DeserializationSettings.Converters.Add(new CloudErrorJsonConverter());
}
/// <summary>
/// Get the settings required for remote login to a compute node
/// </summary>
/// <returns>The remote login settings for this compute node.</returns>
public PSRemoteLoginSettings ListComputeNodeRemoteLoginSettings(ComputeNodeOperationParameters parameters)
{
RemoteLoginSettings remoteLoginSettings;
if (parameters.ComputeNode != null)
{
remoteLoginSettings = parameters.ComputeNode.omObject.GetRemoteLoginSettings(parameters.AdditionalBehaviors);
}
else
{
PoolOperations poolOperations = parameters.Context.BatchOMClient.PoolOperations;
remoteLoginSettings = poolOperations.GetRemoteLoginSettings(parameters.PoolId, parameters.ComputeNodeId, parameters.AdditionalBehaviors);
}
PSRemoteLoginSettings psRemoteLoginSettings = new PSRemoteLoginSettings(remoteLoginSettings);
return(psRemoteLoginSettings);
}
// Lists the node files under a compute node.
private IEnumerable <PSNodeFile> ListNodeFilesByComputeNode(ListNodeFileOptions options)
{
// Get the single node file matching the specified name
if (!string.IsNullOrEmpty(options.NodeFileName))
{
WriteVerbose(string.Format(Resources.GetNodeFileByComputeNodeByName, options.NodeFileName, options.ComputeNodeId));
PoolOperations poolOperations = options.Context.BatchOMClient.PoolOperations;
NodeFile nodeFile = poolOperations.GetNodeFile(options.PoolId, options.ComputeNodeId, options.NodeFileName, options.AdditionalBehaviors);
PSNodeFile psNodeFile = new PSNodeFile(nodeFile);
return(new PSNodeFile[] { psNodeFile });
}
// List node files using the specified filter
else
{
string computeNodeId = options.ComputeNode == null ? options.ComputeNodeId : options.ComputeNode.Id;
ODATADetailLevel odata = null;
string verboseLogString = null;
if (!string.IsNullOrEmpty(options.Filter))
{
verboseLogString = string.Format(Resources.GetNodeFileByComputeNodeByOData, computeNodeId);
odata = new ODATADetailLevel(filterClause: options.Filter);
}
else
{
verboseLogString = string.Format(Resources.GetNodeFileByComputeNodeNoFilter, computeNodeId);
}
WriteVerbose(verboseLogString);
IPagedEnumerable <NodeFile> nodeFiles = null;
if (options.ComputeNode != null)
{
nodeFiles = options.ComputeNode.omObject.ListNodeFiles(options.Recursive, odata, options.AdditionalBehaviors);
}
else
{
PoolOperations poolOperations = options.Context.BatchOMClient.PoolOperations;
nodeFiles = poolOperations.ListNodeFiles(options.PoolId, options.ComputeNodeId, options.Recursive, odata, options.AdditionalBehaviors);
}
Func <NodeFile, PSNodeFile> mappingFunction = f => { return(new PSNodeFile(f)); };
return(PSPagedEnumerable <PSNodeFile, NodeFile> .CreateWithMaxCount(
nodeFiles, mappingFunction, options.MaxCount, () => WriteVerbose(string.Format(Resources.MaxCount, options.MaxCount))));
}
}
public TestContext(ILogTracer logTracer, IStorage storage, ICreds creds, string storagePrefix)
{
EntityConverter = new EntityConverter();
ServiceConfiguration = new TestServiceConfiguration(storagePrefix);
Storage = storage;
Creds = creds;
Containers = new Containers(logTracer, Storage, Creds, ServiceConfiguration);
Queue = new Queue(Storage, logTracer);
RequestHandling = new RequestHandling(logTracer);
TaskOperations = new TaskOperations(logTracer, this);
NodeOperations = new NodeOperations(logTracer, this);
JobOperations = new JobOperations(logTracer, this);
NodeTasksOperations = new NodeTasksOperations(logTracer, this);
TaskEventOperations = new TaskEventOperations(logTracer, this);
NodeMessageOperations = new NodeMessageOperations(logTracer, this);
ConfigOperations = new ConfigOperations(logTracer, this);
PoolOperations = new PoolOperations(logTracer, this);
ScalesetOperations = new ScalesetOperations(logTracer, this);
UserCredentials = new UserCredentials(logTracer, ConfigOperations);
}
