From 549370328004cc0a9c39d7b93b06f70ca302920c Mon Sep 17 00:00:00 2001
From: Joseph Doherty <dohejw01@gmail.com>
Date: Sat, 28 Feb 2026 20:15:59 -0500
Subject: [PATCH] feat(batch19): implement service reply and stream
 import/export methods

---
 .../ZB.MOM.NatsNet.Server/Accounts/Account.cs | 414 ++++++++++++++++++
 porting.db                                    | Bin 6684672 -> 6688768 bytes
 2 files changed, 414 insertions(+)

diff --git a/dotnet/src/ZB.MOM.NatsNet.Server/Accounts/Account.cs b/dotnet/src/ZB.MOM.NatsNet.Server/Accounts/Account.cs
index a6ef4db..c12203e 100644
--- a/dotnet/src/ZB.MOM.NatsNet.Server/Accounts/Account.cs
+++ b/dotnet/src/ZB.MOM.NatsNet.Server/Accounts/Account.cs
@@ -2768,6 +2768,420 @@ public sealed class Account : INatsAccount
         ServiceImportReply = [.. prefix, (byte)'.'];
     }
 
+    /// <summary>
+    /// Generates a new service reply subject.
+    /// Mirrors Go <c>(a *Account) newServiceReply(tracking bool) []byte</c>.
+    /// </summary>
+    internal byte[] NewServiceReply(bool tracking)
+    {
+        bool createdPrefix = false;
+        byte[] replyPrefix;
+
+        _mu.EnterWriteLock();
+        try
+        {
+            if (ServiceImportReply == null)
+            {
+                CreateRespWildcard();
+                createdPrefix = true;
+            }
+
+            replyPrefix = ServiceImportReply ?? Encoding.ASCII.GetBytes("_R_.");
+        }
+        finally
+        {
+            _mu.ExitWriteLock();
+        }
+
+        if (createdPrefix)
+            _ = SubscribeServiceImportResponse(Encoding.ASCII.GetString([.. replyPrefix, (byte)'>']));
+
+        const string alphabet = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+        Span<byte> randomPart = stackalloc byte[20];
+        ulong random = (ulong)Random.Shared.NextInt64();
+        for (var i = 0; i < randomPart.Length; i++)
+        {
+            randomPart[i] = (byte)alphabet[(int)(random % (ulong)alphabet.Length)];
+            random /= (ulong)alphabet.Length;
+        }
+
+        var reply = new List<byte>(replyPrefix.Length + randomPart.Length + 2);
+        reply.AddRange(replyPrefix);
+        reply.AddRange(randomPart.ToArray());
+
+        if (tracking)
+        {
+            reply.Add((byte)'.');
+            reply.Add((byte)'T');
+        }
+
+        return [.. reply];
+    }
+
+    /// <summary>
+    /// Returns the response threshold for an exported service.
+    /// Mirrors Go <c>(a *Account) ServiceExportResponseThreshold(...)</c>.
+    /// </summary>
+    public (TimeSpan Threshold, Exception? Error) ServiceExportResponseThreshold(string export)
+    {
+        _mu.EnterReadLock();
+        try
+        {
+            var serviceExport = GetServiceExport(export);
+            if (serviceExport == null)
+                return (TimeSpan.Zero, new InvalidOperationException($"no export defined for \"{export}\""));
+            return (serviceExport.ResponseThreshold, null);
+        }
+        finally
+        {
+            _mu.ExitReadLock();
+        }
+    }
+
+    /// <summary>
+    /// Sets max response delivery time for an exported service.
+    /// Mirrors Go <c>(a *Account) SetServiceExportResponseThreshold(...)</c>.
+    /// </summary>
+    public Exception? SetServiceExportResponseThreshold(string export, TimeSpan maxTime)
+    {
+        _mu.EnterWriteLock();
+        try
+        {
+            if (IsClaimAccount())
+                return new InvalidOperationException("claim based accounts can not be updated directly");
+
+            var serviceExport = GetServiceExport(export);
+            if (serviceExport == null)
+                return new InvalidOperationException($"no export defined for \"{export}\"");
+
+            serviceExport.ResponseThreshold = maxTime;
+            return null;
+        }
+        finally
+        {
+            _mu.ExitWriteLock();
+        }
+    }
+
+    /// <summary>
+    /// Enables/disables cross-account trace propagation on a service export.
+    /// Mirrors Go <c>(a *Account) SetServiceExportAllowTrace(...)</c>.
+    /// </summary>
+    public Exception? SetServiceExportAllowTrace(string export, bool allowTrace)
+    {
+        _mu.EnterWriteLock();
+        try
+        {
+            var serviceExport = GetServiceExport(export);
+            if (serviceExport == null)
+                return new InvalidOperationException($"no export defined for \"{export}\"");
+
+            serviceExport.AllowTrace = allowTrace;
+            return null;
+        }
+        finally
+        {
+            _mu.ExitWriteLock();
+        }
+    }
+
+    /// <summary>
+    /// Creates internal response service import entry.
+    /// Mirrors Go <c>(a *Account) addRespServiceImport(...)</c>.
+    /// </summary>
+    internal ServiceImportEntry AddRespServiceImport(Account destination, string to, ServiceImportEntry originalServiceImport, bool tracking, Dictionary<string, string[]>? header)
+    {
+        var newReply = Encoding.ASCII.GetString(originalServiceImport.Account?.NewServiceReply(tracking) ?? NewServiceReply(tracking));
+
+        ServiceImportEntry responseImport;
+        _mu.EnterWriteLock();
+        try
+        {
+            responseImport = new ServiceImportEntry
+            {
+                Account = destination,
+                ServiceExport = originalServiceImport.ServiceExport,
+                From = newReply,
+                To = to,
+                ResponseType = originalServiceImport.ResponseType,
+                IsResponse = true,
+                Share = originalServiceImport.Share,
+                Timestamp = UtcNowUnixNanos(),
+                Tracking = tracking && originalServiceImport.ResponseType == ServiceRespType.Singleton,
+                TrackingHeader = header,
+                Latency = tracking && originalServiceImport.ResponseType == ServiceRespType.Singleton
+                    ? originalServiceImport.Latency
+                    : null,
+            };
+
+            Exports.Responses ??= new Dictionary<string, ServiceImportEntry>(StringComparer.Ordinal);
+            Exports.Responses[newReply] = responseImport;
+        }
+        finally
+        {
+            _mu.ExitWriteLock();
+        }
+
+        destination.AddReverseRespMapEntry(this, to, newReply);
+        return responseImport;
+    }
+
+    /// <summary>
+    /// Adds stream import with optional claim context.
+    /// Mirrors Go <c>(a *Account) AddStreamImportWithClaim(...)</c>.
+    /// </summary>
+    public Exception? AddStreamImportWithClaim(Account account, string from, string prefix, object? importClaim) =>
+        AddStreamImportWithClaimInternal(account, from, prefix, false, importClaim);
+
+    /// <summary>
+    /// Internal stream import add helper.
+    /// Mirrors Go <c>(a *Account) addStreamImportWithClaim(...)</c>.
+    /// </summary>
+    internal Exception? AddStreamImportWithClaimInternal(Account account, string from, string prefix, bool allowTrace, object? importClaim)
+    {
+        if (account == null)
+            return ServerErrors.ErrMissingAccount;
+        if (!account.CheckStreamImportAuthorized(this, from, importClaim))
+            return ServerErrors.ErrStreamImportAuthorization;
+
+        if (!string.IsNullOrEmpty(prefix))
+        {
+            if (SubscriptionIndex.SubjectHasWildcard(prefix))
+                return ServerErrors.ErrStreamImportBadPrefix;
+            if (!prefix.EndsWith(".", StringComparison.Ordinal))
+                prefix += '.';
+        }
+
+        return AddMappedStreamImportWithClaimInternal(account, from, prefix + from, allowTrace, importClaim);
+    }
+
+    /// <summary>
+    /// Convenience helper for mapped stream imports without claim.
+    /// Mirrors Go <c>(a *Account) AddMappedStreamImport(...)</c>.
+    /// </summary>
+    public Exception? AddMappedStreamImport(Account account, string from, string to) =>
+        AddMappedStreamImportWithClaim(account, from, to, null);
+
+    /// <summary>
+    /// Adds mapped stream import with optional claim.
+    /// Mirrors Go <c>(a *Account) AddMappedStreamImportWithClaim(...)</c>.
+    /// </summary>
+    public Exception? AddMappedStreamImportWithClaim(Account account, string from, string to, object? importClaim) =>
+        AddMappedStreamImportWithClaimInternal(account, from, to, false, importClaim);
+
+    /// <summary>
+    /// Internal mapped stream import add helper.
+    /// Mirrors Go <c>(a *Account) addMappedStreamImportWithClaim(...)</c>.
+    /// </summary>
+    internal Exception? AddMappedStreamImportWithClaimInternal(Account account, string from, string to, bool allowTrace, object? importClaim)
+    {
+        if (account == null)
+            return ServerErrors.ErrMissingAccount;
+        if (!account.CheckStreamImportAuthorized(this, from, importClaim))
+            return ServerErrors.ErrStreamImportAuthorization;
+
+        if (string.IsNullOrEmpty(to))
+            to = from;
+
+        var cycleErr = StreamImportFormsCycle(account, to) ?? StreamImportFormsCycle(account, from);
+        if (cycleErr != null)
+            return cycleErr;
+
+        ISubjectTransformer? transform = null;
+        var usePublishedSubject = false;
+        if (SubscriptionIndex.SubjectHasWildcard(from))
+        {
+            if (to == from)
+            {
+                usePublishedSubject = true;
+            }
+            else
+            {
+                var (created, err) = SubjectTransform.New(from, to);
+                if (err != null)
+                    return new InvalidOperationException($"failed to create mapping transform for stream import subject from \"{from}\" to \"{to}\": {err.Message}");
+                transform = created;
+            }
+        }
+
+        _mu.EnterWriteLock();
+        try
+        {
+            if (IsStreamImportDuplicate(account, from))
+                return ServerErrors.ErrStreamImportDuplicate;
+
+            Imports.Streams ??= [];
+            Imports.Streams.Add(new StreamImportEntry
+            {
+                Account = account,
+                From = from,
+                To = to,
+                Transform = transform,
+                Claim = importClaim,
+                UsePublishedSubject = usePublishedSubject,
+                AllowTrace = allowTrace,
+            });
+            return null;
+        }
+        finally
+        {
+            _mu.ExitWriteLock();
+        }
+    }
+
+    /// <summary>
+    /// Checks if stream import duplicate exists. Lock should be held.
+    /// Mirrors Go <c>(a *Account) isStreamImportDuplicate(...)</c>.
+    /// </summary>
+    internal bool IsStreamImportDuplicate(Account account, string from)
+    {
+        if (Imports.Streams == null)
+            return false;
+
+        foreach (var streamImport in Imports.Streams)
+        {
+            if (ReferenceEquals(streamImport.Account, account) && streamImport.From == from)
+                return true;
+        }
+        return false;
+    }
+
+    /// <summary>
+    /// Adds stream import from a specific account.
+    /// Mirrors Go <c>(a *Account) AddStreamImport(...)</c>.
+    /// </summary>
+    public Exception? AddStreamImport(Account account, string from, string prefix) =>
+        AddStreamImportWithClaimInternal(account, from, prefix, false, null);
+
+    /// <summary>
+    /// Adds stream export, optionally restricted to explicit accounts.
+    /// Mirrors Go <c>(a *Account) AddStreamExport(...)</c>.
+    /// </summary>
+    public Exception? AddStreamExport(string subject, IReadOnlyList<Account>? accounts = null) =>
+        AddStreamExportWithAccountPos(subject, accounts, 0);
+
+    /// <summary>
+    /// Adds stream export with account-position matching.
+    /// Mirrors Go <c>(a *Account) addStreamExportWithAccountPos(...)</c>.
+    /// </summary>
+    public Exception? AddStreamExportWithAccountPos(string subject, IReadOnlyList<Account>? accounts, uint accountPos)
+    {
+        if (!SubscriptionIndex.IsValidSubject(subject))
+            return ServerErrors.ErrBadSubject;
+
+        _mu.EnterWriteLock();
+        try
+        {
+            Exports.Streams ??= new Dictionary<string, StreamExport>(StringComparer.Ordinal);
+            Exports.Streams.TryGetValue(subject, out var export);
+            export ??= new StreamExport();
+
+            if (accounts != null || accountPos > 0)
+            {
+                var authErr = SetExportAuth(export, subject, accounts, accountPos);
+                if (authErr != null)
+                    return authErr;
+            }
+
+            Exports.Streams[subject] = export;
+            return null;
+        }
+        finally
+        {
+            _mu.ExitWriteLock();
+        }
+    }
+
+    /// <summary>
+    /// Checks stream import authorization with account lock.
+    /// Mirrors Go <c>(a *Account) checkStreamImportAuthorized(...)</c>.
+    /// </summary>
+    internal bool CheckStreamImportAuthorized(Account account, string subject, object? importClaim)
+    {
+        _mu.EnterReadLock();
+        try { return CheckStreamImportAuthorizedNoLock(account, subject, importClaim); }
+        finally { _mu.ExitReadLock(); }
+    }
+
+    /// <summary>
+    /// Checks stream import authorization assuming lock is already held.
+    /// Mirrors Go <c>(a *Account) checkStreamImportAuthorizedNoLock(...)</c>.
+    /// </summary>
+    internal bool CheckStreamImportAuthorizedNoLock(Account account, string subject, object? importClaim)
+    {
+        if (Exports.Streams == null || !SubscriptionIndex.IsValidSubject(subject))
+            return false;
+        return CheckStreamExportApproved(account, subject, importClaim);
+    }
+
+    /// <summary>
+    /// Gets wildcard-matching service export for subject.
+    /// Lock should be held.
+    /// Mirrors Go <c>(a *Account) getWildcardServiceExport(from string)</c>.
+    /// </summary>
+    internal ServiceExportEntry? GetWildcardServiceExport(string from)
+    {
+        if (Exports.Services == null)
+            return null;
+
+        var tokens = SubjectTransform.TokenizeSubject(from);
+        foreach (var (subject, serviceExport) in Exports.Services)
+        {
+            if (SubjectTransform.IsSubsetMatch(tokens, subject))
+                return serviceExport;
+        }
+        return null;
+    }
+
+    /// <summary>
+    /// Handles stream import activation expiration.
+    /// Mirrors Go <c>(a *Account) streamActivationExpired(...)</c>.
+    /// </summary>
+    internal void StreamActivationExpired(Account exportAccount, string subject)
+    {
+        _mu.EnterWriteLock();
+        try
+        {
+            if (IsExpired() || Imports.Streams == null)
+                return;
+
+            foreach (var streamImport in Imports.Streams)
+            {
+                if (ReferenceEquals(streamImport.Account, exportAccount) && streamImport.From == subject)
+                {
+                    streamImport.Invalid = true;
+                    return;
+                }
+            }
+        }
+        finally
+        {
+            _mu.ExitWriteLock();
+        }
+    }
+
+    /// <summary>
+    /// Handles service import activation expiration.
+    /// Mirrors Go <c>(a *Account) serviceActivationExpired(...)</c>.
+    /// </summary>
+    internal void ServiceActivationExpired(Account destinationAccount, string subject)
+    {
+        _mu.EnterWriteLock();
+        try
+        {
+            if (IsExpired() || Imports.Services == null)
+                return;
+
+            var serviceImport = GetServiceImportForAccountLocked(destinationAccount.Name, subject);
+            if (serviceImport != null)
+                serviceImport.Invalid = true;
+        }
+        finally
+        {
+            _mu.ExitWriteLock();
+        }
+    }
+
     // -------------------------------------------------------------------------
     // Export checks
     // -------------------------------------------------------------------------
diff --git a/porting.db b/porting.db
index b8b7dd8af34c1826986988f973757d3fe1ccbe0c..b519e6617c5988917a52b8ff0332b00143fbe7a6 100644
GIT binary patch
delta 5072
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

delta 1725
zcmZ9~U2GIp6bJCRGqba^yK{H9TMC8U+inXK3QD&if{4)8@?~kIhy_t}EnPm0g?8Ig
z5vgq<DG5r7Ko1Y3d_*5KF;#e&XdpI7jK!#gNDw8V5F>~@R6q(S#sAJg%lh!ko-_B}
zbMKyen-A<&nw$43?Lo(GNz$S_!?W4$&!Yu-?29c2^UQ;JEc%&KJs>r!5t$;rtRP^_
zS3gj<svFcbhU~fN`Q7s~MOyr;%<f*+tAw0CNTHSMt83nj)yJgU$h?DDzj^dGRwTQt
zVyj~Dc&v&A>79G5n2yfy%~-+}ArB6ClQN!^8A+KZDRXm0@05&(b?BGN?1XAmux;j{
zD{Ku585NHlZUEWP;qI6@SJ`1UDXE?-DbtfOXCfo*8Y@y0k-6|1TX$@gbl><!8edo6
zP$>-{%CMq4h=y6wZA5M>>USw=vK3v!x5-xYCn9_8RYdmMKM>h#uOPD5UN*y@$XgXk
ze_syG;*$m|-SXXfQ0Z?(cBPw$>`FHf*_Hl6WLN4l2R@axY`xPcmlC&c8mHu$j8dkj
zSD2mUz9a6o^7Aq%pn?N5aDomlNX+q=<>!skU39%}xaer(Ug}xTCs6wdg?B^^Eu%~E
zRy*=|p_(OMX1!9EG1mR1>xzEYc~ZOOxItNAw%yF#$cr7+Rl`4|z&w|rnp!@UdRsNG
zvZ&QVkxVg)PSx^-bbWzSbd)H5S`g=v#1>v^i}UZTMb`IowcJPTb$q0?T7RR}l_Ie@
zYw6<GJdJ*;<8jJ9Gcr-aP1W@{WnvG#tX0RXa!y@Akw*M5chmj`uF>gwUO-!pc?I=d
z#5eyD?xcbSo@;O1*ud}8;?mUrjcU~N6?f5(jXcYqcWDDZLfOY1c5k{HA0B+5k)Nj1
z{rI=hxv1X%79UGB_uSsLbxj-+zdrCo3Ire(hCvz(hY^qtBViN-&2>$oT`i-vk0h_u
zBso^7jozF5U!%u;*43k5lA82XXQ8rLjxdqv`*Lb<iv9GqEDlrtQa*+jDdIs_cPQej
zedrR!N&8fhZ?%ekRk7gG4n5IACv`eRuJwISsc5iEG}iL8J?{z^EsH;Fz!WAf3|?!<
z8nkXG@j?Q4dHby9=LZXA7MvC=r0PnZL1#2EjwWhi1ReA_L)5pLb8jrZVeQJ6veprg
z+}6fQ9<U~xm|VgrO&6OeFjvK`tmf&oSr>llP+U3G;}Rd!@lD#$fSb184ds|;-C{eV
zL&ceby15umdkpMsJ*|_5IA<Rm19^4>?s3sM^xVGnicD*+OK<fBBv#UrLOZMQ)KY!o
zy`espRdJoZ^NI0^xxAxW(b_b>fDFilFl0eCjD|5V7II)5jE7v902ARccpN4{9z-A?
zCc_kX0;a-~Fb$@|Q!oRbhMDjT%!1ia0EJKl&q6WGfw?db=EDMb4oYAlltLLi4~w82
z7Q+j$1YU#+SPIMFC0GtG!z-`?UWL~n3a>*Ytb{64^T!4*_%%;h@<qH+-fnbz`aEG1
Nuh#IG;eTSi>VHP@9L)d#