NdsHostDirectoryImporter.cs

namespace NdsForge;

internal static class NdsHostDirectoryImporter
{
    public static async ValueTask<NdsHostDirectorySnapshot> StageAsync(
        string sourceDirectory,
        string destinationDirectory,
        NdsDirectoryImportOptions options,
        CancellationToken cancellationToken)
    {
        string sourceRoot = Path.GetFullPath(sourceDirectory);
        if (!Directory.Exists(sourceRoot))
        {
            throw new DirectoryNotFoundException($"Host import directory was not found: {sourceRoot}");
        }
 
        if ((File.GetAttributes(sourceRoot) & FileAttributes.ReparsePoint) != 0)
        {
            throw new IOException("The host import root cannot itself be a link or reparse point.");
        }
 
        var directories = new List<string> { destinationDirectory };
        var files = new List<NdsHostFileSnapshot>();
        var pending = new Stack<(string Host, string Relative)>();
        pending.Push((sourceRoot, string.Empty));
        long totalBytes = 0;
        int skipped = 0;
        while (pending.Count != 0)
        {
            cancellationToken.ThrowIfCancellationRequested();
            (string hostDirectory, string relativeDirectory) = pending.Pop();
            string[] entries = Directory.EnumerateFileSystemEntries(hostDirectory)
                .Order(StringComparer.Ordinal)
                .ToArray();
            for (int index = entries.Length - 1; index >= 0; index--)
            {
                string entry = entries[index];
                FileAttributes attributes = File.GetAttributes(entry);
                if ((attributes & FileAttributes.ReparsePoint) != 0)
                {
                    if (options.LinkPolicy == NdsHostLinkPolicy.Reject)
                    {
                        throw new IOException($"Host import encountered a link or reparse point: {entry}");
                    }
 
                    skipped++;
                    continue;
                }
 
                string relative = string.IsNullOrEmpty(relativeDirectory)
                    ? Path.GetFileName(entry)
                    : relativeDirectory + "/" + Path.GetFileName(entry);
                string target = Combine(destinationDirectory, relative);
                if ((attributes & FileAttributes.Directory) != 0)
                {
                    directories.Add(target);
                    pending.Push((entry, relative));
                    continue;
                }
 
                if (files.Count >= options.MaximumFiles)
                {
                    throw new InvalidDataException("Host directory import exceeds the configured file-count limit.");
                }
                long length = new FileInfo(entry).Length;
                if (length > options.MaximumTotalBytes - totalBytes || length > Array.MaxLength)
                {
                    throw new InvalidDataException("Host directory import exceeds the configured byte allocation limit.");
                }
 
                byte[] contents = await File.ReadAllBytesAsync(entry, cancellationToken).ConfigureAwait(false);
                if (contents.LongLength > options.MaximumTotalBytes - totalBytes)
                {
                    throw new InvalidDataException("A host file changed size and exceeded the import allocation limit while being read.");
                }
 
                totalBytes = checked(totalBytes + contents.LongLength);
                files.Add(new(target, contents));
            }
        }
 
        return new(
            directories.Distinct(StringComparer.Ordinal).Order(StringComparer.Ordinal).ToArray(),
            files.OrderBy(static value => value.Path, StringComparer.Ordinal).ToArray(),
            totalBytes,
            skipped);
    }

    private static string Combine(string destinationDirectory, string relativePath) =>
        NdsFileSystemBuilder.NormalizePath(
            destinationDirectory == "/" ? "/" + relativePath : destinationDirectory + "/" + relativePath,
            allowRoot: true);
}

internal sealed record NdsHostFileSnapshot(string Path, byte[] Contents);

internal sealed record NdsHostDirectorySnapshot(
    string[] Directories,
    NdsHostFileSnapshot[] Files,
    long TotalBytes,
    int SkippedLinks);