private static long ToId(DirectoryId folderId) { if (!folderId.Value.StartsWith("d", StringComparison.Ordinal)) throw new FormatException(string.Format(CultureInfo.InvariantCulture, Resources.InvalidFolderId, folderId)); return long.Parse(folderId.Value.Substring(1), NumberStyles.Number); }
public async Task <FileInfoContract> NewFileItemAsync(RootName root, DirectoryId parent, string name, Stream content, IProgress <ProgressValue> progress) { if (content.Length == 0) { return(new ProxyFileInfoContract(name)); } var context = await RequireContextAsync(root); var file = new GoogleFile() { Name = name, MimeType = MIME_TYPE_FILE, Parents = new[] { parent.Value } }; var insert = context.Service.Files.Create(file, content, MIME_TYPE_FILE).AsFile(); if (progress != null) { insert.ProgressChanged += p => progress.Report(new ProgressValue((int)p.BytesSent, (int)content.Length)); } var upload = await AsyncFunc.RetryAsync <IUploadProgress, GoogleApiException>(async() => await insert.UploadAsync(), RETRIES); var item = insert.ResponseBody; return(new FileInfoContract(item.Id, item.Name, new DateTimeOffset(item.CreatedTime.Value), new DateTimeOffset(item.ModifiedTime.Value), item.Size.Value, item.Md5Checksum)); }
public async Task <FileInfoContract> NewFileItemAsync(RootName root, DirectoryId parent, string name, Stream content, IProgress <ProgressValue> progress) { if (content.Length == 0) { return(new ProxyFileInfoContract(name)); } var context = await RequireContextAsync(root); var item = default(Item); var requestBuilder = context.Client.Drive.Items[parent.Value].ItemWithPath(name); if (content.Length <= LargeFileThreshold) { var stream = progress != null ? new ProgressStream(content, progress) : content; var retryPolicyWithAction = Policy.Handle <ServiceException>().WaitAndRetryAsync(5, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), (ex, ts) => content.Seek(0, SeekOrigin.Begin)); item = await retryPolicyWithAction.ExecuteAsync(() => requestBuilder.Content.Request().PutAsync <Item>(stream)); } else { var session = await requestBuilder.CreateSession().Request().PostAsync(); var provider = new ChunkedUploadProvider(session, context.Client, content); item = await ChunkedUploadAsync(provider, progress); } return(new FileInfoContract(item.Id, item.Name, item.CreatedDateTime ?? DateTimeOffset.FromFileTime(0), item.LastModifiedDateTime ?? DateTimeOffset.FromFileTime(0), (FileSize)(item.Size ?? -1), item.File.Hashes.Sha1Hash.ToLowerInvariant())); }
public async Task <FileInfoContract> NewFileItemAsync(RootName root, DirectoryId parent, string name, Stream content, IProgress <ProgressValue> progress) { if (content.Length == 0) { return(new ProxyFileInfoContract(name)); } var context = await RequireContextAsync(root); var objectId = parent.GetObjectId(name); var length = content.Length; var item = default(SwiftResponse); var retryPolicyWithAction = Policy.Handle <Exception>().WaitAndRetryAsync(5, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), (ex, ts) => content.Seek(0, SeekOrigin.Begin)); if (length <= LargeFileThreshold) { var stream = progress != null ? new ProgressStream(content, progress) : content; item = await retryPolicyWithAction.ExecuteAsync(() => context.Client.PutObject(context.Container, objectId, stream)); if (!item.IsSuccess) { throw new ApplicationException(item.Reason); } } else { item = await retryPolicyWithAction.ExecuteAsync(() => ChunkedUpload(context, objectId, content, progress)); } var creationTime = DateTime.Parse(item.Headers["Date"]); return(new FileInfoContract(objectId, name, creationTime, creationTime, (FileSize)length, item.Headers["ETag"])); }
public async Task <FileSystemInfoContract> MoveItemAsync(RootName root, FileSystemId source, string moveName, DirectoryId destination, Func <FileSystemInfoLocator> locatorResolver) { // Emulate MoveItem through CopyItem + RemoveItem var context = await RequireContextAsync(root); var sourceObjectId = new StorageObjectId(source.Value); var destinationObjectId = new StorageObjectId(destination.Value); var directorySource = source as DirectoryId; if (directorySource != null) { moveName += Path.AltDirectorySeparatorChar; } var item = await retryPolicy.ExecuteAsync(() => context.Client.CopyObjectAsync(sourceObjectId.Bucket, sourceObjectId.Path, destinationObjectId.Bucket, $"{destinationObjectId.Path}{moveName}")); if (directorySource != null) { var subDestination = new DirectoryId(item.Id); foreach (var subItem in await GetChildItemAsync(root, directorySource)) { await retryPolicy.ExecuteAsync(() => MoveItemAsync(root, subItem.Id, subItem.Name, subDestination, locatorResolver)); } } await retryPolicy.ExecuteAsync(() => context.Client.DeleteObjectAsync(sourceObjectId.Bucket, sourceObjectId.Path)); return(item.ToFileSystemInfoContract()); }
public async Task <FileInfoContract> NewFileItemAsync(RootName root, DirectoryId parent, string name, Stream content, IProgress <ProgressValue> progress) { if (content.Length == 0) { return(new ProxyFileInfoContract(name)); } var context = await RequireContextAsync(root); var objectId = parent.GetObjectId(name); var length = content.Length; var item = default(SwiftResponse); if (length <= LARGE_FILE_THRESHOLD) { var stream = progress != null ? new ProgressStream(content, progress) : content; item = await AsyncFunc.RetryAsync <SwiftResponse, Exception>(async() => await context.Client.PutObject(context.Container, objectId, stream), RETRIES); if (!item.IsSuccess) { throw new ApplicationException(item.Reason); } } else { item = await AsyncFunc.RetryAsync <SwiftResponse, Exception>(async() => await ChunkedUpload(context, objectId, content, progress), RETRIES); } var creationTime = DateTime.Parse(item.Headers["Date"]); return(new FileInfoContract(objectId, name, creationTime, creationTime, length, item.Headers["ETag"])); }
public IEnumerable <FileSystemInfoContract> GetChildItem(RootName root, DirectoryId parent) { if (root == null) { throw new ArgumentNullException(nameof(root)); } if (parent == null) { throw new ArgumentNullException(nameof(parent)); } var effectivePath = GetFullPath(root, parent.Value); var directory = new DirectoryInfo(effectivePath); if (directory.Exists) { return(directory.EnumerateDirectories().Select(d => new DirectoryInfoContract(GetRelativePath(root, d.FullName), d.Name, d.CreationTime, d.LastWriteTime)).Cast <FileSystemInfoContract>().Concat( directory.EnumerateFiles().Select(f => new FileInfoContract(GetRelativePath(root, f.FullName), f.Name, f.CreationTime, f.LastWriteTime, f.Length, null)).Cast <FileSystemInfoContract>())); } else { return new FileSystemInfoContract[] { } }; }
public IEnumerable <FileSystemInfoContract> GetChildItem(RootName root, DirectoryId parent) { if (root == null) { throw new ArgumentNullException(nameof(root)); } if (parent == null) { throw new ArgumentNullException(nameof(parent)); } if (string.IsNullOrEmpty(rootPath)) { throw new InvalidOperationException($"{nameof(rootPath)} not initialized".ToString(CultureInfo.CurrentCulture)); } var effectivePath = GetFullPath(rootPath, parent.Value); var directory = new DirectoryInfo(effectivePath); if (directory.Exists) { return(directory.EnumerateDirectories().Select(d => new DirectoryInfoContract(GetRelativePath(rootPath, d.FullName), d.Name, d.CreationTime, d.LastWriteTime)).Cast <FileSystemInfoContract>().Concat( directory.EnumerateFiles().Select(f => new FileInfoContract(GetRelativePath(rootPath, f.FullName), f.Name, f.CreationTime, f.LastWriteTime, f.Length, null)).Cast <FileSystemInfoContract>())); } else { return(Array.Empty <FileSystemInfoContract>()); } }
public Mock <IAsyncCloudGateway> InitializeGetChildItemsAsyncWithFilter(RootName rootName, string path, string filter, params IEnumerable <FileSystemInfoContract>[] pathChildItems) { var gatewayMock = new Mock <IAsyncCloudGateway>(MockBehavior.Strict); gatewayMock.SetupSequence(g => g.GetRootAsync(rootName, FileSystemFixture.ApiKey)) .ReturnsAsync(FileSystemFixture.Root) .ThrowsAsync(new InvalidOperationException("Redundant call to GetRoot()")); gatewayMock.SetupSequence(g => g.GetDriveAsync(rootName, FileSystemFixture.ApiKey)) .ReturnsAsync(FileSystemFixture.Drive) .Throws(new InvalidOperationException("Redundant call to GetDrive()")); if (path != null) { path = path + Path.DirectorySeparatorChar; for (int i = 0, j = 0; i >= 0; i = path.IndexOf(Path.DirectorySeparatorChar, Math.Min(path.Length, i + 2)), ++j) { var currentPath = new DirectoryId(path.Substring(0, Math.Max(1, i))); bool applyFilter = j == pathChildItems.Length - 1; var effectiveFilter = applyFilter && filter != null ? new Regex("^" + filter.Replace("*", ".*") + "$") : null; gatewayMock.SetupSequence(g => g.GetChildItemAsync(rootName, currentPath)) .ReturnsAsync(applyFilter ? pathChildItems[j].Where(f => effectiveFilter == null || effectiveFilter.IsMatch(f.Name)) : pathChildItems[j]) .ThrowsAsync(new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, "Redundant access to {0}", currentPath))); } } return(gatewayMock); }
public Mock<ICloudGateway> InitializeGetChildItemsWithFilter(RootName rootName, string path, string filter, params IEnumerable<FileSystemInfoContract>[] pathChildItems) { var gatewayMock = new Mock<ICloudGateway>(MockBehavior.Strict); gatewayMock.SetupSequence(g => g.GetRoot(rootName, FileSystemFixture.ApiKey)) .Returns(FileSystemFixture.Root) .Throws(new InvalidOperationException(@"Redundant call to GetRoot()")); gatewayMock.SetupSequence(g => g.GetDrive(rootName, FileSystemFixture.ApiKey)) .Returns(FileSystemFixture.Drive) .Throws(new InvalidOperationException(@"Redundant call to GetDrive()")); if (path != null) { path = path + Path.DirectorySeparatorChar; for (int i = 0, j = 0; i >= 0; i = path.IndexOf(Path.DirectorySeparatorChar, Math.Min(path.Length, i + 2)), ++j) { var currentPath = new DirectoryId(path.Substring(0, Math.Max(1, i))); bool applyFilter = j == pathChildItems.Length - 1; var effectiveFilter = applyFilter && filter != null ? new Regex("^" + filter.Replace("*", ".*") + "$") : null; gatewayMock.SetupSequence(g => g.GetChildItem(rootName, currentPath)) .Returns(applyFilter ? pathChildItems[j].Where(f => effectiveFilter == null || effectiveFilter.IsMatch(f.Name)) : pathChildItems[j]) .Throws(new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, @"Redundant access to {0}", currentPath))); } } return gatewayMock; }
public async Task <FileInfoContract> NewFileItemAsync(RootName root, DirectoryId parent, string name, Stream content, IProgress <ProgressValue> progress) { if (content.Length == 0) { return(new ProxyFileInfoContract(name)); } var context = await RequireContextAsync(root); var item = default(Item); var requestBuilder = context.Client.Drive.Items[parent.Value].ItemWithPath(name); if (content.Length <= LARGE_FILE_THRESHOLD) { var stream = progress != null ? new ProgressStream(content, progress) : content; item = await AsyncFunc.RetryAsync <Item, ServiceException>(async() => await requestBuilder.Content.Request().PutAsync <Item>(stream), RETRIES); } else { var session = await requestBuilder.CreateSession().Request().PostAsync(); var provider = new ChunkedUploadProvider(session, context.Client, content); item = await ChunkedUploadAsync(provider, progress, RETRIES); } return(new FileInfoContract(item.Id, item.Name, item.CreatedDateTime ?? DateTimeOffset.FromFileTime(0), item.LastModifiedDateTime ?? DateTimeOffset.FromFileTime(0), item.Size ?? -1, item.File.Hashes.Sha1Hash.ToLowerInvariant())); }
public DirectoryInfoContract NewDirectoryItem(RootName root, DirectoryId parent, string name) { if (root == null) { throw new ArgumentNullException(nameof(root)); } if (parent == null) { throw new ArgumentNullException(nameof(parent)); } if (string.IsNullOrEmpty(name)) { throw new ArgumentNullException(nameof(name)); } if (string.IsNullOrEmpty(rootPath)) { throw new InvalidOperationException($"{nameof(rootPath)} not initialized".ToString(CultureInfo.CurrentCulture)); } var effectivePath = GetFullPath(rootPath, Path.Combine(parent.Value, name)); var directory = new DirectoryInfo(effectivePath); if (directory.Exists) { throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, Properties.Resources.DuplicatePath, effectivePath)); } directory.Create(); return(new DirectoryInfoContract(GetRelativePath(rootPath, directory.FullName), directory.Name, directory.CreationTime, directory.LastWriteTime)); }
private void DoTestRenderer(PathTable pathTable, PipFragmentRenderer renderer, string expectedHash) { // StringId var strValue = "my string"; XAssert.AreEqual(strValue, renderer.Render(PipFragment.FromString(strValue, pathTable.StringTable))); var pathStr = A("t", "file1.txt"); var path = AbsolutePath.Create(pathTable, pathStr); var srcFile = FileArtifact.CreateSourceFile(path); var outFile = FileArtifact.CreateOutputFile(srcFile); var rwFile = outFile.CreateNextWrittenVersion(); var rw2File = rwFile.CreateNextWrittenVersion(); var opaqueDir = DirectoryArtifact.CreateDirectoryArtifactForTesting(path, 0); var sharedDir = new DirectoryArtifact(path, 1, isSharedOpaque: true); // AbsolutePath XAssert.AreEqual(pathStr, renderer.Render(PipFragment.FromAbsolutePathForTesting(path))); XAssert.AreEqual(pathStr, renderer.Render(PipFragment.FromAbsolutePathForTesting(srcFile))); XAssert.AreEqual(pathStr, renderer.Render(PipFragment.FromAbsolutePathForTesting(outFile))); XAssert.AreEqual(pathStr, renderer.Render(PipFragment.FromAbsolutePathForTesting(rwFile))); XAssert.AreEqual(pathStr, renderer.Render(PipFragment.FromAbsolutePathForTesting(rw2File))); // VsoHash XAssert.AreEqual(expectedHash, renderer.Render(PipFragment.VsoHashFromFileForTesting(srcFile))); XAssert.AreEqual(expectedHash, renderer.Render(PipFragment.VsoHashFromFileForTesting(outFile))); XAssert.AreEqual(expectedHash, renderer.Render(PipFragment.VsoHashFromFileForTesting(rwFile))); XAssert.AreEqual(expectedHash, renderer.Render(PipFragment.VsoHashFromFileForTesting(rw2File))); XAssert.AreEqual(DirectoryId.ToString(opaqueDir), renderer.Render(PipFragment.DirectoryIdForTesting(opaqueDir))); XAssert.AreEqual(DirectoryId.ToString(sharedDir), renderer.Render(PipFragment.DirectoryIdForTesting(sharedDir))); }
public FileInfoContract NewFileItem(RootName root, DirectoryId parent, string name, Stream content, IProgress <ProgressValue> progress) { if (root == null) { throw new ArgumentNullException(nameof(root)); } if (parent == null) { throw new ArgumentNullException(nameof(parent)); } if (string.IsNullOrEmpty(name)) { throw new ArgumentNullException(nameof(name)); } var effectivePath = GetFullPath(root, Path.Combine(parent.Value, name)); var file = new FileInfo(effectivePath); if (file.Exists) { throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, Resource.DuplicatePath, parent.Value)); } using (var fileStream = file.Create()) { if (content != null) { content.CopyTo(fileStream); } } file.Refresh(); return(new FileInfoContract(GetRelativePath(root, file.FullName), file.Name, file.CreationTime, file.LastWriteTime, file.Length, null)); }
public async Task <FileInfoContract> NewFileItemAsync(RootName root, DirectoryId parent, string name, Stream content, IProgress <ProgressValue> progress) { if (content.Length == 0) { return(new ProxyFileInfoContract(name)); } var context = await RequireContextAsync(root); var file = new GoogleFile() { Title = name, MimeType = MIME_TYPE_FILE, Parents = new[] { new ParentReference() { Id = parent.Value } } }; var insert = context.Service.Files.Insert(file, content, MIME_TYPE_FILE); if (progress != null) { insert.ProgressChanged += p => progress.Report(new ProgressValue((int)p.BytesSent, (int)content.Length)); } var retryPolicyWithAction = Policy.Handle <GoogleApiException>().WaitAndRetryAsync(5, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), (ex, ts) => content.Seek(0, SeekOrigin.Begin)); var upload = await retryPolicyWithAction.ExecuteAsync(() => insert.UploadAsync()); var item = insert.ResponseBody; return(new FileInfoContract(item.Id, item.Title, new DateTimeOffset(item.CreatedDate.Value), new DateTimeOffset(item.ModifiedDate.Value), (FileSize)item.FileSize.Value, item.Md5Checksum)); }
public async Task <FileInfoContract> NewFileItemAsync(RootName root, DirectoryId parent, string name, Stream content, IProgress <ProgressValue> progress) { if (content.Length == 0) { return(new ProxyFileInfoContract(name)); } var context = await RequireContextAsync(root); var config = await context.Agent.Upload.GetUploadConfiguration(WebUtility.UrlEncode(name), content.Length, parent.Value, MediaFireActionOnDuplicate.Skip); var mediaFireProgress = progress != null ? new Progress <MediaFireOperationProgress>(p => progress.Report(new ProgressValue((int)p.CurrentSize, (int)p.TotalSize))) : null; var upload = await context.Agent.Upload.Simple(config, content, mediaFireProgress); while (!(upload.IsComplete && upload.IsSuccess)) { await Task.Delay(100); upload = await context.Agent.Upload.PollUpload(upload.Key); } var item = await context.Agent.GetAsync <MediaFireGetFileInfoResponse>(MediaFireApiFileMethods.GetInfo, new Dictionary <string, object>() { [MediaFireApiParameters.QuickKey] = upload.QuickKey }); return(new FileInfoContract(item.FileInfo.QuickKey, WebUtility.UrlDecode(item.FileInfo.Name), item.FileInfo.Created, item.FileInfo.Created, item.FileInfo.Size, item.FileInfo.Hash)); }
public bool Equals(DirectoryInfoEx other) { return(other != null && DirectoryDbId.Equals(other.DirectoryDbId) && DirectoryId.Equals(other.DirectoryId) && EqualityComparer <DirectoryInfo> .Default.Equals(DirectoryInfo, other.DirectoryInfo) && EqualityComparer <IEnumerable <Exception> > .Default.Equals(Exceptions, other.Exceptions)); }
public async Task <FileInfoContract> NewFileItemAsync(RootName root, DirectoryId parent, string name, Stream content, IProgress <ProgressValue> progress) { var context = await RequireContext(root); var item = await AsyncFunc.Retry <FileSystem, ServerException>(async() => await context.Client.FileSystemManager.UploadNewFileStreamAsync(parent.Value, name, new ProgressStream(content, progress), true), RETRIES); return(new FileInfoContract(item.Id, item.Name, item.DateLastSynced, FileSystemExtensions.Later(item.DateLastSynced, item.ModifiedTime), item.Size, null)); }
public FileInfoContract NewFileItem(RootName root, DirectoryId parent, string name, System.IO.Stream content, IProgress <ProgressValue> progress) { var contract = _localState.NewFileItem(root, parent, name, content, progress); _contentCache[contract.Id] = content.ReadFully(); return(contract); }
private static long ToId(DirectoryId folderId) { if (!folderId.Value.StartsWith("d", StringComparison.Ordinal)) { throw new FormatException(string.Format(CultureInfo.InvariantCulture, Properties.Resources.InvalidFolderId, folderId)); } return(long.Parse(folderId.Value.Substring(1), NumberStyles.Number)); }
public FileSystemInfoLocator(FileSystemInfoContract fileSystem) { if (fileSystem == null) throw new ArgumentNullException(nameof(fileSystem)); Id = fileSystem.Id; Name = fileSystem.Name; ParentId = (fileSystem as DirectoryInfoContract)?.Parent.Id ?? (fileSystem as FileInfoContract)?.Directory.Id; }
public async Task <FileInfoContract> NewFileItemAsync(RootName root, DirectoryId parent, string name, Stream content, IProgress <ProgressValue> progress) { var context = await RequireContext(root); var tokenSource = new CancellationTokenSource(); var item = await AsyncFunc.Retry <pCloudFile, pCloudException>(async() => await context.Client.UploadFileAsync(new ProgressStream(content, progress), ToId(parent), name, tokenSource.Token), RETRIES); return(new FileInfoContract(item.Id, item.Name, item.Created, item.Modified, item.Size, null)); }
public FileInfoContract SetupNewFile(DirectoryId parentId, string fileName) { var file = new FileInfoContract($"{parentId.Value.TrimEnd('\\')}\\{fileName}".ToString(CultureInfo.CurrentCulture), fileName, "2016-02-01 12:00:00".ToDateTime(), "2016-02-01 12:00:00".ToDateTime(), FileSize.Empty, null); _drive .Setup(drive => drive.NewFileItem(It.Is <DirectoryInfoContract>(parent => parent.Id == parentId), fileName, It.Is <Stream>(s => s.Length == 0))) .Returns(file) .Verifiable(); return(file); }
private GetSealedDirectoryContentCommand ReceiveGetSealedDirectoryContentCommandAndCheckItMatchesDirectoryId(string payload, string expectedDirectoryId) { var cmd = global::BuildXL.Ipc.ExternalApi.Commands.Command.Deserialize(payload); XAssert.AreEqual(typeof(GetSealedDirectoryContentCommand), cmd.GetType()); var getSealedDirectoryCmd = (GetSealedDirectoryContentCommand)cmd; XAssert.AreEqual(expectedDirectoryId, DirectoryId.ToString(getSealedDirectoryCmd.Directory)); return(getSealedDirectoryCmd); }
public IEnumerable <FileSystemInfoContract> GetChildItem(RootName root, DirectoryId parent) { var context = RequireContext(root); var nodes = context.Client.GetNodes(); var parentItem = nodes.Single(n => n.Id == parent.Value); var items = context.Client.GetNodes(parentItem); return(items.Select(i => i.ToFileSystemInfoContract())); }
public DirectoryInfoContract NewDirectoryItem(RootName root, DirectoryId parent, string name) { var context = RequireContext(root); var nodes = context.Client.GetNodes(); var parentItem = nodes.Single(n => n.Id == parent.Value); var item = context.Client.CreateFolder(name, parentItem); return(new DirectoryInfoContract(item.Id, item.Name, DateTimeOffset.MinValue, item.LastModificationDate)); }
public FileInfoContract NewFileItem(RootName root, DirectoryId parent, string name, Stream content, IProgress <ProgressValue> progress) { var context = RequireContext(root); var nodes = context.Client.GetNodes(); var parentItem = nodes.Single(n => n.Id == parent.Value); var item = context.Client.Upload(new ProgressStream(content, progress), name, parentItem); return(new FileInfoContract(item.Id, item.Name, DateTimeOffset.MinValue, item.LastModificationDate, item.Size, null)); }
public DirectoryInfoContract SetupNewDirectory(string parentName, string directoryName) { var parentId = new DirectoryId(parentName); var directory = new DirectoryInfoContract($"{parentId.Value}{directoryName}\\".ToString(CultureInfo.CurrentCulture), directoryName, "2016-01-01 12:00:00".ToDateTime(), "2016-01-01 12:00:00".ToDateTime()); _drive .Setup(drive => drive.NewDirectoryItem(It.Is <DirectoryInfoContract>(parent => parent.Id == parentId), directoryName)) .Returns(directory) .Verifiable(); return(directory); }
/// <summary> /// Initializes a new instance of the <see cref="FileSystemInfoLocator"/> class. /// </summary> /// <param name="fileSystem">The file system info object.</param> /// <exception cref="ArgumentNullException">The filesystem is <c>null</c>.</exception> public FileSystemInfoLocator(FileSystemInfoContract fileSystem) { if (fileSystem == null) { throw new ArgumentNullException(nameof(fileSystem)); } Id = fileSystem.Id; Name = fileSystem.Name; ParentId = (fileSystem as DirectoryInfoContract)?.Parent.Id ?? (fileSystem as FileInfoContract)?.Directory.Id; }
public async Task <FileInfoContract> NewFileItemAsync(RootName root, DirectoryId parent, string name, Stream content, IProgress <ProgressValue> progress) { if (content.Length == 0) { return(new ProxyFileInfoContract(name)); } var context = await RequireContextAsync(root); var item = await AsyncFunc.RetryAsync <Item, OneDriveException>(async() => await context.Client.Drive.Items[parent.Value].ItemWithPath(name).Content.Request().PutAsync <Item>(content), RETRIES); return(new FileInfoContract(item.Id, item.Name, item.CreatedDateTime ?? DateTimeOffset.FromFileTime(0), item.LastModifiedDateTime ?? DateTimeOffset.FromFileTime(0), item.Size ?? -1, item.File.Hashes.Sha1Hash.ToLowerInvariant())); }
public void TestValidDirectoryId(int pathId, uint partialSealId, bool isSharedOpaque) { // skip invalid input if (partialSealId == 0 && isSharedOpaque) { return; } var dir = new DirectoryArtifact(new AbsolutePath(pathId), partialSealId, isSharedOpaque); var dir2 = DirectoryId.Parse(DirectoryId.ToString(dir)); XAssert.AreEqual(dir, dir2); }
public async Task <FileInfoContract> NewFileItemAsync(RootName root, DirectoryId parent, string name, Stream content, IProgress <ProgressValue> progress) { var context = await RequireContext(root); var itemReference = ODConnection.ItemReferenceForItemId(parent.Value, context.Drive.Id); var uploadOptions = progress != null ? new ItemUploadOptions() { ProgressReporter = (complete, transfered, total) => progress.Report(new ProgressValue(complete, (int)transfered, (int)total)) } : ItemUploadOptions.Default; var item = await AsyncFunc.Retry <ODItem, ODException>(async() => await context.Connection.PutNewFileToParentItemAsync(itemReference, name, content, uploadOptions), RETRIES); return(new FileInfoContract(item.Id, item.Name, item.CreatedDateTime, item.LastModifiedDateTime, item.Size, item.File.Hashes.Sha1.ToLowerInvariant())); }
public async Task GivenDirectoryEntry_WhenRoundTrip_Success() { DirectoryClient client = TestApplication.GetDirectoryClient(); var documentId = new DocumentId("test/unit-tests/entry1"); var query = new QueryParameter() { Filter = "test/unit-tests", Recursive = false, }; IReadOnlyList <DatalakePathItem> search = (await client.Search(query).ReadNext()).Records; if (search.Any(x => x.Name == (string)documentId)) { await client.Delete(documentId); } var entry = new DirectoryEntryBuilder() .SetDirectoryId(documentId) .SetClassType("test") .AddProperty(new EntryProperty { Name = "property1", Value = "value1" }) .Build(); await client.Set(entry); search = (await client.Search(query).ReadNext()).Records; search.Any(x => x.Name == (string)documentId).Should().BeTrue(); DirectoryEntry?readEntry = await client.Get(documentId); readEntry.Should().NotBeNull(); readEntry !.DirectoryId.Should().Be(entry.DirectoryId); readEntry.ClassType.Should().Be(entry.ClassType); readEntry.ETag.Should().NotBeNull(); readEntry.Properties.Count.Should().Be(1); readEntry.Properties.Values.First().Action(x => { (x == entry.Properties.Values.First()).Should().BeTrue(); }); await client.Delete(documentId); search = (await client.Search(query).ReadNext()).Records; search.Any(x => x.Name == (string)documentId).Should().BeFalse(); }
public IEnumerable<FileSystemInfoContract> GetChildItem(RootName root, DirectoryId parent) { if (root == null) throw new ArgumentNullException(nameof(root)); if (parent == null) throw new ArgumentNullException(nameof(parent)); var effectivePath = GetFullPath(root, parent.Value); var directory = new DirectoryInfo(effectivePath); if (directory.Exists) return directory.EnumerateDirectories().Select(d => new DirectoryInfoContract(GetRelativePath(root, d.FullName), d.Name, d.CreationTime, d.LastWriteTime)).Cast<FileSystemInfoContract>().Concat( directory.EnumerateFiles().Select(f => new FileInfoContract(GetRelativePath(root, f.FullName), f.Name, f.CreationTime, f.LastWriteTime, f.Length, null)).Cast<FileSystemInfoContract>()); else return new FileSystemInfoContract[] { }; }
public async Task<DirectoryInfoContract> NewDirectoryItemAsync(RootName root, DirectoryId parent, string name) { var context = await RequireContext(root); var item = await AsyncFunc.Retry<Folder, pCloudException>(async () => await context.Client.CreateFolderAsync(ToId(parent), name), RETRIES); return new DirectoryInfoContract(item.Id, item.Name, item.Created, item.Modified); }
public FileInfoContract NewFileItem(RootName root, DirectoryId parent, string name, Stream content, IProgress<ProgressValue> progress) { var context = RequireContext(root); var nodes = context.Client.GetNodes(); var parentItem = nodes.Single(n => n.Id == parent.Value); var item = context.Client.Upload(new ProgressStream(content, progress), name, parentItem); return new FileInfoContract(item.Id, item.Name, DateTimeOffset.MinValue, item.LastModificationDate, item.Size, null); }
public FileSystemInfoContract MoveItem(RootName root, FileSystemId source, string moveName, DirectoryId destination) { var context = RequireContext(root); var nodes = context.Client.GetNodes(); var sourceItem = nodes.Single(n => n.Id == source.Value); if (!string.IsNullOrEmpty(moveName) && moveName != sourceItem.Name) throw new NotSupportedException(Resources.RenamingOfFilesNotSupported); var destinationParentItem = nodes.Single(n => n.Id == destination.Value); var item = context.Client.Move(sourceItem, destinationParentItem); return item.ToFileSystemInfoContract(); }
public IEnumerable<FileSystemInfoContract> GetChildItem(RootName root, DirectoryId parent) { var context = RequireContext(root); var nodes = context.Client.GetNodes(); var parentItem = nodes.Single(n => n.Id == parent.Value); var items = context.Client.GetNodes(parentItem); return items.Select(i => i.ToFileSystemInfoContract()); }
public Task<FileSystemInfoContract> CopyItemAsync(RootName root, FileSystemId source, string copyName, DirectoryId destination, bool recurse) { return Task.FromException<FileSystemInfoContract>(new NotSupportedException(Resources.CopyingOfFilesOrDirectoriesNotSupported)); }
public async Task<DirectoryInfoContract> NewDirectoryItemAsync(RootName root, DirectoryId parent, string name) { var context = await RequireContext(root); var item = await AsyncFunc.Retry<FileSystem, ServerException>(async () => await context.Client.FileSystemManager.CreateNewFolderAsync(parent.Value, name, false), RETRIES); return new DirectoryInfoContract(item.Id, item.Name, item.DateLastSynced, FileSystemExtensions.Later(item.DateLastSynced, item.ModifiedTime)); }
public FileSystemInfoContract MoveItem(RootName root, FileSystemId source, string moveName, DirectoryId destination) { if (root == null) throw new ArgumentNullException(nameof(root)); if (source == null) throw new ArgumentNullException(nameof(source)); if (string.IsNullOrEmpty(moveName)) throw new ArgumentNullException(nameof(moveName)); if (destination == null) throw new ArgumentNullException(nameof(destination)); var effectivePath = GetFullPath(root, source.Value); var destinationPath = destination.Value; if (Path.IsPathRooted(destinationPath)) destinationPath = destinationPath.Remove(0, Path.GetPathRoot(destinationPath).Length); var effectiveMovePath = GetFullPath(root, Path.Combine(destinationPath, moveName)); var directory = new DirectoryInfo(effectivePath); if (directory.Exists) { directory.MoveTo(effectiveMovePath); return new DirectoryInfoContract(GetRelativePath(root, directory.FullName), directory.Name, directory.CreationTime, directory.LastWriteTime); } var file = new FileInfo(effectivePath); if (file.Exists) { file.MoveTo(effectiveMovePath); return new FileInfoContract(GetRelativePath(root, file.FullName), file.Name, file.CreationTime, file.LastWriteTime, file.Length, null); } throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, Resource.PathNotFound, source.Value)); }
public async Task<IEnumerable<FileSystemInfoContract>> GetChildItemAsync(RootName root, DirectoryId parent) { var context = await RequireContext(root); var item = await AsyncFunc.Retry<ListedFolder, pCloudException>(async () => await context.Client.ListFolderAsync(ToId(parent)), RETRIES); var items = item.Contents; return items.Select(i => i.ToFileSystemInfoContract()); }
public async Task<FileSystemInfoContract> CopyItemAsync(RootName root, FileSystemId source, string copyName, DirectoryId destination, bool recurse) { var fileSource = source as FileId; if (fileSource == null) throw new NotSupportedException(Resources.CopyingOfDirectoriesNotSupported); var context = await RequireContext(root); var item = await AsyncFunc.Retry<pCloudFile, pCloudException>(async () => await context.Client.CopyFileAsync(ToId(fileSource), ToId(destination), copyName), RETRIES); return new FileInfoContract(item.Id, item.Name, item.Created, item.Modified, item.Size, null); }
public async Task<FileSystemInfoContract> MoveItemAsync(RootName root, FileSystemId source, string moveName, DirectoryId destination, Func<FileSystemInfoLocator> locatorResolver) { var context = await RequireContext(root); var directorySource = source as DirectoryId; if (directorySource != null) { var item = await context.Client.RenameFolderAsync(ToId(directorySource), ToId(destination), moveName); return new DirectoryInfoContract(item.Id, item.Name, item.Created, item.Modified); } var fileSource = source as FileId; if (fileSource != null) { var item = await context.Client.RenameFileAsync(ToId(fileSource), ToId(destination), moveName); return new FileInfoContract(item.Id, item.Name, item.Created, item.Modified, item.Size, null); } throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, Resources.ItemTypeNotSupported, source.GetType().Name)); }
internal DirectoryInfoContract SetupNewDirectory(string parentName, string directoryName) { var parentId = new DirectoryId(parentName); var directory = new DirectoryInfoContract($"{parentId.Value}{directoryName}\\", directoryName, ToDateTime("2016-01-01 12:00:00"), ToDateTime("2016-01-01 12:00:00")); Drive .Setup(drive => drive.NewDirectoryItem(It.Is<DirectoryInfoContract>(parent => parent.Id == parentId), directoryName)) .Returns(directory); return directory; }
public async Task<IEnumerable<FileSystemInfoContract>> GetChildItemAsync(RootName root, DirectoryId parent) { var context = await RequireContext(root); var childReferences = await AsyncFunc.Retry<ChildList, GoogleApiException>(async () => await context.Service.Children.List(parent.Value).ExecuteAsync(), RETRIES); var items = childReferences.Items.Select(async c => await AsyncFunc.Retry<GoogleFile, GoogleApiException>(async () => await context.Service.Files.Get(c.Id).ExecuteAsync(), RETRIES)).ToArray(); Task.WaitAll(items); return items.Select(i => i.Result.ToFileSystemInfoContract()); }
internal FileInfoContract SetupNewFile(DirectoryId parentId, string fileName) { var file = new FileInfoContract($"{parentId.Value.TrimEnd('\\')}\\{fileName}", fileName, ToDateTime("2016-02-01 12:00:00"), ToDateTime("2016-02-01 12:00:00"), 0, null); Drive .Setup(drive => drive.NewFileItem(It.Is<DirectoryInfoContract>(parent => parent.Id == parentId), fileName, It.Is<Stream>(s => s.Length == 0))) .Returns(file); return file; }
public async Task<FileSystemInfoContract> CopyItemAsync(RootName root, FileSystemId source, string copyName, DirectoryId destination, bool recurse) { var context = await RequireContext(root); var copy = new GoogleFile() { Title = copyName }; if (destination != null) copy.Parents = new[] { new ParentReference() { Id = destination.Value } }; var item = await AsyncFunc.Retry<GoogleFile, GoogleApiException>(async () => await context.Service.Files.Copy(copy, source.Value).ExecuteAsync(), RETRIES); return item.ToFileSystemInfoContract(); }
public async Task<FileInfoContract> NewFileItemAsync(RootName root, DirectoryId parent, string name, Stream content, IProgress<ProgressValue> progress) { var context = await RequireContext(root); var item = await AsyncFunc.Retry<FileSystem, ServerException>(async () => await context.Client.FileSystemManager.UploadNewFileStreamAsync(parent.Value, name, new ProgressStream(content, progress), true), RETRIES); return new FileInfoContract(item.Id, item.Name, item.DateLastSynced, FileSystemExtensions.Later(item.DateLastSynced, item.ModifiedTime), item.Size, null); }
public async Task<FileSystemInfoContract> MoveItemAsync(RootName root, FileSystemId source, string moveName, DirectoryId destination, Func<FileSystemInfoLocator> locatorResolver) { var context = await RequireContext(root); var move = new GoogleFile() { Parents = new[] { new ParentReference() { Id = destination.Value } }, Title = moveName }; var patch = context.Service.Files.Patch(move, source.Value); var item = await AsyncFunc.Retry<GoogleFile, GoogleApiException>(async () => await patch.ExecuteAsync(), RETRIES); return item.ToFileSystemInfoContract(); }
public async Task<FileSystemInfoContract> MoveItemAsync(RootName root, FileSystemId source, string moveName, DirectoryId destination, Func<FileSystemInfoLocator> locatorResolver) { var context = await RequireContext(root); if (string.IsNullOrEmpty(moveName)) moveName = locatorResolver().Name; var success = await AsyncFunc.Retry<bool, ServerException>(async () => await context.Client.FileSystemManager.MoveFileAsync(source.Value, destination.Value, moveName, false), RETRIES); if (!success) throw new ApplicationException(string.Format(CultureInfo.CurrentCulture, Resources.MoveFailed, source.Value, destination.Value, moveName?.Insert(0, @"/") ?? string.Empty)); var movedItemPath = destination.Value.Substring(0, destination.Value.LastIndexOf('/')) + @"/" + moveName; var item = await AsyncFunc.Retry<FileSystem, ServerException>(async () => await context.Client.FileSystemManager.GetFileSystemInformationAsync(movedItemPath), RETRIES); return item.ToFileSystemInfoContract(); }
public async Task<DirectoryInfoContract> NewDirectoryItemAsync(RootName root, DirectoryId parent, string name) { var context = await RequireContext(root); var file = new GoogleFile() { Title = name, MimeType = MIME_TYPE_DIRECTORY, Parents = new[] { new ParentReference() { Id = parent.Value } } }; var item = await AsyncFunc.Retry<GoogleFile, GoogleApiException>(async () => await context.Service.Files.Insert(file).ExecuteAsync(), RETRIES); return new DirectoryInfoContract(item.Id, item.Title, new DateTimeOffset(item.CreatedDate.Value), new DateTimeOffset(item.ModifiedDate.Value)); }
public async Task<IEnumerable<FileSystemInfoContract>> GetChildItemAsync(RootName root, DirectoryId parent) { var context = await RequireContext(root); var items = await AsyncFunc.Retry<FileSystem, ServerException>(async () => await context.Client.FileSystemManager.GetFileSystemInformationAsync(parent.Value), RETRIES); return items.Children.Select(i => i.ToFileSystemInfoContract()); }
public async Task<FileInfoContract> NewFileItemAsync(RootName root, DirectoryId parent, string name, Stream content, IProgress<ProgressValue> progress) { var context = await RequireContext(root); var file = new GoogleFile() { Title = name, MimeType = MIME_TYPE_FILE, Parents = new[] { new ParentReference() { Id = parent.Value } } }; var insert = context.Service.Files.Insert(file, content, MIME_TYPE_FILE); insert.ProgressChanged += p => progress.Report(new ProgressValue((int)p.BytesSent, (int)content.Length)); var upload = await AsyncFunc.Retry<IUploadProgress, GoogleApiException>(async () => await insert.UploadAsync(), RETRIES); var item = insert.ResponseBody; return new FileInfoContract(item.Id, item.Title, new DateTimeOffset(item.CreatedDate.Value), new DateTimeOffset(item.ModifiedDate.Value), item.FileSize.Value, item.Md5Checksum); }
public FileSystemInfoContract CopyItem(RootName root, FileSystemId source, string copyName, DirectoryId destination, bool recurse) { throw new NotSupportedException(Resources.CopyingOfFilesNotSupported); }
public FileInfoContract NewFileItem(RootName root, DirectoryId parent, string name, Stream content, IProgress<ProgressValue> progress) { if (root == null) throw new ArgumentNullException(nameof(root)); if (parent == null) throw new ArgumentNullException(nameof(parent)); if (string.IsNullOrEmpty(name)) throw new ArgumentNullException(nameof(name)); var effectivePath = GetFullPath(root, Path.Combine(parent.Value, name)); var file = new FileInfo(effectivePath); if (file.Exists) throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, Resource.DuplicatePath, parent.Value)); using (var fileStream = file.Create()) { if (content != null) content.CopyTo(fileStream); } file.Refresh(); return new FileInfoContract(GetRelativePath(root, file.FullName), file.Name, file.CreationTime, file.LastWriteTime, file.Length, null); }
public DirectoryInfoContract NewDirectoryItem(RootName root, DirectoryId parent, string name) { var context = RequireContext(root); var nodes = context.Client.GetNodes(); var parentItem = nodes.Single(n => n.Id == parent.Value); var item = context.Client.CreateFolder(name, parentItem); return new DirectoryInfoContract(item.Id, item.Name, DateTimeOffset.MinValue, item.LastModificationDate); }
public DirectoryInfoContract NewDirectoryItem(RootName root, DirectoryId parent, string name) { if (root == null) throw new ArgumentNullException(nameof(root)); if (parent == null) throw new ArgumentNullException(nameof(parent)); if (string.IsNullOrEmpty(name)) throw new ArgumentNullException(nameof(name)); var effectivePath = GetFullPath(root, Path.Combine(parent.Value, name)); var directory = new DirectoryInfo(effectivePath); if (directory.Exists) throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, Resource.DuplicatePath, effectivePath)); directory.Create(); return new DirectoryInfoContract(GetRelativePath(root, directory.FullName), directory.Name, directory.CreationTime, directory.LastWriteTime); }
public async Task<FileInfoContract> NewFileItemAsync(RootName root, DirectoryId parent, string name, Stream content, IProgress<ProgressValue> progress) { var context = await RequireContext(root); var request = new BoxFileRequest() { Name = name, Parent = new BoxRequestEntity() { Id = parent.Value } }; var item = await AsyncFunc.Retry<BoxFile, BoxException>(async () => await context.Client.FilesManager.UploadAsync(request, new ProgressStream(content, progress), boxFileFields), RETRIES); return new FileInfoContract(item.Id, item.Name, item.CreatedAt.Value, item.ModifiedAt.Value, item.Size.Value, item.Sha1.ToLowerInvariant()); }
public async Task<FileInfoContract> NewFileItemAsync(RootName root, DirectoryId parent, string name, Stream content, IProgress<ProgressValue> progress) { var context = await RequireContext(root); var tokenSource = new CancellationTokenSource(); var item = await AsyncFunc.Retry<pCloudFile, pCloudException>(async () => await context.Client.UploadFileAsync(new ProgressStream(content, progress), ToId(parent), name, tokenSource.Token), RETRIES); return new FileInfoContract(item.Id, item.Name, item.Created, item.Modified, item.Size, null); }