11762631757

Committed 08 Nov 2024 01:44PM UTC coverage: 84.369%. Remained the same

Build # 11762631757

Build Type

push

github

Committed by

me-viper

Commit Message

chore: Apply formatting rules

Run Details

1820 of 2364 branches covered (76.99%)

Branch coverage included in aggregate %.

7 of 7 new or added lines in 3 files covered. (100.0%)

82 existing lines in 15 files now uncovered.

3815 of 4315 relevant lines covered (88.41%)

1719.55 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

69.59

/src/Compilation.Abstractions/src/BundleWriter.cs

﻿using System.Formats.Tar;
using System.IO.Compression;
using System.Runtime.InteropServices;
using System.Text;
using System.Text.Json;
using System.Text.Json.Nodes;

using Microsoft.Extensions.FileSystemGlobbing;
using Microsoft.Extensions.FileSystemGlobbing.Abstractions;

using MemoryStream = System.IO.MemoryStream;

namespace OpaDotNet.Compilation.Abstractions;

/// <summary>
/// Implements writing files into OPA policy bundle.
/// </summary>
/// <remarks>You need to dispose <see cref="BundleWriter"/> instance before you can use resulting bundle.</remarks>
/// <example>
/// <code>
/// using var ms = new MemoryStream();
///
/// using (var writer = new BundleWriter(ms))
/// {
///     writer.WriteEntry("package test", "policy.rego");
/// }
///
/// // Now bundle have been constructed.
/// ms.Seek(0, SeekOrigin.Begin);
/// ...
/// </code>
/// </example>
[PublicAPI]
public sealed class BundleWriter : IDisposable, IAsyncDisposable
{
    private readonly TarWriter _writer;

    /// <summary>
    /// <c>true</c> if BundleWriter has no entries written; otherwise <c>false</c>.
    /// </summary>
    public bool IsEmpty { get; private set; }

    /// <summary>
    /// Creates new instance of <see cref="BundleWriter"/>.
    /// </summary>
    /// <param name="stream">Stream to write bundle to.</param>
    /// <param name="manifest">Policy bundle manifest.</param>
    public BundleWriter(Stream stream, BundleManifest? manifest = null)
    {
        ArgumentNullException.ThrowIfNull(stream);

        var zip = new GZipStream(stream, CompressionMode.Compress, true);
        _writer = new TarWriter(zip);

        if (manifest != null)
            WriteEntry(JsonSerializer.Serialize(manifest), ".manifest");
    }

    private static string NormalizePath(string path) => "/" + path.Replace("\\", "/").TrimStart('/');

    /// <summary>
    /// Merges two capabilities.json streams.
    /// </summary>
    /// <param name="caps1">First capabilities.json stream.</param>
    /// <param name="caps2">Second capabilities.json stream.</param>
    /// <returns>New merged capabilities.json stream.</returns>
    public static Stream MergeCapabilities(Stream caps1, Stream caps2)
    {
        ArgumentNullException.ThrowIfNull(caps1);
        ArgumentNullException.ThrowIfNull(caps2);

        var resultDoc = JsonNode.Parse(caps1);

        if (resultDoc == null)
            throw new RegoCompilationException("Failed to parse capabilities file");

        var resultBins = resultDoc.Root["builtins"]?.AsArray();

        if (resultBins == null)
            throw new RegoCompilationException("Invalid capabilities file: 'builtins' node not found");

        var capsDoc = JsonDocument.Parse(caps2);
        var capsBins = capsDoc.RootElement.GetProperty("builtins");

        foreach (var bin in capsBins.EnumerateArray())
        {
            JsonNode? node = bin.ValueKind switch
            {
                JsonValueKind.Array => JsonArray.Create(bin),
                JsonValueKind.Object => JsonObject.Create(bin),
                _ => JsonValue.Create(bin)
            };

            resultBins.Add(node);
        }

        var ms = new MemoryStream();

        using (var jw = new Utf8JsonWriter(ms))
        {
            resultDoc.WriteTo(jw);
        }

        ms.Seek(0, SeekOrigin.Begin);

        return ms;
    }

    /// <summary>
    /// Creates new instance of <see cref="BundleWriter"/> and populates it with files in <paramref name="path"/>.
    /// </summary>
    /// <param name="stream">Stream to write bundle to.</param>
    /// <param name="path">Path containing bundle source files.</param>
    /// <param name="exclusions">File name patterns for files the BundleWriter should exclude from the results.</param>
    public static BundleWriter FromDirectory(
        Stream stream,
        string path,
        IReadOnlySet<string>? exclusions)
    {
        var di = new DirectoryInfo(path);

        if (!di.Exists)
            throw new DirectoryNotFoundException($"Directory {di.FullName} was not found");

        var comparison = RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
            ? StringComparison.OrdinalIgnoreCase
            : StringComparison.Ordinal;

        var glob = new Matcher(comparison);
        glob.AddInclude("**/data.json");
        glob.AddInclude("**/data.yaml");
        glob.AddInclude("**/*.rego");
        glob.AddInclude("**/policy.wasm");
        glob.AddInclude("**/.manifest");

        if (exclusions != null)
        {
            foreach (var excl in exclusions)
                glob.AddExclude(excl);
        }

        var matches = glob.Execute(new DirectoryInfoWrapper(di));

        var writer = new BundleWriter(stream);

        foreach (var file in matches.Files)
        {
            var filePath = string.IsNullOrWhiteSpace(file.Stem) || string.Equals(file.Path, file.Stem, StringComparison.Ordinal)
                ? file.Path
                : Path.Combine(file.Path, file.Stem);

            var fullPath = Path.Combine(di.FullName, filePath);

            using var fs = new FileStream(fullPath, FileMode.Open, FileAccess.Read);
            writer.WriteEntry(fs, filePath);
        }

        return writer;
    }

    /// <summary>
    /// Writes string content into bundle.
    /// </summary>
    /// <param name="str">String content.</param>
    /// <param name="path">Relative file path inside bundle.</param>
    public void WriteEntry(ReadOnlySpan<char> str, string path)
    {
        ArgumentException.ThrowIfNullOrEmpty(path);

        Span<byte> bytes = new byte[Encoding.UTF8.GetByteCount(str)];
        _ = Encoding.UTF8.GetBytes(str, bytes);

        WriteEntry(bytes, path);
    }

    /// <summary>
    /// Writes bytes content into bundle.
    /// </summary>
    /// <param name="bytes">String content.</param>
    /// <param name="path">Relative file path inside bundle.</param>
    public void WriteEntry(ReadOnlySpan<byte> bytes, string path)
    {
        ArgumentException.ThrowIfNullOrEmpty(path);

        using var ms = new MemoryStream(bytes.Length);
        ms.Write(bytes);
        ms.Seek(0, SeekOrigin.Begin);

        WriteEntry(ms, path);
    }

    /// <summary>
    /// Writes stream content into bundle.
    /// </summary>
    /// <param name="stream">String content.</param>
    /// <param name="path">Relative file path inside bundle.</param>
    public void WriteEntry(Stream stream, string path)
    {
        ArgumentNullException.ThrowIfNull(stream);
        ArgumentException.ThrowIfNullOrEmpty(path);

        if (Path.IsPathRooted(path))
        {
            if (Path.GetPathRoot(path)?[0] != Path.DirectorySeparatorChar)
                path = path[2..];
        }

        var entry = new PaxTarEntry(TarEntryType.RegularFile, NormalizePath(path))
        {
            DataStream = stream,
        };

        _writer.WriteEntry(entry);
        IsEmpty = false;
    }

    /// <summary>
    /// Merges contents of source bundle into this bundle.
    /// </summary>
    /// <param name="bundle">Source bundle.</param>
    public void WriteBundle(Span<byte> bundle)
    {
        using var ms = new MemoryStream(bundle.Length);
        ms.Write(bundle);
        ms.Seek(0, SeekOrigin.Begin);

        WriteBundle(ms);
    }

    /// <summary>
    /// Merges contents of source bundle into this bundle.
    /// </summary>
    /// <param name="bundle">Source bundle.</param>
    public void WriteBundle(Stream bundle)
    {
        ArgumentNullException.ThrowIfNull(bundle);

        using var gzip = new GZipStream(bundle, CompressionMode.Decompress);
        using var ms = new MemoryStream();

        gzip.CopyTo(ms);
        ms.Seek(0, SeekOrigin.Begin);

        using var tr = new TarReader(ms);

        while (tr.GetNextEntry() is { } sourceEntry)
        {
            var entry = new PaxTarEntry(sourceEntry);
            _writer.WriteEntry(entry);
        }
    }

    /// <summary>
    /// Writes contents of file into bundle.
    /// </summary>
    /// <param name="path">File to write.</param>
    /// <param name="overridePath">Relative file path inside bundle.</param>
    public void WriteFile(string path, string? overridePath = null)
    {
        using var fs = new FileStream(path, FileMode.Open, FileAccess.Read);
        var targetPath = overridePath ?? path;
        WriteEntry(fs, targetPath);
    }

    /// <summary>
    /// Writes manifest into bundle.
    /// </summary>
    /// <param name="manifest">Policy bundle manifest.</param>
    public void WriteManifest(BundleManifest manifest)
    {
        ArgumentNullException.ThrowIfNull(manifest);

        WriteEntry(JsonSerializer.Serialize(manifest), ".manifest");
    }

    /// <inheritdoc />
    public void Dispose()
    {
        _writer.Dispose();
    }

    /// <inheritdoc />
    public async ValueTask DisposeAsync()
    {
        await _writer.DisposeAsync().ConfigureAwait(false);
    }
}

1	using System.Formats.Tar;
2	using System.IO.Compression;
3	using System.Runtime.InteropServices;
4	using System.Text;
5	using System.Text.Json;
6	using System.Text.Json.Nodes;
7
8	using Microsoft.Extensions.FileSystemGlobbing;
9	using Microsoft.Extensions.FileSystemGlobbing.Abstractions;
10
11	using MemoryStream = System.IO.MemoryStream;
12
13	namespace OpaDotNet.Compilation.Abstractions;
14
15	/// <summary>
16	/// Implements writing files into OPA policy bundle.
17	/// </summary>
18	/// <remarks>You need to dispose <see cref="BundleWriter"/> instance before you can use resulting bundle.</remarks>
19	/// <example>
20	/// <code>
21	/// using var ms = new MemoryStream();
22	///
23	/// using (var writer = new BundleWriter(ms))
24	/// {
25	/// writer.WriteEntry("package test", "policy.rego");
26	/// }
27	///
28	/// // Now bundle have been constructed.
29	/// ms.Seek(0, SeekOrigin.Begin);
30	/// ...
31	/// </code>
32	/// </example>
33	[PublicAPI]
34	public sealed class BundleWriter : IDisposable, IAsyncDisposable
35	{
36	private readonly TarWriter _writer;
37
38	/// <summary>
39	/// <c>true</c> if BundleWriter has no entries written; otherwise <c>false</c>.
40	/// </summary>
41	public bool IsEmpty { get; private set; }	2,168✔
42
43	/// <summary>
44	/// Creates new instance of <see cref="BundleWriter"/>.
45	/// </summary>
46	/// <param name="stream">Stream to write bundle to.</param>
47	/// <param name="manifest">Policy bundle manifest.</param>
48	public BundleWriter(Stream stream, BundleManifest? manifest = null)	874✔
49	{
50	ArgumentNullException.ThrowIfNull(stream);	874✔
51
52	var zip = new GZipStream(stream, CompressionMode.Compress, true);	874✔
53	_writer = new TarWriter(zip);	874✔
54
55	if (manifest != null)	874✔
56	WriteEntry(JsonSerializer.Serialize(manifest), ".manifest");	2✔
57	}	874✔
58
59	private static string NormalizePath(string path) => "/" + path.Replace("\\", "/").TrimStart('/');	2,160✔
60
61	/// <summary>
62	/// Merges two capabilities.json streams.
63	/// </summary>
64	/// <param name="caps1">First capabilities.json stream.</param>
65	/// <param name="caps2">Second capabilities.json stream.</param>
66	/// <returns>New merged capabilities.json stream.</returns>
67	public static Stream MergeCapabilities(Stream caps1, Stream caps2)
68	{
69	ArgumentNullException.ThrowIfNull(caps1);	28✔
70	ArgumentNullException.ThrowIfNull(caps2);	28✔
71
72	var resultDoc = JsonNode.Parse(caps1);	28✔
73
74	if (resultDoc == null)	28!
UNCOV 75	throw new RegoCompilationException("Failed to parse capabilities file");	×
76
77	var resultBins = resultDoc.Root["builtins"]?.AsArray();	28!
78
79	if (resultBins == null)	28!
UNCOV 80	throw new RegoCompilationException("Invalid capabilities file: 'builtins' node not found");	×
81
82	var capsDoc = JsonDocument.Parse(caps2);	28✔
83	var capsBins = capsDoc.RootElement.GetProperty("builtins");	28✔
84
85	foreach (var bin in capsBins.EnumerateArray())	348✔
86	{
87	JsonNode? node = bin.ValueKind switch	146!
88	{	146✔
89	JsonValueKind.Array => JsonArray.Create(bin),	×
90	JsonValueKind.Object => JsonObject.Create(bin),	146✔
UNCOV 91	_ => JsonValue.Create(bin)	×
92	};	146✔
93
94	resultBins.Add(node);	146✔
95	}
96
97	var ms = new MemoryStream();	28✔
98
99	using (var jw = new Utf8JsonWriter(ms))	28✔
100	{
101	resultDoc.WriteTo(jw);	28✔
102	}	28✔
103
104	ms.Seek(0, SeekOrigin.Begin);	28✔
105
106	return ms;	28✔
107	}
108
109	/// <summary>
110	/// Creates new instance of <see cref="BundleWriter"/> and populates it with files in <paramref name="path"/>.
111	/// </summary>
112	/// <param name="stream">Stream to write bundle to.</param>
113	/// <param name="path">Path containing bundle source files.</param>
114	/// <param name="exclusions">File name patterns for files the BundleWriter should exclude from the results.</param>
115	public static BundleWriter FromDirectory(
116	Stream stream,
117	string path,
118	IReadOnlySet<string>? exclusions)
119	{
120	var di = new DirectoryInfo(path);	242✔
121
122	if (!di.Exists)	242!
UNCOV 123	throw new DirectoryNotFoundException($"Directory {di.FullName} was not found");	×
124
125	var comparison = RuntimeInformation.IsOSPlatform(OSPlatform.Windows)	242!
126	? StringComparison.OrdinalIgnoreCase	242✔
127	: StringComparison.Ordinal;	242✔
128
129	var glob = new Matcher(comparison);	242✔
130	glob.AddInclude("**/data.json");	242✔
131	glob.AddInclude("**/data.yaml");	242✔
132	glob.AddInclude("*/.rego");	242✔
133	glob.AddInclude("**/policy.wasm");	242✔
134	glob.AddInclude("**/.manifest");	242✔
135
136	if (exclusions != null)	242✔
137	{
138	foreach (var excl in exclusions)	496✔
139	glob.AddExclude(excl);	8✔
140	}
141
142	var matches = glob.Execute(new DirectoryInfoWrapper(di));	242✔
143
144	var writer = new BundleWriter(stream);	242✔
145
146	foreach (var file in matches.Files)	3,328✔
147	{
148	var filePath = string.IsNullOrWhiteSpace(file.Stem) \|\| string.Equals(file.Path, file.Stem, StringComparison.Ordinal)	1,422!
149	? file.Path	1,422✔
150	: Path.Combine(file.Path, file.Stem);	1,422✔
151
152	var fullPath = Path.Combine(di.FullName, filePath);	1,422✔
153
154	using var fs = new FileStream(fullPath, FileMode.Open, FileAccess.Read);	1,422✔
155	writer.WriteEntry(fs, filePath);	1,422✔
156	}
157
158	return writer;	242✔
159	}
160
161	/// <summary>
162	/// Writes string content into bundle.
163	/// </summary>
164	/// <param name="str">String content.</param>
165	/// <param name="path">Relative file path inside bundle.</param>
166	public void WriteEntry(ReadOnlySpan<char> str, string path)
167	{
168	ArgumentException.ThrowIfNullOrEmpty(path);	654✔
169
170	Span<byte> bytes = new byte[Encoding.UTF8.GetByteCount(str)];	654✔
171	_ = Encoding.UTF8.GetBytes(str, bytes);	654✔
172
173	WriteEntry(bytes, path);	654✔
174	}	654✔
175
176	/// <summary>
177	/// Writes bytes content into bundle.
178	/// </summary>
179	/// <param name="bytes">String content.</param>
180	/// <param name="path">Relative file path inside bundle.</param>
181	public void WriteEntry(ReadOnlySpan<byte> bytes, string path)
182	{
183	ArgumentException.ThrowIfNullOrEmpty(path);	666✔
184
185	using var ms = new MemoryStream(bytes.Length);	666✔
186	ms.Write(bytes);	666✔
187	ms.Seek(0, SeekOrigin.Begin);	666✔
188
189	WriteEntry(ms, path);	666✔
190	}	1,332✔
191
192	/// <summary>
193	/// Writes stream content into bundle.
194	/// </summary>
195	/// <param name="stream">String content.</param>
196	/// <param name="path">Relative file path inside bundle.</param>
197	public void WriteEntry(Stream stream, string path)
198	{
199	ArgumentNullException.ThrowIfNull(stream);	2,160✔
200	ArgumentException.ThrowIfNullOrEmpty(path);	2,160✔
201
202	if (Path.IsPathRooted(path))	2,160✔
203	{
204	if (Path.GetPathRoot(path)?[0] != Path.DirectorySeparatorChar)	60!
UNCOV 205	path = path[2..];	×
206	}
207
208	var entry = new PaxTarEntry(TarEntryType.RegularFile, NormalizePath(path))	2,160✔
209	{	2,160✔
210	DataStream = stream,	2,160✔
211	};	2,160✔
212
213	_writer.WriteEntry(entry);	2,160✔
214	IsEmpty = false;	2,160✔
215	}	2,160✔
216
217	/// <summary>
218	/// Merges contents of source bundle into this bundle.
219	/// </summary>
220	/// <param name="bundle">Source bundle.</param>
221	public void WriteBundle(Span<byte> bundle)
222	{
223	using var ms = new MemoryStream(bundle.Length);	×
UNCOV 224	ms.Write(bundle);	×
225	ms.Seek(0, SeekOrigin.Begin);	×
226
UNCOV 227	WriteBundle(ms);	×
UNCOV 228	}	×
229
230	/// <summary>
231	/// Merges contents of source bundle into this bundle.
232	/// </summary>
233	/// <param name="bundle">Source bundle.</param>
234	public void WriteBundle(Stream bundle)
235	{
236	ArgumentNullException.ThrowIfNull(bundle);	×
237
UNCOV 238	using var gzip = new GZipStream(bundle, CompressionMode.Decompress);	×
239	using var ms = new MemoryStream();	×
240
UNCOV 241	gzip.CopyTo(ms);	×
242	ms.Seek(0, SeekOrigin.Begin);	×
243
244	using var tr = new TarReader(ms);	×
245
246	while (tr.GetNextEntry() is { } sourceEntry)	×
247	{
248	var entry = new PaxTarEntry(sourceEntry);	×
249	_writer.WriteEntry(entry);	×
UNCOV 250	}	×
UNCOV 251	}	×
252
253	/// <summary>
254	/// Writes contents of file into bundle.
255	/// </summary>
256	/// <param name="path">File to write.</param>
257	/// <param name="overridePath">Relative file path inside bundle.</param>
258	public void WriteFile(string path, string? overridePath = null)
259	{
260	using var fs = new FileStream(path, FileMode.Open, FileAccess.Read);	×
261	var targetPath = overridePath ?? path;	×
UNCOV 262	WriteEntry(fs, targetPath);	×
UNCOV 263	}	×
264
265	/// <summary>
266	/// Writes manifest into bundle.
267	/// </summary>
268	/// <param name="manifest">Policy bundle manifest.</param>
269	public void WriteManifest(BundleManifest manifest)
270	{
271	ArgumentNullException.ThrowIfNull(manifest);	×
272
UNCOV 273	WriteEntry(JsonSerializer.Serialize(manifest), ".manifest");	×
UNCOV 274	}	×
275
276	/// <inheritdoc />
277	public void Dispose()
278	{
279	_writer.Dispose();	30✔
280	}	30✔
281
282	/// <inheritdoc />
283	public async ValueTask DisposeAsync()
284	{
285	await _writer.DisposeAsync().ConfigureAwait(false);	844✔
286	}	844✔
287	}

me-viper / OpaDotNet / 11762631757

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous