DefaultIOManager.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
 
using Tgstation.Server.Host.Utils;
 
namespace Tgstation.Server.Host.IO
{
    class DefaultIOManager : IIOManager
    {
        public const string CurrentDirectory = ".";
 
        public const int DefaultBufferSize = 4096;
 
        public const TaskCreationOptions BlockingTaskCreationOptions = TaskCreationOptions.None;
 
        static void NormalizeAndDelete(DirectoryInfo dir, CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();
 
            // check if we are a symbolic link
            if (!dir.Attributes.HasFlag(FileAttributes.Directory) || dir.Attributes.HasFlag(FileAttributes.ReparsePoint))
            {
                dir.Delete();
                return;
            }
 
            foreach (var subDir in dir.EnumerateDirectories())
                NormalizeAndDelete(subDir, cancellationToken);
 
            foreach (var file in dir.EnumerateFiles())
            {
                cancellationToken.ThrowIfCancellationRequested();
                try
                {
                    file.Attributes = FileAttributes.Normal;
                    file.Delete();
                }
                catch (FileNotFoundException)
                {
                    // has happened before with .dyn.rsc.lk
                }
            }
 
            cancellationToken.ThrowIfCancellationRequested();
            dir.Delete(true);
        }
 
        public async ValueTask CopyDirectory(
            IEnumerable<string>? ignore,
            Func<string, string, ValueTask>? postCopyCallback,
            string src,
            string dest,
            int? taskThrottle,
            CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(src);
            ArgumentNullException.ThrowIfNull(src);
 
            if (taskThrottle.HasValue && taskThrottle < 1)
                throw new ArgumentOutOfRangeException(nameof(taskThrottle), taskThrottle, "taskThrottle must be at least 1!");
 
            src = ResolvePath(src);
            dest = ResolvePath(dest);
 
            using var semaphore = taskThrottle.HasValue ? new SemaphoreSlim(taskThrottle.Value) : null;
            await Task.WhenAll(CopyDirectoryImpl(src, dest, ignore, postCopyCallback, semaphore, cancellationToken));
        }
 
        public string ConcatPath(params string[] paths) => Path.Combine(paths);
 
        public async ValueTask CopyFile(string src, string dest, CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(src);
            ArgumentNullException.ThrowIfNull(dest);
 
            // tested to hell and back, these are the optimal buffer sizes
            await using var srcStream = new FileStream(
                ResolvePath(src),
                FileMode.Open,
                FileAccess.Read,
                FileShare.Read | FileShare.Delete,
                DefaultBufferSize,
                FileOptions.Asynchronous | FileOptions.SequentialScan);
            await using var destStream = CreateAsyncSequentialWriteStream(dest);
 
            // value taken from documentation
            await srcStream.CopyToAsync(destStream, 81920, cancellationToken);
        }
 
        public Task CreateDirectory(string path, CancellationToken cancellationToken) => Task.Factory.StartNew(() => Directory.CreateDirectory(ResolvePath(path)), cancellationToken, BlockingTaskCreationOptions, TaskScheduler.Current);
 
        public Task DeleteDirectory(string path, CancellationToken cancellationToken)
        {
            path = ResolvePath(path);
            var di = new DirectoryInfo(path);
            if (!di.Exists)
                return Task.CompletedTask;
 
            return Task.Factory.StartNew(
                () => NormalizeAndDelete(di, cancellationToken),
                cancellationToken,
                BlockingTaskCreationOptions,
                TaskScheduler.Current);
        }
 
        public Task DeleteFile(string path, CancellationToken cancellationToken) => Task.Factory.StartNew(() => File.Delete(ResolvePath(path)), cancellationToken, BlockingTaskCreationOptions, TaskScheduler.Current);
 
        public Task<bool> FileExists(string path, CancellationToken cancellationToken) => Task.Factory.StartNew(() => File.Exists(ResolvePath(path)), cancellationToken, BlockingTaskCreationOptions, TaskScheduler.Current);
 
        public Task<bool> DirectoryExists(string path, CancellationToken cancellationToken) => Task.Factory.StartNew(() => Directory.Exists(ResolvePath(path)), cancellationToken, BlockingTaskCreationOptions, TaskScheduler.Current);
 
        public string GetDirectoryName(string path) => Path.GetDirectoryName(path ?? throw new ArgumentNullException(nameof(path)))
            ?? throw new InvalidOperationException($"Null was returned. Path ({path}) must be rooted. This is not supported!");
 
        public string GetFileName(string path) => Path.GetFileName(path ?? throw new ArgumentNullException(nameof(path)));
 
        public string GetFileNameWithoutExtension(string path) => Path.GetFileNameWithoutExtension(path ?? throw new ArgumentNullException(nameof(path)));
 
        public Task<List<string>> GetFilesWithExtension(string path, string extension, bool recursive, CancellationToken cancellationToken) => Task.Factory.StartNew(
            () =>
            {
                path = ResolvePath(path);
                ArgumentNullException.ThrowIfNull(extension);
                var results = new List<string>();
                foreach (var fileName in Directory.EnumerateFiles(
                    path,
                    $"*.{extension}",
                    recursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly))
                {
                    cancellationToken.ThrowIfCancellationRequested();
                    results.Add(fileName);
                }
 
                return results;
            },
            cancellationToken,
            BlockingTaskCreationOptions,
            TaskScheduler.Current);
 
        public Task MoveFile(string source, string destination, CancellationToken cancellationToken) => Task.Factory.StartNew(
            () =>
            {
                ArgumentNullException.ThrowIfNull(destination);
                source = ResolvePath(source ?? throw new ArgumentNullException(nameof(source)));
                destination = ResolvePath(destination);
                File.Move(source, destination);
            },
            cancellationToken,
            BlockingTaskCreationOptions,
            TaskScheduler.Current);
 
        public Task MoveDirectory(string source, string destination, CancellationToken cancellationToken) => Task.Factory.StartNew(
            () =>
            {
                ArgumentNullException.ThrowIfNull(destination);
                source = ResolvePath(source ?? throw new ArgumentNullException(nameof(source)));
                destination = ResolvePath(destination);
                Directory.Move(source, destination);
            },
            cancellationToken,
            BlockingTaskCreationOptions,
            TaskScheduler.Current);
 
        public async ValueTask<byte[]> ReadAllBytes(string path, CancellationToken cancellationToken)
        {
            path = ResolvePath(path);
            await using var file = new FileStream(
                path,
                FileMode.Open,
                FileAccess.Read,
                FileShare.ReadWrite | FileShare.Delete,
                DefaultBufferSize,
                FileOptions.Asynchronous | FileOptions.SequentialScan);
            byte[] buf;
            buf = new byte[file.Length];
            await file.ReadAsync(buf, cancellationToken);
            return buf;
        }
 
        public string ResolvePath() => ResolvePath(CurrentDirectory);
 
        public virtual string ResolvePath(string path) => Path.GetFullPath(path ?? throw new ArgumentNullException(nameof(path)));
 
        public async ValueTask WriteAllBytes(string path, byte[] contents, CancellationToken cancellationToken)
        {
            await using var file = CreateAsyncSequentialWriteStream(path);
            await file.WriteAsync(contents, cancellationToken);
        }
 
        public FileStream CreateAsyncSequentialWriteStream(string path)
        {
            path = ResolvePath(path);
            return new FileStream(
                path,
                FileMode.Create,
                FileAccess.Write,
                FileShare.Read | FileShare.Delete,
                DefaultBufferSize,
                FileOptions.Asynchronous | FileOptions.SequentialScan);
        }
 
        public Task<IReadOnlyList<string>> GetDirectories(string path, CancellationToken cancellationToken) => Task.Factory.StartNew(
            () =>
            {
                path = ResolvePath(path);
                var results = new List<string>();
                cancellationToken.ThrowIfCancellationRequested();
                foreach (var directoryName in Directory.EnumerateDirectories(path))
                {
                    results.Add(directoryName);
                    cancellationToken.ThrowIfCancellationRequested();
                }
 
                return (IReadOnlyList<string>)results;
            },
            cancellationToken,
            BlockingTaskCreationOptions,
            TaskScheduler.Current);
 
        public Task<IReadOnlyList<string>> GetFiles(string path, CancellationToken cancellationToken) => Task.Factory.StartNew(
            () =>
            {
                path = ResolvePath(path);
                var results = new List<string>();
                cancellationToken.ThrowIfCancellationRequested();
                foreach (var fileName in Directory.EnumerateFiles(path))
                {
                    results.Add(fileName);
                    cancellationToken.ThrowIfCancellationRequested();
                }
 
                return (IReadOnlyList<string>)results;
            },
            cancellationToken,
            BlockingTaskCreationOptions,
            TaskScheduler.Current);
 
        public Task ZipToDirectory(string path, Stream zipFile, CancellationToken cancellationToken) => Task.Factory.StartNew(
            () =>
            {
                path = ResolvePath(path);
                ArgumentNullException.ThrowIfNull(zipFile);
 
#if NET9_0_OR_GREATER
#error Check if zip file seeking has been addressesed. See https://github.com/tgstation/tgstation-server/issues/1531
#endif
 
                // ZipArchive does a synchronous copy on unseekable streams we want to avoid
                if (!zipFile.CanSeek)
                    throw new ArgumentException("Stream does not support seeking!", nameof(zipFile));
 
                using var archive = new ZipArchive(zipFile, ZipArchiveMode.Read, true);
                archive.ExtractToDirectory(path);
            },
            cancellationToken,
            BlockingTaskCreationOptions,
            TaskScheduler.Current);
 
        public bool PathContainsParentAccess(string path) => path
            ?.Split(
                [
                    Path.DirectorySeparatorChar,
                    Path.AltDirectorySeparatorChar,
                ])
            .Any(x => x == "..")
            ?? throw new ArgumentNullException(nameof(path));
 
        public Task<DateTimeOffset> GetLastModified(string path, CancellationToken cancellationToken) => Task.Factory.StartNew(
            () =>
            {
                path = ResolvePath(path ?? throw new ArgumentNullException(nameof(path)));
                var fileInfo = new FileInfo(path);
                return new DateTimeOffset(fileInfo.LastWriteTimeUtc);
            },
            cancellationToken,
            BlockingTaskCreationOptions,
            TaskScheduler.Current);
 
        public FileStream GetFileStream(string path, bool shareWrite) => new(
            ResolvePath(path),
            FileMode.Open,
            FileAccess.Read,
            FileShare.Read | FileShare.Delete | (shareWrite ? FileShare.Write : FileShare.None),
            DefaultBufferSize,
            true);
 
        IEnumerable<Task> CopyDirectoryImpl(
            string src,
            string dest,
            IEnumerable<string>? ignore,
            Func<string, string, ValueTask>? postCopyCallback,
            SemaphoreSlim? semaphore,
            CancellationToken cancellationToken)
        {
            var dir = new DirectoryInfo(src);
            Task? subdirCreationTask = null;
            foreach (var subDirectory in dir.EnumerateDirectories())
            {
                if (ignore != null && ignore.Contains(subDirectory.Name))
                    continue;
 
                var checkingSubdirCreationTask = true;
                foreach (var copyTask in CopyDirectoryImpl(subDirectory.FullName, Path.Combine(dest, subDirectory.Name), null, postCopyCallback, semaphore, cancellationToken))
                {
                    if (subdirCreationTask == null)
                    {
                        subdirCreationTask = copyTask;
                        yield return subdirCreationTask;
                    }
                    else if (!checkingSubdirCreationTask)
                        yield return copyTask;
 
                    checkingSubdirCreationTask = false;
                }
            }
 
            foreach (var fileInfo in dir.EnumerateFiles())
            {
                if (subdirCreationTask == null)
                {
                    subdirCreationTask = CreateDirectory(dest, cancellationToken);
                    yield return subdirCreationTask;
                }
 
                if (ignore != null && ignore.Contains(fileInfo.Name))
                    continue;
 
                var sourceFile = fileInfo.FullName;
                var destFile = ConcatPath(dest, fileInfo.Name);
 
                async Task CopyThisFile()
                {
                    await subdirCreationTask.WaitAsync(cancellationToken);
                    using var lockContext = semaphore != null
                        ? await SemaphoreSlimContext.Lock(semaphore, cancellationToken)
                        : null;
                    await CopyFile(sourceFile, destFile, cancellationToken);
                    if (postCopyCallback != null)
                        await postCopyCallback(sourceFile, destFile);
                }
 
                yield return CopyThisFile();
            }
        }
    }
}