VsOfflineInstallerHelper/ConfigLoading.cs at master · nobyArdor/VsOfflineInstallerHelper · GitHub

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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
using Utf8Json;
using VsCodeInstallerHelper.ConfigModels;
using VsCodeInstallerHelper.Extensions;
using VYaml.Serialization;

namespace VsCodeInstallerHelper;
internal static class ConfigLoading
{
    internal static async Task<LoadFileConfig?> LoadFileConfig(string configFile)
    {
        if (!File.Exists(configFile))
        {
            Error($"Config file '{configFile}' does not exist.");
            return null;
        }

        if (!Path.HasExtension(configFile))
            return await LoadAny(configFile);

        var extension = Path.GetExtension(configFile);
        return extension switch
        {
            ".yaml" or ".yml" => await LoadYaml(configFile),
            ".json" => await LoadJson(configFile),
            _ => NullError(configFile)
        };
    }


    internal static LoadFileConfig? NullError(string fileName)
    {
        Error($"Config file '{fileName}' has not supported extensions.");
        return null;
    }

    internal static async Task<LoadFileConfig?> LoadYaml(string filePath)
    {

        try
        {
            var fileStream = File.OpenRead(filePath);
            await using var stream = fileStream.ConfigureAwait(false);
            var config = await YamlSerializer.DeserializeAsync<LoadFileConfig>(fileStream);
            return config;
        }
        catch (Exception ex)
        {
            Error($"Failed to load configuration from '{filePath}': {ex.Message}");
            return null;
        }
    }

    static async Task<LoadFileConfig?> LoadJson(string filePath)
    {

        try
        {
            var fileStream = File.OpenRead(filePath);
            await using var stream = fileStream.ConfigureAwait(false);
            var config = await JsonSerializer.DeserializeAsync<LoadFileConfig?>(fileStream);
            return config;
        }
        catch (Exception ex)
        {
            Error($"Failed to load configuration from '{filePath}': {ex.Message}");
            return null;
        }
    }

    static async Task<LoadFileConfig?> LoadAny(string filePath)
    {

        try
        {
            var config = await LoadYaml(filePath);
            return config;
        }
        catch (Exception ex)
        {
            try
            {
                var config = await LoadJson(filePath);
                return config;
            }
            catch (Exception ex2)
            {
                Error($"Failed to load configuration from '{filePath}': {ex.Message} -- {ex2.Message}");
                return null;
            }
        }
    }

    internal static async Task LoadConfigs(IEnumerable<string> configPaths, List<LoadFileConfig> loadedConfigs)
    {
        while (true)
        {
            var nextParseConfigPaths = new List<string>();
            foreach (var configFilePath in configPaths)
            {
                var fileConfig = await ConfigLoading.LoadFileConfig(configFilePath);

                if (fileConfig is null)
                {
                    Error($"Config file '{configFilePath}' has parsing error");
                    return;
                }

                loadedConfigs.Add(fileConfig);
                if (!fileConfig.Include.HasContent(out var include))
                    continue;

                var workDir = Path.IsPathFullyQualified(configFilePath) ? Path.GetDirectoryName(configFilePath) : Directory.GetCurrentDirectory();
                include = include.Select(configPath =>
                        FileLikeArgsProcessing.UpdateFileSystemPath(configPath, workDir, true, true))
                    .ToArray();

                nextParseConfigPaths.AddRange(include);
            }

            if (nextParseConfigPaths.Count > 0)
            {
                configPaths = nextParseConfigPaths;
                continue;
            }

            break;
        }
    }

}