textual-notation-of-model/packages/features/middleware/middleware_physical_software_realization.sysml

Source

1/*2 * DE4SDV middleware physical/software realization model slice.3 *4 * INC-MW-008 maps the middleware logical responsibilities to a concrete5 * candidate software/platform boundary: the Autoware-to-AAOS SDV adapter and6 * the AAOS SDV boundary model. This is a model of the integration boundary,7 * not a vendored AAOS implementation. A bounded Vehicle.Speed8 * AAOS/Cuttlefish-to-ROS 2 campaign path is represented separately below as9 * System 2 evidence transport; it is not production middleware runtime10 * deployment or native SDV transport interoperability evidence.11 *12 * The adapter and AAOS boundary remain candidate realizations. The selected13 * Autoware ROS 2 topic and AOSP SDV gateway/middleware source artifacts are14 * pinned. The vehicle-velocity VSIDL service bundle remains a DE4SDV reference15 * contract, while production process deployment and executable behavior remain16 * deferred until their target-owned source contracts are pinned.17 */1819package DE4SDV_MiddlewarePhysicalSoftwareRealization {20  private import DE4SDV_MethodContext::*;21  private import DE4SDV_MethodProcess::*;22  private import DE4SDV_ProductLine::*;23  private import DE4SDV_Stakeholders::*;24  private import DE4SDV_ExecutionEnvironments::*;25  private import DE4SDV_MiddlewareLogicalArchitecture::*;26  private import DE4SDV_SDVPlatformStack::*;27  private import DE4SDV_AAOSSDVMiddlewareBoundary::*;28  private import DE4SDV_AEBSPhysicalSoftwareRealization::*;29  private import DE4SDV_ROS2Types::*;30  private import COVESA_VSS::**;31  private import SAF_Viewpoints::*;32  private import SysideViews::**;33  private import Views::*;3435  part incMW008 : FeatureIncrement {36    doc /* INC-MW-008: middleware integration physical/software realization. */37  }3839  part physicalSourceContractGap : DeferredProductLineScope {40    doc /*41     * GAP-MW-019: The Autoware ROS 2 topic and AOSP SDV transport sources are42     * pinned, and the selected vehicle-velocity VSIDL/service-bundle schema43     * (de4sdv.reference.vehicle_speed) with its generated client binding is44     * now exercised at runtime (E-MW-012). The generated binding remains a45     * staging artifact (stage_aosp_bridge.sh), not a committed production46     * contract; the production adapter-chain binding decision remains open.47     */48  }4950  part physicalProcessDeploymentGap : DeferredProductLineScope {51    doc /*52     * GAP-MW-020: No System 1 production adapter process, executor, runtime,53     * VM, or network deployment is selected. The bounded Vehicle.Speed54     * campaign deployment below is System 2 evidence infrastructure and must55     * not be read as the production deployment decision.56     */57  }5859  part physicalServiceSatisfactionGap : DeferredProductLineScope {60    doc /* GAP-MW-021: The candidate AAOS SDV boundary has not been shown to satisfy the logical service responsibilities or requirements. */61  }6263  part physicalEnablingSystemGap : DeferredProductLineScope {64    doc /*65     * GAP-MW-023: The bounded campaign exercised one AAOS/Cuttlefish host and66     * one ROS 2 host, but no reusable or selected System 2 capability envelope67     * is baselined for future campaigns. The observed campaign hosts do not68     * establish a System 1 product deployment.69     */70  }7172  part velocitySignalContractGap : DeferredProductLineScope {73    doc /*74     * GAP-MW-022: The pinned public AOSP SDV tree provides gateway,75     * service-discovery, data-tunnel, RPC-agent, and transport interfaces,76     * but the selected production vehicle-velocity VSIDL service bundle,77     * FQIN, payload contract, or generated client binding were not78     * established. The DE4SDV reference payload and VSIDL catalog remain79     * candidate-only. The campaign path now exercises the reference80     * provider/observer bundles end-to-end (E-MW-012) through the dedicated81     * observer domain; the production deployment decision remains open.82     */83  }8485  part def AAOSSDVSourceArtifact {86    doc /*87     * Source ID: AOSP-AAOS-SDV-MANIFEST.88     * Pinned AOSP source manifest and build target for the AAOS SDV build.89     * Detailed repository, revision, branch, and path provenance is maintained90     * in the INC-MW-008 pilot source_alignment record.91     */92  }9394  part def COVESAVehicleSpeedSemanticSource {95    doc /*96     * Source ID: COVESA-VSS-VEHICLE-SPEED.97     * Source-backed semantic definition for VSS Vehicle.Speed. This is the98     * canonical vehicle-speed meaning used between the AAOS contract and the99     * Autoware ROS 2 representation; it is not an AAOS VSIDL service contract.100     * VSS path: Vehicle.Speed; quantity: speed; unit: km/h.101     * The canonical field/unit transformation is recorded by mapping102     * VSS-SIM-AEBS-001 in103     * methodologies/sysmod-sysmlv2/pilots/aebs-simulation-deployment/104     * vss-simulation-realization.yaml; this increment traces that mapping105     * rather than redefining it.106     */107  }108109  part def DE4SDVVSSVehicleSpeedAdapterSource {110    doc /*111     * Source ID: DE4SDV-VSS-VEHICLE-SPEED-ADAPTER.112     * Source-backed DE4SDV provider-neutral adapter implementation.113     * This implementation normalizes VSS Vehicle.Speed [km/h] to a114     * provider-neutral longitudinal velocity [m/s]. It does not claim AAOS,115     * VSIDL, ROS 2, transport, deployment, or runtime interoperability.116     */117  }118119  part def DE4SDVAAOSSDVReferenceInteropBenchSource {120    doc /*121     * Source ID: DE4SDV-AAOS-SDV-REFERENCE-INTEROP-BENCH.122     * Source-backed DE4SDV-owned reference contract and executable rehearsal.123     * The reference protobuf message is `VehicleSpeed` with the semantic124     * field `speed_kmh`; the companion VSIDL catalog identifies the125     * `VehicleSpeedProvider` publisher, `VehicleSpeed` message, and126     * `VEHICLE_SPEED` channel. These artifacts define a reference contract127     * candidate, not a selected OEM or production AAOS service.128     * The bounded campaign proves the reference provider/observer path,129     * structured logcat extraction, host-side forwarding, private TCP transfer,130     * ROS 2 publication, and independent observation for one target execution.131     * It remains a development-campaign transport slice, not an OEM contract,132     * production deployment, or native SDV transport result.133     */134  }135136  item def DE4SDVReferenceVehicleSpeedPayload {137    doc /*138     * Candidate semantic payload slice for the DE4SDV-owned reference139     * contract. `speed_kmh` is the explicit identity mapping from COVESA VSS140     * `Vehicle.Speed` [km/h]. The reference protobuf also carries timestamp141     * and quality fields; their semantics remain outside this signal slice142     * until they are separately mapped.143     */144    attribute speed_kmh : Vehicle_Speed;145  }146147  port def DE4SDVReferenceVehicleSpeedAccessPort :> VehicleSignalAccessPort {148    doc /*149     * Candidate typed AAOS-side access port for the reference vehicle-speed150     * slice. The type binds the current signal boundary to the reference151     * payload without selecting a production VSIDL service, generated152     * binding, deployment, or runtime transport.153     */154    inout item vehicleSpeed : DE4SDVReferenceVehicleSpeedPayload redefines vehicleSignals;155  }156157  part def AAOSVSIDLProviderAgentSource {158    doc /*159     * Source ID: AOSP-AAOS-SDV-VSIDL.160     * VSIDL provider agent from161     * system/software_defined_vehicle/vsidl/provider/agent/sdv. The pinned162     * implementation exposes metadata RPCs including diagnostics declaration,163     * message descriptor, publication descriptor, and RPC method descriptor.164     */165  }166167  part def AAOSMiddlewareSource {168    doc /*169     * Source ID: AOSP-AAOS-SDV-MIDDLEWARE.170     * Source-backed AAOS SDV middleware communication implementation from171     * system/software_defined_vehicle/middleware.172     * The pinned source provides the middleware communication boundary.173     */174  }175176  part def AAOSHardwareSDVInterfacesSource {177    doc /*178     * Source ID: AOSP-AAOS-SDV-INTERFACES.179     * Source-backed hardware/sdv interface definitions for middleware,180     * lifecycle, service discovery, RPC, and data-tunnel boundaries.181     */182  }183184  part def AAOSSDVGatewaySessionSource {185    doc /*186     * Source ID: AOSP-AAOS-SDV-INTERFACES.187     * Source-backed AAOS SDV gateway session interface. It exposes188     * serviceDiscoveryAgent(), dataTunnelAgent(), createPublication(), and189     * findRpcServerByName().190     */191  }192193  part def AAOSSDVDataTunnelPublicationSource {194    doc /*195     * Source ID: AOSP-AAOS-SDV-INTERFACES.196     * Source-backed AAOS SDV data-tunnel publication interface. It exposes197     * publication ownership and publisher metadata at the gateway boundary.198     */199  }200201  part def AAOSSDVRpcAgentSource {202    doc /*203     * Source ID: AOSP-AAOS-SDV-MIDDLEWARE.204     * Source-backed AAOS SDV RPC-agent implementation. It registers RPC205     * servers and transport metadata with the SDV middleware.206     */207  }208209  part def AAOSLifecycleServiceSource {210    doc /*211     * Source ID: AOSP-AAOS-SDV-LIFECYCLE.212     * Source-backed lifecycle-management project at213     * system/software_defined_vehicle/lifecycle_management.214     */215  }216217  part def AAOSHealthMonitorSource {218    doc /*219     * Source ID: AOSP-AAOS-SDV-HEALTH.220     * Source-backed health-monitor project at221     * system/software_defined_vehicle/health_monitor.222     */223  }224225  part def AAOSDiagnosticsSource {226    doc /*227     * Source ID: AOSP-AAOS-SDV-DIAGNOSTICS.228     * Source-backed automotive diagnostics project at229     * system/software_defined_vehicle/automotive_services, relevant source230     * area: diagnostics.231     */232  }233234  part def SignalAccessClient {235    doc /* Candidate generic physical/software client for vehicle signal access through the selected adapter and platform boundary. Concrete signal slices specialize the adapter endpoint and retain their own mapping records. */236    port vehicleSignal : VehicleSignalAccessPort;237  }238239  part def DiagnosticAccessClient {240    doc /* Candidate physical/software client for diagnostic access through the selected adapter and platform boundary. */241    port diagnostics : DiagnosticAccessPort;242  }243244  part def LifecycleClient {245    doc /* Candidate physical/software client for lifecycle coordination. */246    port lifecycle : LifecycleCoordinationPort;247  }248249  part def HealthClient {250    doc /* Candidate physical/software client for health status observation and forwarding. */251    port health : HealthStatusPort;252  }253254  part def UpdateClient {255    doc /* Candidate physical/software client for update coordination. */256    port update : UpdateCoordinationPort;257  }258259  part def ServiceDiscoveryClient {260    doc /* Candidate physical/software client for service discovery and authorization boundary handling. */261    port discovery : ServiceDiscoveryPort;262  }263264  port def VelocityReportPublication :> ROS2TopicPublication {265    out item velocityReport : VelocityReportMessage redefines payload;266  }267268  part def AutowareToAAOSSDVAdapterPhysical :> AutowareToAAOSSDVAdapter {269    doc /*270     * Physical adapter candidate with explicit application-side logical ports271     * and AAOS SDV-side service ports. The port contracts are integration272     * boundaries; concrete production ROS 2 topic and VSIDL schemas remain273     * controlled by GAP-MW-019 and GAP-MW-022 until reviewed source revisions274     * are pinned. The typed vehicle-speed port below is a DE4SDV reference275     * contract candidate, not that production binding.276     */277    port applicationSignal : SignalAccessApplicationPort;278    port applicationDiagnostics : DiagnosticApplicationPort;279    port applicationLifecycle : LifecycleApplicationPort;280    port applicationHealth : HealthApplicationPort;281    port applicationUpdate : UpdateApplicationPort;282    port applicationDiscovery : ServiceBindingApplicationPort;283284    port aaosSignal : DE4SDVReferenceVehicleSpeedAccessPort;285    port aaosDiagnostics : DiagnosticAccessPort;286    port aaosLifecycle : LifecycleCoordinationPort;287    port aaosHealth : HealthStatusPort;288    port aaosUpdate : UpdateCoordinationPort;289    port aaosDiscovery : ServiceDiscoveryPort;290291    port ros2VelocityOut : VelocityReportPublication {292      doc /* Adapter publication to Autoware topic /vehicle/status/velocity_status. */293    }294    port ros2AutowareStateIn : AutowareStateSubscription {295      doc /* Existing Autoware topic /autoware/state. */296    }297    port ros2DiagnosticsOut : DiagnosticPublication {298      doc /* Existing Autoware diagnostic publication /diagnostics. */299    }300  }301302  part def AutowareRos2TopicBoundary {303    doc /*304     * Autoware-facing ROS 2 topic boundary for the reference middleware305     * integration slice. Only the velocity-report edge is wired in this306     * increment; the remaining Autoware edges (state, diagnostics) stay307     * candidates owned by GAP-MW-019 and GAP-MW-022 until their contracts308     * are pinned.309     */310    port velocityReportIn : VelocityReportSubscription;311  }312313  part def MiddlewarePhysicalSoftwareBoundary {314    doc /*315     * Candidate physical/software integration boundary for an Autoware-to-AAOS316     * SDV configuration. The AAOS model is a boundary reference; no internal317     * implementation, deployment, or runtime claim is made.318     *319     * The wired velocity path reflects the exercised reference rehearsal:320     * AAOS SDV VSIDL service access -> adapter -> Autoware-facing ROS 2321     * velocity-report boundary. Production VSIDL service, FQIN, payload322     * contract, and generated binding remain candidates (GAP-MW-019,323     * GAP-MW-022); the ROS 2 publication boundary is exercised as a324     * VelocityReport-shaped record, not as live ROS 2 runtime evidence.325     */326    part adapter : AutowareToAAOSSDVAdapterPhysical;327    part aaosSdvBoundary : SDVCoreBoundary;328    part autowareRos2Boundary : AutowareRos2TopicBoundary;329    part signalAccessClient : SignalAccessClient;330    part diagnosticAccessClient : DiagnosticAccessClient;331    part lifecycleClient : LifecycleClient;332    part healthClient : HealthClient;333    part updateClient : UpdateClient;334    part serviceDiscoveryClient : ServiceDiscoveryClient;335336    connection aaosVehicleSpeedToAdapter337      connect aaosSdvBoundary.vehicleSignalAccessOut to adapter.aaosSignal;338    connection adapterToAutowareVelocityReport339      connect adapter.ros2VelocityOut to autowareRos2Boundary.velocityReportIn;340341    doc /*342     * AAOS SDV VSIDL service access -> adapter vehicle-speed input. The343     * reference rehearsal exercises this edge through the provider stand-in344     * and the provider-neutral VssVehicleSpeedAdapter; the VSIDL schema and345     * generated client contract are not pinned (GAP-MW-019, GAP-MW-022).346     */347    flow aaosVehicleSpeedToAdapterPayload348      from aaosSdvBoundary.vehicleSignalAccessOut.vehicleSignals349      to adapter.aaosSignal.vehicleSpeed;350351    doc /*352     * Adapter VelocityReport publication -> Autoware-facing ROS 2 topic353     * boundary (/vehicle/status/velocity_status). The rehearsal exercises354     * this edge as a VelocityReport-shaped record; live ROS 2 runtime355     * publication is not claimed by this increment.356     */357    flow adapterToAutowareVelocityReportPayload358      from adapter.ros2VelocityOut.velocityReport359      to autowareRos2Boundary.velocityReportIn.velocityReport;360  }361362  part def MiddlewarePhysicalSoftwareSourceSet {363    doc /*364     * System 2 source and evidence references used to justify the candidate365     * realization. These records are not physical/software components of the366     * System 1 boundary and therefore remain outside its decomposition.367     */368    ref part aaosSourceArtifact : AAOSSDVSourceArtifact;369    ref part vssVehicleSpeedSource : COVESAVehicleSpeedSemanticSource;370    ref part de4sdvVehicleSpeedAdapterSource : DE4SDVVSSVehicleSpeedAdapterSource;371    ref part referenceInteropBenchSource : DE4SDVAAOSSDVReferenceInteropBenchSource;372    ref part vsidlProviderSource : AAOSVSIDLProviderAgentSource;373    ref part middlewareSource : AAOSMiddlewareSource;374    ref part hardwareInterfacesSource : AAOSHardwareSDVInterfacesSource;375    ref part gatewaySessionSource : AAOSSDVGatewaySessionSource;376    ref part dataTunnelPublicationSource : AAOSSDVDataTunnelPublicationSource;377    ref part rpcAgentSource : AAOSSDVRpcAgentSource;378    ref part lifecycleServiceSource : AAOSLifecycleServiceSource;379    ref part healthMonitorSource : AAOSHealthMonitorSource;380    ref part diagnosticsSource : AAOSDiagnosticsSource;381  }382383  part physicalSoftware : MiddlewarePhysicalSoftwareBoundary;384  part physicalSoftwareSources : MiddlewarePhysicalSoftwareSourceSet;385386  part aaosBuildRuntimeEnvironmentCandidate : AOSPAAOSBuildRuntimeEnvironment {387    doc /*388     * System 2 enabling-system candidate for the AAOS source/build and389     * Cuttlefish attempt. The bounded campaign used an exercised instance of390     * this capability shape, but provider, region, quota, disk, KVM, and access391     * are not a reusable product or production-deployment selection.392     */393  }394395  dependency aaosBuildRuntimeEnablingSystemTrace396    from aaosBuildRuntimeEnvironmentCandidate397    to DE4SDV_ExecutionEnvironments::EngineeringComputeNode;398399  /*400   * Bounded Vehicle.Speed campaign communication/deployment slice.401   *402   * This is deliberately separate from physicalSoftware: the two VM domains,403   * host-side forwarder, and private TCP boundary are System 2 evidence404   * infrastructure. The AAOS service bundle emits a structured logcat record;405   * it does not own the network socket in the accepted path because the active406   * guest SELinux policy restricts that service domain. The host-side forwarder407   * owns the private TCP connection instead.408   */409  enum def VehicleSpeedCampaignQuality {410    QUALITY_UNSPECIFIED;411    VALID;412    STALE;413    INVALID;414  }415416  item def VehicleSpeedProviderMessage :> DE4SDVReferenceVehicleSpeedPayload {417    doc /*418     * Reference protobuf/VSIDL message published by the generated AAOS419     * Vehicle.Speed provider and consumed by the generated observer.420     * The bounded bridge accepts the VALID quality value for publication;421     * STALE and INVALID remain contract values rejected before publication.422     */423    attribute timestamp_ns : ScalarValues::Integer;424    attribute quality : VehicleSpeedCampaignQuality;425  }426427  port def VehicleSpeedProviderPublication {428    out item vehicleSpeed : VehicleSpeedProviderMessage;429  }430431  port def VehicleSpeedProviderSubscription {432    in item vehicleSpeed : VehicleSpeedProviderMessage;433  }434435  item def VehicleSpeedCampaignWireEnvelope :> VehicleSpeedProviderMessage {436    doc /*437     * Typed campaign envelope emitted by the AAOS observer. The JSON/logcat438     * transport adds `schema` and `clock_domain` to the provider message. The439     * executable JSON/protobuf/VSIDL contracts remain authoritative for exact440     * serialization and validation. The source timestamp remains available in441     * the envelope and bridge logs; the current VelocityReport evidence proves442     * velocity transfer, not source-timestamp propagation through ROS.443     */444    attribute schema : ScalarValues::String;445    attribute clock_domain : ScalarValues::String;446  }447448  port def VehicleSpeedCampaignWirePublication {449    out item envelope : VehicleSpeedCampaignWireEnvelope;450  }451452  port def VehicleSpeedCampaignWireSubscription {453    in item envelope : VehicleSpeedCampaignWireEnvelope;454  }455456  part def AAOSVehicleSpeedProvider {457    doc /*458     * Generated AAOS Vehicle.Speed provider. The provider publishes the459     * reference message through the service-bundle discovery boundary.460     */461    port vehicleSpeedOut : VehicleSpeedProviderPublication;462  }463464  part def AAOSVehicleSpeedObserver {465    doc /*466     * Generated independent AAOS Vehicle.Speed observer. It receives the467     * provider message and emits the structured campaign envelope through468     * logcat.469     */470    port vehicleSpeedIn : VehicleSpeedProviderSubscription;471    port structuredLogcatOut : VehicleSpeedCampaignWirePublication;472  }473474  part def AAOSVehicleSpeedServiceBundle {475    doc /*476     * AAOS Cuttlefish guest-side provider/observer boundary. The service bundle477     * does not claim direct network-socket ownership.478     */479    part provider : AAOSVehicleSpeedProvider;480    part observer : AAOSVehicleSpeedObserver;481    port structuredLogcatOut : VehicleSpeedCampaignWirePublication;482483    connection providerToObserver484      connect provider.vehicleSpeedOut to observer.vehicleSpeedIn;485    flow providerToObserverPayload from provider.vehicleSpeedOut.vehicleSpeed486      to observer.vehicleSpeedIn.vehicleSpeed;487    bind structuredLogcatOut = observer.structuredLogcatOut;488  }489490  part def AAOSHostLogcatForwarder {491    doc /*492     * VM-A host-side ADB/logcat extractor and forwarder. It reads the guest's493     * structured record and opens the private TCP connection to the ROS 2 host.494     */495    port structuredLogcatIn : VehicleSpeedCampaignWireSubscription;496    port privateTcpOut : VehicleSpeedCampaignWirePublication;497  }498499  part def VehicleSpeedPrivateTcpTransport {500    doc /*501     * Private TCP boundary between independent campaign VM domains. This is502     * development/evidence transport only; it is not native SDV transport or503     * a production vehicle-network decision.504     */505    port vmAIn : VehicleSpeedCampaignWireSubscription;506    port vmBOut : VehicleSpeedCampaignWirePublication;507  }508509  part def ROS2VehicleSpeedTcpIngress {510    doc /*511     * VM-B ingress validates the campaign envelope, applies speed_kmh / 3.6,512     * and publishes the official autoware_vehicle_msgs/msg/VelocityReport513     * boundary on /vehicle/status/velocity_status. The conversion is a role-level514     * implementation claim; this deployment view is not a complete internal515     * behavior model of the executable bridge.516     */517    port privateTcpIn : VehicleSpeedCampaignWireSubscription;518    port velocityReportOut : VelocityReportPublication;519  }520521  part def ROS2VelocityReportIndependentObserver {522    doc /*523     * Independent VM-B observer of the published VelocityReport. Its524     * observation is separate from the ingress node's conversion and state. It525     * validates the published velocity and records local receipt time; it does526     * not validate source-timestamp propagation.527     */528    port velocityReportIn : VelocityReportSubscription;529  }530531  part def AutowareVehicleVelocityConsumer {532    doc /*533     * Real Autoware-side consumer of the published VelocityReport on534     * /vehicle/status/velocity_status. This is the product-path consumption535     * leg: an Autoware node (Autoware vehicle-interface or equivalent) that536     * subscribes to the topic and processes the velocity into its own state537     * and logs, providing Autoware-side provenance (GAP-MW-027 scope).538     *539     * This part is realized by the Autoware runtime on VM-B; it is distinct540     * from the independent observer, which exists only for evidence.541     */542    port velocityReportIn : VelocityReportSubscription;543  }544545  part def AAOSVehicleSpeedCampaignHostVm :> AOSPAAOSBuildRuntimeEnvironment {546    doc /*547     * VM-A/System-2 campaign host containing the nested AAOS/Cuttlefish guest548     * and the host-side ADB/logcat forwarder.549     */550    part cuttlefishGuest : AAOSVehicleSpeedServiceBundle;551    part hostForwarder : AAOSHostLogcatForwarder;552  }553554  part def ROS2VehicleSpeedCampaignHostVm :> EngineeringExecutionEnvironment {555    doc /*556     * VM-B/System-2 campaign host containing the ROS 2 ingress, independent557     * observer, and the real Autoware vehicle-velocity consumer. It is not a558     * System 1 vehicle compute target.559     */560    part ros2Ingress : ROS2VehicleSpeedTcpIngress;561    part independentObserver : ROS2VelocityReportIndependentObserver;562    part autowareConsumer : AutowareVehicleVelocityConsumer;563  }564565  part def VehicleSpeedCampaignCommunicationDeployment {566    doc /*567     * Bounded cross-domain communication path exercised by the reference568     * campaign: AAOS guest -> structured logcat -> VM-A host forwarder ->569     * private TCP -> VM-B ROS 2 ingress -> VelocityReport -> independent570     * observer and real Autoware vehicle-velocity consumer. The deployment is571     * evidence infrastructure, not a production SDV deployment or a direct572     * AAOS-service-to-ROS socket claim. The flows establish typed boundary573     * topology; executable forwarding and conversion semantics remain owned by574     * the implementation and evidence artifacts.575     */576    part vmA : AAOSVehicleSpeedCampaignHostVm;577    part vmB : ROS2VehicleSpeedCampaignHostVm;578    part privateTcpBoundary : VehicleSpeedPrivateTcpTransport;579580    connection guestToHostForwarder581      connect vmA.cuttlefishGuest.structuredLogcatOut582      to vmA.hostForwarder.structuredLogcatIn;583    connection hostForwarderToPrivateTcp584      connect vmA.hostForwarder.privateTcpOut to privateTcpBoundary.vmAIn;585    connection privateTcpToRos2Ingress586      connect privateTcpBoundary.vmBOut to vmB.ros2Ingress.privateTcpIn;587    connection ros2IngressToObserver588      connect vmB.ros2Ingress.velocityReportOut589      to vmB.independentObserver.velocityReportIn;590    connection ros2IngressToAutowareConsumer591      connect vmB.ros2Ingress.velocityReportOut592      to vmB.autowareConsumer.velocityReportIn;593594    flow guestToHostForwarderPayload595      from vmA.cuttlefishGuest.structuredLogcatOut.envelope596      to vmA.hostForwarder.structuredLogcatIn.envelope;597    flow hostForwarderToPrivateTcpPayload598      from vmA.hostForwarder.privateTcpOut.envelope599      to privateTcpBoundary.vmAIn.envelope;600    flow privateTcpToRos2IngressPayload601      from privateTcpBoundary.vmBOut.envelope602      to vmB.ros2Ingress.privateTcpIn.envelope;603    flow ros2IngressToObserverPayload604      from vmB.ros2Ingress.velocityReportOut.velocityReport605      to vmB.independentObserver.velocityReportIn.velocityReport;606    flow ros2IngressToAutowareConsumerPayload607      from vmB.ros2Ingress.velocityReportOut.velocityReport608      to vmB.autowareConsumer.velocityReportIn.velocityReport;609  }610611  part vehicleSpeedCampaignDeployment : VehicleSpeedCampaignCommunicationDeployment;612613  dependency vehicleSpeedCampaignImplementationTrace614    from vehicleSpeedCampaignDeployment615    to physicalSoftwareSources::referenceInteropBenchSource;616617  allocation def LogicalToPhysicalSoftwareCandidate {618    doc /* Candidate logical-to-physical mapping. This does not imply complete realization, satisfaction, runtime execution, or acceptance. */619  }620621  allocation signalTranslatorCandidate : LogicalToPhysicalSoftwareCandidate622    allocate DE4SDV_MiddlewareLogicalArchitecture::system::signalTranslator623    to physicalSoftware::signalAccessClient;624  #AdapterExchangeExcluded allocation vehicleSpeedSystemToSoftwareSignalCandidate : SystemToSoftwareSignalMappingCandidate625    allocate DE4SDV_MiddlewareLogicalArchitecture::system::signalTranslator626    to physicalSoftware::adapter::aaosSignal::vehicleSpeed;627  allocation diagnosticProxyCandidate : LogicalToPhysicalSoftwareCandidate628    allocate DE4SDV_MiddlewareLogicalArchitecture::system::diagnosticProxy629    to physicalSoftware::diagnosticAccessClient;630  allocation lifecycleBridgeCandidate : LogicalToPhysicalSoftwareCandidate631    allocate DE4SDV_MiddlewareLogicalArchitecture::system::lifecycleBridge632    to physicalSoftware::lifecycleClient;633  allocation healthProxyCandidate : LogicalToPhysicalSoftwareCandidate634    allocate DE4SDV_MiddlewareLogicalArchitecture::system::healthProxy635    to physicalSoftware::healthClient;636  allocation updateCoordinatorCandidate : LogicalToPhysicalSoftwareCandidate637    allocate DE4SDV_MiddlewareLogicalArchitecture::system::updateCoordinator638    to physicalSoftware::updateClient;639  allocation serviceBindingManagerCandidate : LogicalToPhysicalSoftwareCandidate640    allocate DE4SDV_MiddlewareLogicalArchitecture::system::serviceBindingManager641    to physicalSoftware::serviceDiscoveryClient;642643  dependency aaosBoundaryCandidateForSignalAccess644    from physicalSoftware::signalAccessClient645    to physicalSoftware::aaosSdvBoundary::vsidlMiddleware;646  dependency aaosBoundaryCandidateForDiagnostics647    from physicalSoftware::diagnosticAccessClient648    to physicalSoftware::aaosSdvBoundary::diagnostics;649  dependency aaosBoundaryCandidateForLifecycle650    from physicalSoftware::lifecycleClient651    to physicalSoftware::aaosSdvBoundary::lifecycleManager;652  dependency aaosBoundaryCandidateForHealth653    from physicalSoftware::healthClient654    to physicalSoftware::aaosSdvBoundary::healthMonitor;655  dependency aaosBoundaryCandidateForUpdates656    from physicalSoftware::updateClient657    to physicalSoftware::aaosSdvBoundary::updateManager;658  dependency aaosBoundaryCandidateForDiscovery659    from physicalSoftware::serviceDiscoveryClient660    to physicalSoftware::aaosSdvBoundary::serviceDiscovery;661662  dependency adapterCandidateAtApplicationBoundary663    from physicalSoftware::adapter664    to DE4SDV_MiddlewareLogicalArchitecture::system;665666  #AdapterExchangeExcluded dependency adapterSignalMapping667    from physicalSoftware::adapter::applicationSignal668    to physicalSoftware::adapter::aaosSignal;669  dependency referenceVehicleSpeedContractTrace670    from physicalSoftware::adapter::aaosSignal::vehicleSpeed671    to physicalSoftwareSources::referenceInteropBenchSource;672  dependency referenceVehicleSpeedVSIDLCandidate673    from physicalSoftware::adapter::aaosSignal::vehicleSpeed674    to physicalSoftware::aaosSdvBoundary::vsidlMiddleware;675  #AdapterExchangeExcluded dependency adapterDiagnosticMapping676    from physicalSoftware::adapter::applicationDiagnostics677    to physicalSoftware::adapter::aaosDiagnostics;678  #AdapterExchangeExcluded dependency adapterLifecycleMapping679    from physicalSoftware::adapter::applicationLifecycle680    to physicalSoftware::adapter::aaosLifecycle;681  #AdapterExchangeExcluded dependency adapterHealthMapping682    from physicalSoftware::adapter::applicationHealth683    to physicalSoftware::adapter::aaosHealth;684  #AdapterExchangeExcluded dependency adapterUpdateMapping685    from physicalSoftware::adapter::applicationUpdate686    to physicalSoftware::adapter::aaosUpdate;687  #AdapterExchangeExcluded dependency adapterDiscoveryMapping688    from physicalSoftware::adapter::applicationDiscovery689    to physicalSoftware::adapter::aaosDiscovery;690691  dependency adapterSignalServiceCandidate692    from physicalSoftware::adapter::aaosSignal693    to physicalSoftware::aaosSdvBoundary::vsidlMiddleware;694  dependency adapterDiagnosticServiceCandidate695    from physicalSoftware::adapter::aaosDiagnostics696    to physicalSoftware::aaosSdvBoundary::diagnostics;697  dependency adapterLifecycleServiceCandidate698    from physicalSoftware::adapter::aaosLifecycle699    to physicalSoftware::aaosSdvBoundary::lifecycleManager;700  dependency adapterHealthServiceCandidate701    from physicalSoftware::adapter::aaosHealth702    to physicalSoftware::aaosSdvBoundary::healthMonitor;703  dependency adapterUpdateServiceCandidate704    from physicalSoftware::adapter::aaosUpdate705    to physicalSoftware::aaosSdvBoundary::updateManager;706  dependency adapterDiscoveryServiceCandidate707    from physicalSoftware::adapter::aaosDiscovery708    to physicalSoftware::aaosSdvBoundary::serviceDiscovery;709710  dependency vsidlSignalToROS2Velocity711    from physicalSoftware::adapter::aaosSignal::vehicleSpeed712    to physicalSoftware::adapter::ros2VelocityOut;713  #AdapterExchangeExcluded dependency ros2AutowareStateToVSIDLLifecycle714    from physicalSoftware::adapter::ros2AutowareStateIn715    to physicalSoftware::adapter::aaosLifecycle;716  #AdapterExchangeExcluded dependency vsidlDiagnosticsToROS2Diagnostics717    from physicalSoftware::adapter::aaosDiagnostics718    to physicalSoftware::adapter::ros2DiagnosticsOut;719720  dependency vehicleSpeedSemanticTrace721    from physicalSoftware::adapter::aaosSignal::vehicleSpeed722    to physicalSoftwareSources::vssVehicleSpeedSource;723  dependency de4sdvAdapterImplementationTrace724    from physicalSoftware::adapter725    to physicalSoftwareSources::de4sdvVehicleSpeedAdapterSource;726  dependency referenceInteropBenchTrace727    from physicalSoftware::adapter728    to physicalSoftwareSources::referenceInteropBenchSource;729  dependency aaosVSIDLSourceTrace730    from physicalSoftware::adapter::aaosSignal731    to physicalSoftwareSources::vsidlProviderSource;732  dependency aaosMiddlewareSourceTrace733    from physicalSoftware::adapter::aaosSignal734    to physicalSoftwareSources::middlewareSource;735  dependency aaosHardwareInterfacesSourceTrace736    from physicalSoftware::adapter::aaosSignal737    to physicalSoftwareSources::hardwareInterfacesSource;738  dependency aaosGatewaySessionSourceTrace739    from physicalSoftware::adapter::aaosSignal740    to physicalSoftwareSources::gatewaySessionSource;741  dependency aaosDataTunnelSourceTrace742    from physicalSoftware::adapter::aaosSignal743    to physicalSoftwareSources::dataTunnelPublicationSource;744  dependency aaosRpcAgentSourceTrace745    from physicalSoftware::adapter::aaosSignal746    to physicalSoftwareSources::rpcAgentSource;747  dependency aaosLifecycleSourceTrace748    from physicalSoftware::aaosSdvBoundary::lifecycleManager749    to physicalSoftwareSources::lifecycleServiceSource;750  dependency aaosHealthSourceTrace751    from physicalSoftware::aaosSdvBoundary::healthMonitor752    to physicalSoftwareSources::healthMonitorSource;753  dependency aaosDiagnosticsSourceTrace754    from physicalSoftware::aaosSdvBoundary::diagnostics755    to physicalSoftwareSources::diagnosticsSource;756  dependency aaosAdapterSourceManifestTrace757    from physicalSoftware::adapter758    to physicalSoftwareSources::aaosSourceArtifact;759  dependency aaosSourceBuildEnvironmentCandidate760    from physicalSoftwareSources::aaosSourceArtifact761    to aaosBuildRuntimeEnvironmentCandidate;762  dependency aaosCuttlefishEnvironmentCandidate763    from physicalSoftware::aaosSdvBoundary764    to aaosBuildRuntimeEnvironmentCandidate;765766  concern physicalStructureConcern : PhysicalStructureConcern {767    doc /*768     * Review the System 1 candidate software boundary: adapter, AAOS SDV769     * boundary, and application-side clients. Source records and the bounded770     * System 2 campaign are excluded from this breakdown.771     */772    subject;773    stakeholder systemsEngineer : SystemsEngineer;774    stakeholder reviewer : OpenSourceReviewer;775  }776777  concern physicalInterfaceConcern : PhysicalInterfaceConcern {778    doc /*779     * Known issue: no System 1 Physical Interface view is published yet.780     * Physical interfaces can include software protocol endpoints, but this781     * increment has only a candidate vehicle-speed access port and no reviewed782     * pin, bus, deployed service, or production transport contract. The source783     * definitions remain authoritative; publishing their current native784     * projection would duplicate the functional interface catalog and leak an785     * unrelated candidate allocation.786     */787    subject;788    stakeholder systemsEngineer : SystemsEngineer;789    stakeholder reviewer : OpenSourceReviewer;790  }791792  concern vehicleSpeedCampaignInternalExchangeConcern : PhysicalInternalExchangeConcern {793    doc /*794     * Known issue: no Physical Internal Exchange view is published for the795     * campaign. Five explicit connections and five named item flows remain796     * authoritative in the model, but the tested native projection renders797     * only nested part boxes and does not materialize the connector path, flow798     * direction, or exchanged item types. A box-only artifact would misstate799     * the concern. The campaign source and observer are both inside the subject,800     * so there is also no external boundary exchange to substitute.801     */802    subject campaignDeployment : VehicleSpeedCampaignCommunicationDeployment;803    stakeholder systemsEngineer : SystemsEngineer;804    stakeholder reviewer : OpenSourceReviewer;805    stakeholder systemArchitect : SystemArchitect;806    stakeholder softwareDeveloper : SoftwareDeveloper;807    stakeholder verificationEngineer : VerificationEngineer;808  }809810  concern vehicleSpeedServiceBundleInternalExchangeConcern : PhysicalInternalExchangeConcern {811    doc /*812     * Which provider sends VehicleSpeedProviderMessage to which observer,813     * through which owned ports and connector, and in which direction? Keep814     * this bounded review slice inside the AAOS service bundle; transport and815     * deployment topology belong to the wider campaign concern.816     */817    subject serviceBundle : AAOSVehicleSpeedServiceBundle;818    stakeholder systemsEngineer : SystemsEngineer;819    stakeholder reviewer : OpenSourceReviewer;820    stakeholder softwareDeveloper : SoftwareDeveloper;821    stakeholder verificationEngineer : VerificationEngineer;822  }823824  concern vehicleSpeedCampaignStructureConcern : PhysicalStructureConcern {825    doc /* Supporting System 2 campaign-host breakdown, distinct from the System 1 product boundary. */826    subject campaignDeployment : VehicleSpeedCampaignCommunicationDeployment;827    stakeholder systemsEngineer : SystemsEngineer;828    stakeholder reviewer : OpenSourceReviewer;829  }830831  concern vehicleSpeedCampaignInterfaceConcern : PhysicalInterfaceConcern {832    doc /* Supporting System 2 campaign transport contracts, distinct from the System 1 candidate interfaces. */833    subject campaignDeployment : VehicleSpeedCampaignCommunicationDeployment;834    stakeholder systemsEngineer : SystemsEngineer;835    stakeholder reviewer : OpenSourceReviewer;836  }837838  concern physicalFunctionalMappingConcern : PhysicalFunctionalMappingConcern {839    subject;840    stakeholder systemsEngineer : SystemsEngineer;841    stakeholder reviewer : OpenSourceReviewer;842  }843844  concern physicalLogicalMappingConcern : PhysicalLogicalMappingConcern {845    subject;846    stakeholder systemsEngineer : SystemsEngineer;847    stakeholder reviewer : OpenSourceReviewer;848  }849850  view middlewarePhysicalStructureView {851    viewpoint selectedPhysicalStructureViewpoint : PhysicalStructureDefinitionViewpoint {852      frame physicalStructureConcern;853    }854    expose MiddlewarePhysicalSoftwareBoundary;855    attribute depth = 1;856    attribute showAnnotationRows = false;857    attribute maxCompartmentEntries = -1;858    render asTreeDiagram;859  }860861  metadata def AdapterExchangeExcluded {862    doc /*863     * View-scope exclusion tag for the adapter-exchange concern. Relationships864     * annotated with this metadata describe candidate paths outside the wired865     * velocity exchange (state, diagnostics, lifecycle, health, update,866     * discovery mappings) and are filtered out of middlewareAdapterBoundaryExchangeView.867     */868  }869870  concern adapterBoundaryExchangeConcern : PhysicalInternalExchangeConcern {871    doc /*872     * Which AAOS SDV VSIDL service access feeds the adapter, and which873     * Autoware-facing ROS 2 velocity-report boundary does the adapter874     * publish through, in which direction? Keep this bounded to the wired875     * velocity path; state and diagnostics edges remain candidates.876     */877    subject boundary : MiddlewarePhysicalSoftwareBoundary;878    stakeholder systemsEngineer : SystemsEngineer;879    stakeholder reviewer : OpenSourceReviewer;880    stakeholder softwareDeveloper : SoftwareDeveloper;881    stakeholder verificationEngineer : VerificationEngineer;882  }883884  view middlewareAdapterBoundaryExchangeView {885    viewpoint selectedAdapterBoundaryExchangeViewpoint : PhysicalInternalExchangeViewpoint {886      frame adapterBoundaryExchangeConcern;887    }888    doc /*889     * Bounded projection of the wired adapter chain: AAOS SDV service890     * access -> adapter -> Autoware-facing ROS 2 velocity-report boundary.891     * Parts are wired through ports; inherited port rows, mapping892     * dependencies, and allocations are excluded from this concern.893     */894    expose MiddlewarePhysicalSoftwareBoundary::adapter;895    expose MiddlewarePhysicalSoftwareBoundary::adapter::**;896    expose MiddlewarePhysicalSoftwareBoundary::aaosSdvBoundary;897    expose MiddlewarePhysicalSoftwareBoundary::autowareRos2Boundary;898    expose MiddlewarePhysicalSoftwareBoundary::autowareRos2Boundary::*;899    filter not (@ AdapterExchangeExcluded);900    attribute depth = -1;901    attribute showAnnotationRows = false;902    attribute showInheritedRows = false;903    attribute maxCompartmentEntries = 0;904    render asInterconnectionDiagram;905  }906907  /*908   * No Physical Context Exchange view is published for this campaign. Both909   * hosts and the complete one-directional transfer chain are contained by the910   * deployment subject, so presenting them as an external-boundary exchange911   * would be false. The typed connections and flows in the source are912   * authoritative for this scope while native rendering remains inadequate.913   */914915  view middlewareAAOSVehicleSpeedServiceBundleInternalExchangeView {916    viewpoint selectedAAOSVehicleSpeedServiceBundleInternalExchangeViewpoint : PhysicalInternalExchangeViewpoint {917      frame vehicleSpeedServiceBundleInternalExchangeConcern;918    }919    doc /*920     * Bounded native projection of the authoritative provider-to-observer921     * connection and VehicleSpeedProviderMessage flow. The wider campaign922     * exchange remains withheld because it does not pass the same visual gate.923     */924    expose vehicleSpeedCampaignDeployment::vmA::cuttlefishGuest;925    expose vehicleSpeedCampaignDeployment::vmA::cuttlefishGuest::**;926    attribute depth = -1;927    attribute showAnnotationRows = false;928    render asInterconnectionDiagram;929  }930931  view middlewareVehicleSpeedCampaignStructureView {932    viewpoint selectedVehicleSpeedCampaignStructureViewpoint : PhysicalStructureDefinitionViewpoint {933      frame vehicleSpeedCampaignStructureConcern;934    }935    doc /*936     * Supporting structure view for the two independent System 2 hosts, the937     * nested AAOS guest, host-side forwarder, ROS 2 ingress, and observer.938     */939    expose VehicleSpeedCampaignCommunicationDeployment;940    expose VehicleSpeedCampaignCommunicationDeployment::vmA;941    expose VehicleSpeedCampaignCommunicationDeployment::vmA::cuttlefishGuest;942    expose VehicleSpeedCampaignCommunicationDeployment::vmA::hostForwarder;943    expose VehicleSpeedCampaignCommunicationDeployment::privateTcpBoundary;944    expose VehicleSpeedCampaignCommunicationDeployment::vmB;945    expose VehicleSpeedCampaignCommunicationDeployment::vmB::ros2Ingress;946    expose VehicleSpeedCampaignCommunicationDeployment::vmB::independentObserver;947    attribute showAnnotationRows = false;948    attribute maxCompartmentEntries = 0;949    render asTreeDiagram;950  }951952  view middlewareVehicleSpeedCampaignInterfaceView {953    viewpoint selectedVehicleSpeedCampaignInterfaceViewpoint : PhysicalInterfaceDefinitionViewpoint {954      frame vehicleSpeedCampaignInterfaceConcern;955    }956    doc /*957     * Supporting interface view for the campaign envelope and the official958     * VelocityReport publication/subscription boundary. Exact serialization959     * and transport parameters remain owned by the executable contracts.960     */961    expose VehicleSpeedProviderPublication;962    expose VehicleSpeedProviderSubscription;963    expose VehicleSpeedCampaignWirePublication;964    expose VehicleSpeedCampaignWireSubscription;965    expose VelocityReportPublication;966    expose VelocityReportSubscription;967    attribute showAnnotationRows = false;968    render asTreeDiagram;969  }970971  /*972   * No physical-function allocation is modeled in this increment. Publishing a973   * Physical Functional Mapping view would therefore present package contents974   * as a false mapping. Add the view only when physical actions and their975   * allocations exist in the model.976   */977978  view middlewarePhysicalLogicalMappingView : MVD::MatrixView {979    viewpoint selectedPhysicalLogicalMappingViewpoint : PhysicalLogicalMappingViewpoint {980      frame physicalLogicalMappingConcern;981    }982    view :>> rowView {983      expose system::signalTranslator;984      expose system::diagnosticProxy;985      expose system::lifecycleBridge;986      expose system::healthProxy;987      expose system::updateCoordinator;988      expose system::serviceBindingManager;989      attribute :>> representation = Rep::name;990    }991    view :>> columnView {992      expose physicalSoftware::signalAccessClient;993      expose physicalSoftware::diagnosticAccessClient;994      expose physicalSoftware::lifecycleClient;995      expose physicalSoftware::healthClient;996      expose physicalSoftware::updateClient;997      expose physicalSoftware::serviceDiscoveryClient;998      expose physicalSoftware::adapter::aaosSignal::vehicleSpeed;999      attribute :>> representation = Rep::name;1000    }1001    view :>> cellView {1002      expose DE4SDV_MiddlewarePhysicalSoftwareRealization::*;1003      attribute :>> direction = SysideViews::MatrixTraceabilityDirection::row2col;1004    }1005  }1006}1007