af5c9744b7
UNS Area/Line/Equipment folders are minted under their opaque entity ids (s=UA-/UL-/EQ-...), virtual tags under s=EQ-.../Name and scripted conditions (+ #629 children) under s=<ScriptedAlarmId>[/...], while every UNS grant is planted at a NAME path. DataPlaneAuthorizer split those ids, so with Security:Acl:Enabled a narrow (Area/Line/Equipment) grant could not Browse, Read, subscribe or HistoryRead them, and Server-object delivery never reached it — so a narrow key never held the EventId Ack/Confirm/AddComment need. - The generation carries UnsFolderScopes (folderId -> path + id chain), built by DeploymentArtifact from the same AclScopePathResolver as the grants; ids two entity kinds share are dropped; plumbed through IDataPlaneAuthoritySink. - OtOpcUaNodeManager.ResolveUnsAclSubject reports live facts (folder id ancestry / scripted owner binding); attached by the Authorizer setter. - Evaluate places the subject against the CURRENT generation before the decision cache, which now caches the walk keyed on the resolved scope. Folders require live chain == generation chain (a moved equipment is denied under old and new line until the rebuild). Owned nodes (vtags, conditions, children) get owner path + a reserved segment, so Tag grants and their Browse transit never expose them. Conditions share TryPlaceScriptedCondition with the #797 command gate. - Server-object visibility of a scripted condition is decided on the condition alone, so a moved alarm cannot reach its old owner there. Tests: UnsFolderScopeWireTests (opaque ids, end-to-end browse -> EventId -> Acknowledge on an Equipment grant; sibling denied; Tag-only grant; moved alarm and moved equipment stale windows). Rig tests now install folder scopes explicitly (ServerEventRig.FolderScopes); the #797 recreate test deliberately asserts the moved alarm is invisible to the Cluster observer in the window.
398 lines
24 KiB
C#
398 lines
24 KiB
C#
using Microsoft.Extensions.Logging.Abstractions;
|
|
using Opc.Ua;
|
|
using Opc.Ua.Client;
|
|
using Shouldly;
|
|
using Xunit;
|
|
using ZB.MOM.WW.OtOpcUa.Commons.OpcUa;
|
|
using ZB.MOM.WW.OtOpcUa.Configuration.Entities;
|
|
using ZB.MOM.WW.OtOpcUa.Configuration.Enums;
|
|
using ZB.MOM.WW.OtOpcUa.Core.Abstractions;
|
|
using ZB.MOM.WW.OtOpcUa.Core.Authorization;
|
|
using ZB.MOM.WW.OtOpcUa.OpcUaServer.Security;
|
|
|
|
namespace ZB.MOM.WW.OtOpcUa.OpcUaServer.IntegrationTests;
|
|
|
|
/// <summary>
|
|
/// Gitea #808 over the wire — a real activated <c>apikey</c> session with <b>zero</b> server-wide roles and only a
|
|
/// NARROW UNS grant, against a production-shaped UNS tree: every Area / Line / Equipment folder is minted under its
|
|
/// opaque entity id (<c>UA-…</c>, <c>UL-…</c>, <c>EQ-…</c>), virtual tags under <c>EQ-…/Name</c>, scripted conditions
|
|
/// under their opaque <c>ScriptedAlarmId</c>, while every grant is planted at a NAME path resolved by
|
|
/// <see cref="AclScopePathResolver"/>. Before #808 such a session could not browse, read or subscribe any of those
|
|
/// nodes, and never received a scripted-alarm event through the Server object — so it never held the EventId that
|
|
/// Acknowledge / Confirm / AddComment need. <see cref="ServerEventRig"/>'s own folders (<c>EqA</c> ⇒
|
|
/// <c>[uns, EqA]</c>) are deliberately NOT used: their id coincides with their path, which is what hid this.
|
|
/// </summary>
|
|
public sealed class UnsFolderScopeWireTests
|
|
{
|
|
private const string AreaId = "UA-0000000001";
|
|
private const string Line1 = "UL-0000000001";
|
|
private const string Line2 = "UL-0000000002";
|
|
private const string Pump = "EQ-00000000a1b2";
|
|
private const string Fan = "EQ-00000000c3d4";
|
|
private const string Alarm = ServerEventRig.ScriptedAlarmId; // "scripted-eqa-hi", deployed under Pump
|
|
private const string PumpLo = "scripted-pump-lo";
|
|
private const string FanAlarm = "scripted-fan-hi";
|
|
private const string PumpSpeed = Pump + "/Speed"; // a virtual tag: s=<EquipmentId>/<Name>
|
|
private const string FanSpeed = Fan + "/Speed";
|
|
private const string PumpFlow = "Area1/Line1/Pump/Flow"; // a UNS reference variable: s=<Area>/<Line>/<Equipment>/<Name>
|
|
private const string FlowTagId = "TAG-flow";
|
|
|
|
private const NodePermissions Operator =
|
|
NodePermissions.ReadOnly | NodePermissions.AlarmAcknowledge | NodePermissions.AlarmConfirm;
|
|
|
|
/// <summary>
|
|
/// The ScadaBridge path end to end on an Equipment grant alone: navigate from the shared root down to the
|
|
/// equipment, read its folder / alarm children / virtual tag / reference variable, receive its scripted alarm
|
|
/// through the Server object, and Acknowledge with the EventId the session obtained ITSELF. Every sibling
|
|
/// (another equipment's folder, alarm, alarm child, virtual tag, folder event item) is denied on the same
|
|
/// session, and the sibling's alarm event — reported FIRST — never arrives.
|
|
/// </summary>
|
|
[Fact]
|
|
public async Task A_narrow_equipment_grant_browses_reads_receives_and_acknowledges_end_to_end()
|
|
{
|
|
var ct = TestContext.Current.CancellationToken;
|
|
await using var rig = await ServerEventRig.StartAsync("Uns808EndToEnd", encrypted: false, ct);
|
|
rig.KeyRoles = [];
|
|
Topology(rig, pumpLine: Line1);
|
|
Install(rig, pumpLine: Line1, Deployed(), EquipmentGrant(Pump, Operator));
|
|
var routed = Route(rig);
|
|
|
|
using var session = await rig.ConnectAsync(anonymous: false, ct);
|
|
AssertNoRoles(rig);
|
|
|
|
// Navigation: shared root → area → line → equipment, each step by Browse transit / the grant itself.
|
|
(await BrowseAsync(session, RootNodeId(session), ct)).Ids.ShouldContain(AreaId);
|
|
(await BrowseAsync(session, Uns(session, AreaId), ct)).Ids.ShouldBe([Line1], "Line2 holds nothing granted");
|
|
(await BrowseAsync(session, Uns(session, Line1), ct)).Ids.ShouldBe([Pump], "the sibling equipment is withheld");
|
|
var inPump = (await BrowseAsync(session, Uns(session, Pump), ct)).Ids;
|
|
inPump.ShouldContain(Alarm);
|
|
inPump.ShouldContain(PumpLo);
|
|
inPump.ShouldContain(PumpSpeed);
|
|
inPump.ShouldContain(PumpFlow);
|
|
(await BrowseAsync(session, Uns(session, Fan), ct)).Status.ShouldBe(StatusCodes.BadUserAccessDenied);
|
|
|
|
// Reads: the folder, a scripted condition child (#629 instance-scoped id), the virtual tag, the reference.
|
|
var pumpEnabled = ChildId(rig, Alarm, c => c.EnabledState!.Id!);
|
|
var fanEnabled = ChildId(rig, FanAlarm, c => c.EnabledState!.Id!);
|
|
pumpEnabled.ShouldStartWith(Alarm + "/");
|
|
(await ReadAsync(session, Uns(session, Pump), Attributes.DisplayName, ct)).ShouldBe(StatusCodes.Good);
|
|
(await ReadAsync(session, Uns(session, Alarm), Attributes.DisplayName, ct)).ShouldBe(StatusCodes.Good);
|
|
(await ReadAsync(session, Uns(session, pumpEnabled), Attributes.Value, ct)).ShouldBe(StatusCodes.Good);
|
|
(await ReadAsync(session, Uns(session, PumpSpeed), Attributes.DisplayName, ct)).ShouldBe(StatusCodes.Good);
|
|
(await ReadAsync(session, Uns(session, PumpFlow), Attributes.DisplayName, ct)).ShouldBe(StatusCodes.Good);
|
|
(await ReadAsync(session, Uns(session, Fan), Attributes.DisplayName, ct)).ShouldBe(StatusCodes.BadUserAccessDenied);
|
|
(await ReadAsync(session, Uns(session, FanAlarm), Attributes.DisplayName, ct)).ShouldBe(StatusCodes.BadUserAccessDenied);
|
|
(await ReadAsync(session, Uns(session, fanEnabled), Attributes.Value, ct)).ShouldBe(StatusCodes.BadUserAccessDenied);
|
|
(await ReadAsync(session, Uns(session, FanSpeed), Attributes.DisplayName, ct)).ShouldBe(StatusCodes.BadUserAccessDenied);
|
|
(await ReadAsync(session, Uns(session, AreaId), Attributes.DisplayName, ct))
|
|
.ShouldBe(StatusCodes.BadUserAccessDenied, "transit confers Browse on the ancestors, never Read");
|
|
|
|
// Events: the session's OWN Server-object item, plus direct items on its equipment folder and the sibling's.
|
|
var events = new RecordedEvents();
|
|
var subscription = await RecordedEvents.SubscribeAsync(session, events, ct);
|
|
var server = RecordedEvents.AddEventItem(subscription, ObjectIds.Server);
|
|
var pumpFolder = RecordedEvents.AddEventItem(subscription, Uns(session, Pump));
|
|
var fanFolder = RecordedEvents.AddEventItem(subscription, Uns(session, Fan));
|
|
await subscription.ApplyChangesAsync(ct);
|
|
server.Status.Error.ShouldBeNull();
|
|
pumpFolder.Status.Error.ShouldBeNull();
|
|
fanFolder.Status.Error.ShouldNotBeNull().StatusCode.ShouldBe(StatusCodes.BadUserAccessDenied);
|
|
|
|
var pre = new AlarmConditionSnapshot(true, false, false, true, AlarmShelvingKind.Unshelved, 700, "base");
|
|
Project(rig, FanAlarm, pre with { Message = "fan-base" }); // reported first: a late copy would precede "base"
|
|
Project(rig, Alarm, pre);
|
|
await RecordedEvents.WaitUntilAsync(() => events.Has(server, "base") && events.Has(pumpFolder, "base"));
|
|
events.Has(server, "fan-base").ShouldBeFalse("the sibling's alarm is not delivered through the Server object");
|
|
|
|
// Acknowledge with the EventId this narrow session received itself — the ScadaBridge flow #797 alone could
|
|
// not complete.
|
|
await ConditionMethodEventTests.CallAsync(
|
|
session, Uns(session, Alarm), "Acknowledge", events.LatestEventId(server, "base"), ct);
|
|
await RecordedEvents.WaitUntilAsync(() => events.ConditionEvents(server, "base").Count == 2);
|
|
events.ConditionEvents(server, "base")[1][RecordedEvents.AckedField].TryGetValue(out bool acked).ShouldBeTrue();
|
|
acked.ShouldBeTrue();
|
|
|
|
var siblingEventId = rig.Nm.TryGetAlarmCondition(FanAlarm)!.EventId!.Value.ToArray();
|
|
var denied = await Should.ThrowAsync<ServiceResultException>(ConditionMethodEventTests.CallAsync(
|
|
session, Uns(session, FanAlarm), "Acknowledge", siblingEventId, ct));
|
|
denied.StatusCode.ShouldBe(StatusCodes.BadUserAccessDenied);
|
|
|
|
Project(rig, FanAlarm, pre with { Message = "fan-sentinel" });
|
|
Project(rig, Alarm, pre with { Acknowledged = true, Message = "sentinel" });
|
|
await RecordedEvents.WaitUntilAsync(() => events.Has(server, "sentinel"));
|
|
events.Of(server).Count(f => RecordedEvents.Message(f)?.StartsWith("fan-", StringComparison.Ordinal) == true)
|
|
.ShouldBe(0);
|
|
routed.Select(c => (c.AlarmId, c.Operation)).ShouldBe([(Alarm, "Acknowledge")]);
|
|
|
|
await session.CloseAsync(ct);
|
|
}
|
|
|
|
/// <summary>
|
|
/// A principal holding only a TAG grant (one reference variable beneath the equipment) can navigate to it and
|
|
/// read it, but is NOT handed the equipment's other contents: its folder is browsable by transit and nothing
|
|
/// more, and the equipment's scripted alarms and virtual tags stay hidden from Browse and Read and its events
|
|
/// do not reach the Server object — a Tag grant is about that signal, not the equipment.
|
|
/// </summary>
|
|
[Fact]
|
|
public async Task A_tag_grant_reaches_its_reference_without_exposing_the_equipments_alarms_or_virtual_tags()
|
|
{
|
|
var ct = TestContext.Current.CancellationToken;
|
|
await using var rig = await ServerEventRig.StartAsync("Uns808TagOnly", encrypted: false, ct);
|
|
rig.KeyRoles = [];
|
|
Topology(rig, pumpLine: Line1);
|
|
Install(rig, pumpLine: Line1, Deployed(), TagGrant());
|
|
|
|
using var session = await rig.ConnectAsync(anonymous: false, ct);
|
|
|
|
(await BrowseAsync(session, Uns(session, Line1), ct)).Ids.ShouldBe([Pump]);
|
|
(await BrowseAsync(session, Uns(session, Pump), ct)).Ids.ShouldBe([PumpFlow]);
|
|
(await ReadAsync(session, Uns(session, PumpFlow), Attributes.DisplayName, ct)).ShouldBe(StatusCodes.Good);
|
|
(await ReadAsync(session, Uns(session, Pump), Attributes.DisplayName, ct)).ShouldBe(StatusCodes.BadUserAccessDenied);
|
|
(await ReadAsync(session, Uns(session, Alarm), Attributes.DisplayName, ct)).ShouldBe(StatusCodes.BadUserAccessDenied);
|
|
(await ReadAsync(session, Uns(session, PumpSpeed), Attributes.DisplayName, ct)).ShouldBe(StatusCodes.BadUserAccessDenied);
|
|
|
|
await session.CloseAsync(ct);
|
|
}
|
|
|
|
/// <summary>
|
|
/// A scripted alarm the generation has MOVED (deployed under Fan) while the address space still binds it to Pump —
|
|
/// the window between installing a generation and rebuilding its address space, or indefinitely after a failed
|
|
/// apply. Under BOTH owners' grants it is invisible (no Server-object event, no Read of the condition or its
|
|
/// children) and not commandable; the owner's other, correctly placed alarm keeps working (positive control).
|
|
/// Once the address space catches up the new owner's grant sees it and the old owner's does not.
|
|
/// </summary>
|
|
[Theory]
|
|
[InlineData(Pump)]
|
|
[InlineData(Fan)]
|
|
public async Task A_moved_alarm_is_denied_under_both_owners_until_the_address_space_catches_up(string grantedEquipment)
|
|
{
|
|
var ct = TestContext.Current.CancellationToken;
|
|
await using var rig = await ServerEventRig.StartAsync($"Uns808Moved{grantedEquipment[^4..]}", encrypted: false, ct);
|
|
rig.KeyRoles = [];
|
|
Topology(rig, pumpLine: Line1);
|
|
Install(rig, pumpLine: Line1, Deployed(alarmOwner: Fan), EquipmentGrant(grantedEquipment, Operator));
|
|
var routed = Route(rig);
|
|
|
|
using var session = await rig.ConnectAsync(anonymous: false, ct);
|
|
var events = new RecordedEvents();
|
|
var subscription = await RecordedEvents.SubscribeAsync(session, events, ct);
|
|
var server = RecordedEvents.AddEventItem(subscription, ObjectIds.Server);
|
|
await subscription.ApplyChangesAsync(ct);
|
|
|
|
var control = grantedEquipment == Pump ? PumpLo : FanAlarm;
|
|
var pre = new AlarmConditionSnapshot(true, false, false, true, AlarmShelvingKind.Unshelved, 700, "base");
|
|
Project(rig, Alarm, pre with { Message = "moved" });
|
|
Project(rig, control, pre with { Message = "control" });
|
|
await RecordedEvents.WaitUntilAsync(() => events.Has(server, "control"));
|
|
events.Has(server, "moved").ShouldBeFalse("a moved alarm is unplaceable for every grant during the window");
|
|
|
|
(await ReadAsync(session, Uns(session, Alarm), Attributes.DisplayName, ct)).ShouldBe(StatusCodes.BadUserAccessDenied);
|
|
(await ReadAsync(session, Uns(session, ChildId(rig, Alarm, c => c.EnabledState!.Id!)), Attributes.Value, ct))
|
|
.ShouldBe(StatusCodes.BadUserAccessDenied);
|
|
var staleEventId = rig.Nm.TryGetAlarmCondition(Alarm)!.EventId!.Value.ToArray();
|
|
(await Should.ThrowAsync<ServiceResultException>(ConditionMethodEventTests.CallAsync(
|
|
session, Uns(session, Alarm), "Acknowledge", staleEventId, ct)))
|
|
.StatusCode.ShouldBe(StatusCodes.BadUserAccessDenied);
|
|
routed.ShouldBeEmpty();
|
|
|
|
// The address space catches up: the alarm is re-materialised under its deployed owner.
|
|
((ISurgicalAddressSpaceSink)rig.Sink).RemoveAlarmConditionNode(Alarm, AddressSpaceRealm.Uns).ShouldBeTrue();
|
|
rig.Sink.MaterialiseAlarmCondition(Alarm, Fan, "hi", "AlarmCondition", 500, AddressSpaceRealm.Uns);
|
|
Project(rig, Alarm, pre with { Message = "placed" });
|
|
Project(rig, control, pre with { Message = "control-2" });
|
|
await RecordedEvents.WaitUntilAsync(() => events.Has(server, "control-2"));
|
|
|
|
var visible = grantedEquipment == Fan;
|
|
events.Has(server, "placed").ShouldBe(visible);
|
|
(await ReadAsync(session, Uns(session, Alarm), Attributes.DisplayName, ct))
|
|
.ShouldBe(visible ? StatusCodes.Good : StatusCodes.BadUserAccessDenied);
|
|
|
|
await session.CloseAsync(ct);
|
|
}
|
|
|
|
/// <summary>
|
|
/// An EQUIPMENT moved to another line by the generation while its folder still hangs under the old line: the live
|
|
/// folder ancestry disagrees with the generation's, so the folder and everything it owns are denied under the
|
|
/// new line's grant AND the old one's. After the rebuild re-parents it, the new line's grant reads it and the old
|
|
/// line's does not.
|
|
/// </summary>
|
|
[Theory]
|
|
[InlineData(Line1)]
|
|
[InlineData(Line2)]
|
|
public async Task A_moved_equipment_folder_is_denied_until_the_rebuild_reparents_it(string grantedLine)
|
|
{
|
|
var ct = TestContext.Current.CancellationToken;
|
|
await using var rig = await ServerEventRig.StartAsync($"Uns808Folder{grantedLine[^1..]}", encrypted: false, ct);
|
|
rig.KeyRoles = [];
|
|
Topology(rig, pumpLine: Line1);
|
|
Install(rig, pumpLine: Line2, Deployed(), LineGrant(grantedLine));
|
|
|
|
using var session = await rig.ConnectAsync(anonymous: false, ct);
|
|
(await ReadAsync(session, Uns(session, Pump), Attributes.DisplayName, ct)).ShouldBe(StatusCodes.BadUserAccessDenied);
|
|
(await ReadAsync(session, Uns(session, PumpSpeed), Attributes.DisplayName, ct)).ShouldBe(StatusCodes.BadUserAccessDenied);
|
|
// Positive control: the sibling, placed identically by both, follows the grant.
|
|
(await ReadAsync(session, Uns(session, Fan), Attributes.DisplayName, ct))
|
|
.ShouldBe(grantedLine == Line1 ? StatusCodes.Good : StatusCodes.BadUserAccessDenied);
|
|
|
|
rig.Sink.RebuildAddressSpace();
|
|
Topology(rig, pumpLine: Line2);
|
|
|
|
var expected = grantedLine == Line2 ? StatusCodes.Good : StatusCodes.BadUserAccessDenied;
|
|
(await ReadAsync(session, Uns(session, Pump), Attributes.DisplayName, ct)).ShouldBe(expected);
|
|
(await ReadAsync(session, Uns(session, PumpSpeed), Attributes.DisplayName, ct)).ShouldBe(expected);
|
|
|
|
await session.CloseAsync(ct);
|
|
}
|
|
|
|
// ───────────────────────────── helpers ─────────────────────────────
|
|
|
|
/// <summary>
|
|
/// Area1 / {Line1, Line2}; Pump under <paramref name="pumpLine"/> and Fan under Line1 — every folder an opaque
|
|
/// entity id, as <c>AddressSpaceApplier.MaterialiseHierarchy</c> mints them. Each equipment carries scripted
|
|
/// alarms and a virtual tag; Pump also carries a UNS reference variable (a NAME-path id).
|
|
/// </summary>
|
|
private static void Topology(ServerEventRig rig, string pumpLine)
|
|
{
|
|
rig.Sink.EnsureFolder(AreaId, parentNodeId: null, displayName: "Area1", realm: AddressSpaceRealm.Uns);
|
|
rig.Sink.EnsureFolder(Line1, parentNodeId: AreaId, displayName: "Line1", realm: AddressSpaceRealm.Uns);
|
|
rig.Sink.EnsureFolder(Line2, parentNodeId: AreaId, displayName: "Line2", realm: AddressSpaceRealm.Uns);
|
|
rig.Sink.EnsureFolder(Pump, parentNodeId: pumpLine, displayName: "Pump", realm: AddressSpaceRealm.Uns);
|
|
rig.Sink.EnsureFolder(Fan, parentNodeId: Line1, displayName: "Fan", realm: AddressSpaceRealm.Uns);
|
|
rig.Sink.EnsureVariable(PumpSpeed, Pump, "Speed", "Double", writable: false, AddressSpaceRealm.Uns);
|
|
rig.Sink.EnsureVariable(FanSpeed, Fan, "Speed", "Double", writable: false, AddressSpaceRealm.Uns);
|
|
rig.Sink.EnsureVariable(PumpFlow, Pump, "Flow", "Double", writable: false, AddressSpaceRealm.Uns);
|
|
rig.Sink.MaterialiseAlarmCondition(Alarm, Pump, "hi", "AlarmCondition", 500, AddressSpaceRealm.Uns);
|
|
rig.Sink.MaterialiseAlarmCondition(PumpLo, Pump, "lo", "AlarmCondition", 300, AddressSpaceRealm.Uns);
|
|
rig.Sink.MaterialiseAlarmCondition(FanAlarm, Fan, "fan hi", "AlarmCondition", 500, AddressSpaceRealm.Uns);
|
|
}
|
|
|
|
private static AclScopePathResolver Resolver(string pumpLine) => new(
|
|
new Dictionary<string, (string? ParentId, string Name)>(),
|
|
new Dictionary<string, (string? RawFolderId, string Name)>(),
|
|
new Dictionary<string, (string DriverInstanceId, string Name)>(),
|
|
new Dictionary<string, (string? ParentId, string DeviceId, string Name)>(),
|
|
new Dictionary<string, (string DeviceId, string? TagGroupId, string Name)>(),
|
|
new Dictionary<string, string> { [AreaId] = "Area1" },
|
|
new Dictionary<string, (string UnsAreaId, string Name)> { [Line1] = (AreaId, "Line1"), [Line2] = (AreaId, "Line2") },
|
|
new Dictionary<string, (string UnsLineId, string Name)> { [Pump] = (pumpLine, "Pump"), [Fan] = (Line1, "Fan") },
|
|
[]);
|
|
|
|
/// <summary>
|
|
/// Installs a generation whose topology puts Pump under <paramref name="pumpLine"/> — the owner paths, folder
|
|
/// scopes and grant paths all from ONE resolver, as <c>DeploymentArtifact.ParseDataPlaneAuthority</c> does.
|
|
/// </summary>
|
|
private static void Install(
|
|
ServerEventRig rig, string pumpLine, IReadOnlyDictionary<string, string> deployedOwners, params NodeAcl[] grants)
|
|
{
|
|
var resolver = Resolver(pumpLine);
|
|
var scopePaths = new Dictionary<AclScopeRef, IReadOnlyList<NodeAclPath>>(resolver.Resolve(grants))
|
|
{
|
|
// A Tag grant's UNS projection (the resolver would derive it from raw rows this rig does not model).
|
|
[new AclScopeRef(NodeAclScopeKind.Tag, FlowTagId)] = [new NodeAclPath([NodeAclRealms.Uns, "Area1", "Line1", "Pump", "Flow"])],
|
|
};
|
|
NodeAclPath One(NodeAclScopeKind kind, string id) => resolver.ResolveOne(kind, id).ShouldHaveSingleItem();
|
|
|
|
var owners = new Dictionary<string, NodeAclPath>
|
|
{
|
|
[Pump] = One(NodeAclScopeKind.Equipment, Pump),
|
|
[Fan] = One(NodeAclScopeKind.Equipment, Fan),
|
|
};
|
|
var folders = new Dictionary<string, UnsFolderScope>
|
|
{
|
|
[AreaId] = new(One(NodeAclScopeKind.UnsArea, AreaId), [AreaId]),
|
|
[Line1] = new(One(NodeAclScopeKind.UnsLine, Line1), [AreaId, Line1]),
|
|
[Line2] = new(One(NodeAclScopeKind.UnsLine, Line2), [AreaId, Line2]),
|
|
[Pump] = new(owners[Pump], [AreaId, pumpLine, Pump]),
|
|
[Fan] = new(owners[Fan], [AreaId, Line1, Fan]),
|
|
};
|
|
|
|
var state = new DataPlaneAuthorityState();
|
|
state.Apply(
|
|
ServerEventRig.Cluster, "rev-1", [ServerEventRig.Key()], grants, scopePaths, owners, deployedOwners, folders);
|
|
rig.Nm.DataPlaneAuthority = state;
|
|
rig.Nm.Authorizer = new DataPlaneAuthorizer(
|
|
state, new TriePermissionEvaluator(state.Tries), true, NullLogger.Instance, TimeProvider.System);
|
|
}
|
|
|
|
/// <summary>The generation's deployed scripted-alarm owners; <paramref name="alarmOwner"/> moves <see cref="Alarm"/>.</summary>
|
|
private static Dictionary<string, string> Deployed(string alarmOwner = Pump) =>
|
|
new() { [Alarm] = alarmOwner, [PumpLo] = Pump, [FanAlarm] = Fan };
|
|
|
|
private static NodeAcl EquipmentGrant(string equipmentId, NodePermissions flags) =>
|
|
KeyGrant($"eq-{equipmentId}", NodeAclScopeKind.Equipment, equipmentId, flags);
|
|
|
|
private static NodeAcl LineGrant(string lineId) =>
|
|
KeyGrant($"line-{lineId}", NodeAclScopeKind.UnsLine, lineId, NodePermissions.ReadOnly);
|
|
|
|
private static NodeAcl TagGrant() => KeyGrant("tag-flow", NodeAclScopeKind.Tag, FlowTagId, Operator);
|
|
|
|
private static NodeAcl KeyGrant(string id, NodeAclScopeKind kind, string scopeId, NodePermissions flags) => new()
|
|
{
|
|
NodeAclId = id,
|
|
ClusterId = ServerEventRig.Cluster,
|
|
Principal = ServerEventRig.KeyPrincipal,
|
|
ScopeKind = kind,
|
|
ScopeId = scopeId,
|
|
PermissionFlags = flags,
|
|
};
|
|
|
|
private static List<AlarmCommand> Route(ServerEventRig rig)
|
|
{
|
|
var routed = new List<AlarmCommand>();
|
|
rig.Nm.AlarmCommandRouter = cmd => { lock (routed) routed.Add(cmd); };
|
|
return routed;
|
|
}
|
|
|
|
private static void AssertNoRoles(ServerEventRig rig) =>
|
|
rig.Server.CurrentInstance.SessionManager.GetSessions()
|
|
.Select(s => s.EffectiveIdentity).OfType<RoleCarryingUserIdentity>()
|
|
.Single(i => i.ApiKeyId == ServerEventRig.KeyId)
|
|
.Roles.ShouldBeEmpty("the narrow grant alone must authorize — the session holds no server-wide role");
|
|
|
|
/// <summary>The <c>s=</c> id of one of a live condition's instance-scoped children.</summary>
|
|
private static string ChildId(ServerEventRig rig, string alarmId, Func<AlarmConditionState, NodeState> child) =>
|
|
child(rig.Nm.TryGetAlarmCondition(alarmId).ShouldNotBeNull()).NodeId.IdentifierAsString;
|
|
|
|
private static void Project(ServerEventRig rig, string alarmId, AlarmConditionSnapshot state) =>
|
|
rig.Sink.WriteAlarmCondition(alarmId, state, DateTime.UtcNow, AddressSpaceRealm.Uns);
|
|
|
|
private static NodeId Uns(ISession session, string id) => ServerEventRig.UnsNodeId(session, id);
|
|
|
|
private static NodeId RootNodeId(ISession session) =>
|
|
new(V3NodeIds.SharedRootFolderId, (ushort)session.NamespaceUris.GetIndex(V3NodeIds.RawNamespaceUri));
|
|
|
|
private static async Task<StatusCode> ReadAsync(ISession session, NodeId node, uint attribute, CancellationToken ct)
|
|
{
|
|
var response = await session.ReadAsync(null, 0, TimestampsToReturn.Neither, new ReadValueId[]
|
|
{
|
|
new() { NodeId = node, AttributeId = attribute },
|
|
}, ct);
|
|
return response.Results.ToList().ShouldHaveSingleItem().StatusCode;
|
|
}
|
|
|
|
private static async Task<(StatusCode Status, List<string> Ids)> BrowseAsync(
|
|
ISession session, NodeId parent, CancellationToken ct)
|
|
{
|
|
var response = await session.BrowseAsync(
|
|
requestHeader: null,
|
|
view: null,
|
|
requestedMaxReferencesPerNode: 0,
|
|
nodesToBrowse:
|
|
[
|
|
new BrowseDescription
|
|
{
|
|
NodeId = parent,
|
|
BrowseDirection = BrowseDirection.Forward,
|
|
ReferenceTypeId = ReferenceTypeIds.HierarchicalReferences,
|
|
IncludeSubtypes = true,
|
|
NodeClassMask = 0,
|
|
ResultMask = (uint)BrowseResultMask.All,
|
|
},
|
|
],
|
|
ct: ct);
|
|
|
|
var result = response.Results[0];
|
|
return (result.StatusCode, result.References.ToList().Select(r => r.NodeId.IdentifierAsString).ToList());
|
|
}
|
|
}
|