feat: native library support and testing

ha-ves · ha-ves · commit 7ab57a96d579 · 2026-05-01T06:00:31.000+09:00
- GitHub Actions tag triggers, NuGet publish job
- NativesHelper, NativeLibraryVersionAttribute
- vcpkg integration, static linking
- zstd support
- native library tests, import checks
- Native AOT test app
- NetCordNativesDir assembly metadata
diff --git a/.github/workflows/build-natives.yml b/.github/workflows/build-natives.yml
@@ -5,6 +5,10 @@ on:
   push:
     paths:
       - 'NetCord.Natives/**'
+      - '.github/workflows/build-natives.yml'
+    tags:
+      - "[0-9]+.[0-9]+.[0-9]+"
+      - "[0-9]+.[0-9]+.[0-9]+-*"
 
 jobs:
   build-natives:
@@ -57,11 +61,6 @@ jobs:
             vcpkg-${{ runner.os }}-${{ matrix.rid }}-
             vcpkg-${{ runner.os }}-
 
-      - name: Setup .NET
-        uses: actions/setup-dotnet@v4
-        with:
-          dotnet-version: 8.0.x
-
       - name: Resolve vcpkg from runner image
         shell: pwsh
         run: |
@@ -116,21 +115,6 @@ jobs:
           path: artifacts
           merge-multiple: false
 
-      - name: Setup .NET
-        uses: actions/setup-dotnet@v4
-        with:
-          dotnet-version: 8.0.x
-
-      - name: Resolve native license root
-        shell: pwsh
-        run: |
-          $licenseRoot = Get-ChildItem artifacts -Directory | Sort-Object Name | Select-Object -First 1
-          if (-not $licenseRoot) {
-            throw "No native artifact directories were downloaded."
-          }
-
-          "NativeLicenseRoot=$($licenseRoot.FullName)" | Out-File -FilePath $env:GITHUB_ENV -Append -Encoding utf8
-
       - name: Pack combined nupkg
         shell: pwsh
         run: |
@@ -141,3 +125,20 @@ jobs:
         with:
           name: NetCord.Natives.Package
           path: artifacts/package/*.nupkg
+
+  publish:
+    needs: pack-natives
+    if: startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download nupkg
+        uses: actions/download-artifact@v4
+        with:
+          name: NetCord.Natives.Package
+          path: artifacts/package
+
+      - name: Publish Package
+        env:
+          KEY: ${{ secrets.NUGET_API_KEY }}
+        run: |
+          dotnet nuget push artifacts/package/*.nupkg -k $KEY -s https://api.nuget.org/v3/index.json --skip-duplicate
diff --git a/NetCord.Natives/NativesHelper.cs b/NetCord.Natives/NativesHelper.cs
@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+
+namespace NetCord.Natives;
+
+[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
+public class NativeLibraryVersionAttribute(string name, string version) : Attribute
+{
+    public string Name { get; } = name;
+    public string Version { get; } = version;
+}
+
+public static class NativesHelper
+{
+    public static IEnumerable<NativeLibraryVersionAttribute> GetNativeLibraryVersions()
+    {
+        return typeof(NativesHelper).Assembly.GetCustomAttributes<NativeLibraryVersionAttribute>();
+    }
+}
diff --git a/NetCord.Natives/NetCord.Natives.csproj b/NetCord.Natives/NetCord.Natives.csproj
diff --git a/NetCord.Natives/NetCord.Natives.local.targets b/NetCord.Natives/NetCord.Natives.local.targets
@@ -4,7 +4,8 @@
 
 	<Target Name="ProcessNetCordNativeAot_Local" BeforeTargets="ProcessNetCordNativeAot">
 	
-		<MSBuild Projects="$(MSBuildThisFileDirectory)\NetCord.Natives.csproj" Targets="GetStaticBuildDir">
+		<MSBuild Projects="$(MSBuildThisFileDirectory)\NetCord.Natives.csproj" 
+				 Targets="GetStaticBuildDir">
 			<Output TaskParameter="TargetOutputs" ItemName="_NetCordStaticDir" />
 		</MSBuild>
 
diff --git a/NetCord.Natives/NetCord.Natives.props b/NetCord.Natives/NetCord.Natives.props
@@ -1,7 +1,7 @@
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 
 	<PropertyGroup>
-        <NetCordNativesStaticDir Condition="'$(NetCordNativesStaticDir)' == ''">$(MSBuildThisFileDirectory)..\runtimes-static\$(RuntimeIdentifier)</NetCordNativesStaticDir>
+        <NetCordNativesStaticDir Condition="'$(NetCordNativesStaticDir)' == ''">$(MSBuildThisFileDirectory)..\staticlibs\$(RuntimeIdentifier)</NetCordNativesStaticDir>
     </PropertyGroup>
 
 </Project>
diff --git a/NetCord.Natives/NetCord.Natives.targets b/NetCord.Natives/NetCord.Natives.targets
@@ -9,6 +9,8 @@
 								Condition="'%(DirectPInvoke.Identity)' == 'libsodium'" />
 			<_NetCordStaticLink Include="opus"
 								Condition="'%(DirectPInvoke.Identity)' == 'opus'" />
+			<_NetCordStaticLink Include="zstd"
+								Condition="'%(DirectPInvoke.Identity)' == 'zstd'" />
 
 			<NativeLibToLink Include="$(NetCordNativesStaticDir)\%(_NetCordStaticLink.Identity).*" />
 
diff --git a/NetCord.Natives/vcpkg.json b/NetCord.Natives/vcpkg.json
@@ -2,7 +2,8 @@
   "dependencies": [
     "libdave",
     "opus",
-    "libsodium"
+    "libsodium",
+    "zstd"
   ],
   "vcpkg-configuration": {
     "overlay-ports": [
diff --git a/NetCord.slnx b/NetCord.slnx
@@ -84,6 +84,7 @@
     <File Path="Tests/Directory.Build.targets" />
     <Project Path="Tests/ColorTest/ColorTest.csproj" />
     <Project Path="Tests/MentionTest/MentionTest.csproj" />
+    <Project Path="Tests/NetCord.Natives.Tests/NetCord.Natives.Tests.csproj" />
     <Project Path="Tests/NetCord.Rest.Tests/NetCord.Rest.Tests.csproj" />
     <Project Path="Tests/NetCord.Test.Hosting.AspNetCore/NetCord.Test.Hosting.AspNetCore.csproj" />
     <Project Path="Tests/NetCord.Test.Hosting/NetCord.Test.Hosting.csproj" />
diff --git a/Tests/NetCord.Natives.Tests/AssemblyInfo.cs b/Tests/NetCord.Natives.Tests/AssemblyInfo.cs
@@ -0,0 +1,3 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+[assembly: Parallelize(Scope = ExecutionScope.MethodLevel)]
diff --git a/Tests/NetCord.Natives.Tests/Assets/NativeAotApp/NativeAotApp.csproj b/Tests/NetCord.Natives.Tests/Assets/NativeAotApp/NativeAotApp.csproj
@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <PublishAot>true</PublishAot>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <!-- <ProjectReference Include="..\..\NetCord.Natives\NetCord.Natives.csproj" /> -->
+    <ProjectReference Include="$(NetCordNativesDir)\NetCord.Natives.csproj" />
+  </ItemGroup>
+
+	<ItemGroup>
+		<DirectPInvoke Include="$(NetCordDirectPInvoke)" />
+	</ItemGroup>
+	<!-- <Import Project="..\NetCord\NetCord.Natives\NetCord.Natives.local.targets"/> -->
+  <Import Project="$(NetCordNativesDir)\NetCord.Natives.local.targets" />
+  
+</Project>
diff --git a/Tests/NetCord.Natives.Tests/Assets/NativeAotApp/Program.cs b/Tests/NetCord.Natives.Tests/Assets/NativeAotApp/Program.cs
@@ -0,0 +1,90 @@
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Runtime.InteropServices;
+
+internal static partial class NativeProbes
+{
+    [LibraryImport("libdave", EntryPoint = "daveMaxSupportedProtocolVersion")]
+    internal static partial uint DaveMaxSupportedProtocolVersion();
+
+    [LibraryImport("libsodium", EntryPoint = "sodium_init")]
+    internal static partial int SodiumInit();
+
+    [LibraryImport("opus", EntryPoint = "opus_get_version_string")]
+    internal static partial nint OpusGetVersionString();
+
+    [LibraryImport("libzstd", EntryPoint = "ZSTD_versionNumber")]
+    internal static partial uint ZstdVersionNumber();
+}
+
+internal static class Program
+{
+    private static void Main()
+    {
+        Console.WriteLine("NetCord native ahead of time publish app.");
+
+        Console.WriteLine($"Dave Max Supported Protocol Version: {NativeProbes.DaveMaxSupportedProtocolVersion()}");
+        Console.WriteLine($"Sodium Init: {NativeProbes.SodiumInit()}");
+        Console.WriteLine($"Opus Version String: {Marshal.PtrToStringAnsi(NativeProbes.OpusGetVersionString())}");
+        Console.WriteLine($"Zstd Version Number: {NativeProbes.ZstdVersionNumber()}");
+
+        var cwd = Path.GetFullPath(Directory.GetCurrentDirectory());
+        Console.WriteLine($"Current working directory: {cwd}");
+
+        string[] libraries = new[] { "libdave", "libsodium", "opus", "libzstd" };
+        var process = Process.GetCurrentProcess();
+        var modules = process.Modules;
+
+        bool allUnderCwd = true;
+
+        foreach (var lib in libraries)
+        {
+            ProcessModule found = null;
+            foreach (ProcessModule m in modules)
+            {
+                if (!string.IsNullOrEmpty(m.FileName) && m.FileName.IndexOf(lib, StringComparison.OrdinalIgnoreCase) >= 0)
+                {
+                    found = m;
+                    break;
+                }
+                if (!string.IsNullOrEmpty(m.ModuleName) && m.ModuleName.IndexOf(lib, StringComparison.OrdinalIgnoreCase) >= 0)
+                {
+                    found = m;
+                    break;
+                }
+            }
+
+            if (found == null)
+            {
+                Console.WriteLine($"Library '{lib}' not found among loaded modules.");
+                allUnderCwd = false;
+                continue;
+            }
+
+            Console.WriteLine($"{lib} loaded from: {found.FileName}");
+            if (!IsUnderDirectory(found.FileName, cwd))
+            {
+                Console.WriteLine($"Library '{lib}' is not under current working directory.");
+                allUnderCwd = false;
+            }
+        }
+
+        Environment.Exit(allUnderCwd ? 0 : 1);
+    }
+
+    private static bool IsUnderDirectory(string path, string directory)
+    {
+        try
+        {
+            var fullPath = Path.GetFullPath(path);
+            var fullDir = Path.GetFullPath(directory).TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar) + Path.DirectorySeparatorChar;
+            var comparison = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;
+            return fullPath.StartsWith(fullDir, comparison);
+        }
+        catch
+        {
+            return false;
+        }
+    }
+}
diff --git a/Tests/NetCord.Natives.Tests/NativesBuildTests.cs b/Tests/NetCord.Natives.Tests/NativesBuildTests.cs
@@ -0,0 +1,134 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+namespace NetCord.Natives.Tests;
+
+[TestClass]
+public class NativesBuildTests
+{
+    // MSTest automatically injects this property
+    public TestContext TestContext { get; set; }
+    
+    [TestMethod]
+    [DataRow("libdave")]
+    [DataRow("libsodium")]
+    [DataRow("opus")]
+    [DataRow("zstd")]
+    public void NativesLoaded(string libName)
+    {
+        try
+        {
+            NativeLibrary.Load(libName);
+        }
+        catch (Exception ex)
+        {
+            Assert.Fail($"Failed to load library '{libName}': {ex}");
+        }
+    }
+
+    [TestMethod]
+    [DataRow("libdave", "NetCord.Gateway.Voice.Dave")]
+    [DataRow("libsodium", "NetCord.Gateway.Voice.Encryption.XChaCha20Poly1305")]
+    [DataRow("opus", "NetCord.Gateway.Voice.Opus")]
+    [DataRow("zstd", "NetCord.Gateway.Compression.Zstandard")]
+    public void AllLibraryImportsExistInBinary(string libName, string className)
+    {
+        IntPtr libHandle = IntPtr.Zero;
+
+        try
+        {
+            var assembly = typeof(NetCord.Application).Assembly;
+            var typeWithImports = assembly.GetType(className, true);
+
+            libHandle = NativeLibrary.Load(libName);
+
+            var missingExports = new List<string>();
+
+            // Reflect over methods with [LibraryImport]
+            var methods = typeWithImports!.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)
+                .Select(m => new { 
+                    MethodName = m.Name, 
+                    Attr = m.GetCustomAttribute<LibraryImportAttribute>() 
+                })
+                .Where(x => x.Attr != null);
+            Assert.IsNotEmpty(methods, $"No methods with [LibraryImport] found in '{className}'.");
+
+            foreach (var item in methods)
+            {
+                // Use EntryPoint if defined, otherwise fallback to Method Name
+                string exportName = item.Attr!.EntryPoint ?? item.MethodName;
+
+                if (!NativeLibrary.TryGetExport(libHandle, exportName, out _))
+                {
+                    missingExports.Add(exportName);
+                }
+            }
+            Assert.IsEmpty(missingExports, $"The following entry points were not found in '{libName}': {string.Join(", ", missingExports)}");
+        }
+        catch (Exception ex)
+        {
+            Assert.Fail($"An error occurred while verifying imports for '{libName}': {ex}");
+        }
+        finally
+        {
+            NativeLibrary.Free(libHandle);
+        }
+    }
+
+    [TestMethod]
+    [DataRow("libdave;libsodium;opus;zstd")]
+    public void NativeAotStaticLinking(string libName)
+    {
+        try
+        {
+            // get NetCordNativesDir from AssemblyMetadata attribute
+            var assembly = typeof(NativesBuildTests).Assembly;
+            var nativesDir = assembly.GetCustomAttribute<AssemblyMetadataAttribute>()?.Value;
+            Assert.IsNotNull(nativesDir, "NetCordNativesDir metadata attribute is not defined.");
+
+            // build asset NativeAotApp with Native AoT enabled
+            var buildProcess = new System.Diagnostics.Process();
+            buildProcess.StartInfo.FileName = "dotnet";
+            buildProcess.StartInfo.ArgumentList.Add("publish");
+            buildProcess.StartInfo.ArgumentList.Add("-p:Configuration=Release");
+            buildProcess.StartInfo.ArgumentList.Add("-p:RuntimeIdentifier=" + RuntimeInformation.RuntimeIdentifier);
+            buildProcess.StartInfo.ArgumentList.Add($"-p:NetCordNativesDir={nativesDir}");
+            buildProcess.StartInfo.ArgumentList.Add($"-p:NetCordDirectPInvoke=\"{libName}\"");
+
+            TestContext.WriteLine($"Building Native AoT app: 'dotnet {buildProcess.StartInfo.ArgumentList.Aggregate((a, b) => $"{a} {b}")}'");
+
+            buildProcess.StartInfo.WorkingDirectory = Path.Combine(AppContext.BaseDirectory, "Assets", "NativeAotApp");
+            buildProcess.StartInfo.RedirectStandardOutput = true;
+            buildProcess.StartInfo.RedirectStandardError = true;
+            buildProcess.Start();
+            buildProcess.WaitForExit();
+            
+            TestContext.WriteLine($"Build Output of AoT app for '{libName}': {buildProcess.StandardOutput.ReadToEnd()}");
+
+            Assert.AreEqual(0, buildProcess.ExitCode, 
+                $"Native AoT build failed for '{libName}'. Output: {buildProcess.StandardError.ReadToEnd()}");
+
+            // check that the library is running without errors, which indicates that it was statically linked successfully
+            var aotProcess = new System.Diagnostics.Process();
+            aotProcess.StartInfo.FileName = Path.Combine(AppContext.BaseDirectory, "Assets", "NativeAotApp", 
+                "bin", "release", RuntimeInformation.RuntimeIdentifier, "publish", "NativeAotApp.exe");
+
+            TestContext.WriteLine($"Running Native AoT app: '{aotProcess.StartInfo.FileName}'");
+
+            aotProcess.StartInfo.RedirectStandardOutput = true;
+            aotProcess.StartInfo.RedirectStandardError = true;
+            aotProcess.Start();
+            aotProcess.WaitForExit();
+
+            TestContext.WriteLine($"Output of AoT app for '{libName}': {aotProcess.StandardOutput.ReadToEnd()}");
+
+            Assert.AreEqual(0, aotProcess.ExitCode, 
+                $"Native AoT app failed to run for '{libName}'. Output: {aotProcess.StandardError.ReadToEnd()}");
+        }
+        catch (Exception ex)
+        {
+            Assert.Fail($"Failed to statically link '{libName}' for Native Ahead-of-Time (AoT) compilation: {ex}");
+        }
+    }
+}
diff --git a/Tests/NetCord.Natives.Tests/NetCord.Natives.Tests.csproj b/Tests/NetCord.Natives.Tests/NetCord.Natives.Tests.csproj

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+using Microsoft.VisualStudio.TestTools.UnitTesting;`
	`2`	`+`
	`3`	`+[assembly: Parallelize(Scope = ExecutionScope.MethodLevel)]`