summary refs log tree commit diff
path: root/Rhea.Nar.Validator/Program.cs
blob: 14f9c2249d65e18ad40f0dc8af7d071d0d361117 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
using System.Diagnostics;
using ArcaneLibs;
using ArcaneLibs.Extensions;
using Rhea.Nar;

// A simple app to compare output between cppnix/Lix and the NAR serializer
int maxVerifySize = 1024 * 1024 * 1024;

// return;
// while (true)
// foreach (var srcPath in (string[])[
//              "/etc/nix/nix.conf", 
//              FileUtils.GetBinDir() + "/Rhea.runtimeconfig.json", 
//              "/etc/nix", 
//              ".",
//              "/nix/store/06d2xkrl3h1pbyg3m1whz1mvhafqgsqq-source",
//              "/nix/store/0l93s9x3z2s9p4r58jls0xiyk64hwkxz-source",
//              "/nix/store/2g4sa9xcir93nckzib9iq1ky6ly6azgw-7j1q60m17gf95k3s0gk2qvjqygnp1q36-source"
//          ])
// foreach (var srcPath in (string[])["/nix/store/7j1q60m17gf95k3s0gk2qvjqygnp1q36-source"])
Parallel.ForEach(FileUtils.EnumerateDirectory("/nix/store")
        .Where(x => x is DirectoryInfo)
        .Select(x => x.FullName),
    new() { MaxDegreeOfParallelism = 64 },
    srcPath =>
        // foreach (var srcPath in FileUtils.EnumerateDirectory("/nix/store").Select(x=>x.FullName))
    {
        var sw = Stopwatch.StartNew();
        TimeSpan oldTime, newTime;
        var log = "";
        log += ($"\n - {srcPath}:");
        bool tooLarge = false;
        // Console.WriteLine($"Original {srcPath}:");

        var origBuf = new List<byte>();
        var nixProcess = Process.Start(new ProcessStartInfo("nix", ["nar", "dump-path", srcPath])
        {
            RedirectStandardOutput = true
        });
        int b;
        byte[] oldBuf = new byte[16384];
        while ((b = nixProcess.StandardOutput.BaseStream.Read(oldBuf)) != 0)
        {
            if (!tooLarge)
            {
                if (origBuf.Count < maxVerifySize)
                    origBuf.AddRange(oldBuf[..b]);
                else tooLarge = true;
            }
            // Console.WriteLine(b + " @ " + sw.Elapsed + " -> " + Util.BytesToString(origBuf.Count));
            // Thread.Sleep(1);
        }

        // origBuf.ToArray().HexDump(64);
        oldTime = sw.GetElapsedAndRestart();

        // Console.WriteLine($"\nNew {srcPath}:");
        List<byte> tbuf = [];
        // List<byte> buf = [];
        foreach (var chunk in new NarWriter().GetNarStreamContents(srcPath))
        {
            // Console.WriteLine($"ret Chunk({chunk.Length})");
            if (!tooLarge)
            {
                if (tbuf.Count < maxVerifySize)
                    tbuf.AddRange(chunk);
                else tooLarge = true;
            }
            // buf.AddRange(chunk);
            // while (buf.Count > 64)
            // {
            //     byte[] data = buf[..64].ToArray();
            //     buf = buf[64..];
            //     data.HexDump(64);
            // }
        }

        // buf.ToArray().HexDump(64);
        newTime = sw.GetElapsedAndRestart();

        log += ($"\nOld time: {oldTime}, new time: {newTime}");
        if (!tooLarge)
        {
            log += ("\nIs equal: " + origBuf.SequenceEqual(tbuf));
            if (!origBuf.SequenceEqual(tbuf))
            {
                // File.WriteAllBytes("a", origBuf.ToArray().AsHexString().AsBytes().ToArray());
                // File.WriteAllBytes("b", tbuf.ToArray().AsHexString().AsBytes().ToArray());
                var origStdout = Console.Out;
                using (var fs = File.OpenWrite("a"))
                {
                    using var fsw = new StreamWriter(fs);
                    Console.SetOut(fsw);
                    origBuf.HexDump(width: 16, colorize: false);
                    Console.SetOut(origStdout);
                }
            
                using (var fs = File.OpenWrite("b"))
                {
                    using var fsw = new StreamWriter(fs);
                    Console.SetOut(fsw);
                    tbuf.HexDump(width: 16, colorize: false);
                    Console.SetOut(origStdout);
                }
            
                Console.WriteLine(log);
                Environment.Exit(0);
            }
        }
        else log += "\nToo large to check consistency";

        Console.WriteLine(log);
    }
);