< Summary

Class:Microsoft.Azure.Batch.Protocol.FileOperationsExtensions
Assembly:Microsoft.Azure.Batch
File(s):C:\Git\azure-sdk-for-net\sdk\batch\Microsoft.Azure.Batch\src\GeneratedProtocol\FileOperationsExtensions.cs
Covered lines:0
Uncovered lines:42
Coverable lines:42
Total lines:546
Line coverage:0% (0 of 42)
Covered branches:0
Total branches:0

Metrics

MethodCyclomatic complexity Line coverage Branch coverage
DeleteFromTask(...)-0%100%
DeleteFromTaskAsync()-0%100%
GetFromTask(...)-0%100%
GetFromTaskAsync()-0%100%
GetPropertiesFromTask(...)-0%100%
GetPropertiesFromTaskAsync()-0%100%
DeleteFromComputeNode(...)-0%100%
DeleteFromComputeNodeAsync()-0%100%
GetFromComputeNode(...)-0%100%
GetFromComputeNodeAsync()-0%100%
GetPropertiesFromComputeNode(...)-0%100%
GetPropertiesFromComputeNodeAsync()-0%100%
ListFromTask(...)-0%100%
ListFromTaskAsync()-0%100%
ListFromComputeNode(...)-0%100%
ListFromComputeNodeAsync()-0%100%
ListFromTaskNext(...)-0%100%
ListFromTaskNextAsync()-0%100%
ListFromComputeNodeNext(...)-0%100%
ListFromComputeNodeNextAsync()-0%100%

File(s)

C:\Git\azure-sdk-for-net\sdk\batch\Microsoft.Azure.Batch\src\GeneratedProtocol\FileOperationsExtensions.cs

#LineLine coverage
 1// <auto-generated>
 2// Copyright (c) Microsoft Corporation. All rights reserved.
 3// Licensed under the MIT License. See License.txt in the project root for
 4// license information.
 5//
 6// Code generated by Microsoft (R) AutoRest Code Generator.
 7// Changes may cause incorrect behavior and will be lost if the code is
 8// regenerated.
 9// </auto-generated>
 10
 11namespace Microsoft.Azure.Batch.Protocol
 12{
 13    using Microsoft.Rest;
 14    using Microsoft.Rest.Azure;
 15    using Models;
 16    using System.IO;
 17    using System.Threading;
 18    using System.Threading.Tasks;
 19
 20    /// <summary>
 21    /// Extension methods for FileOperations.
 22    /// </summary>
 23    public static partial class FileOperationsExtensions
 24    {
 25            /// <summary>
 26            /// Deletes the specified Task file from the Compute Node where the Task ran.
 27            /// </summary>
 28            /// <param name='operations'>
 29            /// The operations group for this extension method.
 30            /// </param>
 31            /// <param name='jobId'>
 32            /// The ID of the Job that contains the Task.
 33            /// </param>
 34            /// <param name='taskId'>
 35            /// The ID of the Task whose file you want to delete.
 36            /// </param>
 37            /// <param name='filePath'>
 38            /// The path to the Task file or directory that you want to delete.
 39            /// </param>
 40            /// <param name='recursive'>
 41            /// Whether to delete children of a directory. If the filePath parameter
 42            /// represents a directory instead of a file, you can set recursive to true to
 43            /// delete the directory and all of the files and subdirectories in it. If
 44            /// recursive is false then the directory must be empty or deletion will fail.
 45            /// </param>
 46            /// <param name='fileDeleteFromTaskOptions'>
 47            /// Additional parameters for the operation
 48            /// </param>
 49            public static FileDeleteFromTaskHeaders DeleteFromTask(this IFileOperations operations, string jobId, string
 50            {
 051                return operations.DeleteFromTaskAsync(jobId, taskId, filePath, recursive, fileDeleteFromTaskOptions).Get
 52            }
 53
 54            /// <summary>
 55            /// Deletes the specified Task file from the Compute Node where the Task ran.
 56            /// </summary>
 57            /// <param name='operations'>
 58            /// The operations group for this extension method.
 59            /// </param>
 60            /// <param name='jobId'>
 61            /// The ID of the Job that contains the Task.
 62            /// </param>
 63            /// <param name='taskId'>
 64            /// The ID of the Task whose file you want to delete.
 65            /// </param>
 66            /// <param name='filePath'>
 67            /// The path to the Task file or directory that you want to delete.
 68            /// </param>
 69            /// <param name='recursive'>
 70            /// Whether to delete children of a directory. If the filePath parameter
 71            /// represents a directory instead of a file, you can set recursive to true to
 72            /// delete the directory and all of the files and subdirectories in it. If
 73            /// recursive is false then the directory must be empty or deletion will fail.
 74            /// </param>
 75            /// <param name='fileDeleteFromTaskOptions'>
 76            /// Additional parameters for the operation
 77            /// </param>
 78            /// <param name='cancellationToken'>
 79            /// The cancellation token.
 80            /// </param>
 81            public static async Task<FileDeleteFromTaskHeaders> DeleteFromTaskAsync(this IFileOperations operations, str
 82            {
 083                using (var _result = await operations.DeleteFromTaskWithHttpMessagesAsync(jobId, taskId, filePath, recur
 84                {
 085                    return _result.Headers;
 86                }
 087            }
 88
 89            /// <summary>
 90            /// Returns the content of the specified Task file.
 91            /// </summary>
 92            /// <param name='operations'>
 93            /// The operations group for this extension method.
 94            /// </param>
 95            /// <param name='jobId'>
 96            /// The ID of the Job that contains the Task.
 97            /// </param>
 98            /// <param name='taskId'>
 99            /// The ID of the Task whose file you want to retrieve.
 100            /// </param>
 101            /// <param name='filePath'>
 102            /// The path to the Task file that you want to get the content of.
 103            /// </param>
 104            /// <param name='fileGetFromTaskOptions'>
 105            /// Additional parameters for the operation
 106            /// </param>
 107            public static Stream GetFromTask(this IFileOperations operations, string jobId, string taskId, string filePa
 108            {
 0109                return operations.GetFromTaskAsync(jobId, taskId, filePath, fileGetFromTaskOptions).GetAwaiter().GetResu
 110            }
 111
 112            /// <summary>
 113            /// Returns the content of the specified Task file.
 114            /// </summary>
 115            /// <param name='operations'>
 116            /// The operations group for this extension method.
 117            /// </param>
 118            /// <param name='jobId'>
 119            /// The ID of the Job that contains the Task.
 120            /// </param>
 121            /// <param name='taskId'>
 122            /// The ID of the Task whose file you want to retrieve.
 123            /// </param>
 124            /// <param name='filePath'>
 125            /// The path to the Task file that you want to get the content of.
 126            /// </param>
 127            /// <param name='fileGetFromTaskOptions'>
 128            /// Additional parameters for the operation
 129            /// </param>
 130            /// <param name='cancellationToken'>
 131            /// The cancellation token.
 132            /// </param>
 133            public static async Task<Stream> GetFromTaskAsync(this IFileOperations operations, string jobId, string task
 134            {
 0135                var _result = await operations.GetFromTaskWithHttpMessagesAsync(jobId, taskId, filePath, fileGetFromTask
 0136                _result.Request.Dispose();
 0137                return _result.Body;
 0138            }
 139
 140            /// <summary>
 141            /// Gets the properties of the specified Task file.
 142            /// </summary>
 143            /// <param name='operations'>
 144            /// The operations group for this extension method.
 145            /// </param>
 146            /// <param name='jobId'>
 147            /// The ID of the Job that contains the Task.
 148            /// </param>
 149            /// <param name='taskId'>
 150            /// The ID of the Task whose file you want to get the properties of.
 151            /// </param>
 152            /// <param name='filePath'>
 153            /// The path to the Task file that you want to get the properties of.
 154            /// </param>
 155            /// <param name='fileGetPropertiesFromTaskOptions'>
 156            /// Additional parameters for the operation
 157            /// </param>
 158            public static FileGetPropertiesFromTaskHeaders GetPropertiesFromTask(this IFileOperations operations, string
 159            {
 0160                return operations.GetPropertiesFromTaskAsync(jobId, taskId, filePath, fileGetPropertiesFromTaskOptions).
 161            }
 162
 163            /// <summary>
 164            /// Gets the properties of the specified Task file.
 165            /// </summary>
 166            /// <param name='operations'>
 167            /// The operations group for this extension method.
 168            /// </param>
 169            /// <param name='jobId'>
 170            /// The ID of the Job that contains the Task.
 171            /// </param>
 172            /// <param name='taskId'>
 173            /// The ID of the Task whose file you want to get the properties of.
 174            /// </param>
 175            /// <param name='filePath'>
 176            /// The path to the Task file that you want to get the properties of.
 177            /// </param>
 178            /// <param name='fileGetPropertiesFromTaskOptions'>
 179            /// Additional parameters for the operation
 180            /// </param>
 181            /// <param name='cancellationToken'>
 182            /// The cancellation token.
 183            /// </param>
 184            public static async Task<FileGetPropertiesFromTaskHeaders> GetPropertiesFromTaskAsync(this IFileOperations o
 185            {
 0186                using (var _result = await operations.GetPropertiesFromTaskWithHttpMessagesAsync(jobId, taskId, filePath
 187                {
 0188                    return _result.Headers;
 189                }
 0190            }
 191
 192            /// <summary>
 193            /// Deletes the specified file from the Compute Node.
 194            /// </summary>
 195            /// <param name='operations'>
 196            /// The operations group for this extension method.
 197            /// </param>
 198            /// <param name='poolId'>
 199            /// The ID of the Pool that contains the Compute Node.
 200            /// </param>
 201            /// <param name='nodeId'>
 202            /// The ID of the Compute Node from which you want to delete the file.
 203            /// </param>
 204            /// <param name='filePath'>
 205            /// The path to the file or directory that you want to delete.
 206            /// </param>
 207            /// <param name='recursive'>
 208            /// Whether to delete children of a directory. If the filePath parameter
 209            /// represents a directory instead of a file, you can set recursive to true to
 210            /// delete the directory and all of the files and subdirectories in it. If
 211            /// recursive is false then the directory must be empty or deletion will fail.
 212            /// </param>
 213            /// <param name='fileDeleteFromComputeNodeOptions'>
 214            /// Additional parameters for the operation
 215            /// </param>
 216            public static FileDeleteFromComputeNodeHeaders DeleteFromComputeNode(this IFileOperations operations, string
 217            {
 0218                return operations.DeleteFromComputeNodeAsync(poolId, nodeId, filePath, recursive, fileDeleteFromComputeN
 219            }
 220
 221            /// <summary>
 222            /// Deletes the specified file from the Compute Node.
 223            /// </summary>
 224            /// <param name='operations'>
 225            /// The operations group for this extension method.
 226            /// </param>
 227            /// <param name='poolId'>
 228            /// The ID of the Pool that contains the Compute Node.
 229            /// </param>
 230            /// <param name='nodeId'>
 231            /// The ID of the Compute Node from which you want to delete the file.
 232            /// </param>
 233            /// <param name='filePath'>
 234            /// The path to the file or directory that you want to delete.
 235            /// </param>
 236            /// <param name='recursive'>
 237            /// Whether to delete children of a directory. If the filePath parameter
 238            /// represents a directory instead of a file, you can set recursive to true to
 239            /// delete the directory and all of the files and subdirectories in it. If
 240            /// recursive is false then the directory must be empty or deletion will fail.
 241            /// </param>
 242            /// <param name='fileDeleteFromComputeNodeOptions'>
 243            /// Additional parameters for the operation
 244            /// </param>
 245            /// <param name='cancellationToken'>
 246            /// The cancellation token.
 247            /// </param>
 248            public static async Task<FileDeleteFromComputeNodeHeaders> DeleteFromComputeNodeAsync(this IFileOperations o
 249            {
 0250                using (var _result = await operations.DeleteFromComputeNodeWithHttpMessagesAsync(poolId, nodeId, filePat
 251                {
 0252                    return _result.Headers;
 253                }
 0254            }
 255
 256            /// <summary>
 257            /// Returns the content of the specified Compute Node file.
 258            /// </summary>
 259            /// <param name='operations'>
 260            /// The operations group for this extension method.
 261            /// </param>
 262            /// <param name='poolId'>
 263            /// The ID of the Pool that contains the Compute Node.
 264            /// </param>
 265            /// <param name='nodeId'>
 266            /// The ID of the Compute Node that contains the file.
 267            /// </param>
 268            /// <param name='filePath'>
 269            /// The path to the Compute Node file that you want to get the content of.
 270            /// </param>
 271            /// <param name='fileGetFromComputeNodeOptions'>
 272            /// Additional parameters for the operation
 273            /// </param>
 274            public static Stream GetFromComputeNode(this IFileOperations operations, string poolId, string nodeId, strin
 275            {
 0276                return operations.GetFromComputeNodeAsync(poolId, nodeId, filePath, fileGetFromComputeNodeOptions).GetAw
 277            }
 278
 279            /// <summary>
 280            /// Returns the content of the specified Compute Node file.
 281            /// </summary>
 282            /// <param name='operations'>
 283            /// The operations group for this extension method.
 284            /// </param>
 285            /// <param name='poolId'>
 286            /// The ID of the Pool that contains the Compute Node.
 287            /// </param>
 288            /// <param name='nodeId'>
 289            /// The ID of the Compute Node that contains the file.
 290            /// </param>
 291            /// <param name='filePath'>
 292            /// The path to the Compute Node file that you want to get the content of.
 293            /// </param>
 294            /// <param name='fileGetFromComputeNodeOptions'>
 295            /// Additional parameters for the operation
 296            /// </param>
 297            /// <param name='cancellationToken'>
 298            /// The cancellation token.
 299            /// </param>
 300            public static async Task<Stream> GetFromComputeNodeAsync(this IFileOperations operations, string poolId, str
 301            {
 0302                var _result = await operations.GetFromComputeNodeWithHttpMessagesAsync(poolId, nodeId, filePath, fileGet
 0303                _result.Request.Dispose();
 0304                return _result.Body;
 0305            }
 306
 307            /// <summary>
 308            /// Gets the properties of the specified Compute Node file.
 309            /// </summary>
 310            /// <param name='operations'>
 311            /// The operations group for this extension method.
 312            /// </param>
 313            /// <param name='poolId'>
 314            /// The ID of the Pool that contains the Compute Node.
 315            /// </param>
 316            /// <param name='nodeId'>
 317            /// The ID of the Compute Node that contains the file.
 318            /// </param>
 319            /// <param name='filePath'>
 320            /// The path to the Compute Node file that you want to get the properties of.
 321            /// </param>
 322            /// <param name='fileGetPropertiesFromComputeNodeOptions'>
 323            /// Additional parameters for the operation
 324            /// </param>
 325            public static FileGetPropertiesFromComputeNodeHeaders GetPropertiesFromComputeNode(this IFileOperations oper
 326            {
 0327                return operations.GetPropertiesFromComputeNodeAsync(poolId, nodeId, filePath, fileGetPropertiesFromCompu
 328            }
 329
 330            /// <summary>
 331            /// Gets the properties of the specified Compute Node file.
 332            /// </summary>
 333            /// <param name='operations'>
 334            /// The operations group for this extension method.
 335            /// </param>
 336            /// <param name='poolId'>
 337            /// The ID of the Pool that contains the Compute Node.
 338            /// </param>
 339            /// <param name='nodeId'>
 340            /// The ID of the Compute Node that contains the file.
 341            /// </param>
 342            /// <param name='filePath'>
 343            /// The path to the Compute Node file that you want to get the properties of.
 344            /// </param>
 345            /// <param name='fileGetPropertiesFromComputeNodeOptions'>
 346            /// Additional parameters for the operation
 347            /// </param>
 348            /// <param name='cancellationToken'>
 349            /// The cancellation token.
 350            /// </param>
 351            public static async Task<FileGetPropertiesFromComputeNodeHeaders> GetPropertiesFromComputeNodeAsync(this IFi
 352            {
 0353                using (var _result = await operations.GetPropertiesFromComputeNodeWithHttpMessagesAsync(poolId, nodeId, 
 354                {
 0355                    return _result.Headers;
 356                }
 0357            }
 358
 359            /// <summary>
 360            /// Lists the files in a Task's directory on its Compute Node.
 361            /// </summary>
 362            /// <param name='operations'>
 363            /// The operations group for this extension method.
 364            /// </param>
 365            /// <param name='jobId'>
 366            /// The ID of the Job that contains the Task.
 367            /// </param>
 368            /// <param name='taskId'>
 369            /// The ID of the Task whose files you want to list.
 370            /// </param>
 371            /// <param name='recursive'>
 372            /// Whether to list children of the Task directory. This parameter can be used
 373            /// in combination with the filter parameter to list specific type of files.
 374            /// </param>
 375            /// <param name='fileListFromTaskOptions'>
 376            /// Additional parameters for the operation
 377            /// </param>
 378            public static IPage<NodeFile> ListFromTask(this IFileOperations operations, string jobId, string taskId, boo
 379            {
 0380                return operations.ListFromTaskAsync(jobId, taskId, recursive, fileListFromTaskOptions).GetAwaiter().GetR
 381            }
 382
 383            /// <summary>
 384            /// Lists the files in a Task's directory on its Compute Node.
 385            /// </summary>
 386            /// <param name='operations'>
 387            /// The operations group for this extension method.
 388            /// </param>
 389            /// <param name='jobId'>
 390            /// The ID of the Job that contains the Task.
 391            /// </param>
 392            /// <param name='taskId'>
 393            /// The ID of the Task whose files you want to list.
 394            /// </param>
 395            /// <param name='recursive'>
 396            /// Whether to list children of the Task directory. This parameter can be used
 397            /// in combination with the filter parameter to list specific type of files.
 398            /// </param>
 399            /// <param name='fileListFromTaskOptions'>
 400            /// Additional parameters for the operation
 401            /// </param>
 402            /// <param name='cancellationToken'>
 403            /// The cancellation token.
 404            /// </param>
 405            public static async Task<IPage<NodeFile>> ListFromTaskAsync(this IFileOperations operations, string jobId, s
 406            {
 0407                using (var _result = await operations.ListFromTaskWithHttpMessagesAsync(jobId, taskId, recursive, fileLi
 408                {
 0409                    return _result.Body;
 410                }
 0411            }
 412
 413            /// <summary>
 414            /// Lists all of the files in Task directories on the specified Compute Node.
 415            /// </summary>
 416            /// <param name='operations'>
 417            /// The operations group for this extension method.
 418            /// </param>
 419            /// <param name='poolId'>
 420            /// The ID of the Pool that contains the Compute Node.
 421            /// </param>
 422            /// <param name='nodeId'>
 423            /// The ID of the Compute Node whose files you want to list.
 424            /// </param>
 425            /// <param name='recursive'>
 426            /// Whether to list children of a directory.
 427            /// </param>
 428            /// <param name='fileListFromComputeNodeOptions'>
 429            /// Additional parameters for the operation
 430            /// </param>
 431            public static IPage<NodeFile> ListFromComputeNode(this IFileOperations operations, string poolId, string nod
 432            {
 0433                return operations.ListFromComputeNodeAsync(poolId, nodeId, recursive, fileListFromComputeNodeOptions).Ge
 434            }
 435
 436            /// <summary>
 437            /// Lists all of the files in Task directories on the specified Compute Node.
 438            /// </summary>
 439            /// <param name='operations'>
 440            /// The operations group for this extension method.
 441            /// </param>
 442            /// <param name='poolId'>
 443            /// The ID of the Pool that contains the Compute Node.
 444            /// </param>
 445            /// <param name='nodeId'>
 446            /// The ID of the Compute Node whose files you want to list.
 447            /// </param>
 448            /// <param name='recursive'>
 449            /// Whether to list children of a directory.
 450            /// </param>
 451            /// <param name='fileListFromComputeNodeOptions'>
 452            /// Additional parameters for the operation
 453            /// </param>
 454            /// <param name='cancellationToken'>
 455            /// The cancellation token.
 456            /// </param>
 457            public static async Task<IPage<NodeFile>> ListFromComputeNodeAsync(this IFileOperations operations, string p
 458            {
 0459                using (var _result = await operations.ListFromComputeNodeWithHttpMessagesAsync(poolId, nodeId, recursive
 460                {
 0461                    return _result.Body;
 462                }
 0463            }
 464
 465            /// <summary>
 466            /// Lists the files in a Task's directory on its Compute Node.
 467            /// </summary>
 468            /// <param name='operations'>
 469            /// The operations group for this extension method.
 470            /// </param>
 471            /// <param name='nextPageLink'>
 472            /// The NextLink from the previous successful call to List operation.
 473            /// </param>
 474            /// <param name='fileListFromTaskNextOptions'>
 475            /// Additional parameters for the operation
 476            /// </param>
 477            public static IPage<NodeFile> ListFromTaskNext(this IFileOperations operations, string nextPageLink, FileLis
 478            {
 0479                return operations.ListFromTaskNextAsync(nextPageLink, fileListFromTaskNextOptions).GetAwaiter().GetResul
 480            }
 481
 482            /// <summary>
 483            /// Lists the files in a Task's directory on its Compute Node.
 484            /// </summary>
 485            /// <param name='operations'>
 486            /// The operations group for this extension method.
 487            /// </param>
 488            /// <param name='nextPageLink'>
 489            /// The NextLink from the previous successful call to List operation.
 490            /// </param>
 491            /// <param name='fileListFromTaskNextOptions'>
 492            /// Additional parameters for the operation
 493            /// </param>
 494            /// <param name='cancellationToken'>
 495            /// The cancellation token.
 496            /// </param>
 497            public static async Task<IPage<NodeFile>> ListFromTaskNextAsync(this IFileOperations operations, string next
 498            {
 0499                using (var _result = await operations.ListFromTaskNextWithHttpMessagesAsync(nextPageLink, fileListFromTa
 500                {
 0501                    return _result.Body;
 502                }
 0503            }
 504
 505            /// <summary>
 506            /// Lists all of the files in Task directories on the specified Compute Node.
 507            /// </summary>
 508            /// <param name='operations'>
 509            /// The operations group for this extension method.
 510            /// </param>
 511            /// <param name='nextPageLink'>
 512            /// The NextLink from the previous successful call to List operation.
 513            /// </param>
 514            /// <param name='fileListFromComputeNodeNextOptions'>
 515            /// Additional parameters for the operation
 516            /// </param>
 517            public static IPage<NodeFile> ListFromComputeNodeNext(this IFileOperations operations, string nextPageLink, 
 518            {
 0519                return operations.ListFromComputeNodeNextAsync(nextPageLink, fileListFromComputeNodeNextOptions).GetAwai
 520            }
 521
 522            /// <summary>
 523            /// Lists all of the files in Task directories on the specified Compute Node.
 524            /// </summary>
 525            /// <param name='operations'>
 526            /// The operations group for this extension method.
 527            /// </param>
 528            /// <param name='nextPageLink'>
 529            /// The NextLink from the previous successful call to List operation.
 530            /// </param>
 531            /// <param name='fileListFromComputeNodeNextOptions'>
 532            /// Additional parameters for the operation
 533            /// </param>
 534            /// <param name='cancellationToken'>
 535            /// The cancellation token.
 536            /// </param>
 537            public static async Task<IPage<NodeFile>> ListFromComputeNodeNextAsync(this IFileOperations operations, stri
 538            {
 0539                using (var _result = await operations.ListFromComputeNodeNextWithHttpMessagesAsync(nextPageLink, fileLis
 540                {
 0541                    return _result.Body;
 542                }
 0543            }
 544
 545    }
 546}
Generated by: ReportGenerator 4.6.4.0
8/12/2020 - 3:47:11 PM
GitHub | www.palmmedia.de

Methods/Properties

DeleteFromTask(...)
DeleteFromTaskAsync()
GetFromTask(...)
GetFromTaskAsync()
GetPropertiesFromTask(...)
GetPropertiesFromTaskAsync()
DeleteFromComputeNode(...)
DeleteFromComputeNodeAsync()
GetFromComputeNode(...)
GetFromComputeNodeAsync()
GetPropertiesFromComputeNode(...)
GetPropertiesFromComputeNodeAsync()
ListFromTask(...)
ListFromTaskAsync()
ListFromComputeNode(...)
ListFromComputeNodeAsync()
ListFromTaskNext(...)
ListFromTaskNextAsync()
ListFromComputeNodeNext(...)
ListFromComputeNodeNextAsync()