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); }