public async Task UnlinkAsync(IUnixFileSystemEntry entry, CancellationToken cancellationToken)
        {
            if (entry is GcsFileEntry gcsFileEntry)
            {
                try
                {
                    await _storageClient.DeleteObjectAsync(_bucketName, gcsFileEntry.FullName,
                                                           null, cancellationToken);
                } catch { }
            }
            else if (entry is GcsDirectoryEntry gcsDirectoryEntry)
            {
                var foldersToDelete = new ConcurrentBag <GcsDirectoryEntry>();
                await UnlinkDirectoriesRecursivelyAsync(gcsDirectoryEntry, cancellationToken, foldersToDelete);

                var reversed = foldersToDelete.Reverse();
                foreach (var folderToDelete in reversed)
                {
                    try
                    {
                        await _storageClient.DeleteObjectAsync(_bucketName, folderToDelete.FullName,
                                                               null, cancellationToken);
                    } catch { }
                }
            }
            else
            {
                throw new NotSupportedException();
            }
        }
        /// <inheritdoc />
        public Task UnlinkAsync(IUnixFileSystemEntry entry, CancellationToken cancellationToken)
        {
            var entryInfo = ((UnixFileSystemEntry)entry).GenericInfo;

            entryInfo.Delete();
            return(Task.CompletedTask);
        }
Beispiel #3
0
        /// <inheritdoc/>
        public async Task <IUnixFileSystemEntry> MoveAsync(
            IUnixDirectoryEntry parent,
            IUnixFileSystemEntry source,
            IUnixDirectoryEntry target,
            string fileName,
            CancellationToken cancellationToken)
        {
            var parentEntry = (GoogleDriveDirectoryEntry)parent;
            var targetEntry = (GoogleDriveDirectoryEntry)target;
            var targetName  = FileSystemExtensions.CombinePath(targetEntry.FullName, fileName);

            if (source is GoogleDriveFileEntry sourceFileEntry)
            {
                var newFile = await MoveItem(
                    parentEntry.File.Id,
                    targetEntry.File.Id,
                    sourceFileEntry.File.Id,
                    fileName,
                    cancellationToken);

                return(new GoogleDriveFileEntry(this, newFile, targetName));
            }
            else
            {
                var sourceDirEntry = (GoogleDriveDirectoryEntry)source;
                var newDir         = await MoveItem(
                    parentEntry.File.Id,
                    targetEntry.File.Id,
                    sourceDirEntry.File.Id,
                    fileName,
                    cancellationToken);

                return(new GoogleDriveDirectoryEntry(this, newDir, targetName));
            }
        }
Beispiel #4
0
        /// <inheritdoc/>
        public override async Task <FtpResponse> Process(FtpCommand command, CancellationToken cancellationToken)
        {
            var path        = command.Argument;
            var currentPath = Data.Path.Clone();
            var fileInfo    = await Data.FileSystem.SearchFileAsync(currentPath, path, cancellationToken).ConfigureAwait(false);

            IUnixFileSystemEntry foundEntry = fileInfo?.Entry;

            if (foundEntry == null)
            {
                var parts = path.Split(new[] { ' ' }, 2);
                if (parts.Length != 2)
                {
                    return(new FtpResponse(550, "File not found."));
                }

                if (!parts[0].TryParseTimestamp("UTC", out var modificationTime))
                {
                    return(new FtpResponse(550, "File not found."));
                }

                path        = parts[1];
                currentPath = Data.Path.Clone();
                fileInfo    = await Data.FileSystem.SearchFileAsync(currentPath, path, cancellationToken).ConfigureAwait(false);

                if (fileInfo?.Entry == null)
                {
                    return(new FtpResponse(550, "File not found."));
                }

                foundEntry = await Data.FileSystem.SetMacTimeAsync(fileInfo.Entry, modificationTime, null, null, cancellationToken).ConfigureAwait(false);
            }

            return(new FtpResponse(213, $"{foundEntry.LastWriteTime?.ToUniversalTime():yyyyMMddHHmmss.fff}"));
        }
Beispiel #5
0
        /// <inheritdoc/>
        public async Task <IUnixFileSystemEntry> SetMacTimeAsync(IUnixFileSystemEntry entry, DateTimeOffset?modify, DateTimeOffset?access, DateTimeOffset?create, CancellationToken cancellationToken)
        {
            var dirEntry  = entry as GoogleDriveDirectoryEntry;
            var fileEntry = entry as GoogleDriveFileEntry;
            var item      = dirEntry == null ? fileEntry?.File : dirEntry.File;

            if (item == null)
            {
                throw new InvalidOperationException();
            }
            var newItemValues = new File()
            {
                ModifiedDate       = modify?.UtcDateTime,
                CreatedDate        = create?.UtcDateTime,
                LastViewedByMeDate = access?.UtcDateTime,
            };
            var newItem = await Service.UpdateAsync(item.Id, newItemValues, cancellationToken);

            var fullName       = dirEntry == null ? fileEntry.FullName : dirEntry.FullName;
            var targetFullName = FileSystemExtensions.CombinePath(fullName.GetParentPath(), newItem.Title);

            if (dirEntry != null)
            {
                return(new GoogleDriveDirectoryEntry(this, newItem, targetFullName, dirEntry.IsRoot));
            }
            return(new GoogleDriveFileEntry(this, newItem, fullName, fileEntry.Size));
        }
        /// <inheritdoc />
        public Task <IUnixFileSystemEntry> MoveAsync(
            IUnixDirectoryEntry parent,
            IUnixFileSystemEntry source,
            IUnixDirectoryEntry target,
            string fileName,
            CancellationToken cancellationToken)
        {
            var parentEntry = (InMemoryDirectoryEntry)parent;
            var sourceEntry = (InMemoryFileSystemEntry)source;
            var targetEntry = (InMemoryDirectoryEntry)target;

            targetEntry.Children.Add(fileName, source);

            if (!parentEntry.Children.Remove(source.Name))
            {
                targetEntry.Children.Remove(fileName);
                throw new FileUnavailableException($"The source file {source.Name} couldn't be found in directory {parentEntry.Name}");
            }

            var now = DateTimeOffset.Now;

            parentEntry.SetLastWriteTime(now);
            targetEntry.SetLastWriteTime(now);

            sourceEntry.Parent = targetEntry;

            return(Task.FromResult(source));
        }
        /// <summary>
        /// Sets the modify/access/create timestamp of a file system item.
        /// </summary>
        /// <param name="entry">The <see cref="IUnixFileSystemEntry"/> to change the timestamp for.</param>
        /// <param name="modify">The modification timestamp.</param>
        /// <param name="access">The access timestamp.</param>
        /// <param name="create">The creation timestamp.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns>The modified <see cref="IUnixFileSystemEntry"/>.</returns>
        public Task <IUnixFileSystemEntry> SetMacTimeAsync(IUnixFileSystemEntry entry, DateTimeOffset?modify, DateTimeOffset?access, DateTimeOffset?create, CancellationToken cancellationToken)
        {
            var item = ((CustomServerDemoEntry)entry).Info;

            if (access != null)
            {
                item.LastAccessTimeUtc = access.Value.UtcDateTime;
            }

            if (modify != null)
            {
                item.LastWriteTimeUtc = modify.Value.UtcDateTime;
            }

            if (create != null)
            {
                item.CreationTimeUtc = create.Value.UtcDateTime;
            }

            if (entry is CustomDirectoryEntry dirEntry)
            {
                return(Task.FromResult <IUnixFileSystemEntry>(new CustomDirectoryEntry((DirectoryInfo)item, dirEntry.IsRoot, SupportsNonEmptyDirectoryDelete)));
            }

            return(Task.FromResult <IUnixFileSystemEntry>(new CustomFileEntry((FileInfo)item)));
        }
        /// <summary>
        /// Sets the modify/access/create timestamp of a file system item.
        /// </summary>
        /// <param name="entry">The <see cref="IUnixFileSystemEntry"/> to change the timestamp for.</param>
        /// <param name="modify">The modification timestamp.</param>
        /// <param name="access">The access timestamp.</param>
        /// <param name="create">The creation timestamp.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns>The modified <see cref="IUnixFileSystemEntry"/>.</returns>
        public Task <IUnixFileSystemEntry> SetMacTimeAsync(IUnixFileSystemEntry entry, DateTimeOffset?modify, DateTimeOffset?access, DateTimeOffset?create, CancellationToken cancellationToken)
        {
            var item = ((ServerManagerFileSystemEntry)entry).Info;

            if (item == null)
            {
                throw new InvalidOperationException();
            }

            if (access != null)
            {
                item.LastAccessTimeUtc = access.Value.UtcDateTime;
            }

            if (modify != null)
            {
                item.LastWriteTimeUtc = modify.Value.UtcDateTime;
            }

            if (create != null)
            {
                item.CreationTimeUtc = create.Value.UtcDateTime;
            }

            if (entry is ServerManagerDirectoryEntry dirEntry)
            {
                return(Task.FromResult <IUnixFileSystemEntry>(new ServerManagerDirectoryEntry((DirectoryInfo)item, SupportsNonEmptyDirectoryDelete)));
            }

            return(Task.FromResult <IUnixFileSystemEntry>(new DotNetFileEntry((FileInfo)item)));
        }
        /// <inheritdoc />
        public Task <IUnixFileSystemEntry> MoveAsync(
            IUnixDirectoryEntry parent,
            IUnixFileSystemEntry source,
            IUnixDirectoryEntry target,
            string fileName,
            CancellationToken cancellationToken)
        {
            var parentEntry = (InMemoryDirectoryEntry)parent;
            var sourceEntry = (InMemoryFileSystemEntry)source;
            var targetEntry = (InMemoryDirectoryEntry)target;

            targetEntry.Children.Add(fileName, source);

            if (!parentEntry.Children.Remove(source.Name))
            {
                targetEntry.Children.Remove(fileName);
                return(Task.FromResult <IUnixFileSystemEntry>(null));
            }

            var now = DateTimeOffset.Now;

            parentEntry.SetLastWriteTime(now);
            targetEntry.SetLastWriteTime(now);

            sourceEntry.Parent = targetEntry;

            return(Task.FromResult(source));
        }
Beispiel #10
0
 /// <inheritdoc/>
 public string Format(IUnixFileSystemEntry entry)
 {
     var currentDirEntry = _pathEntries.Count == 0 ? _fileSystem.Root : _pathEntries.Peek();
     var dirEntry = entry as IUnixDirectoryEntry;
     if (dirEntry != null)
         return BuildLine(BuildFacts(currentDirEntry, dirEntry, new TypeFact(dirEntry)), entry.Name);
     return BuildLine(BuildFacts(currentDirEntry, (IUnixFileEntry)entry), entry.Name);
 }
        /// <inheritdoc />
        public Task UnlinkAsync(IUnixFileSystemEntry entry, CancellationToken cancellationToken)
        {
            var fsEntry = (InMemoryFileSystemEntry)entry;

            if (fsEntry.Parent?.Children.Remove(entry.Name) ?? false)
            {
                fsEntry.Parent.SetLastWriteTime(DateTimeOffset.Now);
                fsEntry.Parent = null;
            }

            return(Task.CompletedTask);
        }
Beispiel #12
0
 /// <inheritdoc/>
 public Task UnlinkAsync(IUnixFileSystemEntry entry, CancellationToken cancellationToken)
 {
     if (entry is DotNetDirectoryEntry dirEntry)
     {
         dirEntry.Info.Delete(SupportsNonEmptyDirectoryDelete);
     }
     else
     {
         var fileEntry = (DotNetFileEntry)entry;
         fileEntry.Info.Delete();
     }
     return(Task.FromResult(0));
 }
Beispiel #13
0
        /// <inheritdoc/>
        public async Task UnlinkAsync(IUnixFileSystemEntry entry, CancellationToken cancellationToken)
        {
            var dirEntry = entry as GoogleDriveDirectoryEntry;

            if (dirEntry != null)
            {
                await Service.TrashAsync(dirEntry.File, cancellationToken);
            }
            else
            {
                var fileEntry = (GoogleDriveFileEntry)entry;
                await Service.TrashAsync(fileEntry.File, cancellationToken);
            }
        }
 public MlstFtpResponse(
     ISet <string> activeMlstFacts,
     ClaimsPrincipal user,
     IUnixFileSystem fileSystem,
     IUnixFileSystemEntry targetEntry,
     Stack <IUnixDirectoryEntry> path)
     : base(250, $" {targetEntry.Name}", "End")
 {
     _activeMlstFacts = activeMlstFacts;
     _user            = user;
     _fileSystem      = fileSystem;
     _targetEntry     = targetEntry;
     _path            = path;
 }
        public async Task <IUnixFileSystemEntry> GetEntryByNameAsync(IUnixDirectoryEntry directoryEntry, string name, CancellationToken cancellationToken)
        {
            IUnixFileSystemEntry result = null;
            var parentEntry             = (GcsDirectoryEntry)directoryEntry;
            var fullName = string.Join("/", new string[] { parentEntry.FullName.Trim('/'), name }).Trim('/');

            Google.Apis.Storage.v1.Data.Object obj = null;
            try
            {
                obj = await _storageClient.GetObjectAsync(_bucketName, fullName, null, cancellationToken);
            } catch { }
            if (obj == null)
            {
                var childEntry = new GcsDirectoryEntry(this)
                {
                    Name = $"{fullName}/"
                };
                var directoryExists = await DirectoryExistsAsync(childEntry);

                if (directoryExists)
                {
                    result = childEntry;
                }
            }
            else
            {
                if (obj.ContentType != "application/x-directory")
                {
                    DateTimeOffset?createdTime = null;
                    if (obj.TimeCreated is DateTime created)
                    {
                        createdTime = new DateTimeOffset(created);
                    }
                    DateTimeOffset?updatedTime = null;
                    if (obj.Updated is DateTime updated)
                    {
                        updatedTime = new DateTimeOffset(updated);
                    }
                    return(new GcsFileEntry(this)
                    {
                        Name = obj.Name,
                        Size = Convert.ToInt64(obj.Size),
                        CreatedTime = createdTime,
                        LastWriteTime = updatedTime
                    });
                }
            }

            return(result);
        }
Beispiel #16
0
        /// <inheritdoc/>
        public Task UnlinkAsync(IUnixFileSystemEntry entry, CancellationToken cancellationToken)
        {
            var dirEntry = entry as RemoteDirectoryEntry;

            if (dirEntry != null)
            {
                dirEntry.Info.Delete(SupportsNonEmptyDirectoryDelete);
            }
            else
            {
                var fileEntry = (RemoteFileEntry)entry;
                fileEntry.Info.Delete();
            }
            return(Task.FromResult(0));
        }
Beispiel #17
0
 private static string BuildLine(IUnixFileSystemEntry entry, IUnixFileEntry fileEntry, string name)
 {
     return string.Format(
         CultureInfo.InvariantCulture,
         "{0}{1}{2}{3} {4} {5} {6} {7:D13} {8:MMM dd HH:mm} {9}",
         fileEntry == null ? "d" : "-",
         BuildAccessMode(entry.Permissions.User),
         BuildAccessMode(entry.Permissions.Group),
         BuildAccessMode(entry.Permissions.Other),
         entry.NumberOfLinks,
         entry.Owner,
         entry.Group,
         fileEntry?.Size ?? 0,
         entry.LastWriteTime,
         name);
 }
Beispiel #18
0
 private static string BuildLine(IUnixFileSystemEntry entry, IUnixFileEntry fileEntry, string name)
 {
     return(string.Format(
                CultureInfo.InvariantCulture,
                "{0}{1}{2}{3} {4} {5} {6} {7:D13} {8:MMM dd HH:mm} {9}",
                fileEntry == null ? "d" : "-",
                BuildAccessMode(entry.Permissions.User),
                BuildAccessMode(entry.Permissions.Group),
                BuildAccessMode(entry.Permissions.Other),
                entry.NumberOfLinks,
                entry.Owner,
                entry.Group,
                fileEntry?.Size ?? 0,
                entry.LastWriteTime,
                name));
 }
        /// <inheritdoc/>
        public Task <IUnixFileSystemEntry> MoveAsync(IUnixDirectoryEntry parent, IUnixFileSystemEntry source, IUnixDirectoryEntry target, string fileName, CancellationToken cancellationToken)
        {
            var targetEntry = (DotNetDirectoryEntry)target;
            var targetName  = Path.Combine(targetEntry.Info.FullName, fileName);

            if (source is DotNetFileEntry sourceFileEntry)
            {
                sourceFileEntry.Info.MoveTo(targetName);
                return(Task.FromResult <IUnixFileSystemEntry>(new DotNetFileEntry(this, new FileInfo(targetName))));
            }

            var sourceDirEntry = (DotNetDirectoryEntry)source;

            sourceDirEntry.Info.MoveTo(targetName);
            return(Task.FromResult <IUnixFileSystemEntry>(new DotNetDirectoryEntry(this, new DirectoryInfo(targetName), false)));
        }
        /// <inheritdoc/>
        public Task <IUnixFileSystemEntry> MoveAsync(IUnixDirectoryEntry parent, IUnixFileSystemEntry source, IUnixDirectoryEntry target, string fileName, CancellationToken cancellationToken)
        {
            var targetEntry = (CustomDirectoryEntry)target;
            var targetName  = Path.Combine(targetEntry.Info.FullName, fileName);

            if (source is CustomFileEntry sourceFileEntry)
            {
                sourceFileEntry.FileInfo.MoveTo(targetName);
                return(Task.FromResult <IUnixFileSystemEntry>(new CustomFileEntry(new FileInfo(targetName))));
            }

            var sourceDirEntry = (CustomDirectoryEntry)source;

            sourceDirEntry.DirectoryInfo.MoveTo(targetName);
            return(Task.FromResult <IUnixFileSystemEntry>(new CustomDirectoryEntry(new DirectoryInfo(targetName), false, SupportsNonEmptyDirectoryDelete)));
        }
        /// <inheritdoc/>
        public string Format(IUnixFileSystemEntry entry, string name)
        {
            switch (name)
            {
                case ".":
                    return FormatThisDirectoryEntry();
                case "..":
                    return FormatParentDirectoryEntry();
            }

            var currentDirEntry = _enumerator.CurrentDirectory;
            var dirEntry = entry as IUnixDirectoryEntry;
            if (dirEntry != null)
                return BuildLine(BuildFacts(currentDirEntry, dirEntry, new TypeFact(dirEntry)), dirEntry.IsRoot ? string.Empty : name ?? entry.Name);
            return BuildLine(BuildFacts(currentDirEntry, (IUnixFileEntry)entry), name ?? entry.Name);
        }
Beispiel #22
0
 public Task UnlinkAsync(IUnixFileSystemEntry entry, CancellationToken cancellationToken)
 {
     if (((AzureBlobFileSystemEntry)entry).IsFolder)
     {
         var dir = (CloudBlobDirectory)((AzureBlobDirectoryEntry)entry).Item;
         foreach (IListBlobItem item in dir.ListBlobs(true))
         {
             ((CloudBlockBlob)item).Delete();
         }
     }
     else
     {
         var file = (CloudBlockBlob)((AzureBlobFileEntry)entry).Item;
         file.Delete();
     }
     return(Task.FromResult(0));
 }
Beispiel #23
0
        /// <inheritdoc/>
        public async Task UnlinkAsync(IUnixFileSystemEntry entry, CancellationToken cancellationToken)
        {
            var body = new File
            {
                Trashed = true,
            };

            if (entry is GoogleDriveDirectoryEntry dirEntry)
            {
                await Service.Files.Update(body, dirEntry.File.Id).ExecuteAsync(cancellationToken);
            }
            else
            {
                var fileEntry = (GoogleDriveFileEntry)entry;
                await Service.Files.Update(body, fileEntry.File.Id).ExecuteAsync(cancellationToken);
            }
        }
        /// <inheritdoc/>
        public Task UnlinkAsync(IUnixFileSystemEntry entry, CancellationToken cancellationToken)
        {
            if (entry is ServerManagerDirectoryEntry dirEntry)
            {
                if (dirEntry.Info == null)
                {
                    throw new InvalidOperationException();
                }
                ((DirectoryInfo)dirEntry.Info).Delete(SupportsNonEmptyDirectoryDelete);
            }
            else
            {
                var fileEntry = (ServerManagerFileEntry)entry;
                fileEntry.Info.Delete();
            }

            return(Task.FromResult(0));
        }
Beispiel #25
0
        /// <inheritdoc />
        public Task UnlinkAsync(IUnixFileSystemEntry entry, CancellationToken cancellationToken)
        {
            var fsEntry = (InMemoryFileSystemEntry)entry;
            var parent  = fsEntry.Parent;

            if (parent != null)
            {
                lock (parent.ChildrenLock)
                {
                    if (parent.Children.Remove(entry.Name))
                    {
                        parent.SetLastWriteTime(DateTimeOffset.Now);
                        fsEntry.Parent = null;
                    }
                }
            }

            return(Task.CompletedTask);
        }
Beispiel #26
0
        /// <summary>
        /// Sets the modify/access/create timestamp of a file system item.
        /// </summary>
        /// <param name="entry">The <see cref="IUnixFileSystemEntry"/> to change the timestamp for.</param>
        /// <param name="modify">The modification timestamp.</param>
        /// <param name="access">The access timestamp.</param>
        /// <param name="create">The creation timestamp.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns>The modified <see cref="IUnixFileSystemEntry"/>.</returns>
        public Task <IUnixFileSystemEntry> SetMacTimeAsync(IUnixFileSystemEntry entry, DateTimeOffset?modify, DateTimeOffset?access, DateTimeOffset?create, CancellationToken cancellationToken)
        {
            var dirEntry  = entry as DotNetDirectoryEntry;
            var fileEntry = entry as DotNetFileEntry;

            FileSystemInfo item;

            if (dirEntry != null)
            {
                item = dirEntry.Info;
            }
            else if (fileEntry != null)
            {
                item = fileEntry.Info;
            }
            else
            {
                throw new ArgumentException("Argument must be of type DotNetDirectoryEntry or DotNetFileEntry", nameof(entry));
            }

            if (access != null)
            {
                item.LastAccessTimeUtc = access.Value.UtcDateTime;
            }

            if (modify != null)
            {
                item.LastWriteTimeUtc = modify.Value.UtcDateTime;
            }

            if (create != null)
            {
                item.CreationTimeUtc = create.Value.UtcDateTime;
            }

            if (dirEntry != null)
            {
                return(Task.FromResult <IUnixFileSystemEntry>(new DotNetDirectoryEntry(this, (DirectoryInfo)item, dirEntry.IsRoot)));
            }

            return(Task.FromResult <IUnixFileSystemEntry>(new DotNetFileEntry(this, (FileInfo)item)));
        }
Beispiel #27
0
        /// <inheritdoc/>
        public string Format(IUnixFileSystemEntry entry, string name)
        {
            switch (name)
            {
            case ".":
                return(FormatThisDirectoryEntry());

            case "..":
                return(FormatParentDirectoryEntry());
            }

            var currentDirEntry = _enumerator.CurrentDirectory;

            if (entry is IUnixDirectoryEntry dirEntry)
            {
                return(BuildLine(BuildFacts(currentDirEntry, dirEntry, new TypeFact(dirEntry)), dirEntry.IsRoot ? string.Empty : name ?? entry.Name));
            }

            return(BuildLine(BuildFacts(currentDirEntry, (IUnixFileEntry)entry), name ?? entry.Name));
        }
        /// <inheritdoc />
        public Task <IUnixFileSystemEntry> SetMacTimeAsync(
            IUnixFileSystemEntry entry,
            DateTimeOffset?modify,
            DateTimeOffset?access,
            DateTimeOffset?create,
            CancellationToken cancellationToken)
        {
            var fsEntry = (InMemoryFileSystemEntry)entry;

            if (modify != null)
            {
                fsEntry.SetLastWriteTime(modify.Value);
            }

            if (create != null)
            {
                fsEntry.SetCreateTime(create.Value);
            }

            return(Task.FromResult(entry));
        }
Beispiel #29
0
        private static string BuildLine(IUnixFileSystemEntry entry, IUnixFileEntry fileEntry, string name)
        {
            var lastWriteDate = entry.LastWriteTime ?? new DateTimeOffset(new DateTime(1970, 01, 01));
            var format        = lastWriteDate.Year == DateTimeOffset.UtcNow.Year
                ? "{0}{1}{2}{3} {4} {5} {6} {7} {8:MMM dd HH:mm} {9}"
                : "{0}{1}{2}{3} {4} {5} {6} {7} {8:MMM dd yyyy} {9}";

            return(string.Format(
                       CultureInfo.InvariantCulture,
                       format,
                       fileEntry == null ? "d" : "-",
                       BuildAccessMode(entry.Permissions.User),
                       BuildAccessMode(entry.Permissions.Group),
                       BuildAccessMode(entry.Permissions.Other),
                       entry.NumberOfLinks,
                       entry.Owner,
                       entry.Group,
                       fileEntry?.Size ?? 0,
                       lastWriteDate,
                       name));
        }
        /// <inheritdoc />
        public Task <IUnixFileSystemEntry> MoveAsync(
            IUnixDirectoryEntry parent,
            IUnixFileSystemEntry source,
            IUnixDirectoryEntry target,
            string fileName,
            CancellationToken cancellationToken)
        {
            var sourceInfo      = ((UnixFileSystemEntry)source).GenericInfo;
            var targetEntry     = (UnixDirectoryEntry)target;
            var targetInfo      = targetEntry.Info;
            var sourceEntryName = sourceInfo.FullName;
            var targetEntryName = UnixPath.Combine(targetInfo.FullName, fileName);

            if (Stdlib.rename(sourceEntryName, targetEntryName) == -1)
            {
                throw new InvalidOperationException("The entry couldn't be moved.");
            }

            var targetEntryInfo = UnixFileSystemInfo.GetFileSystemEntry(targetEntryName);

            return(Task.FromResult(CreateEntry(targetEntry, targetEntryInfo)));
        }
        /// <inheritdoc />
        public Task <IUnixFileSystemEntry> SetMacTimeAsync(
            IUnixFileSystemEntry entry,
            DateTimeOffset?modify,
            DateTimeOffset?access,
            DateTimeOffset?create,
            CancellationToken cancellationToken)
        {
            if (access == null && modify == null)
            {
                return(Task.FromResult(entry));
            }

            var entryInfo = ((UnixFileSystemEntry)entry).GenericInfo;

            var times = new Timeval[2];

            if (access != null)
            {
                times[0] = ToTimeval(access.Value.UtcDateTime);
            }
            else
            {
                times[0] = ToTimeval(entryInfo.LastAccessTimeUtc);
            }

            if (modify != null)
            {
                times[1] = ToTimeval(modify.Value.UtcDateTime);
            }
            else
            {
                times[1] = ToTimeval(entryInfo.LastWriteTimeUtc);
            }

            Syscall.utimes(entryInfo.FullName, times);

            entryInfo.Refresh();
            return(Task.FromResult(entry));
        }
Beispiel #32
0
        /// <inheritdoc/>
        public async Task <IUnixFileSystemEntry> SetMacTimeAsync(
            IUnixFileSystemEntry entry,
            DateTimeOffset?modify,
            DateTimeOffset?access,
            DateTimeOffset?create,
            CancellationToken cancellationToken)
        {
            var dirEntry  = entry as GoogleDriveDirectoryEntry;
            var fileEntry = entry as GoogleDriveFileEntry;
            var item      = dirEntry == null ? fileEntry?.File : dirEntry.File;

            if (item == null)
            {
                throw new InvalidOperationException();
            }

            var newItemValues = new File()
            {
                ModifiedTime   = modify?.UtcDateTime,
                CreatedTime    = create?.UtcDateTime,
                ViewedByMeTime = access?.UtcDateTime,
            };

            var request = Service.Files.Update(newItemValues, item.Id);

            request.Fields = FileExtensions.DefaultFileFields;

            var newItem = await request.ExecuteAsync(cancellationToken).ConfigureAwait(false);

            var fullName       = dirEntry == null ? fileEntry.FullName : dirEntry.FullName;
            var targetFullName = FileSystemExtensions.CombinePath(fullName.GetParentPath(), newItem.Name);

            if (dirEntry != null)
            {
                return(new GoogleDriveDirectoryEntry(newItem, targetFullName, dirEntry.IsRoot));
            }

            return(new GoogleDriveFileEntry(newItem, fullName, fileEntry.Size));
        }
        /// <inheritdoc/>
        public Task <IUnixFileSystemEntry> MoveAsync(IUnixDirectoryEntry parent, IUnixFileSystemEntry source, IUnixDirectoryEntry target, string fileName, CancellationToken cancellationToken)
        {
            var targetEntry = (ServerManagerDirectoryEntry)target;

            if (targetEntry.Info == null)
            {
                throw new InvalidOperationException();
            }

            var targetName = Path.Combine(targetEntry.Info.FullName, fileName);

            if (source is ServerManagerFileEntry sourceFileEntry)
            {
                ((FileInfo)sourceFileEntry.Info).MoveTo(targetName);
                return(Task.FromResult <IUnixFileSystemEntry>(new ServerManagerFileEntry(targetEntry.Server, new FileInfo(targetName))));
            }

            var sourceDirEntry = (ServerManagerDirectoryEntry)source;

            ((DirectoryInfo)sourceDirEntry.Info).MoveTo(targetName);
            return(Task.FromResult <IUnixFileSystemEntry>(new ServerManagerDirectoryEntry(targetEntry.Server, new DirectoryInfo(targetName), SupportsNonEmptyDirectoryDelete, targetEntry.IsRoot)));
        }
        /// <inheritdoc/>
        public async Task<IUnixFileSystemEntry> MoveAsync(IUnixDirectoryEntry parent, IUnixFileSystemEntry source, IUnixDirectoryEntry target, string fileName, CancellationToken cancellationToken)
        {
            var parentEntry = (GoogleDriveDirectoryEntry)parent;
            var targetEntry = (GoogleDriveDirectoryEntry)target;
            var targetName = FileSystemExtensions.CombinePath(targetEntry.FullName, fileName);

            var sourceFileEntry = source as GoogleDriveFileEntry;
            if (sourceFileEntry != null)
            {
                var newFile = await Service.MoveAsync(sourceFileEntry.File, parentEntry.File.Id, targetEntry.File, fileName, cancellationToken);
                return new GoogleDriveFileEntry(this, newFile, targetName);
            }

            var sourceDirEntry = (GoogleDriveDirectoryEntry)source;
            var newDir = await Service.MoveAsync(sourceDirEntry.File, parentEntry.File.Id, targetEntry.File, fileName, cancellationToken);
            return new GoogleDriveDirectoryEntry(this, newDir, targetName);
        }
Beispiel #35
0
 /// <inheritdoc/>
 public string Format(IUnixFileSystemEntry entry)
 {
     var fileEntry = entry as IUnixFileEntry;
     return BuildLine(entry, fileEntry, entry.Name);
 }
Beispiel #36
0
 /// <summary>
 /// Sets the modify/access/create timestamp of a file system item
 /// </summary>
 /// <param name="entry">The <see cref="IUnixFileSystemEntry"/> to change the timestamp for</param>
 /// <param name="modify">The modification timestamp</param>
 /// <param name="access">The access timestamp</param>
 /// <param name="create">The creation timestamp</param>
 /// <param name="cancellationToken">The cancellation token</param>
 /// <returns>The modified <see cref="IUnixFileSystemEntry"/></returns>
 public Task<IUnixFileSystemEntry> SetMacTimeAsync(IUnixFileSystemEntry entry, DateTimeOffset? modify, DateTimeOffset? access, DateTimeOffset? create, CancellationToken cancellationToken)
 {
     var dirEntry = entry as DotNetDirectoryEntry;
     var fileEntry = entry as DotNetFileEntry;
     var item = dirEntry == null ? (FileSystemInfo)fileEntry.Info : dirEntry.Info;
     if (access != null)
         item.LastAccessTimeUtc = access.Value.UtcDateTime;
     if (modify != null)
         item.LastWriteTimeUtc = modify.Value.UtcDateTime;
     if (create != null)
         item.CreationTimeUtc = create.Value.UtcDateTime;
     if (dirEntry != null)
         return Task.FromResult<IUnixFileSystemEntry>(new DotNetDirectoryEntry(this, (DirectoryInfo)item, dirEntry.IsRoot));
     return Task.FromResult<IUnixFileSystemEntry>(new DotNetFileEntry(this, (FileInfo)item));
 }
 /// <inheritdoc/>
 public string Format(IUnixFileSystemEntry entry, string name)
 {
     return name ?? entry.Name;
 }
Beispiel #38
0
 /// <inheritdoc/>
 public string Format(IUnixFileSystemEntry entry)
 {
     return entry.Name;
 }
Beispiel #39
0
 /// <inheritdoc/>
 public Task<IUnixFileSystemEntry> MoveAsync(IUnixDirectoryEntry parent, IUnixFileSystemEntry source, IUnixDirectoryEntry target, string fileName, CancellationToken cancellationToken)
 {
     throw new NotSupportedException();
 }
Beispiel #40
0
 /// <inheritdoc/>
 public Task<IUnixFileSystemEntry> SetMacTimeAsync(IUnixFileSystemEntry entry, DateTimeOffset? modify, DateTimeOffset? access, DateTimeOffset? create, CancellationToken cancellationToken)
 {
     throw new NotSupportedException();
 }
Beispiel #41
0
 /// <summary>
 /// Initializes a new instance of the <see cref="TypeFact"/> class.
 /// </summary>
 /// <param name="entry">The file system entry to get the <code>type</code> fact for</param>
 public TypeFact(IUnixFileSystemEntry entry)
     : this(entry is IUnixFileEntry ? "file" : "dir")
 {
 }
Beispiel #42
0
 /// <inheritdoc/>
 public Task UnlinkAsync(IUnixFileSystemEntry entry, CancellationToken cancellationToken)
 {
     throw new NotSupportedException();
 }
 /// <inheritdoc/>
 public async Task<IUnixFileSystemEntry> SetMacTimeAsync(IUnixFileSystemEntry entry, DateTimeOffset? modify, DateTimeOffset? access, DateTimeOffset? create, CancellationToken cancellationToken)
 {
     var dirEntry = entry as GoogleDriveDirectoryEntry;
     var fileEntry = entry as GoogleDriveFileEntry;
     var item = dirEntry == null ? fileEntry?.File : dirEntry.File;
     if (item == null)
         throw new InvalidOperationException();
     var newItemValues = new File()
     {
         ModifiedDate = modify?.UtcDateTime,
         CreatedDate = create?.UtcDateTime,
         LastViewedByMeDate = access?.UtcDateTime,
     };
     var newItem = await Service.UpdateAsync(item.Id, newItemValues, cancellationToken);
     var fullName = dirEntry == null ? fileEntry.FullName : dirEntry.FullName;
     var targetFullName = FileSystemExtensions.CombinePath(fullName.GetParentPath(), newItem.Title);
     if (dirEntry != null)
         return new GoogleDriveDirectoryEntry(this, newItem, targetFullName, dirEntry.IsRoot);
     return new GoogleDriveFileEntry(this, newItem, fullName, fileEntry.Size);
 }
 /// <inheritdoc/>
 public async Task<IUnixFileSystemEntry> MoveAsync(IUnixDirectoryEntry parent, IUnixFileSystemEntry source, IUnixDirectoryEntry target, string fileName, CancellationToken cancellationToken)
 {
     var sourceItem = ((OneDriveFileSystemEntry)source).Item;
     var sourceId = sourceItem.Id;
     var newParentItem = ((OneDriveDirectoryEntry)target).Item;
     var newParentRef = new ItemReference()
     {
         Id = newParentItem.Id,
     };
     _cache.Remove(GetFileId(sourceItem));
     var newItem = await Service.MoveAsync(Drive.Id, sourceId, fileName, newParentRef, cancellationToken);
     _cache.Set(GetFileId(newItem), newItem, _defaultCacheTimeSpan);
     return await ConvertToUnixFileSystemEntry(newItem, cancellationToken);
 }
 /// <inheritdoc/>
 public async Task UnlinkAsync(IUnixFileSystemEntry entry, CancellationToken cancellationToken)
 {
     var entryItem = ((OneDriveFileSystemEntry)entry).Item;
     await Service.DeleteAsync(Drive.Id, entryItem.Id, cancellationToken);
 }
        /// <inheritdoc/>
        public async Task<IUnixFileSystemEntry> SetMacTimeAsync(IUnixFileSystemEntry entry, DateTimeOffset? modify, DateTimeOffset? access, DateTimeOffset? create, CancellationToken cancellationToken)
        {
            var item = ((OneDriveFileSystemEntry)entry).Item;

            await _uploadsLock.WaitAsync(cancellationToken);
            try
            {
                var id = GetFileId(item);
                BackgroundUpload uploader;
                if (_uploads.TryGetValue(id, out uploader))
                {
                    if (uploader.ItemChanges == null)
                        uploader.ItemChanges = new Item();
                    if (uploader.ItemChanges.FileSystemInfo == null)
                        uploader.ItemChanges.FileSystemInfo = new FileSystemInfo();
                    if (item.FileSystemInfo == null)
                        item.FileSystemInfo = new FileSystemInfo();
                    if (uploader.Item.FileSystemInfo == null)
                        uploader.Item.FileSystemInfo = new FileSystemInfo();
                    if (modify != null)
                    {
                        uploader.ItemChanges.FileSystemInfo.LastModifiedDateTime = modify;
                        uploader.Item.FileSystemInfo.LastModifiedDateTime = modify;
                        item.FileSystemInfo.LastModifiedDateTime = modify;
                    }
                    if (create != null)
                    {
                        uploader.ItemChanges.FileSystemInfo.CreatedDateTime = create;
                        uploader.Item.FileSystemInfo.CreatedDateTime = create;
                        item.FileSystemInfo.CreatedDateTime = create;
                    }
                    return entry;
                }
            }
            finally
            {
                _uploadsLock.Release();
            }

            var updateItem = new Item() { FileSystemInfo = new FileSystemInfo() };
            if (modify != null)
                updateItem.FileSystemInfo.LastModifiedDateTime = modify;
            if (create != null)
                updateItem.FileSystemInfo.CreatedDateTime = create;

            var newItem = await Service.UpdateAsync(Drive.Id, item.Id, updateItem, cancellationToken);
            _cache.Set(GetFileId(newItem), newItem, _defaultCacheTimeSpan);
            if (newItem.Folder != null)
                return new OneDriveDirectoryEntry(this, newItem, false);
            return new OneDriveFileEntry(this, newItem, null);
        }
 /// <inheritdoc/>
 public Task UnlinkAsync(IUnixFileSystemEntry entry, CancellationToken cancellationToken)
 {
     var dirEntry = entry as DotNetDirectoryEntry;
     if (dirEntry != null)
     {
         dirEntry.Info.Delete(SupportsNonEmptyDirectoryDelete);
     }
     else
     {
         var fileEntry = (DotNetFileEntry)entry;
         fileEntry.Info.Delete();
     }
     return Task.FromResult(0);
 }
        /// <inheritdoc/>
        public Task<IUnixFileSystemEntry> MoveAsync(IUnixDirectoryEntry parent, IUnixFileSystemEntry source, IUnixDirectoryEntry target, string fileName, CancellationToken cancellationToken)
        {
            var targetEntry = (DotNetDirectoryEntry)target;
            var targetName = Path.Combine(targetEntry.Info.FullName, fileName);

            var sourceFileEntry = source as DotNetFileEntry;
            if (sourceFileEntry != null)
            {
                sourceFileEntry.Info.MoveTo(targetName);
                return Task.FromResult<IUnixFileSystemEntry>(new DotNetFileEntry(this, new FileInfo(targetName)));
            }

            var sourceDirEntry = (DotNetDirectoryEntry)source;
            sourceDirEntry.Info.MoveTo(targetName);
            return Task.FromResult<IUnixFileSystemEntry>(new DotNetDirectoryEntry(this, new DirectoryInfo(targetName), false));
        }
        /// <summary>
        /// Sets the modify/access/create timestamp of a file system item
        /// </summary>
        /// <param name="entry">The <see cref="IUnixFileSystemEntry"/> to change the timestamp for</param>
        /// <param name="modify">The modification timestamp</param>
        /// <param name="access">The access timestamp</param>
        /// <param name="create">The creation timestamp</param>
        /// <param name="cancellationToken">The cancellation token</param>
        /// <returns>The modified <see cref="IUnixFileSystemEntry"/></returns>
        public Task<IUnixFileSystemEntry> SetMacTimeAsync(IUnixFileSystemEntry entry, DateTimeOffset? modify, DateTimeOffset? access, DateTimeOffset? create, CancellationToken cancellationToken)
        {
            var dirEntry = entry as DotNetDirectoryEntry;
            var fileEntry = entry as DotNetFileEntry;

            FileSystemInfo item;
            if (dirEntry != null)
            {
                item = dirEntry.Info;
            }
            else if (fileEntry != null)
            {
                item = fileEntry.Info;
            }
            else
            {
                throw new ArgumentException("Argument must be of type DotNetDirectoryEntry or DotNetFileEntry", nameof(entry));
            }

            if (access != null)
                item.LastAccessTimeUtc = access.Value.UtcDateTime;
            if (modify != null)
                item.LastWriteTimeUtc = modify.Value.UtcDateTime;
            if (create != null)
                item.CreationTimeUtc = create.Value.UtcDateTime;
            if (dirEntry != null)
                return Task.FromResult<IUnixFileSystemEntry>(new DotNetDirectoryEntry(this, (DirectoryInfo)item, dirEntry.IsRoot));
            return Task.FromResult<IUnixFileSystemEntry>(new DotNetFileEntry(this, (FileInfo)item));
        }
 /// <inheritdoc/>
 public async Task UnlinkAsync(IUnixFileSystemEntry entry, CancellationToken cancellationToken)
 {
     var dirEntry = entry as GoogleDriveDirectoryEntry;
     if (dirEntry != null)
     {
         await Service.TrashAsync(dirEntry.File, cancellationToken);
     }
     else
     {
         var fileEntry = (GoogleDriveFileEntry)entry;
         await Service.TrashAsync(fileEntry.File, cancellationToken);
     }
 }