Exemple #1
0
        /// <summary>
        /// Starts all of the necessary operations to rename the directory <paramref name="oldLeafName"/> to
        /// the <paramref name="newLeafName"/> name. This includes renaming the directory and all subdirectories and files
        /// under the directory being renamed.
        /// </summary>
        /// <param name="bucket">The bucket where the directory to rename resides.</param>
        /// <param name="parentName">The parent directory of the directory being renamed.</param>
        /// <param name="oldLeafName">The old (current) name of the directory.</param>
        /// <param name="newLeafName">The new name for the directory.</param>
        /// <param name="cancellationToken">The cancellation token for the operaitons.</param>
        /// <returns></returns>
        public async Task <OperationsQueue> StartDirectoryRenameOperationsAsync(
            string bucket,
            string parentName,
            string oldLeafName,
            string newLeafName,
            CancellationToken cancellationToken)
        {
            var oldNamePrefix = GcsPathUtils.Combine(parentName, oldLeafName) + "/";
            var newNamePrefix = GcsPathUtils.Combine(parentName, newLeafName) + "/";

            var filesToMove = await GetGcsFilesFromPrefixAsync(bucket, oldNamePrefix);

            var moveOperations = new List <GcsMoveFileOperation>();

            foreach (var file in filesToMove)
            {
                var movedName = newNamePrefix + file.Name.Substring(oldNamePrefix.Length);
                var movedItem = new GcsItemRef(bucket, movedName);
                moveOperations.Add(new GcsMoveFileOperation(file, movedItem));
            }

            var operationsQueue = new OperationsQueue(cancellationToken);

            operationsQueue.EnqueueOperations(moveOperations, _dataSource.StartMoveOperation);
            operationsQueue.StartOperations();
            return(operationsQueue);
        }
Exemple #2
0
        /// <summary>
        /// Starts the file upload operations for the given file sources, does not wait for the operations to complete.
        /// </summary>
        /// <param name="sources">The files, or directories, to upload.</param>
        /// <param name="bucket">The destination bucket.</param>
        /// <param name="bucketPath">The destination path in the bucket.</param>
        /// <param name="cancellationToken">The cancellation token source to use for the operations.</param>
        /// <returns>The list of operations started.</returns>
        public OperationsQueue StartUploadOperations(
            IEnumerable <string> sources,
            string bucket,
            string bucketPath,
            CancellationToken cancellationToken)
        {
            var uploadOperations = CreateUploadOperations(sources, bucket: bucket, bucketPath: bucketPath);
            var operationsQueue  = new OperationsQueue(cancellationToken);

            operationsQueue.EnqueueOperations(uploadOperations, _dataSource.StartFileUploadOperation);
            operationsQueue.StartOperations();
            return(operationsQueue);
        }
Exemple #3
0
        /// <summary>
        /// Starts a set of download operations for files and directories stored on GCS. It will enumerate
        /// all of the directories and subdirectories specified as well as all of the files stored.
        /// </summary>
        /// <param name="sources">The list of files or directories to download.</param>
        /// <param name="destinationDir">Where to store the downloaded files.</param>
        /// <param name="cancellationToken">The cancellation token for the operation.</param>
        /// <returns>The list of operations started.</returns>
        public async Task <OperationsQueue> StartDownloadOperationsAsync(
            IEnumerable <GcsItemRef> sources,
            string destinationDir,
            CancellationToken cancellationToken)
        {
            List <GcsFileTransferOperation> downloadOperations = new List <GcsFileTransferOperation>(
                sources
                .Where(x => x.IsFile)
                .Select(x => new GcsFileTransferOperation(
                            localPath: Path.Combine(destinationDir, GcsPathUtils.GetFileName(x.Name)),
                            gcsItem: x)));

            // Collect all of the files from all of the directories to download, collects all of the
            // local file system directories that need to be created to mirror the source structure.
            var subDirs = new HashSet <string>();

            foreach (var dir in sources.Where(x => x.IsDirectory))
            {
                var files = await GetGcsFilesFromPrefixAsync(dir.Bucket, dir.Name);

                foreach (var file in files)
                {
                    var relativeFilePath = Path.Combine(
                        GcsPathUtils.GetFileName(dir.Name),
                        GetRelativeName(file.Name, dir.Name).Replace('/', '\\'));
                    var absoluteFilePath = Path.Combine(destinationDir, relativeFilePath);

                    // Create the file operation for this file.
                    downloadOperations.Add(new GcsFileTransferOperation(
                                               localPath: absoluteFilePath,
                                               gcsItem: file));

                    // Collects the list of directories to create.
                    subDirs.Add(Path.GetDirectoryName(absoluteFilePath));
                }
            }

            // Create all of the directories.
            foreach (var dir in subDirs)
            {
                Directory.CreateDirectory(dir);
            }

            var operationsQueue = new OperationsQueue(cancellationToken);

            operationsQueue.EnqueueOperations(downloadOperations, _dataSource.StartFileDownloadOperation);
            operationsQueue.StartOperations();
            return(operationsQueue);
        }
Exemple #4
0
        /// <summary>
        /// Enumerates all of the files and directories and starts the operations to delete them.
        /// </summary>
        /// <param name="sources">The list of sources to delete.</param>
        /// <param name="cancellationToken">The cancellation token to use for the operations.</param>
        /// <returns>The list of operations started.</returns>
        public async Task <OperationsQueue> StartDeleteOperationsAsync(
            IEnumerable <GcsItemRef> sources,
            CancellationToken cancellationToken)
        {
            var deleteOperations = new List <GcsDeleteFileOperation>(sources
                                                                     .Where(x => x.IsFile)
                                                                     .Select(x => new GcsDeleteFileOperation(x)));

            foreach (var dir in sources.Where(x => x.IsDirectory))
            {
                var filesInPrefix = await GetGcsFilesFromPrefixAsync(dir.Bucket, dir.Name);

                deleteOperations.AddRange(filesInPrefix.Select(x => new GcsDeleteFileOperation(x)));
            }

            var operationsQueue = new OperationsQueue(cancellationToken);

            operationsQueue.EnqueueOperations(deleteOperations, _dataSource.StartDeleteOperation);
            operationsQueue.StartOperations();
            return(operationsQueue);
        }