chore: clean up some dotnet internals (#82)

Author: sighphyre

dotnet-engine/Yggdrasil.Engine/Buf.cs

@@ -1,7 +1,7 @@
 using System.Runtime.InteropServices;
 
 [StructLayout(LayoutKind.Sequential)]
-public struct Buf
+internal struct Buf
 {
     public IntPtr ptr;
     public nuint len;

dotnet-engine/Yggdrasil.Engine/FFI.cs

@@ -1,127 +1,174 @@
-using System;
 using System.Runtime.InteropServices;
+using System.Text;
 
 namespace Yggdrasil;
 
+
 internal static class FFI
 {
-    private static IntPtr _libHandle;
+    private static readonly IntPtr _libHandle;
 
     static FFI()
     {
         _libHandle = NativeLibLoader.LoadNativeLibrary();
 
+        // standard ygg messages, these require a buffer and return one
+        check_enabled = LoadMsgCall("flat_check_enabled");
+        check_variant = LoadMsgCall("flat_check_variant");
+        define_counter = LoadMsgCall("flat_define_counter");
+        inc_counter = LoadMsgCall("flat_inc_counter");
+        define_gauge = LoadMsgCall("flat_define_gauge");
+        set_gauge = LoadMsgCall("flat_set_gauge");
+        define_histogram = LoadMsgCall("flat_define_histogram");
+        observe_histogram = LoadMsgCall("flat_observe_histogram");
+
         new_engine = Marshal.GetDelegateForFunctionPointer<NewEngineDelegate>(NativeLibLoader.LoadFunctionPointer(_libHandle, "new_engine"));
         free_engine = Marshal.GetDelegateForFunctionPointer<FreeEngineDelegate>(NativeLibLoader.LoadFunctionPointer(_libHandle, "free_engine"));
-        get_metrics = Marshal.GetDelegateForFunctionPointer<GetMetricsDelegate>(NativeLibLoader.LoadFunctionPointer(_libHandle, "get_metrics"));
-        take_state = Marshal.GetDelegateForFunctionPointer<TakeStateDelegate>(NativeLibLoader.LoadFunctionPointer(_libHandle, "take_state"));
         get_state = Marshal.GetDelegateForFunctionPointer<GetStateDelegate>(NativeLibLoader.LoadFunctionPointer(_libHandle, "get_state"));
-        check_enabled = Marshal.GetDelegateForFunctionPointer<CheckEnabledDelegate>(NativeLibLoader.LoadFunctionPointer(_libHandle, "check_enabled"));
-        check_variant = Marshal.GetDelegateForFunctionPointer<CheckVariantDelegate>(NativeLibLoader.LoadFunctionPointer(_libHandle, "check_variant"));
         free_response = Marshal.GetDelegateForFunctionPointer<FreeResponseDelegate>(NativeLibLoader.LoadFunctionPointer(_libHandle, "free_response"));
-        count_toggle = Marshal.GetDelegateForFunctionPointer<CountToggleDelegate>(NativeLibLoader.LoadFunctionPointer(_libHandle, "count_toggle"));
-        count_variant = Marshal.GetDelegateForFunctionPointer<CountVariantDelegate>(NativeLibLoader.LoadFunctionPointer(_libHandle, "count_variant"));
-        should_emit_impression_event = Marshal.GetDelegateForFunctionPointer<ShouldEmitImpressionEventDelegate>(NativeLibLoader.LoadFunctionPointer(_libHandle, "should_emit_impression_event"));
-        built_in_strategies = Marshal.GetDelegateForFunctionPointer<BuiltInStrategiesDelegate>(NativeLibLoader.LoadFunctionPointer(_libHandle, "built_in_strategies"));
-        list_known_toggles = Marshal.GetDelegateForFunctionPointer<ListKnownTogglesDelegate>(NativeLibLoader.LoadFunctionPointer(_libHandle, "list_known_toggles"));
+
+        // everything else has some special details to it
+        // if these get out of hand they'll need some refactor but for now 5 is fine
+        take_state = Marshal.GetDelegateForFunctionPointer<TakeStateDelegate>(
+            NativeLibLoader.LoadFunctionPointer(_libHandle, "flat_take_state"));
+
+        free_buffer = Marshal.GetDelegateForFunctionPointer<FreeBufferDelegate>(
+            NativeLibLoader.LoadFunctionPointer(_libHandle, "flat_buf_free"));
+
+        list_known_toggles = Marshal.GetDelegateForFunctionPointer<ListKnownTogglesDelegate>(
+            NativeLibLoader.LoadFunctionPointer(_libHandle, "flat_list_known_toggles"));
+
+        built_in_strategies = Marshal.GetDelegateForFunctionPointer<BuiltInStrategiesDelegate>(
+            NativeLibLoader.LoadFunctionPointer(_libHandle, "flat_built_in_strategies"));
+
+        get_metrics = Marshal.GetDelegateForFunctionPointer<GetMetricsDelegate>(
+            NativeLibLoader.LoadFunctionPointer(_libHandle, "flat_get_metrics"));
     }
 
+    // one delegate type to rule them all, lets us not have to deal with a ton of delegate types in the higher layers
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    private delegate Buf FlatBufferMessageDelegate(IntPtr enginePtr, byte[] message, nuint messageLen);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    private delegate Buf TakeStateDelegate(IntPtr ptr, byte[] json);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    private delegate void FreeBufferDelegate(Buf buf);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    private delegate Buf ListKnownTogglesDelegate(IntPtr enginePtr);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    private delegate Buf BuiltInStrategiesDelegate();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    private delegate Buf GetMetricsDelegate(IntPtr enginePtr);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
     private delegate IntPtr NewEngineDelegate();
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
     private delegate void FreeEngineDelegate(IntPtr ptr);
-    private delegate IntPtr GetMetricsDelegate(IntPtr ptr);
-    private delegate IntPtr TakeStateDelegate(IntPtr ptr, byte[] json);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
     private delegate IntPtr GetStateDelegate(IntPtr ptr);
-    private delegate IntPtr CheckEnabledDelegate(IntPtr ptr, byte[] toggle_name, byte[] context, byte[] customStrategyResults);
-    private delegate IntPtr CheckVariantDelegate(IntPtr ptr, byte[] toggle_name, byte[] context, byte[] customStrategyResults);
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
     private delegate void FreeResponseDelegate(IntPtr ptr);
-    private delegate IntPtr CountToggleDelegate(IntPtr ptr, byte[] toggle_name, bool enabled);
-    private delegate IntPtr CountVariantDelegate(IntPtr ptr, byte[] toggle_name, byte[] variant_name);
-    private delegate IntPtr ShouldEmitImpressionEventDelegate(IntPtr ptr, byte[] toggle_name);
-    private delegate IntPtr BuiltInStrategiesDelegate(IntPtr ptr);
-    private delegate IntPtr ListKnownTogglesDelegate(IntPtr ptr);
     private static readonly NewEngineDelegate new_engine;
     private static readonly FreeEngineDelegate free_engine;
-    private static readonly GetMetricsDelegate get_metrics;
-    private static readonly TakeStateDelegate take_state;
     private static readonly GetStateDelegate get_state;
-    private static readonly CheckEnabledDelegate check_enabled;
-    private static readonly CheckVariantDelegate check_variant;
     private static readonly FreeResponseDelegate free_response;
-    private static readonly CountToggleDelegate count_toggle;
-    private static readonly CountVariantDelegate count_variant;
-    private static readonly ShouldEmitImpressionEventDelegate should_emit_impression_event;
-    private static readonly BuiltInStrategiesDelegate built_in_strategies;
+
+    private static readonly TakeStateDelegate take_state;
+    private static readonly FreeBufferDelegate free_buffer;
+
+    private static readonly FlatBufferMessageDelegate check_enabled;
+    private static readonly FlatBufferMessageDelegate check_variant;
+
+    private static readonly FlatBufferMessageDelegate define_counter;
+    private static readonly FlatBufferMessageDelegate inc_counter;
+    private static readonly FlatBufferMessageDelegate define_gauge;
+    private static readonly FlatBufferMessageDelegate set_gauge;
+    private static readonly FlatBufferMessageDelegate define_histogram;
+    private static readonly FlatBufferMessageDelegate observe_histogram;
+
     private static readonly ListKnownTogglesDelegate list_known_toggles;
+    private static readonly BuiltInStrategiesDelegate built_in_strategies;
+    private static readonly GetMetricsDelegate get_metrics;
 
-    public static IntPtr NewEngine()
-    {
-        return new_engine();
-    }
+    internal static Buf TakeState(IntPtr ptr, string json)
+        => take_state(ptr, ToUtf8NullTerminated(json));
 
-    public static void FreeEngine(IntPtr ptr)
-    {
-        free_engine(ptr);
-    }
+    internal static Buf CheckEnabled(IntPtr ptr, byte[] message)
+        => check_enabled(ptr, message, (nuint)message.Length);
 
-    public static IntPtr GetMetrics(IntPtr ptr)
-    {
-        return get_metrics(ptr);
-    }
+    internal static Buf CheckVariant(IntPtr ptr, byte[] message)
+        => Call(message, ptr, check_variant);
 
-    public static IntPtr TakeState(IntPtr ptr, string json)
-    {
-        return take_state(ptr, ToUtf8Bytes(json));
-    }
+    internal static Buf DefineCounter(IntPtr ptr, byte[] message)
+        => Call(message, ptr, define_counter);
 
-    public static IntPtr GetState(IntPtr ptr)
-    {
-        return get_state(ptr);
-    }
+    internal static Buf IncCounter(IntPtr ptr, byte[] message)
+        => Call(message, ptr, inc_counter);
 
-    public static IntPtr CheckEnabled(IntPtr ptr, string toggle_name, string context, string customStrategyResults)
-    {
-        return check_enabled(ptr, ToUtf8Bytes(toggle_name), ToUtf8Bytes(context), ToUtf8Bytes(customStrategyResults));
-    }
+    internal static Buf DefineGauge(IntPtr ptr, byte[] message)
+        => Call(message, ptr, define_gauge);
 
-    public static IntPtr CheckVariant(IntPtr ptr, string toggle_name, string context, string customStrategyResults)
-    {
-        return check_variant(ptr, ToUtf8Bytes(toggle_name), ToUtf8Bytes(context), ToUtf8Bytes(customStrategyResults));
-    }
+    internal static Buf SetGauge(IntPtr ptr, byte[] message)
+        => Call(message, ptr, set_gauge);
 
-    public static void FreeResponse(IntPtr ptr)
-    {
-        free_response(ptr);
-    }
+    internal static Buf DefineHistogram(IntPtr ptr, byte[] message)
+        => Call(message, ptr, define_histogram);
+
+    internal static Buf ObserveHistogram(IntPtr ptr, byte[] message)
+        => Call(message, ptr, observe_histogram);
+
+    internal static Buf ListKnownToggles(IntPtr ptr) => list_known_toggles(ptr);
+
+    internal static Buf BuiltInStrategies() => built_in_strategies();
+
+    internal static Buf GetMetrics(IntPtr ptr) => get_metrics(ptr);
+
+    internal static void FreeBuf(Buf buf) => free_buffer(buf);
 
-    public static IntPtr CountToggle(IntPtr ptr, string toggle_name, bool enabled)
+    internal static IntPtr NewEngine()
     {
-        return count_toggle(ptr, ToUtf8Bytes(toggle_name), enabled);
+        return new_engine();
     }
 
-    public static IntPtr CountVariant(IntPtr ptr, string toggle_name, string variant_name)
+    internal static void FreeEngine(IntPtr ptr)
     {
-        return count_variant(ptr, ToUtf8Bytes(toggle_name), ToUtf8Bytes(variant_name));
+        free_engine(ptr);
     }
 
-    public static IntPtr ShouldEmitImpressionEvent(IntPtr ptr, string toggle_name)
+    internal static IntPtr GetState(IntPtr ptr)
     {
-        return should_emit_impression_event(ptr, ToUtf8Bytes(toggle_name));
+        return get_state(ptr);
     }
 
-    public static IntPtr BuiltInStrategies(IntPtr ptr)
+    internal static void FreeResponse(IntPtr ptr)
     {
-        return built_in_strategies(ptr);
+        free_response(ptr);
     }
 
-    public static IntPtr ListKnownToggles(IntPtr ptr)
+    private static FlatBufferMessageDelegate LoadMsgCall(string symbol)
+    => Marshal.GetDelegateForFunctionPointer<FlatBufferMessageDelegate>(
+        NativeLibLoader.LoadFunctionPointer(_libHandle, symbol));
+
+    private static Buf Call(byte[] message, IntPtr enginePtr, FlatBufferMessageDelegate nativeCall)
     {
-        return list_known_toggles(ptr);
+        if (message is null) throw new ArgumentNullException(nameof(message));
+
+        return nativeCall(enginePtr, message, (nuint)message.Length);
     }
 
-    private static byte[] ToUtf8Bytes(string input)
+    private static byte[] ToUtf8NullTerminated(string input)
     {
-        byte[] utf8Bytes = System.Text.Encoding.UTF8.GetBytes(input);
+        if (input is null) throw new ArgumentNullException(nameof(input));
+
+        byte[] utf8Bytes = Encoding.UTF8.GetBytes(input);
         Array.Resize(ref utf8Bytes, utf8Bytes.Length + 1);
         return utf8Bytes;
     }
-}
+}