AIFACTORY-FEAT-099: SaaS libraries: tenancy filters for Orleans grains¶
Generated from the architecture model
This page is rendered from model/**/*.yaml by tools/docs_model during mkdocs build. Edit the YAML, not this page; hand-written design lives on the linked service, platform and plane pages.
A design artefact, not a tracker
This backlog is generated from model/backlog/ and validated against the architecture model. No work item exists in any tracker, and no item carries a date, an estimate or an assignee (ADR-0029).
Epic Ecosystem component extensions · Increment I0 Readiness · State elaborated · Route backend-developer · Phase before development · Build order 5 of 185 (Templates and libraries)
Before development
Template or library work: every task of this feature changes a template or a shared library the Factory builds on, and it lands before the Factory's own repositories of I0 are developed. The mark travels with every task (tag phase:before-development).
The SaaS extension libraries resolve the tenant from the trusted scope inside Orleans grains and apply tenant filters to grain persistence and messaging, as they already do for HTTP requests. Component: Extensions.Saas.* libraries (extend).
| Delivers | — |
| Stubs | — |
| Realizes | components: cmp-saas-extensions |
| Requirements | — |
| Depends on | — |
| Sources | model/components.yaml, docs/architecture/ecosystem-composition.md |
AIFACTORY-US-202: SaaS libraries: the tenant travels in the Orleans call context and a call to a tenant-scoped grain without it is refused¶
enabling · persona platform-admin
As a platform admin, I want the tenant of a request to follow every grain call inside the silo and between client and silo, so that a grain never runs on behalf of an unknown tenant and never has to trust a tenant passed as a method argument.
The SaaS libraries resolve the tenant of an HTTP request, of a gRPC call and of a MassTransit or NServiceBus message into a scoped ITenantContext. For Orleans the package ConnectSoft.Extensions.Saas.Orleans ships one helper, SaasGrainIdentityFormatter.FormatComposite, which joins a tenant id and an aggregate id into a grain key, and its Integration page warns that Orleans remoting does not set the tenant context inside the silo and that client and silo need their own resolution. The canonical tenancy decision that ADR-0015 inherits names the Orleans call context as a carrier of the tenant id and requires a fail-closed answer on conflicting evidence. This PBI adds the missing carrier. An outgoing grain call filter copies the tenant of the current context into the call context under the tenant key the libraries already use for gRPC and messaging metadata; an incoming grain call filter restores a mutable tenant context for the duration of the call. The default is fail closed, as decision D114 settles: every grain type is tenant-scoped unless it is marked as a host-level grain or its assembly is listed as host-level in the registration, which is how the grains of another library, such as the messaging adapter, are exempted, and no option admits a grain without a tenant in any other way. The default changes what a silo with the filters admits, so the package releases it as a new major version, and an existing consumer adds its exemptions, the marker on its own host-level grains and the assembly entries of the libraries it hosts, when it takes that version; a grain it did not exempt is refused and never admitted by a fallback. A call to a tenant-scoped grain that arrives without a tenant is refused before the grain method runs, with a typed error that names the grain type, and the refusal is counted. When the grain key was built with the composite formatter and its tenant part differs from the tenant of the call, the call is refused as well. The tenant is never read from a method argument. One registration on the silo builder and one on the client builder turn the filters on. The project, run and attempt identity of the Factory scope are not part of the SaaS libraries; the Factory service profile of the base template carries them. The test silo that exercises the filters lives in a testing project of the Orleans repository, published as the package ConnectSoft.Extensions.Saas.Orleans.Testing; the existing package ConnectSoft.Extensions.Saas.Testing, which holds FixedTenantContext and references only the abstractions package, gains nothing that references Orleans.
Acceptance criteria
| AC1 | Given a silo and a client that register the tenant filters of the package ConnectSoft.Extensions.Saas.Orleans, when a request of one tenant calls a grain that calls a second grain, then both grain methods observe the tenant of the request through ITenantContext, carried in the Orleans call context under the tenant key of the libraries, which is the carrier the tenancy decision inherited by ADR-0015 names. |
| AC2 | Given a call to a tenant-scoped grain that arrives without a tenant in the call context, when the incoming filter runs, then the call is refused before the grain method executes with a typed error naming the grain type and the refusal is counted; a grain marked as host-level, or one whose assembly the registration lists, accepts the call, every other grain is tenant-scoped and no option admits it without a tenant, and an existing consumer adds these exemptions when it takes the new major version of the package, as the migration note of the Integration page tells it (ADR-0011, ADR-0015 decision 2 takes the tenant from the authenticated context only). |
| AC3 | Given a grain whose key was built with SaasGrainIdentityFormatter.FormatComposite for one tenant, when a call that carries another tenant addresses it, then the call is refused as conflicting evidence and the grain state is not read; the tenant is never taken from a method argument, and a unit test covers both refusals (ADR-0015, ADR-0024 decision 1 makes grains the substrate these calls reach). |
| Traces: adrs | ADR-0011, ADR-0015, ADR-0024 |
| Sources | model/components.yaml, docs/architecture/ecosystem-composition.md, docs/architecture/adr/0015-factory-tenancy-under-canonical-adr-0100.md, docs/architecture/adr/0011-multi-tenant-isolation-strategy.md |
Tasks
| Task | Kind | Expected output | Repository |
|---|---|---|---|
AIFACTORY-TASK-164 Tenant context inside grains and grain storage |
implementation | The package ConnectSoft.Extensions.Saas.Orleans holds an outgoing grain call filter that writes the tenant of the current ITenantContext to the call context and an incoming filter that restores a mutable tenant context for the call; one extension on the silo builder and one on the client builder register them; a grain call without tenant context fails before the grain method runs. |
ConnectSoft.Extensions.Saas |
AIFACTORY-TASK-994 Host-level grain marker and the key consistency check |
implementation | The package ConnectSoft.Extensions.Saas.Orleans defines the marker of a host-level grain, accepts a list of host-level assemblies in the registration and treats every other grain as tenant-scoped; the incoming filter compares the tenant part of a composite grain key with the tenant of the call and refuses a difference with a typed error; refusals are counted on the meter of the package; the fail-closed default has no switch and is released as a new major version of the package, whose migration note tells an existing consumer to add the marker or the assembly entry for its host-level grains. |
ConnectSoft.Extensions.Saas |
AIFACTORY-TASK-995 Test silo with two tenants in a testing package of the Orleans repository |
fixture | A testing project in the solution of the Orleans repository, published as the package ConnectSoft.Extensions.Saas.Orleans.Testing and built with a project reference to the Orleans package, holds a test silo and client with the tenant filters registered and a helper that runs a block of calls as a given tenant, so that the tests of this feature and of consuming services exercise two tenants against the same grains; ConnectSoft.Extensions.Saas.Testing, which holds FixedTenantContext and references only the abstractions package, gains nothing that references Orleans. |
ConnectSoft.Extensions.Saas |
AIFACTORY-TASK-996 Verify the propagation and the two refusals on the test silo |
verification | Run dotnet test -c Release --no-build on the solution of the Orleans repository, whose tests use the test silo by project reference; the tests of the nested grain call, the call without tenant, the grain exempted by the marker, the grain exempted by an assembly entry and the conflicting grain key pass and prove AC1 to AC3 of AIFACTORY-US-202 (ADR-0015). |
ConnectSoft.Extensions.Saas |
AIFACTORY-US-203: SaaS libraries: grain state and the loads of a unit of work opened in a grain are filtered by the tenant of the call¶
enabling · persona platform-admin
As a platform admin, I want grain storage and the persistence a grain opens to apply the tenant of the call without code in each grain, so that state of one tenant is never visible to an activation that serves another.
The Integration page of ConnectSoft.Extensions.Saas.Orleans separates two problems: the grain key, which the composite formatter solves, and the database filter, which the package ConnectSoft.Extensions.Saas.NHibernate solves for a session when its tenant filter is enabled inside a scoped tenant boundary. It states that grain code which opens a unit of work uses the tenant context independently. The NHibernate package already has the registration AddConnectSoftSaasNHibernateTenantFilter, which registers a scoped unit of work that calls TryEnableSaasTenantFilter; what a grain call lacks is a tenant context for that unit of work to read. The tenancy decision that ADR-0015 inherits requires that a load from a shared database never bypasses a tenant predicate, and ADR-0024 decision 1 makes grains the place where attempt and workflow run state is persisted. This PBI adds the link on both paths. A grain storage decorator stamps the tenant of the call on the state it writes and checks the stamp on every read: state written for one tenant is not returned to a call of another, the read fails closed with a typed error, and nothing of the foreign state is logged. The grain path extends the existing registration: a unit of work opened inside a grain call takes the filter value from the tenant context the incoming grain call filter restored, without a call in the grain and without a second enabling mechanism, and opening one in a tenant-scoped grain without a tenant fails before a query is sent. Host-level grains write state without a stamp and never read stamped state. The decorator wraps any registered grain storage provider, so the choice of provider stays with the host.
Acceptance criteria
| AC1 | Given a tenant-scoped grain with the storage decorator registered, when it writes its state under one tenant and an activation called under another tenant reads the same storage key, then the read fails closed with a typed error and returns nothing of the foreign state, proven by a test with two tenants (ADR-0015, ADR-0024 decision 1). |
| AC2 | Given a grain call with a restored tenant context, when the grain opens a unit of work on a shared database, then the tenant filter of the package ConnectSoft.Extensions.Saas.NHibernate is enabled for that session through its existing registration AddConnectSoftSaasNHibernateTenantFilter, without code in the grain and without a second enabling mechanism, and a load returns only rows of the tenant of the call, which is the rule that a shared load never bypasses a tenant predicate (ADR-0011, ADR-0015). |
| AC3 | Given a tenant-scoped grain called without a tenant or a host-level grain, when persistence is used, then the first fails before a query is sent and the second writes state without a tenant stamp and cannot read stamped state; the decorator wraps whichever grain storage provider the host registered (ADR-0015 decision 2). |
| Traces: adrs | ADR-0011, ADR-0015, ADR-0024 |
| Depends on | AIFACTORY-US-202 |
| Sources | model/components.yaml, docs/architecture/adr/0015-factory-tenancy-under-canonical-adr-0100.md, docs/architecture/adr/0024-durable-execution-substrate.md |
Tasks
| Task | Kind | Expected output | Repository |
|---|---|---|---|
AIFACTORY-TASK-997 Tenant-stamping grain storage decorator |
implementation | The package ConnectSoft.Extensions.Saas.Orleans holds a grain storage decorator that stamps the tenant of the call on written state, checks the stamp on read and fails closed with a typed error on a difference; a registration extension wraps a named storage provider; host-level grains bypass the stamp. |
ConnectSoft.Extensions.Saas |
AIFACTORY-TASK-998 Tenant filter enabled for a unit of work opened inside a grain call |
implementation | The registration AddConnectSoftSaasNHibernateTenantFilter of the package ConnectSoft.Extensions.Saas.NHibernate is extended for the grain path: the scoped unit of work it registers takes the filter value, through the existing TryEnableSaasTenantFilter, from the tenant context the incoming grain call filter restored for the call, and no second enabling mechanism is added; opening a unit of work in a tenant-scoped grain without a tenant fails before a query is sent; the package gains no Orleans reference, because it reads the tenant context of the abstractions package. |
ConnectSoft.Extensions.Saas |
AIFACTORY-TASK-999 Two-tenant persistence fixture on the test silo |
fixture | A sample grain with stored state and a mapped entity runs on the test silo of AIFACTORY-TASK-995, on two paths. The storage decorator case lives in the test project of the Orleans repository against an in-memory storage provider. The grain plus unit-of-work case lives in the test project of the NHibernate repository, which references the published packages ConnectSoft.Extensions.Saas.Orleans and ConnectSoft.Extensions.Saas.Orleans.Testing and a test database. On both paths the fixture writes as one tenant and reads as another. |
ConnectSoft.Extensions.Saas |
AIFACTORY-TASK-1000 Verify that grain state and loads never cross tenants |
verification | Run dotnet test -c Release --no-build on the solution of the Orleans repository for the storage decorator and on the solution of the NHibernate repository for the unit of work opened in a grain; the two-tenant tests of both pass and prove AC1 to AC3 of AIFACTORY-US-203 (ADR-0015). |
ConnectSoft.Extensions.Saas |
AIFACTORY-US-204: SaaS libraries: the tenant is carried on messages of the Orleans messaging profile and restored before a handler runs¶
enabling · persona platform-admin
As a platform admin, I want a message published through the Orleans messaging profile to carry the tenant of its publisher and a handler to run under that tenant, so that the default messaging profile of Factory hosts is as tenant-safe as the broker profiles already are.
The SaaS libraries carry the tenant on messages of two transports: the MassTransit package has publish, send and consume filters and the NServiceBus package an incoming behaviour, both on the messaging header name of the abstractions package. Nothing exists for the Orleans messaging adapter, although ADR-0012 makes it a transport profile, Factory hosts use it by default, and docs/architecture/ecosystem-composition.md lists messaging propagation as missing for this component. The adapter stores the headers a publisher supplies on its outbox record and hands them to the consumer with the message context, so the tenant can travel there without a change of the adapter. This PBI adds the pair for the Orleans profile as a new package of the family, ConnectSoft.Extensions.Saas.Messaging.Orleans, beside ConnectSoft.Extensions.Saas.Messaging.MassTransit and ConnectSoft.Extensions.Saas.Messaging.NServiceBus, because the family keeps messaging propagation in one package per transport. The new package references ConnectSoft.Extensions.MessagingModel.Orleans and the abstractions package; ConnectSoft.Extensions.Saas.Orleans keeps referencing only the abstractions package and the Orleans SDK, so a silo that wants only the grain call filters takes no messaging reference. Whether the owner prefers one Orleans package instead is reported as an open question. On publish and send, the tenant of the current context is written to the tenant header of a message; publishing a tenant-scoped message without a tenant fails before the outbox record is written, so nothing is stored. On consume, the tenant header is restored into a mutable tenant context before the handler runs, together with the grain call filters of the earlier PBI. A tenant-scoped message that arrives without the header is not handled; it goes to the poison handling of the profile with the reason recorded. The header name and the marker of a tenant-scoped message are those of the abstractions package, so a message keeps its tenant when a host changes its profile. ADR-0012 decision 2 asks every profile to declare its tenant isolation with evidence from its own tests; the round trip test of this PBI is that evidence for the Orleans profile.
Acceptance criteria
| AC1 | Given a host on the Orleans messaging profile with the tenant propagation of the package ConnectSoft.Extensions.Saas.Messaging.Orleans registered, when a handler of one tenant publishes a message and the inbox dispatches it, then the outbox record carries the tenant header and the consuming handler observes the same tenant through ITenantContext, on the header name the MassTransit and NServiceBus packages use (ADR-0012 decision 2, ADR-0015). |
| AC2 | Given a tenant-scoped message, when it is published without a tenant in the current context, then publication fails before an outbox record is written; when such a message arrives without the tenant header, then no handler runs and the message goes to the poison handling of the profile with the reason recorded (ADR-0014 decision 1 makes the tenant a required field of a Factory message). |
| AC3 | Given messages of two tenants on the same queue, when they are dispatched in turn, then each handler runs under the tenant of its own message and the context of one is never visible to the other; the round trip test is recorded as the tenant isolation evidence ADR-0012 decision 2 requires of the profile (docs/architecture/ecosystem-composition.md). |
| Traces: adrs | ADR-0012, ADR-0014, ADR-0015 |
| Depends on | AIFACTORY-US-202 |
| Sources | model/components.yaml, docs/architecture/ecosystem-composition.md, docs/architecture/adr/0012-messaging-port-and-transport-profiles.md, docs/architecture/adr/0015-factory-tenancy-under-canonical-adr-0100.md |
Tasks
| Task | Kind | Expected output | Repository |
|---|---|---|---|
AIFACTORY-TASK-1001 Tenant header on publish and send through the Orleans messaging profile |
implementation | The new package ConnectSoft.Extensions.Saas.Messaging.Orleans, which references ConnectSoft.Extensions.MessagingModel.Orleans and ConnectSoft.Extensions.Saas.Abstractions, decorates publish and send of the messaging port so that the tenant of the current context is written to the tenant header of the message, on the header name and with the marker of a tenant-scoped message of the abstractions package; publishing a tenant-scoped message without a tenant fails before the outbox record is written; ConnectSoft.Extensions.Saas.Orleans gains no messaging reference. |
ConnectSoft.Extensions.Saas |
AIFACTORY-TASK-1002 Tenant restored on consume and a message without tenant refused |
implementation | The package ConnectSoft.Extensions.Saas.Messaging.Orleans restores a mutable tenant context from the tenant header of the message context before a handler runs; a tenant-scoped message without the header is not handled and is handed to the poison handling of the profile with the reason. |
ConnectSoft.Extensions.Saas |
AIFACTORY-TASK-1003 Outbox to inbox round trip fixture for two tenants |
fixture | A fixture in the test project of the package ConnectSoft.Extensions.Saas.Messaging.Orleans, on the test silo of the published package ConnectSoft.Extensions.Saas.Orleans.Testing, runs the Orleans messaging adapter with an outbox and an inbox, publishes messages of two tenants and a message without tenant, and records the tenant each handler observed. |
ConnectSoft.Extensions.Saas |
AIFACTORY-TASK-1004 Verify the tenant round trip on the Orleans messaging profile |
verification | Run dotnet test -c Release --no-build on the solution of the package ConnectSoft.Extensions.Saas.Messaging.Orleans; the round trip, the refused publication and the unhandled message tests pass and prove AC1 to AC3 of AIFACTORY-US-204 (ADR-0012, ADR-0015). |
ConnectSoft.Extensions.Saas |
AIFACTORY-US-205: SaaS libraries: the Orleans, Orleans testing, NHibernate and Orleans messaging packages are published to the ConnectSoft feed in dependency order with the versions the consumers pin¶
evidence · persona platform-admin
As a platform admin, I want proof that the SaaS packages with the grain tenancy filters are on the ConnectSoft feed with versions a consumer can pin, so that a Factory service restores tenant isolation for grains instead of writing it.
This PBI is the publication proof of the feature. Four packages are published. ConnectSoft.Extensions.Saas.Orleans gains the call filters and the storage decorator and publishes under a new major version, because every grain is tenant-scoped by default (decision D114), and its solution publishes the new testing package ConnectSoft.Extensions.Saas.Orleans.Testing with the test silo. ConnectSoft.Extensions.Saas.NHibernate takes its filter value from the tenant context of a grain call. The new package ConnectSoft.Extensions.Saas.Messaging.Orleans carries the messaging propagation. ConnectSoft.Extensions.Saas.Abstractions is consumed as it is on the feed and ConnectSoft.Extensions.Saas.Testing is not changed. Each repository has its own pipeline, which builds, tests, packs and pushes to the ConnectSoft feed, the Azure Artifacts feed the ConnectSoft libraries already publish to, which decision D114 makes the Factory feed; a publication stage runs only when the tests pass and refuses a version that is already on the feed. The order is stated, so that no test needs a package that is not yet built: the abstractions package, then the Orleans package with its testing package from one solution, then the NHibernate package, whose grain test restores the two Orleans packages from the feed, then the Orleans messaging package. A probe proves the result from the side of a consumer: a clean silo host that has the ConnectSoft feed as its only source restores the published versions, registers the filters with one call on the silo builder and the messaging propagation with one call, and a test with two tenants shows that a grain call without tenant is refused, that state of one tenant is not visible to the other and that a message is handled under the tenant of its publisher. The Integration page of the Orleans package is rewritten: its warning that the tenant does not flow into the silo is replaced by the registration and the refusal rules, with a migration note that tells an existing consumer which exemptions to add when it takes the new major version, and the Features page lists the new types. The published versions are recorded in the Runbook pages, where the base template and the Factory services read their pins.
Acceptance criteria
| AC1 | Given the pipelines of the Orleans, the NHibernate and the Orleans messaging repositories, when they run after the work of the feature, then the packages are built, tested, packed and pushed to the ConnectSoft feed in the stated order (the abstractions package as published, the Orleans package under a new major version with its testing package, the NHibernate package, the Orleans messaging package), a publication stage runs only after the tests pass and refuses a version that is already on the feed, and the published versions are recorded in the Runbook pages (ADR-0028, model/backlog/epics.yaml). |
| AC2 | Given a clean probe silo with the ConnectSoft feed as its only package source, when it restores the published versions and registers the tenant filters and the messaging propagation, then a grain call without tenant is refused, a test with two tenants proves that grain state of one tenant is never visible to another, and a message published by one tenant is handled under that tenant, which is the isolation ADR-0015 requires of every backend. |
| AC3 | Given the pages of the Orleans package, when a maintainer of a consuming service reads them, then the Integration page describes the registration, the host-level marker and the refusal rules in place of the earlier warning, its migration note lists the exemptions an existing consumer adds when it takes the new major version, and the Features page lists the new types, which closes the gap docs/architecture/ecosystem-composition.md records for the component (ADR-0015). |
| Traces: adrs | ADR-0015, ADR-0028 |
| Depends on | AIFACTORY-US-202, AIFACTORY-US-203, AIFACTORY-US-204 |
| Sources | model/components.yaml, model/backlog/epics.yaml, docs/architecture/ecosystem-composition.md, docs/architecture/catalogs/libraries.md |
Tasks
| Task | Kind | Expected output | Repository |
|---|---|---|---|
AIFACTORY-TASK-1005 Publication order and version guard in the pipelines of the SaaS packages |
operations | The pipelines of the Orleans, the NHibernate and the Orleans messaging repositories publish to the ConnectSoft feed after the tests of each solution pass, in the order Orleans together with ConnectSoft.Extensions.Saas.Orleans.Testing from the same solution, then NHibernate, then ConnectSoft.Extensions.Saas.Messaging.Orleans, each restoring its upstream packages from the feed; the Orleans package publishes under a new major version because of the fail-closed default; the new messaging repository gets its pipeline from the definition in the repository; a version already on the feed is refused with the reason; the published versions are written to the Runbook pages. |
ConnectSoft.Extensions.Saas |
AIFACTORY-TASK-1006 Integration and Features pages of the Orleans package rewritten |
documentation | The Integration page of the Orleans package describes the silo and client registration, the host-level marker, the storage decorator, the testing package and the refusal rules in place of the warning that the tenant does not flow into the silo, with a migration note on the exemptions an existing consumer adds for the new major version, and its Features page lists the new types; the pages of the package ConnectSoft.Extensions.Saas.Messaging.Orleans describe the registration of the messaging propagation and its two refusals. |
ConnectSoft.Extensions.Saas |
AIFACTORY-TASK-1007 Feed probe silo for the published packages |
fixture | A probe silo host with the ConnectSoft feed as its only source restores the published versions, registers the filters and the messaging propagation with one call each and runs the two-tenant test of grain calls, grain state and a published message; the probe runs as the last stage of the pipeline of the Orleans messaging package, the last package in the order. | ConnectSoft.Extensions.Saas |
AIFACTORY-TASK-1008 Verify the published packages by the probe silo |
verification | One run of the three pipelines in their order publishes the four packages and the probe silo passes its two-tenant test; a rerun with the same version is refused; the runs prove AC1 to AC3 of AIFACTORY-US-205 (ADR-0015, ADR-0028). | ConnectSoft.Extensions.Saas |
AIFACTORY-US-099: SaaS libraries: tenancy filters for Orleans grains is delivered and proven by its consumers¶
enabling · persona platform-admin
As a platform admin, I want Extensions.Saas.* libraries to carry tenancy filters for Orleans grains, so that it serves tenant resolution per ADR-0100 without later rework.
This is the integration PBI of the feature. A platform admin takes the SaaS libraries from a grain key helper to published packages in which the tenant of a request follows every grain call, grain state and the loads of a unit of work opened in a grain are filtered by that tenant, and a message of the Orleans messaging profile carries the tenant and is handled under it. The implementation lives in the earlier PBIs of this file; this PBI proves them together on one silo. A request of one tenant calls a grain that stores state, publishes a message and is handled by a second grain; the same flow runs for a second tenant; a call, a read and a message without tenant are each refused. The feature is done when no grain of a host built on the published versions runs for an unknown tenant and no state crosses tenants, as the tenancy decisions inherited by ADR-0015 require for grains in the same way as for HTTP requests. Repository of the feature: the SaaS library repositories. The services that reach these libraries in a later increment are the control plane API, the agent runtime worker and the data and event foundations.
Acceptance criteria
| AC1 | Given the library repositories of the feature, when their pipelines run, then each package builds, its tests pass and it publishes to the ConnectSoft feed with a verified version that the consuming repositories pin (ADR-0028, model/components.yaml). |
| AC2 | Given the work of AIFACTORY-TASK-164 (tenant context inside grains and grain storage) is done, then a grain call without tenant context fails and grain state of one tenant is never visible to another, proven by a test with two tenants (ADR-0015, ADR-0024 decision 1). |
| AC3 | Given a silo built on the published versions, when one flow of grain call, stored state, published message and handling grain runs for two tenants in turn, then every step of each flow observes its own tenant only, and a call, a read and a message without tenant are each refused with the reason recorded (ADR-0012 decision 2, ADR-0015 decision 2). |
| Traces: adrs | ADR-0012, ADR-0015, ADR-0024, ADR-0028 |
| Depends on | AIFACTORY-US-202, AIFACTORY-US-203, AIFACTORY-US-204, AIFACTORY-US-205 |
| Sources | model/components.yaml, docs/architecture/ecosystem-composition.md, docs/architecture/adr/0015-factory-tenancy-under-canonical-adr-0100.md |
Tasks
| Task | Kind | Expected output | Repository |
|---|---|---|---|
AIFACTORY-TASK-1009 End-to-end flow of two tenants on one silo against the published packages |
verification | A consumer test project restores the published packages from the ConnectSoft feed and runs the flow of grain call, stored state, published message and handling grain for two tenants in turn, then the three refusals without tenant; the run proves AC2 and AC3 of AIFACTORY-US-099 (ADR-0015). | ConnectSoft.Extensions.Saas |
AIFACTORY-TASK-688 Verify saas-extensions-delivered by running the declared command |
verification | Run dotnet build -c Release and dotnet test -c Release --no-build on the solutions of the Orleans, the NHibernate and the Orleans messaging repositories; they pass and prove AC1 to AC3 of AIFACTORY-US-099. |
ConnectSoft.Extensions.Saas |