@innovatorstack/harness 0.0.0-stage → 0.1.1

package/dist/methods/csharp/managed/Method.cs.template

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using InnovatorHarness.Managed;
+
+namespace InnovatorHarness.Generated;
+
+public sealed class __TYPE_NAME__ : Item, IArasMethod
+{
+    private readonly System.Xml.XmlDocument InputDocument;
+
+    public __TYPE_NAME__(ItemPayload context, Remote remote)
+        : base(context, remote)
+    {
+        InputDocument = dom
+            ?? throw new InvalidOperationException("Missing Method input document.");
+    }
+
+    public Item Execute()
+    {
+        var eventData = __EVENT_ARGS_CONSTRUCTOR__;
+
+#line __SOURCE_LINE__ "__SOURCE_PATH__"
+__METHOD_CODE__
+#line default
+    }
+
+    ItemPayload IArasMethod.ContextPayload => ReadDocument(InputDocument);
+    System.Xml.XmlDocument IArasMethod.ContextDocument => InputDocument;
+}

package/dist/methods/csharp/managed/MethodAssemblies.cs

@@ -0,0 +1,83 @@
+using System.Reflection;
+using System.Reflection.Metadata;
+using System.Reflection.PortableExecutable;
+
+namespace InnovatorHarness.Managed;
+
+/// <summary>Keep JIT code only when the assembly has no world-owned static storage.</summary>
+internal sealed class MethodAssemblies(IReadOnlyDictionary<string, string> references)
+{
+    private const int AssembliesMax = 2048;
+    private readonly MethodContext context = new(references);
+    private readonly Dictionary<string, Assembly?> assemblies = new(StringComparer.Ordinal);
+    private readonly object gate = new();
+
+    internal Assembly? Find(string path)
+    {
+        lock (gate)
+        {
+            if (assemblies.TryGetValue(path, out var cached))
+            {
+                return cached;
+            }
+
+            if (assemblies.Count >= AssembliesMax)
+            {
+                return null;
+            }
+
+            Assembly? assembly = null;
+
+            if (CanShare(path))
+            {
+                assembly = context.LoadMethod(path);
+            }
+
+            assemblies.Add(path, assembly);
+
+            return assembly;
+        }
+    }
+
+    private static bool CanShare(string path)
+    {
+        if (!ContextSafety.CanReuse(path))
+        {
+            return false;
+        }
+
+        using var stream = File.OpenRead(path);
+        using var image = new PEReader(stream);
+        var metadata = image.GetMetadataReader();
+
+        foreach (var handle in metadata.FieldDefinitions)
+        {
+            var field = metadata.GetFieldDefinition(handle);
+            var attributes = field.Attributes;
+
+            if ((attributes & FieldAttributes.Static) != 0 &&
+                !IsCodeConstant(metadata, field))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    private static bool IsCodeConstant(MetadataReader metadata, FieldDefinition field)
+    {
+        if ((field.Attributes & FieldAttributes.Literal) != 0)
+        {
+            return true;
+        }
+
+        // Roslyn embeds array initializer bytes here; InitializeArray copies them into new arrays.
+        var immutableData = FieldAttributes.InitOnly | FieldAttributes.HasFieldRVA;
+        var owner = metadata.GetTypeDefinition(field.GetDeclaringType());
+
+        return (field.Attributes & immutableData) == immutableData &&
+            field.GetRelativeVirtualAddress() != 0 &&
+            metadata.GetString(owner.Name) == "<PrivateImplementationDetails>";
+    }
+}

package/dist/methods/csharp/managed/MethodContext.cs

@@ -0,0 +1,44 @@
+using System.Reflection;
+using System.Runtime.Loader;
+
+namespace InnovatorHarness.Managed;
+
+internal sealed class MethodContext(IReadOnlyDictionary<string, string> references)
+    : AssemblyLoadContext(isCollectible: true)
+{
+    private int reusable = 1;
+
+    internal bool CanReuse => Volatile.Read(ref reusable) == 1;
+
+    internal Assembly LoadMethod(string path)
+    {
+        if (!ContextSafety.CanReuse(path))
+        {
+            Interlocked.Exchange(ref reusable, 0);
+        }
+
+        return LoadFromAssemblyPath(path);
+    }
+
+    protected override Assembly? Load(AssemblyName name)
+    {
+        var contract = typeof(IArasMethod).Assembly;
+
+        if (name.Name == contract.GetName().Name)
+        {
+            return contract;
+        }
+
+        if (name.Name == "Newtonsoft.Json")
+        {
+            return Default.LoadFromAssemblyName(name);
+        }
+
+        if (name.Name is not null && references.TryGetValue(name.Name, out var path))
+        {
+            return LoadFromAssemblyPath(path);
+        }
+
+        return null;
+    }
+}

package/dist/methods/csharp/managed/MethodEventArgs.cs

@@ -0,0 +1,64 @@
+using System.Xml;
+using InnovatorHarness.Managed;
+
+namespace Aras.Server.Core;
+
+public sealed class OnBeforeUpdateEventArgs
+{
+    public string Id { get; }
+    public IEnumerable<string> IdList { get; }
+
+    public OnBeforeUpdateEventArgs(Remote remote, XmlDocument? input = null)
+    {
+        var data = EventMetadata.Require(remote, "onBeforeUpdate");
+        Id = EventMetadata.Required(data.Id, "id");
+        IdList = data.Ids();
+    }
+}
+
+public sealed class OnAfterAddEventArgs
+{
+    public string TypeId { get; }
+    public string Id { get; }
+    public IEnumerable<string> IdList { get; }
+
+    public OnAfterAddEventArgs(Remote remote, XmlDocument? input = null)
+    {
+        var data = EventMetadata.Require(remote, "onAfterAdd");
+        TypeId = EventMetadata.Required(data.TypeId, "typeId");
+        Id = EventMetadata.Required(data.Id, "id");
+        IdList = data.Ids();
+    }
+}
+
+public sealed class OnAfterUpdateEventArgs
+{
+    public string TypeId { get; }
+    public string? Id { get; }
+    public IReadOnlyDictionary<string, string> OldIdsNewIdsMap { get; }
+    public IEnumerable<string> NewItemsIds => OldIdsNewIdsMap.Values;
+
+    public OnAfterUpdateEventArgs(Remote remote, XmlDocument? input = null)
+    {
+        var data = EventMetadata.Require(remote, "onAfterUpdate");
+        TypeId = EventMetadata.Required(data.TypeId, "typeId");
+        Id = data.Id;
+        OldIdsNewIdsMap = data.Mapping();
+    }
+}
+
+public sealed class AfterVersionEventArgs
+{
+    public string TypeId { get; }
+    public string NewItemId { get; }
+    public IReadOnlyDictionary<string, string> OldIdsNewIdsMap { get; }
+    public IEnumerable<string> NewItemsIds => OldIdsNewIdsMap.Values;
+
+    public AfterVersionEventArgs(Remote remote, XmlDocument? input = null)
+    {
+        var data = EventMetadata.Require(remote, "onAfterVersion");
+        TypeId = EventMetadata.Required(data.TypeId, "typeId");
+        NewItemId = EventMetadata.Required(data.NewItemId, "newItemId");
+        OldIdsNewIdsMap = data.Mapping();
+    }
+}

package/dist/methods/csharp/managed/MethodInvocation.cs

@@ -0,0 +1,201 @@
+using System.Reflection;
+using System.Text.Json;
+using System.Xml;
+
+namespace InnovatorHarness.Managed;
+
+internal static class MethodInvocation
+{
+    private const int FailureTextMax = 16 * 1024;
+    private sealed record RetainedInput(ItemPayload Payload, OriginFrame Origins);
+
+    internal static void Run(Invocation message, MethodContext context,
+        MethodAssemblies? shared, Protocol protocol)
+    {
+        var remote = new Remote(protocol, message.Id, message.EventData);
+        IArasMethod? method = null;
+        XmlElement? initialRoot = null;
+
+        try
+        {
+            using var scope = RemoteContext.Enter(remote);
+
+            if (message.Document is { } document && message.Context is { } input)
+            {
+                message = message with { Context = ManagedDocuments.Restore(input, document) };
+            }
+
+            method = CreateMethod(message, context, shared, remote);
+            initialRoot = method.ContextDocument.DocumentElement;
+            Execute(message, context, protocol, remote, method, initialRoot);
+        }
+        catch (Exception exception)
+        {
+            Exception error = exception;
+
+            if (exception is TargetInvocationException { InnerException: { } inner })
+            {
+                error = inner;
+            }
+
+            WriteFailure(message, context, protocol, remote, method, initialRoot, error);
+        }
+    }
+
+    private static void WriteFailure(
+        Invocation message, MethodContext context, Protocol protocol, Remote remote,
+        IArasMethod? method, XmlElement? initialRoot, Exception error)
+    {
+        string failure = FailureText(error);
+
+        try
+        {
+            ItemPayload? input = method?.ContextPayload ?? message.Context;
+            RetainedInput? retained = CaptureDetachedInput(message.Context, input, remote);
+            OriginFrame? origins = null;
+
+            if (input is not null)
+            {
+                origins = remote.Origins.Capture(input);
+            }
+
+            protocol.Write(new
+            {
+                kind = "failure",
+                id = message.Id,
+                reusable = context.CanReuse,
+                error = failure,
+                context = input,
+                contextOrigins = origins,
+                retainedContext = retained?.Payload,
+                retainedOrigins = retained?.Origins,
+                contextDocument = ContextXml(message, method, initialRoot),
+                documentReplaced = ReplacedRoot(method, initialRoot)
+            });
+        }
+        catch (Exception contextError) when (contextError is NotSupportedException
+            or InvalidOperationException or JsonException or ArgumentException or XmlException)
+        {
+            protocol.Write(new
+            {
+                kind = "failure",
+                id = message.Id,
+                reusable = context.CanReuse,
+                error = failure,
+                contextError = FailureText(contextError)
+            });
+        }
+    }
+
+    private static string FailureText(Exception error)
+    {
+        string text = error.ToString();
+
+        if (text.Length > FailureTextMax)
+        {
+            return text[..FailureTextMax] + " [truncated]";
+        }
+
+        return text;
+    }
+
+    private static IArasMethod CreateMethod(Invocation message, MethodContext context,
+        MethodAssemblies? shared, Remote remote)
+    {
+        if (message.Assembly is null || message.TypeName is null || message.Context is null)
+        {
+            throw new InvalidOperationException("Incomplete managed invocation.");
+        }
+
+        remote.Origins.Apply(message.Context, message.ContextOrigins);
+        var assembly = shared?.Find(message.Assembly);
+
+        if (assembly is null)
+        {
+            assembly = context.LoadMethod(message.Assembly);
+        }
+
+        var type = assembly.GetType(message.TypeName, throwOnError: true)
+            ?? throw new InvalidOperationException("Compiled Method type is missing.");
+        var instance = Activator.CreateInstance(type, message.Context, remote);
+
+        return instance as IArasMethod
+            ?? throw new InvalidOperationException("Compiled Method has the wrong template.");
+    }
+
+    private static void Execute(Invocation message, MethodContext context,
+        Protocol protocol, Remote remote, IArasMethod method, XmlElement? initialRoot)
+    {
+        protocol.Write(new { kind = "started", id = message.Id, reusable = context.CanReuse });
+        var result = method.Execute();
+        var original = method.ContextPayload;
+        RetainedInput? retained = CaptureDetachedInput(message.Context, original, remote);
+        var returned = new ItemPayload { Result = "" };
+
+        if (result is not null)
+        {
+            returned = result.DocumentPayload;
+        }
+
+        var contextIsResult = ReferenceEquals(returned, original);
+        ItemPayload? changedContext = null;
+        OriginFrame? changedOrigins = null;
+
+        if (!contextIsResult)
+        {
+            changedContext = original;
+            changedOrigins = remote.Origins.Capture(original);
+        }
+
+        protocol.Write(new
+        {
+            kind = "result",
+            id = message.Id,
+            payload = returned,
+            reusable = context.CanReuse,
+            contextIsResult,
+            context = changedContext,
+            origins = remote.Origins.Capture(returned),
+            contextOrigins = changedOrigins,
+            retainedContext = retained?.Payload,
+            retainedOrigins = retained?.Origins,
+            contextDocument = ContextXml(message, method, initialRoot),
+            documentReplaced = ReplacedRoot(method, initialRoot)
+        });
+    }
+
+    private static string? ContextXml(
+        Invocation message, IArasMethod? method, XmlElement? initialRoot)
+    {
+        if (method is null || (message.Document is null
+            && ReferenceEquals(initialRoot, method.ContextDocument.DocumentElement)))
+        {
+            return null;
+        }
+
+        return method.ContextDocument.OuterXml;
+    }
+
+    private static bool ReplacedRoot(IArasMethod? method, XmlElement? initialRoot)
+    {
+        return method is not null
+            && !ReferenceEquals(initialRoot, method.ContextDocument.DocumentElement);
+    }
+
+    private static RetainedInput? CaptureDetachedInput(
+        ItemPayload? original, ItemPayload? current, Remote remote)
+    {
+        if (original is null || current is null
+            || (original.Items.Count == current.Items.Count
+                && original.Items.Zip(current.Items)
+                    .All(pair => ReferenceEquals(pair.First, pair.Second))))
+        {
+            return null;
+        }
+
+        var retained = new ItemPayload { Items = original.Items.ToList() };
+        OriginFrame origins = remote.Origins.Capture(retained);
+
+        return new(retained, origins);
+    }
+}

package/dist/methods/csharp/managed/NuGet.Config

@@ -0,0 +1,6 @@
+<configuration>
+    <packageSources>
+        <clear />
+        <add key="nuget.org" value="https://api.nuget.org/v3/index.json" />
+    </packageSources>
+</configuration>

package/dist/methods/csharp/managed/PayloadXml.cs

@@ -0,0 +1,38 @@
+using System.Xml;
+
+namespace InnovatorHarness.Managed;
+
+internal static class PayloadXml
+{
+    public static XmlElement CreateResult(
+        XmlDocument document, ItemPayload payload, bool wrapEnvelope = false)
+    {
+        XmlElement result = document.CreateElement("Result");
+
+        if (!wrapEnvelope && payload.Messages is not { Count: > 0 })
+        {
+            document.AppendChild(result);
+
+            return result;
+        }
+
+        const string soapNamespace = "http://schemas.xmlsoap.org/soap/envelope/";
+        XmlElement envelope = document.CreateElement("SOAP-ENV", "Envelope", soapNamespace);
+        XmlElement body = document.CreateElement("SOAP-ENV", "Body", soapNamespace);
+        document.AppendChild(envelope);
+        envelope.AppendChild(body);
+        body.AppendChild(result);
+        XmlElement message = document.CreateElement("Message");
+        body.AppendChild(message);
+
+        foreach (ItemMessage entry in payload.Messages ?? new())
+        {
+            XmlElement element = document.CreateElement("event");
+            element.SetAttribute("name", entry.Name);
+            element.SetAttribute("value", entry.Value);
+            message.AppendChild(element);
+        }
+
+        return result;
+    }
+}

package/dist/methods/csharp/managed/Permissions.cs

@@ -0,0 +1,47 @@
+using Aras.Server.Security;
+
+namespace InnovatorHarness.Managed;
+
+public sealed class Permissions(Remote remote)
+{
+    public string IdentitiesList
+    {
+        get
+        {
+            return remote.Call("securityIdentities", new { }).Result
+                ?? throw new InvalidOperationException("The session identity list is missing.");
+        }
+    }
+
+    public bool IdentityListHasId(string identities, string id)
+    {
+        return identities.Split(',',
+            StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries)
+            .Any(identity => identity.Equals(id, StringComparison.OrdinalIgnoreCase));
+    }
+
+    public IDisposable GrantIdentity(Identity? identity)
+    {
+        ArgumentNullException.ThrowIfNull(identity);
+        string token = remote.Call("securityGrant", new { id = identity.Id }).Result
+            ?? throw new InvalidOperationException("The granted identity scope has no token.");
+
+        return new Grant(remote, token);
+    }
+
+    private sealed class Grant(Remote remote, string token) : IDisposable
+    {
+        private bool disposed;
+
+        public void Dispose()
+        {
+            if (disposed)
+            {
+                return;
+            }
+
+            remote.Call("securityRevoke", new { token });
+            disposed = true;
+        }
+    }
+}

package/dist/methods/csharp/managed/Program.cs

@@ -0,0 +1,83 @@
+using System.Reflection;
+using System.Runtime.Loader;
+using System.Text.Json;
+using InnovatorHarness.Managed;
+
+var protocol = new Protocol(Console.Out);
+using var input = new ProtocolInput(Console.OpenStandardInput());
+Console.SetOut(Console.Error);
+var references = args.ToDictionary(
+    path => AssemblyName.GetAssemblyName(path).Name
+        ?? throw new InvalidOperationException("Reference assembly has no name."),
+    Path.GetFullPath,
+    StringComparer.OrdinalIgnoreCase);
+
+if (!references.ContainsKey("Newtonsoft.Json"))
+{
+    references.Add("Newtonsoft.Json",
+        Path.Combine(AppContext.BaseDirectory, "Newtonsoft.Json.dll"));
+}
+
+AssemblyLoadContext.Default.Resolving += (_, name) =>
+{
+    if (name.Name is not null && references.TryGetValue(name.Name, out var path))
+    {
+        return AssemblyLoadContext.Default.LoadFromAssemblyPath(path);
+    }
+
+    return null;
+};
+var tasks = new List<Task>();
+MethodAssemblies? sharedMethods = null;
+
+if (args.Length == 0)
+{
+    sharedMethods = new MethodAssemblies(references);
+}
+
+var methodContext = new MethodContext(references);
+
+try
+{
+    while (input.ReadLine() is { } line)
+    {
+        var message = JsonSerializer.Deserialize<Invocation>(line, Protocol.Json)
+            ?? throw new InvalidOperationException("Invalid Bun message.");
+
+        if (message.Kind == "callbackResult")
+        {
+            protocol.Complete(message);
+        }
+        else if (message.Kind == "reset")
+        {
+            // Keep the blocking input loop on its dedicated main thread after a reset.
+            Task.WhenAll(tasks).GetAwaiter().GetResult();
+            tasks.Clear();
+            methodContext.Unload();
+            methodContext = new MethodContext(references);
+            protocol.Write(new { kind = "reset", id = message.Id });
+        }
+        else if (message.Kind == "invoke")
+        {
+            protocol.Write(new { kind = "received", id = message.Id });
+            tasks.RemoveAll(task => task.IsCompleted);
+
+            if (tasks.Count >= WorkLimits.PendingCallsMax)
+            {
+                throw new InvalidOperationException("Managed invocation queue is full.");
+            }
+
+            tasks.Add(Task.Run(() => MethodInvocation.Run(
+                message, methodContext, sharedMethods, protocol)));
+        }
+        else
+        {
+            throw new InvalidOperationException($"Unknown message kind '{message.Kind}'.");
+        }
+    }
+}
+finally
+{
+    protocol.Stop();
+    Task.WhenAll(tasks).GetAwaiter().GetResult();
+}

package/dist/methods/csharp/managed/PropertyItems.cs

@@ -0,0 +1,46 @@
+using System.Xml;
+
+namespace InnovatorHarness.Managed;
+
+internal static class PropertyItems
+{
+    // A property keeps its wrapper and attributes; the supplied Item becomes an imported copy.
+    public static XmlElement Replace(XmlElement property, XmlElement source)
+    {
+        XmlElement copy = Copy(property, source);
+        var previous = property.ChildNodes.OfType<XmlElement>()
+            .FirstOrDefault(child => child.Name == "Item");
+
+        if (previous is not null)
+        {
+            property.ReplaceChild(copy, previous);
+        }
+        else
+        {
+            property.InnerText = "";
+            property.AppendChild(copy);
+        }
+
+        return copy;
+    }
+
+    public static XmlElement Append(XmlElement parent, XmlElement source)
+    {
+        XmlElement copy = Copy(parent, source);
+        parent.AppendChild(copy);
+
+        return copy;
+    }
+
+    private static XmlElement Copy(XmlElement parent, XmlElement source)
+    {
+        XmlTraversal.Validate(source);
+
+        if (XmlTraversal.Owner(parent).ImportNode(source, deep: true) is XmlElement copy)
+        {
+            return copy;
+        }
+
+        throw new InvalidOperationException("An imported Item must remain an element.");
+    }
+}