Implemented Store.SetLimits (#243)

* Implemented `Store.SetLimits` using the new `wasmtime_store_limiter` function.

* Fixed filepath case

* Added runtime checking of limiter values

* Fixed braces

Author: martindevans

src/Store.cs

@@ -158,6 +158,51 @@ public Store(Engine engine, object? data)
             handle = new Handle(Native.wasmtime_store_new(engine.NativeHandle, (IntPtr)storeHandle, Finalizer));
         }
 
+        /// <summary>
+        /// Limit the resources that this store may consume. Note that the limits are only used to limit the creation/growth of resources in the future,
+        /// this does not retroactively attempt to apply limits to the store.
+        /// </summary>
+        /// <param name="memorySize">the maximum number of bytes a linear memory can grow to. Growing a linear memory beyond this limit will fail.
+        /// Pass in a null value to use the default value (unlimited)</param>
+        /// <param name="tableElements">the maximum number of elements in a table. Growing a table beyond this limit will fail.
+        /// Pass in a null value to use the default value (unlimited)</param>
+        /// <param name="instances">the maximum number of instances that can be created for a Store. Module instantiation will fail if this limit is exceeded.
+        /// Pass in a null value to use the default value (10000)</param>
+        /// <param name="tables">the maximum number of tables that can be created for a Store. Module instantiation will fail if this limit is exceeded.
+        /// Pass in a null value to use the default value (10000)</param>
+        /// <param name="memories">the maximum number of linear memories that can be created for a Store. Instantiation will fail with an error if this limit is exceeded.
+        /// Pass in a null value to use the default value (10000)</param>
+        public void SetLimits(long? memorySize = null, uint? tableElements = null, long? instances = null, long? tables = null, long? memories = null)
+        {
+            if (memorySize.HasValue && memorySize.Value < 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(memorySize));
+            }
+
+            if (instances.HasValue && instances.Value < 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(instances));
+            }
+
+            if (tables.HasValue && tables.Value < 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(tables));
+            }
+
+            if (memories.HasValue && memories.Value < 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(memories));
+            }
+
+            long tableElements64 = -1;
+            if (tableElements.HasValue)
+            {
+                tableElements64 = tableElements.Value;
+            }
+
+            Native.wasmtime_store_limiter(NativeHandle, memorySize ?? -1, tableElements64, instances ?? -1, tables ?? -1, memories ?? -1);
+        }
+
         /// <summary>
         /// Perform garbage collection within the given store.
         /// </summary>
@@ -298,6 +343,9 @@ private static class Native
 
             [DllImport(Engine.LibraryName)]
             public static extern void wasmtime_store_delete(IntPtr store);
+
+            [DllImport(Engine.LibraryName)]
+            public static extern void wasmtime_store_limiter(Handle store, long memory_size, long table_elements, long instances, long tables, long memories);
         }
 
         private readonly Handle handle;

tests/StoreTests.cs

@@ -0,0 +1,95 @@
+using FluentAssertions;
+using System.IO;
+using Xunit;
+
+namespace Wasmtime.Tests
+{
+    public class StoreTests
+        : StoreFixture
+    {
+        [Fact]
+        public void ItSetsLimits()
+        {
+            Store.SetLimits(1, 2, 3, 4, 5);
+        }
+
+        [Fact]
+        public void ItSetsDefaultLimits()
+        {
+            Store.SetLimits(null, null, null, null, null);
+        }
+
+        [Fact]
+        public void ItLimitsMemorySize()
+        {
+            Store.SetLimits(memorySize: Memory.PageSize);
+
+            var memory = new Memory(Store, 0, 1024);
+            memory.GetSize().Should().Be(0);
+
+
+            memory.Grow(1).Should().Be(0);
+
+            var act = () => { memory.Grow(1); };
+            act.Should().Throw<WasmtimeException>();
+        }
+
+        [Fact]
+        public void ItLimitsTableElements()
+        {
+            Store.SetLimits(tableElements: 5);
+
+            var table = new Table(Store, ValueKind.ExternRef, null, 0);
+            table.GetSize().Should().Be(0);
+
+            table.Grow(5, null);
+
+            var act = () => { table.Grow(1, null); };
+            act.Should().Throw<WasmtimeException>();
+        }
+
+        [Fact]
+        public void ItLimitsInstances()
+        {
+            Store.SetLimits(instances: 3);
+
+            using var module = Module.FromTextFile(Engine, Path.Combine("Modules", "Trap.wat"));
+
+            var inst1 = new Instance(Store, module);
+            var inst2 = new Instance(Store, module);
+            var inst3 = new Instance(Store, module);
+
+            var act = () => { new Instance(Store, module); };
+            act.Should().Throw<WasmtimeException>();
+        }
+
+        [Fact]
+        public void ItLimitsTables()
+        {
+            Store.SetLimits(tables: 3);
+
+            // This module exports exactly 3 tables
+            using var module = Module.FromTextFile(Engine, Path.Combine("Modules", "TableExports.wat"));
+
+            var inst1 = new Instance(Store, module);
+
+            var act = () => { new Instance(Store, module); };
+            act.Should().Throw<WasmtimeException>();
+        }
+
+        [Fact]
+        public void ItLimitsMemories()
+        {
+            Store.SetLimits(memories: 2);
+
+            // This module exports 1 memory
+            using var module = Module.FromTextFile(Engine, Path.Combine("Modules", "MemoryExports.wat"));
+
+            var inst1 = new Instance(Store, module);
+            var inst2 = new Instance(Store, module);
+
+            var act = () => { new Instance(Store, module); };
+            act.Should().Throw<WasmtimeException>();
+        }
+    }
+}