From 5a4be821ac801de5950df8f481049840fc3f35f6 Mon Sep 17 00:00:00 2001 From: yangdekun2026 Date: Mon, 16 Nov 2026 17:42:47 +0800 Subject: [PATCH 1/6] feat(can): integrate shared reception, signals and recorder history --- CONTEXT.md | 35 + .../common/enums/ChannelSourceEnum.java | 11 +- .../opentest/common/enums/FileTypeEnum.java | 1 + .../opentest/common/exception/ErrorCode.java | 3 + .../common/model/dto/BoxChannelDto.java | 4 + .../model/dto/CanChannelSaveRequestDto.java | 16 + .../model/dto/CanRecordingSectionDto.java | 37 + .../opentest/common/model/dto/ChannelDto.java | 3 + .../model/dto/FlowExecuteSnapshotDataDto.java | 4 + .../common/model/dto/RenderDataDto.java | 5 + .../common/model/entity/BoxChannel.java | 2 + .../com/opentest/core/jni/CanJNIBridge.java | 7 + .../result/MeasurementResultFileMetadata.java | 48 +- .../MeasurementResultFileProjection.java | 22 + .../result/PersistResultFileOutput.java | 33 +- .../result/PersistResultSinkProcessor.java | 25 +- .../result/CanMeasurementResultFileTest.java | 89 ++ .../controller/BoxChannelController.java | 16 + .../opentest/controller/CanController.java | 77 ++ .../opentest/controller/CanDbcController.java | 40 + .../controller/CanRawFramesController.java | 42 + .../controller/CanRawRecordingController.java | 101 +++ ...111120000__repair_math_sample_columns.java | 62 ++ ...1110160000__add_project_can_definition.sql | 1 + .../main/resources/lang/messages.properties | 65 ++ .../resources/lang/messages_de.properties | 31 + .../resources/lang/messages_en.properties | 65 ++ .../resources/lang/messages_es.properties | 31 + .../resources/lang/messages_fr.properties | 31 + .../resources/lang/messages_ja.properties | 31 + .../resources/lang/messages_ko.properties | 31 + .../resources/lang/messages_ru.properties | 31 + .../resources/lang/messages_tr.properties | 31 + .../resources/lang/messages_zh.properties | 31 + .../resources/lang/messages_zh_TW.properties | 31 + .../controller/CanControllerTest.java | 387 +++++++++ .../controller/CanDbcControllerTest.java | 117 +++ .../CanProjectChannelControllerTest.java | 107 +++ .../CanRawFramesControllerTest.java | 122 +++ .../CanRawRecordingControllerTest.java | 265 ++++++ .../CanProjectDefinitionMigrationTest.java | 44 + .../MathSampleSchemaRepairMigrationTest.java | 266 ++++++ .../opentest/service/BoxChannelService.java | 164 +++- .../service/DashboardConfigService.java | 17 +- .../com/opentest/service/ProjectService.java | 128 ++- .../opentest/service/VariablesService.java | 11 + .../service/can/CanConfigurationStore.java | 33 + .../opentest/service/can/CanDbcService.java | 131 +++ .../service/can/CanNativeGateway.java | 21 + .../service/can/CanOperationException.java | 17 + .../service/can/CanProjectChannelFacts.java | 179 ++++ .../service/can/CanProjectChannelService.java | 273 ++++++ .../service/can/CanRawRecordingStore.java | 342 ++++++++ .../com/opentest/service/can/CanService.java | 783 ++++++++++++++++++ .../service/can/CanStoredUnitConversion.java | 87 ++ .../service/can/JniCanNativeGateway.java | 70 ++ .../AbstractDashboardExecuteStrategy.java | 14 + ...boardHistoricalResultArtifactResolver.java | 3 + .../framework/BoundMeasurementInputs.java | 37 +- .../DashboardConfigurationChannels.java | 17 +- .../framework/MeasurementInputBindings.java | 66 +- .../MeasurementResultMemberFacts.java | 88 +- .../ProviderDashboardResultReader.java | 4 +- .../framework/ProviderExecutionErrors.java | 35 +- .../ProviderExecutionPreparation.java | 4 +- .../framework/ProviderGraphicUnitService.java | 75 +- .../framework/SavedMeasurementInputFacts.java | 14 +- .../framework/SavedProviderArtifacts.java | 6 + .../grpc/core/AbstractDashboardHandler.java | 4 + .../grpc/core/TimeStopCompletionSource.java | 19 + .../service/grpc/core/sender/GrpcWriter.java | 11 +- .../sync/SyncMeasurementRecorderManager.java | 84 +- .../CompletedGraphicResultPublisher.java | 7 +- .../MeasurementCompletedTargetPolicy.java | 27 +- .../MeasurementFileOutputAliases.java | 4 +- .../provider/ProviderCanSignalInputs.java | 283 +++++++ .../ProviderPipelineDashboardHandler.java | 295 ++++++- .../provider/ProviderWaveformFileOutput.java | 4 +- .../grpc/replay/RecordedCanSignalInputs.java | 84 ++ .../RecordedMeasurementReplayPlanner.java | 89 +- .../RecordedMeasurementReplaySession.java | 38 +- .../grpc/replay/RecordedResultMembers.java | 16 +- .../service/jni/UnitConversionService.java | 4 + .../result/ResultUnitConversionService.java | 6 + .../mapper/BoxChannelStructMapper.java | 4 + .../project/CanRecordedProjectArtifacts.java | 174 ++++ .../measurement/CanRecordedFacts.java | 92 ++ .../measurement/CanRecordedInputStore.java | 375 +++++++++ .../measurement/SavedInputResolver.java | 6 +- .../VirtualChannelConfigValidator.java | 4 + .../service/BoxChannelCanProjectionTest.java | 109 +++ .../service/ProjectServiceCanImportTest.java | 127 +++ ...ojectServiceCanRecordingRoundtripTest.java | 333 ++++++++ .../service/can/CanDbcServiceTest.java | 121 +++ .../service/can/CanErrorLocalizationTest.java | 242 ++++++ .../can/CanProjectChannelServiceTest.java | 293 +++++++ .../service/can/CanProjectDbcChannelTest.java | 233 ++++++ .../can/CanRawRecordingLifecycleTest.java | 422 ++++++++++ .../service/can/CanRawRecordingStoreTest.java | 321 +++++++ .../opentest/service/can/CanServiceTest.java | 753 +++++++++++++++++ .../CanMeasurementInputBindingsTest.java | 213 +++++ .../CanMeasurementResultMemberFactsTest.java | 103 +++ .../framework/CanProjectFactsWiringTest.java | 37 + .../framework/CanStoredUnitSelectionTest.java | 106 +++ .../ProviderHistoricalCanUnitFactsTest.java | 321 +++++++ .../framework/SavedCanHistoryFactsTest.java | 228 +++++ .../core/sync/CanOnlyTimeCompletionTest.java | 317 +++++++ .../sync/MeasurementOperatorStopTest.java | 70 ++ .../sync/TimeStopTargetInstallationTest.java | 37 +- .../CompletedGraphicResultPublisherTest.java | 213 +++++ .../MeasurementFileOutputAliasesTest.java | 45 + .../MeasurementLiveGraphicUnitsTest.java | 95 +++ .../ProviderCanHostRecordingTest.java | 260 ++++++ .../provider/ProviderCanSignalInputsTest.java | 346 ++++++++ .../RecordedProviderFactsPlanningTest.java | 80 ++ .../replay/RecordedResultMembersTest.java | 21 +- .../CanRecordedInputStoreTest.java | 229 +++++ .../VirtualChannelCanDependencyTest.java | 51 ++ .../api/capability/CanChannelFacts.java | 19 + .../api/capability/CanSignalBatch.java | 12 + .../api/capability/CanSignalEvent.java | 40 + .../api/capability/CanSignalInputs.java | 8 + .../api/capability/CanSignalProjection.java | 13 + .../dashboard/api/channel/CanPortBinding.java | 11 + .../api/channel/CanSignalChannel.java | 16 + .../api/channel/CanSignalQuantity.java | 5 + .../api/channel/CanSignalUnitConversion.java | 84 ++ .../dashboard/api/channel/CanSignalUnits.java | 43 + .../dashboard/api/channel/ChannelCatalog.java | 18 + .../recorded/RecordedOutputSelection.java | 29 +- .../api/pipeline/CapabilityRegistry.java | 4 + .../api/CanChannelFactsContractTest.java | 107 +++ .../channel/CanSignalUnitConversionTest.java | 50 ++ .../plugin/locales/en-US.json | 4 +- .../plugin/locales/zh-CN.json | 4 +- .../monitor/measure/MonitorCanProjection.java | 71 ++ .../monitor/measure/MonitorCanUnits.java | 26 + .../measure/MonitorDashboardProvider.java | 24 +- .../monitor/measure/MonitorDefinitions.java | 16 +- .../monitor/measure/MonitorRecordedUse.java | 8 +- .../monitor/measure/MonitorResultCatalog.java | 4 +- .../monitor/measure/MonitorSelection.java | 3 +- .../MonitorTableDefinitionResolver.java | 18 +- .../resources/json/DashboardResultConfig.json | 26 + .../src/main/resources/monitor-results.json | 26 + .../measure/MonitorCanContractTest.java | 275 ++++++ .../monitor/measure/MonitorCanUnitsTest.java | 71 ++ .../measure/MonitorDashboardProviderTest.java | 65 +- .../MonitorDefinitionSelectionTest.java | 2 +- .../MonitorManualStopContractTest.java | 2 + .../measure/MonitorRawFsUnitsTest.java | 3 +- .../measure/MonitorUnboundChannelsTest.java | 4 + apps/frontend/src/constants/channel.ts | 3 +- .../__tests__/time-history-curve.test.ts | 65 ++ .../legacy/charts/TimeHistoryCurve.ts | 4 + .../crychart/legacy/core/BaseChartV2.ts | 2 +- .../__tests__/unit-conversion.test.ts | 74 ++ .../handlers/can-unit-conversion.ts | 29 + .../file-loader/handlers/unit-conversion.ts | 31 +- apps/frontend/src/locales/can-channel/en.ts | 67 ++ .../frontend/src/locales/can-channel/zh-CN.ts | 67 ++ apps/frontend/src/locales/can-raw/en.ts | 57 ++ apps/frontend/src/locales/can-raw/zh-CN.ts | 55 ++ apps/frontend/src/locales/can/en.ts | 93 +++ apps/frontend/src/locales/can/zh-CN.ts | 93 +++ apps/frontend/src/locales/en.ts | 6 + .../src/locales/native-error-supplement.ts | 2 + apps/frontend/src/locales/tr-TR.ts | 1 + apps/frontend/src/locales/zh-CN.ts | 6 + .../channel/can/__tests__/dbc-fixture.ts | 66 ++ .../channel/can/__tests__/dbc-model.test.ts | 116 +++ .../channel/can/__tests__/editor.test.ts | 415 ++++++++++ .../channel/can/__tests__/model.test.ts | 215 +++++ .../src/modules/device/channel/can/editor.vue | 665 +++++++++++++++ .../src/modules/device/channel/can/index.vue | 135 +++ .../src/modules/device/channel/can/model.ts | 459 ++++++++++ .../configuration/__tests__/index.test.ts | 2 +- .../device/channel/configuration/index.vue | 18 +- .../src/modules/device/channel/index.vue | 7 + .../modules/device/channel/table/index.vue | 72 +- .../detail/can/__tests__/can-api.test.ts | 55 ++ .../detail/can/__tests__/can-form.test.ts | 149 ++++ .../detail/can/__tests__/can-session.test.ts | 144 ++++ .../detail/can/__tests__/can-ui.test.ts | 160 ++++ .../detail/can/__tests__/detail-close.test.ts | 84 ++ .../hardware/detail/can/__tests__/fixtures.ts | 60 ++ .../device/hardware/detail/can/can-api.ts | 192 +++++ .../device/hardware/detail/can/can-form.ts | 151 ++++ .../device/hardware/detail/can/can-session.ts | 199 +++++ .../device/hardware/detail/can/index.vue | 436 ++++++++++ .../can/raw-frames/__tests__/fixtures.ts | 110 +++ .../can/raw-frames/__tests__/raw-api.test.ts | 96 +++ .../raw-frames/__tests__/raw-download.test.ts | 75 ++ .../raw-frames/__tests__/raw-parser.test.ts | 153 ++++ .../__tests__/raw-recording-session.test.ts | 220 +++++ .../raw-frames/__tests__/raw-session.test.ts | 193 +++++ .../can/raw-frames/__tests__/raw-ui.test.ts | 263 ++++++ .../hardware/detail/can/raw-frames/index.vue | 418 ++++++++++ .../hardware/detail/can/raw-frames/raw-api.ts | 58 ++ .../detail/can/raw-frames/raw-parser.ts | 207 +++++ .../detail/can/raw-frames/raw-session.ts | 296 +++++++ .../detail/can/reception-indicator.vue | 68 ++ .../modules/device/hardware/detail/index.vue | 56 +- .../src/modules/device/hardware/index.vue | 7 + .../src/modules/device/math/setup/index.vue | 10 +- .../__tests__/record-channel-select.test.ts | 12 + .../components/record-channel-select.vue | 2 +- .../__tests__/use-monitor-graphics.test.ts | 14 + .../monitor/hooks/use-monitor-graphics.ts | 2 + .../src/modules/monitor/hooks/use-monitor.ts | 1 + .../src/modules/monitor/recorder-channels.ts | 8 +- .../shared/dashboard/measurement-control.vue | 11 +- .../views/__tests__/single-value-view.test.ts | 9 + .../components/views/single-value-rows.vue | 5 +- .../hooks/__tests__/use-render-value.test.ts | 91 ++ .../data-graph/hooks/use-render-value.ts | 25 +- .../utils/__tests__/time-axis.test.ts | 9 + .../__tests__/unit-conversion-options.test.ts | 64 ++ .../shared/data-graph/utils/time-axis.ts | 11 +- .../utils/unit-conversion-options.ts | 13 +- .../dc-channel-select/__tests__/index.test.ts | 27 +- .../shared/dc-channel-select/index.vue | 15 +- .../modules/shared/trigger-config/index.vue | 12 +- .../components/channel-level-filtering.vue | 18 +- .../src/plugin-host/measure-settings.ts | 4 +- .../src/plugin-host/workspace-context.ts | 5 +- .../src/stores/__tests__/channel.test.ts | 47 +- apps/frontend/src/stores/channel.ts | 17 +- .../__tests__/can-error-localization.test.ts | 53 ++ apps/frontend/src/utils/channel.ts | 9 + .../0046-host-owned-shared-can-reception.md | 19 + ...6-host-owned-shared-can-reception.zh-CN.md | 19 + docs/can-integration.md | 40 + docs/can-integration.zh-CN.md | 40 + 234 files changed, 20475 insertions(+), 299 deletions(-) create mode 100644 apps/backend/crydaq-common/src/main/java/com/opentest/common/model/dto/CanChannelSaveRequestDto.java create mode 100644 apps/backend/crydaq-common/src/main/java/com/opentest/common/model/dto/CanRecordingSectionDto.java create mode 100644 apps/backend/crydaq-dashboard-standard-processors/src/test/java/com/opentest/dashboard/standard/result/CanMeasurementResultFileTest.java create mode 100644 apps/backend/crydaq-server/src/main/java/com/opentest/controller/CanController.java create mode 100644 apps/backend/crydaq-server/src/main/java/com/opentest/controller/CanDbcController.java create mode 100644 apps/backend/crydaq-server/src/main/java/com/opentest/controller/CanRawFramesController.java create mode 100644 apps/backend/crydaq-server/src/main/java/com/opentest/controller/CanRawRecordingController.java create mode 100644 apps/backend/crydaq-server/src/main/java/com/opentest/dbmigration/V2_5_0_20261111120000__repair_math_sample_columns.java create mode 100644 apps/backend/crydaq-server/src/main/resources/db/migration/V2.5.0_20261110160000__add_project_can_definition.sql create mode 100644 apps/backend/crydaq-server/src/test/java/com/opentest/controller/CanControllerTest.java create mode 100644 apps/backend/crydaq-server/src/test/java/com/opentest/controller/CanDbcControllerTest.java create mode 100644 apps/backend/crydaq-server/src/test/java/com/opentest/controller/CanProjectChannelControllerTest.java create mode 100644 apps/backend/crydaq-server/src/test/java/com/opentest/controller/CanRawFramesControllerTest.java create mode 100644 apps/backend/crydaq-server/src/test/java/com/opentest/controller/CanRawRecordingControllerTest.java create mode 100644 apps/backend/crydaq-server/src/test/java/com/opentest/migration/CanProjectDefinitionMigrationTest.java create mode 100644 apps/backend/crydaq-server/src/test/java/com/opentest/migration/MathSampleSchemaRepairMigrationTest.java create mode 100644 apps/backend/crydaq-service/src/main/java/com/opentest/service/can/CanConfigurationStore.java create mode 100644 apps/backend/crydaq-service/src/main/java/com/opentest/service/can/CanDbcService.java create mode 100644 apps/backend/crydaq-service/src/main/java/com/opentest/service/can/CanNativeGateway.java create mode 100644 apps/backend/crydaq-service/src/main/java/com/opentest/service/can/CanOperationException.java create mode 100644 apps/backend/crydaq-service/src/main/java/com/opentest/service/can/CanProjectChannelFacts.java create mode 100644 apps/backend/crydaq-service/src/main/java/com/opentest/service/can/CanProjectChannelService.java create mode 100644 apps/backend/crydaq-service/src/main/java/com/opentest/service/can/CanRawRecordingStore.java create mode 100644 apps/backend/crydaq-service/src/main/java/com/opentest/service/can/CanService.java create mode 100644 apps/backend/crydaq-service/src/main/java/com/opentest/service/can/CanStoredUnitConversion.java create mode 100644 apps/backend/crydaq-service/src/main/java/com/opentest/service/can/JniCanNativeGateway.java create mode 100644 apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/core/TimeStopCompletionSource.java create mode 100644 apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/provider/ProviderCanSignalInputs.java create mode 100644 apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/replay/RecordedCanSignalInputs.java create mode 100644 apps/backend/crydaq-service/src/main/java/com/opentest/service/project/CanRecordedProjectArtifacts.java create mode 100644 apps/backend/crydaq-service/src/main/java/com/opentest/service/recording/measurement/CanRecordedFacts.java create mode 100644 apps/backend/crydaq-service/src/main/java/com/opentest/service/recording/measurement/CanRecordedInputStore.java create mode 100644 apps/backend/crydaq-service/src/test/java/com/opentest/service/BoxChannelCanProjectionTest.java create mode 100644 apps/backend/crydaq-service/src/test/java/com/opentest/service/ProjectServiceCanImportTest.java create mode 100644 apps/backend/crydaq-service/src/test/java/com/opentest/service/ProjectServiceCanRecordingRoundtripTest.java create mode 100644 apps/backend/crydaq-service/src/test/java/com/opentest/service/can/CanDbcServiceTest.java create mode 100644 apps/backend/crydaq-service/src/test/java/com/opentest/service/can/CanErrorLocalizationTest.java create mode 100644 apps/backend/crydaq-service/src/test/java/com/opentest/service/can/CanProjectChannelServiceTest.java create mode 100644 apps/backend/crydaq-service/src/test/java/com/opentest/service/can/CanProjectDbcChannelTest.java create mode 100644 apps/backend/crydaq-service/src/test/java/com/opentest/service/can/CanRawRecordingLifecycleTest.java create mode 100644 apps/backend/crydaq-service/src/test/java/com/opentest/service/can/CanRawRecordingStoreTest.java create mode 100644 apps/backend/crydaq-service/src/test/java/com/opentest/service/can/CanServiceTest.java create mode 100644 apps/backend/crydaq-service/src/test/java/com/opentest/service/dashboard/framework/CanMeasurementInputBindingsTest.java create mode 100644 apps/backend/crydaq-service/src/test/java/com/opentest/service/dashboard/framework/CanMeasurementResultMemberFactsTest.java create mode 100644 apps/backend/crydaq-service/src/test/java/com/opentest/service/dashboard/framework/CanProjectFactsWiringTest.java create mode 100644 apps/backend/crydaq-service/src/test/java/com/opentest/service/dashboard/framework/CanStoredUnitSelectionTest.java create mode 100644 apps/backend/crydaq-service/src/test/java/com/opentest/service/dashboard/framework/ProviderHistoricalCanUnitFactsTest.java create mode 100644 apps/backend/crydaq-service/src/test/java/com/opentest/service/dashboard/framework/SavedCanHistoryFactsTest.java create mode 100644 apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/core/sync/CanOnlyTimeCompletionTest.java create mode 100644 apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/core/sync/MeasurementOperatorStopTest.java create mode 100644 apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/provider/MeasurementLiveGraphicUnitsTest.java create mode 100644 apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/provider/ProviderCanHostRecordingTest.java create mode 100644 apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/provider/ProviderCanSignalInputsTest.java create mode 100644 apps/backend/crydaq-service/src/test/java/com/opentest/service/recording/measurement/CanRecordedInputStoreTest.java create mode 100644 apps/backend/crydaq-service/src/test/java/com/opentest/service/virtualchannel/VirtualChannelCanDependencyTest.java create mode 100644 apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/capability/CanChannelFacts.java create mode 100644 apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/capability/CanSignalBatch.java create mode 100644 apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/capability/CanSignalEvent.java create mode 100644 apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/capability/CanSignalInputs.java create mode 100644 apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/capability/CanSignalProjection.java create mode 100644 apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/channel/CanPortBinding.java create mode 100644 apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/channel/CanSignalChannel.java create mode 100644 apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/channel/CanSignalQuantity.java create mode 100644 apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/channel/CanSignalUnitConversion.java create mode 100644 apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/channel/CanSignalUnits.java create mode 100644 apps/backend/opentest-dashboard-api/src/test/java/com/opentest/dashboard/api/CanChannelFactsContractTest.java create mode 100644 apps/backend/opentest-dashboard-api/src/test/java/com/opentest/dashboard/api/channel/CanSignalUnitConversionTest.java create mode 100644 apps/backend/opentest-monitor-tools/src/main/java/com/opentest/plugins/monitor/measure/MonitorCanProjection.java create mode 100644 apps/backend/opentest-monitor-tools/src/main/java/com/opentest/plugins/monitor/measure/MonitorCanUnits.java create mode 100644 apps/backend/opentest-monitor-tools/src/test/java/com/opentest/plugins/monitor/measure/MonitorCanContractTest.java create mode 100644 apps/backend/opentest-monitor-tools/src/test/java/com/opentest/plugins/monitor/measure/MonitorCanUnitsTest.java create mode 100644 apps/frontend/src/libs/file-loader/handlers/can-unit-conversion.ts create mode 100644 apps/frontend/src/locales/can-channel/en.ts create mode 100644 apps/frontend/src/locales/can-channel/zh-CN.ts create mode 100644 apps/frontend/src/locales/can-raw/en.ts create mode 100644 apps/frontend/src/locales/can-raw/zh-CN.ts create mode 100644 apps/frontend/src/locales/can/en.ts create mode 100644 apps/frontend/src/locales/can/zh-CN.ts create mode 100644 apps/frontend/src/modules/device/channel/can/__tests__/dbc-fixture.ts create mode 100644 apps/frontend/src/modules/device/channel/can/__tests__/dbc-model.test.ts create mode 100644 apps/frontend/src/modules/device/channel/can/__tests__/editor.test.ts create mode 100644 apps/frontend/src/modules/device/channel/can/__tests__/model.test.ts create mode 100644 apps/frontend/src/modules/device/channel/can/editor.vue create mode 100644 apps/frontend/src/modules/device/channel/can/index.vue create mode 100644 apps/frontend/src/modules/device/channel/can/model.ts create mode 100644 apps/frontend/src/modules/device/hardware/detail/can/__tests__/can-api.test.ts create mode 100644 apps/frontend/src/modules/device/hardware/detail/can/__tests__/can-form.test.ts create mode 100644 apps/frontend/src/modules/device/hardware/detail/can/__tests__/can-session.test.ts create mode 100644 apps/frontend/src/modules/device/hardware/detail/can/__tests__/can-ui.test.ts create mode 100644 apps/frontend/src/modules/device/hardware/detail/can/__tests__/detail-close.test.ts create mode 100644 apps/frontend/src/modules/device/hardware/detail/can/__tests__/fixtures.ts create mode 100644 apps/frontend/src/modules/device/hardware/detail/can/can-api.ts create mode 100644 apps/frontend/src/modules/device/hardware/detail/can/can-form.ts create mode 100644 apps/frontend/src/modules/device/hardware/detail/can/can-session.ts create mode 100644 apps/frontend/src/modules/device/hardware/detail/can/index.vue create mode 100644 apps/frontend/src/modules/device/hardware/detail/can/raw-frames/__tests__/fixtures.ts create mode 100644 apps/frontend/src/modules/device/hardware/detail/can/raw-frames/__tests__/raw-api.test.ts create mode 100644 apps/frontend/src/modules/device/hardware/detail/can/raw-frames/__tests__/raw-download.test.ts create mode 100644 apps/frontend/src/modules/device/hardware/detail/can/raw-frames/__tests__/raw-parser.test.ts create mode 100644 apps/frontend/src/modules/device/hardware/detail/can/raw-frames/__tests__/raw-recording-session.test.ts create mode 100644 apps/frontend/src/modules/device/hardware/detail/can/raw-frames/__tests__/raw-session.test.ts create mode 100644 apps/frontend/src/modules/device/hardware/detail/can/raw-frames/__tests__/raw-ui.test.ts create mode 100644 apps/frontend/src/modules/device/hardware/detail/can/raw-frames/index.vue create mode 100644 apps/frontend/src/modules/device/hardware/detail/can/raw-frames/raw-api.ts create mode 100644 apps/frontend/src/modules/device/hardware/detail/can/raw-frames/raw-parser.ts create mode 100644 apps/frontend/src/modules/device/hardware/detail/can/raw-frames/raw-session.ts create mode 100644 apps/frontend/src/modules/device/hardware/detail/can/reception-indicator.vue create mode 100644 apps/frontend/src/utils/__tests__/can-error-localization.test.ts create mode 100644 docs/adr/0046-host-owned-shared-can-reception.md create mode 100644 docs/adr/0046-host-owned-shared-can-reception.zh-CN.md create mode 100644 docs/can-integration.md create mode 100644 docs/can-integration.zh-CN.md diff --git a/CONTEXT.md b/CONTEXT.md index a14da749..4c4e740d 100644 --- a/CONTEXT.md +++ b/CONTEXT.md @@ -421,6 +421,41 @@ _Avoid_:已开始录制、启动准备中、取消请求即完成 **停止许可(Stop Permission)**:本次执行已经确认可以接受操作员停止请求的事实;预约等待与实际运行均可具有停止许可。它不表示执行已经结束,也不允许在停止收尾期间再次启动。 _Avoid_:实际采集开始、资源已经释放 +## CAN 业务术语 + +**CAN 总开关(CAN Enable Switch)**:用户允许设备使用 CAN 的总控制,开启后业务才能使用该设备的 CAN 端口;开启本身不表示端口正在接收。 +_Avoid_:开始测量、端口接收状态 + +**CAN 原始报文录制(Raw CAN Recording)**:对一个设备端口在手动开始至结束期间收到的报文形成的独立记录,可作为全局诊断历史查看与下载,不随工程归属。 +_Avoid_:Monitor Recorder、解码信号历史、表格筛选结果 + +**CAN 端口(CAN Port)**:设备提供的一路 CAN 总线接口,具有自己的接收配置和接收状态。同一设备的不同端口不表示主备关系。 +_Avoid_:解码信号通道、固定收发方向 + +**CAN 接收使用关系(CAN Reception Usage)**:某个业务或手动接收操作对指定端口数据的持续使用。多个使用关系可以共用一次接收,结束其中一个不表示其他使用也已结束。 +_Avoid_:配置弹窗是否打开、独立硬件接收、图表是否可见 + +**CAN 配置草稿(CAN Configuration Draft)**:用户正在编辑、尚未成功应用的一份端口配置,与已应用配置分别保留。 +_Avoid_:已生效硬件参数、已应用配置 + +**已应用 CAN 配置(Applied CAN Configuration)**:用户通过 Apply 成功接受并保存、供端口接收使用的配置。它本身不表示已经开始接收,也不等同于硬件实际回读值。 +_Avoid_:未应用草稿、硬件回读、正在接收 + +**CAN 解码录制(Recorded CAN Signals)**:Recorder 在一次工程测试中保存的 CAN 信号值、时间和有效性记录,按录制当时的通道与解码定义解释。历史回放使用已保存的解码结果,不依赖当前设备或后来修改的 DBC。 +_Avoid_:全局原始报文录制、音频 WAV、按新规则重新解码 + +**CAN 原始帧(Raw CAN Frame)**:从总线接收的一条报文,包含标识、帧格式、载荷及来源时间信息。 +_Avoid_:解码值、音频采样块 + +**CAN 信号通道(CAN Signal Channel)**:由指定设备端口上的报文和解码规则定义的一路物理量,具有名称、单位和有效性规则。 +_Avoid_:CAN 硬件端口、等间隔音频输入 + +**端口接收过滤(CAN Receive Filter)**:决定哪些报文进入该端口接收结果的规则,对使用该接收结果的消费者共同生效。 +_Avoid_:Raw Frames 页面筛选 + +**原始帧显示筛选(Raw Frame Display Filter)**:从已接收报文中选择页面展示内容的条件,不改变端口接收范围。 +_Avoid_:硬件接收过滤器 + ## 波形采集时间 **设备采集时间戳**:连续采集接口随波形数据返回的采样时间标记;其时钟基准由采集来源决定,不统一认定为 UTC。 diff --git a/apps/backend/crydaq-common/src/main/java/com/opentest/common/enums/ChannelSourceEnum.java b/apps/backend/crydaq-common/src/main/java/com/opentest/common/enums/ChannelSourceEnum.java index 4e58a3b6..8c09e75a 100644 --- a/apps/backend/crydaq-common/src/main/java/com/opentest/common/enums/ChannelSourceEnum.java +++ b/apps/backend/crydaq-common/src/main/java/com/opentest/common/enums/ChannelSourceEnum.java @@ -5,7 +5,8 @@ public enum ChannelSourceEnum implements BaseEnum { PHYSICAL(0), - MATH(1); + MATH(1), + CAN(2); private final Integer value; @@ -26,4 +27,12 @@ public String getDescription() { public static boolean isMath(Integer value) { return ObjectUtil.equal(MATH.value, value); } + + public static boolean isCan(Integer value) { + return ObjectUtil.equal(CAN.value, value); + } + + public static boolean isPhysical(Integer value) { + return value == null || ObjectUtil.equal(PHYSICAL.value, value); + } } diff --git a/apps/backend/crydaq-common/src/main/java/com/opentest/common/enums/FileTypeEnum.java b/apps/backend/crydaq-common/src/main/java/com/opentest/common/enums/FileTypeEnum.java index 48b02109..224a2349 100644 --- a/apps/backend/crydaq-common/src/main/java/com/opentest/common/enums/FileTypeEnum.java +++ b/apps/backend/crydaq-common/src/main/java/com/opentest/common/enums/FileTypeEnum.java @@ -65,6 +65,7 @@ public enum FileTypeEnum { * Word Open XML 模板格式 */ DOCX(13, "DOCX", ".docx"), + CAN_EVENTS(14, "CAN_EVENTS", ".can-events.jsonl"), ; /** diff --git a/apps/backend/crydaq-common/src/main/java/com/opentest/common/exception/ErrorCode.java b/apps/backend/crydaq-common/src/main/java/com/opentest/common/exception/ErrorCode.java index 0a86cde7..087e28a6 100644 --- a/apps/backend/crydaq-common/src/main/java/com/opentest/common/exception/ErrorCode.java +++ b/apps/backend/crydaq-common/src/main/java/com/opentest/common/exception/ErrorCode.java @@ -1358,6 +1358,9 @@ public enum ErrorCode { 1300004, "Dashboard has not been first-created, projectId={}, providerId={}", "error.dashboard.execution.not.first.created"), + CAN_RECORDER_UNAVAILABLE(1301001, + "CAN recording and history are not available yet. Use live Monitor or remove CAN inputs.", + "error.can.recorder.unavailable"), SOUND_POWER_ROOM_DIMENSIONS_INVALID(12090155, "Enter valid room length, width and height before sound power measurement. Each dimension and the calculated room surface area must be finite and greater than zero.", "error.sound.power.room.dimensions.invalid"), diff --git a/apps/backend/crydaq-common/src/main/java/com/opentest/common/model/dto/BoxChannelDto.java b/apps/backend/crydaq-common/src/main/java/com/opentest/common/model/dto/BoxChannelDto.java index e1743acd..d938ba2b 100644 --- a/apps/backend/crydaq-common/src/main/java/com/opentest/common/model/dto/BoxChannelDto.java +++ b/apps/backend/crydaq-common/src/main/java/com/opentest/common/model/dto/BoxChannelDto.java @@ -3,6 +3,7 @@ import com.opentest.dashboard.api.channel.MathSampleSemantics; import cn.hutool.core.convert.Convert; import com.opentest.common.model.BaseModel; +import com.opentest.common.enums.ChannelSourceEnum; import com.opentest.common.model.entity.Device; import com.opentest.common.model.validation.ValidationOptNumQuery; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; @@ -82,6 +83,8 @@ public class BoxChannelDto extends BaseModel implements Serializable { */ private Integer channelSource; + private String canDefinitionJson; + /** * 自定义名称 */ @@ -306,6 +309,7 @@ public static class BoxChannelItem implements Serializable { private Collection boxChannelItems; public Double getGain() { + if (ChannelSourceEnum.isCan(channelSource)) return null; if ("OPENDAQ".equals(protocol)) { return null; } diff --git a/apps/backend/crydaq-common/src/main/java/com/opentest/common/model/dto/CanChannelSaveRequestDto.java b/apps/backend/crydaq-common/src/main/java/com/opentest/common/model/dto/CanChannelSaveRequestDto.java new file mode 100644 index 00000000..75591227 --- /dev/null +++ b/apps/backend/crydaq-common/src/main/java/com/opentest/common/model/dto/CanChannelSaveRequestDto.java @@ -0,0 +1,16 @@ +package com.opentest.common.model.dto; + +import lombok.Data; + +import java.io.Serializable; + +@Data +public class CanChannelSaveRequestDto implements Serializable { + private Long id; + private Long projectId; + private String vchId; + private Long deviceId; + private String customName; + private String channelColor; + private String canDefinitionJson; +} diff --git a/apps/backend/crydaq-common/src/main/java/com/opentest/common/model/dto/CanRecordingSectionDto.java b/apps/backend/crydaq-common/src/main/java/com/opentest/common/model/dto/CanRecordingSectionDto.java new file mode 100644 index 00000000..f6b09fe0 --- /dev/null +++ b/apps/backend/crydaq-common/src/main/java/com/opentest/common/model/dto/CanRecordingSectionDto.java @@ -0,0 +1,37 @@ +package com.opentest.common.model.dto; + +import java.io.Serializable; +import java.util.List; +import java.util.Map; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +/** Versioned request-owned CAN event artifact; absent in sampled-only legacy histories. */ +@Data +public class CanRecordingSectionDto implements Serializable { + private int version = 1; + private String requestId; + /** Original immutable event-header owner after project import; absent in original V1 recordings. */ + private String sourceRequestId; + private Map> channels; + private List clockAnchors; + private String businessId; + private String fileId; + private String relativePath; + private long byteLength; + private String sha256; + private long batchCount; + private String status; + private String terminationReason; + private String failure; + private List> nativeFinishSnapshots; + + @Data + @NoArgsConstructor + @AllArgsConstructor + public static class ClockAnchor implements Serializable { + private double observationSeconds; + private double recordingSeconds; + } +} diff --git a/apps/backend/crydaq-common/src/main/java/com/opentest/common/model/dto/ChannelDto.java b/apps/backend/crydaq-common/src/main/java/com/opentest/common/model/dto/ChannelDto.java index d6d014af..ff895906 100644 --- a/apps/backend/crydaq-common/src/main/java/com/opentest/common/model/dto/ChannelDto.java +++ b/apps/backend/crydaq-common/src/main/java/com/opentest/common/model/dto/ChannelDto.java @@ -96,6 +96,8 @@ public class ChannelDto extends BaseModel implements Serializable { */ private Integer channelSource; + private String canDefinitionJson; + /** * 通道类型描述 */ @@ -490,6 +492,7 @@ public String getFileName() { @JsonProperty(access = JsonProperty.Access.READ_ONLY) public Double getGain() { + if (ChannelSourceEnum.isCan(channelSource)) return null; // if ("OPENDAQ".equals(protocol)) { // return null; // } diff --git a/apps/backend/crydaq-common/src/main/java/com/opentest/common/model/dto/FlowExecuteSnapshotDataDto.java b/apps/backend/crydaq-common/src/main/java/com/opentest/common/model/dto/FlowExecuteSnapshotDataDto.java index cfc135df..bbec0911 100644 --- a/apps/backend/crydaq-common/src/main/java/com/opentest/common/model/dto/FlowExecuteSnapshotDataDto.java +++ b/apps/backend/crydaq-common/src/main/java/com/opentest/common/model/dto/FlowExecuteSnapshotDataDto.java @@ -99,6 +99,10 @@ public String toJson() { /** Absent for legacy recordings reconstructed from physical dependencies. */ private RecordedWaveformPlanDto recordedWaveformPlan; + /** Frozen irregular CAN inputs and exact request file binding; null for legacy histories. */ + @SavedMeasurementInputSection + private CanRecordingSectionDto canRecording; + /** FFT 已完成带宽准备的工程通道采样率;null 表示尚未准备,空表表示无需调整。 */ private Map fftInputBandwidthSamplingRates; diff --git a/apps/backend/crydaq-common/src/main/java/com/opentest/common/model/dto/RenderDataDto.java b/apps/backend/crydaq-common/src/main/java/com/opentest/common/model/dto/RenderDataDto.java index 5488e6c4..84cff274 100644 --- a/apps/backend/crydaq-common/src/main/java/com/opentest/common/model/dto/RenderDataDto.java +++ b/apps/backend/crydaq-common/src/main/java/com/opentest/common/model/dto/RenderDataDto.java @@ -36,6 +36,11 @@ */ @Data public class RenderDataDto implements Serializable { + public record CanUnitConversion(String sourceUnit, String targetUnit, double scale, double offset) implements Serializable { } + + @JsonInclude(JsonInclude.Include.ALWAYS) + private CanUnitConversion canUnitConversion; + private ResultUnitIdentity resultUnitIdentity; private MathSampleSemantics mathSampleSemantics; diff --git a/apps/backend/crydaq-common/src/main/java/com/opentest/common/model/entity/BoxChannel.java b/apps/backend/crydaq-common/src/main/java/com/opentest/common/model/entity/BoxChannel.java index 6d895447..b50ed0cb 100644 --- a/apps/backend/crydaq-common/src/main/java/com/opentest/common/model/entity/BoxChannel.java +++ b/apps/backend/crydaq-common/src/main/java/com/opentest/common/model/entity/BoxChannel.java @@ -63,6 +63,8 @@ public class BoxChannel extends BaseModel { */ private Integer channelSource; + private String canDefinitionJson; + /** * 自定义名称 */ diff --git a/apps/backend/crydaq-core/src/main/java/com/opentest/core/jni/CanJNIBridge.java b/apps/backend/crydaq-core/src/main/java/com/opentest/core/jni/CanJNIBridge.java index b2d6655d..2dd313fa 100644 --- a/apps/backend/crydaq-core/src/main/java/com/opentest/core/jni/CanJNIBridge.java +++ b/apps/backend/crydaq-core/src/main/java/com/opentest/core/jni/CanJNIBridge.java @@ -60,6 +60,13 @@ public class CanJNIBridge { /** Reads this subscription only; samples include definitionRevision and selectionRevision. */ public native String readCanSignalSubscriptionV1(String receiveId, String subscriptionId, int maxSamples, int timeoutMs); + /** + * Seals this subscription and drains up to 1..256 queued events per call, within the JSON byte budget. + * Repeat until drained=true; complete reports frozen integrity independently. Retains ownership until unsubscribe. + * Requires the optional matching JNI export. Callers must serialize polling, write handoff and finish. + */ + public native String finishAndDrainCanSignalSubscriptionV1(String receiveId, String subscriptionId, int maxSamples); + /** * Clears one business subscription. Others continue; if last and rawFrames=false, * stops/releases port reception while retaining device CAN enable and saved configuration. diff --git a/apps/backend/crydaq-dashboard-standard-processors/src/main/java/com/opentest/dashboard/standard/result/MeasurementResultFileMetadata.java b/apps/backend/crydaq-dashboard-standard-processors/src/main/java/com/opentest/dashboard/standard/result/MeasurementResultFileMetadata.java index 60f9c36c..7a9a6c6e 100644 --- a/apps/backend/crydaq-dashboard-standard-processors/src/main/java/com/opentest/dashboard/standard/result/MeasurementResultFileMetadata.java +++ b/apps/backend/crydaq-dashboard-standard-processors/src/main/java/com/opentest/dashboard/standard/result/MeasurementResultFileMetadata.java @@ -8,6 +8,7 @@ import java.util.Map; import java.util.Objects; import com.opentest.dashboard.api.channel.ChannelMetadata; +import com.opentest.dashboard.api.channel.CanSignalChannel; import com.opentest.dashboard.api.frame.ResultFrame; /** Host-bound metadata for exact frozen measurement file targets. This does not grant input authority. */ @@ -20,20 +21,52 @@ public record Key(String resultCode, String hash, String memberId, String unitX, } } - public record Target(long dashboardResultId, Key key, ChannelMetadata metadata, ResultFileUnitIdentity fileUnitIdentity, ResultUnitIdentity resultUnitIdentityY) { - public Target(long dashboardResultId, Key key, ChannelMetadata metadata, ResultFileUnitIdentity fileUnitIdentity) { - this(dashboardResultId, key, metadata, fileUnitIdentity, null); - } + public sealed interface Source permits SampledSource, CanSource { } + public record SampledSource(ChannelMetadata metadata) implements Source { + public SampledSource { Objects.requireNonNull(metadata); } + } + public record CanSource(CanSignalChannel channel) implements Source { + public CanSource { Objects.requireNonNull(channel); } + } + + public record Target(long dashboardResultId, Key key, ChannelMetadata metadata, + ResultFileUnitIdentity fileUnitIdentity, ResultUnitIdentity resultUnitIdentityY, Source source) { public Target(long dashboardResultId, Key key, ChannelMetadata metadata) { this(dashboardResultId, key, metadata, ResultFileUnitIdentity.Y_ONLY); } + public Target(long dashboardResultId, Key key, ChannelMetadata metadata, ResultFileUnitIdentity identity) { + this(dashboardResultId, key, metadata, identity, null); + } + public Target(long dashboardResultId, Key key, ChannelMetadata metadata, ResultFileUnitIdentity identity, + ResultUnitIdentity resultUnitIdentityY) { + this(dashboardResultId, key, metadata, identity, resultUnitIdentityY, new SampledSource(metadata)); + } + public static Target can(long dashboardResultId, Key key, CanSignalChannel channel, ResultFileUnitIdentity identity) { + return can(dashboardResultId, key, channel, identity, null); + } + public static Target can(long dashboardResultId, Key key, CanSignalChannel channel, ResultFileUnitIdentity identity, + ResultUnitIdentity resultUnitIdentityY) { + return new Target(dashboardResultId, key, null, identity, resultUnitIdentityY, new CanSource(channel)); + } + public ChannelMetadata metadata() { + if (source instanceof SampledSource sampled) return sampled.metadata(); + throw new IllegalArgumentException("CAN file target has no sampled channel metadata"); + } public Target { if (dashboardResultId <= 0) throw new IllegalArgumentException("A genuine measurement result is required"); Objects.requireNonNull(key); Objects.requireNonNull(fileUnitIdentity); - Objects.requireNonNull(metadata); - if (!key.memberId().equals(metadata.vchId())) + Objects.requireNonNull(source); + if (source instanceof SampledSource sampled && !sampled.metadata().equals(metadata) + || source instanceof CanSource && metadata != null) + throw new IllegalArgumentException("Measurement file source disagrees with sampled metadata"); + String member = source instanceof SampledSource sampled ? sampled.metadata().vchId() + : ((CanSource) source).channel().vchId(); + if (!key.memberId().equals(member)) throw new IllegalArgumentException("Measurement file metadata belongs to another member"); + if (source instanceof CanSource can && (!can.channel().units().outputUnits().contains(key.unitY()) + || key.unitX() != null && !"s".equals(key.unitX()))) + throw new IllegalArgumentException("CAN file target requires its frozen units and seconds axis"); } } @@ -60,7 +93,8 @@ public Target require(ResultFrame frame) { var key = new Key(frame.resultCode(), frame.hash(), frame.vchId(), frame.unitX(), frame.unitY()); var target = targets.get(new TargetKey(frame.dashboardResultId(), key)); if (target == null) throw new IllegalArgumentException("Undeclared measurement file target: " + key); - if (target.metadata().mathSampleSemantics() == MathSampleSemantics.RAW_FS_CUSTOM + if (target.source() instanceof SampledSource sampled + && sampled.metadata().mathSampleSemantics() == MathSampleSemantics.RAW_FS_CUSTOM && (target.resultUnitIdentityY() == null || frame.outputMetadata().resultUnitIdentityY() != target.resultUnitIdentityY())) throw new IllegalArgumentException("Custom Math output requires its explicit frozen result unit identity"); return target; diff --git a/apps/backend/crydaq-dashboard-standard-processors/src/main/java/com/opentest/dashboard/standard/result/MeasurementResultFileProjection.java b/apps/backend/crydaq-dashboard-standard-processors/src/main/java/com/opentest/dashboard/standard/result/MeasurementResultFileProjection.java index 269ef02b..25ca8565 100644 --- a/apps/backend/crydaq-dashboard-standard-processors/src/main/java/com/opentest/dashboard/standard/result/MeasurementResultFileProjection.java +++ b/apps/backend/crydaq-dashboard-standard-processors/src/main/java/com/opentest/dashboard/standard/result/MeasurementResultFileProjection.java @@ -14,6 +14,28 @@ public final class MeasurementResultFileProjection { private MeasurementResultFileProjection() { } + public static XYData projectTarget(String logicalFileName, ResultFrame frame, + MeasurementResultFileMetadata.Target target, Layout layout, SensitivityFields sensitivityFields) { + if (target.source() instanceof MeasurementResultFileMetadata.SampledSource sampled) + return project(logicalFileName, frame, sampled.metadata(), layout, sensitivityFields); + double[] x = frame.outputMetadata().outputXCoordinates(); + if (x == null) x = frame.x(); + if (layout != Layout.FRAMED || x == null || x.length != frame.y().length + || frame.xStep() != null || frame.outputMetadata().stepMs() != null + || frame.outputMetadata().persistedHeaderStepMs() != null + || frame.outputMetadata().persistedIndexSampleCount() != null + || frame.outputMetadata().persistedIndexEndTimeMs() != null + || frame.outputMetadata().fullScaleBasis() != null) + throw new IllegalArgumentException("CAN numeric results require irregular explicit X and no sampled metadata"); + double previous = -1; + for (double value : x) { + if (!Double.isFinite(value) || value < 0 || value < previous) + throw new IllegalArgumentException("CAN numeric X must be ordered finite seconds"); + previous = value; + } + return project(logicalFileName, frame, null, layout, sensitivityFields); + } + public static XYData project(String logicalFileName, ResultFrame frame, ChannelMetadata channel, Layout layout, SensitivityFields sensitivityFields) { XYData.Metadata metadata = new XYData.Metadata(); diff --git a/apps/backend/crydaq-dashboard-standard-processors/src/main/java/com/opentest/dashboard/standard/result/PersistResultFileOutput.java b/apps/backend/crydaq-dashboard-standard-processors/src/main/java/com/opentest/dashboard/standard/result/PersistResultFileOutput.java index 31aadb90..ea815ad4 100644 --- a/apps/backend/crydaq-dashboard-standard-processors/src/main/java/com/opentest/dashboard/standard/result/PersistResultFileOutput.java +++ b/apps/backend/crydaq-dashboard-standard-processors/src/main/java/com/opentest/dashboard/standard/result/PersistResultFileOutput.java @@ -1,5 +1,6 @@ package com.opentest.dashboard.standard.result; +import com.opentest.dashboard.api.execution.ResultPersistenceScope; import com.opentest.dashboard.api.result.ResultFileUnitRules; import com.opentest.dashboard.api.channel.ChannelMetadata; import com.opentest.dashboard.api.frame.ResultFrame; @@ -35,7 +36,7 @@ final class PersistResultFileOutput implements PersistResultSinkProcessor.FileOu private final long projectId; private final long dashboardId; private final Long requestId; - private final com.opentest.dashboard.api.execution.ResultPersistenceScope persistenceScope; + private final ResultPersistenceScope persistenceScope; private final Map channels; private final Layout layout; private final ResultFileUnitRules fileUnitRules; @@ -52,10 +53,16 @@ final class PersistResultFileOutput implements PersistResultSinkProcessor.FileOu private int pendingWrites; private Throwable asynchronousFailure; private boolean closed; + private boolean requireCloseCompletion; + + PersistResultSinkProcessor.FileOutput requireCloseCompletion() { + requireCloseCompletion = true; + return this; + } static PersistResultSinkProcessor.FileOutput create(long projectId, long dashboardId, Long requestId, List channels, Layout layout, ResultFileUnitRules fileUnitRules, - com.opentest.dashboard.api.execution.ResultPersistenceScope persistenceScope, + ResultPersistenceScope persistenceScope, SensitivityFields sensitivityFields, FileNaming fileNaming) { return new PersistResultFileOutput(projectId, dashboardId, requestId, channels, layout, fileUnitRules, persistenceScope, sensitivityFields, fileNaming); @@ -76,16 +83,16 @@ public PersistResultFileOutput(long projectId, long dashboardId, long requestId, public PersistResultFileOutput(long projectId, long dashboardId, long requestId, List channels, Layout layout, ResultFileUnitRules fileUnitRules) { this(projectId, dashboardId, requestId, channels, layout, fileUnitRules, - com.opentest.dashboard.api.execution.ResultPersistenceScope.CURRENT_REQUEST); + ResultPersistenceScope.CURRENT_REQUEST); } public PersistResultFileOutput(long projectId, long dashboardId, Long requestId, List channels, Layout layout, ResultFileUnitRules fileUnitRules, - com.opentest.dashboard.api.execution.ResultPersistenceScope persistenceScope) { + ResultPersistenceScope persistenceScope) { this.persistenceScope = Objects.requireNonNull(persistenceScope); - if (persistenceScope == com.opentest.dashboard.api.execution.ResultPersistenceScope.NONE) + if (persistenceScope == ResultPersistenceScope.NONE) throw new IllegalArgumentException("Continuous display cannot create persistence sinks"); - if (persistenceScope == com.opentest.dashboard.api.execution.ResultPersistenceScope.CURRENT_REQUEST) + if (persistenceScope == ResultPersistenceScope.CURRENT_REQUEST) Objects.requireNonNull(requestId, "requestId"); this.layout = Objects.requireNonNull(layout, "layout"); this.fileUnitRules = Objects.requireNonNull(fileUnitRules, "fileUnitRules"); @@ -109,14 +116,14 @@ public PersistResultFileOutput(long projectId, long dashboardId, Long requestId, public PersistResultFileOutput(long projectId, long dashboardId, Long requestId, List channels, Layout layout, ResultFileUnitRules fileUnitRules, - com.opentest.dashboard.api.execution.ResultPersistenceScope persistenceScope, SensitivityFields sensitivityFields) { + ResultPersistenceScope persistenceScope, SensitivityFields sensitivityFields) { this(projectId, dashboardId, requestId, channels, layout, fileUnitRules, persistenceScope); this.sensitivityFields = Objects.requireNonNull(sensitivityFields); } public PersistResultFileOutput(long projectId, long dashboardId, Long requestId, List channels, Layout layout, ResultFileUnitRules fileUnitRules, - com.opentest.dashboard.api.execution.ResultPersistenceScope persistenceScope, + ResultPersistenceScope persistenceScope, SensitivityFields sensitivityFields, FileNaming fileNaming) { this(projectId,dashboardId,requestId,channels,layout,fileUnitRules,persistenceScope,sensitivityFields); this.fileNaming = Objects.requireNonNull(fileNaming); @@ -144,7 +151,7 @@ public void accept(ResultFrame frame) { String logicalFileName; String businessId; if (fileNaming == FileNaming.FLAT_WITH_ORIGINAL_ID) { - Long identityRequest = persistenceScope == com.opentest.dashboard.api.execution.ResultPersistenceScope.SHARED_DASHBOARD + Long identityRequest = persistenceScope == ResultPersistenceScope.SHARED_DASHBOARD ? null : requestId; String originalId = identityRequest + "_" + dashboardId + "_" + frame.vchId() + "_" + frame.hash() + "_" + frame.resultCode() + "_0_0_" @@ -216,7 +223,7 @@ public void close() { CompletionStage> completion = fileManager.releaseFileConsumer(file.getKey()); ArtifactState artifact = artifactStates.get(file.getValue()); - if (persistenceScope == com.opentest.dashboard.api.execution.ResultPersistenceScope.SHARED_DASHBOARD) { + if (requireCloseCompletion || persistenceScope == ResultPersistenceScope.SHARED_DASHBOARD) { // Publication, not merely writer close, is the success barrier for a shared File. completion.thenAccept(physicalFiles -> notifyCompletedStrict(file.getValue(), physicalFiles, artifact)) @@ -245,8 +252,10 @@ public void close() { } private XYData toXYData(String logicalFileName, ResultFrame frame) { - ChannelMetadata channel = measurementTargets == null ? channels.get(frame.vchId()) - : measurementTargets.require(frame).metadata(); + if (measurementTargets != null) + return MeasurementResultFileProjection.projectTarget(logicalFileName, frame, + measurementTargets.require(frame), layout, sensitivityFields); + ChannelMetadata channel = channels.get(frame.vchId()); return MeasurementResultFileProjection.project(logicalFileName, frame, channel, layout, sensitivityFields); } diff --git a/apps/backend/crydaq-dashboard-standard-processors/src/main/java/com/opentest/dashboard/standard/result/PersistResultSinkProcessor.java b/apps/backend/crydaq-dashboard-standard-processors/src/main/java/com/opentest/dashboard/standard/result/PersistResultSinkProcessor.java index af8471e3..36a9a841 100644 --- a/apps/backend/crydaq-dashboard-standard-processors/src/main/java/com/opentest/dashboard/standard/result/PersistResultSinkProcessor.java +++ b/apps/backend/crydaq-dashboard-standard-processors/src/main/java/com/opentest/dashboard/standard/result/PersistResultSinkProcessor.java @@ -1,5 +1,6 @@ package com.opentest.dashboard.standard.result; +import com.opentest.dashboard.api.execution.ResultPersistenceScope; import com.opentest.dashboard.api.result.ResultFileUnitRules; import com.opentest.dashboard.api.channel.ChannelMetadata; import com.opentest.dashboard.api.frame.ResultFrame; @@ -28,7 +29,7 @@ public enum SensitivityFields { PRIMARY_ONLY, PRIMARY_AND_VIBRATION } private final long projectId; private final long dashboardId; private final Long requestId; - private final com.opentest.dashboard.api.execution.ResultPersistenceScope persistenceScope; + private final ResultPersistenceScope persistenceScope; private final Map channels; private final Layout layout; private final ResultFileUnitRules fileUnitRules; @@ -50,16 +51,16 @@ public PersistResultSinkProcessor(long projectId, long dashboardId, long request public PersistResultSinkProcessor(long projectId, long dashboardId, long requestId, List channels, Layout layout, ResultFileUnitRules fileUnitRules) { this(projectId, dashboardId, requestId, channels, layout, fileUnitRules, - com.opentest.dashboard.api.execution.ResultPersistenceScope.CURRENT_REQUEST); + ResultPersistenceScope.CURRENT_REQUEST); } public PersistResultSinkProcessor(long projectId, long dashboardId, Long requestId, List channels, Layout layout, ResultFileUnitRules fileUnitRules, - com.opentest.dashboard.api.execution.ResultPersistenceScope persistenceScope) { + ResultPersistenceScope persistenceScope) { this.persistenceScope = Objects.requireNonNull(persistenceScope); - if (persistenceScope == com.opentest.dashboard.api.execution.ResultPersistenceScope.NONE) + if (persistenceScope == ResultPersistenceScope.NONE) throw new IllegalArgumentException("Continuous display cannot create persistence sinks"); - if (persistenceScope == com.opentest.dashboard.api.execution.ResultPersistenceScope.CURRENT_REQUEST) + if (persistenceScope == ResultPersistenceScope.CURRENT_REQUEST) Objects.requireNonNull(requestId, "requestId"); this.layout = Objects.requireNonNull(layout, "layout"); this.fileUnitRules = Objects.requireNonNull(fileUnitRules, "fileUnitRules"); @@ -83,14 +84,14 @@ public PersistResultSinkProcessor(long projectId, long dashboardId, Long request public PersistResultSinkProcessor(long projectId, long dashboardId, Long requestId, List channels, Layout layout, ResultFileUnitRules fileUnitRules, - com.opentest.dashboard.api.execution.ResultPersistenceScope persistenceScope, SensitivityFields sensitivityFields) { + ResultPersistenceScope persistenceScope, SensitivityFields sensitivityFields) { this(projectId, dashboardId, requestId, channels, layout, fileUnitRules, persistenceScope); this.sensitivityFields = Objects.requireNonNull(sensitivityFields); } public PersistResultSinkProcessor(long projectId, long dashboardId, Long requestId, List channels, Layout layout, ResultFileUnitRules fileUnitRules, - com.opentest.dashboard.api.execution.ResultPersistenceScope persistenceScope, + ResultPersistenceScope persistenceScope, SensitivityFields sensitivityFields, FileNaming fileNaming) { this(projectId,dashboardId,requestId,channels,layout,fileUnitRules,persistenceScope,sensitivityFields); this.fileNaming = Objects.requireNonNull(fileNaming); @@ -115,7 +116,15 @@ public PersistResultSinkProcessor(long projectId, long dashboardId, Long request @Override public void close() { if (output != null) output.close(); } - interface FileOutput { + /** Host-owned irregular inputs reuse the same file writer without manufacturing sampled pipeline inputs. */ + public static FileOutput createFileOutput(long projectId, long dashboardId, Long requestId, + List channels, Layout layout, ResultFileUnitRules fileUnitRules, + ResultPersistenceScope persistenceScope) { + return new PersistResultFileOutput(projectId, dashboardId, requestId, channels, layout, fileUnitRules, + persistenceScope, SensitivityFields.PRIMARY_AND_VIBRATION, FileNaming.DIRECTORY_FROM_FILE).requireCloseCompletion(); + } + + public interface FileOutput extends AutoCloseable { void start(com.opentest.dashboard.api.pipeline.ProcessorContext context, CrybinArtifactRegistrar registrar); void accept(ResultFrame frame); void close(); diff --git a/apps/backend/crydaq-dashboard-standard-processors/src/test/java/com/opentest/dashboard/standard/result/CanMeasurementResultFileTest.java b/apps/backend/crydaq-dashboard-standard-processors/src/test/java/com/opentest/dashboard/standard/result/CanMeasurementResultFileTest.java new file mode 100644 index 00000000..37d2491d --- /dev/null +++ b/apps/backend/crydaq-dashboard-standard-processors/src/test/java/com/opentest/dashboard/standard/result/CanMeasurementResultFileTest.java @@ -0,0 +1,89 @@ +package com.opentest.dashboard.standard.result; + +import com.opentest.dashboard.api.channel.CanPortBinding; +import com.opentest.dashboard.api.channel.CanSignalChannel; +import com.opentest.dashboard.api.channel.CanSignalQuantity; +import com.opentest.dashboard.api.channel.CanSignalUnits; +import com.opentest.dashboard.api.channel.ChannelMetadata; +import com.opentest.dashboard.api.channel.SignalType; +import com.opentest.dashboard.api.frame.ResultFrame; +import com.opentest.dashboard.api.result.ResultFileUnitIdentity; +import com.opentest.dashboard.standard.result.PersistResultSinkProcessor.Layout; +import com.opentest.dashboard.standard.result.PersistResultSinkProcessor.SensitivityFields; +import java.util.List; +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertInstanceOf; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class CanMeasurementResultFileTest { + private static final MeasurementResultFileMetadata.Key KEY = new MeasurementResultFileMetadata.Key("CAN Viewer", "hash", "can", "s", "V"); + private static CanSignalChannel channel() { + return new CanSignalChannel("can", "1", "2", "Frozen volts", 1, + new CanPortBinding("3", "CAN", "serial", "CAN0"), "{\"version\":1}", + new CanSignalUnits(CanSignalQuantity.VOLTAGE, "mV", "V", null), "fingerprint"); + } + + @Test void scalarCanValueKeepsNullAxisDeclarationAndPersistsObservedSecondsWithoutSamplingFacts() { + var key = new MeasurementResultFileMetadata.Key("CAN Value", "hash", "can", null, "V"); + var target = MeasurementResultFileMetadata.Target.can(7, key, channel(), ResultFileUnitIdentity.Y_ONLY); + var base = ResultFrame.explicitX("CAN Value", "hash", "can", null, "V", + new double[]{0.137}, new double[]{Double.NaN}, 137, null); + var frame = base.withDashboardResultId(7); base.release(); + try { + assertEquals(target, new MeasurementResultFileMetadata(List.of(target)).require(frame)); + var data = MeasurementResultFileProjection.projectTarget("value", frame, target, Layout.FRAMED, + SensitivityFields.PRIMARY_AND_VIBRATION); + assertArrayEquals(new double[]{0.137}, data.getXDataAsDoubleArray()); + assertTrue(Double.isNaN(data.getYDataAsDoubleArray()[0])); + assertNull(data.getMetadata().getSamplingRate()); + assertNull(frame.unitX()); + } finally { frame.release(); } + } + + @Test void typedCanTargetProjectsIrregularSecondsAndNanGapsWithoutAnySamplingMetadata() { + var target = MeasurementResultFileMetadata.Target.can(7, KEY, channel(), ResultFileUnitIdentity.X_AND_Y); + var targets = new MeasurementResultFileMetadata(List.of(target)); + var base = ResultFrame.explicitX("CAN Viewer", "hash", "can", "s", "V", + new double[]{0, 0.017, 0.103}, new double[]{1, Double.NaN, 3}, 103, null); + var frame = base.withDashboardResultId(7); base.release(); + try { + assertEquals(target, targets.require(frame)); + assertInstanceOf(MeasurementResultFileMetadata.CanSource.class, target.source()); + assertThrows(IllegalArgumentException.class, target::metadata); + var projected = MeasurementResultFileProjection.projectTarget("can", frame, target, Layout.FRAMED, + SensitivityFields.PRIMARY_AND_VIBRATION); + assertArrayEquals(frame.x(), projected.getXDataAsDoubleArray()); + assertTrue(Double.isNaN(projected.getYDataAsDoubleArray()[1])); + assertNull(projected.getMetadata().getSamplingRate()); + assertNull(projected.getMetadata().getSensitivity()); + assertNull(projected.getMetadata().getVp()); + assertThrows(IllegalArgumentException.class, () -> MeasurementResultFileProjection.projectTarget( + "can", frame, target, Layout.CONTINUOUS, SensitivityFields.PRIMARY_AND_VIBRATION)); + } finally { frame.release(); } + } + + @Test void legacyNullConstructorsStillRejectAndPositiveSamplingContractRemains() { + assertThrows(NullPointerException.class, () -> new MeasurementResultFileMetadata.Target(7, KEY, null)); + assertThrows(NullPointerException.class, () -> new MeasurementResultFileMetadata.Target(7, KEY, null, ResultFileUnitIdentity.Y_ONLY)); + assertThrows(IllegalArgumentException.class, () -> new ChannelMetadata("can", SignalType.VOLTAGE, 0, "V", null, null, null)); + var sampled = new ChannelMetadata("can", SignalType.VOLTAGE, 1000, "V", 1D, 2D, null); + assertEquals(sampled, new MeasurementResultFileMetadata.Target(7, KEY, sampled).metadata()); + } + + @Test void irregularTargetRejectsWrongUnitMemberAndMissingExplicitX() { + assertThrows(IllegalArgumentException.class, () -> MeasurementResultFileMetadata.Target.can(7, + new MeasurementResultFileMetadata.Key("CAN Viewer", "hash", "other", "s", "V"), channel(), ResultFileUnitIdentity.Y_ONLY)); + assertThrows(IllegalArgumentException.class, () -> MeasurementResultFileMetadata.Target.can(7, + new MeasurementResultFileMetadata.Key("CAN Viewer", "hash", "can", "s", "rpm"), channel(), ResultFileUnitIdentity.Y_ONLY)); + var frame = ResultFrame.withoutX("CAN Viewer", "hash", "can", null, "V", new double[]{1}, 0, null); + try { + var target = MeasurementResultFileMetadata.Target.can(7, KEY, channel(), ResultFileUnitIdentity.Y_ONLY); + assertThrows(IllegalArgumentException.class, () -> MeasurementResultFileProjection.projectTarget("can", frame, + target, Layout.FRAMED, SensitivityFields.PRIMARY_AND_VIBRATION)); + } finally { frame.release(); } + } +} diff --git a/apps/backend/crydaq-server/src/main/java/com/opentest/controller/BoxChannelController.java b/apps/backend/crydaq-server/src/main/java/com/opentest/controller/BoxChannelController.java index 6093e1ec..16f6d7c2 100644 --- a/apps/backend/crydaq-server/src/main/java/com/opentest/controller/BoxChannelController.java +++ b/apps/backend/crydaq-server/src/main/java/com/opentest/controller/BoxChannelController.java @@ -6,6 +6,7 @@ import com.opentest.common.enums.LocalPermissionCodeEnum; import com.opentest.common.model.dto.BoxChannelBatchResultDto; import com.opentest.common.model.dto.BoxChannelDto; +import com.opentest.common.model.dto.CanChannelSaveRequestDto; import com.opentest.common.model.dto.MathChannelSaveRequestDto; import com.opentest.common.model.dto.DeviceDto; import com.opentest.common.model.dto.ProjectChannelBatchModifyRequestDto; @@ -27,6 +28,7 @@ import com.opentest.common.model.validation.ValidationQuery; import com.opentest.common.result.CommonResult; import com.opentest.service.BoxChannelService; +import com.opentest.service.can.CanProjectChannelService; import com.opentest.service.teds.TedsHotPlugApplicationService; import com.opentest.service.virtualchannel.VirtualChannelConfigService; import com.fasterxml.jackson.databind.JsonNode; @@ -51,6 +53,8 @@ public class BoxChannelController extends BaseController { @Resource private BoxChannelService boxChannelService; @Resource + private CanProjectChannelService canProjectChannelService; + @Resource private VirtualChannelConfigService virtualChannelConfigService; @Resource private TedsHotPlugApplicationService tedsHotPlugApplicationService; @@ -123,6 +127,18 @@ public CommonResult modifySensorBinding(@RequestBody BoxChannelDto dto) return success(boxChannelService.modifySensorBinding(dto)); } + @PostMapping("/can/save") + @RequireLocalPermission(LocalPermissionCodeEnum.HARDWARE_CHANNEL_SETUP) + public CommonResult saveCanChannel(@RequestBody CanChannelSaveRequestDto dto) { + return success(canProjectChannelService.save(dto)); + } + + @DeleteMapping("/can/{boxChannelId}") + @RequireLocalPermission(LocalPermissionCodeEnum.HARDWARE_CHANNEL_SETUP) + public CommonResult deleteCanChannel(@PathVariable Long boxChannelId) { + return success(canProjectChannelService.delete(boxChannelId)); + } + @PostMapping("/math/save") @RequireLocalPermission(LocalPermissionCodeEnum.HARDWARE_CHANNEL_SETUP) public CommonResult saveMathChannel(@RequestBody MathChannelSaveRequestDto dto) { diff --git a/apps/backend/crydaq-server/src/main/java/com/opentest/controller/CanController.java b/apps/backend/crydaq-server/src/main/java/com/opentest/controller/CanController.java new file mode 100644 index 00000000..b3dbabf6 --- /dev/null +++ b/apps/backend/crydaq-server/src/main/java/com/opentest/controller/CanController.java @@ -0,0 +1,77 @@ +package com.opentest.controller; + +import cn.hutool.json.JSONObject; +import cn.hutool.json.JSONUtil; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.node.ObjectNode; +import com.opentest.common.result.CommonResult; +import com.opentest.common.utils.LocaleUtil; +import com.opentest.service.can.CanOperationException; +import com.opentest.service.can.CanService; +import jakarta.validation.Valid; +import jakarta.validation.constraints.NotNull; +import org.springframework.web.bind.annotation.ExceptionHandler; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.PathVariable; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestParam; +import org.springframework.web.bind.annotation.RestController; + +@RestController +@RequestMapping("/v1/device/{deviceId}/can") +public class CanController { + public record EnableRequest(@NotNull Boolean enabled) { } + private static final ObjectMapper JSON = new ObjectMapper(); + private final CanService can; + + public CanController(CanService can) { this.can = can; } + + @GetMapping("/capabilities") + public CommonResult capabilities(@PathVariable Long deviceId) { + return response(can.capabilities(deviceId)); + } + @PostMapping("/enabled") + public CommonResult enabled(@PathVariable Long deviceId, @Valid @RequestBody EnableRequest request) { + return response(can.enable(deviceId, request.enabled())); + } + @GetMapping("/ports/{portId}") + public CommonResult status(@PathVariable Long deviceId, @PathVariable String portId) { + return response(can.status(deviceId, portId)); + } + @PostMapping("/ports/{portId}/configuration") + public CommonResult configuration(@PathVariable Long deviceId, @PathVariable String portId, + @RequestBody ObjectNode configuration) { + return response(can.configuration(deviceId, portId, JSONUtil.parseObj(configuration.toString()))); + } + @PostMapping("/ports/{portId}/start") + public CommonResult start(@PathVariable Long deviceId, @PathVariable String portId) { + return response(can.start(deviceId, portId)); + } + @PostMapping("/ports/{portId}/stop") + public CommonResult stop(@PathVariable Long deviceId, @PathVariable String portId) { + return response(can.stop(deviceId, portId)); + } + @GetMapping("/ports/{portId}/frames") + public CommonResult frames(@PathVariable Long deviceId, @PathVariable String portId, + @RequestParam(defaultValue = "0") String after) { + return response(can.frames(deviceId, portId, after)); + } + private CommonResult response(JSONObject data) { + try { return CommonResult.success(JSON.readTree(data.toString())); } + catch (JsonProcessingException error) { + throw new CanOperationException(13103019, "can.error.invalidResponse"); + } + } + @ExceptionHandler(CanOperationException.class) + public CommonResult failed(CanOperationException error) { + return CommonResult.error(error.code(), LocaleUtil.getDescWithKey(error.messageKey())); + } + @ExceptionHandler(LinkageError.class) + public CommonResult unavailable(LinkageError error) { + return CommonResult.error(13103001, LocaleUtil.getDescWithKey("can.error.nativeUnavailable")); + } +} diff --git a/apps/backend/crydaq-server/src/main/java/com/opentest/controller/CanDbcController.java b/apps/backend/crydaq-server/src/main/java/com/opentest/controller/CanDbcController.java new file mode 100644 index 00000000..ac645714 --- /dev/null +++ b/apps/backend/crydaq-server/src/main/java/com/opentest/controller/CanDbcController.java @@ -0,0 +1,40 @@ +package com.opentest.controller; + +import com.fasterxml.jackson.databind.JsonNode; +import com.opentest.common.annotation.RequireLocalPermission; +import com.opentest.common.enums.LocalPermissionCodeEnum; +import com.opentest.common.result.CommonResult; +import com.opentest.service.can.CanDbcService; +import com.opentest.service.can.CanProjectChannelService; +import java.io.IOException; +import java.io.InputStream; +import org.springframework.http.MediaType; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestParam; +import org.springframework.web.bind.annotation.RestController; +import org.springframework.web.multipart.MultipartFile; + +@RestController +@RequestMapping("/v1/project-channel/can/dbc") +public class CanDbcController { + private final CanDbcService dbc; + + public CanDbcController(CanDbcService dbc) { this.dbc = dbc; } + + @PostMapping(value = "/parse", consumes = MediaType.MULTIPART_FORM_DATA_VALUE) + @RequireLocalPermission(LocalPermissionCodeEnum.HARDWARE_CHANNEL_SETUP) + public CommonResult parse(@RequestParam("file") MultipartFile file) { + try { CanDbcService.requireFileName(file.getOriginalFilename()); } + catch (IllegalArgumentException error) { + throw CanProjectChannelService.invalid("dbcDocument", "The saved DBC file or selection is invalid."); + } + if (file.getSize() == 0 || file.getSize() > CanDbcService.MAX_BYTES) + throw CanProjectChannelService.invalid("dbcSize", "DBC files must contain 1 to 5,000,000 bytes."); + try (InputStream input = file.getInputStream()) { + return CommonResult.success(dbc.parse(input.readNBytes(CanDbcService.MAX_BYTES + 1))); + } catch (IOException error) { + throw CanProjectChannelService.invalid("dbcRead", "The DBC file could not be read."); + } + } +} diff --git a/apps/backend/crydaq-server/src/main/java/com/opentest/controller/CanRawFramesController.java b/apps/backend/crydaq-server/src/main/java/com/opentest/controller/CanRawFramesController.java new file mode 100644 index 00000000..bf2ec064 --- /dev/null +++ b/apps/backend/crydaq-server/src/main/java/com/opentest/controller/CanRawFramesController.java @@ -0,0 +1,42 @@ +package com.opentest.controller; + +import cn.hutool.json.JSONObject; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.opentest.common.result.CommonResult; +import com.opentest.common.utils.LocaleUtil; +import com.opentest.service.can.CanOperationException; +import com.opentest.service.can.CanService; +import org.springframework.web.bind.annotation.ExceptionHandler; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +@RestController +@RequestMapping("/v1/can/raw-frames") +public class CanRawFramesController { + private static final ObjectMapper JSON = new ObjectMapper(); + private final CanService can; + + public CanRawFramesController(CanService can) { this.can = can; } + + @GetMapping("/sources") + public CommonResult sources() { + JSONObject data = can.rawSources(); + try { return CommonResult.success(JSON.readTree(data.toString())); } + catch (JsonProcessingException error) { + throw new CanOperationException(13103019, "can.error.invalidResponse"); + } + } + + @ExceptionHandler(CanOperationException.class) + public CommonResult failed(CanOperationException error) { + return CommonResult.error(error.code(), LocaleUtil.getDescWithKey(error.messageKey())); + } + + @ExceptionHandler(LinkageError.class) + public CommonResult unavailable(LinkageError error) { + return CommonResult.error(13103001, LocaleUtil.getDescWithKey("can.error.nativeUnavailable")); + } +} diff --git a/apps/backend/crydaq-server/src/main/java/com/opentest/controller/CanRawRecordingController.java b/apps/backend/crydaq-server/src/main/java/com/opentest/controller/CanRawRecordingController.java new file mode 100644 index 00000000..8277ab05 --- /dev/null +++ b/apps/backend/crydaq-server/src/main/java/com/opentest/controller/CanRawRecordingController.java @@ -0,0 +1,101 @@ +package com.opentest.controller; + +import cn.hutool.json.JSONObject; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.opentest.common.result.CommonResult; +import com.opentest.common.utils.LocaleUtil; +import com.opentest.service.can.CanOperationException; +import com.opentest.service.can.CanRawRecordingStore; +import com.opentest.service.can.CanService; +import jakarta.servlet.http.HttpServletResponse; +import org.springframework.http.HttpHeaders; +import org.springframework.web.bind.annotation.DeleteMapping; +import org.springframework.web.bind.annotation.ExceptionHandler; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.PathVariable; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestParam; +import org.springframework.web.bind.annotation.RestController; + +import java.io.IOException; +import java.nio.charset.StandardCharsets; + +@RestController +public class CanRawRecordingController { + private static final String RECORDINGS = "/v1/can/raw-frames/recordings"; + private static final String PORT = "/v1/device/{deviceId}/can/ports/{portId}/recording"; + private static final ObjectMapper JSON = new ObjectMapper(); + private final CanService can; + private final CanRawRecordingStore store; + + public CanRawRecordingController(CanService can, CanRawRecordingStore store) { + this.can = can; + this.store = store; + } + + @PostMapping(PORT + "/start") + public CommonResult start(@PathVariable Long deviceId, @PathVariable String portId) { + return response(can.startRecording(deviceId, portId)); + } + + @PostMapping(PORT + "/stop") + public CommonResult stop(@PathVariable Long deviceId, @PathVariable String portId) { + return response(can.stopRecording(deviceId, portId)); + } + + @GetMapping(RECORDINGS) + public CommonResult history() { return response(store.history()); } + + @GetMapping(RECORDINGS + "/{id}/frames") + public CommonResult preview(@PathVariable String id, + @RequestParam(defaultValue = "0") String offset, + @RequestParam(defaultValue = "1000") String limit) { + try { + if (!offset.matches("0|[1-9][0-9]*") || !limit.matches("[1-9][0-9]*")) throw new NumberFormatException(); + return response(store.preview(id, Long.parseLong(offset), Integer.parseInt(limit))); + } catch (NumberFormatException error) { + throw new CanOperationException(CanRawRecordingStore.INVALID_REQUEST, "can.recording.error.request"); + } + } + + @GetMapping(RECORDINGS + "/{id}/csv") + public void csv(@PathVariable String id, HttpServletResponse response) throws IOException { + store.preview(id, 0, 1); + response.setCharacterEncoding(StandardCharsets.UTF_8.name()); + response.setContentType("text/csv"); + response.setHeader(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"can-raw-" + id + ".csv\""); + response.setHeader(HttpHeaders.CACHE_CONTROL, "no-store"); + try { + store.csv(id, response.getWriter()); + } catch (CanOperationException error) { + if (!response.isCommitted()) response.reset(); + throw error; + } + } + + @DeleteMapping(RECORDINGS + "/{id}") + public CommonResult delete(@PathVariable String id) { + store.delete(id); + return CommonResult.success(null); + } + + private CommonResult response(JSONObject data) { + try { return CommonResult.success(JSON.readTree(data.toString())); } + catch (JsonProcessingException error) { + throw new CanOperationException(13103019, "can.error.invalidResponse"); + } + } + + @ExceptionHandler(CanOperationException.class) + public CommonResult failed(CanOperationException error, HttpServletResponse response) { + if (response.isCommitted()) return null; + return CommonResult.error(error.code(), LocaleUtil.getDescWithKey(error.messageKey())); + } + + @ExceptionHandler(LinkageError.class) + public CommonResult unavailable(LinkageError error) { + return CommonResult.error(13103001, LocaleUtil.getDescWithKey("can.error.nativeUnavailable")); + } +} diff --git a/apps/backend/crydaq-server/src/main/java/com/opentest/dbmigration/V2_5_0_20261111120000__repair_math_sample_columns.java b/apps/backend/crydaq-server/src/main/java/com/opentest/dbmigration/V2_5_0_20261111120000__repair_math_sample_columns.java new file mode 100644 index 00000000..0e3ef34c --- /dev/null +++ b/apps/backend/crydaq-server/src/main/java/com/opentest/dbmigration/V2_5_0_20261111120000__repair_math_sample_columns.java @@ -0,0 +1,62 @@ +package com.opentest.dbmigration; + +import com.opentest.common.utils.SimpleVersionManager; +import org.springframework.stereotype.Component; + +import java.sql.Connection; +import java.sql.SQLException; +import java.sql.Savepoint; +import java.util.HashSet; +import java.util.Locale; +import java.util.Set; + +@Component +public class V2_5_0_20261111120000__repair_math_sample_columns + implements SimpleVersionManager.JavaMigration { + + @Override + public void migrate(Connection connection) throws SQLException { + boolean autoCommit = connection.getAutoCommit(); + Savepoint savepoint = autoCommit ? null : connection.setSavepoint(); + if (autoCommit) { + connection.setAutoCommit(false); + } + try { + Set columns = new HashSet<>(); + try (var statement = connection.createStatement(); + var rows = statement.executeQuery("PRAGMA table_info(box_channel)")) { + while (rows.next()) { + columns.add(rows.getString("name").toLowerCase(Locale.ROOT)); + } + } + try (var statement = connection.createStatement()) { + if (!columns.contains("math_sample_semantics")) { + statement.execute("ALTER TABLE box_channel ADD COLUMN math_sample_semantics TEXT"); + } + if (!columns.contains("math_vp")) { + statement.execute("ALTER TABLE box_channel ADD COLUMN math_vp REAL"); + } + } + if (autoCommit) { + connection.commit(); + } else { + connection.releaseSavepoint(savepoint); + } + } catch (SQLException failure) { + try { + if (autoCommit) { + connection.rollback(); + } else { + connection.rollback(savepoint); + } + } catch (SQLException rollbackFailure) { + failure.addSuppressed(rollbackFailure); + } + throw failure; + } finally { + if (autoCommit) { + connection.setAutoCommit(true); + } + } + } +} diff --git a/apps/backend/crydaq-server/src/main/resources/db/migration/V2.5.0_20261110160000__add_project_can_definition.sql b/apps/backend/crydaq-server/src/main/resources/db/migration/V2.5.0_20261110160000__add_project_can_definition.sql new file mode 100644 index 00000000..aa2b2d45 --- /dev/null +++ b/apps/backend/crydaq-server/src/main/resources/db/migration/V2.5.0_20261110160000__add_project_can_definition.sql @@ -0,0 +1 @@ +ALTER TABLE box_channel ADD COLUMN can_definition_json TEXT; diff --git a/apps/backend/crydaq-server/src/main/resources/lang/messages.properties b/apps/backend/crydaq-server/src/main/resources/lang/messages.properties index aa479cd6..f2fface9 100644 --- a/apps/backend/crydaq-server/src/main/resources/lang/messages.properties +++ b/apps/backend/crydaq-server/src/main/resources/lang/messages.properties @@ -1524,3 +1524,68 @@ error.rt60.frequency.nyquist=RT60 highest selected band upper edge {} Hz reaches error.rt60.evaluation.invalid=RT60 evaluation ranges {} are invalid: {}. Select one or more distinct values from T10, T15, T20, T30. error.rt60.spl.averaging.samples=RT60 SPL display averaging time must contain at least two samples. + +can.error.nativeFailure=CAN 操作失败,请检查端口配置、设备连接及接收状态。 +can.error.invalidResponse=CAN 返回的数据无效,请检查设备插件与 Native 库版本。 +can.error.saveFailed=CAN 参数已应用,但配置保存失败,请重新应用并保存。 +can.error.deviceUnavailable=未找到有效的 CAN 设备。 +can.error.portUnavailable=当前设备没有可用的指定 CAN 端口。 +can.error.busy=CAN 端口仍在使用或释放中,请先停止对应业务。 +can.error.sourceFailed=CAN 接收已异常结束,请先停止并释放本次接收。 +can.error.invalidCursor=CAN 报文读取位置无效。 +can.error.nativeUnavailable=当前 Native 库不提供所需 CAN 接口,请更新运行材料。 +error.jni.native.13103001=CAN 参数无效。 +error.jni.native.13103002=CAN 当前状态不允许此操作,请检查总开关、端口配置及接收状态。 +error.jni.native.13103003=CAN 接收标识无效或已释放。 +error.jni.native.13103004=当前设备不支持所需 CAN 能力。 +error.jni.native.13103005=CAN 帧格式不受支持。 +error.jni.native.13103006=未找到 CAN 设备。 +error.jni.native.13103007=CAN 设备已断开。 +error.jni.native.13103008=CAN 端口正在使用或释放中。 +error.jni.native.13103009=CAN 操作超时。 +error.jni.native.13103010=CAN 接收缓冲区溢出。 +error.jni.native.13103011=CAN 缓冲区数据不足。 +error.jni.native.13103012=CAN 插件主版本不兼容。 +error.jni.native.13103013=CAN 插件次版本不受支持。 +error.jni.native.13103014=CAN 插件结构大小不兼容。 +error.jni.native.13103015=CAN 插件缺少必需接口。 +error.jni.native.13103016=CAN 返回缓冲区过小。 +error.jni.native.13103017=CAN 操作已中断。 +error.jni.native.13103018=CAN 设备执行操作失败。 +error.jni.native.13103019=CAN 插件返回或执行异常。 +error.jni.native.13103020=没有执行 CAN 操作的权限。 +error.jni.native.13103021=CAN 内存分配失败。 +error.jni.native.13103022=CAN 操作发生异常。 +error.jni.native.13103023=CAN JNI 接口执行失败。 +error.jni.native.13103024=CAN 返回结果编码失败。 + +# CAN project channel persistence +can.project.error.required=\u8bf7\u63d0\u4f9b\u5de5\u7a0b\u3001\u8bbe\u5907\u53ca\u901a\u9053\u540d\u79f0\u3002 +can.project.error.scope=CAN \u5de5\u7a0b\u6216\u8bbe\u5907\u7ed1\u5b9a\u4e0d\u53ef\u7528\u3002 +can.project.error.fields=CAN \u901a\u9053\u4ec5\u5141\u8bb8\u4fee\u6539\u5de5\u7a0b\u8eab\u4efd\u3001\u540d\u79f0\u3001\u989c\u8272\u53ca CAN \u5b9a\u4e49\u5b57\u6bb5\u3002 +can.project.error.definition=\u4fdd\u5b58\u7684 CAN \u5b9a\u4e49\u65e0\u6548\u3002 +can.project.error.units=CAN \u4fe1\u53f7\u7c7b\u578b\u3001\u6e90\u5355\u4f4d\u3001\u8f93\u51fa\u5355\u4f4d\u6216 Tacho PPR \u65e0\u6548\u3002 +can.project.error.nativeUnavailable=\u5f53\u524d Native \u5e93\u65e0\u6cd5\u6821\u9a8c CAN \u4fe1\u53f7\u5b9a\u4e49\u3002 +can.project.error.nativeResponse=Native \u8fd4\u56de\u7684 CAN \u6821\u9a8c\u7ed3\u679c\u4e0d\u5b8c\u6574\u3002 +can.project.error.rule=CAN \u89e3\u7801\u89c4\u5219\u65e0\u6548\u6216\u6682\u4e0d\u652f\u6301\u3002 +can.project.error.mathInput=CAN \u4fe1\u53f7\u4e0d\u80fd\u4f5c\u4e3a\u6570\u5b66\u901a\u9053\u8f93\u5165\u3002 +can.project.error.ambiguousDevice=CAN \u8bbe\u5907\u8eab\u4efd\u4e0d\u552f\u4e00\uff0c\u8bf7\u660e\u786e\u9009\u62e9\u8bbe\u5907\u3002 +error.can.recorder.unavailable=CAN \u5f55\u5236\u4e0e\u5386\u53f2\u529f\u80fd\u6682\u4e0d\u53ef\u7528\uff0c\u8bf7\u4f7f\u7528\u5b9e\u65f6 Monitor \u6216\u79fb\u9664 CAN \u8f93\u5165\u3002 +can.error.invalidDefinition=\u624b\u52a8 CAN \u4fe1\u53f7\u5b9a\u4e49\u65e0\u6548\uff0c\u8bf7\u68c0\u67e5\u5b57\u6bb5\u53ca\u5355\u4f4d\u3002 +can.project.error.dbcSize=DBC \u6587\u4ef6\u5927\u5c0f\u5fc5\u987b\u4e3a 1 \u81f3 5,000,000 \u5b57\u8282\u3002 +can.project.error.dbcUnavailable=\u5df2\u5b89\u88c5\u7684 Native \u5e93\u65e0\u6cd5\u89e3\u6790 DBC \u6587\u4ef6\u3002 +can.project.error.dbcResponse=Native \u8fd4\u56de\u7684 DBC \u89e3\u6790\u7ed3\u679c\u4e0d\u5b8c\u6574\u3002 +can.project.error.dbcDocument=\u4fdd\u5b58\u7684 DBC \u6587\u4ef6\u6216\u9009\u62e9\u65e0\u6548\u3002 +can.project.error.dbcSelection=\u8bf7\u9009\u62e9\u53d7\u652f\u6301\u7684 DBC \u62a5\u6587\u548c\u4fe1\u53f7\u3002 +can.project.error.dbcDecoder=DBC \u89e3\u7801\u5b57\u6bb5\u5fc5\u987b\u4e0e\u6240\u9009\u4fe1\u53f7\u4e00\u81f4\u3002 +can.project.error.dbcRead=\u65e0\u6cd5\u8bfb\u53d6 DBC \u6587\u4ef6\u3002 + +can.recording.error.storage=CAN \u539f\u59cb\u62a5\u6587\u8bb0\u5f55\u5b58\u50a8\u64cd\u4f5c\u5931\u8d25\u3002 +can.recording.error.request=\u539f\u59cb\u62a5\u6587\u8bb0\u5f55\u6807\u8bc6\u6216\u5206\u9875\u53c2\u6570\u65e0\u6548\u3002 +can.recording.error.notFound=\u627e\u4e0d\u5230 CAN \u539f\u59cb\u62a5\u6587\u8bb0\u5f55\u3002 +can.recording.error.active=\u8bf7\u5148\u505c\u6b62\u8be5\u539f\u59cb\u62a5\u6587\u5f55\u5236\uff0c\u518d\u5220\u9664\u8bb0\u5f55\u3002 +can.recording.error.closed=\u8be5\u539f\u59cb\u62a5\u6587\u5f55\u5236\u5df2\u7ed3\u675f\u3002 + +can.recorded.error.write=保存 CAN 事件文件失败,请检查存储目录、磁盘空间和写入权限。 +can.recorded.error.register=CAN 事件文件已创建,但登记录制文件失败,请检查工程数据库。 +can.recorded.error.publish=CAN 事件文件已写入,但发布录制快照失败,请检查工程数据库。 diff --git a/apps/backend/crydaq-server/src/main/resources/lang/messages_de.properties b/apps/backend/crydaq-server/src/main/resources/lang/messages_de.properties index e21082d8..1be51ad3 100644 --- a/apps/backend/crydaq-server/src/main/resources/lang/messages_de.properties +++ b/apps/backend/crydaq-server/src/main/resources/lang/messages_de.properties @@ -1835,3 +1835,34 @@ error.vibration.no.convertible.input=Kein Vibrationseingang kann in Beschleunigu result.name.file_waveform=Dateiwellenform error.rt60.filter.config.invalid=RT60-Kanal {}\: Der Filterbewertungsparameter {} ist ungültig\: {}. Bitte korrigieren Sie die Kanalkonfiguration und versuchen Sie es erneut + +# CAN project channel persistence +can.project.error.required=Project, device and channel name are required. +can.project.error.scope=The CAN project or device binding is unavailable. +can.project.error.fields=CAN channels accept only project identity, name, color and CAN definition fields. +can.project.error.definition=The saved CAN definition is invalid. +can.project.error.units=The CAN quantity, source unit, output unit or Tacho PPR is invalid. +can.project.error.nativeUnavailable=The installed Native library cannot validate CAN signal definitions. +can.project.error.nativeResponse=Native returned an incomplete CAN validation response. +can.project.error.rule=The CAN decoder rule is invalid or unsupported. +can.project.error.mathInput=CAN signals cannot be used as Math inputs. +can.project.error.ambiguousDevice=The CAN device identity is ambiguous; select the device explicitly. +error.can.recorder.unavailable=CAN recording and history are not available yet. Use live Monitor or remove CAN inputs. +can.error.invalidDefinition=Invalid manual CAN signal definition; check the fields and units. +can.project.error.dbcSize=DBC-Dateien m\u00fcssen 1 bis 5.000.000 Bytes enthalten. +can.project.error.dbcUnavailable=Die installierte Native-Bibliothek kann DBC-Dateien nicht analysieren. +can.project.error.dbcResponse=Native hat ein unvollst\u00e4ndiges DBC-Analyseergebnis zur\u00fcckgegeben. +can.project.error.dbcDocument=Die gespeicherte DBC-Datei oder Auswahl ist ung\u00fcltig. +can.project.error.dbcSelection=W\u00e4hlen Sie eine unterst\u00fctzte DBC-Nachricht und ein Signal. +can.project.error.dbcDecoder=Die DBC-Decodierfelder m\u00fcssen dem ausgew\u00e4hlten Signal entsprechen. +can.project.error.dbcRead=Die DBC-Datei konnte nicht gelesen werden. + +can.recording.error.storage=Der Speichervorgang f\u00fcr die CAN-Rohdatenaufzeichnung ist fehlgeschlagen. +can.recording.error.request=Die Aufzeichnungs-ID oder die Seitenparameter sind ung\u00fcltig. +can.recording.error.notFound=Die CAN-Rohdatenaufzeichnung wurde nicht gefunden. +can.recording.error.active=Beenden Sie diese Rohdatenaufzeichnung, bevor Sie sie l\u00f6schen. +can.recording.error.closed=Diese Rohdatenaufzeichnung wurde beendet. + +can.recorded.error.write=Die aufgezeichnete CAN-Ereignisdatei konnte nicht geschrieben werden. Prüfen Sie Speicherordner, freien Speicherplatz und Schreibrechte. +can.recorded.error.register=Die CAN-Ereignisdatei wurde erstellt, konnte aber nicht registriert werden. Prüfen Sie die Projektdatenbank. +can.recorded.error.publish=Die CAN-Ereignisdatei wurde geschrieben, der Aufnahme-Snapshot konnte aber nicht gespeichert werden. Prüfen Sie die Projektdatenbank. diff --git a/apps/backend/crydaq-server/src/main/resources/lang/messages_en.properties b/apps/backend/crydaq-server/src/main/resources/lang/messages_en.properties index 7180e1de..56f1bdbc 100644 --- a/apps/backend/crydaq-server/src/main/resources/lang/messages_en.properties +++ b/apps/backend/crydaq-server/src/main/resources/lang/messages_en.properties @@ -1301,3 +1301,68 @@ error.rt60.frequency.nyquist=RT60 highest selected band upper edge {} Hz reaches error.rt60.evaluation.invalid=RT60 evaluation ranges {} are invalid: {}. Select one or more distinct values from T10, T15, T20, T30. error.rt60.spl.averaging.samples=RT60 SPL display averaging time must contain at least two samples. + +can.error.nativeFailure=CAN operation failed. Check the port configuration, device connection and reception state. +can.error.invalidResponse=Invalid CAN response. Check the device plugin and Native library versions. +can.error.saveFailed=CAN settings were applied, but could not be saved. Apply and save them again. +can.error.deviceUnavailable=The CAN device is unavailable. +can.error.portUnavailable=The selected CAN port is unavailable on this device. +can.error.busy=The CAN port is in use or being released. Stop the corresponding operation first. +can.error.sourceFailed=CAN reception ended with an error. Stop and release this reception first. +can.error.invalidCursor=The CAN frame cursor is invalid. +can.error.nativeUnavailable=The Native library does not provide the required CAN interface. Update the runtime libraries. +error.jni.native.13103001=Invalid CAN parameters. +error.jni.native.13103002=The current CAN state does not allow this operation. Check the enable switch, port configuration and reception state. +error.jni.native.13103003=The CAN reception handle is invalid or released. +error.jni.native.13103004=The device does not support the requested CAN capability. +error.jni.native.13103005=The CAN frame format is not supported. +error.jni.native.13103006=The CAN device was not found. +error.jni.native.13103007=The CAN device is disconnected. +error.jni.native.13103008=The CAN port is in use or being released. +error.jni.native.13103009=The CAN operation timed out. +error.jni.native.13103010=The CAN reception buffer overflowed. +error.jni.native.13103011=The CAN buffer has insufficient data. +error.jni.native.13103012=The CAN plugin major version is incompatible. +error.jni.native.13103013=The CAN plugin minor version is unsupported. +error.jni.native.13103014=The CAN plugin structure size is incompatible. +error.jni.native.13103015=The CAN plugin is missing a required interface. +error.jni.native.13103016=The CAN response buffer is too small. +error.jni.native.13103017=The CAN operation was interrupted. +error.jni.native.13103018=The CAN device operation failed. +error.jni.native.13103019=The CAN plugin returned an invalid response or failed. +error.jni.native.13103020=Permission to perform the CAN operation was denied. +error.jni.native.13103021=CAN memory allocation failed. +error.jni.native.13103022=The CAN operation raised an exception. +error.jni.native.13103023=The CAN JNI operation failed. +error.jni.native.13103024=The CAN result could not be encoded. + +# CAN project channel persistence +can.project.error.required=Project, device and channel name are required. +can.project.error.scope=The CAN project or device binding is unavailable. +can.project.error.fields=CAN channels accept only project identity, name, color and CAN definition fields. +can.project.error.definition=The saved CAN definition is invalid. +can.project.error.units=The CAN quantity, source unit, output unit or Tacho PPR is invalid. +can.project.error.nativeUnavailable=The installed Native library cannot validate CAN signal definitions. +can.project.error.nativeResponse=Native returned an incomplete CAN validation response. +can.project.error.rule=The CAN decoder rule is invalid or unsupported. +can.project.error.mathInput=CAN signals cannot be used as Math inputs. +can.project.error.ambiguousDevice=The CAN device identity is ambiguous; select the device explicitly. +error.can.recorder.unavailable=CAN recording and history are not available yet. Use live Monitor or remove CAN inputs. +can.error.invalidDefinition=Invalid manual CAN signal definition; check the fields and units. +can.project.error.dbcSize=DBC files must contain 1 to 5,000,000 bytes. +can.project.error.dbcUnavailable=The installed Native library cannot parse DBC files. +can.project.error.dbcResponse=Native returned an incomplete DBC parse response. +can.project.error.dbcDocument=The saved DBC file or selection is invalid. +can.project.error.dbcSelection=Select a supported DBC message and signal. +can.project.error.dbcDecoder=DBC decoder fields must match the selected signal. +can.project.error.dbcRead=The DBC file could not be read. + +can.recording.error.storage=The CAN raw recording storage operation failed. +can.recording.error.request=The raw recording ID or page parameters are invalid. +can.recording.error.notFound=The CAN raw recording was not found. +can.recording.error.active=Stop this raw recording before deleting it. +can.recording.error.closed=This raw recording has ended. + +can.recorded.error.write=Failed to write the recorded CAN event file. Check the storage directory, free disk space and write permissions. +can.recorded.error.register=The CAN event file was created, but registering the recording file failed. Check the project database. +can.recorded.error.publish=The CAN event file was written, but publishing the recording snapshot failed. Check the project database. diff --git a/apps/backend/crydaq-server/src/main/resources/lang/messages_es.properties b/apps/backend/crydaq-server/src/main/resources/lang/messages_es.properties index 54847264..88c8d868 100644 --- a/apps/backend/crydaq-server/src/main/resources/lang/messages_es.properties +++ b/apps/backend/crydaq-server/src/main/resources/lang/messages_es.properties @@ -1835,3 +1835,34 @@ error.vibration.no.convertible.input=Ninguna entrada de vibración se puede conv result.name.file_waveform=Forma de onda del archivo error.rt60.filter.config.invalid=RT60\: en el canal {}, el parámetro de filtrado y ponderación {} no es válido\: {}. Corrija la configuración del canal e inténtelo de nuevo + +# CAN project channel persistence +can.project.error.required=Project, device and channel name are required. +can.project.error.scope=The CAN project or device binding is unavailable. +can.project.error.fields=CAN channels accept only project identity, name, color and CAN definition fields. +can.project.error.definition=The saved CAN definition is invalid. +can.project.error.units=The CAN quantity, source unit, output unit or Tacho PPR is invalid. +can.project.error.nativeUnavailable=The installed Native library cannot validate CAN signal definitions. +can.project.error.nativeResponse=Native returned an incomplete CAN validation response. +can.project.error.rule=The CAN decoder rule is invalid or unsupported. +can.project.error.mathInput=CAN signals cannot be used as Math inputs. +can.project.error.ambiguousDevice=The CAN device identity is ambiguous; select the device explicitly. +error.can.recorder.unavailable=CAN recording and history are not available yet. Use live Monitor or remove CAN inputs. +can.error.invalidDefinition=Invalid manual CAN signal definition; check the fields and units. +can.project.error.dbcSize=Los archivos DBC deben contener entre 1 y 5.000.000 bytes. +can.project.error.dbcUnavailable=La biblioteca Native instalada no puede analizar archivos DBC. +can.project.error.dbcResponse=Native devolvi\u00f3 un resultado de an\u00e1lisis DBC incompleto. +can.project.error.dbcDocument=El archivo DBC guardado o la selecci\u00f3n no son v\u00e1lidos. +can.project.error.dbcSelection=Seleccione un mensaje y una se\u00f1al DBC compatibles. +can.project.error.dbcDecoder=Los campos de decodificaci\u00f3n DBC deben coincidir con la se\u00f1al seleccionada. +can.project.error.dbcRead=No se pudo leer el archivo DBC. + +can.recording.error.storage=La operaci\u00f3n de almacenamiento de la grabaci\u00f3n CAN sin procesar ha fallado. +can.recording.error.request=El identificador de grabaci\u00f3n o los par\u00e1metros de p\u00e1gina no son v\u00e1lidos. +can.recording.error.notFound=No se encontr\u00f3 la grabaci\u00f3n CAN sin procesar. +can.recording.error.active=Detenga esta grabaci\u00f3n antes de eliminarla. +can.recording.error.closed=Esta grabaci\u00f3n ha finalizado. + +can.recorded.error.write=No se pudo escribir el archivo de eventos CAN grabados. Compruebe la carpeta, el espacio libre y los permisos de escritura. +can.recorded.error.register=El archivo de eventos CAN se creó, pero no se pudo registrar. Compruebe la base de datos del proyecto. +can.recorded.error.publish=El archivo de eventos CAN se escribió, pero no se pudo publicar la instantánea de la grabación. Compruebe la base de datos del proyecto. diff --git a/apps/backend/crydaq-server/src/main/resources/lang/messages_fr.properties b/apps/backend/crydaq-server/src/main/resources/lang/messages_fr.properties index 19dc91a1..2670337c 100644 --- a/apps/backend/crydaq-server/src/main/resources/lang/messages_fr.properties +++ b/apps/backend/crydaq-server/src/main/resources/lang/messages_fr.properties @@ -1835,3 +1835,34 @@ error.vibration.no.convertible.input=Aucune entrée de vibration ne peut être c result.name.file_waveform=Forme d'onde du fichier error.rt60.filter.config.invalid=RT60 \: pour le canal {}, le paramètre de pondération du filtre {} n'est pas valide \: {}. Corrigez la configuration du canal, puis réessayez + +# CAN project channel persistence +can.project.error.required=Project, device and channel name are required. +can.project.error.scope=The CAN project or device binding is unavailable. +can.project.error.fields=CAN channels accept only project identity, name, color and CAN definition fields. +can.project.error.definition=The saved CAN definition is invalid. +can.project.error.units=The CAN quantity, source unit, output unit or Tacho PPR is invalid. +can.project.error.nativeUnavailable=The installed Native library cannot validate CAN signal definitions. +can.project.error.nativeResponse=Native returned an incomplete CAN validation response. +can.project.error.rule=The CAN decoder rule is invalid or unsupported. +can.project.error.mathInput=CAN signals cannot be used as Math inputs. +can.project.error.ambiguousDevice=The CAN device identity is ambiguous; select the device explicitly. +error.can.recorder.unavailable=CAN recording and history are not available yet. Use live Monitor or remove CAN inputs. +can.error.invalidDefinition=Invalid manual CAN signal definition; check the fields and units. +can.project.error.dbcSize=Les fichiers DBC doivent contenir entre 1 et 5 000 000 octets. +can.project.error.dbcUnavailable=La biblioth\u00e8que Native install\u00e9e ne peut pas analyser les fichiers DBC. +can.project.error.dbcResponse=Native a renvoy\u00e9 un r\u00e9sultat DBC incomplet. +can.project.error.dbcDocument=Le fichier DBC enregistr\u00e9 ou la s\u00e9lection est invalide. +can.project.error.dbcSelection=S\u00e9lectionnez un message et un signal DBC pris en charge. +can.project.error.dbcDecoder=Les champs de d\u00e9codage DBC doivent correspondre au signal s\u00e9lectionn\u00e9. +can.project.error.dbcRead=Impossible de lire le fichier DBC. + +can.recording.error.storage=L\u2019op\u00e9ration de stockage de l\u2019enregistrement CAN brut a \u00e9chou\u00e9. +can.recording.error.request=L\u2019identifiant de l\u2019enregistrement ou les param\u00e8tres de pagination ne sont pas valides. +can.recording.error.notFound=L\u2019enregistrement CAN brut est introuvable. +can.recording.error.active=Arr\u00eatez cet enregistrement avant de le supprimer. +can.recording.error.closed=Cet enregistrement est termin\u00e9. + +can.recorded.error.write=Impossible d'écrire le fichier des événements CAN enregistrés. Vérifiez le dossier de stockage, l'espace libre et les droits d'écriture. +can.recorded.error.register=Le fichier des événements CAN a été créé, mais son enregistrement a échoué. Vérifiez la base de données du projet. +can.recorded.error.publish=Le fichier des événements CAN a été écrit, mais la publication de l'instantané a échoué. Vérifiez la base de données du projet. diff --git a/apps/backend/crydaq-server/src/main/resources/lang/messages_ja.properties b/apps/backend/crydaq-server/src/main/resources/lang/messages_ja.properties index 10f20e73..60ce74ed 100644 --- a/apps/backend/crydaq-server/src/main/resources/lang/messages_ja.properties +++ b/apps/backend/crydaq-server/src/main/resources/lang/messages_ja.properties @@ -1835,3 +1835,34 @@ error.vibration.no.convertible.input=加速度に変換できる振動入力が result.name.file_waveform=ファイル波形 error.rt60.filter.config.invalid=RT60 チャネル {} のフィルター重み付けパラメータ {} が無効です:{}。チャネル設定を修正してから再試行してください。 + +# CAN project channel persistence +can.project.error.required=Project, device and channel name are required. +can.project.error.scope=The CAN project or device binding is unavailable. +can.project.error.fields=CAN channels accept only project identity, name, color and CAN definition fields. +can.project.error.definition=The saved CAN definition is invalid. +can.project.error.units=The CAN quantity, source unit, output unit or Tacho PPR is invalid. +can.project.error.nativeUnavailable=The installed Native library cannot validate CAN signal definitions. +can.project.error.nativeResponse=Native returned an incomplete CAN validation response. +can.project.error.rule=The CAN decoder rule is invalid or unsupported. +can.project.error.mathInput=CAN signals cannot be used as Math inputs. +can.project.error.ambiguousDevice=The CAN device identity is ambiguous; select the device explicitly. +error.can.recorder.unavailable=CAN recording and history are not available yet. Use live Monitor or remove CAN inputs. +can.error.invalidDefinition=Invalid manual CAN signal definition; check the fields and units. +can.project.error.dbcSize=DBC \u30d5\u30a1\u30a4\u30eb\u306f 1 \uff5e 5,000,000 \u30d0\u30a4\u30c8\u3067\u3042\u308b\u5fc5\u8981\u304c\u3042\u308a\u307e\u3059\u3002 +can.project.error.dbcUnavailable=\u30a4\u30f3\u30b9\u30c8\u30fc\u30eb\u6e08\u307f\u306e Native \u30e9\u30a4\u30d6\u30e9\u30ea\u306f DBC \u30d5\u30a1\u30a4\u30eb\u3092\u89e3\u6790\u3067\u304d\u307e\u305b\u3093\u3002 +can.project.error.dbcResponse=Native \u304c\u8fd4\u3057\u305f DBC \u89e3\u6790\u7d50\u679c\u304c\u4e0d\u5b8c\u5168\u3067\u3059\u3002 +can.project.error.dbcDocument=\u4fdd\u5b58\u3055\u308c\u305f DBC \u30d5\u30a1\u30a4\u30eb\u307e\u305f\u306f\u9078\u629e\u304c\u7121\u52b9\u3067\u3059\u3002 +can.project.error.dbcSelection=\u5bfe\u5fdc\u3057\u3066\u3044\u308b DBC \u30e1\u30c3\u30bb\u30fc\u30b8\u3068\u4fe1\u53f7\u3092\u9078\u629e\u3057\u3066\u304f\u3060\u3055\u3044\u3002 +can.project.error.dbcDecoder=DBC \u30c7\u30b3\u30fc\u30c9\u9805\u76ee\u306f\u9078\u629e\u3057\u305f\u4fe1\u53f7\u3068\u4e00\u81f4\u3059\u308b\u5fc5\u8981\u304c\u3042\u308a\u307e\u3059\u3002 +can.project.error.dbcRead=DBC \u30d5\u30a1\u30a4\u30eb\u3092\u8aad\u307f\u53d6\u308c\u307e\u305b\u3093\u3067\u3057\u305f\u3002 + +can.recording.error.storage=CAN \u751f\u30d5\u30ec\u30fc\u30e0\u8a18\u9332\u306e\u30b9\u30c8\u30ec\u30fc\u30b8\u64cd\u4f5c\u306b\u5931\u6557\u3057\u307e\u3057\u305f\u3002 +can.recording.error.request=\u8a18\u9332 ID \u307e\u305f\u306f\u30da\u30fc\u30b8\u6307\u5b9a\u304c\u7121\u52b9\u3067\u3059\u3002 +can.recording.error.notFound=CAN \u751f\u30d5\u30ec\u30fc\u30e0\u8a18\u9332\u304c\u898b\u3064\u304b\u308a\u307e\u305b\u3093\u3002 +can.recording.error.active=\u524a\u9664\u3059\u308b\u524d\u306b\u3001\u3053\u306e\u751f\u30d5\u30ec\u30fc\u30e0\u8a18\u9332\u3092\u505c\u6b62\u3057\u3066\u304f\u3060\u3055\u3044\u3002 +can.recording.error.closed=\u3053\u306e\u751f\u30d5\u30ec\u30fc\u30e0\u8a18\u9332\u306f\u7d42\u4e86\u3057\u3066\u3044\u307e\u3059\u3002 + +can.recorded.error.write=記録した CAN イベントファイルを書き込めません。保存先、空き容量、書き込み権限を確認してください。 +can.recorded.error.register=CAN イベントファイルを作成しましたが、録音ファイルの登録に失敗しました。プロジェクトデータベースを確認してください。 +can.recorded.error.publish=CAN イベントファイルを書き込みましたが、記録スナップショットの保存に失敗しました。プロジェクトデータベースを確認してください。 diff --git a/apps/backend/crydaq-server/src/main/resources/lang/messages_ko.properties b/apps/backend/crydaq-server/src/main/resources/lang/messages_ko.properties index 2e6609c3..7abd10da 100644 --- a/apps/backend/crydaq-server/src/main/resources/lang/messages_ko.properties +++ b/apps/backend/crydaq-server/src/main/resources/lang/messages_ko.properties @@ -1835,3 +1835,34 @@ error.vibration.no.convertible.input=가속도로 변환할 수 있는 진동 result.name.file_waveform=파일 파형 error.rt60.filter.config.invalid=RT60 채널 {}의 필터 가중 파라미터 {}의 값이 잘못되었습니다\: {}. 채널 구성을 수정한 후 다시 시도하십시오 + +# CAN project channel persistence +can.project.error.required=Project, device and channel name are required. +can.project.error.scope=The CAN project or device binding is unavailable. +can.project.error.fields=CAN channels accept only project identity, name, color and CAN definition fields. +can.project.error.definition=The saved CAN definition is invalid. +can.project.error.units=The CAN quantity, source unit, output unit or Tacho PPR is invalid. +can.project.error.nativeUnavailable=The installed Native library cannot validate CAN signal definitions. +can.project.error.nativeResponse=Native returned an incomplete CAN validation response. +can.project.error.rule=The CAN decoder rule is invalid or unsupported. +can.project.error.mathInput=CAN signals cannot be used as Math inputs. +can.project.error.ambiguousDevice=The CAN device identity is ambiguous; select the device explicitly. +error.can.recorder.unavailable=CAN recording and history are not available yet. Use live Monitor or remove CAN inputs. +can.error.invalidDefinition=Invalid manual CAN signal definition; check the fields and units. +can.project.error.dbcSize=DBC \ud30c\uc77c \ud06c\uae30\ub294 1~5,000,000\ubc14\uc774\ud2b8\uc5ec\uc57c \ud569\ub2c8\ub2e4. +can.project.error.dbcUnavailable=\uc124\uce58\ub41c Native \ub77c\uc774\ube0c\ub7ec\ub9ac\uac00 DBC \ud30c\uc77c\uc744 \ubd84\uc11d\ud560 \uc218 \uc5c6\uc2b5\ub2c8\ub2e4. +can.project.error.dbcResponse=Native\uac00 \ubd88\uc644\uc804\ud55c DBC \ubd84\uc11d \uacb0\uacfc\ub97c \ubc18\ud658\ud588\uc2b5\ub2c8\ub2e4. +can.project.error.dbcDocument=\uc800\uc7a5\ub41c DBC \ud30c\uc77c \ub610\ub294 \uc120\ud0dd\uc774 \uc798\ubabb\ub418\uc5c8\uc2b5\ub2c8\ub2e4. +can.project.error.dbcSelection=\uc9c0\uc6d0\ub418\ub294 DBC \uba54\uc2dc\uc9c0\uc640 \uc2e0\ud638\ub97c \uc120\ud0dd\ud558\uc138\uc694. +can.project.error.dbcDecoder=DBC \ub514\ucf54\ub529 \ud544\ub4dc\ub294 \uc120\ud0dd\ud55c \uc2e0\ud638\uc640 \uc77c\uce58\ud574\uc57c \ud569\ub2c8\ub2e4. +can.project.error.dbcRead=DBC \ud30c\uc77c\uc744 \uc77d\uc744 \uc218 \uc5c6\uc2b5\ub2c8\ub2e4. + +can.recording.error.storage=CAN \uc6d0\uc2dc \ud504\ub808\uc784 \uae30\ub85d\uc758 \uc800\uc7a5\uc18c \uc791\uc5c5\uc5d0 \uc2e4\ud328\ud588\uc2b5\ub2c8\ub2e4. +can.recording.error.request=\uae30\ub85d ID \ub610\ub294 \ud398\uc774\uc9c0 \ub9e4\uac1c\ubcc0\uc218\uac00 \uc62c\ubc14\ub974\uc9c0 \uc54a\uc2b5\ub2c8\ub2e4. +can.recording.error.notFound=CAN \uc6d0\uc2dc \ud504\ub808\uc784 \uae30\ub85d\uc744 \ucc3e\uc744 \uc218 \uc5c6\uc2b5\ub2c8\ub2e4. +can.recording.error.active=\uc774 \uc6d0\uc2dc \ud504\ub808\uc784 \uae30\ub85d\uc744 \uc911\uc9c0\ud55c \ud6c4 \uc0ad\uc81c\ud558\uc138\uc694. +can.recording.error.closed=\uc774 \uc6d0\uc2dc \ud504\ub808\uc784 \uae30\ub85d\uc774 \uc885\ub8cc\ub418\uc5c8\uc2b5\ub2c8\ub2e4. + +can.recorded.error.write=기록된 CAN 이벤트 파일을 쓸 수 없습니다. 저장 폴더, 디스크 여유 공간 및 쓰기 권한을 확인하세요. +can.recorded.error.register=CAN 이벤트 파일을 만들었지만 기록 파일 등록에 실패했습니다. 프로젝트 데이터베이스를 확인하세요. +can.recorded.error.publish=CAN 이벤트 파일을 썼지만 기록 스냅샷 게시에 실패했습니다. 프로젝트 데이터베이스를 확인하세요. diff --git a/apps/backend/crydaq-server/src/main/resources/lang/messages_ru.properties b/apps/backend/crydaq-server/src/main/resources/lang/messages_ru.properties index 39c11049..c544cd47 100644 --- a/apps/backend/crydaq-server/src/main/resources/lang/messages_ru.properties +++ b/apps/backend/crydaq-server/src/main/resources/lang/messages_ru.properties @@ -1835,3 +1835,34 @@ error.vibration.no.convertible.input=Ни один вход вибрации н result.name.file_waveform=Форма сигнала из файла error.rt60.filter.config.invalid=RT60\: для канала {} параметр фильтра и частотной коррекции {} недопустим\: {}. Исправьте конфигурацию канала и повторите попытку + +# CAN project channel persistence +can.project.error.required=Project, device and channel name are required. +can.project.error.scope=The CAN project or device binding is unavailable. +can.project.error.fields=CAN channels accept only project identity, name, color and CAN definition fields. +can.project.error.definition=The saved CAN definition is invalid. +can.project.error.units=The CAN quantity, source unit, output unit or Tacho PPR is invalid. +can.project.error.nativeUnavailable=The installed Native library cannot validate CAN signal definitions. +can.project.error.nativeResponse=Native returned an incomplete CAN validation response. +can.project.error.rule=The CAN decoder rule is invalid or unsupported. +can.project.error.mathInput=CAN signals cannot be used as Math inputs. +can.project.error.ambiguousDevice=The CAN device identity is ambiguous; select the device explicitly. +error.can.recorder.unavailable=CAN recording and history are not available yet. Use live Monitor or remove CAN inputs. +can.error.invalidDefinition=Invalid manual CAN signal definition; check the fields and units. +can.project.error.dbcSize=\u0424\u0430\u0439\u043b\u044b DBC \u0434\u043e\u043b\u0436\u043d\u044b \u0441\u043e\u0434\u0435\u0440\u0436\u0430\u0442\u044c \u043e\u0442 1 \u0434\u043e 5 000 000 \u0431\u0430\u0439\u0442. +can.project.error.dbcUnavailable=\u0423\u0441\u0442\u0430\u043d\u043e\u0432\u043b\u0435\u043d\u043d\u0430\u044f \u0431\u0438\u0431\u043b\u0438\u043e\u0442\u0435\u043a\u0430 Native \u043d\u0435 \u043c\u043e\u0436\u0435\u0442 \u0440\u0430\u0437\u043e\u0431\u0440\u0430\u0442\u044c \u0444\u0430\u0439\u043b\u044b DBC. +can.project.error.dbcResponse=Native \u0432\u0435\u0440\u043d\u0443\u043b\u0430 \u043d\u0435\u043f\u043e\u043b\u043d\u044b\u0439 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442 \u0440\u0430\u0437\u0431\u043e\u0440\u0430 DBC. +can.project.error.dbcDocument=\u0421\u043e\u0445\u0440\u0430\u043d\u0451\u043d\u043d\u044b\u0439 \u0444\u0430\u0439\u043b DBC \u0438\u043b\u0438 \u0432\u044b\u0431\u043e\u0440 \u043d\u0435\u0434\u043e\u043f\u0443\u0441\u0442\u0438\u043c\u044b. +can.project.error.dbcSelection=\u0412\u044b\u0431\u0435\u0440\u0438\u0442\u0435 \u043f\u043e\u0434\u0434\u0435\u0440\u0436\u0438\u0432\u0430\u0435\u043c\u044b\u0435 \u0441\u043e\u043e\u0431\u0449\u0435\u043d\u0438\u0435 \u0438 \u0441\u0438\u0433\u043d\u0430\u043b DBC. +can.project.error.dbcDecoder=\u041f\u043e\u043b\u044f \u0434\u0435\u043a\u043e\u0434\u0438\u0440\u043e\u0432\u0430\u043d\u0438\u044f DBC \u0434\u043e\u043b\u0436\u043d\u044b \u0441\u043e\u043e\u0442\u0432\u0435\u0442\u0441\u0442\u0432\u043e\u0432\u0430\u0442\u044c \u0432\u044b\u0431\u0440\u0430\u043d\u043d\u043e\u043c\u0443 \u0441\u0438\u0433\u043d\u0430\u043b\u0443. +can.project.error.dbcRead=\u041d\u0435 \u0443\u0434\u0430\u043b\u043e\u0441\u044c \u043f\u0440\u043e\u0447\u0438\u0442\u0430\u0442\u044c \u0444\u0430\u0439\u043b DBC. + +can.recording.error.storage=\u041e\u0448\u0438\u0431\u043a\u0430 \u043e\u043f\u0435\u0440\u0430\u0446\u0438\u0438 \u0441 \u0445\u0440\u0430\u043d\u0438\u043b\u0438\u0449\u0435\u043c \u0437\u0430\u043f\u0438\u0441\u0438 \u0438\u0441\u0445\u043e\u0434\u043d\u044b\u0445 \u043a\u0430\u0434\u0440\u043e\u0432 CAN. +can.recording.error.request=\u041d\u0435\u0434\u043e\u043f\u0443\u0441\u0442\u0438\u043c\u044b\u0439 \u0438\u0434\u0435\u043d\u0442\u0438\u0444\u0438\u043a\u0430\u0442\u043e\u0440 \u0437\u0430\u043f\u0438\u0441\u0438 \u0438\u043b\u0438 \u043f\u0430\u0440\u0430\u043c\u0435\u0442\u0440\u044b \u0441\u0442\u0440\u0430\u043d\u0438\u0446\u044b. +can.recording.error.notFound=\u0417\u0430\u043f\u0438\u0441\u044c \u0438\u0441\u0445\u043e\u0434\u043d\u044b\u0445 \u043a\u0430\u0434\u0440\u043e\u0432 CAN \u043d\u0435 \u043d\u0430\u0439\u0434\u0435\u043d\u0430. +can.recording.error.active=\u041e\u0441\u0442\u0430\u043d\u043e\u0432\u0438\u0442\u0435 \u044d\u0442\u0443 \u0437\u0430\u043f\u0438\u0441\u044c \u043f\u0435\u0440\u0435\u0434 \u0443\u0434\u0430\u043b\u0435\u043d\u0438\u0435\u043c. +can.recording.error.closed=\u042d\u0442\u0430 \u0437\u0430\u043f\u0438\u0441\u044c \u0437\u0430\u0432\u0435\u0440\u0448\u0435\u043d\u0430. + +can.recorded.error.write=Не удалось записать файл событий CAN. Проверьте папку хранения, свободное место и права записи. +can.recorded.error.register=Файл событий CAN создан, но зарегистрировать его не удалось. Проверьте базу данных проекта. +can.recorded.error.publish=Файл событий CAN записан, но сохранить снимок записи не удалось. Проверьте базу данных проекта. diff --git a/apps/backend/crydaq-server/src/main/resources/lang/messages_tr.properties b/apps/backend/crydaq-server/src/main/resources/lang/messages_tr.properties index d2e73283..cf0eec54 100644 --- a/apps/backend/crydaq-server/src/main/resources/lang/messages_tr.properties +++ b/apps/backend/crydaq-server/src/main/resources/lang/messages_tr.properties @@ -1835,3 +1835,34 @@ error.vibration.no.convertible.input=Hiçbir titreşim girişi ivmeye dönüşt result.name.file_waveform=Dosya Dalga Formu error.rt60.filter.config.invalid=RT60 kanalı {} için filtre ağırlıklandırma parametresi {} geçersiz\: {}. Kanal yapılandırmasını düzeltip tekrar deneyin + +# CAN project channel persistence +can.project.error.required=Project, device and channel name are required. +can.project.error.scope=The CAN project or device binding is unavailable. +can.project.error.fields=CAN channels accept only project identity, name, color and CAN definition fields. +can.project.error.definition=The saved CAN definition is invalid. +can.project.error.units=The CAN quantity, source unit, output unit or Tacho PPR is invalid. +can.project.error.nativeUnavailable=The installed Native library cannot validate CAN signal definitions. +can.project.error.nativeResponse=Native returned an incomplete CAN validation response. +can.project.error.rule=The CAN decoder rule is invalid or unsupported. +can.project.error.mathInput=CAN signals cannot be used as Math inputs. +can.project.error.ambiguousDevice=The CAN device identity is ambiguous; select the device explicitly. +error.can.recorder.unavailable=CAN recording and history are not available yet. Use live Monitor or remove CAN inputs. +can.error.invalidDefinition=Invalid manual CAN signal definition; check the fields and units. +can.project.error.dbcSize=DBC dosyalar\u0131 1 ile 5.000.000 bayt aras\u0131nda olmal\u0131d\u0131r. +can.project.error.dbcUnavailable=Y\u00fckl\u00fc Native kitapl\u0131\u011f\u0131 DBC dosyalar\u0131n\u0131 ayr\u0131\u015ft\u0131ram\u0131yor. +can.project.error.dbcResponse=Native eksik bir DBC ayr\u0131\u015ft\u0131rma sonucu d\u00f6nd\u00fcrd\u00fc. +can.project.error.dbcDocument=Kaydedilen DBC dosyas\u0131 veya se\u00e7im ge\u00e7ersiz. +can.project.error.dbcSelection=Desteklenen bir DBC mesaj\u0131 ve sinyali se\u00e7in. +can.project.error.dbcDecoder=DBC kod \u00e7\u00f6zme alanlar\u0131 se\u00e7ilen sinyalle e\u015fle\u015fmelidir. +can.project.error.dbcRead=DBC dosyas\u0131 okunamad\u0131. + +can.recording.error.storage=Ham CAN kayd\u0131 depolama i\u015flemi ba\u015far\u0131s\u0131z oldu. +can.recording.error.request=Kay\u0131t kimli\u011fi veya sayfa parametreleri ge\u00e7ersiz. +can.recording.error.notFound=Ham CAN kayd\u0131 bulunamad\u0131. +can.recording.error.active=Silmeden \u00f6nce bu ham kayd\u0131 durdurun. +can.recording.error.closed=Bu ham kay\u0131t sona erdi. + +can.recorded.error.write=Kaydedilen CAN olay dosyası yazılamadı. Depolama klasörünü, boş disk alanını ve yazma izinlerini kontrol edin. +can.recorded.error.register=CAN olay dosyası oluşturuldu ancak kayıt dosyası kaydedilemedi. Proje veritabanını kontrol edin. +can.recorded.error.publish=CAN olay dosyası yazıldı ancak kayıt anlık görüntüsü yayımlanamadı. Proje veritabanını kontrol edin. diff --git a/apps/backend/crydaq-server/src/main/resources/lang/messages_zh.properties b/apps/backend/crydaq-server/src/main/resources/lang/messages_zh.properties index 04365e02..f0870617 100644 --- a/apps/backend/crydaq-server/src/main/resources/lang/messages_zh.properties +++ b/apps/backend/crydaq-server/src/main/resources/lang/messages_zh.properties @@ -1835,3 +1835,34 @@ error.vibration.no.convertible.input=没有可转换为加速度的振动输入 result.name.file_waveform=文件波形 error.rt60.filter.config.invalid=RT60 通道 {} 的滤波计权参数 {} 无效:{}。请修正通道配置后重试。 + +# CAN project channel persistence +can.project.error.required=\u8bf7\u63d0\u4f9b\u5de5\u7a0b\u3001\u8bbe\u5907\u53ca\u901a\u9053\u540d\u79f0\u3002 +can.project.error.scope=CAN \u5de5\u7a0b\u6216\u8bbe\u5907\u7ed1\u5b9a\u4e0d\u53ef\u7528\u3002 +can.project.error.fields=CAN \u901a\u9053\u4ec5\u5141\u8bb8\u4fee\u6539\u5de5\u7a0b\u8eab\u4efd\u3001\u540d\u79f0\u3001\u989c\u8272\u53ca CAN \u5b9a\u4e49\u5b57\u6bb5\u3002 +can.project.error.definition=\u4fdd\u5b58\u7684 CAN \u5b9a\u4e49\u65e0\u6548\u3002 +can.project.error.units=CAN \u4fe1\u53f7\u7c7b\u578b\u3001\u6e90\u5355\u4f4d\u3001\u8f93\u51fa\u5355\u4f4d\u6216 Tacho PPR \u65e0\u6548\u3002 +can.project.error.nativeUnavailable=\u5f53\u524d Native \u5e93\u65e0\u6cd5\u6821\u9a8c CAN \u4fe1\u53f7\u5b9a\u4e49\u3002 +can.project.error.nativeResponse=Native \u8fd4\u56de\u7684 CAN \u6821\u9a8c\u7ed3\u679c\u4e0d\u5b8c\u6574\u3002 +can.project.error.rule=CAN \u89e3\u7801\u89c4\u5219\u65e0\u6548\u6216\u6682\u4e0d\u652f\u6301\u3002 +can.project.error.mathInput=CAN \u4fe1\u53f7\u4e0d\u80fd\u4f5c\u4e3a\u6570\u5b66\u901a\u9053\u8f93\u5165\u3002 +can.project.error.ambiguousDevice=CAN \u8bbe\u5907\u8eab\u4efd\u4e0d\u552f\u4e00\uff0c\u8bf7\u660e\u786e\u9009\u62e9\u8bbe\u5907\u3002 +error.can.recorder.unavailable=CAN \u5f55\u5236\u4e0e\u5386\u53f2\u529f\u80fd\u6682\u4e0d\u53ef\u7528\uff0c\u8bf7\u4f7f\u7528\u5b9e\u65f6 Monitor \u6216\u79fb\u9664 CAN \u8f93\u5165\u3002 +can.error.invalidDefinition=\u624b\u52a8 CAN \u4fe1\u53f7\u5b9a\u4e49\u65e0\u6548\uff0c\u8bf7\u68c0\u67e5\u5b57\u6bb5\u53ca\u5355\u4f4d\u3002 +can.project.error.dbcSize=DBC \u6587\u4ef6\u5927\u5c0f\u5fc5\u987b\u4e3a 1 \u81f3 5,000,000 \u5b57\u8282\u3002 +can.project.error.dbcUnavailable=\u5df2\u5b89\u88c5\u7684 Native \u5e93\u65e0\u6cd5\u89e3\u6790 DBC \u6587\u4ef6\u3002 +can.project.error.dbcResponse=Native \u8fd4\u56de\u7684 DBC \u89e3\u6790\u7ed3\u679c\u4e0d\u5b8c\u6574\u3002 +can.project.error.dbcDocument=\u4fdd\u5b58\u7684 DBC \u6587\u4ef6\u6216\u9009\u62e9\u65e0\u6548\u3002 +can.project.error.dbcSelection=\u8bf7\u9009\u62e9\u53d7\u652f\u6301\u7684 DBC \u62a5\u6587\u548c\u4fe1\u53f7\u3002 +can.project.error.dbcDecoder=DBC \u89e3\u7801\u5b57\u6bb5\u5fc5\u987b\u4e0e\u6240\u9009\u4fe1\u53f7\u4e00\u81f4\u3002 +can.project.error.dbcRead=\u65e0\u6cd5\u8bfb\u53d6 DBC \u6587\u4ef6\u3002 + +can.recording.error.storage=CAN \u539f\u59cb\u62a5\u6587\u8bb0\u5f55\u5b58\u50a8\u64cd\u4f5c\u5931\u8d25\u3002 +can.recording.error.request=\u539f\u59cb\u62a5\u6587\u8bb0\u5f55\u6807\u8bc6\u6216\u5206\u9875\u53c2\u6570\u65e0\u6548\u3002 +can.recording.error.notFound=\u627e\u4e0d\u5230 CAN \u539f\u59cb\u62a5\u6587\u8bb0\u5f55\u3002 +can.recording.error.active=\u8bf7\u5148\u505c\u6b62\u8be5\u539f\u59cb\u62a5\u6587\u5f55\u5236\uff0c\u518d\u5220\u9664\u8bb0\u5f55\u3002 +can.recording.error.closed=\u8be5\u539f\u59cb\u62a5\u6587\u5f55\u5236\u5df2\u7ed3\u675f\u3002 + +can.recorded.error.write=保存 CAN 事件文件失败,请检查存储目录、磁盘空间和写入权限。 +can.recorded.error.register=CAN 事件文件已创建,但登记录制文件失败,请检查工程数据库。 +can.recorded.error.publish=CAN 事件文件已写入,但发布录制快照失败,请检查工程数据库。 diff --git a/apps/backend/crydaq-server/src/main/resources/lang/messages_zh_TW.properties b/apps/backend/crydaq-server/src/main/resources/lang/messages_zh_TW.properties index 43546d30..0320e676 100644 --- a/apps/backend/crydaq-server/src/main/resources/lang/messages_zh_TW.properties +++ b/apps/backend/crydaq-server/src/main/resources/lang/messages_zh_TW.properties @@ -1835,3 +1835,34 @@ error.vibration.no.convertible.input=沒有可轉換為加速度的振動輸入 result.name.file_waveform=檔案波形 error.rt60.filter.config.invalid=RT60 通道 {} 的濾波計權參數 {} 無效:{}。請修正通道設定後重試。 + +# CAN project channel persistence +can.project.error.required=\u8acb\u63d0\u4f9b\u5de5\u7a0b\u3001\u88dd\u7f6e\u53ca\u901a\u9053\u540d\u7a31\u3002 +can.project.error.scope=CAN \u5de5\u7a0b\u6216\u88dd\u7f6e\u7e6b\u7d50\u4e0d\u53ef\u7528\u3002 +can.project.error.fields=CAN \u901a\u9053\u50c5\u5141\u8a31\u4fee\u6539\u5de5\u7a0b\u8eab\u5206\u3001\u540d\u7a31\u3001\u984f\u8272\u53ca CAN \u5b9a\u7fa9\u6b04\u4f4d\u3002 +can.project.error.definition=\u5132\u5b58\u7684 CAN \u5b9a\u7fa9\u7121\u6548\u3002 +can.project.error.units=CAN \u8a0a\u865f\u985e\u578b\u3001\u4f86\u6e90\u55ae\u4f4d\u3001\u8f38\u51fa\u55ae\u4f4d\u6216 Tacho PPR \u7121\u6548\u3002 +can.project.error.nativeUnavailable=\u76ee\u524d Native \u7a0b\u5f0f\u5eab\u7121\u6cd5\u9a57\u8b49 CAN \u8a0a\u865f\u5b9a\u7fa9\u3002 +can.project.error.nativeResponse=Native \u50b3\u56de\u7684 CAN \u9a57\u8b49\u7d50\u679c\u4e0d\u5b8c\u6574\u3002 +can.project.error.rule=CAN \u89e3\u78bc\u898f\u5247\u7121\u6548\u6216\u66ab\u4e0d\u652f\u63f4\u3002 +can.project.error.mathInput=CAN \u8a0a\u865f\u4e0d\u80fd\u4f5c\u70ba\u6578\u5b78\u901a\u9053\u8f38\u5165\u3002 +can.project.error.ambiguousDevice=CAN \u88dd\u7f6e\u8eab\u5206\u4e0d\u552f\u4e00\uff0c\u8acb\u660e\u78ba\u9078\u64c7\u88dd\u7f6e\u3002 +error.can.recorder.unavailable=CAN \u9304\u88fd\u8207\u6b77\u53f2\u529f\u80fd\u66ab\u4e0d\u53ef\u7528\uff0c\u8acb\u4f7f\u7528\u5373\u6642 Monitor \u6216\u79fb\u9664 CAN \u8f38\u5165\u3002 +can.error.invalidDefinition=\u624b\u52d5 CAN \u8a0a\u865f\u5b9a\u7fa9\u7121\u6548\uff0c\u8acb\u6aa2\u67e5\u6b04\u4f4d\u53ca\u55ae\u4f4d\u3002 +can.project.error.dbcSize=DBC \u6a94\u6848\u5927\u5c0f\u5fc5\u9808\u70ba 1 \u81f3 5,000,000 \u4f4d\u5143\u7d44\u3002 +can.project.error.dbcUnavailable=\u5df2\u5b89\u88dd\u7684 Native \u7a0b\u5f0f\u5eab\u7121\u6cd5\u89e3\u6790 DBC \u6a94\u6848\u3002 +can.project.error.dbcResponse=Native \u50b3\u56de\u7684 DBC \u89e3\u6790\u7d50\u679c\u4e0d\u5b8c\u6574\u3002 +can.project.error.dbcDocument=\u5132\u5b58\u7684 DBC \u6a94\u6848\u6216\u9078\u53d6\u9805\u76ee\u7121\u6548\u3002 +can.project.error.dbcSelection=\u8acb\u9078\u53d6\u53d7\u652f\u63f4\u7684 DBC \u8a0a\u606f\u548c\u8a0a\u865f\u3002 +can.project.error.dbcDecoder=DBC \u89e3\u78bc\u6b04\u4f4d\u5fc5\u9808\u8207\u6240\u9078\u8a0a\u865f\u4e00\u81f4\u3002 +can.project.error.dbcRead=\u7121\u6cd5\u8b80\u53d6 DBC \u6a94\u6848\u3002 + +can.recording.error.storage=CAN \u539f\u59cb\u8a0a\u6846\u8a18\u9304\u5132\u5b58\u64cd\u4f5c\u5931\u6557\u3002 +can.recording.error.request=\u539f\u59cb\u8a0a\u6846\u8a18\u9304\u8b58\u5225\u78bc\u6216\u5206\u9801\u53c3\u6578\u7121\u6548\u3002 +can.recording.error.notFound=\u627e\u4e0d\u5230 CAN \u539f\u59cb\u8a0a\u6846\u8a18\u9304\u3002 +can.recording.error.active=\u8acb\u5148\u505c\u6b62\u8a72\u539f\u59cb\u8a0a\u6846\u9304\u88fd\uff0c\u518d\u522a\u9664\u8a18\u9304\u3002 +can.recording.error.closed=\u8a72\u539f\u59cb\u8a0a\u6846\u9304\u88fd\u5df2\u7d50\u675f\u3002 + +can.recorded.error.write=儲存 CAN 事件檔案失敗,請檢查儲存目錄、磁碟空間和寫入權限。 +can.recorded.error.register=CAN 事件檔案已建立,但登記錄製檔案失敗,請檢查專案資料庫。 +can.recorded.error.publish=CAN 事件檔案已寫入,但發佈錄製快照失敗,請檢查專案資料庫。 diff --git a/apps/backend/crydaq-server/src/test/java/com/opentest/controller/CanControllerTest.java b/apps/backend/crydaq-server/src/test/java/com/opentest/controller/CanControllerTest.java new file mode 100644 index 00000000..6ec1ac7b --- /dev/null +++ b/apps/backend/crydaq-server/src/test/java/com/opentest/controller/CanControllerTest.java @@ -0,0 +1,387 @@ +package com.opentest.controller; + +import cn.hutool.json.JSONConfig; +import cn.hutool.json.JSONObject; +import cn.hutool.json.JSONUtil; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.opentest.common.exception.CryExceptionHandler; +import com.opentest.common.i18n.GlobalLocaleProvider; +import com.opentest.common.utils.SpringContextHolder; +import com.opentest.configurer.CustomWebMvcConfigurer; +import com.opentest.configurer.I18nConfig; +import com.opentest.service.can.CanOperationException; +import com.opentest.service.can.CanService; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; +import org.junit.jupiter.params.provider.ValueSource; +import org.mockito.ArgumentCaptor; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import org.springframework.context.ApplicationContext; +import org.springframework.context.i18n.LocaleContext; +import org.springframework.context.i18n.LocaleContextHolder; +import org.springframework.context.support.GenericApplicationContext; +import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder; +import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter; +import org.springframework.mock.web.MockHttpSession; +import org.springframework.test.util.ReflectionTestUtils; +import org.springframework.test.web.servlet.MockMvc; +import org.springframework.test.web.servlet.request.MockHttpServletRequestBuilder; +import org.springframework.test.web.servlet.setup.MockMvcBuilders; +import org.springframework.validation.beanvalidation.LocalValidatorFactoryBean; +import org.springframework.web.HttpRequestMethodNotSupportedException; + +import java.io.InputStream; +import java.io.InputStreamReader; +import java.nio.charset.StandardCharsets; +import java.util.List; +import java.util.Locale; +import java.util.Properties; + +import static org.hamcrest.Matchers.not; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertInstanceOf; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoInteractions; +import static org.mockito.Mockito.when; +import static org.springframework.http.MediaType.APPLICATION_JSON; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; + +@ExtendWith(MockitoExtension.class) +class CanControllerTest { + private static final long DEVICE_ID = 9007199254740993L; + private static final String BASE = "/v1/device/9007199254740993/can"; + private static final String PORT = "CAN2"; + private static final String PORT_URL = BASE + "/ports/" + PORT; + private static final String CONFIGURATION = """ + {"schemaVersion":1,"receiveMode":"listen-only","canMode":"fd", + "nominalBitrate":500000,"dataBitrate":2000000, + "nominalSamplePoint":0.875,"dataSamplePoint":0.8, + "busOffRestartDelayMs":100, + "filters":[{"id":291,"mask":2047,"idFormat":"standard"}, + {"id":536870911,"mask":536870911,"idFormat":"extended"}]} + """; + + @Mock + private CanService can; + + private ApplicationContext previousContext; + private LocaleContext previousLocale; + private GenericApplicationContext context; + private LocalValidatorFactoryBean validator; + private ObjectMapper mapper; + private MockMvc http; + + @BeforeEach + void setUp() { + previousContext = (ApplicationContext) ReflectionTestUtils.getField(SpringContextHolder.class, "context"); + previousLocale = LocaleContextHolder.getLocaleContext(); + I18nConfig i18n = new I18nConfig(); + context = new GenericApplicationContext(); + context.getBeanFactory().registerSingleton("messageSource", i18n.messageSource()); + context.refresh(); + new SpringContextHolder().setApplicationContext(context); + + CustomWebMvcConfigurer configurer = new CustomWebMvcConfigurer(); + ReflectionTestUtils.setField(configurer, "targetPackages", + "com.opentest.common.model,com.opentest.service.liteflow.node"); + Jackson2ObjectMapperBuilder builder = Jackson2ObjectMapperBuilder.json(); + configurer.jsonCustomizer().customize(builder); + mapper = builder.build(); + validator = new LocalValidatorFactoryBean(); + validator.afterPropertiesSet(); + http = MockMvcBuilders.standaloneSetup(new CanController(can)) + .setControllerAdvice(new CryExceptionHandler()) + .setMessageConverters(new MappingJackson2HttpMessageConverter(mapper)) + .setValidator(validator) + .setLocaleResolver(i18n.localeResolver(context.getBeanProvider(GlobalLocaleProvider.class))) + .defaultRequest(get("/").session(new MockHttpSession())) + .build(); + } + + @AfterEach + void tearDown() { + new SpringContextHolder().setApplicationContext(previousContext); + LocaleContextHolder.setLocaleContext(previousLocale); + if (validator != null) validator.close(); + if (context != null) context.close(); + } + + @Test + void capabilitiesUseDeviceScopedGetAndCommonResultEnvelope() throws Exception { + when(can.capabilities(DEVICE_ID)).thenReturn(JSONUtil.parseObj(""" + {"supported":true,"enabled":true,"requestedEnabled":true, + "ports":[{"portId":"CAN2","canFdSupported":true}], + "constraints":{"nominalBitrates":[125000,500000]}} + """)); + + http.perform(get(BASE + "/capabilities")) + .andExpect(status().isOk()) + .andExpect(content().contentTypeCompatibleWith(APPLICATION_JSON)) + .andExpect(jsonPath("$.code").value(0)) + .andExpect(jsonPath("$.msg").value("")) + .andExpect(jsonPath("$.data.supported").value(true)) + .andExpect(jsonPath("$.data.enabled").value(true)) + .andExpect(jsonPath("$.data.requestedEnabled").value(true)) + .andExpect(jsonPath("$.data.ports[0].portId").value(PORT)) + .andExpect(jsonPath("$.data.constraints.nominalBitrates[1]").value(500000)); + verify(can).capabilities(DEVICE_ID); + } + + @Test + void unknownHardwareReadbackRemainsExplicitJsonNull() throws Exception { + JSONObject capabilities = new JSONObject(JSONConfig.create().setIgnoreNullValue(false)) + .set("supported", true).set("enabled", null).set("requestedEnabled", true); + when(can.capabilities(DEVICE_ID)).thenReturn(capabilities); + + JsonNode data = mapper.readTree(http.perform(get(BASE + "/capabilities")) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.code").value(0)) + .andReturn().getResponse().getContentAsByteArray()).path("data"); + + assertTrue(data.has("enabled"), "Unknown hardware readback must be present as JSON null"); + assertTrue(data.path("enabled").isNull(), "Unknown readback must not become false or an object"); + assertTrue(data.path("requestedEnabled").booleanValue()); + } + + @ParameterizedTest + @ValueSource(booleans = {true, false}) + void enablePostBindsBothBooleanValues(boolean enabled) throws Exception { + when(can.enable(DEVICE_ID, enabled)).thenReturn(new JSONObject().set("requestedEnabled", enabled)); + + http.perform(post(BASE + "/enabled").contentType(APPLICATION_JSON) + .content("{\"enabled\":" + enabled + "}")) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.code").value(0)) + .andExpect(jsonPath("$.data.requestedEnabled").value(enabled)); + verify(can).enable(DEVICE_ID, enabled); + } + + @Test + void portStatusRetainsOwnershipDiagnosticsAndExactRevision() throws Exception { + when(can.status(DEVICE_ID, PORT)).thenReturn(JSONUtil.parseObj(""" + {"portId":"CAN2","configurationRevision":"18446744073709551615", + "receiveId":"receive-2","manualReceiving":true,"state":"error", + "usages":[{"id":"manual","label":"manual"}], + "diagnostics":{"application":{"state":"error"}},"lastErrorCode":13103018} + """)); + + http.perform(get(PORT_URL)) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.code").value(0)) + .andExpect(jsonPath("$.data.portId").value(PORT)) + .andExpect(jsonPath("$.data.configurationRevision").isString()) + .andExpect(jsonPath("$.data.configurationRevision").value("18446744073709551615")) + .andExpect(jsonPath("$.data.receiveId").value("receive-2")) + .andExpect(jsonPath("$.data.manualReceiving").value(true)) + .andExpect(jsonPath("$.data.state").value("error")) + .andExpect(jsonPath("$.data.usages[0].id").value("manual")) + .andExpect(jsonPath("$.data.diagnostics.application.state").value("error")) + .andExpect(jsonPath("$.data.lastErrorCode").value(13103018)); + verify(can).status(DEVICE_ID, PORT); + } + + @ParameterizedTest + @ValueSource(booleans = {false, true}) + void configurationPostPreservesNativeObjectIncludingNullableSamplePoints(boolean nullable) throws Exception { + String body = nullable ? CONFIGURATION.replace("0.875", "null").replace("0.8", "null") : CONFIGURATION; + when(can.configuration(eq(DEVICE_ID), eq(PORT), any(JSONObject.class))) + .thenAnswer(call -> new JSONObject().set("portId", PORT) + .set("appliedConfig", call.getArgument(2, JSONObject.class)) + .set("configurationRevision", "9007199254740993").set("manualReceiving", false)); + + JsonNode response = mapper.readTree(http.perform(post(PORT_URL + "/configuration") + .contentType(APPLICATION_JSON).content(body)) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.code").value(0)) + .andExpect(jsonPath("$.data.configurationRevision").value("9007199254740993")) + .andExpect(jsonPath("$.data.manualReceiving").value(false)) + .andReturn().getResponse().getContentAsByteArray()); + + ArgumentCaptor configuration = ArgumentCaptor.forClass(JSONObject.class); + verify(can).configuration(eq(DEVICE_ID), eq(PORT), configuration.capture()); + assertEquals(mapper.readTree(body), mapper.readTree(configuration.getValue().toString()), + "The Native configuration must reach the service without renaming or dropping fields"); + assertEquals(mapper.readTree(body), response.path("data").path("appliedConfig"), + "The applied Native configuration must be a JSON object with the same numeric and null values"); + } + + @Test + void startAndStopUseTheirOfficialPostRoutes() throws Exception { + when(can.start(DEVICE_ID, PORT)).thenReturn(new JSONObject().set("portId", PORT) + .set("state", "running").set("manualReceiving", true).set("receiveId", "receive-2")); + when(can.stop(DEVICE_ID, PORT)).thenReturn(new JSONObject().set("portId", PORT) + .set("state", "stopped").set("manualReceiving", false)); + + http.perform(post(PORT_URL + "/start").contentType(APPLICATION_JSON).content("{}")) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.code").value(0)) + .andExpect(jsonPath("$.data.state").value("running")) + .andExpect(jsonPath("$.data.receiveId").value("receive-2")) + .andExpect(jsonPath("$.data.manualReceiving").value(true)); + http.perform(post(PORT_URL + "/stop").contentType(APPLICATION_JSON).content("{}")) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.code").value(0)) + .andExpect(jsonPath("$.data.state").value("stopped")) + .andExpect(jsonPath("$.data.manualReceiving").value(false)); + verify(can).start(DEVICE_ID, PORT); + verify(can).stop(DEVICE_ID, PORT); + } + + @Test + void framesPreserveUnsigned64BitCursorSequenceAndNanosecondStrings() throws Exception { + String after = "18446744073709551613"; + when(can.frames(DEVICE_ID, PORT, after)).thenReturn(JSONUtil.parseObj(""" + {"frames":[{"sequence":"18446744073709551614","canId":536870911, + "rawTimestampNs":"1794216167166000001","measurementTimeValid":false, + "sessionEpoch":"9007199254740993","mappingRevision":"9007199254740995", + "idFormat":"extended","frameType":"fd","flags":3,"length":3,"dlc":3, + "dataHex":"00A1FF","source":"bus-rx","timestampSource":"kernel-software", + "rawClockId":0}],"lastSequence":"18446744073709551614"} + """)); + + http.perform(get(PORT_URL + "/frames").param("after", after)) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.code").value(0)) + .andExpect(jsonPath("$.data.frames[0].sequence").isString()) + .andExpect(jsonPath("$.data.frames[0].sequence").value("18446744073709551614")) + .andExpect(jsonPath("$.data.frames[0].rawTimestampNs").isString()) + .andExpect(jsonPath("$.data.frames[0].rawTimestampNs").value("1794216167166000001")) + .andExpect(jsonPath("$.data.frames[0].canId").isNumber()) + .andExpect(jsonPath("$.data.frames[0].canId").value(536870911)) + .andExpect(jsonPath("$.data.frames[0].measurementTimeValid").value(false)) + .andExpect(jsonPath("$.data.frames[0].sessionEpoch").isString()) + .andExpect(jsonPath("$.data.frames[0].sessionEpoch").value("9007199254740993")) + .andExpect(jsonPath("$.data.frames[0].mappingRevision").isString()) + .andExpect(jsonPath("$.data.frames[0].mappingRevision").value("9007199254740995")) + .andExpect(jsonPath("$.data.frames[0].frameType").value("fd")) + .andExpect(jsonPath("$.data.frames[0].dataHex").value("00A1FF")) + .andExpect(jsonPath("$.data.lastSequence").isString()) + .andExpect(jsonPath("$.data.lastSequence").value("18446744073709551614")); + verify(can).frames(DEVICE_ID, PORT, after); + } + + @Test + void missingCursorDefaultsToZeroWithoutDroppingTheFramesArray() throws Exception { + when(can.frames(DEVICE_ID, PORT, "0")).thenReturn(JSONUtil.parseObj( + "{\"frames\":[],\"lastSequence\":null}", JSONConfig.create().setIgnoreNullValue(false))); + + JsonNode data = mapper.readTree(http.perform(get(PORT_URL + "/frames")) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.code").value(0)) + .andExpect(jsonPath("$.data.frames").isArray()) + .andExpect(jsonPath("$.data.frames").isEmpty()) + .andReturn().getResponse().getContentAsByteArray()).path("data"); + assertTrue(data.has("lastSequence"), "An empty preview must expose a null last sequence"); + assertTrue(data.path("lastSequence").isNull()); + verify(can).frames(DEVICE_ID, PORT, "0"); + } + + @ParameterizedTest + @CsvSource({"en, /lang/messages_en.properties", "zh-CN, /lang/messages.properties"}) + void operationFailuresKeepNativeCodeAndUseTheRequestedLanguage(String language, String bundle) throws Exception { + when(can.start(DEVICE_ID, PORT)).thenThrow(new CanOperationException(13103008, "can.error.busy")); + + http.perform(post(PORT_URL + "/start").locale(Locale.forLanguageTag(language))) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.code").value(13103008)) + .andExpect(jsonPath("$.msg").value(translation(bundle, "can.error.busy"))) + .andExpect(jsonPath("$.data").doesNotExist()); + } + + @ParameterizedTest + @CsvSource({"en, /lang/messages_en.properties", "zh-CN, /lang/messages.properties"}) + void missingNativeSymbolsReturnLocalizedFailureInsteadOfSuccessfulEmptyData(String language, String bundle) + throws Exception { + when(can.capabilities(DEVICE_ID)).thenThrow(new UnsatisfiedLinkError("internal-native-symbol")); + + http.perform(get(BASE + "/capabilities").locale(Locale.forLanguageTag(language))) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.code").value(13103001)) + .andExpect(jsonPath("$.msg").value(translation(bundle, "can.error.nativeUnavailable"))) + .andExpect(jsonPath("$.data").doesNotExist()); + } + + @ParameterizedTest + @ValueSource(strings = {"", "null", "{}", "{\"enabled\":null}", "{\"enabled\":[]}"}) + void missingOrInvalidEnabledNeverDisablesHardware(String body) throws Exception { + http.perform(post(BASE + "/enabled").contentType(APPLICATION_JSON).content(body)) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.code").value(not(0))) + .andExpect(jsonPath("$.data").doesNotExist()); + verifyNoInteractions(can); + } + + @ParameterizedTest + @ValueSource(strings = {"", "null", "[]"}) + void missingOrNonObjectConfigurationDoesNotReachNativeConfiguration(String body) throws Exception { + http.perform(post(PORT_URL + "/configuration").contentType(APPLICATION_JSON).content(body)) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.code").value(not(0))) + .andExpect(jsonPath("$.data").doesNotExist()); + verifyNoInteractions(can); + } + + @Test + void literalNullCursorReturnsTheLocalizedServiceError() throws Exception { + when(can.frames(DEVICE_ID, PORT, "null")) + .thenThrow(new CanOperationException(13103001, "can.error.invalidCursor")); + + http.perform(get(PORT_URL + "/frames").param("after", "null").locale(Locale.ENGLISH)) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.code").value(13103001)) + .andExpect(jsonPath("$.msg").value(translation("/lang/messages_en.properties", "can.error.invalidCursor"))); + verify(can).frames(DEVICE_ID, PORT, "null"); + } + + @ParameterizedTest + @ValueSource(strings = {"null", "not-a-device", "9223372036854775808"}) + void invalidDeviceIdentityIsRejectedBeforeCallingTheService(String deviceId) throws Exception { + http.perform(get("/v1/device/{deviceId}/can/capabilities", deviceId)) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.code").value(not(0))); + verifyNoInteractions(can); + } + + @Test + void readRoutesRejectPostAndMutationRoutesRejectGetAndPut() throws Exception { + for (MockHttpServletRequestBuilder request : List.of( + post(BASE + "/capabilities"), post(PORT_URL), post(PORT_URL + "/frames"), + get(BASE + "/enabled"), get(PORT_URL + "/configuration"), + get(PORT_URL + "/start"), get(PORT_URL + "/stop"), + put(PORT_URL + "/configuration").contentType(APPLICATION_JSON).content(CONFIGURATION))) { + http.perform(request) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.code").value(not(0))) + .andExpect(result -> assertInstanceOf(HttpRequestMethodNotSupportedException.class, + result.getResolvedException())); + } + verifyNoInteractions(can); + } + + private String translation(String resource, String key) throws Exception { + Properties properties = new Properties(); + try (InputStream input = getClass().getResourceAsStream(resource)) { + assertNotNull(input, resource); + properties.load(new InputStreamReader(input, StandardCharsets.UTF_8)); + } + String value = properties.getProperty(key); + assertNotNull(value, key); + assertTrue(!value.isBlank() && !value.equals(key), "The error needs a translated message"); + return value; + } +} diff --git a/apps/backend/crydaq-server/src/test/java/com/opentest/controller/CanDbcControllerTest.java b/apps/backend/crydaq-server/src/test/java/com/opentest/controller/CanDbcControllerTest.java new file mode 100644 index 00000000..5107fbb4 --- /dev/null +++ b/apps/backend/crydaq-server/src/test/java/com/opentest/controller/CanDbcControllerTest.java @@ -0,0 +1,117 @@ +package com.opentest.controller; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.opentest.common.annotation.RequireLocalPermission; +import com.opentest.common.enums.LocalPermissionCodeEnum; +import com.opentest.common.exception.CryBusinessException; +import com.opentest.common.utils.SpringContextHolder; +import com.opentest.configurer.I18nConfig; +import com.opentest.service.can.CanDbcService; +import java.io.ByteArrayInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.util.Arrays; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.springframework.context.ApplicationContext; +import org.springframework.context.support.GenericApplicationContext; +import org.springframework.mock.web.MockHttpSession; +import org.springframework.mock.web.MockMultipartFile; +import org.springframework.test.util.ReflectionTestUtils; +import org.springframework.test.web.servlet.MockMvc; +import org.springframework.test.web.servlet.setup.MockMvcBuilders; +import org.springframework.web.multipart.MultipartFile; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.AdditionalMatchers.aryEq; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoInteractions; +import static org.mockito.Mockito.when; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.multipart; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; + +class CanDbcControllerTest { + private final CanDbcService dbc = mock(CanDbcService.class); + private final CanDbcController controller = new CanDbcController(dbc); + private ApplicationContext previousContext; + private GenericApplicationContext context; + + @BeforeEach void messages() { + previousContext = (ApplicationContext) ReflectionTestUtils.getField(SpringContextHolder.class, "context"); + context = new GenericApplicationContext(); + context.getBeanFactory().registerSingleton("messageSource", new I18nConfig().messageSource()); + context.refresh(); new SpringContextHolder().setApplicationContext(context); + } + @AfterEach void restore() { + new SpringContextHolder().setApplicationContext(previousContext); context.close(); + } + + @Test void exactMultipartEndpointPreservesNativeSchemaAndSelectionIdentity() throws Exception { + byte[] bytes = { (byte) 0xef, (byte) 0xbb, (byte) 0xbf, 42 }; + JsonNode data = new ObjectMapper().readTree(""" + {"schemaVersion":1,"parser":"opentest-integer-dbc-subset-v1","encoding":"UTF-8", + "limits":{"inputBytes":5000000},"messages":[{"messageId":"2147484032","canId":384, + "idFormat":"extended","name":"Engine","length":8,"frameType":"any","signals":[ + {"name":"Rpm","signalId":"dbc-2147484032-Rpm","unit":"rpm","supported":false, + "unitMetadata":{"category":"rotational-speed","normalizedUnit":"rpm","scaleToBase":1}, + "unsupportedReason":"multiplexing is unsupported","definition":null}]}]} + """); + when(dbc.parse(any())).thenReturn(data); + http().perform(multipart("/v1/project-channel/can/dbc/parse") + .file(new MockMultipartFile("file", "original.dbc", "application/octet-stream", bytes))) + .andExpect(status().isOk()).andExpect(jsonPath("$.code").value(0)) + .andExpect(jsonPath("$.data").value(new ObjectMapper().convertValue(data, Object.class))) + .andExpect(jsonPath("$.data.messages[0].messageId").value("2147484032")) + .andExpect(jsonPath("$.data.messages[0].canId").value(384)); + verify(dbc).parse(aryEq(bytes)); + assertEquals(LocalPermissionCodeEnum.HARDWARE_CHANNEL_SETUP, + CanDbcController.class.getMethod("parse", MultipartFile.class) + .getAnnotation(RequireLocalPermission.class).value()); + } + + @Test void wrongMultipartFieldIsRejected() throws Exception { + http().perform(multipart("/v1/project-channel/can/dbc/parse") + .file(new MockMultipartFile("dbc", "original.dbc", "text/plain", new byte[]{1}))) + .andExpect(status().isBadRequest()); + verifyNoInteractions(dbc); + } + + @Test void rejectsEmptyOversizedAndMissingOriginalFilenameBeforeParser() { + for (MockMultipartFile file : new MockMultipartFile[]{ + new MockMultipartFile("file", "original.dbc", "text/plain", new byte[0]), + new MockMultipartFile("file", "original.dbc", "text/plain", new byte[CanDbcService.MAX_BYTES + 1]), + new MockMultipartFile("file", "", "text/plain", new byte[]{1})}) { + assertThrows(CryBusinessException.class, () -> controller.parse(file)); + } + verifyNoInteractions(dbc); + } + + @Test void streamIsBoundedEvenWhenMultipartReportedSizeDisagrees() { + byte[] bytes = new byte[CanDbcService.MAX_BYTES + 20]; Arrays.fill(bytes, (byte) 42); + MockMultipartFile file = new MockMultipartFile("file", "original.dbc", "text/plain", new byte[]{1}) { + @Override public InputStream getInputStream() { return new ByteArrayInputStream(bytes); } + }; + when(dbc.parse(any())).thenThrow(new CryBusinessException("oversized DBC")); + assertThrows(CryBusinessException.class, () -> controller.parse(file)); + verify(dbc).parse(aryEq(Arrays.copyOf(bytes, CanDbcService.MAX_BYTES + 1))); + } + + @Test void readFailureDoesNotInvokeParser() { + MockMultipartFile file = new MockMultipartFile("file", "original.dbc", "text/plain", new byte[]{1}) { + @Override public InputStream getInputStream() throws IOException { throw new IOException("unreadable"); } + }; + assertThrows(CryBusinessException.class, () -> controller.parse(file)); + verifyNoInteractions(dbc); + } + + private MockMvc http() { + return MockMvcBuilders.standaloneSetup(controller) + .defaultRequest(get("/").session(new MockHttpSession())).build(); + } +} diff --git a/apps/backend/crydaq-server/src/test/java/com/opentest/controller/CanProjectChannelControllerTest.java b/apps/backend/crydaq-server/src/test/java/com/opentest/controller/CanProjectChannelControllerTest.java new file mode 100644 index 00000000..91c7558d --- /dev/null +++ b/apps/backend/crydaq-server/src/test/java/com/opentest/controller/CanProjectChannelControllerTest.java @@ -0,0 +1,107 @@ +package com.opentest.controller; + +import com.fasterxml.jackson.databind.ObjectMapper; +import com.opentest.common.annotation.RequireLocalPermission; +import com.opentest.common.enums.LocalPermissionCodeEnum; +import com.opentest.common.model.dto.BoxChannelDto; +import com.opentest.common.model.dto.CanChannelSaveRequestDto; +import com.opentest.service.can.CanProjectChannelService; +import com.opentest.configurer.I18nConfig; +import com.opentest.common.utils.SpringContextHolder; +import com.opentest.configurer.CustomWebMvcConfigurer; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.ArgumentCaptor; +import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter; +import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder; +import org.springframework.context.ApplicationContext; +import org.springframework.context.support.GenericApplicationContext; +import org.springframework.mock.web.MockHttpSession; +import org.springframework.test.util.ReflectionTestUtils; +import org.springframework.test.web.servlet.MockMvc; +import org.springframework.test.web.servlet.setup.MockMvcBuilders; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static org.springframework.http.MediaType.APPLICATION_JSON; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; + +class CanProjectChannelControllerTest { + private final ObjectMapper json = new ObjectMapper(); + private final CanProjectChannelService can = mock(CanProjectChannelService.class); + private ApplicationContext previousContext; + private GenericApplicationContext context; + + @BeforeEach void messages() { + previousContext = (ApplicationContext) ReflectionTestUtils.getField(SpringContextHolder.class, "context"); + context = new GenericApplicationContext(); + context.getBeanFactory().registerSingleton("messageSource", new I18nConfig().messageSource()); + context.refresh(); + new SpringContextHolder().setApplicationContext(context); + } + @AfterEach void restoreMessages() { + new SpringContextHolder().setApplicationContext(previousContext); + context.close(); + } + + @Test + void saveConsumesExactWireStringAndReturnsNormalProjectRow() throws Exception { + String definition = "{\"schemaVersion\":1,\"portId\":\"can0\",\"decodeMethod\":\"manual\"}"; + BoxChannelDto result = new BoxChannelDto(); + result.setId(9007199254740993L); + result.setVchId("CAN1"); + result.setChannelSource(2); + result.setCanDefinitionJson(definition); + when(can.save(any())).thenReturn(result); + CanChannelSaveRequestDto request = new CanChannelSaveRequestDto(); + request.setProjectId(11L); + request.setDeviceId(22L); + request.setCustomName("Engine"); + request.setCanDefinitionJson(definition); + http().perform(post("/v1/project-channel/can/save").contentType(APPLICATION_JSON) + .content(json.writeValueAsBytes(request))) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.data.id").value("9007199254740993")) + .andExpect(jsonPath("$.data.channelSource").value(2)) + .andExpect(jsonPath("$.data.canDefinitionJson").value(definition)) + .andExpect(jsonPath("$.data.samplingRate").doesNotExist()) + .andExpect(jsonPath("$.data.channelId").doesNotExist()); + ArgumentCaptor captured = ArgumentCaptor.forClass(CanChannelSaveRequestDto.class); + verify(can).save(captured.capture()); + assertEquals(definition, captured.getValue().getCanDefinitionJson()); + } + + @Test + void deleteUsesProjectRowIdAndBothMutationsUseNormalSetupPermission() throws Exception { + when(can.delete(33L)).thenReturn(true); + http().perform(delete("/v1/project-channel/can/33")) + .andExpect(status().isOk()).andExpect(jsonPath("$.data").value(true)); + verify(can).delete(33L); + for (String method : new String[]{"saveCanChannel", "deleteCanChannel"}) { + Class input = method.equals("saveCanChannel") ? CanChannelSaveRequestDto.class : Long.class; + RequireLocalPermission permission = BoxChannelController.class.getMethod(method, input) + .getAnnotation(RequireLocalPermission.class); + assertEquals(LocalPermissionCodeEnum.HARDWARE_CHANNEL_SETUP, permission.value()); + } + } + + private MockMvc http() { + BoxChannelController controller = new BoxChannelController(); + ReflectionTestUtils.setField(controller, "canProjectChannelService", can); + CustomWebMvcConfigurer configurer = new CustomWebMvcConfigurer(); + ReflectionTestUtils.setField(configurer, "targetPackages", "com.opentest.common.model,com.opentest.service.liteflow.node"); + var builder = Jackson2ObjectMapperBuilder.json(); + configurer.jsonCustomizer().customize(builder); + return MockMvcBuilders.standaloneSetup(controller) + .setMessageConverters(new MappingJackson2HttpMessageConverter(builder.build())) + .defaultRequest(get("/").session(new MockHttpSession())).build(); + } +} diff --git a/apps/backend/crydaq-server/src/test/java/com/opentest/controller/CanRawFramesControllerTest.java b/apps/backend/crydaq-server/src/test/java/com/opentest/controller/CanRawFramesControllerTest.java new file mode 100644 index 00000000..a55d0a4f --- /dev/null +++ b/apps/backend/crydaq-server/src/test/java/com/opentest/controller/CanRawFramesControllerTest.java @@ -0,0 +1,122 @@ +package com.opentest.controller; + +import cn.hutool.json.JSONUtil; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.opentest.common.i18n.GlobalLocaleProvider; +import com.opentest.common.utils.SpringContextHolder; +import com.opentest.configurer.I18nConfig; +import com.opentest.service.can.CanOperationException; +import com.opentest.service.can.CanService; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import org.springframework.context.ApplicationContext; +import org.springframework.context.i18n.LocaleContext; +import org.springframework.context.i18n.LocaleContextHolder; +import org.springframework.context.support.GenericApplicationContext; +import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter; +import org.springframework.mock.web.MockHttpSession; +import org.springframework.test.util.ReflectionTestUtils; +import org.springframework.test.web.servlet.MockMvc; +import org.springframework.test.web.servlet.setup.MockMvcBuilders; + +import static org.hamcrest.Matchers.containsString; +import static org.hamcrest.Matchers.hasKey; +import static org.hamcrest.Matchers.nullValue; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoInteractions; +import static org.mockito.Mockito.verifyNoMoreInteractions; +import static org.mockito.Mockito.when; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; + +@ExtendWith(MockitoExtension.class) +class CanRawFramesControllerTest { + @Mock private CanService can; + private MockMvc http; + private GenericApplicationContext context; + private ApplicationContext previousContext; + private LocaleContext previousLocale; + + @BeforeEach + void setUp() { + previousContext = (ApplicationContext) ReflectionTestUtils.getField(SpringContextHolder.class, "context"); + previousLocale = LocaleContextHolder.getLocaleContext(); + I18nConfig i18n = new I18nConfig(); + context = new GenericApplicationContext(); + context.getBeanFactory().registerSingleton("messageSource", i18n.messageSource()); + context.refresh(); + new SpringContextHolder().setApplicationContext(context); + http = MockMvcBuilders.standaloneSetup(new CanRawFramesController(can)) + .setMessageConverters(new MappingJackson2HttpMessageConverter(new ObjectMapper())) + .setLocaleResolver(i18n.localeResolver(context.getBeanProvider(GlobalLocaleProvider.class))) + .defaultRequest(get("/").session(new MockHttpSession())) + .build(); + } + + @AfterEach + void tearDown() { + new SpringContextHolder().setApplicationContext(previousContext); + LocaleContextHolder.setLocaleContext(previousLocale); + if (context != null) context.close(); + } + + @Test + void catalogUsesGlobalGetAndPreservesExactSourceFacts() throws Exception { + when(can.rawSources()).thenReturn(JSONUtil.parseObj(""" + {"sources":[{"sourceId":"fixture/device/can0","deviceId":"9007199254740993", + "deviceName":"CAN fixture","protocol":"fixture","portId":"can0", + "receiveId":"can-process-1","state":"running","manualReceiving":true, + "usages":[{"id":"manual","label":"manual"}],"diagnostics":null, + "lastErrorCode":null,"metadata":{"epoch":"18446744073709551615", + "lastSequence":"18446744073709551614","complete":false}}]} + """)); + http.perform(get("/v1/can/raw-frames/sources")) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.code").value(0)) + .andExpect(jsonPath("$.data.sources[0].deviceId").value("9007199254740993")) + .andExpect(jsonPath("$.data.sources[0].metadata.lastSequence").value("18446744073709551614")) + .andExpect(jsonPath("$.data.sources[0].metadata.complete").value(false)) + .andExpect(jsonPath("$.data.sources[0]", hasKey("diagnostics"))) + .andExpect(jsonPath("$.data.sources[0].diagnostics").value(nullValue())) + .andExpect(jsonPath("$.data.sources[0].usages[0].id").value("manual")); + verify(can).rawSources(); + verifyNoMoreInteractions(can); + } + + @Test + void emptyCatalogIsNotAnInventedLivePort() throws Exception { + when(can.rawSources()).thenReturn(JSONUtil.parseObj("{\"sources\":[]}")); + http.perform(get("/v1/can/raw-frames/sources")) + .andExpect(status().isOk()).andExpect(jsonPath("$.data.sources").isEmpty()); + verify(can).rawSources(); + verifyNoMoreInteractions(can); + } + + @Test + void catalogCannotStartOrChangeReception() throws Exception { + http.perform(post("/v1/can/raw-frames/sources")).andExpect(status().isMethodNotAllowed()); + verifyNoInteractions(can); + } + + @Test + void operationFailureUsesLocalizedBusinessEnvelope() throws Exception { + when(can.rawSources()).thenThrow(new CanOperationException(13103019, "can.error.invalidResponse")); + http.perform(get("/v1/can/raw-frames/sources").header("Accept-Language", "en")) + .andExpect(status().isOk()).andExpect(jsonPath("$.code").value(13103019)) + .andExpect(jsonPath("$.msg", containsString("CAN"))); + } + + @Test + void missingNativeUsesExistingUnavailableError() throws Exception { + when(can.rawSources()).thenThrow(new UnsatisfiedLinkError("missing CAN JNI")); + http.perform(get("/v1/can/raw-frames/sources").header("Accept-Language", "en")) + .andExpect(status().isOk()).andExpect(jsonPath("$.code").value(13103001)) + .andExpect(jsonPath("$.msg", containsString("CAN"))); + } +} diff --git a/apps/backend/crydaq-server/src/test/java/com/opentest/controller/CanRawRecordingControllerTest.java b/apps/backend/crydaq-server/src/test/java/com/opentest/controller/CanRawRecordingControllerTest.java new file mode 100644 index 00000000..dbdacb9b --- /dev/null +++ b/apps/backend/crydaq-server/src/test/java/com/opentest/controller/CanRawRecordingControllerTest.java @@ -0,0 +1,265 @@ +package com.opentest.controller; + +import cn.hutool.json.JSONConfig; +import cn.hutool.json.JSONObject; +import cn.hutool.json.JSONUtil; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.opentest.common.exception.CryExceptionHandler; +import com.opentest.common.i18n.GlobalLocaleProvider; +import com.opentest.common.utils.SpringContextHolder; +import com.opentest.configurer.CustomWebMvcConfigurer; +import com.opentest.configurer.I18nConfig; +import com.opentest.service.can.CanOperationException; +import com.opentest.service.can.CanRawRecordingStore; +import com.opentest.service.can.CanService; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.jupiter.api.io.TempDir; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; +import org.junit.jupiter.params.provider.ValueSource; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import org.springframework.context.ApplicationContext; +import org.springframework.context.i18n.LocaleContext; +import org.springframework.context.i18n.LocaleContextHolder; +import org.springframework.context.support.GenericApplicationContext; +import org.springframework.http.HttpHeaders; +import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder; +import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter; +import org.springframework.mock.web.MockHttpSession; +import org.springframework.test.util.ReflectionTestUtils; +import org.springframework.test.web.servlet.MockMvc; +import org.springframework.test.web.servlet.setup.MockMvcBuilders; + +import java.io.InputStreamReader; +import java.math.BigInteger; +import java.nio.charset.StandardCharsets; +import java.nio.file.Path; +import java.util.List; +import java.util.Locale; +import java.util.Properties; +import java.util.UUID; +import java.util.stream.IntStream; + +import static org.hamcrest.Matchers.containsString; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoInteractions; +import static org.mockito.Mockito.when; +import static org.springframework.http.MediaType.APPLICATION_JSON; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.header; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; + +@ExtendWith(MockitoExtension.class) +class CanRawRecordingControllerTest { + private static final long DEVICE_ID = 9007199254740993L; + private static final String PORT = "CAN2"; + private static final String CONTROL = "/v1/device/9007199254740993/can/ports/CAN2/recording"; + private static final String RECORDINGS = "/v1/can/raw-frames/recordings"; + @TempDir Path base; + @Mock private CanService can; + private ApplicationContext previousContext; + private LocaleContext previousLocale; + private GenericApplicationContext context; + private ObjectMapper mapper; + private CanRawRecordingStore store; + private MockMvc http; + + @BeforeEach + void setUp() { + previousContext = (ApplicationContext) ReflectionTestUtils.getField(SpringContextHolder.class, "context"); + previousLocale = LocaleContextHolder.getLocaleContext(); + I18nConfig i18n = new I18nConfig(); + context = new GenericApplicationContext(); + context.getBeanFactory().registerSingleton("messageSource", i18n.messageSource()); + context.refresh(); + new SpringContextHolder().setApplicationContext(context); + CustomWebMvcConfigurer configurer = new CustomWebMvcConfigurer(); + ReflectionTestUtils.setField(configurer, "targetPackages", + "com.opentest.common.model,com.opentest.service.liteflow.node"); + Jackson2ObjectMapperBuilder builder = Jackson2ObjectMapperBuilder.json(); + configurer.jsonCustomizer().customize(builder); + mapper = builder.build(); + store = new CanRawRecordingStore(base, mapper); + http = MockMvcBuilders.standaloneSetup(new CanRawRecordingController(can, store)) + .setControllerAdvice(new CryExceptionHandler()) + .setMessageConverters(new MappingJackson2HttpMessageConverter(mapper)) + .setLocaleResolver(i18n.localeResolver(context.getBeanProvider(GlobalLocaleProvider.class))) + .defaultRequest(get("/").session(new MockHttpSession())) + .build(); + } + + @AfterEach + void tearDown() { + new SpringContextHolder().setApplicationContext(previousContext); + LocaleContextHolder.setLocaleContext(previousLocale); + if (context != null) context.close(); + } + + @Test + void portStartAndStopReturnTheMainOwnedLifecycleStatusWithExplicitNulls() throws Exception { + CanRawRecordingStore.Recording recording = store.begin(source(), new JSONObject()); + JSONObject started = new JSONObject(JSONConfig.create().setIgnoreNullValue(false)) + .set("portId", PORT).set("state", "running").set("manualReceiving", true) + .set("recording", recording.snapshot()).set("recordingErrorCode", null); + when(can.startRecording(DEVICE_ID, PORT)).thenReturn(started); + JsonNode data = mapper.readTree(http.perform(post(CONTROL + "/start") + .contentType(APPLICATION_JSON).content("{\"path\":\"/ignored-caller-path\"}")) + .andExpect(status().isOk()).andExpect(jsonPath("$.code").value(0)) + .andExpect(jsonPath("$.data.recording.deviceId").value("9007199254740993")) + .andExpect(jsonPath("$.data.recording.frameCount").value("0")) + .andExpect(jsonPath("$.data.manualReceiving").value(true)) + .andReturn().getResponse().getContentAsByteArray()).path("data"); + assertTrue(data.path("recording").has("finishedAtEpochMs")); + assertTrue(data.path("recording").path("finishedAtEpochMs").isNull()); + assertTrue(data.has("recordingErrorCode")); + assertTrue(data.path("recordingErrorCode").isNull()); + when(can.stopRecording(DEVICE_ID, PORT)).thenReturn(new JSONObject(JSONConfig.create().setIgnoreNullValue(false)) + .set("recording", null).set("recordingErrorCode", null).set("state", "running").set("manualReceiving", true)); + JsonNode stopped = mapper.readTree(http.perform(post(CONTROL + "/stop")) + .andExpect(status().isOk()).andExpect(jsonPath("$.code").value(0)) + .andExpect(jsonPath("$.data.state").value("running")) + .andReturn().getResponse().getContentAsByteArray()).path("data"); + assertTrue(stopped.has("recording") && stopped.path("recording").isNull()); + verify(can).startRecording(DEVICE_ID, PORT); + verify(can).stopRecording(DEVICE_ID, PORT); + recording.finish(new JSONObject(), true); + } + + @Test + void historyAndPagedFramesReadPersistedDataThroughTheNormalJsonConfiguration() throws Exception { + CanRawRecordingStore.Recording recording = completed(2, false); + http.perform(get(RECORDINGS)).andExpect(status().isOk()) + .andExpect(content().contentTypeCompatibleWith(APPLICATION_JSON)) + .andExpect(jsonPath("$.code").value(0)) + .andExpect(jsonPath("$.data.records[0].id").value(recording.id())) + .andExpect(jsonPath("$.data.records[0].frameCount").value("2")) + .andExpect(jsonPath("$.data.records[0].complete").value(false)); + JsonNode data = mapper.readTree(http.perform(get(RECORDINGS + "/{id}/frames", recording.id()) + .param("offset", "1").param("limit", "1")) + .andExpect(status().isOk()).andExpect(jsonPath("$.code").value(0)) + .andExpect(jsonPath("$.data.offset").value("1")) + .andExpect(jsonPath("$.data.nextOffset").value("2")) + .andExpect(jsonPath("$.data.frameCount").value("2")) + .andExpect(jsonPath("$.data.frames[0].sequence").value("18446744073709551616")) + .andExpect(jsonPath("$.data.frames[0].flags").value(27)) + .andReturn().getResponse().getContentAsByteArray()).path("data"); + assertTrue(data.path("frames").get(0).path("measurementTimeNs").isNull()); + assertEquals("9007199254740993", data.path("frames").get(0).path("origin").path("deviceId").textValue()); + assertTrue(data.path("metadata").path("unknownCounter").isNull()); + verifyNoInteractions(can); + } + + @Test + void defaultDisplayPageIsBoundedButCsvDownloadsEveryFrameFromDisk() throws Exception { + CanRawRecordingStore.Recording recording = completed(1507, true); + http.perform(get(RECORDINGS + "/{id}/frames", recording.id())) + .andExpect(jsonPath("$.data.frames.length()").value(1000)) + .andExpect(jsonPath("$.data.nextOffset").value("1000")); + String csv = http.perform(get(RECORDINGS + "/{id}/csv", recording.id())) + .andExpect(status().isOk()).andExpect(content().contentTypeCompatibleWith("text/csv")) + .andExpect(header().string(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"can-raw-" + recording.id() + ".csv\"")) + .andExpect(header().string(HttpHeaders.CACHE_CONTROL, "no-store")) + .andExpect(content().string(containsString("18446744073709553121"))) + .andReturn().getResponse().getContentAsString(StandardCharsets.UTF_8); + assertEquals(1508, csv.lines().count()); + assertTrue(csv.contains("measurementTimeValid")); + assertTrue(csv.contains("origin.receiveId")); + assertFalse(csv.contains("$.")); + verifyNoInteractions(can); + } + + @Test + void deleteUsesOnlyTheGlobalRecordingId() throws Exception { + CanRawRecordingStore.Recording recording = completed(1, true); + http.perform(delete(RECORDINGS + "/{id}", recording.id())) + .andExpect(status().isOk()).andExpect(jsonPath("$.code").value(0)); + http.perform(get(RECORDINGS)).andExpect(jsonPath("$.data.records.length()").value(0)); + http.perform(get(RECORDINGS + "/{id}/frames", recording.id())) + .andExpect(jsonPath("$.code").value(CanRawRecordingStore.NOT_FOUND)); + verifyNoInteractions(can); + } + + @ParameterizedTest + @ValueSource(strings = {"-1", "null", "0.5", "9223372036854775808", "../outside", "00"}) + void invalidOffsetUsesTheLocalizedRecordingError(String offset) throws Exception { + http.perform(get(RECORDINGS + "/{id}/frames", UUID.randomUUID().toString()).param("offset", offset)) + .andExpect(status().isOk()).andExpect(jsonPath("$.code").value(CanRawRecordingStore.INVALID_REQUEST)); + verifyNoInteractions(can); + } + + @ParameterizedTest + @ValueSource(strings = {"0", "1001", "-1", "null", "2147483648"}) + void invalidLimitUsesTheRecordingError(String limit) throws Exception { + http.perform(get(RECORDINGS + "/{id}/frames", UUID.randomUUID().toString()).param("limit", limit)) + .andExpect(status().isOk()).andExpect(jsonPath("$.code").value(CanRawRecordingStore.INVALID_REQUEST)); + verifyNoInteractions(can); + } + + @ParameterizedTest + @CsvSource({"en,en", "zh-CN,zh", "zh-TW,zh_TW", "de,de", "es,es", "fr,fr", "ja,ja", "ko,ko", "ru,ru", "tr,tr"}) + void storageFailuresUseTheOrdinaryLocalizedErrorEnvelope(String language, String bundle) throws Exception { + when(can.startRecording(DEVICE_ID, PORT)).thenThrow(new CanOperationException( + CanRawRecordingStore.STORAGE_ERROR, "can.recording.error.storage", new IllegalStateException("private storage path"))); + String response = http.perform(post(CONTROL + "/start").locale(Locale.forLanguageTag(language))) + .andExpect(status().isOk()).andExpect(jsonPath("$.code").value(CanRawRecordingStore.STORAGE_ERROR)) + .andExpect(jsonPath("$.msg").value(translation(bundle, "can.recording.error.storage"))) + .andReturn().getResponse().getContentAsString(StandardCharsets.UTF_8); + assertFalse(response.contains("private storage path")); + } + + @Test + void invalidDownloadIdsReturnJsonInsteadOfCsvAndActiveDeleteIsRejected() throws Exception { + http.perform(get(RECORDINGS + "/not-a-uuid/csv")) + .andExpect(content().contentTypeCompatibleWith(APPLICATION_JSON)) + .andExpect(jsonPath("$.code").value(CanRawRecordingStore.INVALID_REQUEST)) + .andExpect(header().doesNotExist(HttpHeaders.CONTENT_DISPOSITION)); + CanRawRecordingStore.Recording active = store.begin(source(), new JSONObject()); + http.perform(delete(RECORDINGS + "/{id}", active.id())) + .andExpect(jsonPath("$.code").value(CanRawRecordingStore.ACTIVE_RECORDING)); + active.finish(new JSONObject(), true); + verifyNoInteractions(can); + } + + private CanRawRecordingStore.Recording completed(int count, boolean complete) { + CanRawRecordingStore.Recording recording = store.begin(source(), new JSONObject()); + List frames = IntStream.range(0, count).mapToObj(index -> json(""" + {"canId":536870911,"flags":27,"rawTimestampNs":"1794216167166000001", + "sessionEpoch":"18446744073709551615","mappingRevision":"9007199254740995", + "measurementTimeValid":false,"measurementTimeNs":null,"receivedAtEpochMs":"1794216167166", + "origin":{"deviceId":"9007199254740993","receiveId":"receive-2","epoch":"42"}} + """).set("sequence", new BigInteger("18446744073709551615").add(BigInteger.valueOf(index)).toString())).toList(); + recording.append(frames, json("{\"unknownCounter\":null,\"epoch\":\"42\"}")); + recording.finish(new JSONObject(), complete); + return recording; + } + + private static JSONObject source() { + return json("{\"deviceId\":\"9007199254740993\",\"deviceName\":\"device\",\"protocol\":\"SonoDAQ\"," + + "\"portId\":\"CAN2\",\"receiveId\":\"receive-2\"}"); + } + private static JSONObject json(String text) { return JSONUtil.parseObj(text, JSONConfig.create().setIgnoreNullValue(false)); } + private String translation(String bundle, String key) throws Exception { + Properties values = new Properties(); + try (var input = getClass().getResourceAsStream("/lang/messages_" + bundle + ".properties")) { + assertNotNull(input); + values.load(new InputStreamReader(input, StandardCharsets.UTF_8)); + } + String value = values.getProperty(key); + assertNotNull(value); + assertFalse(value.isBlank()); + return value; + } +} diff --git a/apps/backend/crydaq-server/src/test/java/com/opentest/migration/CanProjectDefinitionMigrationTest.java b/apps/backend/crydaq-server/src/test/java/com/opentest/migration/CanProjectDefinitionMigrationTest.java new file mode 100644 index 00000000..42e4a7af --- /dev/null +++ b/apps/backend/crydaq-server/src/test/java/com/opentest/migration/CanProjectDefinitionMigrationTest.java @@ -0,0 +1,44 @@ +package com.opentest.migration; + +import org.junit.jupiter.api.Test; + +import java.nio.charset.StandardCharsets; +import java.sql.DriverManager; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class CanProjectDefinitionMigrationTest { + @Test + void addsNullableDefinitionWithoutChangingExistingPhysicalAndMathRows() throws Exception { + try (var connection = DriverManager.getConnection("jdbc:sqlite::memory:"); + var statement = connection.createStatement(); + var migration = getClass().getResourceAsStream( + "/db/migration/V2.5.0_20261110160000__add_project_can_definition.sql")) { + assertNotNull(migration); + statement.execute("CREATE TABLE box_channel (id INTEGER PRIMARY KEY, project_id INTEGER, channel_source INTEGER)"); + statement.execute("INSERT INTO box_channel VALUES (1, 11, 0), (2, 11, 1)"); + statement.execute(new String(migration.readAllBytes(), StandardCharsets.UTF_8)); + try (var rows = statement.executeQuery("SELECT id, channel_source, can_definition_json FROM box_channel ORDER BY id")) { + assertTrue(rows.next()); + assertEquals(0, rows.getInt("channel_source")); + assertNull(rows.getString("can_definition_json")); + assertTrue(rows.next()); + assertEquals(1, rows.getInt("channel_source")); + assertNull(rows.getString("can_definition_json")); + } + String definition = "{\"schemaVersion\":1,\"definition\":{\"invalidRawValue\":\"0x1fffffffffffff\"}}"; + try (var insert = connection.prepareStatement("INSERT INTO box_channel VALUES (3,11,2,?)")) { + insert.setString(1, definition); + insert.executeUpdate(); + } + try (var rows = statement.executeQuery("SELECT channel_source,can_definition_json FROM box_channel WHERE id=3")) { + assertTrue(rows.next()); + assertEquals(2, rows.getInt("channel_source")); + assertEquals(definition, rows.getString("can_definition_json")); + } + } + } +} diff --git a/apps/backend/crydaq-server/src/test/java/com/opentest/migration/MathSampleSchemaRepairMigrationTest.java b/apps/backend/crydaq-server/src/test/java/com/opentest/migration/MathSampleSchemaRepairMigrationTest.java new file mode 100644 index 00000000..c9143f63 --- /dev/null +++ b/apps/backend/crydaq-server/src/test/java/com/opentest/migration/MathSampleSchemaRepairMigrationTest.java @@ -0,0 +1,266 @@ +package com.opentest.migration; + +import com.opentest.common.utils.SimpleVersionManager; +import com.opentest.dbmigration.V2_5_0_20261111120000__repair_math_sample_columns; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.io.TempDir; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; +import org.springframework.context.annotation.AnnotationConfigApplicationContext; + +import java.net.URL; +import java.net.URLClassLoader; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class MathSampleSchemaRepairMigrationTest { + private static final String OLD_VERSION = "2.5.0.20261105120000"; + private static final String LATER_VERSION = "2.5.0.20261110160000"; + private static final String REPAIR_VERSION = "2.5.0.20261111120000"; + private static final String OLD_SCRIPT = "V2.5.0_20261105120000__math_fs_sample_semantics.sql"; + private static final String MIGRATIONS_PATH = "math-schema-repair-migrations"; + + @TempDir + Path temporaryDirectory; + + @Test + void normalManagerRepairsColumnsSkippedBehindLaterRecordedVersion() throws Exception { + try (var connection = legacyDatabase(); var context = migrationContext()) { + List> before = legacyRows(connection); + + migrate(connection, context); + + assertReadableNullMathColumns(connection); + assertEquals(before, legacyRows(connection)); + assertEquals(0, historyCount(connection, OLD_VERSION)); + assertEquals(1, historyCount(connection, LATER_VERSION)); + assertEquals(1, historyCount(connection, REPAIR_VERSION)); + migrate(connection, context); + assertEquals(before, legacyRows(connection)); + assertEquals(1, historyCount(connection, REPAIR_VERSION)); + assertTrue(connection.getAutoCommit()); + try (var statement = connection.createStatement(); + var rows = statement.executeQuery("SELECT success, script FROM schema_history " + + "WHERE version='" + REPAIR_VERSION + "'")) { + assertTrue(rows.next()); + assertEquals(1, rows.getInt("success")); + assertEquals("com.opentest.dbmigration.V2_5_0_20261111120000__repair_math_sample_columns", + rows.getString("script")); + } + } + } + + @ParameterizedTest + @CsvSource({"true,false", "false,true", "true,true"}) + void repairsOnlyMissingColumnsAndPreservesExistingMathValues(boolean semanticsExists, boolean vpExists) + throws Exception { + try (var connection = legacyDatabase(); var context = migrationContext()) { + List> before = legacyRows(connection); + try (var statement = connection.createStatement()) { + if (semanticsExists) { + statement.execute("ALTER TABLE box_channel ADD COLUMN math_sample_semantics TEXT"); + statement.execute("UPDATE box_channel SET math_sample_semantics='LEGACY_PHYSICAL' WHERE id=2"); + } + if (vpExists) { + statement.execute("ALTER TABLE box_channel ADD COLUMN math_vp REAL"); + statement.execute("UPDATE box_channel SET math_vp=3.5 WHERE id=2"); + } + } + migrate(connection, context); + migrate(connection, context); + assertEquals(before, legacyRows(connection)); + assertEquals(1, historyCount(connection, REPAIR_VERSION)); + try (var statement = connection.createStatement(); + var rows = statement.executeQuery("SELECT math_sample_semantics, math_vp FROM box_channel WHERE id=2")) { + assertTrue(rows.next()); + assertEquals(semanticsExists ? "LEGACY_PHYSICAL" : null, rows.getString(1)); + assertEquals(vpExists ? 3.5 : null, rows.getObject(2)); + } + } + } + + @Test + void canRetryWhenHistoryRegistrationFailsAfterSchemaRepair() throws Exception { + try (var connection = legacyDatabase(); var context = migrationContext()) { + List> before = legacyRows(connection); + try (var statement = connection.createStatement()) { + statement.execute("CREATE TRIGGER reject_repair_history BEFORE INSERT ON schema_history " + + "WHEN NEW.version='" + REPAIR_VERSION + "' BEGIN SELECT RAISE(FAIL,'history unavailable'); END"); + } + assertThrows(SQLException.class, () -> migrate(connection, context)); + assertReadableNullMathColumns(connection); + assertEquals(0, historyCount(connection, REPAIR_VERSION)); + try (var statement = connection.createStatement()) { + statement.execute("DROP TRIGGER reject_repair_history"); + } + migrate(connection, context); + assertEquals(1, historyCount(connection, REPAIR_VERSION)); + assertEquals(before, legacyRows(connection)); + } + } + + @ParameterizedTest + @CsvSource({"MATH_SAMPLE_SEMANTICS,MATH_VP", "Math_Sample_Semantics,Math_Vp"}) + void acceptsExistingCaseInsensitiveSqliteColumnNames(String semanticsColumn, String vpColumn) throws Exception { + try (var connection = legacyDatabase(); var context = migrationContext()) { + try (var statement = connection.createStatement()) { + statement.execute("ALTER TABLE box_channel ADD COLUMN " + semanticsColumn + " TEXT"); + statement.execute("ALTER TABLE box_channel ADD COLUMN " + vpColumn + " REAL"); + statement.execute("UPDATE box_channel SET math_sample_semantics='LEGACY_PHYSICAL',math_vp=3.5 WHERE id=2"); + } + List> before = legacyRows(connection); + migrate(connection, context); + try (var statement = connection.createStatement(); + var rows = statement.executeQuery("SELECT math_sample_semantics,math_vp FROM box_channel WHERE id=2")) { + assertTrue(rows.next()); + assertEquals("LEGACY_PHYSICAL", rows.getString(1)); + assertEquals(3.5, rows.getDouble(2)); + } + assertEquals(before, legacyRows(connection)); + } + } + + @Test + void normalManagerLeavesSchemaAndHistoryInTheCallersTransaction() throws Exception { + try (var connection = legacyDatabase(); var context = migrationContext()) { + List> before = legacyRows(connection); + connection.setAutoCommit(false); + migrate(connection, context); + assertFalse(connection.getAutoCommit()); + assertReadableNullMathColumns(connection); + assertEquals(1, historyCount(connection, REPAIR_VERSION)); + connection.rollback(); + assertEquals(0, historyCount(connection, REPAIR_VERSION)); + assertEquals(before, legacyRows(connection)); + try (var statement = connection.createStatement(); + var rows = statement.executeQuery("SELECT COUNT(*) FROM pragma_table_info('box_channel') " + + "WHERE name IN ('math_sample_semantics','math_vp')")) { + assertTrue(rows.next()); + assertEquals(0, rows.getInt(1)); + } + } + } + + @Test + void directRepairLeavesTheCallersTransactionOpenAndRollbackRestoresOriginalSchema() throws Exception { + try (var connection = legacyDatabase()) { + List> before = legacyRows(connection); + connection.setAutoCommit(false); + new V2_5_0_20261111120000__repair_math_sample_columns().migrate(connection); + assertFalse(connection.getAutoCommit()); + assertReadableNullMathColumns(connection); + connection.rollback(); + try (var statement = connection.createStatement(); + var rows = statement.executeQuery("SELECT COUNT(*) FROM pragma_table_info('box_channel') " + + "WHERE name IN ('math_sample_semantics','math_vp')")) { + assertTrue(rows.next()); + assertEquals(0, rows.getInt(1)); + } + assertEquals(before, legacyRows(connection)); + } + } + + private AnnotationConfigApplicationContext migrationContext() { + var context = new AnnotationConfigApplicationContext(); + context.register(V2_5_0_20261111120000__repair_math_sample_columns.class); + context.refresh(); + return context; + } + + private void migrate(Connection connection, AnnotationConfigApplicationContext context) throws Exception { + Path resources = temporaryDirectory.resolve("resources"); + Path migrations = resources.resolve(MIGRATIONS_PATH); + Files.createDirectories(migrations); + Files.writeString(migrations.resolve(OLD_SCRIPT), resource("/db/migration/" + OLD_SCRIPT)); + ClassLoader originalLoader = Thread.currentThread().getContextClassLoader(); + try (var loader = new URLClassLoader(new URL[]{resources.toUri().toURL()}, originalLoader)) { + Thread.currentThread().setContextClassLoader(loader); + new SimpleVersionManager(connection, MIGRATIONS_PATH, "schema_history", true, context).migrate(); + } finally { + Thread.currentThread().setContextClassLoader(originalLoader); + } + } + + private Connection legacyDatabase() throws Exception { + Connection connection = DriverManager.getConnection("jdbc:sqlite::memory:"); + try (var statement = connection.createStatement()) { + String initialSchema = resource("/db/migration/V1.0__init.sql"); + int start = initialSchema.indexOf("CREATE TABLE box_channel ("); + assertTrue(start >= 0); + statement.execute(initialSchema.substring(start, initialSchema.indexOf(';', start))); + statement.execute("ALTER TABLE box_channel ADD COLUMN channel_source INTEGER"); + statement.execute(resource("/db/migration/V2.5.0_20261110160000__add_project_can_definition.sql")); + statement.execute("INSERT INTO box_channel " + + "(id,box_id,vch_id,channel_id,project_id,tenant_id,channel_io,channel_source,can_definition_json) " + + "VALUES (1,10,'physical',101,20,30,0,0,NULL)," + + "(2,10,'math',NULL,20,30,0,1,'{\"preserved\":true}')"); + statement.execute("CREATE TABLE schema_history (version TEXT PRIMARY KEY, description TEXT, " + + "script TEXT, checksum TEXT, installed_by TEXT, " + + "installed_on TIMESTAMP DEFAULT CURRENT_TIMESTAMP, execution_time INTEGER, success INTEGER)"); + statement.execute("INSERT INTO schema_history " + + "(version,description,script,checksum,installed_by,execution_time,success) VALUES ('" + + LATER_VERSION + "','add_project_can_definition'," + + "'V2.5.0_20261110160000__add_project_can_definition.sql','legacy-checksum','test',1,1)"); + } + return connection; + } + + private String resource(String path) throws Exception { + try (var stream = getClass().getResourceAsStream(path)) { + assertNotNull(stream, path); + return new String(stream.readAllBytes(), StandardCharsets.UTF_8); + } + } + + private List> legacyRows(Connection connection) throws Exception { + List> result = new ArrayList<>(); + try (var statement = connection.createStatement(); + var rows = statement.executeQuery("SELECT id,box_id,vch_id,channel_id,project_id,tenant_id," + + "device_id,channel_type,channel_io,created_time,updated_time,channel_source,can_definition_json " + + "FROM box_channel ORDER BY id")) { + while (rows.next()) { + List row = new ArrayList<>(); + for (int column = 1; column <= rows.getMetaData().getColumnCount(); column++) { + row.add(rows.getObject(column)); + } + result.add(row); + } + } + return result; + } + + private void assertReadableNullMathColumns(Connection connection) throws Exception { + try (var statement = connection.createStatement(); + var rows = statement.executeQuery("SELECT math_sample_semantics, math_vp FROM box_channel ORDER BY id")) { + for (int row = 0; row < 2; row++) { + assertTrue(rows.next()); + assertNull(rows.getString("math_sample_semantics")); + assertNull(rows.getObject("math_vp")); + } + assertFalse(rows.next()); + } + } + + private int historyCount(Connection connection, String version) throws Exception { + try (var statement = connection.prepareStatement("SELECT COUNT(*) FROM schema_history WHERE version=?")) { + statement.setString(1, version); + try (var rows = statement.executeQuery()) { + assertTrue(rows.next()); + return rows.getInt(1); + } + } + } +} diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/BoxChannelService.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/BoxChannelService.java index ac3cc208..88d8ecb0 100644 --- a/apps/backend/crydaq-service/src/main/java/com/opentest/service/BoxChannelService.java +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/BoxChannelService.java @@ -18,7 +18,15 @@ import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper; import com.baomidou.mybatisplus.extension.plugins.pagination.Page; import com.opentest.common.constants.CryDaqConstant; -import com.opentest.common.enums.*; +import com.opentest.common.enums.BoxChannelStatusEnum; +import com.opentest.common.enums.ChannelIOEnum; +import com.opentest.common.enums.ChannelSourceEnum; +import com.opentest.common.enums.ChannelTypeEnum; +import com.opentest.common.enums.DeviceStateEnum; +import com.opentest.common.enums.FieldColumnEnum; +import com.opentest.common.enums.SensorBindingModeEnum; +import com.opentest.common.enums.SensorCalibrationSourceEnum; +import com.opentest.common.enums.SensorDeviceDirectionEnum; import com.opentest.common.exception.CryBusinessException; import com.opentest.common.exception.ErrorCode; import com.opentest.common.exception.JniBusinessException; @@ -27,10 +35,29 @@ import com.opentest.common.model.FieldPatch; import com.opentest.common.model.MeasurementModeSupport; import com.opentest.common.model.ProjectChannelRangeLimitPatchCommand; -import com.opentest.common.model.dto.*; +import com.opentest.common.model.dto.BoxChannelBatchResultDto; +import com.opentest.common.model.dto.BoxChannelDto; +import com.opentest.common.model.dto.BoxChannelStatusDto; +import com.opentest.common.model.dto.ChannelDto; +import com.opentest.common.model.dto.DeviceDto; +import com.opentest.common.model.dto.ProjectChannelBatchModifyRequestDto; +import com.opentest.common.model.dto.ProjectChannelBatchModifyResponseDto; +import com.opentest.common.model.dto.ProjectChannelBatchModifyResultDto; +import com.opentest.common.model.dto.ProjectChannelSensitivityPreviewDto; +import com.opentest.common.model.dto.ProjectChannelSensitivityPreviewRequestDto; import com.opentest.common.model.dto.batch.BatchOptionsTeds; import com.opentest.common.model.dto.batch.BoxChannelRequest; -import com.opentest.common.model.entity.*; +import com.opentest.common.model.entity.BoxChannel; +import com.opentest.common.model.entity.Calibration; +import com.opentest.common.model.entity.Channel; +import com.opentest.common.model.entity.DashboardConfig; +import com.opentest.common.model.entity.Device; +import com.opentest.common.model.entity.Project; +import com.opentest.common.model.entity.ProjectChannelSensitivity; +import com.opentest.common.model.entity.SensorCalibrationStandard; +import com.opentest.common.model.entity.SensorComponentCalibration; +import com.opentest.common.model.entity.SensorDevice; +import com.opentest.common.model.entity.SensorDeviceComponent; import com.opentest.common.model.query.BoxChannelQuery; import com.opentest.common.model.query.ChannelQuery; import com.opentest.common.model.query.DeviceQuery; @@ -45,8 +72,9 @@ import com.opentest.dal.mapper.sqlite.SensorComponentCalibrationMapper; import com.opentest.dal.mapper.sqlite.SensorDeviceComponentMapper; import com.opentest.dal.mapper.sqlite.SensorDeviceMapper; -import com.opentest.service.helper.SetupChannelCascadeContext; +import com.opentest.service.can.CanProjectChannelService; import com.opentest.service.helper.DisplayTextResolver; +import com.opentest.service.helper.SetupChannelCascadeContext; import com.opentest.service.jni.AudioJNIBridgeService; import com.opentest.service.jni.LicenseJNIBridgeService; import com.opentest.service.mapper.BoxChannelStructMapper; @@ -75,6 +103,7 @@ import com.google.common.collect.Sets; import lombok.extern.slf4j.Slf4j; import org.springframework.stereotype.Component; +import org.springframework.context.annotation.Lazy; import org.springframework.transaction.PlatformTransactionManager; import org.springframework.transaction.TransactionDefinition; import org.springframework.transaction.annotation.Transactional; @@ -82,7 +111,23 @@ import jakarta.annotation.Resource; import java.time.LocalDateTime; -import java.util.*; +import java.util.AbstractMap; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.Comparator; +import java.util.EnumMap; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.LinkedHashMap; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.Set; +import java.util.UUID; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.CompletableFuture; import java.util.concurrent.TimeUnit; @@ -111,6 +156,9 @@ public class BoxChannelService extends BaseService entityToDto(List records) { // 1.从BoxChannel中拿到channelId列表 List channelIds = records.stream() + .filter(record -> !ChannelSourceEnum.isCan(record.getChannelSource())) .map(BoxChannel::getChannelId) .filter(Objects::nonNull) .distinct() @@ -180,6 +229,10 @@ public List entityToDto(List records) { // 如果没有有效的channelId,直接返回基本信息 if (CollUtil.isEmpty(channelIds)) { records.forEach(record -> { + if (ChannelSourceEnum.isCan(record.getChannelSource())) { + list.add(canChannelDto(record)); + return; + } BoxChannelDto dto = boxChannelStructMapper.toDto(record); dto.setSensorModelId(getRegisteredSensorModelId(record, sensorModelIdMap)); if (!ChannelSourceEnum.isMath(record.getChannelSource())) { @@ -203,6 +256,10 @@ public List entityToDto(List records) { // 3.遍历记录,将Channel对象按照对应的id,设置到BoxChannelDto中的Channel字段 records.forEach(record -> { + if (ChannelSourceEnum.isCan(record.getChannelSource())) { + list.add(canChannelDto(record)); + return; + } BoxChannelDto dto = boxChannelStructMapper.toDto(record); dto.setSensorModelId(getRegisteredSensorModelId(record, sensorModelIdMap)); dto.setRange(record.getRange()); @@ -245,6 +302,36 @@ public List entityToDto(List records) { return list; } + private BoxChannelDto canChannelDto(BoxChannel record) { + BoxChannelDto dto = new BoxChannelDto(); + dto.setId(record.getId()); + dto.setTenantId(record.getTenantId()); + dto.setProjectId(record.getProjectId()); + dto.setCreatedTime(record.getCreatedTime()); + dto.setUpdatedTime(record.getUpdatedTime()); + dto.setVchId(record.getVchId()); + dto.setVchIdNumber(record.getVchIdNumber()); + dto.setChannelSource(ChannelSourceEnum.CAN.getValue()); + dto.setChannelIo(ChannelIOEnum.INPUT.getValue()); + dto.setDeviceId(record.getDeviceId()); + dto.setProtocol(record.getProtocol()); + dto.setCustomName(record.getCustomName()); + dto.setChannelColor(record.getChannelColor()); + dto.setCanDefinitionJson(record.getCanDefinitionJson()); + if (record.getDeviceId() != null) { + Device device = deviceService.findById(record.getDeviceId(), false); + dto.setDevice(device); + if (device != null) dto.setProtocol(device.getProtocol()); + } + return dto; + } + + public void refreshCanChannelReferences(Long projectId, BoxChannel previous) { + dashboardConfigService.asyncUpdateGraphicInfo(projectId, null, + Collections.singletonList(previous.getVchId()), ChannelIOEnum.INPUT); + dashboardConfigService.updateProjectInputChannelGraphicInfo(projectId, previous); + } + private void clearMissingPhysicalBindingProjection(BoxChannelDto dto) { dto.setChannelId(null); dto.setDeviceId(null); @@ -536,6 +623,9 @@ private void clearPersistedInputSensitivity(BoxChannel channel) { public String add(BoxChannelDto dto) { MathChannelMutationBoundary.requirePhysicalSave(dto, dto.getId() == null ? null : findById(dto.getId(), false)); + if (ChannelSourceEnum.isCan(dto.getChannelSource()) || dto.getCanDefinitionJson() != null) { + throw CanProjectChannelService.invalid("fields", "Use the CAN channel save operation."); + } BoxChannel entity = dtoToEntity(dto); var powerChange = beginProjectChannelPowerChange(entity.getProjectId()); boolean physicalInput = ChannelIOEnum.INPUT.getValue().equals(entity.getChannelIo()) @@ -783,6 +873,9 @@ private Boolean applySingleDeviceMutation(BoxChannelDto dto, JsonNode patch, } BoxChannel current = findById(dto.getId()); MathChannelMutationBoundary.validatePatch(dto, current, explicitFields); + if (ChannelSourceEnum.isCan(current.getChannelSource())) { + throw CanProjectChannelService.invalid("fields", "CAN channels accept only project identity, name, color and CAN definition fields."); + } if (hasRegisteredSensorBinding(current) && explicitFields.contains( ChannelConfigurationField.MEASUREMENT_MODE.getJsonName()) @@ -890,6 +983,17 @@ protected Boolean applySparseDomainPatch(BoxChannelDto dto, Set explicit } BoxChannel old = findById(dto.getId()); MathChannelMutationBoundary.validatePatch(dto, old, explicitFields); + if (ChannelSourceEnum.isCan(old.getChannelSource())) { + ObjectNode values = BATCH_MODIFY_OBJECT_MAPPER.valueToTree(dto); + ObjectNode patch = BATCH_MODIFY_OBJECT_MAPPER.createObjectNode(); + explicitFields.forEach(field -> patch.set(field, values.get(field))); + canProjectChannelService.patch(old, patch); + return true; + } + if (explicitFields.contains("canDefinitionJson") || explicitFields.contains("channelSource") + && ChannelSourceEnum.isCan(dto.getChannelSource())) { + throw CanProjectChannelService.invalid("fields", "Use the CAN channel save operation."); + } if (explicitFields.contains("projectId") && !Objects.equals(dto.getProjectId(), old.getProjectId())) { throw new CryBusinessException(ErrorCode.CHECK_PARAMETER, "projectId与工程通道不匹配"); @@ -2138,10 +2242,15 @@ private Map getChannelMapByVchIdsWithoutDisplayInternal(Long Map channelMap = MapUtil.newHashMap(); if (CollUtil.isNotEmpty(boxChannels)) { - List channelIds = boxChannels.stream().map(BoxChannel::getChannelId).filter(Objects::nonNull).distinct().collect(Collectors.toList()); + List channelIds = boxChannels.stream() + .filter(channel -> !ChannelSourceEnum.isCan(channel.getChannelSource())) + .map(BoxChannel::getChannelId).filter(Objects::nonNull).distinct().collect(Collectors.toList()); Map rawChannelMap = loadRawChannelMap(channelIds); + List sampledChannels = boxChannels.stream() + .filter(channel -> ChannelSourceEnum.isPhysical(channel.getChannelSource())).collect(Collectors.toList()); Map rangeProjections = - ObjectUtil.defaultIfNull(projectChannelViewAssembler.assembleRangeProjections(boxChannels), + sampledChannels.isEmpty() ? Collections.emptyMap() : + ObjectUtil.defaultIfNull(projectChannelViewAssembler.assembleRangeProjections(sampledChannels), Collections.emptyMap()); for (BoxChannel boxChannel : boxChannels) { if (boxChannel == null || StrUtil.isBlank(boxChannel.getVchId())) { @@ -2180,6 +2289,9 @@ public Map getChannelDtoMapByVchIds(Long projectId, Set getHasNoRealChannelList(Long projectId) { if (CollUtil.isEmpty(dtoList)) { return CollUtil.newHashSet(); } - return dtoList.stream().map(BoxChannel::getVchId).collect(Collectors.toSet()); + return dtoList.stream().filter(slot -> ChannelSourceEnum.isPhysical(slot.getChannelSource())) + .map(BoxChannel::getVchId).collect(Collectors.toSet()); } /** @@ -3046,7 +3190,7 @@ public Set findUnboundPhysicalChannelVchIds(Long projectId, } List channelIds = slots.stream() .filter(Objects::nonNull) - .filter(slot -> !ChannelSourceEnum.isMath(slot.getChannelSource())) + .filter(slot -> ChannelSourceEnum.isPhysical(slot.getChannelSource())) .map(BoxChannel::getChannelId) .filter(Objects::nonNull) .distinct() @@ -3055,7 +3199,7 @@ public Set findUnboundPhysicalChannelVchIds(Long projectId, return slots.stream() .filter(Objects::nonNull) .filter(slot -> StrUtil.isNotBlank(slot.getVchId())) - .filter(slot -> !ChannelSourceEnum.isMath(slot.getChannelSource())) + .filter(slot -> ChannelSourceEnum.isPhysical(slot.getChannelSource())) .filter(slot -> slot.getChannelId() == null || !resolvedChannelIds.contains(slot.getChannelId())) .map(BoxChannel::getVchId) .collect(Collectors.toCollection(LinkedHashSet::new)); diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/DashboardConfigService.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/DashboardConfigService.java index 651d1b40..b38aba12 100644 --- a/apps/backend/crydaq-service/src/main/java/com/opentest/service/DashboardConfigService.java +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/DashboardConfigService.java @@ -2808,7 +2808,7 @@ public void syncProjectInputChannelMutations(Long projectId, List delete } } - /** Preserve the saved selection; only directory creation and a new binding admit a physical slot. */ + /** Preserve selection; a new CAN row or a new physical binding joins Monitor once. */ private List reconcileMonitorInputSelection(Long projectId, List selected, Map previous, Map current) { @@ -2823,7 +2823,9 @@ private List reconcileMonitorInputSelection(Long projectId, List String id = resolveBoxChannelVchId(entry.getValue(), entry.getKey()); BoxChannel before = findBoxChannelByVchId(previous, id); BoxChannel after = entry.getValue(); - if (StrUtil.isNotBlank(id) && (before == null || after.getChannelId() != null + if (StrUtil.isNotBlank(id) && (before == null + || ChannelSourceEnum.isCan(after.getChannelSource()) && !ChannelSourceEnum.isCan(before.getChannelSource()) + || after.getChannelId() != null && !Objects.equals(before.getChannelId(), after.getChannelId()))) { inputs.add(id); } @@ -2923,7 +2925,12 @@ private void syncInputListenAudioConfig(DashboardItemConfigDto bean, List channels = new ArrayList<>(); + Set canInputs = bean.getCollectConfig() == null ? Set.of() + : CollUtil.emptyIfNull(bean.getCollectConfig().getChannels()).stream() + .filter(channel -> channel != null && ChannelSourceEnum.isCan(channel.getChannelSource())) + .map(ChannelDto::getVchId).collect(Collectors.toSet()); for (String inputChannel : inputChannels) { + if (canInputs.contains(inputChannel)) continue; ListenAudioChannelConfigDto channel = oldChannelMap.get(inputChannel); if (channel == null) { channel = new ListenAudioChannelConfigDto(); @@ -5568,6 +5575,9 @@ private int channelSortKey(ChannelDto c) { */ private VirtualChannelExecutionPlan resolveExecutionPlan(Long projectId, List selectedChannels, boolean monitor) { + if (monitor && selectedChannels != null) + selectedChannels = selectedChannels.stream() + .filter(channel -> !ChannelSourceEnum.isCan(channel.getChannelSource())).toList(); if (CollUtil.isEmpty(selectedChannels) || selectedChannels.stream().noneMatch(ChannelDto::isMathChannel)) { return virtualChannelExecutionChannelResolver.buildPlan( @@ -5583,7 +5593,8 @@ private VirtualChannelExecutionPlan resolveExecutionPlan(Long projectId, List !ChannelSourceEnum.isCan(channel.getChannelSource())).toList(), unbound); } return virtualChannelExecutionChannelResolver.buildPlan( selectedChannels, availableChannelMap.values()); diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/ProjectService.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/ProjectService.java index 392fc2ee..f6b00f7c 100644 --- a/apps/backend/crydaq-service/src/main/java/com/opentest/service/ProjectService.java +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/ProjectService.java @@ -7,6 +7,7 @@ import com.opentest.common.config.DashboardConfigurationJson; import com.opentest.service.project.ProjectImportSelection; +import com.opentest.service.can.CanProjectChannelService; import com.opentest.service.dashboard.framework.PluginDashboardConfigurationResolver; import com.opentest.service.dashboard.framework.ProjectTriggerConfiguration; import com.opentest.service.dashboard.framework.ProjectExcitationConfiguration; @@ -94,6 +95,7 @@ import com.opentest.service.project.ProjectFileArtifactResolver; import com.opentest.service.project.ProjectImportProgressListener; import com.opentest.service.project.ProjectOtPackageService; +import com.opentest.service.project.CanRecordedProjectArtifacts; import com.opentest.service.project.ProjectPackageChannelTopology; import com.opentest.service.project.ProjectWordTemplateResourceService; import com.opentest.service.support.GeneratorChannelConfigResolver; @@ -211,6 +213,9 @@ public class ProjectService extends BaseService Objects.equals(request.getId(), file.getRequestId())).findFirst().orElseThrow(); + CanRecordedProjectArtifacts.requireSourceBinding( + FlowExecuteSnapshotDataDto.parseJson(sourceRequest.getSnapshotData()), file); + included = true; + } if (!included) continue; var artifact = findPackagedCrybinArtifact(file, index); if (artifact != null) selected.add(artifact); @@ -2520,21 +2532,29 @@ private ProjectPackageBuildResult buildProjectPackageArtifacts(ProjectExportDto exportDto.setProjectResourceFiles(Collections.emptyList()); } } - if (!BooleanUtil.isTrue(includeTestRecords) || exportDto == null || CollUtil.isEmpty(exportDto.getFiles())) { + if (!BooleanUtil.isTrue(includeTestRecords) || exportDto == null) { if (exportDto != null) { exportDto.setFiles(Collections.emptyList()); } return new ProjectPackageBuildResult(manifest, sourceEntries, sourceEntryRequestIds); } + List canFiles = new ArrayList<>(); + for (var event : CanRecordedProjectArtifacts.export(exportDto, variablesService.getDefaultStoragePath())) { + canFiles.add(event.file()); + manifest.getArtifacts().add(event.artifact()); + artifactKeys.add(event.artifact().getArtifactKey()); + sourceEntries.add(event.source()); + sourceEntryRequestIds.put(event.source().getEntryName(), event.file().getRequestId()); + } List selectedFiles = new ProjectCrybinExportSelector().select(exportDto.getFiles()); if (CollUtil.isEmpty(selectedFiles)) { - exportDto.setFiles(Collections.emptyList()); + exportDto.setFiles(canFiles); return new ProjectPackageBuildResult(manifest, sourceEntries, sourceEntryRequestIds); } - List packagedFiles = new ArrayList<>(); + List packagedFiles = new ArrayList<>(canFiles); ProjectFileArtifactResolver artifactResolver = new ProjectFileArtifactResolver(); String storagePath = variablesService.getDefaultStoragePath(); Long sourceProjectId = exportDto.getProject() == null ? null : exportDto.getProject().getId(); @@ -3754,6 +3774,7 @@ private String createProjectFromExport(ProjectExportDto importDto, packageReadResult, progressListener, artifactRestorePlan); + requireImportedCanRecordings(flowExecuteResultIdMapping); return newProjectId.toString(); } @@ -3939,12 +3960,21 @@ private void createFilesFromExport(List f ProjectPackageArtifactIndex artifactIndex = buildProjectPackageArtifactIndex(packageReadResult); Map recordCrybinRemainingCounts = countPackagedRecordFiles(files, flowExecuteResultIdMapping, artifactIndex); Map sourceRequestIdsByNewId = invertRequestIdMapping(flowExecuteResultIdMapping); + List canBindings = new ArrayList<>(); + Set canRequests = new HashSet<>(); List newFiles = CollUtil.newArrayList(); for (com.opentest.common.model.entity.File file : files) { com.opentest.common.model.entity.File newFile = new com.opentest.common.model.entity.File(); BeanUtil.copyProperties(file, newFile, "id", "createdTime", "updatedTime"); Long newImportedRecordRequestId = null; - if (ObjectUtil.equals(FileBusinessTypeEnum.POST_PROCESS.getType(), file.getBusinessType())) { + if (CanRecordedProjectArtifacts.isEventFile(file)) { + Long targetRequest = flowExecuteResultIdMapping.get(file.getRequestId()); + if (targetRequest == null || !canRequests.add(targetRequest)) + throw new IllegalArgumentException("CAN event file has no unique imported request"); + newFile.setId(IdUtil.getSnowflakeNextId()); + newFile.setRequestId(targetRequest); + newImportedRecordRequestId = targetRequest; + } else if (ObjectUtil.equals(FileBusinessTypeEnum.POST_PROCESS.getType(), file.getBusinessType())) { // businessId 替换第一个_前的数据 List businessIdList = StrUtil.split(file.getBusinessId(), "_"); if (CollUtil.isEmpty(businessIdList)) { @@ -3983,8 +4013,19 @@ private void createFilesFromExport(List f newImportedRecordRequestId = newRequestId; } ProjectPackageManifestDto.ProjectPackageArtifactDto artifact = findPackagedCrybinArtifact(file, artifactIndex); - if (artifact != null) { - Runnable restoreStep = preparePackagedArtifactRestore(artifact, newFile, newProjectId, packageReadResult, artifactRestorePlan); + if (artifact != null || CanRecordedProjectArtifacts.isEventFile(file)) { + Runnable restoreStep; + if (CanRecordedProjectArtifacts.isEventFile(file)) { + var targetRequest = flowExecuteResultService.findById(newFile.getRequestId(), false); + if (targetRequest == null) throw new IllegalArgumentException("Imported CAN request is missing"); + String storageRoot = variablesService.getDefaultStoragePath(); + var restored = CanRecordedProjectArtifacts.prepareImport( + FlowExecuteSnapshotDataDto.parseJson(targetRequest.getSnapshotData()), file, newFile, + newProjectId, newFile.getRequestId(), storageRoot, artifact, packageReadResult); + restoreStep = () -> copyImportedArtifactFiles(List.of(new ProjectImportFileCopy( + restored.source(), restored.destination(), restored.relativePath())), artifactRestorePlan); + canBindings.add(new ImportedCanFile(file, newFile, storageRoot)); + } else restoreStep = preparePackagedArtifactRestore(artifact, newFile, newProjectId, packageReadResult, artifactRestorePlan); if (restoreStep != null) { Long restoredRecordRequestId = newImportedRecordRequestId; Runnable restoreAndMark = () -> { @@ -4008,6 +4049,27 @@ private void createFilesFromExport(List f return; } fileService.baseServiceBatchAdd(newFiles); + for (var binding : canBindings) { + var request = flowExecuteResultService.findById(binding.target().getRequestId(), false); + if (request == null) throw new IllegalArgumentException("Imported CAN request disappeared"); + String expected = request.getSnapshotData(); + var snapshot = FlowExecuteSnapshotDataDto.parseJson(expected); + CanRecordedProjectArtifacts.rebind(snapshot, binding.source(), binding.target(), binding.storageRoot()); + String updated = Objects.requireNonNull(snapshot.toJson(), "Rebound CAN snapshot"); + if (!flowExecuteResultService.compareAndSetSnapshotData(request.getId(), expected, updated)) + throw new IllegalStateException("Imported CAN request changed during file rebinding"); + } + } + + private record ImportedCanFile(com.opentest.common.model.entity.File source, + com.opentest.common.model.entity.File target, String storageRoot) { } + + private void requireImportedCanRecordings(Map requestMapping) { + for (Long requestId : requestMapping.values()) { + var request = flowExecuteResultService.findById(requestId, false); + if (request != null) CanRecordedProjectArtifacts.requireRebound( + FlowExecuteSnapshotDataDto.parseJson(request.getSnapshotData()), requestId); + } } private void remapImportedFileBusinessChannelId(List businessIdList, @@ -5516,11 +5578,16 @@ private Map createDevicesFromExport(List devices, List> dbChannelsByDeviceId = listChannelsByDeviceId(dbDevices); Map> requiredPositionsByDeviceId = buildRequiredBoundChannelPositions(channels, boxChannels); Set matchedDbDeviceIds = new HashSet<>(); + Set canDeviceIds = CollUtil.emptyIfNull(boxChannels).stream() + .filter(channel -> ChannelSourceEnum.isCan(channel.getChannelSource())) + .map(BoxChannel::getDeviceId).filter(Objects::nonNull).collect(Collectors.toSet()); List toAddDevices = new ArrayList<>(); Map originalIdToAddedDevice = new LinkedHashMap<>(); for (Device importDevice : devices) { - Device matchedDevice = findMatchingDbDevice(importDevice, dbDevices, dbChannelsByDeviceId, requiredPositionsByDeviceId, matchedDbDeviceIds); + Device matchedDevice = canDeviceIds.contains(importDevice.getId()) + ? findMatchingCanDevice(importDevice, dbDevices, matchedDbDeviceIds) + : findMatchingDbDevice(importDevice, dbDevices, dbChannelsByDeviceId, requiredPositionsByDeviceId, matchedDbDeviceIds); if (matchedDevice != null) { deviceIdMapping.put(importDevice.getId(), matchedDevice.getId()); matchedDbDeviceIds.add(matchedDevice.getId()); @@ -5528,6 +5595,7 @@ private Map createDevicesFromExport(List devices, List createDevicesFromExport(List devices, List devices, Set matchedIds) { + if (StrUtil.isBlank(imported.getProtocol()) || StrUtil.isBlank(imported.getDeviceName())) { + throw CanProjectChannelService.invalid("scope", "The CAN project or device binding is unavailable."); + } + List matches = devices.stream() + .filter(device -> !matchedIds.contains(device.getId())) + .filter(device -> Objects.equals(imported.getTenantId(), device.getTenantId())) + .filter(device -> Objects.equals(imported.getProtocol(), device.getProtocol())) + .filter(device -> Objects.equals(imported.getDeviceName(), device.getDeviceName())) + .toList(); + if (matches.size() > 1) { + throw CanProjectChannelService.invalid("ambiguousDevice", "The CAN device identity is ambiguous; select the device explicitly."); + } + return matches.isEmpty() ? null : matches.getFirst(); + } + private Map> listChannelsByDeviceId(List devices) { if (CollUtil.isEmpty(devices)) { return Collections.emptyMap(); @@ -5567,6 +5651,7 @@ private Map> buildRequiredBoundChannelPositions(List .collect(Collectors.toMap(Channel::getId, channel -> channel, (a, b) -> a)); Map> positionsByDeviceId = new HashMap<>(); for (BoxChannel boxChannel : boxChannels) { + if (ChannelSourceEnum.isCan(boxChannel.getChannelSource())) continue; Channel boundChannel = boxChannel.getChannelId() == null ? null : channelById.get(boxChannel.getChannelId()); Long deviceId = boundChannel == null ? boxChannel.getDeviceId() : boundChannel.getDeviceId(); String positionKey = boundChannel == null ? channelPositionKey(boxChannel) : channelPositionKey(boundChannel); @@ -5780,7 +5865,13 @@ private Map createBoxChannelsFromExport(List boxChannels newBoxChannel.setProjectId(newProjectId); // 设置新的设备ID和通道ID newBoxChannel.setDeviceId(deviceIdMapping.get(boxChannel.getDeviceId())); - newBoxChannel.setChannelId(channelIdMapping.get(boxChannel.getChannelId())); + if (ChannelSourceEnum.isCan(boxChannel.getChannelSource())) { + if (newBoxChannel.getDeviceId() == null || boxChannel.getChannelId() != null + || !ChannelIOEnum.INPUT.getValue().equals(boxChannel.getChannelIo())) { + throw CanProjectChannelService.invalid("scope", "The CAN project or device binding is unavailable."); + } + newBoxChannel = importCanChannel(boxChannel, tenantId, newProjectId, newBoxChannel.getDeviceId()); + } else newBoxChannel.setChannelId(channelIdMapping.get(boxChannel.getChannelId())); //if (Objects.nonNull(newBoxChannel.getDeviceId()) && Objects.nonNull(newBoxChannel.getChannelId())) { newBoxChannels.add(newBoxChannel); //} @@ -5800,6 +5891,26 @@ private Map createBoxChannelsFromExport(List boxChannels return boxChannelIdMapping; } + private BoxChannel importCanChannel(BoxChannel source, Long tenantId, Long projectId, Long deviceId) { + if (StrUtil.isBlank(source.getCustomName()) || StrUtil.isBlank(source.getVchId())) { + throw CanProjectChannelService.invalid("required", "Project, device and channel name are required."); + } + BoxChannel channel = new BoxChannel(); + channel.setTenantId(tenantId); + channel.setProjectId(projectId); + channel.setDeviceId(deviceId); + channel.setProtocol(source.getProtocol()); + channel.setVchId(source.getVchId()); + channel.setVchIdNumber(source.getVchIdNumber()); + channel.setChannelSource(ChannelSourceEnum.CAN.getValue()); + channel.setChannelIo(ChannelIOEnum.INPUT.getValue()); + channel.setCustomName(source.getCustomName().trim()); + channel.setChannelColor(source.getChannelColor()); + channel.setCanDefinitionJson(canProjectChannelService.validateDefinition( + source.getCanDefinitionJson(), projectId, source.getVchId())); + return channel; + } + private void createProjectSensitivitiesFromExport(ProjectExportDto importDto, Project targetProject, Map channelIdMapping) { @@ -8691,6 +8802,7 @@ private ResultDeterminationImportMapping createResultDeterminationConfigsFromExp exportLimitConfigs, validNodeIdsFromMapping(nodeIdMapping), "import.resultLimit.nodeId"); + if (validLimitConfigs == null) validLimitConfigs = List.of(); List validJudgmentRules = filterJudgmentRuleConfigsByExistingNodes( exportJudgmentRules, validNodeIdsFromMapping(nodeIdMapping), diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/VariablesService.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/VariablesService.java index 1e782ae1..6bc9b039 100644 --- a/apps/backend/crydaq-service/src/main/java/com/opentest/service/VariablesService.java +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/VariablesService.java @@ -7,6 +7,7 @@ import cn.hutool.core.util.BooleanUtil; import cn.hutool.core.util.ObjectUtil; import cn.hutool.core.util.StrUtil; +import cn.hutool.json.JSONObject; import cn.hutool.json.JSONUtil; import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper; @@ -241,6 +242,16 @@ public Boolean updateCurrentGlobalLanguage(String languageTag) { ); } + public JSONObject getCanPortConfigurations() { + String value = getSystemVariableValue("system_can_port_configurations_v1"); + return StrUtil.isBlank(value) ? new JSONObject() : JSONUtil.parseObj(value); + } + + @Transactional(rollbackFor = Exception.class) + public Boolean saveCanPortConfigurations(JSONObject configurations) { + return saveSystemJsonVariable("system_can_port_configurations_v1", "CAN port configurations", configurations); + } + public GlobalDbrReferenceSettingsDto getGlobalDbrReferenceSettings() { String value = getSystemVariableValue(CryDaqConstant.SYSTEM_GLOBAL_DBRA_VARIABLE_NAME); if (StrUtil.isBlank(value)) { diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/can/CanConfigurationStore.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/can/CanConfigurationStore.java new file mode 100644 index 00000000..b4a8ec7e --- /dev/null +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/can/CanConfigurationStore.java @@ -0,0 +1,33 @@ +package com.opentest.service.can; + +import cn.hutool.json.JSONObject; +import cn.hutool.json.JSONUtil; +import com.opentest.service.VariablesService; +import org.springframework.stereotype.Component; + +@Component +public class CanConfigurationStore { + private final VariablesService variables; + + public CanConfigurationStore(VariablesService variables) { this.variables = variables; } + + public synchronized JSONObject get(String device, String port) { + JSONObject all = JSONUtil.parseObj(variables.getCanPortConfigurations().toString()); + JSONObject ports = all.getJSONObject(device); + JSONObject config = ports == null ? null : ports.getJSONObject(port); + return config == null ? null : JSONUtil.parseObj(config.toString()); + } + + public synchronized void save(String device, String port, JSONObject configuration) { + JSONObject all = JSONUtil.parseObj(variables.getCanPortConfigurations().toString()); + JSONObject ports = all.getJSONObject(device); + if (ports == null) { ports = new JSONObject(); all.set(device, ports); } + ports.set(port, configuration); + try { + if (!Boolean.TRUE.equals(variables.saveCanPortConfigurations(all))) + throw new CanOperationException(13103001, "can.error.saveFailed"); + } catch (RuntimeException error) { + throw new CanOperationException(13103001, "can.error.saveFailed", error); + } + } +} diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/can/CanDbcService.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/can/CanDbcService.java new file mode 100644 index 00000000..c4bfd28a --- /dev/null +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/can/CanDbcService.java @@ -0,0 +1,131 @@ +package com.opentest.service.can; + +import com.fasterxml.jackson.core.JsonParser; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.DeserializationFeature; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.node.ObjectNode; +import com.opentest.common.exception.JniBusinessException; +import com.opentest.core.jni.CanJNIBridge; +import com.opentest.dashboard.api.channel.CanSignalQuantity; +import java.util.Base64; +import java.util.Set; +import org.springframework.stereotype.Service; + +/** Offline parsing and verification of project-owned DBC bytes; no reception state. */ +@Service +public class CanDbcService { + public static final int MAX_BYTES = 5_000_000; + private static final ObjectMapper JSON = new ObjectMapper() + .enable(JsonParser.Feature.STRICT_DUPLICATE_DETECTION) + .enable(DeserializationFeature.FAIL_ON_TRAILING_TOKENS); + private static final Set DBC_FIELDS = Set.of("fileName", "contentBase64", "messageId", "signalName"); + private static final Set IMMUTABLE_FIELDS = Set.of( + "canId", "idFormat", "byteOrder", "valueType", "startBit", "bitLength", "factor", "offset", "unit"); + private static final Set OVERRIDES = Set.of("frameType", "timeoutMs", "invalidRawValue"); + private final CanJNIBridge nativeCan; + + public CanDbcService(CanJNIBridge nativeCan) { this.nativeCan = nativeCan; } + + public JsonNode parse(byte[] bytes) { + if (bytes == null || bytes.length == 0 || bytes.length > MAX_BYTES) + throw CanProjectChannelService.invalid("dbcSize", "DBC files must contain 1 to 5,000,000 bytes."); + JsonNode response; + try { + response = JSON.readTree(nativeCan.parseCanDbcV1(bytes)); + } catch (LinkageError error) { + throw CanProjectChannelService.invalid("dbcUnavailable", "The installed Native library cannot parse DBC files."); + } catch (JsonProcessingException | IllegalArgumentException error) { + throw malformedResponse(); + } + if (response == null || !response.path("code").isIntegralNumber() || !response.path("code").canConvertToInt()) + throw malformedResponse(); + if (response.path("code").intValue() != 0) + throw JniBusinessException.fromNativeResponseCode(response.path("code").intValue()); + JsonNode data = response.path("data"); + if (!data.isObject() || !data.path("schemaVersion").isIntegralNumber() || !data.path("schemaVersion").canConvertToInt() + || data.path("schemaVersion").intValue() != 1 || !data.path("messages").isArray() + || data.path("messages").isEmpty()) throw malformedResponse(); + return data; + } + + ObjectNode verify(ObjectNode saved) { + byte[] bytes; + try { bytes = frozenBytes(saved.path("dbc")); } + catch (IllegalArgumentException error) { + throw CanProjectChannelService.invalid("dbcDocument", "The saved DBC file or selection is invalid."); + } + JsonNode dbc = saved.path("dbc"); + JsonNode selected = null; + for (JsonNode message : parse(bytes).path("messages")) { + if (!dbc.path("messageId").equals(message.path("messageId"))) continue; + if (!message.path("signals").isArray()) throw malformedResponse(); + for (JsonNode signal : message.path("signals")) { + if (!dbc.path("signalName").equals(signal.path("name"))) continue; + if (selected != null) throw malformedResponse(); + selected = signal; + } + } + if (selected == null || !selected.path("supported").isBoolean() + || !selected.path("supported").booleanValue() || !selected.path("definition").isObject()) + throw CanProjectChannelService.invalid("dbcSelection", "Select a supported DBC message and signal."); + if (!selected.path("unit").isTextual() || !selected.path("unit").equals(saved.path("sourceUnit")) + || !quantityAllowed(selected.path("unitMetadata"), saved.path("quantity").asText())) + throw CanProjectChannelService.invalid("units", "The CAN quantity, source unit, output unit or Tacho PPR is invalid."); + JsonNode supplied = saved.path("definition"); + ObjectNode derived = selected.path("definition").deepCopy(); + for (String field : IMMUTABLE_FIELDS) { + JsonNode expected = derived.path(field); + JsonNode actual = supplied.path(field); + boolean equal = expected.isNumber() && actual.isNumber() + ? expected.decimalValue().compareTo(actual.decimalValue()) == 0 : expected.equals(actual); + if (expected.isMissingNode() || !equal) + throw CanProjectChannelService.invalid("dbcDecoder", "DBC decoder fields must match the selected signal."); + } + for (String field : OVERRIDES) if (supplied.has(field)) derived.set(field, supplied.get(field)); + return derived; + } + + private static boolean quantityAllowed(JsonNode metadata, String quantity) { + if (!metadata.path("category").isTextual() || !metadata.path("normalizedUnit").isTextual()) return false; + return switch (metadata.path("category").textValue()) { + case "frequency" -> CanSignalQuantity.FREQUENCY.name().equals(quantity) + || "hz".equals(metadata.path("normalizedUnit").textValue()) && CanSignalQuantity.TACHO.name().equals(quantity); + case "rotational-speed" -> CanSignalQuantity.ROTATIONAL_SPEED.name().equals(quantity); + case "speed" -> CanSignalQuantity.SPEED.name().equals(quantity); + case "temperature" -> CanSignalQuantity.TEMPERATURE.name().equals(quantity); + case "voltage" -> CanSignalQuantity.VOLTAGE.name().equals(quantity); + case "custom" -> CanSignalQuantity.CUSTOM.name().equals(quantity); + default -> false; + }; + } + + // Facts use format checks only. Native revalidation belongs to save/import boundaries. + static byte[] frozenBytes(JsonNode dbc) { + if (!dbc.isObject() || dbc.size() != DBC_FIELDS.size()) throw new IllegalArgumentException("Invalid DBC document"); + for (String field : DBC_FIELDS) + if (!dbc.path(field).isTextual() || dbc.path(field).textValue().isBlank()) + throw new IllegalArgumentException("Invalid DBC field: " + field); + requireFileName(dbc.path("fileName").textValue()); + String messageId = dbc.path("messageId").textValue(); + if (!messageId.matches("0|[1-9][0-9]{0,9}") || Long.parseLong(messageId) > 0xffffffffL) + throw new IllegalArgumentException("Invalid DBC message identity"); + String encoded = dbc.path("contentBase64").textValue(); + if (encoded.length() > 4 * ((MAX_BYTES + 2) / 3)) throw new IllegalArgumentException("DBC exceeds size limit"); + byte[] bytes = Base64.getDecoder().decode(encoded); + if (bytes.length == 0 || bytes.length > MAX_BYTES) throw new IllegalArgumentException("Invalid DBC size"); + return bytes; + } + + public static void requireFileName(String fileName) { + if (fileName == null || fileName.isBlank() || fileName.equals(".") || fileName.equals("..") + || fileName.indexOf('/') >= 0 || fileName.indexOf('\\') >= 0 + || fileName.chars().anyMatch(Character::isISOControl)) + throw new IllegalArgumentException("DBC requires the original filename without directory components"); + } + + private static RuntimeException malformedResponse() { + return CanProjectChannelService.invalid("dbcResponse", "Native returned an incomplete DBC parse response."); + } +} diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/can/CanNativeGateway.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/can/CanNativeGateway.java new file mode 100644 index 00000000..8f5966c4 --- /dev/null +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/can/CanNativeGateway.java @@ -0,0 +1,21 @@ +package com.opentest.service.can; + +import cn.hutool.json.JSONObject; + +public interface CanNativeGateway { + JSONObject capabilities(String protocol, String deviceId); + JSONObject enable(String protocol, String deviceId, boolean enabled); + JSONObject configure(String protocol, String deviceId, String portId, JSONObject configuration); + JSONObject start(String protocol, String deviceId, String portId, JSONObject request); + JSONObject readFrames(String receiveId); + JSONObject status(String protocol, String deviceId, String portId); + JSONObject stop(String receiveId); + JSONObject close(String receiveId); + JSONObject validateDefinitions(JSONObject definitions); + JSONObject updateDefinitions(String receiveId, JSONObject definitions); + JSONObject subscribe(String receiveId, JSONObject selection); + JSONObject readSignals(String receiveId, String subscriptionId); + JSONObject resetSignals(String receiveId, String subscriptionId, JSONObject selection); + JSONObject finishSignals(String receiveId, String subscriptionId); + JSONObject unsubscribe(String receiveId, String subscriptionId); +} diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/can/CanOperationException.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/can/CanOperationException.java new file mode 100644 index 00000000..b9d3286c --- /dev/null +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/can/CanOperationException.java @@ -0,0 +1,17 @@ +package com.opentest.service.can; + +public final class CanOperationException extends RuntimeException { + private final int code; + private final String messageKey; + + public CanOperationException(int code, String messageKey) { + this(code, messageKey, null); + } + public CanOperationException(int code, String messageKey, Throwable cause) { + super(messageKey, cause); + this.code = code; + this.messageKey = messageKey; + } + public int code() { return code; } + public String messageKey() { return messageKey; } +} diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/can/CanProjectChannelFacts.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/can/CanProjectChannelFacts.java new file mode 100644 index 00000000..574f6fdb --- /dev/null +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/can/CanProjectChannelFacts.java @@ -0,0 +1,179 @@ +package com.opentest.service.can; + +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.core.JsonParser; +import com.fasterxml.jackson.databind.DeserializationFeature; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.opentest.common.enums.ChannelSourceEnum; +import com.opentest.common.model.dto.ChannelDto; +import com.opentest.common.model.entity.Device; +import com.opentest.dashboard.api.channel.CanPortBinding; +import com.opentest.dashboard.api.channel.CanSignalChannel; +import com.opentest.dashboard.api.channel.CanSignalQuantity; +import com.opentest.dashboard.api.channel.CanSignalUnits; +import com.opentest.service.DeviceService; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.security.NoSuchAlgorithmException; +import java.util.HexFormat; +import java.util.ArrayList; +import java.util.Objects; +import java.util.Set; +import java.util.TreeMap; +import org.springframework.context.annotation.Lazy; +import org.springframework.stereotype.Component; + +/** Resolves saved project facts without consulting or starting a live CAN source. */ +@Component +public final class CanProjectChannelFacts { + private static final ObjectMapper JSON = new ObjectMapper() + .enable(JsonParser.Feature.STRICT_DUPLICATE_DETECTION) + .enable(DeserializationFeature.FAIL_ON_TRAILING_TOKENS); + private final DeviceService devices; + + public CanProjectChannelFacts(@Lazy DeviceService devices) { this.devices = devices; } + + public CanSignalChannel resolve(ChannelDto row) { + requireRow(row); + return resolve(row, devices.findById(row.getDeviceId())); + } + + /** Historical facts use the retained device identity, even after the device is removed. */ + public static CanSignalChannel saved(ChannelDto row) { + requireRow(row); + if (row.getProtocol() == null || row.getProtocol().isBlank() + || row.getDeviceName() == null || row.getDeviceName().isBlank()) + throw new IllegalArgumentException("Saved CAN device identity is required"); + var document = document(row.getCanDefinitionJson()); + return new CanSignalChannel(row.getVchId(), row.getBoxChannelId().toString(), row.getProjectId().toString(), + row.getCustomName() == null ? row.getChannelName() : row.getCustomName(), row.getVchIdNumber(), + new CanPortBinding(row.getDeviceId().toString(), row.getProtocol(), + DeviceService.deviceIdentity(row.getProtocol(), row.getDeviceName(), row.getIpAddress()), + text(document, "portId")), row.getCanDefinitionJson(), units(document), fingerprint(row.getCanDefinitionJson())); + } + + public static CanSignalChannel resolve(ChannelDto row, Device device) { + requireRow(row); + if (device == null || !Objects.equals(row.getDeviceId(), device.getId()) + || device.getProtocol() == null || device.getProtocol().isBlank() + || device.getDeviceName() == null || device.getDeviceName().isBlank() + || row.getProtocol() != null && !row.getProtocol().equals(device.getProtocol()) + || row.getTenantId() != null && device.getTenantId() != null + && !row.getTenantId().equals(device.getTenantId())) + throw new IllegalArgumentException("CAN device identity disagrees with the project row"); + var document = document(row.getCanDefinitionJson()); + return new CanSignalChannel(row.getVchId(), row.getBoxChannelId().toString(), row.getProjectId().toString(), + row.getCustomName() == null ? row.getChannelName() : row.getCustomName(), row.getVchIdNumber(), + new CanPortBinding(row.getDeviceId().toString(), device.getProtocol(), + DeviceService.deviceIdentity(device.getProtocol(), device.getDeviceName(), device.getIpAddress()), + text(document, "portId")), row.getCanDefinitionJson(), units(document), fingerprint(row.getCanDefinitionJson())); + } + + public static void requireMatches(ChannelDto row, CanSignalChannel frozen) { + requireRow(row); + var document = document(row.getCanDefinitionJson()); + if (!row.getVchId().equals(frozen.vchId()) + || !row.getBoxChannelId().toString().equals(frozen.projectChannelId()) + || !row.getProjectId().toString().equals(frozen.projectId()) + || !row.getDeviceId().toString().equals(frozen.binding().deviceId()) + || row.getProtocol() != null && !row.getProtocol().equals(frozen.binding().protocol()) + || !text(document, "portId").equals(frozen.binding().portId()) + || !fingerprint(row.getCanDefinitionJson()).equals(frozen.definitionFingerprint()) + || !fingerprint(frozen.persistedJson()).equals(frozen.definitionFingerprint()) + || !units(document).equals(frozen.units())) + throw new IllegalArgumentException("CAN result source disagrees with the frozen project facts"); + } + + private static void requireRow(ChannelDto row) { + Objects.requireNonNull(row, "project row"); + if (!ChannelSourceEnum.isCan(row.getChannelSource()) || !Integer.valueOf(0).equals(row.getChannelIo()) + || row.getBoxChannelId() == null || row.getBoxChannelId() <= 0 + || row.getProjectId() == null || row.getProjectId() <= 0 || row.getDeviceId() == null + || row.getVchId() == null || row.getVchId().isBlank() + || row.getJniChannelNumber() != null || row.getSamplingRate() != null) + throw new IllegalArgumentException("CAN requires a genuine input project row without sampled identity"); + } + + public static String fingerprint(String persistedJson) { + try { + byte[] canonical = JSON.writeValueAsString(canonical(document(persistedJson))).getBytes(StandardCharsets.UTF_8); + return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256").digest(canonical)); + } catch (JsonProcessingException | NoSuchAlgorithmException error) { + throw new IllegalStateException("Cannot fingerprint CAN definition", error); + } + } + + private static Object canonical(JsonNode value) { + if (value.isObject()) { + var sorted = new TreeMap(); + value.fields().forEachRemaining(entry -> sorted.put(entry.getKey(), canonical(entry.getValue()))); + return sorted; + } + if (value.isArray()) { + var values = new ArrayList(); + value.forEach(child -> values.add(canonical(child))); + return values; + } + return value; + } + + private static JsonNode document(String value) { + try { + var root = JSON.readTree(Objects.requireNonNull(value, "CAN definition")); + if (root == null || !root.isObject() || !root.path("schemaVersion").isIntegralNumber() || !root.path("schemaVersion").canConvertToInt() + || root.path("schemaVersion").intValue() != 1 + || !Set.of("manual", "dbc").contains(text(root, "decodeMethod"))) + throw new IllegalArgumentException("Unsupported CAN project definition"); + if ("dbc".equals(text(root, "decodeMethod"))) CanDbcService.frozenBytes(root.path("dbc")); + else if (root.has("dbc")) throw new IllegalArgumentException("Manual CAN definition contains a DBC file"); + text(root, "portId"); + var rule = root.path("definition"); + if (!rule.isObject()) throw new IllegalArgumentException("CAN integer definition is missing"); + choice(rule, "idFormat", Set.of("standard", "extended")); + choice(rule, "frameType", Set.of("any", "classic", "fd")); + choice(rule, "byteOrder", Set.of("intel", "motorola")); + choice(rule, "valueType", Set.of("signed", "unsigned")); + integer(rule, "canId", 0, "standard".equals(text(rule, "idFormat")) ? 0x7ff : 0x1fffffff); + integer(rule, "startBit", 0, 511); + integer(rule, "bitLength", 1, 53); + integer(rule, "timeoutMs", 1, Integer.MAX_VALUE); + for (String field : Set.of("factor", "offset")) + if (!rule.path(field).isNumber() || !Double.isFinite(rule.path(field).doubleValue())) + throw new IllegalArgumentException("Invalid CAN numeric rule field: " + field); + units(root); + return root; + } catch (JsonProcessingException error) { + throw new IllegalArgumentException("Malformed CAN project definition", error); + } + } + + private static CanSignalUnits units(JsonNode document) { + var quantity = CanSignalQuantity.valueOf(text(document, "quantity")); + var ppr = document.get("tachoPpr"); + Integer pulses = ppr == null || ppr.isNull() ? null : integer(document, "tachoPpr", 1, Integer.MAX_VALUE); + return new CanSignalUnits(quantity, unit(document, "sourceUnit"), unit(document, "outputUnit"), pulses); + } + + private static String unit(JsonNode node, String field) { + if (!node.path(field).isTextual()) throw new IllegalArgumentException("CAN unit is missing: " + field); + return node.path(field).textValue(); + } + + private static String text(JsonNode node, String field) { + String value = unit(node, field); + if (value.isBlank()) throw new IllegalArgumentException("CAN field is blank: " + field); + return value; + } + + private static void choice(JsonNode node, String field, Set choices) { + if (!choices.contains(text(node, field))) throw new IllegalArgumentException("Unsupported CAN field: " + field); + } + + private static int integer(JsonNode node, String field, int min, int max) { + var value = node.path(field); + if (!value.isIntegralNumber() || !value.canConvertToInt() || value.intValue() < min || value.intValue() > max) + throw new IllegalArgumentException("Invalid CAN integer field: " + field); + return value.intValue(); + } +} diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/can/CanProjectChannelService.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/can/CanProjectChannelService.java new file mode 100644 index 00000000..99ed8421 --- /dev/null +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/can/CanProjectChannelService.java @@ -0,0 +1,273 @@ +package com.opentest.service.can; + +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.core.JsonParser; +import com.fasterxml.jackson.databind.DeserializationFeature; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.node.ObjectNode; +import com.opentest.common.enums.ChannelIOEnum; +import com.opentest.common.enums.ChannelSourceEnum; +import com.opentest.common.exception.CryBusinessException; +import com.opentest.common.exception.ErrorCode; +import com.opentest.common.exception.JniBusinessException; +import com.opentest.common.exception.LocalizedMessage; +import com.opentest.common.model.dto.BoxChannelDto; +import com.opentest.common.model.dto.CanChannelSaveRequestDto; +import com.opentest.common.model.entity.BoxChannel; +import com.opentest.common.model.entity.Device; +import com.opentest.common.model.entity.Project; +import com.opentest.common.model.query.BoxChannelQuery; +import com.opentest.core.jni.CanJNIBridge; +import com.opentest.dashboard.api.channel.CanSignalQuantity; +import com.opentest.dashboard.api.channel.CanSignalUnits; +import com.opentest.service.BoxChannelService; +import com.opentest.service.DeviceService; +import com.opentest.service.ProjectService; +import com.opentest.service.helper.SetupChannelCascadeContext; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.Set; + +/** Project configuration only; reception and live rule installation belong to CanService. */ +@Service +public class CanProjectChannelService { + private static final ObjectMapper JSON = new ObjectMapper() + .enable(JsonParser.Feature.STRICT_DUPLICATE_DETECTION) + .enable(DeserializationFeature.FAIL_ON_TRAILING_TOKENS); + private static final Set PATCH_FIELDS = Set.of( + "id", "tenantId", "projectId", "channelIo", "vchId", "deviceId", "customName", "channelColor", "canDefinitionJson"); + private static final Set DEFINITION_FIELDS = Set.of("schemaVersion", "portId", "decodeMethod", + "definition", "quantity", "sourceUnit", "outputUnit", "tachoPpr", "dbc"); + private static final Set RULE_FIELDS = Set.of("signalId", "canId", "idFormat", "frameType", + "byteOrder", "valueType", "startBit", "bitLength", "factor", "offset", "timeoutMs", "invalidRawValue", "unit"); + private final BoxChannelService channels; + private final ProjectService projects; + private final DeviceService devices; + private final CanJNIBridge nativeCan; + private final CanDbcService dbc; + + public CanProjectChannelService(BoxChannelService channels, ProjectService projects, + DeviceService devices, CanJNIBridge nativeCan) { + this.channels = channels; + this.projects = projects; + this.devices = devices; + this.nativeCan = nativeCan; + this.dbc = new CanDbcService(nativeCan); + } + + @Transactional(rollbackFor = Exception.class) + public BoxChannelDto save(CanChannelSaveRequestDto request) { + if (request == null || request.getProjectId() == null || request.getDeviceId() == null + || request.getCustomName() == null || request.getCustomName().trim().isEmpty()) { + throw invalid("required", "Project, device and channel name are required."); + } + Project project = projects.findById(request.getProjectId()); + Device device = devices.findById(request.getDeviceId()); + if (project == null || device == null || project.getTenantId() == null + || !Objects.equals(project.getTenantId(), device.getTenantId()) + || device.getProtocol() == null || device.getDeviceName() == null) { + throw invalid("scope", "The CAN project or device binding is unavailable."); + } + BoxChannel existing = request.getId() == null ? null : requireCan(request.getId()); + if (existing != null && (!Objects.equals(existing.getProjectId(), project.getId()) + || !Objects.equals(existing.getTenantId(), project.getTenantId()) + || request.getVchId() != null && !Objects.equals(request.getVchId(), existing.getVchId()))) { + throw invalid("scope", "The CAN project or device binding is unavailable."); + } + BoxChannelQuery query = new BoxChannelQuery(); + query.setProjectId(project.getId()); + List projectChannels = channels.list(query); + String name = request.getCustomName().trim(); + if (projectChannels.stream().anyMatch(channel -> !Objects.equals(channel.getId(), request.getId()) + && name.equals(channel.getCustomName() == null ? null : channel.getCustomName().trim()))) { + throw new CryBusinessException(ErrorCode.VIRTUAL_CHANNEL_NAME_DUPLICATE, name); + } + BoxChannel candidate = new BoxChannel(); + candidate.setId(existing == null ? null : existing.getId()); + candidate.setCreatedTime(existing == null ? null : existing.getCreatedTime()); + candidate.setTenantId(project.getTenantId()); + candidate.setProjectId(project.getId()); + candidate.setDeviceId(device.getId()); + candidate.setProtocol(device.getProtocol()); + candidate.setChannelSource(ChannelSourceEnum.CAN.getValue()); + candidate.setChannelIo(ChannelIOEnum.INPUT.getValue()); + candidate.setCustomName(name); + candidate.setChannelColor(request.getChannelColor() == null && existing != null + ? existing.getChannelColor() : request.getChannelColor()); + Integer index = existing == null ? nextIndex(projectChannels) : existing.getVchIdNumber(); + candidate.setVchId(existing == null ? "CAN" + index : existing.getVchId()); + candidate.setVchIdNumber(index); + candidate.setCanDefinitionJson(validateDefinition(request.getCanDefinitionJson(), + project.getId(), candidate.getVchId())); + Map previous = new LinkedHashMap<>(channels.getProjectInputChannelMap(project.getId())); + channels.saveOrUpdateEntity(candidate); + cascade(project.getId(), previous, existing, candidate); + return channels.findDtoById(candidate.getId()); + } + + @Transactional(rollbackFor = Exception.class) + public boolean delete(Long boxChannelId) { + BoxChannel target = requireCan(boxChannelId); + Project project = projects.findById(target.getProjectId()); + if (project == null || !Objects.equals(project.getTenantId(), target.getTenantId())) { + throw invalid("scope", "The CAN project or device binding is unavailable."); + } + Map previous = new LinkedHashMap<>(channels.getProjectInputChannelMap(target.getProjectId())); + channels.removeById(target.getId()); + cascade(target.getProjectId(), previous, target, null); + return true; + } + + @Transactional(rollbackFor = Exception.class) + public BoxChannelDto patch(BoxChannel existing, JsonNode patch) { + patch.fieldNames().forEachRemaining(field -> { + if (!PATCH_FIELDS.contains(field)) { + throw invalid("fields", "CAN channels accept only project identity, name, color and CAN definition fields."); + } + }); + if (patch.has("channelIo") && (!patch.path("channelIo").isIntegralNumber() + || patch.path("channelIo").intValue() != ChannelIOEnum.INPUT.getValue()) + || patch.has("tenantId") && !String.valueOf(existing.getTenantId()).equals(patch.path("tenantId").asText())) { + throw invalid("scope", "The CAN project or device binding is unavailable."); + } + CanChannelSaveRequestDto request = new CanChannelSaveRequestDto(); + request.setId(existing.getId()); + request.setProjectId(existing.getProjectId()); + request.setVchId(existing.getVchId()); + request.setDeviceId(existing.getDeviceId()); + request.setCustomName(existing.getCustomName()); + request.setChannelColor(existing.getChannelColor()); + request.setCanDefinitionJson(existing.getCanDefinitionJson()); + ObjectNode merged = JSON.valueToTree(request); + patch.fields().forEachRemaining(entry -> { + if (!Set.of("tenantId", "channelIo").contains(entry.getKey())) merged.set(entry.getKey(), entry.getValue()); + }); + try { + return save(JSON.treeToValue(merged, CanChannelSaveRequestDto.class)); + } catch (JsonProcessingException failure) { + throw invalid("fields", "CAN channels accept only project identity, name, color and CAN definition fields."); + } + } + + /** Imports issue a new project rule identity while retaining the saved decoder and units. */ + public String validateDefinition(String savedJson, Long projectId, String vchId) { + if (projectId == null || vchId == null || vchId.isBlank()) { + throw invalid("scope", "The CAN project or device binding is unavailable."); + } + ObjectNode saved = object(savedJson); + saved.fieldNames().forEachRemaining(field -> { + if (!DEFINITION_FIELDS.contains(field)) throw invalid("definition", "The saved CAN definition is invalid."); + }); + if (!saved.path("schemaVersion").isIntegralNumber() || !saved.path("schemaVersion").canConvertToInt() + || saved.path("schemaVersion").intValue() != 1 + || !Set.of("manual", "dbc").contains(saved.path("decodeMethod").asText()) + || !saved.path("portId").isTextual() || saved.path("portId").textValue().isBlank() + || !saved.path("definition").isObject()) { + throw invalid("definition", "The saved CAN definition is invalid."); + } + if ("manual".equals(saved.path("decodeMethod").asText()) && saved.has("dbc")) + throw invalid("definition", "The saved CAN definition is invalid."); + try { + if (!saved.path("quantity").isTextual() || !saved.path("sourceUnit").isTextual() + || !saved.path("outputUnit").isTextual()) throw new IllegalArgumentException(); + JsonNode ppr = saved.get("tachoPpr"); + if (ppr != null && !ppr.isNull() && (!ppr.isIntegralNumber() || !ppr.canConvertToInt())) + throw new IllegalArgumentException(); + new CanSignalUnits(CanSignalQuantity.valueOf(saved.path("quantity").textValue()), + saved.path("sourceUnit").textValue(), saved.path("outputUnit").textValue(), + ppr == null || ppr.isNull() ? null : ppr.intValue()); + } catch (IllegalArgumentException failure) { + throw invalid("units", "The CAN quantity, source unit, output unit or Tacho PPR is invalid."); + } + ObjectNode definition = (ObjectNode) saved.get("definition"); + definition.fieldNames().forEachRemaining(field -> { + if (!RULE_FIELDS.contains(field)) throw invalid("definition", "The saved CAN definition is invalid."); + }); + JsonNode invalidRaw = definition.get("invalidRawValue"); + if (invalidRaw != null && !invalidRaw.isNull() && !invalidRaw.isTextual()) { + throw invalid("definition", "The saved CAN definition is invalid."); + } + if ("dbc".equals(saved.path("decodeMethod").asText())) { + definition = dbc.verify(saved); + saved.set("definition", definition); + } + definition.put("signalId", signalId(projectId, vchId)); + definition.put("unit", saved.path("sourceUnit").textValue()); + ObjectNode payload = JSON.createObjectNode().put("schemaVersion", 1); + payload.putArray("signals").add(definition); + JsonNode response; + try { + response = object(nativeCan.validateCanSignalDefinitionsV1(payload.toString())); + } catch (LinkageError failure) { + throw invalid("nativeUnavailable", "The installed Native library cannot validate CAN signal definitions."); + } + if (!response.path("code").isIntegralNumber() || !response.path("code").canConvertToInt()) { + throw invalid("nativeResponse", "Native returned an incomplete CAN validation response."); + } + if (response.path("code").intValue() != 0) { + throw JniBusinessException.fromNativeResponseCode(response.path("code").intValue()); + } + JsonNode data = response.path("data"); + if (!data.path("valid").isBoolean() || !data.path("issues").isArray() + || !data.path("signals").isArray() || data.path("signals").size() != 1) { + throw invalid("nativeResponse", "Native returned an incomplete CAN validation response."); + } + if (!data.path("valid").booleanValue() || !data.path("issues").isEmpty() + || !data.path("signals").get(0).isObject() + || !signalId(projectId, vchId).equals(data.path("signals").get(0).path("signalId").asText())) { + throw invalid("rule", "The CAN decoder rule is invalid or unsupported."); + } + return saved.toString(); + } + + public static String signalId(Long projectId, String vchId) { + return "can:" + projectId + ":" + vchId; + } + + private ObjectNode object(String json) { + try { + JsonNode value = json == null ? null : JSON.readTree(json); + if (value instanceof ObjectNode object) return object; + } catch (JsonProcessingException ignored) { + // The boundary exposes a localized configuration error, not parser internals. + } + throw invalid("definition", "The saved CAN definition is invalid."); + } + + private BoxChannel requireCan(Long id) { + if (id == null) throw invalid("scope", "The CAN project or device binding is unavailable."); + BoxChannel channel = channels.findById(id); + if (channel == null || !ChannelSourceEnum.isCan(channel.getChannelSource())) + throw invalid("scope", "The CAN project or device binding is unavailable."); + return channel; + } + + private int nextIndex(List projectChannels) { + return projectChannels.stream().filter(channel -> ChannelSourceEnum.isCan(channel.getChannelSource())) + .map(BoxChannel::getVchIdNumber).filter(Objects::nonNull).mapToInt(Integer::intValue).max().orElse(0) + 1; + } + + private void cascade(Long projectId, Map previous, BoxChannel old, BoxChannel current) { + try (SetupChannelCascadeContext ignored = SetupChannelCascadeContext.open(projectId)) { + projects.modifyCollectionInputConfig(projectId, previous, channels.getProjectInputChannelMap(projectId)); + if (old != null && current != null + && (!Objects.equals(old.getCanDefinitionJson(), current.getCanDefinitionJson()) + || !Objects.equals(old.getDeviceId(), current.getDeviceId()) + || !Objects.equals(old.getCustomName(), current.getCustomName()) + || !Objects.equals(old.getChannelColor(), current.getChannelColor()))) { + channels.refreshCanChannelReferences(projectId, old); + } + } + } + + public static CryBusinessException invalid(String reason, String fallback) { + return new CryBusinessException(ErrorCode.CHECK_PARAMETER, + LocalizedMessage.of("can.project.error." + reason, fallback)); + } +} diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/can/CanRawRecordingStore.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/can/CanRawRecordingStore.java new file mode 100644 index 00000000..454065f4 --- /dev/null +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/can/CanRawRecordingStore.java @@ -0,0 +1,342 @@ +package com.opentest.service.can; + +import cn.hutool.json.JSONConfig; +import cn.hutool.json.JSONObject; +import cn.hutool.json.JSONUtil; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.opentest.platform.file.concurrent.ConcurrentFileManager; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +import java.io.Writer; +import java.math.BigInteger; +import java.nio.ByteBuffer; +import java.nio.channels.FileChannel; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.LinkOption; +import java.nio.file.Path; +import java.nio.file.StandardCopyOption; +import java.nio.file.StandardOpenOption; +import java.util.ArrayList; +import java.util.Comparator; +import java.util.List; +import java.util.Map; +import java.util.UUID; +import java.util.concurrent.ConcurrentHashMap; +import java.util.stream.Stream; + +@Service +public class CanRawRecordingStore { + public static final int STORAGE_ERROR = 13103201; + public static final int INVALID_REQUEST = 13103202; + public static final int NOT_FOUND = 13103203; + public static final int ACTIVE_RECORDING = 13103204; + private static final String DIRECTORY = "can-raw-recordings"; + private static final List SOURCE_FIELDS = List.of("deviceId", "deviceName", "protocol", "portId", "receiveId"); + private static final List CSV_FIELDS = List.of( + "sequence", "canId", "idFormat", "frameType", "flags", "length", "dlc", "dataHex", "source", + "rawTimestampNs", "timestampSource", "rawClockId", "sessionEpoch", "mappingRevision", + "measurementTimeValid", "measurementTimeNs", "receivedAtEpochMs", + "origin.deviceId", "origin.deviceName", "origin.protocol", "origin.portId", "origin.receiveId", "origin.epoch"); + private final Path root; + private final ObjectMapper mapper; + private final Map active = new ConcurrentHashMap<>(); + + @Autowired + public CanRawRecordingStore(ConcurrentFileManager manager, ObjectMapper mapper) { + this(Path.of(manager.getBasePath()), mapper); + } + + public CanRawRecordingStore(Path basePath, ObjectMapper mapper) { + this.root = basePath.toAbsolutePath().normalize().resolve(DIRECTORY); + this.mapper = mapper; + } + + public interface Recording { + String id(); + JSONObject snapshot(); + void append(List frames, JSONObject batchMetadata); + JSONObject finish(JSONObject terminalMetadata, boolean complete); + } + + public synchronized Recording begin(JSONObject source, JSONObject startCutoff) { + String id = UUID.randomUUID().toString(); + FileChannel frames = null; + try { + Files.createDirectories(root); + requireDirectory(root); + Path directory = Files.createDirectory(root.resolve(id)); + frames = FileChannel.open(directory.resolve("frames.jsonl"), StandardOpenOption.CREATE_NEW, + StandardOpenOption.WRITE, LinkOption.NOFOLLOW_LINKS); + JSONObject descriptor = object().set("id", id); + for (String field : SOURCE_FIELDS) descriptor.set(field, source.getStr(field)); + descriptor.set("startedAtEpochMs", Long.toString(System.currentTimeMillis())) + .set("finishedAtEpochMs", null).set("frameCount", "0").set("complete", false) + .set("startCutoff", copy(startCutoff)).set("metadata", object()); + DiskRecording recording = new DiskRecording(directory, descriptor, frames); + publish(directory, descriptor); + active.put(id, recording); + return recording; + } catch (IOException error) { + if (frames != null) { + try { frames.close(); } catch (IOException closeError) { error.addSuppressed(closeError); } + } + throw storage(error); + } + } + + public synchronized JSONObject history() { + List records = new ArrayList<>(); + if (Files.notExists(root, LinkOption.NOFOLLOW_LINKS)) return object().set("records", records); + try { + requireDirectory(root); + try (Stream paths = Files.list(root)) { + for (Path directory : paths.filter(path -> validId(path.getFileName().toString())).toList()) { + requireDirectory(directory); + if (Files.notExists(directory.resolve("descriptor.json"), LinkOption.NOFOLLOW_LINKS)) continue; + JSONObject descriptor = descriptor(directory.getFileName().toString()); + if (!descriptor.isNull("finishedAtEpochMs")) records.add(descriptor); + } + } + records.sort(Comparator.comparing((JSONObject record) -> new BigInteger(record.getStr("startedAtEpochMs"))) + .reversed().thenComparing(record -> record.getStr("id"))); + return object().set("records", records); + } catch (IOException error) { throw storage(error); } + } + + public synchronized JSONObject preview(String recordingId, long offset, int limit) { + if (offset < 0 || limit < 1 || limit > 1000) throw invalidRequest(); + JSONObject descriptor = descriptor(recordingId); + BigInteger count = new BigInteger(descriptor.getStr("frameCount")); + List frames = new ArrayList<>(); + long next = offset; + try (BufferedReader input = frames(recordingId)) { + long skipped = 0; + while (skipped < offset && BigInteger.valueOf(skipped).compareTo(count) < 0) { + readFrame(input); + skipped++; + } + while (frames.size() < limit && BigInteger.valueOf(next).compareTo(count) < 0) { + frames.add(json(readFrame(input))); + next++; + } + return object().set("frames", frames).set("offset", Long.toString(offset)) + .set("nextOffset", Long.toString(next)).set("frameCount", count.toString()) + .set("metadata", descriptor.getJSONObject("metadata")); + } catch (IOException error) { throw storage(error); } + } + + public synchronized void csv(String recordingId, Writer output) { + JSONObject descriptor = descriptor(recordingId); + BigInteger count = new BigInteger(descriptor.getStr("frameCount")); + try (BufferedReader input = frames(recordingId)) { + output.write(String.join(",", CSV_FIELDS)); + output.write(",frameJson\r\n"); + for (BigInteger row = BigInteger.ZERO; row.compareTo(count) < 0; row = row.add(BigInteger.ONE)) { + String line = readFrame(input); + JsonNode frame = mapper.readTree(line); + for (String field : CSV_FIELDS) { + JsonNode value = frame; + for (String part : field.split("\\.")) value = value.path(part); + csvCell(output, value.isMissingNode() || value.isNull() ? "" : value.asText()); + output.write(','); + } + // The final column also preserves future Native fields, nested payloads and explicit nulls. + csvCell(output, line); + output.write("\r\n"); + } + output.flush(); + } catch (IOException error) { throw storage(error); } + } + + public synchronized void delete(String recordingId) { + JSONObject descriptor = descriptor(recordingId); + if (active.containsKey(recordingId) || descriptor.isNull("finishedAtEpochMs")) + throw new CanOperationException(ACTIVE_RECORDING, "can.recording.error.active"); + try { + Path directory = directory(recordingId); + requireFile(directory.resolve("frames.jsonl")); + Files.delete(directory.resolve("frames.jsonl")); + Files.delete(directory.resolve("descriptor.json")); + Files.delete(directory); + } catch (IOException error) { throw storage(error); } + } + + private final class DiskRecording implements Recording { + private final Path directory; + private final JSONObject descriptor; + private final FileChannel frames; + private BigInteger count = BigInteger.ZERO; + private long committedBytes; + private boolean closed; + + private DiskRecording(Path directory, JSONObject descriptor, FileChannel frames) { + this.directory = directory; + this.descriptor = descriptor; + this.frames = frames; + } + + @Override public String id() { return directory.getFileName().toString(); } + @Override public synchronized JSONObject snapshot() { return copy(descriptor); } + + @Override + public synchronized void append(List batch, JSONObject batchMetadata) { + requireOpen(); + mergeMetadata(batchMetadata); + try { + for (JSONObject frame : batch) { + ByteBuffer bytes = StandardCharsets.UTF_8.encode(frame.toString() + "\n"); + while (bytes.hasRemaining()) frames.write(bytes); + committedBytes = frames.position(); + count = count.add(BigInteger.ONE); + descriptor.set("frameCount", count.toString()); + } + publish(directory, descriptor); + } catch (IOException error) { throw failed(error); } + } + + @Override + public synchronized JSONObject finish(JSONObject terminalMetadata, boolean complete) { + if (closed) return snapshot(); + mergeMetadata(terminalMetadata); + descriptor.set("finishedAtEpochMs", Long.toString(System.currentTimeMillis())).set("complete", complete); + try { + frames.force(true); + frames.close(); + publish(directory, descriptor); + closed = true; + active.remove(id(), this); + return snapshot(); + } catch (IOException error) { throw failed(error); } + } + + private void requireOpen() { + if (closed) throw new CanOperationException(ACTIVE_RECORDING, "can.recording.error.closed"); + } + + private void mergeMetadata(JSONObject metadata) { + if (metadata == null) return; + JSONObject copy = copy(metadata); + copy.remove("frames"); + descriptor.getJSONObject("metadata").putAll(copy); + } + + private CanOperationException failed(IOException error) { + descriptor.set("finishedAtEpochMs", Long.toString(System.currentTimeMillis())).set("complete", false); + descriptor.getJSONObject("metadata").set("recordingErrorCode", STORAGE_ERROR); + try { + if (frames.isOpen()) { + // Keep only complete JSONL rows if a disk write stopped in the middle of a frame. + frames.truncate(committedBytes); + frames.force(true); + } + } catch (IOException recoveryError) { error.addSuppressed(recoveryError); } + finally { + try { frames.close(); } catch (IOException closeError) { error.addSuppressed(closeError); } + closed = true; + } + try { publish(directory, descriptor); } + catch (IOException publishError) { error.addSuppressed(publishError); } + finally { active.remove(id(), this); } + return storage(error); + } + } + + private JSONObject descriptor(String id) { + Path directory = directory(id); + // Active writers own the descriptor; a disk reader can block its replacement on Windows. + DiskRecording recording = active.get(id); + if (recording != null) return recording.snapshot(); + Path file = directory.resolve("descriptor.json"); + if (Files.notExists(file, LinkOption.NOFOLLOW_LINKS)) + throw new CanOperationException(NOT_FOUND, "can.recording.error.notFound"); + try { + requireFile(file); + try (BufferedReader input = reader(file)) { + JsonNode data = mapper.readTree(input); + if (data == null || !id.equals(data.path("id").asText()) + || !data.path("frameCount").asText().matches("0|[1-9][0-9]*")) + throw new IOException("Invalid recording descriptor"); + return json(data.toString()); + } + } catch (IOException error) { throw storage(error); } + } + + private Path directory(String id) { + if (!validId(id)) throw invalidRequest(); + Path directory = root.resolve(id); + if (Files.notExists(directory, LinkOption.NOFOLLOW_LINKS)) + throw new CanOperationException(NOT_FOUND, "can.recording.error.notFound"); + try { + requireDirectory(root); + requireDirectory(directory); + return directory; + } catch (IOException error) { throw storage(error); } + } + + private BufferedReader frames(String id) throws IOException { + Path file = directory(id).resolve("frames.jsonl"); + requireFile(file); + return reader(file); + } + + private BufferedReader reader(Path file) throws IOException { + return new BufferedReader(new InputStreamReader( + Files.newInputStream(file, StandardOpenOption.READ, LinkOption.NOFOLLOW_LINKS), StandardCharsets.UTF_8)); + } + + private void publish(Path directory, JSONObject descriptor) throws IOException { + requireDirectory(root); + requireDirectory(directory); + Path temporary = Files.createTempFile(directory, "descriptor-", ".tmp"); + try { + byte[] json = mapper.writeValueAsBytes(mapper.readTree(descriptor.toString())); + try (FileChannel output = FileChannel.open(temporary, StandardOpenOption.WRITE, LinkOption.NOFOLLOW_LINKS)) { + ByteBuffer bytes = ByteBuffer.wrap(json); + while (bytes.hasRemaining()) output.write(bytes); + output.force(true); + } + Files.move(temporary, directory.resolve("descriptor.json"), + StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING); + } finally { Files.deleteIfExists(temporary); } + } + + private static String readFrame(BufferedReader input) throws IOException { + String line = input.readLine(); + if (line == null) throw new IOException("Recording frame stream is truncated"); + return line; + } + + private static void csvCell(Writer output, String value) throws IOException { + output.write('"'); + output.write(value.replace("\"", "\"\"")); + output.write('"'); + } + + private static boolean validId(String id) { + return id != null && id.matches("[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}"); + } + + private static void requireDirectory(Path path) throws IOException { + if (!Files.isDirectory(path, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Invalid recording directory"); + } + + private static void requireFile(Path path) throws IOException { + if (!Files.isRegularFile(path, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Invalid recording file"); + } + + private static JSONObject object() { return new JSONObject(JSONConfig.create().setIgnoreNullValue(false)); } + private static JSONObject json(String text) { return JSONUtil.parseObj(text, JSONConfig.create().setIgnoreNullValue(false)); } + private static JSONObject copy(JSONObject source) { return source == null ? object() : json(source.toString()); } + private static CanOperationException invalidRequest() { + return new CanOperationException(INVALID_REQUEST, "can.recording.error.request"); + } + private static CanOperationException storage(IOException error) { + return new CanOperationException(STORAGE_ERROR, "can.recording.error.storage", error); + } +} diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/can/CanService.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/can/CanService.java new file mode 100644 index 00000000..b2657437 --- /dev/null +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/can/CanService.java @@ -0,0 +1,783 @@ +package com.opentest.service.can; + +import cn.hutool.json.JSONArray; +import cn.hutool.json.JSONObject; +import cn.hutool.json.JSONUtil; +import cn.hutool.json.JSONConfig; +import com.opentest.common.model.entity.Device; +import com.opentest.service.DeviceService; +import com.opentest.service.jni.AudioJNIBridgeService; +import com.opentest.dashboard.api.channel.CanSignalChannel; +import jakarta.annotation.PostConstruct; +import jakarta.annotation.PreDestroy; +import jakarta.annotation.Resource; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.stereotype.Service; + +import java.math.BigInteger; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.security.NoSuchAlgorithmException; +import java.util.ArrayDeque; +import java.util.ArrayList; +import java.util.Deque; +import java.util.HexFormat; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.TreeMap; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.Executors; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.TimeUnit; + +@Service +public class CanService { + private static final Logger LOG = LoggerFactory.getLogger(CanService.class); + private record DeviceKey(String protocol, String stableId, String nativeId, Long databaseId, String displayName) { + String storageKey() { return JSONUtil.toJsonStr(new String[] {protocol, stableId}); } + } + private static final class DeviceState { + volatile DeviceKey identity; + Boolean requestedEnabled; + final Map ports = new ConcurrentHashMap<>(); + } + private static final class PortSource { + final String port; + final Deque preview = new ArrayDeque<>(); + String receiveId; + String nativeId; + String revision; + String state = "stopped"; + boolean manual; + Integer lastErrorCode; + JSONObject diagnostics; + JSONObject appliedConfig; + JSONObject rawMetadata; + DeviceKey identity; + final Map business = new LinkedHashMap<>(); + CanRawRecordingStore.Recording recording; + String recordingStartSequence; + String recordingSessionEpoch; + JSONObject recordingMetadata; + boolean recordingComplete; + Integer recordingErrorCode; + boolean configurationSaved = true; + PortSource(String port) { this.port = port; } + } + private record RecordingStop(String sessionEpoch, BigInteger sequence) { } + + private final DeviceService devices; + private final AudioJNIBridgeService audioDevices; + private final CanNativeGateway nativeCan; + private final CanConfigurationStore configurations; + @Resource private CanRawRecordingStore recordings; + private final Map states = new ConcurrentHashMap<>(); + private volatile boolean shuttingDown; + private final ScheduledExecutorService reader = Executors.newScheduledThreadPool(2, runnable -> { + Thread thread = new Thread(runnable, "can-raw-reader"); + thread.setDaemon(true); + return thread; + }); + + public CanService(DeviceService devices, AudioJNIBridgeService audioDevices, CanNativeGateway nativeCan, CanConfigurationStore configurations) { + this.devices = devices; + this.audioDevices = audioDevices; + this.nativeCan = nativeCan; + this.configurations = configurations; + } + + @PostConstruct + public void startReader() { reader.scheduleWithFixedDelay(this::readSources, 0, 10, TimeUnit.MILLISECONDS); } + + private DeviceKey key(Long deviceId) { + Device device = devices.findById(deviceId); + if (device == null || device.getProtocol() == null || device.getDeviceName() == null) + throw new CanOperationException(13103006, "can.error.deviceUnavailable"); + return new DeviceKey(device.getProtocol(), DeviceService.deviceIdentity(device.getProtocol(), + device.getDeviceName(), device.getIpAddress()), audioDevices.getJniDeviceId(device), deviceId, device.getDeviceName()); + } + private DeviceState device(DeviceKey key) { + DeviceState state = states.computeIfAbsent(key.storageKey(), ignored -> new DeviceState()); + state.identity = key; + return state; + } + + private DeviceKey existingKey(Long deviceId, String portId) { + Device device = devices.findById(deviceId); + if (device == null) throw new CanOperationException(13103006, "can.error.deviceUnavailable"); + DeviceKey stable = new DeviceKey(device.getProtocol(), DeviceService.deviceIdentity(device.getProtocol(), + device.getDeviceName(), device.getIpAddress()), null, deviceId, device.getDeviceName()); + DeviceState current = states.get(stable.storageKey()); + PortSource source = current == null ? null : current.ports.get(portId); + if (source != null) { + synchronized (source) { + if (source.receiveId != null) + return new DeviceKey(stable.protocol, stable.stableId, source.nativeId, deviceId, device.getDeviceName()); + } + } + return key(deviceId); + } + + private PortSource port(DeviceKey key, String port) { + DeviceState state = device(key); + PortSource existing = state.ports.get(port); + if (existing != null) return existing; + JSONArray available = nativeCan.capabilities(key.protocol, key.nativeId).getJSONArray("ports"); + boolean found = available != null && available.stream().anyMatch(item -> + port.equals(JSONUtil.parseObj(item).getStr("portId"))); + if (!found) throw new CanOperationException(13103001, "can.error.portUnavailable"); + PortSource source = state.ports.computeIfAbsent(port, PortSource::new); + source.identity = key; + return source; + } + + public JSONObject capabilities(Long deviceId) { + DeviceKey key = key(deviceId); + synchronized (device(key)) { + JSONObject result = new JSONObject(nativeCan.capabilities(key.protocol, key.nativeId), JSONConfig.create().setIgnoreNullValue(false)); + return result.set("requestedEnabled", device(key).requestedEnabled); + } + } + + public JSONObject enable(Long deviceId, boolean enabled) { + DeviceKey key = key(deviceId); + synchronized (device(key)) { + if (!enabled && device(key).ports.values().stream().anyMatch(source -> source.receiveId != null)) + throw new CanOperationException(13103008, "can.error.busy"); + nativeCan.enable(key.protocol, key.nativeId, enabled); + device(key).requestedEnabled = enabled; + return capabilities(deviceId); + } + } + + public JSONObject configuration(Long deviceId, String portId, JSONObject config) { + DeviceKey key = key(deviceId); + synchronized (device(key)) { + PortSource source = port(key, portId); + synchronized (source) { + if (source.receiveId != null) throw new CanOperationException(13103008, "can.error.busy"); + JSONObject receipt = nativeCan.configure(key.protocol, key.nativeId, portId, config); + source.revision = receipt.getStr("configurationRevision"); + source.appliedConfig = JSONUtil.parseObj(config.toString()); + source.configurationSaved = false; + configurations.save(key.storageKey(), portId, source.appliedConfig); + source.configurationSaved = true; + source.lastErrorCode = null; + return snapshot(key, source); + } + } + } + + public JSONObject start(Long deviceId, String portId) { + DeviceKey key = key(deviceId); + synchronized (device(key)) { + PortSource source = port(key, portId); + synchronized (source) { + if (source.receiveId != null) { + if (!"running".equals(source.state)) throw new CanOperationException(13103002, "can.error.sourceFailed"); + source.manual = true; + return snapshot(key, source); + } + startSource(key, source); + source.manual = true; + return snapshot(key, source); + } + } + } + + private void startSource(DeviceKey key, PortSource source) { + String portId = source.port; + // Preserve a Native-applied change even when persisting that change failed. + boolean restoreSaved = source.appliedConfig == null; + JSONObject applied = restoreSaved ? configurations.get(key.storageKey(), portId) : source.appliedConfig; + if (applied != null) { + nativeCan.configure(key.protocol, key.nativeId, portId, applied); + source.appliedConfig = applied; + if (restoreSaved) source.configurationSaved = true; + } + JSONObject request = new JSONObject(JSONConfig.create().setIgnoreNullValue(false)).set("schemaVersion", 1).set("rawFrames", true) + .set("decodedSignals", true).set("signalDelivery", "subscriptions") + .set("signalDefinitions", new JSONArray()); + JSONObject result = nativeCan.start(key.protocol, key.nativeId, portId, request); + String receiveId = result.getStr("receiveId"); + if (receiveId == null || receiveId.isBlank()) + throw new CanOperationException(13103001, "can.error.invalidResponse"); + source.receiveId = receiveId; + source.nativeId = key.nativeId; + source.identity = key; + source.revision = result.getStr("configurationRevision"); + source.state = "running"; + source.preview.clear(); + source.rawMetadata = null; + source.lastErrorCode = null; + } + + public JSONObject stop(Long deviceId, String portId) { + DeviceKey key = existingKey(deviceId, portId); + retryFailedBusinessCleanup(key, portId); + synchronized (device(key)) { + PortSource source = port(key, portId); + synchronized (source) { + if (!source.business.isEmpty()) throw new CanOperationException(13103008, "can.error.busy"); + if (source.receiveId == null) return snapshot(key, source); + CanOperationException recordingFailure = null; + try { stopRecording(source); } + catch (CanOperationException failure) { recordingFailure = failure; } + try { stopSource(source); } + catch (CanOperationException failure) { + if (recordingFailure == null) throw failure; + recordingFailure.addSuppressed(failure); + } + if (recordingFailure != null) throw recordingFailure; + return snapshot(key, source); + } + } + } + + public JSONObject startRecording(Long deviceId, String portId) { + DeviceKey key = existingKey(deviceId, portId); + synchronized (device(key)) { + PortSource source = port(key, portId); + synchronized (source) { + if (source.recording != null) return snapshot(key, source); + if (source.receiveId == null || !"running".equals(source.state)) + throw new CanOperationException(13103002, "can.error.sourceFailed"); + JSONObject status = nativeCan.status(key.protocol, source.nativeId, portId); + JSONObject application = status.getJSONObject("application"); + if (application == null || !source.receiveId.equals(application.getStr("receiveId")) + || !"running".equals(application.getStr("state"))) + throw new CanOperationException(13103002, "can.error.sourceFailed"); + JSONObject observations = application.getJSONObject("sourceObservations"); + JSONObject cutoff = observations == null ? null : observations.getJSONObject("lastFrameIdentity"); + source.recordingStartSequence = cutoff == null ? null : cutoff.getStr("sequence"); + source.recordingSessionEpoch = cutoff == null ? null : cutoff.getStr("sessionEpoch"); + JSONObject origin = new JSONObject().set("deviceId", key.databaseId.toString()) + .set("deviceName", key.displayName).set("protocol", key.protocol) + .set("portId", portId).set("receiveId", source.receiveId); + source.recording = Objects.requireNonNull(recordings, "CAN recording store").begin(origin, application); + source.recordingMetadata = copy(application); + source.recordingComplete = recordingComplete(application); + source.recordingErrorCode = null; + source.manual = true; + return snapshot(key, source); + } + } + } + + public JSONObject stopRecording(Long deviceId, String portId) { + DeviceKey key = existingKey(deviceId, portId); + synchronized (device(key)) { + PortSource source = port(key, portId); + synchronized (source) { + stopRecording(source); + return snapshot(key, source); + } + } + } + + private void stopRecording(PortSource source) { + if (source.recording == null) return; + CanOperationException failure = null; + boolean complete = false; + try { + DeviceKey key = source.identity; + JSONObject status = nativeCan.status(key.protocol, source.nativeId, source.port); + JSONObject application = status.getJSONObject("application"); + if (application == null || !source.receiveId.equals(application.getStr("receiveId"))) + throw new CanOperationException(13103001, "can.error.invalidResponse"); + source.diagnostics = status; + String actual = application.getStr("state"); + if (actual != null && (source.lastErrorCode == null || "error".equals(actual) || "disconnected".equals(actual))) + source.state = actual; + source.recordingMetadata.set("stopCutoff", copy(application)); + source.recordingComplete &= recordingComplete(application); + complete = "running".equals(actual); + JSONObject observations = application.getJSONObject("sourceObservations"); + JSONObject identity = observations == null ? null : observations.getJSONObject("lastFrameIdentity"); + JSONObject stats = application.getJSONObject("applicationStats"); + BigInteger remaining = decimal(stats == null ? null : stats.getStr("queuedFrames")); + String epoch = identity == null ? null : identity.getStr("sessionEpoch"); + BigInteger sequence = identity == null ? null : decimal(identity.getStr("sequence")); + if (identity != null) decimal(epoch); + if (remaining.signum() > 0 && identity == null) + throw new CanOperationException(13103001, "can.error.invalidResponse"); + RecordingStop cutoff = new RecordingStop(epoch, sequence); + boolean reached = remaining.signum() == 0; + // Native status freezes a finite FIFO prefix; arrivals after it cannot extend this drain. + while (remaining.signum() > 0) { + JSONObject batch = nativeCan.readFrames(source.receiveId); + appendFrames(source, batch, cutoff); + JSONArray frames = batch.getJSONArray("frames"); + if (frames == null || frames.isEmpty()) + throw new CanOperationException(13103001, "can.error.invalidResponse"); + for (Object item : frames) { + JSONObject frame = JSONUtil.parseObj(item); + reached |= epoch.equals(frame.getStr("sessionEpoch")) + && sequence.equals(decimal(frame.getStr("sequence"))); + } + remaining = remaining.subtract(BigInteger.valueOf(frames.size())); + } + if (!reached && source.recordingComplete) + throw new CanOperationException(13103001, "can.error.invalidResponse"); + } catch (CanOperationException error) { + failure = error; + } catch (RuntimeException error) { + failure = new CanOperationException(13103001, "can.error.invalidResponse", error); + } catch (LinkageError error) { + failure = new CanOperationException(13103023, "error.jni.native.13103023", error); + } + if (failure != null) { + source.recordingErrorCode = failure.code(); + source.recordingMetadata.set("recordingErrorCode", failure.code()) + .set("recordingErrorKey", failure.messageKey()); + } + try { finishRecording(source, complete && failure == null, true); } + catch (CanOperationException error) { + if (failure == null) failure = error; + else failure.addSuppressed(error); + } + if (failure != null) throw failure; + } + + private static BigInteger decimal(String value) { + if (value == null || !value.matches("0|[1-9][0-9]*")) + throw new CanOperationException(13103001, "can.error.invalidResponse"); + return new BigInteger(value); + } + + private static boolean recordingComplete(JSONObject metadata) { + JSONObject integrity = metadata.getJSONObject("integrity"); + return Boolean.TRUE.equals(metadata.getBool("complete")) && (integrity == null + || !Boolean.FALSE.equals(integrity.getBool("complete")) + && "0".equals(integrity.getStr("lostFrames", "0"))); + } + + private void finishRecording(PortSource source, boolean complete, boolean propagate) { + if (source.recording == null) return; + try { source.recording.finish(source.recordingMetadata, complete && source.recordingComplete); } + catch (RuntimeException failure) { + source.recordingErrorCode = CanRawRecordingStore.STORAGE_ERROR; + LOG.warn("CAN raw recording finalization failed, port={}, record={}", source.port, source.recording.id(), failure); + if (propagate) throw new CanOperationException(CanRawRecordingStore.STORAGE_ERROR, "can.recording.error.storage", failure); + } finally { source.recording = null; } + } + + private void stopSource(PortSource source) { + source.state = "stopping"; + CanOperationException failure = null; + try { + try { + nativeCan.stop(source.receiveId); + JSONObject tail; + do { tail = nativeCan.readFrames(source.receiveId); appendFrames(source, tail); } + while (tail.getJSONArray("frames") != null && !tail.getJSONArray("frames").isEmpty()); + } catch (CanOperationException error) { + if (error.code() != 13103003 && error.code() != 13103006 && error.code() != 13103007) throw error; + if (error.code() != 13103003) failure = error; + LOG.info("CAN cleanup continuing after terminal stop/read, receiveId={}, code={}", source.receiveId, error.code()); + } + try { nativeCan.close(source.receiveId); } + catch (CanOperationException error) { + // Native Close stores its receipt and erases the reservation before reporting these errors. + if (error.code() != 13103003 && error.code() != 13103006 && error.code() != 13103007) throw error; + if (error.code() != 13103003) { + if (failure == null) failure = error; + else if (failure != error) failure.addSuppressed(error); + } + LOG.info("CAN cleanup confirmed a released receiveId={}, code={}", source.receiveId, error.code()); + } + source.receiveId = null; + source.manual = false; + source.state = "stopped"; + source.lastErrorCode = failure == null ? null : failure.code(); + } catch (CanOperationException error) { + if (failure != null && failure != error) { + failure.addSuppressed(error); + error = failure; + } + source.lastErrorCode = error.code(); + source.state = "error"; + throw error; + } catch (RuntimeException | LinkageError error) { + source.state = "error"; + if (failure != null) { + failure.addSuppressed(error); + source.lastErrorCode = failure.code(); + throw failure; + } + source.lastErrorCode = 13103023; + throw new CanOperationException(13103023, "error.jni.native.13103023", error); + } + if (failure != null) throw failure; + } + + public List acquire(String usageId, String label, List channels) { + Map> groups = new LinkedHashMap<>(); + for (var channel : channels) { + String group = JSONUtil.toJsonStr(new String[] {channel.binding().deviceId(), channel.binding().portId()}); + groups.computeIfAbsent(group, ignored -> new ArrayList<>()).add(channel); + } + List acquired = new ArrayList<>(); + try { + for (var group : groups.values()) acquired.add(acquirePort(usageId, label, group)); + return List.copyOf(acquired); + } catch (RuntimeException | LinkageError failure) { + for (var subscription : acquired.reversed()) { + try { subscription.close(); } + catch (RuntimeException | LinkageError cleanup) { failure.addSuppressed(cleanup); } + } + throw failure; + } + } + + private BusinessSubscription acquirePort(String usageId, String label, List channels) { + var first = channels.getFirst(); + DeviceKey key = key(Long.valueOf(first.binding().deviceId())); + if (!key.protocol.equals(first.binding().protocol()) || !key.stableId.equals(first.binding().stableDeviceId())) + throw new CanOperationException(13103006, "can.error.deviceUnavailable"); + synchronized (device(key)) { + PortSource source = port(key, first.binding().portId()); + synchronized (source) { + if (source.business.containsKey(usageId)) throw new IllegalStateException("CAN usage already exists"); + if (source.receiveId != null && !"running".equals(source.state)) + throw new CanOperationException(13103002, "can.error.sourceFailed"); + boolean started = source.receiveId == null; + var subscription = new BusinessSubscription(key, source, usageId, label, channels); + try { + if (started) startSource(key, source); + subscription.receiveId = source.receiveId; + JSONObject union = definitions(source, subscription, null); + JSONObject validation = nativeCan.validateDefinitions(union); + if (!Boolean.TRUE.equals(validation.getBool("valid"))) + throw new CanOperationException(13103001, "can.error.invalidDefinition"); + nativeCan.updateDefinitions(source.receiveId, union); + JSONObject selection = new JSONObject().set("schemaVersion", 1) + .set("signalIds", new JSONArray(subscription.rules.keySet())); + JSONObject receipt = nativeCan.subscribe(source.receiveId, selection); + subscription.subscriptionId = receipt.getStr("subscriptionId"); + if (subscription.subscriptionId == null || subscription.subscriptionId.isBlank()) + throw new CanOperationException(13103019, "can.error.invalidResponse"); + source.business.put(usageId, subscription); + return subscription; + } catch (RuntimeException | LinkageError failure) { + try { + if (source.receiveId != null) { + nativeCan.updateDefinitions(source.receiveId, definitions(source, null, null)); + if (started && !source.manual && source.business.isEmpty()) stopSource(source); + } + } catch (RuntimeException | LinkageError cleanup) { + failure.addSuppressed(cleanup); + if (source.receiveId != null) { + subscription.cleanupFailed = true; + source.business.put(usageId, subscription); + } + } + throw failure; + } + } + } + } + + private JSONObject definitions(PortSource source, BusinessSubscription addition, String removal) { + Map rules = new LinkedHashMap<>(); + source.business.forEach((id, subscription) -> { + if (!id.equals(removal)) rules.putAll(subscription.rules); + }); + if (addition != null) rules.putAll(addition.rules); + return new JSONObject().set("schemaVersion", 1).set("signals", new JSONArray(rules.values())); + } + + public void releaseUsage(String usageId) { + List held = new ArrayList<>(); + states.values().forEach(device -> device.ports.values().forEach(source -> { + synchronized (source) { + BusinessSubscription subscription = source.business.get(usageId); + if (subscription != null) held.add(subscription); + } + })); + Throwable failure = null; + for (var subscription : held.reversed()) { + try { subscription.close(); } + catch (RuntimeException | LinkageError error) { + if (failure == null) failure = error; else failure.addSuppressed(error); + } + } + if (failure instanceof RuntimeException error) throw error; + if (failure instanceof LinkageError error) throw error; + } + + private void retryFailedBusinessCleanup(DeviceKey key, String portId) { + List failed; + synchronized (device(key)) { + PortSource source = port(key, portId); + synchronized (source) { + failed = source.business.values().stream().filter(value -> value.cleanupFailed).toList(); + } + } + for (var subscription : failed) subscription.close(); + } + + public final class BusinessSubscription implements AutoCloseable { + private final DeviceKey key; + private final PortSource source; + private final String usageId; + private final String label; + private String receiveId; + private final Map rules = new LinkedHashMap<>(); + private final Map channels = new LinkedHashMap<>(); + private String subscriptionId; + private boolean unsubscribed; + private boolean closed; + private volatile boolean cleanupFailed; + + private BusinessSubscription(DeviceKey key, PortSource source, String usageId, String label, + List selected) { + this.key = key; this.source = source; this.usageId = usageId; this.label = label; + this.receiveId = source.receiveId; + for (var channel : selected) { + JSONObject definition = JSONUtil.parseObj(channel.persistedJson()).getJSONObject("definition"); + if (definition == null) throw new CanOperationException(13103001, "can.error.invalidDefinition"); + definition.remove("signalId"); + String identity = channel.projectId() + ":" + channel.projectChannelId() + ":" + + JSONUtil.toJsonStr(new TreeMap<>(definition)); + String ruleId = "can-" + digest(identity); + rules.put(ruleId, definition.set("signalId", ruleId)); + channels.put(ruleId, channel); + } + } + + public Map channels() { return Map.copyOf(channels); } + public String receiveId() { return receiveId; } + public String subscriptionId() { return subscriptionId; } + public synchronized JSONObject read() { + if (closed || unsubscribed) throw new IllegalStateException("CAN subscription is closed"); + JSONObject batch = nativeCan.readSignals(receiveId, subscriptionId); + String actual = batch.getStr("state"); + if ("error".equals(actual) || "disconnected".equals(actual)) { + synchronized (source) { source.state = actual; } + } + return batch; + } + public synchronized JSONObject finish() { + if (closed || unsubscribed) throw new IllegalStateException("CAN subscription is closed"); + return nativeCan.finishSignals(receiveId, subscriptionId); + } + public synchronized JSONObject beginRecording() { + if (closed || unsubscribed) throw new IllegalStateException("CAN subscription is closed"); + return nativeCan.resetSignals(receiveId, subscriptionId, new JSONObject().set("schemaVersion", 1) + .set("signalIds", new JSONArray(rules.keySet()))); + } + @Override public synchronized void close() { + if (closed) return; + synchronized (device(key)) { + synchronized (source) { + try { + if (!unsubscribed && subscriptionId != null) { + nativeCan.unsubscribe(receiveId, subscriptionId); + unsubscribed = true; + } + if ("running".equals(source.state)) + nativeCan.updateDefinitions(receiveId, definitions(source, null, usageId)); + source.business.remove(usageId); + if (!source.manual && source.business.isEmpty() && source.receiveId != null) stopSource(source); + closed = true; + cleanupFailed = false; + } catch (RuntimeException | LinkageError failure) { + closed = source.receiveId == null; + cleanupFailed = !closed; + if (cleanupFailed) source.business.put(usageId, this); + else source.business.remove(usageId); + throw failure; + } + } + } + } + } + + private static String digest(String text) { + try { return HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256").digest(text.getBytes(StandardCharsets.UTF_8))); } + catch (NoSuchAlgorithmException impossible) { throw new IllegalStateException(impossible); } + } + + public JSONObject status(Long deviceId, String portId) { + DeviceKey key = existingKey(deviceId, portId); + synchronized (device(key)) { + PortSource source = port(key, portId); + synchronized (source) { + JSONObject diagnostics = nativeCan.status(key.protocol, source.receiveId == null ? key.nativeId : source.nativeId, portId); + source.diagnostics = diagnostics; + JSONObject application = diagnostics.getJSONObject("application"); + if (source.receiveId != null && application != null) { + String actual = application.getStr("state"); + if (actual != null && (source.lastErrorCode == null || "error".equals(actual) || "disconnected".equals(actual))) + source.state = actual; + } + return snapshot(key, source); + } + } + } + + public JSONObject frames(Long deviceId, String portId, String after) { + BigInteger cursor; + try { cursor = new BigInteger(after == null ? "0" : after); } + catch (NumberFormatException error) { throw new CanOperationException(13103001, "can.error.invalidCursor"); } + if (cursor.signum() < 0) throw new CanOperationException(13103001, "can.error.invalidCursor"); + DeviceKey key = existingKey(deviceId, portId); + synchronized (device(key)) { + PortSource source = port(key, portId); + synchronized (source) { + JSONArray result = new JSONArray(); + for (JSONObject frame : source.preview) { + if (new BigInteger(frame.getStr("sequence", "0")).compareTo(cursor) > 0) + result.add(JSONUtil.parseObj(frame.toString())); + } + String last = source.preview.isEmpty() ? null : source.preview.getLast().getStr("sequence"); + return new JSONObject(JSONConfig.create().setIgnoreNullValue(false)).set("frames", result) + .set("lastSequence", last).set("metadata", copy(source.rawMetadata)).set("previewLimit", 1000); + } + } + } + + public JSONObject rawSources() { + JSONArray sources = new JSONArray(); + states.values().forEach(device -> { + DeviceKey key = device.identity; + if (key == null) return; + device.ports.values().forEach(source -> { + synchronized (source) { + sources.add(snapshot(key, source) + .set("sourceId", JSONUtil.toJsonStr(new String[] {key.protocol, key.stableId, source.port})) + .set("deviceId", key.databaseId.toString()).set("deviceName", key.displayName) + .set("protocol", key.protocol).set("metadata", copy(source.rawMetadata))); + } + }); + }); + return new JSONObject().set("sources", sources); + } + + private static JSONObject copy(JSONObject value) { + return value == null ? null : JSONUtil.parseObj(value.toString()); + } + + private JSONObject snapshot(DeviceKey key, PortSource source) { + JSONArray usages = new JSONArray(); + if (source.manual) usages.add(new JSONObject(JSONConfig.create().setIgnoreNullValue(false)).set("id", "manual").set("label", "manual")); + source.business.values().forEach(value -> usages.add(new JSONObject().set("id", value.usageId) + .set("label", value.label).set("stage", value.cleanupFailed ? "cleanup" : "active"))); + return new JSONObject(JSONConfig.create().setIgnoreNullValue(false)).set("portId", source.port) + .set("appliedConfig", source.appliedConfig == null ? configurations.get(key.storageKey(), source.port) : source.appliedConfig) + .set("savedConfig", configurations.get(key.storageKey(), source.port)) + .set("configurationSaved", source.configurationSaved) + .set("configurationRevision", source.revision).set("receiveId", source.receiveId) + .set("manualReceiving", source.manual).set("state", source.state).set("usages", usages) + .set("recording", source.recording == null ? null : source.recording.snapshot()) + .set("recordingErrorCode", source.recordingErrorCode) + .set("diagnostics", source.diagnostics).set("lastErrorCode", source.lastErrorCode); + } + + void readSources() { + if (shuttingDown) return; + states.values().forEach(device -> device.ports.values().forEach(source -> { + synchronized (source) { + if (shuttingDown) return; + if (source.receiveId == null || !"running".equals(source.state) && source.recording == null) return; + try { + for (int batchIndex = 0; batchIndex < 64; batchIndex++) { + JSONObject batch = nativeCan.readFrames(source.receiveId); + appendFrames(source, batch); + JSONArray frames = batch.getJSONArray("frames"); + if (frames == null || frames.size() < 64) break; + } + } + catch (CanOperationException error) { + source.lastErrorCode = error.code(); source.state = "error"; finishRecording(source, false, false); + } + catch (RuntimeException | LinkageError error) { + source.lastErrorCode = 13103001; source.state = "error"; finishRecording(source, false, false); + } + } + })); + } + + private void appendFrames(PortSource source, JSONObject batch) { + appendFrames(source, batch, null); + } + + private void appendFrames(PortSource source, JSONObject batch, RecordingStop cutoff) { + JSONObject metadata = JSONUtil.parseObj(batch.toString()); + metadata.remove("frames"); + source.rawMetadata = metadata; + String actual = batch.getStr("state"); + if ("error".equals(actual) || "disconnected".equals(actual)) source.state = actual; + JSONArray frames = batch.getJSONArray("frames"); + if (frames == null) { + if (cutoff != null) throw new CanOperationException(13103001, "can.error.invalidResponse"); + finishRecording(source, false, false); return; + } + String receivedAt = Long.toString(System.currentTimeMillis()); + List admitted = new ArrayList<>(); + for (Object item : frames) { + JSONObject frame = JSONUtil.parseObj(item); + DeviceKey key = source.identity; + JSONObject origin = new JSONObject(JSONConfig.create().setIgnoreNullValue(false)) + .set("deviceId", key.databaseId.toString()).set("deviceName", key.displayName) + .set("protocol", key.protocol).set("portId", source.port) + .set("receiveId", source.receiveId).set("epoch", batch.get("epoch")); + source.preview.addLast(frame.set("origin", origin).set("receivedAtEpochMs", receivedAt)); + if (source.recording != null && (source.recordingStartSequence == null + || source.recordingSessionEpoch.equals(frame.getStr("sessionEpoch")) + && new BigInteger(frame.getStr("sequence")).compareTo(new BigInteger(source.recordingStartSequence)) > 0) + && (cutoff == null || cutoff.sessionEpoch.equals(frame.getStr("sessionEpoch")) + && decimal(frame.getStr("sequence")).compareTo(cutoff.sequence) <= 0)) + admitted.add(frame); + while (source.preview.size() > 1000) source.preview.removeFirst(); + } + if (source.recording != null) { + source.recordingComplete &= recordingComplete(batch); + JSONObject stopCutoff = source.recordingMetadata.getJSONObject("stopCutoff"); + source.recordingMetadata = copy(metadata); + if (stopCutoff != null) source.recordingMetadata.set("stopCutoff", stopCutoff); + try { source.recording.append(admitted, metadata); } + catch (RuntimeException failure) { + source.recordingErrorCode = CanRawRecordingStore.STORAGE_ERROR; + LOG.warn("CAN raw recording write failed, port={}, record={}", source.port, source.recording.id(), failure); + if (cutoff != null) + throw new CanOperationException(CanRawRecordingStore.STORAGE_ERROR, "can.recording.error.storage", failure); + finishRecording(source, false, false); + } + } + JSONObject stats = metadata.getJSONObject("applicationStats"); + boolean drained = frames.isEmpty() || stats != null && "0".equals(stats.getStr("queuedFrames")); + if (cutoff == null && drained && ("error".equals(source.state) || "disconnected".equals(source.state))) + finishRecording(source, false, false); + } + + @PreDestroy + public void close() { + shuttingDown = true; + reader.shutdown(); + try { if (!reader.awaitTermination(2, TimeUnit.SECONDS)) reader.shutdownNow(); } + catch (InterruptedException error) { reader.shutdownNow(); Thread.currentThread().interrupt(); } + states.values().forEach(device -> device.ports.values().forEach(source -> { + synchronized (source) { + if (source.receiveId != null) { + finishRecording(source, false, false); + source.state = "closing"; + try { nativeCan.stop(source.receiveId); } catch (RuntimeException | LinkageError ignored) { } + try { + nativeCan.close(source.receiveId); + source.receiveId = null; + source.manual = false; + source.state = "closed"; + } catch (RuntimeException | LinkageError error) { + source.state = "error"; + source.lastErrorCode = 13103023; + } + } + } + })); + } +} diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/can/CanStoredUnitConversion.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/can/CanStoredUnitConversion.java new file mode 100644 index 00000000..ce98759f --- /dev/null +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/can/CanStoredUnitConversion.java @@ -0,0 +1,87 @@ +package com.opentest.service.can; + +import cn.hutool.core.bean.BeanUtil; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.opentest.common.enums.ChannelTypeEnum; +import com.opentest.common.model.dto.ChannelDto; +import com.opentest.common.model.dto.FlowExecuteSnapshotDataDto; +import com.opentest.common.model.dto.RenderDataDto; +import com.opentest.common.model.dto.SimpleChannelDto; +import com.opentest.dashboard.api.channel.CanSignalChannel; +import com.opentest.dashboard.api.channel.CanSignalQuantity; +import com.opentest.dashboard.api.channel.CanSignalUnitConversion; +import com.opentest.dashboard.api.channel.CanSignalUnits; +import java.io.IOException; +import java.util.Objects; + +/** Changes stored output units using frozen CAN semantics, never raw decoder scaling. */ +public final class CanStoredUnitConversion { + private static final ObjectMapper JSON = new ObjectMapper(); + + public static CanSignalChannel frozenChannel(FlowExecuteSnapshotDataDto snapshot, String member) { + var section = snapshot == null ? null : snapshot.getCanRecording(); + if (section == null || section.getChannels() == null || !section.getChannels().containsKey(member)) return null; + if (section.getVersion() != 1) throw new IllegalArgumentException("Unsupported frozen CAN unit facts"); + var channel = JSON.convertValue(section.getChannels().get(member), CanSignalChannel.class); + if (!Objects.equals(member, channel.vchId())) throw new IllegalArgumentException("Frozen CAN unit member differs"); + return channel; + } + + public static ChannelDto channel(SimpleChannelDto member, CanSignalChannel frozen) { + var channel = member == null ? new ChannelDto() : BeanUtil.copyProperties(member, ChannelDto.class); + channel.setVchId(frozen.vchId()); channel.setChannelSource(2); + channel.setChannelType(ChannelTypeEnum.UNKNOWN.getValue()); + channel.setCanDefinitionJson(frozen.persistedJson()); + channel.setMathUnit(frozen.units().sourceUnit()); + return channel; + } + + public static boolean supports(ChannelDto channel, String source, String target) { + var units = units(channel); + return units.outputUnits().contains(source) && units.outputUnits().contains(target); + } + + public static double[] convert(ChannelDto channel, double[] input, String source, String target) { + if (input == null) return null; + var units = units(channel); + var result = new double[input.length]; + for (int i = 0; i < input.length; i++) result[i] = CanSignalUnitConversion.convertStored(input[i], units, source, target); + return result; + } + + public static RenderDataDto.CanUnitConversion display(FlowExecuteSnapshotDataDto snapshot, String member, + String source, String target) { + if (source == null || target == null || source.equals(target)) return null; + var frozen = frozenChannel(snapshot, member); + if (frozen == null) return null; + double offset = CanSignalUnitConversion.convertStored(0, frozen.units(), source, target); + double scale = CanSignalUnitConversion.convertStored(1, frozen.units(), source, target) - offset; + return new RenderDataDto.CanUnitConversion(source, target, scale, offset); + } + + private static CanSignalUnits units(ChannelDto channel) { + try { + var root = JSON.readTree(Objects.requireNonNull(channel.getCanDefinitionJson(), "Frozen CAN units")); + var value = root.get("tachoPpr"); + Integer pulses = null; + if (value != null && !value.isNull()) { + if (!value.isIntegralNumber() || !value.canConvertToInt()) + throw new IllegalArgumentException("Frozen CAN PPR must be an integer"); + pulses = value.intValue(); + } + return new CanSignalUnits(CanSignalQuantity.valueOf(text(root, "quantity")), + text(root, "sourceUnit"), text(root, "outputUnit"), pulses); + } catch (IOException failure) { + throw new IllegalArgumentException("Invalid frozen CAN unit definition", failure); + } + } + + private static String text(JsonNode root, String name) { + var value = root.required(name); + if (!value.isTextual()) throw new IllegalArgumentException("Frozen CAN unit field must be text: " + name); + return value.textValue(); + } + + private CanStoredUnitConversion() { } +} diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/can/JniCanNativeGateway.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/can/JniCanNativeGateway.java new file mode 100644 index 00000000..ed2616d3 --- /dev/null +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/can/JniCanNativeGateway.java @@ -0,0 +1,70 @@ +package com.opentest.service.can; + +import cn.hutool.json.JSONObject; +import cn.hutool.json.JSONUtil; +import com.opentest.core.jni.CanJNIBridge; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.stereotype.Component; + +@Component +public class JniCanNativeGateway implements CanNativeGateway { + private static final Logger LOG = LoggerFactory.getLogger(JniCanNativeGateway.class); + private final CanJNIBridge bridge; + + public JniCanNativeGateway(CanJNIBridge bridge) { this.bridge = bridge; } + + public JSONObject capabilities(String protocol, String device) { + return result(bridge.getCanCapabilitiesV1(protocol, device)); + } + public JSONObject enable(String protocol, String device, boolean enabled) { + return result(bridge.setCanEnabledV1(protocol, device, enabled)); + } + public JSONObject configure(String protocol, String device, String port, JSONObject config) { + return result(bridge.configureCanPortV1(protocol, device, port, config.toString())); + } + public JSONObject start(String protocol, String device, String port, JSONObject request) { + return result(bridge.startCanReceptionV1(protocol, device, port, request.toString())); + } + public JSONObject readFrames(String id) { return result(bridge.readCanFramesV1(id, 64, 0)); } + public JSONObject status(String protocol, String device, String port) { + return result(bridge.getCanPortStatusV1(protocol, device, port)); + } + public JSONObject stop(String id) { return result(bridge.stopCanReceptionV1(id)); } + public JSONObject close(String id) { return result(bridge.closeCanReceptionV1(id)); } + public JSONObject validateDefinitions(JSONObject definitions) { + return result(bridge.validateCanSignalDefinitionsV1(definitions.toString())); + } + public JSONObject updateDefinitions(String id, JSONObject definitions) { + return result(bridge.updateCanSignalDefinitionsV1(id, definitions.toString())); + } + public JSONObject subscribe(String id, JSONObject selection) { + return result(bridge.subscribeCanSignalsV1(id, selection.toString())); + } + public JSONObject readSignals(String id, String subscriptionId) { + return result(bridge.readCanSignalSubscriptionV1(id, subscriptionId, 256, 0)); + } + public JSONObject resetSignals(String id, String subscriptionId, JSONObject selection) { + return result(bridge.updateCanSignalSubscriptionV1(id, subscriptionId, selection.toString())); + } + public JSONObject finishSignals(String id, String subscriptionId) { + return result(bridge.finishAndDrainCanSignalSubscriptionV1(id, subscriptionId, 256)); + } + public JSONObject unsubscribe(String id, String subscriptionId) { + return result(bridge.unsubscribeCanSignalsV1(id, subscriptionId)); + } + + private JSONObject result(String response) { + JSONObject envelope = JSONUtil.parseObj(response); + Integer code = envelope.getInt("code"); + if (code == null) throw new CanOperationException(13103019, "can.error.invalidResponse"); + if (code != 0) { + LOG.warn("CAN native operation failed, code={}, nativeStatus={}, detail={}", + code, envelope.get("nativeStatus"), envelope.getStr("message")); + throw new CanOperationException(code, "error.jni.native." + code); + } + JSONObject data = envelope.getJSONObject("data"); + if (data == null) throw new CanOperationException(13103019, "can.error.invalidResponse"); + return data; + } +} diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/component/dashboard/AbstractDashboardExecuteStrategy.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/component/dashboard/AbstractDashboardExecuteStrategy.java index 7b6fc1d2..f0026a7d 100644 --- a/apps/backend/crydaq-service/src/main/java/com/opentest/service/component/dashboard/AbstractDashboardExecuteStrategy.java +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/component/dashboard/AbstractDashboardExecuteStrategy.java @@ -79,6 +79,7 @@ import com.opentest.service.DashboardCustomViewService; import com.opentest.service.DashboardResultService; import com.opentest.service.DeviceService; +import com.opentest.service.can.CanProjectChannelFacts; import com.opentest.service.ExcitationConfigService; import com.opentest.service.FileService; import com.opentest.service.FlowExecuteResultDetailService; @@ -824,6 +825,8 @@ protected final void validateRealChannelBind(DashboardConfigDto dashboardConfigD : dashboardItemConfig.getCollectConfig(); if (collectConfig != null) { channels.addAll(CollUtil.emptyIfNull(collectConfig.getExecutionChannels())); + channels.addAll(CollUtil.emptyIfNull(collectConfig.getChannels()).stream() + .filter(channel -> channel != null && ChannelSourceEnum.isCan(channel.getChannelSource())).toList()); } // 兼容历史 sweep 配置只保留基础播放信息、尚未展开 collect/play channels 的情况。 channels.addAll(CollUtil.emptyIfNull(dashboardConfigDto.getInputChannelInfo())); @@ -835,6 +838,17 @@ protected final void validateRealChannelBind(DashboardConfigDto dashboardConfigD if (channel == null || channel.isMathChannel()) { continue; } + if (ChannelSourceEnum.isCan(channel.getChannelSource())) { + if (!BuiltinDashboardProvider.MONITOR.getProviderId().equals(dashboardConfigDto.getProviderId()) + || channel.getDeviceId() == null || StrUtil.isBlank(channel.getCanDefinitionJson())) + throw new CryBusinessException(ErrorCode.CHANNEL_NOT_BOUND_TO_REAL_CHANNEL, channel.getVchId()); + try { + CanProjectChannelFacts.resolve(channel, deviceService.findById(channel.getDeviceId())); + } catch (IllegalArgumentException failure) { + throw new CryBusinessException(ErrorCode.CHANNEL_NOT_BOUND_TO_REAL_CHANNEL, failure, channel.getVchId()); + } + continue; + } if (channel.getDeviceId() == null || channel.getJniChannelNumber() == null) { throw new CryBusinessException(ErrorCode.CHANNEL_NOT_BOUND_TO_REAL_CHANNEL, channel.getVchId()); } diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/component/dashboard/DashboardHistoricalResultArtifactResolver.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/component/dashboard/DashboardHistoricalResultArtifactResolver.java index b272f4d1..57ad4836 100644 --- a/apps/backend/crydaq-service/src/main/java/com/opentest/service/component/dashboard/DashboardHistoricalResultArtifactResolver.java +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/component/dashboard/DashboardHistoricalResultArtifactResolver.java @@ -27,6 +27,7 @@ import com.opentest.service.FileService; import com.opentest.service.HostReferenceChannelResolver; import com.opentest.service.jni.UnitConversionService; +import com.opentest.service.can.CanStoredUnitConversion; import com.opentest.service.history.HostResultReadFacts; import com.opentest.service.runtime.RenderDataFileAccessScope; import com.opentest.service.unit.artifact.FrozenHistoricalResultArtifactContext; @@ -392,6 +393,8 @@ public void attachProviderThumbnail(RenderDataDto data, DashboardResultDto resul if (selected.size() == 1) data.setResultUnitIdentity(selected.getFirst().resultUnitIdentityY()); } if (member.resultMetadata() != null) data.setMathSampleSemantics(member.resultMetadata().mathSampleSemantics()); + data.setCanUnitConversion(CanStoredUnitConversion.display(saved.snapshot(), + data.getChannelId(), data.getFileUnitY(), data.getUnitY())); SavedProviderArtifacts.attachSavedThumbnail(data, result, indexed, storagePath, definition.fileUnitIdentity()); } diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/BoundMeasurementInputs.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/BoundMeasurementInputs.java index ca3726eb..94229585 100644 --- a/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/BoundMeasurementInputs.java +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/BoundMeasurementInputs.java @@ -2,6 +2,9 @@ import com.opentest.common.model.dto.ChannelDto; import com.opentest.service.virtualchannel.VirtualChannelExecutionChannelResolver; +import com.opentest.common.enums.ChannelSourceEnum; +import com.opentest.dashboard.api.capability.CanChannelFacts; +import com.opentest.dashboard.api.channel.CanSignalChannel; import java.util.List; import java.util.Map; import java.util.Set; @@ -11,6 +14,7 @@ import com.opentest.dashboard.api.channel.ChannelDirection; import java.util.EnumMap; import java.util.Collections; +import java.util.Objects; import com.opentest.dashboard.api.measurement.editing.InputDeclaration; /** Detached operation facts. Business positions remain distinct from unique capture dependencies. */ @@ -18,7 +22,16 @@ public record BoundMeasurementInputs(InputDeclaration declaration, Map selected, List captureDependencies, List outputs, int licensedInputUsage, List availableInputs, Set unboundInputIds, Set unboundOutputIds, - Map> currentUnitFacts) { + Map> currentUnitFacts, + CanChannelFacts canChannels) { + public BoundMeasurementInputs(InputDeclaration declaration, Map channels, + List selected, List captureDependencies, List outputs, + int licensedInputUsage, List availableInputs, Set unboundInputIds, + Set unboundOutputIds, + Map> currentUnitFacts) { + this(declaration, channels, selected, captureDependencies, outputs, licensedInputUsage, availableInputs, + unboundInputIds, unboundOutputIds, currentUnitFacts, CanChannelFacts.empty()); + } public BoundMeasurementInputs(InputDeclaration declaration, Map channels, List selected, List captureDependencies, List outputs, int licensedInputUsage, List availableInputs, Set unboundInputIds, @@ -38,8 +51,16 @@ public BoundMeasurementInputs(InputDeclaration declaration, Map ChannelSourceEnum.isCan(channel.getChannelSource()))) + throw new IllegalArgumentException("CAN cannot be a sampled capture dependency"); + for (var channel : availableInputs) + if (ChannelSourceEnum.isCan(channel.getChannelSource()) && channels.containsKey(channel.getVchId()) + && (channels.get(channel.getVchId()).hardware() == null + || !Integer.valueOf(1).equals(channels.get(channel.getVchId()).hardware().channelIo()))) + throw new IllegalArgumentException("CAN cannot have sampled metadata"); selected = copies(selected); captureDependencies = copies(captureDependencies); outputs = copies(outputs); availableInputs = copies(availableInputs); unboundInputIds = Set.copyOf(unboundInputIds); @@ -53,6 +74,15 @@ public BoundMeasurementInputs(InputDeclaration declaration, Map captureDependencies() { return copies(captureDependencies); } @Override public List outputs() { return copies(outputs); } @Override public List availableInputs() { return copies(availableInputs); } + public List sampledSelected() { + return copies(selected.stream().filter(channel -> !ChannelSourceEnum.isCan(channel.getChannelSource())).toList()); + } + public List selectedCanChannels() { + return selected.stream().filter(channel -> ChannelSourceEnum.isCan(channel.getChannelSource())) + .map(channel -> Objects.requireNonNull(canChannels.channels().get(channel.getVchId()), + "Selected CAN facts are missing")).toList(); + } + public ChannelCatalog catalog() { return DashboardConfigurationChannels.fromBoundCatalog(this); } public BoundMeasurementInputs withSamplingRates(Map rates) { return withSamplingRates(rates, Map.of()); } @@ -69,12 +99,13 @@ public BoundMeasurementInputs withSamplingRates(Map rates, Map< } return new BoundMeasurementInputs(declaration, metadata, withRates(selected, rates, fingerprints), withRates(captureDependencies, rates, fingerprints), outputs, licensedInputUsage, withRates(availableInputs, rates, fingerprints), - unboundInputIds, unboundOutputIds, currentUnitFacts); + unboundInputIds, unboundOutputIds, currentUnitFacts, canChannels); } private static List withRates(List source, Map rates, Map fingerprints) { var result = copies(source); VirtualChannelExecutionChannelResolver.applyComputationFingerprints(result, fingerprints); result.forEach(channel -> { + if (ChannelSourceEnum.isCan(channel.getChannelSource())) return; var rate = rates.get(channel.getVchId()); if (rate != null) { if (rate <= 0) throw new IllegalArgumentException("Confirmed sample rate must be positive"); diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/DashboardConfigurationChannels.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/DashboardConfigurationChannels.java index 7612472a..42603404 100644 --- a/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/DashboardConfigurationChannels.java +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/DashboardConfigurationChannels.java @@ -15,6 +15,8 @@ import com.opentest.dashboard.api.channel.ChannelHardwareMetadata; import com.opentest.dashboard.api.channel.ChannelMetadata; import com.opentest.dashboard.api.channel.SignalType; +import com.opentest.dashboard.api.capability.CanChannelFacts; +import com.opentest.dashboard.api.channel.CanSignalChannel; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; @@ -50,6 +52,7 @@ private static Map load(BoxChannelService service, Long for (String id : input) { if (unbound.contains(id)) continue; var channel = rows.get(id); + if (channel != null && ChannelSourceEnum.isCan(channel.getChannelSource())) continue; if (channel != null) facts.put(id, metadata(channel)); else if (providerId != null) throw new IllegalArgumentException("Channel metadata missing: " + id); @@ -93,6 +96,7 @@ static ChannelCatalog loadCatalog(BoxChannelService service, Long projectId, Jso references(configuration, input, output); var inputs = new LinkedHashMap(); var outputs = new LinkedHashMap(); + var canInputs = new LinkedHashMap(); if (!input.isEmpty()) { var unbound = unboundChannels(service, projectId, input, ChannelIOEnum.INPUT); var rows = service.getChannelMapByVchIdsV2(projectId, input, ChannelIOEnum.INPUT, true); @@ -103,8 +107,12 @@ static ChannelCatalog loadCatalog(BoxChannelService service, Long projectId, Jso return fromBoundCatalog(bound); } for (String id : input) { - if (unbound.contains(id)) continue; var channel = rows.get(id); + if (channel != null && ChannelSourceEnum.isCan(channel.getChannelSource())) { + canInputs.put(id, Objects.requireNonNull(bindings, "CAN project resolver is required").canChannel(channel)); + continue; + } + if (unbound.contains(id)) continue; if (channel != null) inputs.put(id, metadata(channel)); else throw new IllegalArgumentException("Channel metadata missing: " + id); @@ -115,7 +123,7 @@ static ChannelCatalog loadCatalog(BoxChannelService service, Long projectId, Jso .forEach((id, channel) -> { if (output.contains(id) && !unboundOutputs.contains(id)) outputs.put(id, metadata(channel)); }); return new ChannelCatalog(Map.of(ChannelDirection.INPUT, inputs, ChannelDirection.OUTPUT, outputs), Map.of(ChannelDirection.INPUT, unboundChannels(service, projectId, input, ChannelIOEnum.INPUT), - ChannelDirection.OUTPUT, unboundOutputs)); + ChannelDirection.OUTPUT, unboundOutputs), Map.of(), new CanChannelFacts(canInputs)); } /** The input map retains bound roles and synthetic metadata; outputs never share its ID namespace. */ @@ -128,6 +136,7 @@ static ChannelCatalog fromBoundCatalog(BoundMeasurementInputs bound) { inputChannels.addAll(bound.captureDependencies()); inputChannels.addAll(bound.selected()); for (var channel : inputChannels) { + if (ChannelSourceEnum.isCan(channel.getChannelSource())) continue; if (bound.unboundInputIds().contains(channel.getVchId())) continue; var fact = bound.channels().get(channel.getVchId()); if (fact != null && fact.hardware() != null && Integer.valueOf(1).equals(fact.hardware().channelIo())) fact = null; @@ -146,7 +155,7 @@ static ChannelCatalog fromBoundCatalog(BoundMeasurementInputs bound) { } return new ChannelCatalog(Map.of(ChannelDirection.INPUT, inputs, ChannelDirection.OUTPUT, outputs), Map.of(ChannelDirection.INPUT, bound.unboundInputIds(), ChannelDirection.OUTPUT, bound.unboundOutputIds()), - bound.currentUnitFacts()); + bound.currentUnitFacts(), bound.canChannels()); } static Set unboundChannels(BoxChannelService service, Long projectId, Set ids, ChannelIOEnum direction) { @@ -183,6 +192,8 @@ static SignalType signalType(ChannelDto channel) { return type; } static ChannelMetadata metadata(ChannelDto channel) { + if (ChannelSourceEnum.isCan(channel.getChannelSource())) + throw new IllegalArgumentException("CAN cannot have sampled channel metadata"); SignalType type = signalType(channel); if (channel.getSamplingRate() == null) throw new IllegalArgumentException("Channel metadata is incomplete: " + channel.getVchId()); return new ChannelMetadata(channel.getVchId(), type, channel.getSamplingRate(), diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/MeasurementInputBindings.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/MeasurementInputBindings.java index 2ba463b8..3d2ad959 100644 --- a/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/MeasurementInputBindings.java +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/MeasurementInputBindings.java @@ -1,6 +1,10 @@ package com.opentest.service.dashboard.framework; import com.opentest.common.enums.ChannelIOEnum; +import com.opentest.common.enums.ChannelSourceEnum; +import com.opentest.dashboard.api.capability.CanChannelFacts; +import com.opentest.dashboard.api.channel.CanSignalChannel; +import com.opentest.service.can.CanProjectChannelFacts; import com.opentest.common.exception.CryBusinessException; import com.opentest.common.exception.ErrorCode; import com.opentest.common.enums.ChannelTypeEnum; @@ -99,12 +103,17 @@ private static ObjectMapper factMapper() { @Resource private ProjectTriggerFacts triggerFacts; @Resource private VirtualChannelExecutionChannelResolver executionPlans; @Resource @Lazy private PhysicalResultUnitOptionService physicalUnitOptions; + @Resource private CanProjectChannelFacts canProjectChannels; public MeasurementInputBindings(PluginDashboardConfigurationResolver providers, @Lazy BoxChannelService channels, @Lazy AudioJNIBridgeService audio) { this.providers = providers; this.channels = channels; this.audio = audio; } + CanSignalChannel canChannel(ChannelDto row) { + return Objects.requireNonNull(canProjectChannels, "CAN project resolver is required").resolve(row); + } + public Optional openCurrent(DashboardConfig owner, Map configuration, String scopeId, boolean allScopes, List selected) { return openCurrent(owner, configuration, scopeId, allScopes, selected, null); @@ -128,7 +137,9 @@ Binding openConfiguration(MeasurementInputInterpreter interpreter, Long projectI Binding openConfiguration(MeasurementInputInterpreter interpreter, Long projectId, String providerId, Map configuration, boolean inspectPairs) { - return openCurrent(interpreter, projectId, null, configuration, null, true, List.of(), inspectPairs, Use.CONFIGURATION); + var binding = openCurrent(interpreter, projectId, null, configuration, null, true, List.of(), inspectPairs, Use.CONFIGURATION); + binding.monitorExecution = BuiltinDashboardProvider.MONITOR.getProviderId().equals(providerId); + return binding; } public Optional openCurrent(DashboardConfig owner, Map configuration, @@ -206,6 +217,8 @@ private Binding openCurrent(MeasurementInputInterpreter interpreter, Long projec // Explicit metadata inspection boundary: pairedInputs callbacks below use only these frozen rows. var pairs = new LinkedHashMap>(); for (var output : inspectPairs ? outputs.values() : List.of()) { + if (ChannelSourceEnum.isCan(output.getChannelSource())) + throw new IllegalArgumentException("CAN cannot be an output source"); if (unboundOutputs.contains(output.getVchId())) continue; var found = Objects.requireNonNullElse(Objects.requireNonNull(audio, "Host pairing metadata loader is required") .getSonoDAQPairedImpedanceChannel(List.of(copy(output))), List.of()); @@ -259,6 +272,7 @@ private Binding openCurrent(MeasurementInputInterpreter interpreter, Long projec ? declaration.positions().size() : configuredPositions(configuration).size()); var binding = new Binding(interpreter, configuration, scopeId, allScopes, inputs, outputs, pairs, syntheticFacts, visibleIds, selectedIds, licensed, physicalUnitOptions); + binding.canProjectChannels = canProjectChannels; var unboundInputs = new LinkedHashSet<>(channels.findUnboundPhysicalChannelVchIds(projectId, inputs.keySet(), ChannelIOEnum.INPUT)); unboundInputs.addAll(missingInputs); @@ -343,6 +357,7 @@ public static final class Binding implements ExecutionChannelFacts { private Map mathInputs; private Set mathUnboundInputIds = Set.of(); private VirtualChannelExecutionChannelResolver executionPlans; + private CanProjectChannelFacts canProjectChannels; private boolean consumed; private Binding(MeasurementInputInterpreter interpreter, Map configuration, String scope, boolean allScopes, Map inputs, Map outputs, Map> pairs, @@ -431,6 +446,10 @@ public BoundMeasurementInputs bind(Map effectiveConfiguration) { for (var selection : interpreter.bind(configuration, this)) { var channel = copy(bound(selection.factKey())); if (!Objects.equals(channel.getChannelIo(), 0)) throw new IllegalArgumentException("Input selection refers to an output"); + if (ChannelSourceEnum.isCan(channel.getChannelSource()) + && (selection.signalType() != null || selection.calculationRole() != null + || selection.referenceOutputFactKey() != null || selection.referenceOutputSourceFactKey() != null)) + throw new IllegalArgumentException("CAN cannot receive sampled input projections"); if (selection.signalType() != null) { ChannelTypeEnum.fromState(selection.signalType()); channel.setChannelType(selection.signalType()); } @@ -451,19 +470,38 @@ public BoundMeasurementInputs bind(Map effectiveConfiguration) { } // Monitor keeps empty slots in saved configuration, but each execution freezes only // physically bound selections. Explicit trigger/additional dependencies remain mandatory. + var canFacts = new LinkedHashMap(); + var available = mathInputs == null || configurationOnly ? inputs : mathInputs; + for (var channel : available.values()) { + if (!ChannelSourceEnum.isCan(channel.getChannelSource())) continue; + if (!monitorExecution && selected.stream().anyMatch(value -> value.getVchId().equals(channel.getVchId()))) + throw new IllegalArgumentException("CAN inputs are supported only by Monitor"); + canFacts.put(channel.getVchId(), Objects.requireNonNull(canProjectChannels, "CAN project resolver is required") + .resolve(channel)); + } + interpreter.declaration().triggerInputs().forEach(trigger -> { + if (canFacts.containsKey(trigger.channelId())) + throw new IllegalArgumentException("CAN cannot be a signal trigger"); + }); + interpreter.declaration().additionalInputIds().forEach(id -> { + if (canFacts.containsKey(id)) throw new IllegalArgumentException("CAN cannot be a sampled dependency"); + }); var capture = new LinkedHashMap(); if (monitorExecution && !configurationOnly) { if (mathInputs != null) { var plan = Objects.requireNonNull(executionPlans, "Math execution planner is required") - .buildBoundInputs(selected, mathInputs.values(), unboundInputIds); + .buildBoundInputs(selected.stream().filter(channel -> !ChannelSourceEnum.isCan(channel.getChannelSource())).toList(), + mathInputs.values().stream().filter(channel -> !ChannelSourceEnum.isCan(channel.getChannelSource())).toList(), unboundInputIds); plan.getExecutionChannels().forEach(channel -> capture.put(channel.getVchId(), channel)); - selected.removeIf(channel -> !capture.containsKey(channel.getVchId())); - selected.forEach(channel -> channel.setSamplingRate(capture.get(channel.getVchId()).getSamplingRate())); - } else selected.removeIf(channel -> unboundInputIds.contains(channel.getVchId())); + selected.removeIf(channel -> !ChannelSourceEnum.isCan(channel.getChannelSource()) && !capture.containsKey(channel.getVchId())); + selected.stream().filter(channel -> !ChannelSourceEnum.isCan(channel.getChannelSource())) + .forEach(channel -> channel.setSamplingRate(capture.get(channel.getVchId()).getSamplingRate())); + } else selected.removeIf(channel -> !ChannelSourceEnum.isCan(channel.getChannelSource()) && unboundInputIds.contains(channel.getVchId())); } var resolvedMath = mathInputs != null && !monitorExecution ? prepareCurrentFingerprints(selected, configurationOnly) : List.of(); - selected.forEach(channel -> capture.putIfAbsent(channel.getVchId(), channel)); + selected.stream().filter(channel -> !ChannelSourceEnum.isCan(channel.getChannelSource())) + .forEach(channel -> capture.putIfAbsent(channel.getVchId(), channel)); interpreter.declaration().additionalInputIds().forEach(id -> capture.putIfAbsent(id, inputs.get(id))); interpreter.declaration().triggerInputs().forEach(trigger -> capture.putIfAbsent(trigger.channelId(), inputs.get(trigger.channelId()))); if (!configurationOnly) { @@ -475,16 +513,17 @@ public BoundMeasurementInputs bind(Map effectiveConfiguration) { if (!unavailable.isEmpty()) throw new IllegalArgumentException( "Required channels are not physically bound: " + String.join(", ", unavailable)); } - if (monitorExecution && !configurationOnly && capture.values().stream().noneMatch(channel -> !channel.isMathChannel())) + if (monitorExecution && !configurationOnly && selected.stream().noneMatch(channel -> ChannelSourceEnum.isCan(channel.getChannelSource())) + && capture.values().stream().noneMatch(channel -> !channel.isMathChannel())) throw new CryBusinessException(ErrorCode.MONITOR_NO_CAPTURABLE_INPUTS); var metadata = new LinkedHashMap(); - var available = mathInputs == null || configurationOnly ? inputs : mathInputs; if (!monitorExecution && !configurationOnly && mathInputs != null) { available = new LinkedHashMap<>(inputs); for (var dependency : resolvedMath) available.putIfAbsent(dependency.getVchId(), dependency); } var metadataInputs = monitorExecution && !configurationOnly ? capture : inputs; metadataInputs.forEach((id, channel) -> { + if (ChannelSourceEnum.isCan(channel.getChannelSource())) return; if (!unboundInputIds.contains(id) && (!configurationOnly || hasExecutionRate(channel))) metadata.put(id, metadata(channel)); }); @@ -493,6 +532,7 @@ public BoundMeasurementInputs bind(Map effectiveConfiguration) { metadata.putIfAbsent(id, DashboardConfigurationChannels.metadata(channel)); }); selected.forEach(channel -> { + if (ChannelSourceEnum.isCan(channel.getChannelSource())) return; if (!unboundInputIds.contains(channel.getVchId()) && (!configurationOnly || hasExecutionRate(channel))) metadata.put(channel.getVchId(), metadata(channel)); }); @@ -505,7 +545,8 @@ public BoundMeasurementInputs bind(Map effectiveConfiguration) { } int inputUsage = monitorExecution && !configurationOnly ? selected.size() : licensed; return new BoundMeasurementInputs(interpreter.declaration(), metadata, selected, List.copyOf(capture.values()), - List.copyOf(outputs.values()), inputUsage, List.copyOf(available.values()), unboundInputIds, unboundOutputIds, currentUnits); + List.copyOf(outputs.values()), inputUsage, List.copyOf(available.values()), unboundInputIds, unboundOutputIds, + currentUnits, new CanChannelFacts(canFacts)); } private List prepareCurrentFingerprints(List selected, boolean allowDrafts) { var dependencies = new LinkedHashMap(); @@ -539,6 +580,7 @@ private Map currentUnitFacts( Collection channels, Set unbound) { var facts = new LinkedHashMap(); for (var channel : channels) { + if (ChannelSourceEnum.isCan(channel.getChannelSource())) continue; if (unbound.contains(channel.getVchId())) continue; var computed = channel.isMathChannel(); var candidates = computed && physicalUnitOptions != null @@ -561,6 +603,8 @@ private Fact fact(ChannelDto channel) { public ChannelMetadata channelMetadata(String key) { return metadata(bound(key)); } private ChannelDto bound(String key) { return Objects.requireNonNull(bound.get(key), "Foreign or stale input fact key"); } private ChannelMetadata metadata(ChannelDto channel) { + if (ChannelSourceEnum.isCan(channel.getChannelSource())) + throw new IllegalArgumentException("CAN has no sampled metadata"); var synthetic = syntheticFacts.get(channel.getVchId()); if (synthetic == null) return DashboardConfigurationChannels.metadata(channel); var type = com.opentest.dashboard.api.channel.SignalType.valueOf(ChannelTypeEnum.fromState(channel.getChannelType()).name()); @@ -576,6 +620,10 @@ private static String requiredId(String id) { if (id == null || id.isBlank()) throw new IllegalArgumentException("Input identity must be nonblank"); return id; } private static void validateScope(ChannelDto channel, Long projectId, Long tenantId) { + if (ChannelSourceEnum.isCan(channel.getChannelSource()) + && (!Objects.equals(channel.getProjectId(), projectId) + || tenantId != null && !Objects.equals(channel.getTenantId(), tenantId))) + throw new IllegalArgumentException("CAN channel is outside the owning project or tenant"); if (channel.getProjectId() != null && !Objects.equals(channel.getProjectId(), projectId) || tenantId != null && channel.getTenantId() != null && !Objects.equals(channel.getTenantId(), tenantId)) throw new IllegalArgumentException("Channel is outside the owning project or tenant"); diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/MeasurementResultMemberFacts.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/MeasurementResultMemberFacts.java index 9b6759a1..905d4eba 100644 --- a/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/MeasurementResultMemberFacts.java +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/MeasurementResultMemberFacts.java @@ -3,6 +3,9 @@ import com.opentest.common.model.dto.ChannelDto; import com.opentest.common.model.dto.SimpleChannelDto; import com.opentest.common.enums.ChannelTypeEnum; +import com.opentest.common.enums.ChannelSourceEnum; +import com.opentest.dashboard.api.channel.CanSignalChannel; +import com.opentest.service.can.CanProjectChannelFacts; import cn.hutool.core.bean.BeanUtil; import com.opentest.dashboard.api.channel.ChannelDirection; import com.opentest.dashboard.api.channel.ChannelHardwareMetadata; @@ -24,12 +27,35 @@ public record Key(long dashboardResultId, String memberId) { } } - public record Fact(ResultChannelDefinition member, ChannelMetadata metadata, + public sealed interface Source permits SampledSource, CanSource { } + public record SampledSource(ChannelMetadata metadata) implements Source { + public SampledSource { Objects.requireNonNull(metadata); } + } + public record CanSource(CanSignalChannel channel) implements Source { + public CanSource { Objects.requireNonNull(channel); } + } + public record Fact(ResultChannelDefinition member, Source source, GraphicUnitResolution declaredUnits) { + public Fact(ResultChannelDefinition member, ChannelMetadata metadata, GraphicUnitResolution declaredUnits) { + this(member, new SampledSource(metadata), declaredUnits); + } public Fact { - Objects.requireNonNull(member); Objects.requireNonNull(metadata); Objects.requireNonNull(declaredUnits); - if (!member.vchId().equals(metadata.vchId())) + Objects.requireNonNull(member); Objects.requireNonNull(source); Objects.requireNonNull(declaredUnits); + String id = source instanceof SampledSource sampled ? sampled.metadata().vchId() : ((CanSource) source).channel().vchId(); + if (!member.vchId().equals(id)) throw new IllegalArgumentException("Result metadata belongs to another member"); + if (source instanceof CanSource can) { + if (member.channelDirection() != ChannelDirection.INPUT || member.resultMetadata() != null + || member.unitFacts() != null && (member.unitFacts().signalType() != SignalType.UNKNOWN + || !Objects.equals(member.unitFacts().sourceUnit(), can.channel().units().sourceUnit()))) + throw new IllegalArgumentException("CAN result declaration disagrees with its frozen source"); + if (declaredUnits.combinations().stream().anyMatch(unit -> !can.channel().units().outputUnits().contains(unit.unitY()))) + throw new IllegalArgumentException("CAN result units are outside the frozen source unit menu"); + } + } + public ChannelMetadata metadata() { + if (source instanceof SampledSource sampled) return sampled.metadata(); + throw new IllegalArgumentException("CAN has no sampled metadata or sampled replay artifact"); } } @@ -41,16 +67,34 @@ public static Fact resolve(long dashboardResultId, ResultChannelDefinition membe BoundMeasurementInputs inputs, GraphicUnitResolution savedUnits) { new Key(dashboardResultId, Objects.requireNonNull(member).vchId()); Objects.requireNonNull(inputs); - ChannelMetadata metadata = member.resultMetadata(); - if (metadata == null) metadata = source(member, inputs).metadata(); + Source frozen; + if (isCanMember(member, inputs)) { + if (member.resultMetadata() != null) + throw new IllegalArgumentException("Result metadata cannot turn a CAN source into sampled input"); + frozen = source(member, inputs).source(); + } else frozen = member.resultMetadata() == null ? source(member, inputs).source() : new SampledSource(member.resultMetadata()); var units = member.declaredUnits() == null ? savedUnits : member.declaredUnits(); if (units == null) throw new IllegalArgumentException("Complete result member units are missing: " + member.vchId()); - return new Fact(member, metadata, units); + return new Fact(member, frozen, units); } /** A result-owned member never inherits a device identity from an equally named physical input. */ public static SimpleChannelDto display(ResultChannelDefinition member, BoundMeasurementInputs inputs) { Objects.requireNonNull(member); + if (isCanMember(member, inputs)) { + if (member.resultMetadata() != null) throw new IllegalArgumentException("CAN cannot have result-owned sampled metadata"); + var frozen = source(member, inputs); + var can = ((CanSource) frozen.source()).channel(); + var result = BeanUtil.copyProperties(frozen.row(), SimpleChannelDto.class); + result.setChannelName(can.displayName()); result.setCustomName(can.displayName()); + result.setChannelUnitY(can.units().outputUnit()); + var units = member.declaredUnits(); + if (units != null) { + if (units.preferredCombination() != null) result.setChannelUnitY(units.preferredCombination().unitY()); + result.setUnitSwitchSupported(units.combinations().size() > 1); + } + return result; + } var metadata = member.resultMetadata(); if (metadata == null) { var source = source(member, inputs).row(); @@ -82,7 +126,16 @@ public static SimpleChannelDto display(ResultChannelDefinition member, BoundMeas return result; } - private record FrozenSource(ChannelDto row, ChannelMetadata metadata) { } + private static boolean isCanMember(ResultChannelDefinition member, BoundMeasurementInputs inputs) { + if (member.channelDirection() == ChannelDirection.OUTPUT + && inputs.outputs().stream().anyMatch(row -> member.vchId().equals(row.getVchId()) + && !ChannelSourceEnum.isCan(row.getChannelSource()))) return false; + return inputs.canChannels().channels().containsKey(member.vchId()) + || inputs.availableInputs().stream().anyMatch(row -> row.getVchId().equals(member.vchId()) + && ChannelSourceEnum.isCan(row.getChannelSource())); + } + + private record FrozenSource(ChannelDto row, Source source) { } private static FrozenSource source(ResultChannelDefinition member, BoundMeasurementInputs inputs) { Objects.requireNonNull(inputs); @@ -90,17 +143,34 @@ private static FrozenSource source(ResultChannelDefinition member, BoundMeasurem long matches = catalogue.stream().filter(channel -> member.vchId().equals(channel.getVchId())).count(); if (matches != 1) throw new IllegalArgumentException("Result member is missing or ambiguous in its declared channel direction: " + member.vchId()); + var actual = catalogue.stream().filter(channel -> member.vchId().equals(channel.getVchId())).findFirst().orElseThrow(); + if (ChannelSourceEnum.isCan(actual.getChannelSource())) { + if (member.channelDirection() != ChannelDirection.INPUT) + throw new IllegalArgumentException("CAN results require explicit input direction"); + var can = inputs.canChannels().channels().get(member.vchId()); + if (can == null) throw new IllegalArgumentException("Frozen CAN source facts are missing"); + CanProjectChannelFacts.requireMatches(actual, can); + var selected = inputs.selected().stream().filter(row -> row.getVchId().equals(member.vchId())).toList(); + if (selected.isEmpty()) throw new IllegalArgumentException("CAN result member was not selected"); + for (var row : selected) { + if (!Objects.equals(actual.getTenantId(), row.getTenantId())) + throw new IllegalArgumentException("CAN result member tenant disagrees with its project row"); + CanProjectChannelFacts.requireMatches(row, can); + } + return new FrozenSource(actual, new CanSource(can)); + } + if (inputs.canChannels().channels().containsKey(member.vchId())) + throw new IllegalArgumentException("Frozen CAN member is not a CAN project row"); var metadata = DashboardConfigurationChannels.fromBoundCatalog(inputs).get( member.channelDirection() == ChannelDirection.OUTPUT ? ChannelDirection.OUTPUT : ChannelDirection.INPUT, member.vchId()); if (metadata == null) throw new IllegalArgumentException("Frozen result channel metadata is missing: " + member.vchId()); - var actual = catalogue.stream().filter(channel -> member.vchId().equals(channel.getVchId())).findFirst().orElseThrow(); if (member.channelDirection() != ChannelDirection.OUTPUT) // Binding applies position projections in order, so the last position is the effective input fact. actual = inputs.selected().stream().filter(channel -> member.vchId().equals(channel.getVchId())) .reduce((previous, selected) -> selected).orElse(actual); requireConsistent(actual, metadata, member.channelDirection() == ChannelDirection.OUTPUT ? 1 : 0); - return new FrozenSource(actual, metadata); + return new FrozenSource(actual, new SampledSource(metadata)); } private static void requireConsistent(ChannelDto actual, diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/ProviderDashboardResultReader.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/ProviderDashboardResultReader.java index 6223af76..52035d9e 100644 --- a/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/ProviderDashboardResultReader.java +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/ProviderDashboardResultReader.java @@ -5,6 +5,7 @@ import com.opentest.dashboard.api.result.ResultFileUnitIdentity; import com.opentest.common.enums.ChannelTypeEnum; +import com.opentest.common.enums.ChannelSourceEnum; import com.opentest.dashboard.api.definition.DomainType; import com.opentest.dashboard.api.channel.ChannelCatalog; import com.opentest.dashboard.api.channel.ChannelDirection; @@ -547,7 +548,8 @@ Map savedChannelMetadata(String providerId, Map(); - for (var channel : selected) if (channel != null && channel.getVchId() != null) + for (var channel : selected) if (channel != null && channel.getVchId() != null + && !ChannelSourceEnum.isCan(channel.getChannelSource())) channels.putIfAbsent(channel.getVchId(), MeasureProviderInputs.channel(channel)); return Collections.unmodifiableMap(channels); diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/ProviderExecutionErrors.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/ProviderExecutionErrors.java index d3f958e0..8e877150 100644 --- a/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/ProviderExecutionErrors.java +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/ProviderExecutionErrors.java @@ -10,7 +10,10 @@ import java.util.Collections; import java.util.IdentityHashMap; import com.opentest.common.utils.ErrorUtil; +import com.opentest.common.utils.LocaleUtil; +import com.opentest.service.can.CanOperationException; import java.util.List; +import java.util.Locale; import java.math.BigDecimal; import java.util.Map; import com.opentest.dashboard.api.execution.ExecutionValidationError; @@ -96,18 +99,46 @@ public static Exception stopFinalizationFailure(Throwable failure) { public static Exception executionFailure(Throwable failure) { var nativeFailure = JniBusinessException.find(failure); if (nativeFailure != null) return nativeFailure; + CryBusinessException genericFailure = null; var visited = Collections.newSetFromMap(new IdentityHashMap()); for (Throwable current = failure; current != null && visited.add(current); current = current.getCause()) { + if (current instanceof CanOperationException can) return new CanBusinessFailure(can); if (current instanceof DashboardExecutionException declared) { + if (genericFailure != null) return genericFailure; var mapped = businessError(declared.error()); for (var suppressed : declared.getSuppressed()) mapped.addSuppressed(suppressed); if (declared.getCause() != null) mapped.addSuppressed(declared.getCause()); return mapped; } if (current instanceof AlgorithmException nativeStatus) - return new JniBusinessException(nativeStatus.nativeCode()); - if (current instanceof CryBusinessException business) return business; + return genericFailure != null ? genericFailure : new JniBusinessException(nativeStatus.nativeCode()); + if (current instanceof CryBusinessException business) { + if (business.businessIdentity() != ErrorCode.FAILED) + return genericFailure == null || business instanceof CanBusinessFailure ? business : genericFailure; + if (genericFailure == null) genericFailure = business; + } } + if (genericFailure != null) return genericFailure; return failure instanceof Exception exception ? exception : new IllegalStateException("Provider failed", failure); } + + private static final class CanBusinessFailure extends CryBusinessException { + private final String messageKey; + + private CanBusinessFailure(CanOperationException failure) { + super(failure.code(), message(failure.messageKey(), LocaleUtil.getLocale())); + messageKey = failure.messageKey(); + initCause(failure); + } + + @Override public String getMsgKey() { return messageKey; } + @Override public String resolveMessage(Locale locale) { return message(messageKey, locale); } + + private static String message(String key, Locale locale) { + String fallback = LocalizedMessage.of(ErrorCode.JNI_UNKNOWN_ERROR.getMsgKey(), + ErrorCode.JNI_UNKNOWN_ERROR.getErrmsg()).resolve(locale); + String resolved = LocalizedMessage.of(key, fallback).resolve(locale); + return resolved.isBlank() ? fallback : resolved; + } + } } diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/ProviderExecutionPreparation.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/ProviderExecutionPreparation.java index 0b4f8514..9b1fd276 100644 --- a/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/ProviderExecutionPreparation.java +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/ProviderExecutionPreparation.java @@ -17,6 +17,7 @@ import com.opentest.service.recording.ProviderExecutionValidation; import com.opentest.common.exception.CryBusinessException; import com.opentest.common.exception.ErrorCode; +import com.opentest.common.enums.ChannelSourceEnum; import com.opentest.common.model.dto.ChannelDto; import com.opentest.common.enums.BuiltinDashboardProvider; import com.opentest.common.model.dto.DashboardConfigDto; @@ -314,7 +315,8 @@ public void prepare(DashboardConfigDto dashboard, Consumer !ChannelSourceEnum.isCan(channel.getChannelSource())).toList()) : new VirtualChannelExecutionPlan(capture, List.of()); collect.setVirtualChannelExecutionPlan(plan); collect.setExecutionChannels(plan.getExecutionChannels()); diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/ProviderGraphicUnitService.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/ProviderGraphicUnitService.java index 41495cf4..6e896765 100644 --- a/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/ProviderGraphicUnitService.java +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/ProviderGraphicUnitService.java @@ -338,8 +338,9 @@ public List memberOptions(Long resultId, Integer signalType, boolean com var member = context == null ? null : MeasurementResultFacts.requireMember(definition, id); var channel = member != null ? member.resultMetadata() != null ? member.resultMetadata() : member.channelDirection() == null ? null : context.channels().get(member.channelDirection(), id) - : savedContext == null ? facts.get(id) : savedContext.memberMetadata(result, definition, id); - var currentUnits = currentMemberUnitFacts(context, member); + : savedContext == null ? facts.get(id) : null; + var currentUnits = savedContext == null ? currentMemberUnitFacts(context, member) + : savedContext.memberFacts(result, definition, id); if (channel != null) { if (channel.computed() != computed || signalType != null && ChannelTypeEnum.valueOf(channel.signalType().name()).getValue() != signalType) continue; } else if (currentUnits != null) { @@ -399,15 +400,34 @@ private SavedUnitMetadataContext(DashboardConfigDto dashboard) { this.dashboard = dashboard; } - private ChannelMetadata memberMetadata(DashboardResult result, ResultSetDefinition definition, String id) { + private ChannelCatalog catalog() { + if (catalog == null) catalog = resultReader().savedChannelFacts(dashboard); + return catalog; + } + + private ChannelMetadata channelMetadata(ResultChannelDefinition member) { + return member.resultMetadata() != null ? member.resultMetadata() + : member.channelDirection() == null ? null : catalog().get(member.channelDirection(), member.vchId()); + } + + private UnitChannelFacts memberFacts(DashboardResult result, ResultSetDefinition definition, String id) { if (definition == null) throw new IllegalArgumentException("Saved result definition is missing for " + result.getId() + "/" + id); var member = MeasurementResultFacts.requireMember(definition, id); - if (member.resultMetadata() != null) return member.resultMetadata(); - if (member.channelDirection() != null) { - if (catalog == null) catalog = resultReader().savedChannelFacts(dashboard); - var metadata = catalog.get(member.channelDirection(), id); - if (metadata != null) return metadata; + var metadata = channelMetadata(member); + if (metadata != null) + return new UnitChannelFacts(id, metadata.signalType(), metadata.computed(), metadata.waveformUnit(), + metadata.charge(), List.of()); + if (member.channelDirection() == ChannelDirection.INPUT) { + var can = catalog().canInputs().channels().get(id); + if (can != null) + return new UnitChannelFacts(id, member.unitFacts() == null ? SignalType.UNKNOWN + : member.unitFacts().signalType(), false, can.units().sourceUnit(), null, List.of()); + } + if (member.channelDirection() == null && member.unitFacts() != null) { + var units = member.unitFacts(); + return new UnitChannelFacts(id, units.signalType(), Boolean.TRUE.equals(units.computed()), + units.sourceUnit(), null, List.of()); } throw new IllegalArgumentException("Saved member metadata is missing for " + result.getId() + "/" + id); } @@ -487,7 +507,7 @@ && unboundResultChannels(result, new LinkedHashSet<>(ids)).containsAll(ids)) { group.setResultUnitIdentity(resolution.preferredCombination() == null ? null : resolution.preferredCombination().resultUnitIdentityY()); boolean computed = false; if (result.getRequestId() != null) { - var saved = savedContext.memberMetadata(result, definition, id); + var saved = savedContext.memberFacts(result, definition, id); computed = saved.computed(); group.setChannelType(ChannelTypeEnum.valueOf(saved.signalType().name()).getValue()); } else if (selection.currentContext(result) != null) { @@ -711,15 +731,8 @@ private TableUnitFacts currentTableResult(DashboardResult row, /** Historical units are described from the saved configuration, channels and result row. */ private GraphicUnitResolution resolveSavedTableMeasurement(DashboardResult result, String owner, String id, Map graphic) { - var execution = executions.selectById(result.getRequestId()); - if (execution == null || !Objects.equals(execution.getProjectId(), result.getProjectId()) - || !Objects.equals(execution.getTenantId(), result.getTenantId())) - throw new IllegalArgumentException("Saved unit result belongs to another execution scope"); - var snapshot = FlowExecuteSnapshotDataDto.parseJson(execution.getSnapshotData()); - new ResultPluginAccess(providers).requireSnapshot(snapshot); - var savedDashboard = snapshot == null ? null : snapshot.getDashboardConfig(); - if (savedDashboard == null || !owner.equals(savedDashboard.getProviderId())) - throw new IllegalArgumentException("Saved unit result belongs to another Provider"); + var context = openUnitSelectionQuery().savedMetadataContext(result, owner); + var savedDashboard = context.dashboard; if (result.getSourceId() == null) throw new IllegalArgumentException("Saved table result has no current source id"); var reader = resultReader(); @@ -730,14 +743,12 @@ private GraphicUnitResolution resolveSavedTableMeasurement(DashboardResult resul throw new IllegalArgumentException("Complete saved measurement unit declaration is missing"); var configuration = MeasureProviderInputs .jsonMap(savedDashboard.getDashboardItemConfig()); - var channel = member.resultMetadata() != null ? member.resultMetadata() - : member.channelDirection() == null ? null : reader.savedChannelFacts(savedDashboard).get(member.channelDirection(), id); - if (channel == null && member.channelDirection() != null) - throw new IllegalArgumentException("Saved channel facts are missing for " + id); + context.memberFacts(result, facts, id); + var channel = context.channelMetadata(member); var identity = new TableResultIdentity.Manual(result.getSourceId()); var resolved = providers.resolveGraphicUnits(owner, configuration, identity, channel, GraphicUnitScene.HISTORY_VIEW, graphic, member.declaredUnits(), facts, () -> java.util.Optional.empty(), - reader.savedChannelMetadata(owner, configuration, savedDashboard)); + reader.savedChannelMetadata(owner, configuration, savedDashboard), context.catalog(), id); var readable = available(result, id, resolved, true); var preferred = resolved.preferredCombination(); return timeAxisDisplayUnits(owner, result, graphic, new GraphicUnitResolution(readable.isEmpty() ? resolved.retainUnavailableDefault() ? preferred : null @@ -965,6 +976,8 @@ Integer currentMemberChannelType(DashboardResult result, String id) { public UnitMemberMetadata memberMetadata(GraphicResultCodeDto binding, String channelId) { try (var scope = openUnitQueryScope()) { var result = results.selectById(binding.getDashboardResultId()); + var savedContext = result.getRequestId() == null ? null + : openUnitSelectionQuery().savedMetadataContext(result, providerId(result)); var resultUnits = resultOwnedUnits(result, channelId); if (resultUnits != null) { var metadata = new UnitMemberMetadata(); @@ -988,20 +1001,8 @@ public UnitMemberMetadata memberMetadata(GraphicResultCodeDto binding, String ch if (definition == null) throw new IllegalArgumentException("Frozen Provider result definition is missing: " + result.getId()); var member = MeasurementResultFacts.requireMember(definition, channelId); - channel = member.resultMetadata(); - if (channel == null) { - // Source members keep their metadata in the execution input catalogue, not the result definition. - var execution = executions.selectById(result.getRequestId()); - if (execution == null || !Objects.equals(execution.getDashboardId(), result.getDashboardId())) - throw new IllegalArgumentException("Saved member belongs to another dashboard scope"); - var snapshot = FlowExecuteSnapshotDataDto.parseJson(execution.getSnapshotData()); - new ResultPluginAccess(providers).requireSnapshot(snapshot); - var savedDashboard = snapshot.getDashboardConfig(); - channel = member.channelDirection() == null ? null - : resultReader().savedChannelFacts(savedDashboard).get(member.channelDirection(), member.vchId()); - if (channel == null) - throw new IllegalArgumentException("Frozen result channel metadata is missing: " + member.vchId()); - } + currentUnits = savedContext.memberFacts(result, definition, channelId); + channel = savedContext.channelMetadata(member); resolution = measurementResult(result, providerId(result)) ? resolve(result, channelId, Map.of()) : savedResolution(result, channelId); } else { var dashboard = dashboards.selectById(result.getDashboardId()); diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/SavedMeasurementInputFacts.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/SavedMeasurementInputFacts.java index e23ca84f..3a6b8060 100644 --- a/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/SavedMeasurementInputFacts.java +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/SavedMeasurementInputFacts.java @@ -1,6 +1,10 @@ package com.opentest.service.dashboard.framework; import com.opentest.service.plugin.MeasureProviderInputs; +import com.opentest.service.can.CanProjectChannelFacts; +import com.opentest.common.enums.ChannelSourceEnum; +import com.opentest.dashboard.api.capability.CanChannelFacts; +import com.opentest.dashboard.api.channel.CanSignalChannel; import java.util.EnumMap; import com.opentest.dashboard.api.channel.ChannelMetadata; import com.opentest.dashboard.api.channel.ChannelDirection; @@ -97,6 +101,7 @@ public static List readChannelFacts(MeasurementInputInterpreter inte } public static ChannelCatalog catalog(List facts) { + var can = new LinkedHashMap(); var directed = new EnumMap>( ChannelDirection.class); @@ -106,13 +111,20 @@ public static ChannelCatalog catalog(List facts) { case 1 -> ChannelDirection.OUTPUT; default -> throw new IllegalArgumentException("Unsupported saved channel direction"); }; + if (ChannelSourceEnum.isCan(channel.getChannelSource())) { + var frozen = CanProjectChannelFacts.saved(channel); + var previous = can.putIfAbsent(channel.getVchId(), frozen); + if (previous != null && !previous.equals(frozen)) + throw new IllegalArgumentException("Conflicting saved channel facts: " + direction + ":" + channel.getVchId()); + continue; + } var metadata = MeasureProviderInputs.channel(channel); var previous = directed.computeIfAbsent(direction, ignored -> new LinkedHashMap<>()) .putIfAbsent(channel.getVchId(), metadata); if (previous != null && !previous.equals(metadata)) throw new IllegalArgumentException("Conflicting saved channel facts: " + direction + ":" + channel.getVchId()); } - return new ChannelCatalog(directed); + return new ChannelCatalog(directed, Map.of(), Map.of(), new CanChannelFacts(can)); } /** Patch only channel facts actually read by the plugin, retaining their original configuration location. */ diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/SavedProviderArtifacts.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/SavedProviderArtifacts.java index eed59dce..e25adc74 100644 --- a/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/SavedProviderArtifacts.java +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/dashboard/framework/SavedProviderArtifacts.java @@ -25,6 +25,8 @@ import java.util.Objects; import java.util.function.Function; import com.opentest.service.FileService; +import com.opentest.service.can.CanStoredUnitConversion; +import com.opentest.common.enums.ChannelSourceEnum; import java.nio.file.Files; import java.nio.file.Path; @@ -192,6 +194,8 @@ public static List readable(DashboardResultDto result, Map()); for (Throwable failure = exception; failure != null && visited.add(failure); failure = failure.getCause()) { if (failure instanceof com.opentest.dashboard.api.execution.DashboardExecutionException declared) - return com.opentest.service.dashboard.framework.ProviderExecutionErrors.businessError(declared.error()); + return ProviderExecutionErrors.businessError(declared.error()); + if (failure instanceof CryBusinessException business && business.businessIdentity() != ErrorCode.FAILED + && selectedBusinessFailure == null) + selectedBusinessFailure = business; + if (failure instanceof CanOperationException can) + return selectedBusinessFailure != null ? selectedBusinessFailure + : (CryBusinessException) ProviderExecutionErrors.executionFailure(can); } Throwable current = exception; while ((current instanceof CompletionException || current instanceof ExecutionException) diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/core/sync/SyncMeasurementRecorderManager.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/core/sync/SyncMeasurementRecorderManager.java index ace5d219..e4fead15 100644 --- a/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/core/sync/SyncMeasurementRecorderManager.java +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/core/sync/SyncMeasurementRecorderManager.java @@ -6,6 +6,7 @@ import cn.hutool.core.util.IdUtil; import com.opentest.common.exception.CryBusinessException; import com.opentest.common.exception.ErrorCode; +import com.opentest.common.enums.ChannelSourceEnum; import com.opentest.common.model.dto.ChannelDto; import com.opentest.common.model.dto.ContinueCaptureFuture; import com.opentest.common.model.dto.dashboard.CollectConfigDto; @@ -25,6 +26,11 @@ import com.opentest.service.grpc.core.DashboardStopFailureCollector; import com.opentest.service.grpc.core.TimeStopSampleTargetProvider; import com.opentest.service.grpc.core.TimeStopSampleTargets; +import com.opentest.service.grpc.core.TimeStopCompletionSource; +import com.opentest.service.grpc.core.TimeStopCompletionSource.CanAwaitingStart; +import com.opentest.service.grpc.core.TimeStopCompletionSource.CanElapsed; +import com.opentest.service.grpc.core.TimeStopCompletionSource.SampleDriven; +import com.opentest.service.grpc.core.TimeStopCompletionSource.View; import com.opentest.service.grpc.core.StartConfigurationPreparer; import com.opentest.service.grpc.core.sender.GrpcWriter; import com.opentest.platform.mmap.MmapWriter; @@ -774,20 +780,45 @@ private void prepareRecordingStorageResultOutputs() { private void validateTimeStopTargets() { for (SyncMeasurementMemberRuntime runtime : members) { AbstractDashboardHandler handler = runtime.getCurrentHandler(); - if (!requiresSampleCountStop(runtime, handler)) { - continue; - } - resolveTimeStopSampleTargets(runtime, handler); + resolveTimeStopCompletion(runtime, handler); } } private void configureTimeStopTargets(SyncMeasurementMemberRuntime runtime, AbstractDashboardHandler handler) { - if (!requiresSampleCountStop(runtime, handler)) { - return; + TimeStopCompletionPlan plan = resolveTimeStopCompletion(runtime, handler); + if (plan instanceof SampleCompletion samples) { + handler.configureTimeStopSampleTargets(samples.targets()); } - handler.configureTimeStopSampleTargets( - resolveTimeStopSampleTargets(runtime, handler)); + } + + private sealed interface TimeStopCompletionPlan permits SampleCompletion, CanElapsedCompletion { + long expectedDurationMs(); + } + + private record SampleCompletion(TimeStopSampleTargets targets) implements TimeStopCompletionPlan { + @Override public long expectedDurationMs() { return targets.getExpectedCompletionDurationMs(); } + } + + private record CanElapsedCompletion(long expectedDurationMs) implements TimeStopCompletionPlan { } + + private TimeStopCompletionPlan resolveTimeStopCompletion(SyncMeasurementMemberRuntime runtime, + AbstractDashboardHandler handler) { + if (!requiresTimeStop(runtime, handler)) return null; + long durationMs = runtime.getCollectConfig().getAcquisitionTimeInMilliseconds(); + if (durationMs <= 0L) throw invalidProcessTarget(runtime, null, "acquisition duration must be positive"); + View view = timeStopCompletionView(handler); + if (view instanceof CanAwaitingStart || view instanceof CanElapsed) + return new CanElapsedCompletion(durationMs); + return new SampleCompletion(resolveTimeStopSampleTargets(runtime, handler)); + } + + private View timeStopCompletionView(AbstractDashboardHandler handler) { + if (handler instanceof TimeStopCompletionSource source) { + View view = source.timeStopCompletionView(); + if (view != null) return view; + } + return SampleDriven.INSTANCE; } private TimeStopSampleTargets resolveTimeStopSampleTargets( @@ -845,7 +876,7 @@ private TimeStopSampleTargets resolveTimeStopSampleTargets( } } - private boolean requiresSampleCountStop(SyncMeasurementMemberRuntime runtime, + private boolean requiresTimeStop(SyncMeasurementMemberRuntime runtime, AbstractDashboardHandler handler) { CollectConfigDto collectConfig = runtime == null ? null : runtime.getCollectConfig(); return collectConfig != null @@ -858,7 +889,7 @@ private List resolvePhysicalTargetChannels( SyncMeasurementMemberRuntime runtime) { List targetChannels = new ArrayList<>(); for (ChannelDto channel : resolveRuntimeChannels(runtime)) { - if (channel == null || channel.isMathChannel() + if (channel == null || channel.isMathChannel() || ChannelSourceEnum.isCan(channel.getChannelSource()) || StrUtil.isBlank(channel.getDeviceName())) { continue; } @@ -1022,6 +1053,10 @@ private void startDevices(Executor nativeStartExecutor, ScheduledExecutorService timeoutScheduler, long nativeStartTimeoutMs) { Map> deviceChannelsMap = buildUnionDeviceChannels(); + if (deviceChannelsMap.isEmpty()) { + ensureNotStopped("before-ready-without-audio-capture"); + return; + } synchronized (captureLeases) { ensureNotStopped("reserve device capture"); continueCaptureManager.addDeviceCaptureStatusListener(deviceStatusListener); @@ -1319,8 +1354,7 @@ private Long resolveExpectedCompletionDurationMs( if (acquisitionMs <= 0L) { return null; } - return resolveTimeStopSampleTargets(runtime, handler) - .getExpectedCompletionDurationMs(); + return resolveTimeStopCompletion(runtime, handler).expectedDurationMs(); } private void startCaptureDataReaders() { @@ -1576,12 +1610,11 @@ private void checkRecordsFinish(ScheduledExecutorService timeoutScheduler) { boolean allFinished = true; for (SyncMeasurementMemberRuntime runtime : members) { AbstractDashboardHandler handler = runtime.getCurrentHandler(); - if (!runtime.isCompleted() - && requiresSampleCountStop(runtime, handler) + if (!stopRequested && !runtime.isCompleted() + && requiresTimeStop(runtime, handler) && Boolean.FALSE.equals(handler.getFinished()) - && handler.getChannelListenerManager() != null - && handler.getChannelListenerManager().checkProcessAllData()) { - onMemberNaturalStop(runtime, null, timeoutScheduler); + && isTimeStopComplete(runtime, handler)) { + onHandlerNaturalStop(runtime, handler, timeoutScheduler); } if (!runtime.isCompleted() && Boolean.TRUE.equals(handler.getFinished()) @@ -1600,6 +1633,16 @@ && requiresSampleCountStop(runtime, handler) } } + private boolean isTimeStopComplete(SyncMeasurementMemberRuntime runtime, AbstractDashboardHandler handler) { + TimeStopCompletionPlan plan = resolveTimeStopCompletion(runtime, handler); + if (plan instanceof CanElapsedCompletion elapsed) { + return timeStopCompletionView(handler) instanceof CanElapsed clock + && clock.elapsedMillis() >= elapsed.expectedDurationMs(); + } + return plan instanceof SampleCompletion && handler.getChannelListenerManager() != null + && handler.getChannelListenerManager().checkProcessAllData(); + } + private void checkDiskSpaceAndStopIfLow() { try { AbstractDashboardHandler owner = firstHandler(); @@ -1617,7 +1660,9 @@ private void checkDiskSpaceAndStopIfLow() { private synchronized void onHandlerNaturalStop(SyncMeasurementMemberRuntime runtime, AbstractDashboardHandler expectedHandler, ScheduledExecutorService timeoutScheduler) { - if (runtime.getCurrentHandler() != expectedHandler || Boolean.TRUE.equals(expectedHandler.getFinished())) return; + if (hasStop || runtime.isCompleted() || runtime.isFailed() + || runtime.getCurrentHandler() != expectedHandler + || !Boolean.FALSE.equals(expectedHandler.getFinished()) || isSettlementPending(expectedHandler)) return; onMemberNaturalStop(runtime, null, timeoutScheduler); } @@ -2744,7 +2789,8 @@ private Map> buildUnionDeviceChannels() { Map> result = new LinkedHashMap<>(); for (SyncMeasurementMemberRuntime runtime : members) { for (ChannelDto channel : resolveRuntimeChannels(runtime)) { - if (channel == null || channel.isMathChannel() || StrUtil.isBlank(channel.getDeviceName())) { + if (channel == null || channel.isMathChannel() || ChannelSourceEnum.isCan(channel.getChannelSource()) + || StrUtil.isBlank(channel.getDeviceName())) { continue; } Device device = toDevice(channel); diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/provider/CompletedGraphicResultPublisher.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/provider/CompletedGraphicResultPublisher.java index 0c15ab24..04f33629 100644 --- a/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/provider/CompletedGraphicResultPublisher.java +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/provider/CompletedGraphicResultPublisher.java @@ -135,7 +135,7 @@ private void appendGraphicItems(CommonProto.MultiGraphicData.Builder batch, handler.getByVchIdAndDashboardResultId( memberId, dashboardResult.getId()); for (GraphicConfigSnapshotDto graphic : graphics) { - GraphicResultCodeDto binding = findBinding(graphic, dashboardResult); + GraphicResultCodeDto binding = findBinding(graphic, dashboardResult, memberId); if (!matchesUnit(binding, memberId, result.getYDefaultUnit())) { continue; } @@ -202,13 +202,14 @@ private List resolveDashboardResults(CalResult result) { } private GraphicResultCodeDto findBinding(GraphicConfigSnapshotDto graphic, - DashboardResultDto result) { + DashboardResultDto result, String memberId) { if (graphic == null || CollUtil.isEmpty(graphic.getResultCodes())) { return null; } for (GraphicResultCodeDto binding : graphic.getResultCodes()) { if (binding != null && ObjectUtil.equals( - binding.getDashboardResultId(), result.getId())) { + binding.getDashboardResultId(), result.getId()) + && CollUtil.contains(binding.getChannelIds(), memberId)) { return binding; } } diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/provider/MeasurementCompletedTargetPolicy.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/provider/MeasurementCompletedTargetPolicy.java index e040c673..7619fe7e 100644 --- a/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/provider/MeasurementCompletedTargetPolicy.java +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/provider/MeasurementCompletedTargetPolicy.java @@ -12,6 +12,7 @@ import com.opentest.dashboard.api.result.CompletedResultIdentity; import com.opentest.dashboard.api.result.CompletedResultStorage; import com.opentest.dashboard.api.result.ResultRequirement; +import com.opentest.dashboard.api.result.GraphicTarget; import com.opentest.dashboard.api.measurement.ResultFileOutputAlias; /** Immutable admission authority for one compiled measurement's completed numerical output. */ @@ -22,6 +23,7 @@ record Target(long resultId, String code, String hash, String member, String uni record Prepared(CompletedResultCurve curve, Target target) { } private final List targets; + private final List liveTargets; private final Map savedResults; private final java.util.Set ambiguousSavedResults; @@ -33,6 +35,12 @@ record Prepared(CompletedResultCurve curve, Target target) { } MeasurementCompletedTargetPolicy(List requirements, List frozenResults, Map members, List aliases) { + this(requirements, frozenResults, members, aliases, List.of()); + } + + MeasurementCompletedTargetPolicy(List requirements, List frozenResults, + Map members, + List aliases, List graphics) { Objects.requireNonNull(requirements); Objects.requireNonNull(frozenResults); Objects.requireNonNull(members); @@ -76,6 +84,23 @@ record Prepared(CompletedResultCurve curve, Target target) { } selected.add(target); } this.targets = List.copyOf(selected); + var live = new LinkedHashSet<>(selected); + for (var graphic : graphics) { + var sources = requirements.stream().filter(source -> + source.dashboardResultId().equals(graphic.dashboardResultId()) + && source.vchId().equals(graphic.vchId())).toList(); + if (sources.isEmpty()) continue; + if (sources.stream().anyMatch(source -> !source.resultCode().equals(graphic.resultCode()) + || !source.hash().equals(graphic.hash()))) + throw new IllegalArgumentException("Live graphic differs from frozen result identity"); + var member = members.get(new MeasurementResultMemberFacts.Key(graphic.dashboardResultId(), graphic.vchId())); + if (member.declaredUnits().combinations().stream().noneMatch(unit -> + Objects.equals(unit.unitX(), graphic.unitX()) && Objects.equals(unit.unitY(), graphic.unitY()))) + throw new IllegalArgumentException("Live graphic has no frozen member units: " + graphic.vchId()); + live.add(new Target(graphic.dashboardResultId(), graphic.resultCode(), graphic.hash(), + graphic.vchId(), graphic.unitX(), graphic.unitY())); + } + this.liveTargets = List.copyOf(live); this.savedResults = Map.copyOf(byIdentity); this.ambiguousSavedResults = java.util.Set.copyOf(ambiguous); } @@ -91,7 +116,7 @@ List prepare(List curves) { Prepared resolveLive(CompletedResultCurve curve) { Objects.requireNonNull(curve, "Live curve"); if (curve.storage() != null) return resolve(curve); - var matching = targets.stream().filter(target -> curve.dashboardResultId() == target.resultId() + var matching = liveTargets.stream().filter(target -> curve.dashboardResultId() == target.resultId() && Objects.equals(target.code(), curve.resultCode()) && Objects.equals(target.member(), curve.channelId()) && Objects.equals(target.unitX(), curve.unitX()) && Objects.equals(target.unitY(), curve.unitY())).toList(); diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/provider/MeasurementFileOutputAliases.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/provider/MeasurementFileOutputAliases.java index 001a32c9..d12f398e 100644 --- a/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/provider/MeasurementFileOutputAliases.java +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/provider/MeasurementFileOutputAliases.java @@ -42,6 +42,8 @@ static Bound bind(ExecutionOutputs outputs, var fact = memberFacts.get(new MeasurementResultMemberFacts.Key( source.dashboardResultId(), source.vchId())); if (fact == null) throw new IllegalArgumentException("File alias source member is not frozen"); + if (!(fact.source() instanceof MeasurementResultMemberFacts.SampledSource sampled)) + throw new IllegalArgumentException("CAN sampled file aliases are unavailable until event recording is supported"); var sourceKey = new MeasurementResultFileMetadata.Key(source.resultCode(), source.hash(), source.vchId(), source.requestedUnitX(), source.requestedUnitY()); if (canonical.stream().filter(target -> target.dashboardResultId() == source.dashboardResultId() @@ -52,7 +54,7 @@ static Bound bind(ExecutionOutputs outputs, if (!keys.add(new TargetKey(source.dashboardResultId(), emitted))) throw new IllegalArgumentException("Colliding measurement file alias: " + emitted); targets.add(new MeasurementResultFileMetadata.Target(source.dashboardResultId(), emitted, - withMember(fact.metadata(), alias.emittedMemberId()), source.fileUnitIdentity(), + withMember(sampled.metadata(), alias.emittedMemberId()), source.fileUnitIdentity(), canonical.stream().filter(target -> target.dashboardResultId() == source.dashboardResultId() && target.key().equals(sourceKey)) .findFirst().orElseThrow().resultUnitIdentityY())); } diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/provider/ProviderCanSignalInputs.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/provider/ProviderCanSignalInputs.java new file mode 100644 index 00000000..13f9b852 --- /dev/null +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/provider/ProviderCanSignalInputs.java @@ -0,0 +1,283 @@ +package com.opentest.service.grpc.provider; + +import cn.hutool.json.JSONArray; +import cn.hutool.json.JSONObject; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.core.type.TypeReference; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.opentest.dashboard.api.capability.CanChannelFacts; +import com.opentest.dashboard.api.capability.CanSignalBatch; +import com.opentest.dashboard.api.capability.CanSignalEvent; +import com.opentest.dashboard.api.capability.CanSignalInputs; +import com.opentest.dashboard.api.capability.CanSignalProjection; +import com.opentest.dashboard.api.capability.LiveResultOutput; +import com.opentest.dashboard.api.measurement.ExecutionOutputs; +import com.opentest.service.can.CanOperationException; +import com.opentest.service.can.CanService; +import com.opentest.service.recording.measurement.CanRecordedInputStore; +import java.math.BigInteger; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.UUID; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.Executors; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.TimeUnit; +import java.util.function.Consumer; +import java.util.function.DoubleSupplier; + +/** One execution owns admission, callback delivery and release; the service owns shared ports. */ +final class ProviderCanSignalInputs implements CanSignalInputs, AutoCloseable { + private static final ObjectMapper JSON = new ObjectMapper(); + private final CanService service; + private final CanChannelFacts facts; + private final Consumer failure; + private final String usageId = "measurement-" + UUID.randomUUID(); + private final Map lossCounters = new HashMap<>(); + private final ScheduledExecutorService reader = Executors.newSingleThreadScheduledExecutor(runnable -> { + var thread = new Thread(runnable, "can-measurement-reader"); + thread.setDaemon(true); return thread; + }); + private List subscriptions = List.of(); + private CanSignalProjection.Factory factory; + private CanSignalProjection projection; + private boolean prepared; + private boolean bound; + private boolean started; + private boolean stopped; + private boolean failed; + private long observationOrigin; + private CanRecordedInputStore.Recording recording; + private DoubleSupplier recordingSeconds; + private Throwable executionFailure; + private Throwable closeFailure; + private final CompletableFuture released = new CompletableFuture<>(); + + ProviderCanSignalInputs(CanService service, CanChannelFacts facts, Consumer failure) { + this.service = service; this.facts = Objects.requireNonNull(facts); this.failure = Objects.requireNonNull(failure); + } + @Override public CanChannelFacts channels() { return facts; } + CompletableFuture released() { return released; } + + synchronized void prepare() { + if (prepared || stopped) throw new IllegalStateException("CAN preparation is repeated or closed"); + try { + if (!facts.channels().isEmpty()) subscriptions = Objects.requireNonNull(service, "CAN source service") + .acquire(usageId, "Monitor", List.copyOf(facts.channels().values())); + } catch (LinkageError failure) { + throw new CanOperationException(13103001, "can.error.nativeUnavailable", failure); + } + prepared = true; + } + @Override public synchronized void projectWith(CanSignalProjection.Factory factory) { + if (!prepared || bound || stopped || this.factory != null) + throw new IllegalStateException("CAN projection registration is repeated or late"); + this.factory = Objects.requireNonNull(factory); + } + synchronized void bind(ExecutionOutputs outputs, LiveResultOutput output) { + if (bound || stopped) throw new IllegalStateException("CAN projection binding is repeated or closed"); + if (!facts.channels().isEmpty()) projection = Objects.requireNonNull(factory, "CAN projection factory") + .create(facts, outputs, output); + bound = true; + } + synchronized void attachRecording(CanRecordedInputStore.Recording recording, DoubleSupplier recordingSeconds) { + if (started || stopped || this.recording != null) + throw new IllegalStateException("CAN recording attachment is repeated or late"); + this.recording = Objects.requireNonNull(recording); + this.recordingSeconds = Objects.requireNonNull(recordingSeconds); + } + + synchronized void stopFailure(Throwable failure) { + if (failure != null && executionFailure == null) executionFailure = failure; + } + + synchronized void start() { + if (started || stopped || facts.channels().isEmpty()) return; + if (!bound) throw new IllegalStateException("CAN projection has not been bound"); + var admissions = new LinkedHashMap>(); + if (recording != null) for (var subscription : subscriptions) { + // Native selection replacement atomically excludes preparation-time queued events. + JSONObject admission = subscription.beginRecording(); + if (admission == null) throw new CanOperationException(13103019, "can.error.invalidResponse"); + changedCounter(subscription.subscriptionId() + ":samples", admission.getStr("lostSamples")); + JSONObject source = admission.getJSONObject("sourceObservations"); + if (source != null) { + changedCounter(subscription.subscriptionId() + ":sequence", source.getStr("forwardSequenceGaps")); + changedCounter(subscription.subscriptionId() + ":clock", source.getStr("timeDomainChanges")); + } + var boundary = jsonMap(admission); + subscription.channels().values().forEach(channel -> admissions.put(channel.vchId(), boundary)); + } + started = true; + observationOrigin = System.nanoTime(); + var missing = facts.channels().keySet().stream().map(id -> + new CanSignalEvent.InvalidState(id, CanSignalEvent.InvalidReason.NO_DATA, + admissions.containsKey(id) ? Map.of("admission", admissions.get(id)) : Map.of())).toList(); + deliver(new CanSignalBatch(0, missing)); + reader.scheduleWithFixedDelay(this::poll, 0, 10, TimeUnit.MILLISECONDS); + } + + void poll() { + Throwable error = null; + synchronized (this) { + if (!started || stopped || failed) return; + try { + for (var subscription : subscriptions) { + for (int index = 0; index < 16; index++) { + JSONObject batch = subscription.read(); + List events = events(subscription, batch); + if (!events.isEmpty()) deliver(new CanSignalBatch(elapsed(), events)); + String state = batch.getStr("state"); + if (state != null && !"running".equals(state)) + throw new CanOperationException(13103002, "can.error.sourceFailed"); + JSONArray samples = batch.getJSONArray("samples"); + if (samples == null || samples.size() < 256) break; + } + } + } catch (RuntimeException caught) { failed = true; executionFailure = caught; error = caught; } + catch (LinkageError caught) { + failed = true; error = new CanOperationException(13103001, "can.error.nativeUnavailable", caught); + executionFailure = error; + } + } + // Stop may join this participant, so never invoke handler failure under its delivery lock. + if (error != null) { + Throwable observed = error; + CompletableFuture.runAsync(() -> failure.accept(observed)); + } + } + + private double elapsed() { return Math.max(0, System.nanoTime() - observationOrigin) / 1_000_000_000d; } + + private void deliver(CanSignalBatch batch) { + if (recording != null) { + double commonSeconds = recordingSeconds.getAsDouble(); + recording.mapProgress(batch.observationElapsedSeconds(), commonSeconds); + recording.append(batch); + projection.accept(new CanSignalBatch(commonSeconds, batch.events())); + } else { + projection.accept(batch); + } + } + + private List events(CanService.BusinessSubscription subscription, JSONObject batch) { + List result = new ArrayList<>(); + JSONObject source = new JSONObject(batch.toString()); source.remove("samples"); + var sourceFacts = jsonMap(source); + BigInteger dropped = changedCounter(subscription.subscriptionId() + ":samples", batch.getStr("lostSamples")); + JSONObject observations = batch.getJSONObject("sourceObservations"); + boolean sourceGap = false; + if (observations != null) { + sourceGap = changedCounter(subscription.subscriptionId() + ":sequence", observations.getStr("forwardSequenceGaps")).signum() > 0; + sourceGap |= changedCounter(subscription.subscriptionId() + ":clock", observations.getStr("timeDomainChanges")).signum() > 0; + } + if (dropped.signum() > 0 || sourceGap) { + BigInteger count = sourceGap ? null : dropped; + subscription.channels().values().forEach(channel -> result.add(new CanSignalEvent.LossGap(channel.vchId(), count, sourceFacts))); + } + JSONArray samples = batch.getJSONArray("samples"); + if (samples == null) throw new CanOperationException(13103019, "can.error.invalidResponse"); + for (Object value : samples) { + JSONObject sample = value instanceof JSONObject object ? object : new JSONObject(value); + var channel = subscription.channels().get(sample.getStr("signalId")); + if (channel == null) throw new CanOperationException(13103019, "can.error.invalidResponse"); + Map provenance = new LinkedHashMap<>(jsonMap(sample)); + provenance.put("source", sourceFacts); + if (Boolean.TRUE.equals(sample.getBool("valid"))) { + Double physical = sample.getDouble("physicalValue"); + if (physical == null || !Double.isFinite(physical)) + throw new CanOperationException(13103019, "can.error.invalidResponse"); + result.add(new CanSignalEvent.ValidSample(channel.vchId(), physical, provenance)); + } else result.add(new CanSignalEvent.InvalidState(channel.vchId(), invalidReason(sample.getStr("reason")), provenance)); + } + return result; + } + + private BigInteger changedCounter(String key, String value) { + if (value == null) return BigInteger.ZERO; + BigInteger current = new BigInteger(value); + if (current.signum() < 0) throw new CanOperationException(13103019, "can.error.invalidResponse"); + BigInteger previous = lossCounters.put(key, current); + return current.subtract(previous == null ? BigInteger.ZERO : previous).max(BigInteger.ZERO); + } + + private static CanSignalEvent.InvalidReason invalidReason(String reason) { + if (reason == null) return CanSignalEvent.InvalidReason.INVALID_RULE; + return switch (reason) { + case "timeout" -> CanSignalEvent.InvalidReason.TIMEOUT; + case "no-valid-sample" -> CanSignalEvent.InvalidReason.NO_DATA; + case "invalid-raw-value" -> CanSignalEvent.InvalidReason.INVALID_RAW; + case "short-payload" -> CanSignalEvent.InvalidReason.SHORT_PAYLOAD; + case "source-error", "disconnected", "source-stopped" -> CanSignalEvent.InvalidReason.SOURCE_FAILURE; + default -> CanSignalEvent.InvalidReason.INVALID_RULE; + }; + } + + private static Map jsonMap(JSONObject value) { + try { return JSON.readValue(value.toString(), new TypeReference<>() { }); } + catch (JsonProcessingException error) { throw new CanOperationException(13103019, "can.error.invalidResponse"); } + } + + @Override public synchronized void close() { + if (stopped) { + rethrowCloseFailure(); + return; + } + stopped = true; + reader.shutdown(); + // Entering this lock joins any Native read and all already-admitted projection callbacks. + if (recording != null && started) { + var cutoffs = new ArrayList>(); + for (var subscription : subscriptions) { + try { + JSONObject last; + do { + last = subscription.finish(); + if (last == null || !"finished".equals(last.getStr("subscriptionState")) + || last.getBool("drained") == null || last.getJSONObject("cutoff") == null) + throw new CanOperationException(13103019, "can.error.invalidResponse"); + var tail = events(subscription, last); + if (!tail.isEmpty()) deliver(new CanSignalBatch(elapsed(), tail)); + } while (!last.getBool("drained")); + JSONObject snapshot = new JSONObject(last.toString()); snapshot.remove("samples"); + cutoffs.add(jsonMap(snapshot)); + } catch (Throwable failure) { addCloseFailure(failure); } + } + try { + if (closeFailure == null) + recording.finish(elapsed(), recordingSeconds.getAsDouble(), cutoffs, + executionFailure == null ? "STOPPED" : "SOURCE_FAILURE", executionFailure); + else recording.fail(closeFailure); + } catch (Throwable failure) { + addCloseFailure(failure); + try { recording.fail(failure); } + catch (Throwable partialFailure) { addCloseFailure(partialFailure); } + } + } else if (recording != null) { + try { recording.fail(new IllegalStateException("CAN recording ended before formal capture started")); } + catch (Throwable failure) { addCloseFailure(failure); } + } + try { if (projection != null) projection.close(); } + catch (Throwable failure) { addCloseFailure(failure); } + // The usage identity also owns compensation failures from a partially acquired port set. + try { if (!facts.channels().isEmpty()) service.releaseUsage(usageId); } + catch (Throwable failure) { + addCloseFailure(failure); + } + if (closeFailure == null) released.complete(null); else released.completeExceptionally(closeFailure); + rethrowCloseFailure(); + } + private void addCloseFailure(Throwable failure) { + if (closeFailure == null) closeFailure = failure; + else if (closeFailure != failure) closeFailure.addSuppressed(failure); + } + private void rethrowCloseFailure() { + if (closeFailure instanceof RuntimeException error) throw error; + if (closeFailure instanceof Error error) throw error; + if (closeFailure != null) throw new IllegalStateException(closeFailure); + } +} diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/provider/ProviderPipelineDashboardHandler.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/provider/ProviderPipelineDashboardHandler.java index 995c8043..87361b42 100644 --- a/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/provider/ProviderPipelineDashboardHandler.java +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/provider/ProviderPipelineDashboardHandler.java @@ -1,7 +1,21 @@ package com.opentest.service.grpc.provider; +import com.opentest.service.grpc.core.sync.SharedCaptureStopAware; +import com.opentest.service.grpc.core.TimeStopSampleTargetProvider; import com.opentest.dashboard.api.capability.ProjectTriggers; import com.opentest.dashboard.api.internal.ImmutableValues; +import com.opentest.dashboard.api.capability.CanChannelFacts; +import com.opentest.dashboard.api.capability.CanSignalInputs; +import com.opentest.dashboard.api.capability.CanSignalBatch; +import com.opentest.dashboard.api.capability.CanSignalProjection; +import com.opentest.dashboard.api.channel.CanSignalChannel; +import com.opentest.dashboard.api.measurement.ExecutionOutputs; +import com.opentest.dashboard.standard.result.PersistResultSinkProcessor; +import com.opentest.service.recording.measurement.CanRecordedInputStore; +import com.opentest.service.snapshot.FlowExecuteSnapshotMutator; +import java.nio.file.Path; +import com.opentest.common.enums.ChannelSourceEnum; +import com.opentest.service.can.CanService; import com.opentest.common.model.dto.RecordedWaveformPlanDto; import com.opentest.service.recording.RecordedWaveformPlans; @@ -86,6 +100,7 @@ import com.opentest.service.dashboard.framework.BoundMeasurementInputs; import com.opentest.service.dashboard.framework.MeasurementResultMemberFacts; import com.opentest.service.grpc.core.*; +import com.opentest.service.grpc.core.TimeStopCompletionSource; import com.opentest.service.jni.PostProcessService; import com.opentest.dashboard.api.execution.MeasurementStopOutcome; import com.opentest.service.plugin.*; @@ -130,10 +145,20 @@ /** 宿主通用执行适配:采集门控之后直接投递固定 Pipeline,不调用仪表盘业务计算器。 */ @Component @Scope("prototype") -public class ProviderPipelineDashboardHandler extends AbstractDashboardHandler implements com.opentest.service.grpc.core.TimeStopSampleTargetProvider, StartConfigurationPreparer, com.opentest.service.grpc.core.sync.SharedCaptureStopAware { +public class ProviderPipelineDashboardHandler extends AbstractDashboardHandler implements TimeStopSampleTargetProvider, StartConfigurationPreparer, SharedCaptureStopAware, TimeStopCompletionSource { @Resource private com.opentest.service.ExcitationConfigService providerExcitations; @Resource private com.opentest.service.BoxChannelService providerChannelFacts; @Resource private com.opentest.service.DeviceService providerDevices; + @Resource private CanService providerCan; + private volatile ProviderCanSignalInputs canInputs; + private PersistResultSinkProcessor.FileOutput canNumericFiles; + private ResultPersistenceScope canPersistenceScope = ResultPersistenceScope.NONE; + private volatile long formalRecordingOriginNanos; + private volatile long formalRecordingEndNanos; + private volatile boolean formalRecordingEpochPublished; + private volatile boolean formalRecordingEnded; + private volatile boolean canClockRunning; + private volatile boolean captureRuntimeReady; @Resource private com.opentest.service.ptp.PtpSyncConfigStorageService providerSynchronization; @Override public java.util.Map getDeviceSynchronizationModes() { @@ -425,6 +450,17 @@ Map, Object> preparedAuthorServices() { var services = new LinkedHashMap, Object>(); services.put(PlatformYUnitConverter.class, authorUnitConverter); services.put(ExecutionInputDiagnostics.class, inputDiagnostics); + if (canInputs != null) { + var participant = canInputs; + services.put(CanSignalInputs.class, new CanSignalInputs() { + @Override public CanChannelFacts channels() { return participant.channels(); } + @Override public void projectWith(CanSignalProjection.Factory factory) { + participant.projectWith((facts, outputs, live) -> + new CanNumericProjection(factory, facts, outputs, live, canNumericFiles)); + } + }); + services.put(CanChannelFacts.class, canInputs.channels()); + } services.put(MeasurementCalculationMode.class, new MeasurementCalculationMode(super.isSelectiveCalculation(), getCalculationPlan() == null || getCalculationPlan().getOutputSelection() == null ? null : getCalculationPlan().getOutputSelection().getRoots().stream() @@ -494,9 +530,16 @@ public void signalStopRequested(com.opentest.common.exception.CryBusinessExcepti List validateMeasurementInputs() { synchronized (preparationLock) { if (closing.get()) throw new IllegalStateException("Execution is closed"); - preparedProviderChannels = Objects.requireNonNull(measurementInputs, "Bound measurement inputs").selected(); + preparedProviderChannels = Objects.requireNonNull(measurementInputs, "Bound measurement inputs").sampledSelected(); input = providerInputChannels(); - if (input.isEmpty()) throw new IllegalArgumentException("Execution requires an input channel"); + if (input.isEmpty() && measurementInputs.selectedCanChannels().isEmpty()) + throw new IllegalArgumentException("Execution requires an input channel"); + if (canInputs == null) { + var selected = new LinkedHashMap(); + measurementInputs.selectedCanChannels().forEach(channel -> selected.put(channel.vchId(), channel)); + var participant = new ProviderCanSignalInputs(providerCan, new CanChannelFacts(selected), this::requestMeasurementFailure); + canInputs = measurementSession == null ? participant : measurementSession.own(participant); + } return List.copyOf(input); } } @@ -516,6 +559,7 @@ List prepareMeasurementInputSampling(Optional reserveMe if (fact.declaredUnits().combinations().isEmpty()) continue; var units = com.opentest.service.dashboard.framework.ProviderResultRequirementUnits.select( fact.declaredUnits(), result.getCustomUnitX(), result.getCustomUnitY(channel)); - fileTargets.add(new MeasurementResultFileMetadata.Target(row.getId(), + if (fact.source() instanceof MeasurementResultMemberFacts.SampledSource sampled) + fileTargets.add(new MeasurementResultFileMetadata.Target(row.getId(), new MeasurementResultFileMetadata.Key(result.getPrimaryCode(), result.getHash(), member.vchId(), - units.unitX(), units.unitY()), fact.metadata(), ResultFileUnitIdentity.fromCustom(tableDefinition.custom()), units.resultUnitIdentityY())); + units.unitX(), units.unitY()), sampled.metadata(), ResultFileUnitIdentity.fromCustom(tableDefinition.custom()), units.resultUnitIdentityY())); + else if (fact.source() instanceof MeasurementResultMemberFacts.CanSource can) + fileTargets.add(MeasurementResultFileMetadata.Target.can(row.getId(), + new MeasurementResultFileMetadata.Key(result.getPrimaryCode(), result.getHash(), member.vchId(), + units.unitX(), units.unitY()), can.channel(), ResultFileUnitIdentity.fromCustom(tableDefinition.custom()), units.resultUnitIdentityY())); requirements.add(new ResultRequirement(result.getId(), result.getPrimaryCode(), result.getHash(), MeasureProviderInputs.jsonMap(result.getVariableParameters()), channel.getVchId(), units.unitX(), units.unitY(), new com.opentest.dashboard.api.result.ResultExecutionFacts( @@ -687,7 +737,7 @@ void compileMeasurement(com.opentest.dashboard.api.measurement.PipelinePlan plan var fileTargets = frozenOutputs.fileTargets(); var graphics = frozenOutputs.graphics(); var rawChannels = MeasureProviderInputs.channels(getDashboardExecutionChannelsSnapshot().stream() - .filter(channel -> !channel.isMathChannel()).toList()); + .filter(channel -> !channel.isMathChannel() && !ChannelSourceEnum.isCan(channel.getChannelSource())).toList()); var available = new LinkedHashMap(); input.forEach(channel -> available.put(channel.vchId(), channel)); rawChannels.forEach(channel -> available.putIfAbsent(channel.vchId(), channel)); @@ -704,7 +754,8 @@ void compileMeasurement(com.opentest.dashboard.api.measurement.PipelinePlan plan sharedStageWitness = providerFileService.freezeSharedStageWitness(getDashboard().getProjectId(), getDashboardId(), getDashboard().getProviderId()); if (!stageArtifactTargets.inputCopyTargets().isEmpty() && measurementSession.relatedFiles() != null) measurementSession.relatedFiles().includePreparedInputCopyTargets(stageArtifactTargets.inputCopyTargets()); - var completedTargets = new MeasurementCompletedTargetPolicy(requirements, snapshots.resultDtos(), memberFacts, fileAliases.aliases()); + var completedTargets = new MeasurementCompletedTargetPolicy(requirements, snapshots.resultDtos(), memberFacts, + fileAliases.aliases(), graphics); var display = new CompletedGraphicResultPublisher(this, getDashboardExecutionChannelsSnapshot()); measurementCompletedDisplay = display; measurementRuntimeLimits = runtimeLimitJudgments == null ? null : new ProviderRuntimeLimitFrames( @@ -780,7 +831,7 @@ private void observe(CompletedResultCurve curve, long generation, boolean append if (persistenceScope != ResultPersistenceScope.NONE) { RecordedWaveformPlanDto waveformPlan = persistenceScope == ResultPersistenceScope.CURRENT_REQUEST && BuiltinDashboardProvider.MONITOR.getProviderId().equals(getDashboard().getProviderId()) - ? RecordedWaveformPlans.selected(getDashboardSelectedChannelsSnapshot()) : null; + ? selectedWaveformPlan() : null; preparedRecordedWaveformPlan = waveformPlan; waveformFiles = new ProviderWaveformFileOutput(this, this::resolveInternalStoragePath, rawInputs, waveformPlan, waveformPlan == null ? null : receipts -> mutateExecutionSnapshot(snapshot -> { @@ -873,7 +924,11 @@ private void observe(CompletedResultCurve curve, long generation, boolean append } }); } - capabilities.put(PipelineStopCoordinator.class, (PipelineStopCoordinator) failed -> { inputControl.requestClose(); return List.of(); }); + capabilities.put(PipelineStopCoordinator.class, (PipelineStopCoordinator) failed -> { + try { closeCanInputs(failed ? new IllegalStateException("Measurement pipeline failed before CAN completion") : null); } + finally { inputControl.requestClose(); } + return List.of(); + }); capabilities.put(TaskTimeMapper.class, (TaskTimeMapper) (id, position) -> { var channel = pipelineInputs.stream().filter(value -> value.vchId().equals(id)).findFirst().orElseThrow(); Long origin = origins.get(id); @@ -888,6 +943,25 @@ private void observe(CompletedResultCurve curve, long generation, boolean append if (capabilities.containsKey(type)) authorCapabilities.put(type, capabilities.get(type)); } compiledServices = Map.copyOf(authorCapabilities); + canPersistenceScope = persistenceScope; + if (canInputs != null) { + if (!canInputs.channels().channels().isEmpty() && artifacts != null + && !artifacts.isResultPersistenceSuppressed()) { + canNumericFiles = PersistResultSinkProcessor.createFileOutput(executionOutputs.projectId(), + executionOutputs.dashboardId(), executionOutputs.requestId(), List.of(), + PersistResultSinkProcessor.Layout.FRAMED, ResultFileUnitRules.fromRequirements(requirements), persistenceScope); + canNumericFiles.start(new ProcessorContext() { + @Override public void emit(Void ignored) { throw new UnsupportedOperationException("CAN file output has no downstream"); } + @Override public void requestStop() { requestInputStop(); } + @Override public T requireCapability(Class type) { + var value = capabilities.get(type); + if (value == null) throw new IllegalStateException("Missing CAN output capability: " + type.getName()); + return type.cast(value); + } + }, artifacts); + } + canInputs.bind(executionOutputs, (LiveResultOutput) capabilities.get(LiveResultOutput.class)); + } var builder = plan.bind(executionOutputs); try { pipeline = ProcessorPipelineCompiler.create().compile(builder, @@ -903,7 +977,8 @@ private void observe(CompletedResultCurve curve, long generation, boolean append inputControl.requestClose(); var stagesReleased = captureStages == null ? CompletableFuture.completedFuture(null) : captureStages.closeAsync().toCompletableFuture(); - CompletableFuture.allOf(pipeline.resourcesReleased().toCompletableFuture(), inputControl.closed(), stagesReleased) + var canReleased = canInputs == null ? CompletableFuture.completedFuture(null) : canInputs.released(); + CompletableFuture.allOf(pipeline.resourcesReleased().toCompletableFuture(), inputControl.closed(), stagesReleased, canReleased) .whenComplete((closed, closeFailure) -> { if (closeFailure == null) resourcesReleased.complete(null); else resourcesReleased.completeExceptionally(closeFailure); }); @@ -978,10 +1053,13 @@ private List runtimeJudgmentSources(Measureme void releaseUnpublishedMeasurement() { closing.set(true); + Throwable canFailure = null; + try { closeCanInputs(preparationFailure); } + catch (Throwable failure) { canFailure = failure; } synchronized (preparationLock) { - Throwable requestFailure = null; + Throwable requestFailure = canFailure; try { if (inputControl != null) inputControl.requestClose(); } - catch (Throwable failure) { requestFailure = failure; } + catch (Throwable failure) { requestFailure = mergeStopFailure(requestFailure, failure); } // Attempt both independent closures; an input failure must not leave the pipeline running. try { if (pipeline != null) pipeline.stop(); } catch (Throwable failure) { requestFailure = mergeStopFailure(requestFailure, failure); } @@ -999,6 +1077,7 @@ void releaseUnpublishedMeasurement() { } } void requestMeasurementFailure(Throwable failure) { + if (canInputs != null) canInputs.stopFailure(failure); if (measurementSession != null && measurementSession.hasAttachedTransport()) notifyProviderFailure(new IllegalStateException("Measurement execution failed", failure)); else CompletableFuture.runAsync(() -> failPrepared(new com.opentest.common.exception.CryBusinessException( @@ -1242,9 +1321,18 @@ public void acceptFileFrame(ChannelFrame frame) { nextSamples.put(id, end); } @Override protected double getRecordTime() { + if (input.isEmpty() && canInputs != null && !canInputs.channels().channels().isEmpty()) { + return formalRecordingElapsedMillis(); + } if (captureStages != null) return stagedDuration; if (waveformFiles != null && waveformFiles.durationMillis().isPresent()) return waveformFiles.durationMillis().getAsDouble(); - if (inputMode != PipelineInputMode.DIRECT) return super.getRecordTime(); + if (inputMode != PipelineInputMode.DIRECT) { + var manager = getChannelListenerManager(); + if (manager == null) return 0; + return preparedProviderChannels.stream().mapToDouble(channel -> + manager.getChannelProcessedSizeMap().getOrDefault(channel.getId(), 0L) * 1000D / channel.getSamplingRate()) + .max().orElse(0); + } return input.stream().mapToDouble(channel -> (nextSamples.getOrDefault(channel.vchId(), origins.getOrDefault(channel.vchId(), 0L)) - origins.getOrDefault(channel.vchId(), 0L)) * 1000D / channel.sampleRate()).max().orElse(0); } @@ -1314,7 +1402,7 @@ public void preparePipeline() { private List preparedProviderChannels; @Override protected List resolveDashboardChannels() { if (preparedProviderChannels != null) return preparedProviderChannels; - return measurementInputs == null ? super.resolveDashboardChannels() : measurementInputs.selected(); + return measurementInputs == null ? super.resolveDashboardChannels() : measurementInputs.sampledSelected(); } @Override protected List additionalListenerChannels() { @@ -1325,7 +1413,7 @@ private List providerInputChannels() { var facts = Objects.requireNonNull(measurementInputs, "Bound measurement inputs"); var channels = !isContinuousDisplayExecution() && !captureStageInput && BuiltinDashboardProvider.MONITOR.getProviderId().equals(getDashboard().getProviderId()) - ? facts.selected() : facts.captureDependencies(); + ? facts.sampledSelected() : facts.captureDependencies(); return channels.stream().map(channel -> Objects.requireNonNull(facts.channels().get(channel.getVchId()), "Execution input metadata")).toList(); } @@ -1462,17 +1550,160 @@ private void requestPackageStop() { if (captureStageInput && (captureAdmission == null || captureAdmissionOpened)) startFormalMeasurement(); } /** 共享 reader 已就绪;所有 Provider 都收到同一资源事实,不决定业务停止策略。 */ - public void markCaptureRuntimeReady() { recordingLifecycle.ready(); } + public void markCaptureRuntimeReady() { + captureRuntimeReady = true; + recordingLifecycle.ready(); + tryStartCanFormalRecording(); + } + + @Override public void setRecordStartEnabled(boolean enabled) { + super.setRecordStartEnabled(enabled); + if (enabled) tryStartCanFormalRecording(); + } + + private void tryStartCanFormalRecording() { + if (captureRuntimeReady && isRecordStartEnabled() && hasEventOnlyMeasurementInputs() + && canInputs != null && !canInputs.channels().channels().isEmpty()) startFormalMeasurement(); + } + + private boolean hasEventOnlyMeasurementInputs() { + return measurementInputs != null && !measurementInputs.selected().isEmpty() + && measurementInputs.sampledSelected().isEmpty() + && !measurementInputs.selectedCanChannels().isEmpty() + && measurementInputs.captureDependencies().isEmpty() && input.isEmpty(); + } + + @Override public View timeStopCompletionView() { + if (!hasEventOnlyMeasurementInputs()) return SampleDriven.INSTANCE; + if (!canClockRunning) return CanAwaitingStart.INSTANCE; + return new CanElapsed(formalRecordingElapsedMillis()); + } + + protected long recordingNanoTime() { return System.nanoTime(); } + + private double formalRecordingElapsedMillis() { + if (!formalRecordingEpochPublished) return 0; + long end = formalRecordingEnded ? formalRecordingEndNanos : recordingNanoTime(); + return Math.max(0, end - formalRecordingOriginNanos) / 1_000_000d; + } public Long getExpectedCompletionDurationMs() { return recordingLifecycle.expectedDuration(); } @Override public void afterSharedCaptureStopped(boolean successful) { recordingLifecycle.stopped(successful); } private final AtomicBoolean formalMeasurementStarted = new AtomicBoolean(); + + private void attachCanRecording() { + if (canInputs == null || canInputs.channels().channels().isEmpty() + || canPersistenceScope != ResultPersistenceScope.CURRENT_REQUEST) return; + var snapshots = new FlowExecuteSnapshotMutator() { + @Override public FlowExecuteSnapshotDataDto read(Long requestId) { + requireRequest(requestId); + return mutateExecutionSnapshot(snapshot -> { }); + } + @Override public FlowExecuteSnapshotDataDto mutate(Long requestId, Consumer mutation) { + requireRequest(requestId); + return mutateExecutionSnapshot(mutation); + } + private void requireRequest(Long requestId) { + if (!hasExecutionRecord() || !Objects.equals(getRequestId(), requestId)) + throw new IllegalStateException("CAN recording has no formal request owner"); + } + }; + var recording = new CanRecordedInputStore(providerFileService, snapshots).open( + Path.of(resolveInternalStoragePath()), getRequestId(), canInputs.channels()); + try { canInputs.attachRecording(recording, () -> input.isEmpty() && !canClockRunning ? 0 : getRecordTime() / 1000D); } + catch (RuntimeException | Error failure) { + try { recording.fail(failure); } + catch (RuntimeException | Error publicationFailure) { failure.addSuppressed(publicationFailure); } + throw failure; + } + } + + private void closeCanInputs(Throwable failure) { + if (formalRecordingEpochPublished && !formalRecordingEnded) { + formalRecordingEndNanos = recordingNanoTime(); + formalRecordingEnded = true; + } + Throwable closeFailure = null; + try { + if (canInputs != null) { canInputs.stopFailure(failure); canInputs.close(); } + } catch (RuntimeException | Error problem) { closeFailure = problem; } + try { if (canNumericFiles != null) canNumericFiles.close(); } + catch (RuntimeException | Error problem) { closeFailure = mergeStopFailure(closeFailure, problem); } + if (closeFailure instanceof RuntimeException problem) throw problem; + if (closeFailure instanceof Error problem) throw problem; + } + + static final class CanNumericProjection implements CanSignalProjection { + private final CanSignalProjection projection; + private final PersistResultSinkProcessor.FileOutput files; + private double recordingSeconds; + + CanNumericProjection(CanSignalProjection.Factory factory, CanChannelFacts channels, ExecutionOutputs outputs, + LiveResultOutput live, PersistResultSinkProcessor.FileOutput files) { + this.files = files; + projection = Objects.requireNonNull(factory.create(channels, outputs, new LiveResultOutput() { + @Override public void publish(CompletedResultCurve curve, long generation, boolean append) { + persist(curve); live.publish(curve, generation, append); + } + @Override public void observe(CompletedResultCurve curve, boolean append) { + persist(curve); live.observe(curve, append); + } + private void persist(CompletedResultCurve curve) { + if (files == null || outputs.results().stream().noneMatch(result -> + channels.channels().containsKey(result.vchId()) + && Objects.equals(result.dashboardResultId(), curve.dashboardResultId()) + && result.resultCode().equals(curve.resultCode()) && result.hash().equals(curve.uniqueKey()) + && result.vchId().equals(curve.channelId()) + && Objects.equals(result.requestedUnitX(), curve.unitX()) + && Objects.equals(result.requestedUnitY(), curve.unitY()))) return; + double[] x = curve.x(); + if (x == null) { + if (curve.y().length != 1) throw new IllegalArgumentException("CAN scalar requires one value"); + x = new double[]{recordingSeconds}; + } + var source = ResultFrame.explicitX(curve.resultCode(), curve.uniqueKey(), curve.channelId(), + curve.unitX(), curve.unitY(), x, curve.y(), recordingSeconds * 1000D, null); + try { + var frame = source.withDashboardResultId(curve.dashboardResultId()); + try { files.accept(frame); } + finally { frame.release(); } + } finally { source.release(); } + } + }), "CAN projection"); + } + @Override public void accept(CanSignalBatch batch) { + recordingSeconds = batch.observationElapsedSeconds(); + projection.accept(batch); + } + @Override public void close() { + Throwable failure = null; + try { projection.close(); } + catch (RuntimeException | Error problem) { failure = problem; } + try { if (files != null) files.close(); } + catch (RuntimeException | Error problem) { failure = mergeStopFailure(failure, problem); } + if (failure instanceof RuntimeException problem) throw problem; + if (failure instanceof Error problem) throw problem; + } + } + private void startFormalMeasurement() { if (closing.get() || captureAdmission != null && !captureAdmissionOpened || !formalMeasurementStarted.compareAndSet(false, true)) return; if (measurementSession != null) measurementSession.captureStarted(); recordingLifecycle.started(); - recordStartFromPipeline(input.getFirst().vchId()); + String anchor = input.isEmpty() ? measurementInputs.selected().getFirst().getVchId() : input.getFirst().vchId(); + recordStartFromPipeline(anchor); if (executionStates != null) executionStates.started(); + if (closing.get() || !Boolean.FALSE.equals(getFinished())) return; + formalRecordingOriginNanos = recordingNanoTime(); + formalRecordingEpochPublished = true; + try { + attachCanRecording(); + if (canInputs != null) canInputs.start(); + canClockRunning = true; + } catch (RuntimeException | Error failure) { + requestMeasurementFailure(failure); + throw failure; + } if (!Boolean.FALSE.equals(getFinished())) return; } private void applyCaptureGate(boolean armed) { @@ -1493,11 +1724,20 @@ private void applyCaptureGate(boolean armed) { @Override public List getPhysicalWaveformSourceChannelsSnapshot() { if (captureStageInput && stageRecording != null) return List.copyOf(stageRecordingSources); if (isWavOnlyRecordingPlan()) { - return new ArrayList<>(getCalculationPlan().getWaveformSourceChannels()); + return getCalculationPlan().getWaveformSourceChannels().stream() + .filter(channel -> !ChannelSourceEnum.isCan(channel.getChannelSource())).toList(); } if (getDashboard() == null || !BuiltinDashboardProvider.MONITOR.getProviderId().equals(getDashboard().getProviderId())) return super.getPhysicalWaveformSourceChannelsSnapshot(); - return getDashboardExecutionChannelsSnapshot().stream().filter(channel -> !channel.isMathChannel()).toList(); + return getDashboardExecutionChannelsSnapshot().stream().filter(channel -> !channel.isMathChannel() + && !ChannelSourceEnum.isCan(channel.getChannelSource())).toList(); + } + + RecordedWaveformPlanDto selectedWaveformPlan() { + var selected = frozenMeasurementInputs().selected(); + var sampled = selected.stream().filter(channel -> !ChannelSourceEnum.isCan(channel.getChannelSource())).toList(); + if (sampled.isEmpty() && !selected.isEmpty()) return null; + return RecordedWaveformPlans.selected(sampled); } @Override protected FilterContext createFilterContext() { return new FilterContext(); } @@ -1506,8 +1746,10 @@ private void applyCaptureGate(boolean armed) { @Override protected List createChannelListeners(List channels) { preparePipeline(); var listening = new LinkedHashMap(); - channels.forEach(channel -> listening.put(channel.getVchId(), channel)); - getDashboardExecutionChannelsSnapshot().stream().filter(channel -> !channel.isMathChannel()) + channels.stream().filter(channel -> !ChannelSourceEnum.isCan(channel.getChannelSource())) + .forEach(channel -> listening.put(channel.getVchId(), channel)); + getDashboardExecutionChannelsSnapshot().stream().filter(channel -> !channel.isMathChannel() + && !ChannelSourceEnum.isCan(channel.getChannelSource())) .forEach(channel -> listening.putIfAbsent(channel.getVchId(), channel)); return List.of(new ChannelListener() { public List getChannelIds() { return listening.values().stream().map(ChannelDto::getId).toList(); } @@ -1580,6 +1822,9 @@ private void finishPipelineStop() { @Override protected void closeRuntimeResourcesForStop() { closing.set(true); + Throwable canFailure = null; + try { closeCanInputs(null); } + catch (Throwable failure) { canFailure = failure; } if (captureStages != null) { try { captureStages.close(); } catch (RuntimeException | Error failure) { resourcesReleased.completeExceptionally(failure); } @@ -1595,9 +1840,12 @@ private void finishPipelineStop() { resourcesReleased.complete(null); } } + if (canFailure instanceof RuntimeException failure) throw failure; + if (canFailure instanceof Error failure) throw failure; } // Waiting for the author must never retain this handler's monitor (snapshot writers also use it). @Override public void stop(com.opentest.common.exception.CryBusinessException failure) { + if (canInputs != null) canInputs.stopFailure(failure); if (measurementSession == null) { super.stop(failure); return; } if (failure != null) { markPhysicalWaveformRecordingFailed(); markFinalMeasurementIntervalInvalid(); } if (failure != null && pipeline != null) pipeline.fail(failure); @@ -1610,6 +1858,7 @@ private void finishPipelineStop() { settleMeasurementStop(null); } @Override public void failPrepared(com.opentest.common.exception.CryBusinessException failure) { + if (canInputs != null) canInputs.stopFailure(failure); if (measurementSession == null) { super.failPrepared(failure); return; } markPhysicalWaveformRecordingFailed(); markFinalMeasurementIntervalInvalid(); if (failure != null && pipeline != null) pipeline.fail(failure); diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/provider/ProviderWaveformFileOutput.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/provider/ProviderWaveformFileOutput.java index 61c1b8ec..55f798e9 100644 --- a/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/provider/ProviderWaveformFileOutput.java +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/provider/ProviderWaveformFileOutput.java @@ -1,6 +1,7 @@ package com.opentest.service.grpc.provider; import com.opentest.common.model.dto.ChannelDto; +import com.opentest.common.enums.ChannelSourceEnum; import com.opentest.common.model.dto.RecordedWaveformPlanDto; import com.opentest.common.model.dto.RecordedWaveformPlanDto.Stage; import com.opentest.service.recording.RecordingWaveformSamples; @@ -61,7 +62,8 @@ final class ProviderWaveformFileOutput implements WaveformFileOutput { this.committed = committed; this.commitFacts = commitFacts; this.commitLock = commitLock; - if (plan == null) owner.getDashboardExecutionChannelsSnapshot().stream().filter(channel -> !channel.isMathChannel()) + if (plan == null) owner.getDashboardExecutionChannelsSnapshot().stream().filter(channel -> !channel.isMathChannel() + && !ChannelSourceEnum.isCan(channel.getChannelSource())) .forEach(channel -> { channels.put(channel.getVchId(), channel); stages.put(channel.getVchId(), Stage.PHYSICAL_ORIGINAL); }); else plan.validatedMembers(false).forEach(member -> { channels.put(member.getChannel().getVchId(), member.getChannel()); diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/replay/RecordedCanSignalInputs.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/replay/RecordedCanSignalInputs.java new file mode 100644 index 00000000..7e28b0eb --- /dev/null +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/replay/RecordedCanSignalInputs.java @@ -0,0 +1,84 @@ +package com.opentest.service.grpc.replay; + +import com.opentest.dashboard.api.capability.CanChannelFacts; +import com.opentest.dashboard.api.capability.CanSignalInputs; +import com.opentest.dashboard.api.capability.CanSignalProjection; +import com.opentest.dashboard.api.capability.CanSignalBatch; +import com.opentest.dashboard.api.capability.CanSignalEvent; +import com.opentest.dashboard.api.capability.LiveResultOutput; +import com.opentest.dashboard.api.measurement.ExecutionOutputs; +import com.opentest.service.recording.measurement.CanRecordedFacts; +import java.util.Objects; +import java.util.Map; + +/** Existing CAN capability backed entirely by a registered frozen request file. */ +public final class RecordedCanSignalInputs implements CanSignalInputs, AutoCloseable { + private final CanRecordedFacts facts; + private CanSignalProjection.Factory factory; + private CanSignalProjection projection; + private ExecutionOutputs outputs; + private LiveResultOutput output; + private int cursor; + private double progress = -1; + private double currentSeconds; + private boolean closed; + + public RecordedCanSignalInputs(CanRecordedFacts facts) { this.facts = Objects.requireNonNull(facts); } + @Override public CanChannelFacts channels() { return facts.channels(); } + public double durationSeconds() { return facts.durationSeconds(); } + public double currentSeconds() { return currentSeconds; } + + @Override public synchronized void projectWith(CanSignalProjection.Factory factory) { + if (closed || this.factory != null || outputs != null) throw new IllegalStateException("Repeated or late recorded CAN projection"); + this.factory = Objects.requireNonNull(factory); + } + + public synchronized void bind(ExecutionOutputs outputs, LiveResultOutput output) { + if (closed || this.outputs != null) throw new IllegalStateException("Repeated recorded CAN binding"); + this.outputs = Objects.requireNonNull(outputs); this.output = Objects.requireNonNull(output); + projection = Objects.requireNonNull(factory, "Recorded CAN projection factory").create(channels(), outputs, output); + initializeMissingValues(); + } + + public synchronized void seek(double recordingSeconds) { + requireBound(); + projection.close(); + projection = factory.create(channels(), outputs, output); + cursor = 0; progress = -1; + currentSeconds = 0; + initializeMissingValues(); + advance(recordingSeconds); + } + + public synchronized void advance(double recordingSeconds) { + requireBound(); + if (!Double.isFinite(recordingSeconds) || recordingSeconds < 0 || recordingSeconds < progress) + throw new IllegalArgumentException("Recorded CAN progress must be finite and monotonic; use seek to rewind"); + var batches = facts.batches(); + while (cursor < batches.size()) { + var batch = batches.get(cursor); + double mapped = facts.recordingSeconds(batch.observationElapsedSeconds()); + if (mapped > recordingSeconds) break; + currentSeconds = mapped; + projection.accept(new CanSignalBatch(mapped, batch.events())); + cursor++; + } + progress = recordingSeconds; + } + + private void requireBound() { + if (closed || projection == null) throw new IllegalStateException("Recorded CAN projection is not bound"); + } + + private void initializeMissingValues() { + var missing = channels().channels().keySet().stream().map(id -> + new CanSignalEvent.InvalidState(id, CanSignalEvent.InvalidReason.NO_DATA, Map.of())).toList(); + projection.accept(new CanSignalBatch(0, missing)); + } + + @Override public synchronized void close() { + if (closed) return; + closed = true; + if (projection != null) projection.close(); + } +} diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/replay/RecordedMeasurementReplayPlanner.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/replay/RecordedMeasurementReplayPlanner.java index e65f7a0c..e965feb3 100644 --- a/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/replay/RecordedMeasurementReplayPlanner.java +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/replay/RecordedMeasurementReplayPlanner.java @@ -2,8 +2,11 @@ import com.opentest.dashboard.api.measurement.recorded.RecordedInputMode; import com.opentest.common.enums.ResultStorageModeEnum; +import com.opentest.common.enums.ChannelSourceEnum; import com.opentest.common.model.dto.RecordedWaveformPlanDto; import java.io.IOException; +import java.nio.file.Path; +import com.opentest.service.snapshot.FlowExecuteSnapshotMutator; import com.opentest.service.export.dashboard.DashboardExportRequirement; import org.springframework.beans.BeanUtils; @@ -63,6 +66,7 @@ public class RecordedMeasurementReplayPlanner { private final VirtualChannelExecutionChannelResolver virtualChannels; @Resource private UnitConversionService unitConversions; @Resource private ProjectTriggerFacts triggerFacts; + @Resource private FlowExecuteSnapshotMutator snapshotMutator; RecordedMeasurementReplayPlanner(FlowExecuteResultMapper histories,DashboardResultMapper results, RecordedMeasurementInputs inputs,PluginMeasureExecutor plugins,DashboardReplayExecutionCoordinator coordinator, @@ -155,8 +159,9 @@ private String previewExportFileUnitY(long requestId,long resultId,String member plugins.validateRecordedMeasurementPlan(saved.providerId(),null,saved.configuration(), ExecutionInputPurpose.RECORDED_GRAPHIC_EXPORT,List.of(identity)); if (plugins.recordedMeasurementInputMode(saved.providerId(),saved.configuration(),ExecutionInputPurpose.RECORDED_GRAPHIC_EXPORT) - != RecordedInputMode.PROVIDER_FACTS) inputs.admit(history,caller); - var fact=resolveSavedMember(resultId,members.getFirst(),saved.channels()); + != RecordedInputMode.PROVIDER_FACTS && (!saved.channels().isEmpty() || saved.canChannels().channels().isEmpty())) + inputs.admit(history,caller); + var fact=resolveSavedMember(resultId,members.getFirst(),saved); UnitCombination display=requestedDisplay; if(display==null) { var bindings=graphic.getResultCodes()==null?List.of():graphic.getResultCodes().stream() @@ -173,7 +178,7 @@ private String previewExportFileUnitY(long requestId,long resultId,String member display=savedUnits(fact.declaredUnits(),display.unitX(),display.unitY(),display.resultUnitIdentityY()); if(!fact.declaredUnits().combinations().contains(display)) throw invalid("Recorded export display units are outside the saved member declaration"); - var target=new RecordedOutputSelection(identity,fact.metadata(),fact.declaredUnits(),display,graphic==null?null:graphic.getId(), + var target=recordedSelection(identity,fact,display,graphic==null?null:graphic.getId(), graphic==null?Map.of():JSON.convertValue(graphic,new TypeReference>(){})); var released=new java.util.concurrent.CompletableFuture(); try { @@ -197,14 +202,14 @@ public DashboardExportRequirement previewExportRequirement(long requestId,long r .orElseThrow(() -> invalid("Recorded result description is unavailable")); var selected=definition.channels().stream().filter(member -> memberId.equals(member.vchId())).toList(); if(selected.size()!=1)throw invalid("Recorded result member is missing or ambiguous"); - var fact=resolveSavedMember(resultId,selected.getFirst(),saved.channels()); + var fact=resolveSavedMember(resultId,selected.getFirst(),saved); var preferred=fact.declaredUnits().preferredCombination(); String y=requestedUnitY==null?preferred.unitY():requestedUnitY; var options=fact.declaredUnits().combinations().stream().filter(unit -> Objects.equals(y,unit.unitY())).toList(); var display=options.stream().filter(unit -> Objects.equals(preferred.unitX(),unit.unitX())).findFirst() .orElseGet(() -> {if(options.size()!=1)throw invalid("Recorded table display axis is ambiguous");return options.getFirst();}); String fileUnit=previewExportFileUnitY(requestId,resultId,memberId,display,caller); - var source=channel(fact.metadata(),selected.getFirst().channelDirection()==ChannelDirection.OUTPUT?1:0); + var source=channel(fact,selected.getFirst().channelDirection()==ChannelDirection.OUTPUT?1:0); var simple=new SimpleChannelDto();BeanUtils.copyProperties(source,simple);simple.setChannelName(selected.getFirst().displayName()); return new DashboardExportRequirement(null,resultId,memberId,memberId,row.getPrimaryCode(),definition.domainType().name(), display.unitX(),fileUnit,display.unitY(),simple,source); @@ -223,6 +228,20 @@ Prepared prepare(long requestId,RecordedCallScope caller,RecordedMeasurementLeas plugins.validateSavedMeasurementBinding(saved.providerId(),null,saved.configuration(),Map.of(),purpose); descriptions.requireReadable(saved.dashboard(), requestId); var inputMode=Objects.requireNonNull(plugins.recordedMeasurementInputMode(saved.providerId(),saved.configuration(),purpose)); + CanRecordedFacts canFacts = null; + if (!saved.canChannels().channels().isEmpty()) { + var snapshot = FlowExecuteSnapshotDataDto.parseJson(history.getSnapshotData()); + if (snapshot.getInternalStoragePath() == null) throw invalid("CAN history has no frozen internal storage root"); + try { + canFacts = new CanRecordedInputStore(files, snapshotMutator) + .read(Path.of(snapshot.getInternalStoragePath()), requestId, snapshot.getCanRecording()); + } catch (IllegalArgumentException error) { + var failure = invalid("Recorded CAN artifact differs from its frozen saved input"); + failure.initCause(error); + throw failure; + } + if (saved.channels().isEmpty()) inputMode = RecordedInputMode.PROVIDER_FACTS; + } var inputFacts=inputMode == RecordedInputMode.PROVIDER_FACTS ? List.of() : inputs.admit(history,caller); var otherOwners=new TreeSet(); for(var input:inputFacts) { @@ -247,7 +266,7 @@ Prepared prepare(long requestId,RecordedCallScope caller,RecordedMeasurementLeas var declared=definition.channels(); var matches=declared.stream().filter(member->member.vchId().equals(root.getChannelKey())).toList(); if(matches.size()!=1)throw invalid("Recorded result member is missing or ambiguous"); - var fact=resolveSavedMember(row.getId(),matches.getFirst(),saved.channels()); + var fact=resolveSavedMember(row.getId(),matches.getFirst(),saved); members.put(new MeasurementResultMemberFacts.Key(row.getId(),root.getChannelKey()),fact); var parameters=ProviderDashboardResultReader.savedParameterFacts(row); if(parameters==null)parameters=Map.of(); @@ -294,9 +313,9 @@ Prepared prepare(long requestId,RecordedCallScope caller,RecordedMeasurementLeas && Objects.equals(value.vchId(),root.getChannelKey()) && Objects.equals(value.unitX(),unit.unitX()) && Objects.equals(value.unitY(),unit.unitY())).toList(); var choices=new ArrayList(); - for(var target:chosen)choices.add(new RecordedOutputSelection(identity,fact.metadata(),fact.declaredUnits(),unit, + for(var target:chosen)choices.add(recordedSelection(identity,fact,unit, target.graphicId(),target.graphicConfig())); - if(choices.isEmpty())choices.add(new RecordedOutputSelection(identity,fact.metadata(),fact.declaredUnits(),unit,null,Map.of())); + if(choices.isEmpty())choices.add(recordedSelection(identity,fact,unit,null,Map.of())); pending.add(new PendingOutput(row,dto,fact, matches.getFirst().channelDirection() == ChannelDirection.OUTPUT ? 1 : 0, parameters,null,choices,definition.fileUnitIdentity())); @@ -320,7 +339,7 @@ Prepared prepare(long requestId,RecordedCallScope caller,RecordedMeasurementLeas choice.result().memberId(),fileUnits.unitX(),fileUnits.unitY(),target.executionFacts(),fileIdentities.get(row.getId()))); if(!availability.required())unavailable.put(requirements.getLast(),availability); var meta=GraphicDataMeta.builder().projectId(history.getProjectId()).dashboardId(history.getDashboardId()).requestId(requestId) - .channel(channel(target.fact().metadata(),target.channelIo())).unitX(fileUnits.unitX()) + .channel(channel(target.fact(),target.channelIo())).unitX(fileUnits.unitX()) .srcUnit(fileUnits.unitY()).destUnit(fileUnits.unitY()).build(); meta.setFileUnitIdentity(target.fileUnitIdentity()); meta.setResultUnitIdentity(fileUnits.resultUnitIdentityY()); @@ -335,6 +354,10 @@ Prepared prepare(long requestId,RecordedCallScope caller,RecordedMeasurementLeas var services=new HashMap,Object>(); services.put(ProjectTriggers.class, triggerFacts.legacy(saved.providerId(), saved.configuration())); services.put(SavedRecordingFacts.class,recording); + if (canFacts != null) { + services.put(CanChannelFacts.class, canFacts.channels()); + services.put(CanSignalInputs.class, new RecordedCanSignalInputs(canFacts)); + } services.put(ResultStorageMode.class, FlowExecuteSnapshotDataDto.parseJson(history.getSnapshotData()).resolveResultStorageMode() == ResultStorageModeEnum.WAV_ONLY ? ResultStorageMode.WAV_ONLY : ResultStorageMode.LEGACY); services.put(PlatformYUnitConverter.class, new ProviderYUnitConverter(unitConversions)); @@ -415,9 +438,12 @@ private static SavedRecordingFacts recordingFacts(FlowExecuteResult history, return new SavedRecordingFacts(facts,List.copyOf(channels.values())); } private static MeasurementResultMemberFacts.Fact resolveSavedMember(long resultId, - ResultChannelDefinition member,Map channels) { + ResultChannelDefinition member,SavedReplay saved) { new MeasurementResultMemberFacts.Key(resultId,member.vchId()); - var metadata=member.resultMetadata()==null?channels.get(member.vchId()):member.resultMetadata(); + var can = saved.canChannels().channels().get(member.vchId()); + if (can != null) return new MeasurementResultMemberFacts.Fact(member, + new MeasurementResultMemberFacts.CanSource(can), Objects.requireNonNull(member.declaredUnits(), "Frozen CAN member units")); + var metadata=member.resultMetadata()==null?saved.channels().get(member.vchId()):member.resultMetadata(); if(metadata==null)throw invalid("Recorded result member has no saved channel facts"); var units=member.declaredUnits(); if(units==null)throw invalid("Recorded result member has no declared units"); @@ -455,17 +481,48 @@ private SavedReplay saved(FlowExecuteSnapshotDataDto snapshot) { .orElseThrow(()->invalid("Saved measurement input interpretation is unavailable")); var selected=SavedMeasurementInputFacts.readExecutionInputs(interpreter,configuration); var available=snapshot.getVirtualChannelExecutionChannels(); + var canChannels = new LinkedHashMap(); + if (snapshot.getCanRecording() != null) { + if (snapshot.getCanRecording().getVersion() != 1) throw invalid("Unsupported CAN recording version"); + snapshot.getCanRecording().getChannels().forEach((id, value) -> + canChannels.put(id, JSON.convertValue(value, CanSignalChannel.class))); + } + for (var channel : selected) if (ChannelSourceEnum.isCan(channel.getChannelSource()) + && !canChannels.containsKey(channel.getVchId())) + throw invalid("Selected CAN input has no frozen event recording"); + var sampledSelected = selected.stream().filter(channel -> !ChannelSourceEnum.isCan(channel.getChannelSource())).toList(); + var sampledAvailable = available == null ? sampledSelected : available.stream() + .filter(channel -> !ChannelSourceEnum.isCan(channel.getChannelSource())).toList(); var waveformPlan = snapshot.getRecordedWaveformPlan(); var execution = waveformPlan == null - ? virtualChannels.resolve(selected,available==null||available.isEmpty()?selected:available) + ? virtualChannels.resolve(sampledSelected,sampledAvailable.isEmpty()?sampledSelected:sampledAvailable) : waveformPlan.validatedMembers(true).stream().map(RecordedWaveformPlanDto.Member::getChannel).toList(); var metadata=new LinkedHashMap(); - execution.forEach(channel->metadata.put(channel.getVchId(), - MeasureProviderInputs.channel(channel))); - return new SavedReplay(dashboard,providerId,configuration,List.copyOf(execution),Map.copyOf(metadata)); + execution.forEach(channel -> { + if (ChannelSourceEnum.isCan(channel.getChannelSource())) + throw invalid("Recorded CAN replay requires the event recording format"); + metadata.put(channel.getVchId(), MeasureProviderInputs.channel(channel)); + }); + return new SavedReplay(dashboard,providerId,configuration,List.copyOf(execution),Map.copyOf(metadata),new CanChannelFacts(canChannels)); } private record SavedReplay(DashboardConfigDto dashboard,String providerId,Map configuration, - List executionChannels,Map channels) { } + List executionChannels,Map channels, CanChannelFacts canChannels) { } + private static RecordedOutputSelection recordedSelection(RecordedPlanSelection identity, + MeasurementResultMemberFacts.Fact fact, UnitCombination units, Long graphicId, Map graphic) { + if (fact.source() instanceof MeasurementResultMemberFacts.CanSource can) + return RecordedOutputSelection.can(identity,can.channel(),fact.declaredUnits(),units,graphicId,graphic); + return new RecordedOutputSelection(identity,fact.metadata(),fact.declaredUnits(),units,graphicId,graphic); + } + private static ChannelDto channel(MeasurementResultMemberFacts.Fact fact,Integer direction) { + if (fact.source() instanceof MeasurementResultMemberFacts.CanSource can) { + var channel = new ChannelDto(); + channel.setVchId(can.channel().vchId());channel.setSourceVchId(can.channel().vchId()); + channel.setChannelName(can.channel().displayName());channel.setChannelIo(0); + channel.setChannelSource(ChannelSourceEnum.CAN.getValue());channel.setWaveformSourceUnit(can.channel().units().outputUnit()); + return channel; + } + return channel(fact.metadata(), direction); + } private static ChannelDto channel(ChannelMetadata source,Integer direction) { var channel=new ChannelDto();channel.setVchId(source.vchId());channel.setSourceVchId(source.vchId());channel.setChannelIo(direction); channel.setSamplingRate(source.sampleRate());channel.setVp(source.vp());channel.setSensitivity(source.signalType()==SignalType.VIBRATION?source.vibrationSensitivity():source.sensitivity()); diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/replay/RecordedMeasurementReplaySession.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/replay/RecordedMeasurementReplaySession.java index cfa6f350..38074b4e 100644 --- a/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/replay/RecordedMeasurementReplaySession.java +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/replay/RecordedMeasurementReplaySession.java @@ -16,6 +16,8 @@ import java.util.concurrent.CompletionStage; import java.util.function.BiConsumer; import com.opentest.dashboard.api.capability.CompletedResultOutput; +import com.opentest.dashboard.api.capability.CanSignalInputs; +import com.opentest.dashboard.api.capability.LiveResultOutput; import com.opentest.dashboard.api.capability.SavedResultDocuments; import com.opentest.dashboard.api.capability.ResultOutputConsumer; import com.opentest.dashboard.api.frame.ChannelFrame; @@ -45,6 +47,7 @@ final class RecordedMeasurementReplaySession implements PreparedRecordedExecutio private BiConsumer progress; private boolean started; private long lastPresentationMillis = -1; + private final RecordedCanSignalInputs canInputs; RecordedMeasurementReplaySession(RecordedMeasurementReplayPlan plan, PluginMeasureExecutor plugins, DashboardWavReplayRunner runner, Map, Object> exported, @@ -73,6 +76,7 @@ final class RecordedMeasurementReplaySession implements PreparedRecordedExecutio this.completed = Objects.requireNonNull(completed); this.interpretation = Objects.requireNonNull(interpretation); var services = new HashMap, Object>(Objects.requireNonNull(exported)); + canInputs = services.get(CanSignalInputs.class) instanceof RecordedCanSignalInputs recorded ? recorded : null; services.put(ResultOutputConsumer.class, (ResultOutputConsumer) this::acceptFrame); services.put(CompletedResultOutput.class, (CompletedResultOutput) this::acceptCompleted); var binding = new RecordedMeasurementExecution.Binding(plan.providerId(), null, @@ -87,6 +91,7 @@ final class RecordedMeasurementReplaySession implements PreparedRecordedExecutio runSource(input); } }, RecordedMeasurementExecution.Policy.replay(), storageSettlement); + if (canInputs != null) execution.own(canInputs); } @Override public void run(DashboardWavTimelineReader timeline, DashboardReplayCancellationToken cancellation, @@ -108,16 +113,35 @@ final class RecordedMeasurementReplaySession implements PreparedRecordedExecutio } private void runSource(RecordedMeasurementExecution.Input input) { + if (canInputs != null) canInputs.bind(plan.outputs(), new LiveResultOutput() { + @Override public void publish(CompletedResultCurve curve, long generation, boolean append) { observe(curve, append); } + @Override public void observe(CompletedResultCurve curve, boolean append) { + double[] x = curve.x() == null ? new double[]{canInputs.currentSeconds()} : curve.x().clone(); + var base = ResultFrame.explicitX(curve.resultCode(), curve.uniqueKey(), curve.channelId(), + curve.unitX(), curve.unitY(), x, curve.y().clone(), canInputs.currentSeconds() * 1000, null); + var frame = base.withDashboardResultId(Objects.requireNonNull(curve.dashboardResultId())); + base.release(); + try { acceptFrame(frame); } finally { frame.release(); } + } + }); if (plan.inputMode() == RecordedInputMode.PROVIDER_FACTS) { - input.checkActive(); input.finish(true); return; + input.checkActive(); + finishCanReplay(); + input.finish(true); return; } runner.run(new RecordedFrameRuntime() { @Override public void acceptPhysical(ChannelDto channel, CaptureData frame) { acceptInput(input, channel, frame); } - @Override public long replayProgressMillis(long rawMillis) { return presentationMillis(rawMillis); } - @Override public void close(boolean success) { input.finish(success); } + @Override public long replayProgressMillis(long rawMillis) { + if (canInputs != null) canInputs.advance(rawMillis / 1000d); + return presentationMillis(rawMillis); + } + @Override public void close(boolean success) { + if (success) finishCanReplay(); + input.finish(success); + } @Override public void readerClosed(Throwable failure) { if (failure != null) input.cleanupFailed(failure); } @@ -129,6 +153,14 @@ private void runSource(RecordedMeasurementExecution.Input input) { } } + private void finishCanReplay() { + if (canInputs == null) return; + cancellation.throwIfCancellationRequested(); + canInputs.advance(Math.max(canInputs.durationSeconds(), Math.max(0, lastPresentationMillis) / 1000d)); + if (progress != null) progress.accept(100, Math.max(Math.round(canInputs.durationSeconds() * 1000), lastPresentationMillis)); + canInputs.close(); + } + private long presentationMillis(long rawMillis) { long value = interpretation.progressMillis(rawMillis); if (value < 0 || value < lastPresentationMillis) diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/replay/RecordedResultMembers.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/replay/RecordedResultMembers.java index 4bb1ffb5..bd64ad84 100644 --- a/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/replay/RecordedResultMembers.java +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/grpc/replay/RecordedResultMembers.java @@ -1,6 +1,7 @@ package com.opentest.service.grpc.replay; import com.opentest.common.model.dto.FlowExecuteSnapshotDataDto; +import com.opentest.common.enums.ChannelSourceEnum; import com.opentest.service.dashboard.framework.BoundMeasurementInputs; import com.opentest.service.dashboard.framework.MeasurementResultMemberFacts; import java.util.List; @@ -22,7 +23,13 @@ record Member(ResultChannelDefinition declaration, String sourceId) { } static Member resolve(FlowExecuteSnapshotDataDto snapshot, long requestId, long dashboardId, long resultId, ResultSetDefinition definition, String memberId, BoundMeasurementInputs inputs) { var direct = definition.channels().stream().filter(value -> value.vchId().equals(memberId)).toList(); - if (direct.size() == 1) return new Member(direct.getFirst(), memberId); + if (direct.size() == 1) { + if (inputs.canChannels().channels().containsKey(memberId) + || inputs.availableInputs().stream().anyMatch(row -> memberId.equals(row.getVchId()) + && ChannelSourceEnum.isCan(row.getChannelSource()))) + throw new IllegalArgumentException("Recorded CAN replay requires the event recording format"); + return new Member(direct.getFirst(), memberId); + } if (!direct.isEmpty()) throw new IllegalArgumentException("Ambiguous saved result member"); var sequence = DerivedResultChannelSequence.fromCustom(definition.custom()); if (sequence == null || snapshot.getDynamicResultChannelBatches() == null) @@ -40,7 +47,7 @@ static Member resolve(FlowExecuteSnapshotDataDto snapshot, long requestId, long throw new IllegalArgumentException("Recorded dynamic member has no frozen source binding"); var source = sources.getFirst(); var fact = MeasurementResultMemberFacts.resolve(resultId, source, inputs, source.declaredUnits()); - var metadata = fact.metadata(); + var metadata = sampled(fact); var derived = new ChannelMetadata(memberId, metadata.signalType(), metadata.sampleRate(), metadata.waveformUnit(), metadata.sensitivity(), metadata.vp(), metadata.vibrationSensitivity(), true, metadata.gain(), metadata.charge(), metadata.inputOverloadThreshold(), channel.getChannelName(), memberId, metadata.hardware(), @@ -54,6 +61,11 @@ static Member resolve(FlowExecuteSnapshotDataDto snapshot, long requestId, long new ResultChannelUnitFacts(metadata.signalType(), channel.getUnitY(), fact.declaredUnits())), source.vchId()); } + static ChannelMetadata sampled(MeasurementResultMemberFacts.Fact fact) { + if (fact.source() instanceof MeasurementResultMemberFacts.SampledSource source) return source.metadata(); + throw new IllegalArgumentException("Recorded CAN replay requires the event recording format"); + } + static List requirements(List saved, long resultId, String code, String hash, String memberId, Member member) { return saved.stream().filter(value -> Objects.equals(value.dashboardResultId(), resultId) diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/jni/UnitConversionService.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/jni/UnitConversionService.java index 9e883929..bad519c7 100644 --- a/apps/backend/crydaq-service/src/main/java/com/opentest/service/jni/UnitConversionService.java +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/jni/UnitConversionService.java @@ -10,6 +10,8 @@ import com.opentest.common.constants.CryDaqConstant; import com.opentest.common.enums.CalculateResultsEnum; import com.opentest.common.enums.ChannelTypeEnum; +import com.opentest.common.enums.ChannelSourceEnum; +import com.opentest.service.can.CanStoredUnitConversion; import com.opentest.common.enums.UnitEnum; import com.opentest.common.exception.CryBusinessException; import com.opentest.common.exception.ErrorCode; @@ -255,6 +257,8 @@ private Map toUnitConversionMap(List export(ProjectExportDto project, String defaultStorageRoot) { + var result = new ArrayList(); + for (var request : project.getFlowExecuteResults() == null ? List.of() + : project.getFlowExecuteResults()) { + var snapshot = FlowExecuteSnapshotDataDto.parseJson(request.getSnapshotData()); + var section = snapshot == null ? null : snapshot.getCanRecording(); + if (section == null) continue; + if (!Objects.equals(section.getRequestId(), String.valueOf(request.getId()))) + throw invalid("CAN snapshot belongs to another exported request"); + var matches = (project.getFiles() == null ? List.of() : project.getFiles()).stream() + .filter(CanRecordedProjectArtifacts::isEventFile) + .filter(file -> Objects.equals(String.valueOf(file.getId()), section.getFileId())).toList(); + if (matches.size() != 1) throw invalid("CAN recording requires one exact exported event file"); + var file = matches.getFirst(); + requireSourceBinding(snapshot, file); + String storage = snapshot.getInternalStoragePath() == null ? defaultStorageRoot : snapshot.getInternalStoragePath(); + Path source = resolve(storage, file.getFileUrl()); + verifyBytes(source, section); + var artifact = new ProjectPackageArtifactDto(); + artifact.setArtifactKey("can-events-" + file.getId()); + artifact.setSourceFileId(file.getId()); artifact.setSourceRequestId(file.getRequestId()); + artifact.setSourceBusinessId(file.getBusinessId()); artifact.setExportPolicy("CAN_EVENTS"); + var shard = new ProjectPackageShardDto(); + shard.setIndex(1); shard.setEntry("files/" + artifact.getArtifactKey() + "/1" + FileTypeEnum.CAN_EVENTS.getFileExtension()); + shard.setOriginalFileUrl(file.getFileUrl()); shard.setSize(section.getByteLength()); shard.setSha256(section.getSha256()); + artifact.getShards().add(shard); + result.add(new Exported(file, artifact, new SourceEntry(shard.getEntry(), source))); + } + return List.copyOf(result); + } + + public static void requireSourceBinding(FlowExecuteSnapshotDataDto snapshot, File file) { + var section = snapshot == null ? null : snapshot.getCanRecording(); + if (section == null || section.getVersion() != 1 || !isEventFile(file) + || !("FINISHED".equals(section.getStatus()) || "FAILED".equals(section.getStatus())) + || !Objects.equals(section.getRequestId(), String.valueOf(file.getRequestId())) + || !Objects.equals(section.getFileId(), String.valueOf(file.getId())) + || !Objects.equals(section.getBusinessId(), file.getBusinessId()) + || !Objects.equals(section.getRelativePath(), file.getFileUrl()) + || !Objects.equals(file.getBusinessType(), FileBusinessTypeEnum.CALCULATE.getType()) + || !Objects.equals(file.getShardsNo(), 1)) + throw invalid("CAN event file differs from its frozen request binding"); + } + + public static Restoration prepareImport(FlowExecuteSnapshotDataDto snapshot, File sourceFile, File targetFile, + long newProjectId, long newRequestId, String storageRoot, ProjectPackageArtifactDto artifact, ReadResult packageRead) { + requireSourceBinding(snapshot, sourceFile); + var section = snapshot.getCanRecording(); + if (artifact == null || packageRead == null || artifact.getShards() == null || artifact.getShards().size() != 1 + || !Objects.equals(artifact.getSourceFileId(), sourceFile.getId()) + || !Objects.equals(artifact.getSourceRequestId(), sourceFile.getRequestId()) + || !Objects.equals(artifact.getSourceBusinessId(), sourceFile.getBusinessId()) + || artifact.getLimitShards() != null && !artifact.getLimitShards().isEmpty() + || artifact.getIndexEntry() != null) + throw invalid("CAN project package has no exact event artifact"); + var shard = artifact.getShards().getFirst(); + if (shard == null || !Objects.equals(shard.getIndex(), 1) + || !Objects.equals(shard.getOriginalFileUrl(), sourceFile.getFileUrl()) + || !Objects.equals(shard.getSize(), section.getByteLength()) + || !Objects.equals(shard.getSha256(), section.getSha256())) + throw invalid("CAN package event manifest differs from the frozen recording"); + Path source = packageRead.getEntryFiles().get(shard.getEntry()); + if (source == null) throw invalid("CAN package event entry is missing"); + verifyBytes(source, section); + String business = newRequestId + "_can_events_v1"; + String relative = newProjectId + "/" + newRequestId + "/" + business + FileTypeEnum.CAN_EVENTS.getFileExtension(); + targetFile.setRequestId(newRequestId); targetFile.setBusinessId(business); + targetFile.setFileUrl(relative); targetFile.setFileName(relative); targetFile.setShardsNo(1); + return new Restoration(source, resolve(storageRoot, relative), relative); + } + + public static void rebind(FlowExecuteSnapshotDataDto snapshot, File sourceFile, File targetFile, String storageRoot) { + requireSourceBinding(snapshot, sourceFile); + if (targetFile.getId() == null || targetFile.getId() <= 0 || targetFile.getRequestId() == null + || targetFile.getRequestId() <= 0 || !isEventFile(targetFile) + || !Objects.equals(targetFile.getBusinessType(), sourceFile.getBusinessType()) + || Objects.equals(targetFile.getId(), sourceFile.getId())) + throw invalid("Imported CAN event file requires a genuine new registered owner"); + resolve(storageRoot, targetFile.getFileUrl()); + var section = snapshot.getCanRecording(); + if (section.getSourceRequestId() == null) section.setSourceRequestId(section.getRequestId()); + section.setRequestId(targetFile.getRequestId().toString()); section.setFileId(targetFile.getId().toString()); + section.setBusinessId(targetFile.getBusinessId()); section.setRelativePath(targetFile.getFileUrl()); + snapshot.setInternalStoragePath(Path.of(storageRoot).toAbsolutePath().normalize().toString()); + } + + public static void requireRebound(FlowExecuteSnapshotDataDto snapshot, long requestId) { + var section = snapshot == null ? null : snapshot.getCanRecording(); + if (section != null && (!Long.toString(requestId).equals(section.getRequestId()) || section.getSourceRequestId() == null)) + throw invalid("Imported CAN recording has no rebound event file"); + } + + private static Path resolve(String storageRoot, String relative) { + if (storageRoot == null || storageRoot.isBlank() || relative == null || Path.of(relative).isAbsolute()) + throw invalid("CAN project artifact requires a configured root and relative path"); + var root = Path.of(storageRoot).toAbsolutePath().normalize(); + var file = root.resolve(relative).normalize(); + if (!file.startsWith(root) || file.equals(root)) throw invalid("CAN project artifact escaped its storage root"); + return file; + } + + private static void verifyBytes(Path path, CanRecordingSectionDto section) { + try { + if (Files.size(path) != section.getByteLength() || !sha256(path).equals(section.getSha256())) + throw invalid("CAN event bytes differ from the frozen recording hash"); + try (var input = Files.newBufferedReader(path, StandardCharsets.UTF_8)) { + String line = input.readLine(); + if (line == null) throw invalid("CAN event header is missing"); + var header = JSON.readTree(line); + String original = section.getSourceRequestId() == null ? section.getRequestId() : section.getSourceRequestId(); + Map expected = JSON.convertValue(section.getChannels(), new TypeReference<>() { }); + Map recorded = JSON.convertValue(header.required("channels"), new TypeReference<>() { }); + if (header.required("version").intValue() != 1 || !original.equals(header.required("requestId").asText()) + || !expected.equals(recorded)) throw invalid("CAN event header differs from its original frozen facts"); + } + } catch (IOException failure) { + throw new CryBusinessException(ErrorCode.RESOURCE_FILE_READ_ERROR, failure, path); + } + } + + private static String sha256(Path path) throws IOException { + try { + var digest = MessageDigest.getInstance("SHA-256"); + try (var input = new DigestInputStream(Files.newInputStream(path), digest)) { input.transferTo(OutputStream.nullOutputStream()); } + return HexFormat.of().formatHex(digest.digest()); + } catch (NoSuchAlgorithmException failure) { throw new IllegalStateException(failure); } + } + + private static IllegalArgumentException invalid(String message) { return new IllegalArgumentException(message); } +} diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/recording/measurement/CanRecordedFacts.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/recording/measurement/CanRecordedFacts.java new file mode 100644 index 00000000..edddcc07 --- /dev/null +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/recording/measurement/CanRecordedFacts.java @@ -0,0 +1,92 @@ +package com.opentest.service.recording.measurement; + +import com.opentest.common.model.dto.CanRecordingSectionDto; +import com.opentest.dashboard.api.capability.CanChannelFacts; +import com.opentest.dashboard.api.capability.CanSignalBatch; +import com.opentest.dashboard.api.capability.CanSignalEvent; +import com.opentest.dashboard.api.capability.CanSignalProjection; +import java.util.ArrayList; +import java.util.Collections; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; + +/** Frozen offline facts. Every presentation timestamp is mapped by the saved Java clock anchors. */ +public final class CanRecordedFacts { + private final CanChannelFacts channels; + private final List batches; + private final CanRecordingSectionDto section; + + CanRecordedFacts(CanChannelFacts channels, List batches, CanRecordingSectionDto section) { + this.channels = channels; + this.batches = List.copyOf(batches); + this.section = CanRecordedInputStore.copy(section); + double previousObservation = -1; + double previousProgress = -1; + for (var anchor : this.section.getClockAnchors()) { + CanRecordedInputStore.time(anchor.getObservationSeconds()); + CanRecordedInputStore.time(anchor.getRecordingSeconds()); + if (anchor.getObservationSeconds() <= previousObservation || anchor.getRecordingSeconds() < previousProgress) + throw new IllegalArgumentException("Invalid frozen CAN progress mapping"); + previousObservation = anchor.getObservationSeconds(); previousProgress = anchor.getRecordingSeconds(); + } + if (!batches.isEmpty() && (section.getClockAnchors().isEmpty() + || batches.getFirst().observationElapsedSeconds() < section.getClockAnchors().getFirst().getObservationSeconds())) + throw new IllegalArgumentException("CAN events precede their formal progress mapping"); + } + + public CanChannelFacts channels() { return channels; } + public List batches() { return batches; } + public CanRecordingSectionDto section() { return CanRecordedInputStore.copy(section); } + + public double recordingSeconds(double observationSeconds) { + CanRecordedInputStore.time(observationSeconds); + var anchors = section.getClockAnchors(); + if (anchors.isEmpty() || observationSeconds < anchors.getFirst().getObservationSeconds()) + throw new IllegalArgumentException("Observation is outside the frozen formal clock"); + for (int index = 1; index < anchors.size(); index++) { + var right = anchors.get(index); + var left = anchors.get(index - 1); + if (observationSeconds <= right.getObservationSeconds()) { + double fraction = (observationSeconds - left.getObservationSeconds()) + / (right.getObservationSeconds() - left.getObservationSeconds()); + return left.getRecordingSeconds() + fraction * (right.getRecordingSeconds() - left.getRecordingSeconds()); + } + } + var last = anchors.getLast(); + return last.getRecordingSeconds() + observationSeconds - last.getObservationSeconds(); + } + + public double durationSeconds() { + double eventsEnd = batches.isEmpty() ? 0 : recordingSeconds(batches.getLast().observationElapsedSeconds()); + return section.getClockAnchors().isEmpty() ? eventsEnd + : Math.max(eventsEnd, section.getClockAnchors().getLast().getRecordingSeconds()); + } + + /** Returns projection batches in common recording seconds, preserving duplicate timestamps and gaps. */ + public List through(double recordingSeconds) { + CanRecordedInputStore.time(recordingSeconds); + var result = new ArrayList(); + for (var batch : batches) { + double progress = recordingSeconds(batch.observationElapsedSeconds()); + if (progress > recordingSeconds) break; + result.add(new CanSignalBatch(progress, batch.events())); + } + return List.copyOf(result); + } + + public Map at(double recordingSeconds) { + var values = new LinkedHashMap(); + channels.channels().keySet().forEach(id -> values.put(id, + new CanSignalEvent.InvalidState(id, CanSignalEvent.InvalidReason.NO_DATA, Map.of()))); + through(recordingSeconds).forEach(batch -> batch.events().forEach(event -> values.put(event.vchId(), event))); + return Collections.unmodifiableMap(values); + } + + public void replay(double fromSeconds, double toSeconds, CanSignalProjection projection) { + CanRecordedInputStore.time(fromSeconds); CanRecordedInputStore.time(toSeconds); + if (toSeconds < fromSeconds) throw new IllegalArgumentException("CAN replay range is reversed"); + for (var batch : through(toSeconds)) + if (batch.observationElapsedSeconds() >= fromSeconds) projection.accept(batch); + } +} diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/recording/measurement/CanRecordedInputStore.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/recording/measurement/CanRecordedInputStore.java new file mode 100644 index 00000000..975d4350 --- /dev/null +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/recording/measurement/CanRecordedInputStore.java @@ -0,0 +1,375 @@ +package com.opentest.service.recording.measurement; + +import com.fasterxml.jackson.core.type.TypeReference; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.opentest.common.enums.FileBusinessTypeEnum; +import com.opentest.common.enums.FileTypeEnum; +import com.opentest.common.exception.CryBusinessException; +import com.opentest.common.exception.ErrorCode; +import com.opentest.common.model.dto.CanRecordingSectionDto; +import com.opentest.common.model.dto.CanRecordingSectionDto.ClockAnchor; +import com.opentest.common.model.entity.File; +import com.opentest.common.model.query.FileQuery; +import com.opentest.dashboard.api.capability.CanChannelFacts; +import com.opentest.dashboard.api.capability.CanSignalBatch; +import com.opentest.dashboard.api.capability.CanSignalEvent; +import com.opentest.dashboard.api.channel.CanSignalChannel; +import com.opentest.service.FileService; +import com.opentest.service.can.CanOperationException; +import com.opentest.service.snapshot.FlowExecuteSnapshotMutator; +import java.io.BufferedWriter; +import java.io.IOException; +import java.io.OutputStream; +import java.io.OutputStreamWriter; +import java.io.UncheckedIOException; +import java.math.BigInteger; +import java.nio.channels.FileChannel; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.StandardOpenOption; +import java.security.DigestInputStream; +import java.security.MessageDigest; +import java.security.NoSuchAlgorithmException; +import java.util.ArrayList; +import java.util.HexFormat; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Objects; + +/** Request-owned irregular event files, using the caller's already resolved storage root. */ +public final class CanRecordedInputStore { + static final ObjectMapper JSON = new ObjectMapper(); + private final FileService files; + private final FlowExecuteSnapshotMutator snapshots; + private final WriterFactory writers; + + @FunctionalInterface interface WriterFactory { OutputStream open(Path path) throws IOException; } + + public CanRecordedInputStore(FileService files, FlowExecuteSnapshotMutator snapshots) { + this(files, snapshots, path -> Files.newOutputStream(path, StandardOpenOption.CREATE_NEW)); + } + + CanRecordedInputStore(FileService files, FlowExecuteSnapshotMutator snapshots, WriterFactory writers) { + this.files = Objects.requireNonNull(files); + this.snapshots = Objects.requireNonNull(snapshots); + this.writers = Objects.requireNonNull(writers); + } + + public Recording open(Path configuredRoot, long requestId, CanChannelFacts channels) { + if (requestId <= 0 || channels.channels().isEmpty()) + throw new IllegalArgumentException("A saved request and selected CAN channels are required"); + var existing = snapshots.read(requestId); + if (existing == null || existing.getCanRecording() != null) + throw new IllegalStateException("CAN recording requires an unused existing request"); + return new Recording(configuredRoot, requestId, channels); + } + + public CanRecordedFacts read(Path configuredRoot, long requestId, CanRecordingSectionDto section) { + try { return readFrozen(configuredRoot, requestId, section); } + catch (UncheckedIOException error) { + var failure = new CryBusinessException(ErrorCode.LOCAL_FILE_READ_ERROR, + section == null ? "CAN" : section.getRelativePath()); + failure.initCause(error); + throw failure; + } catch (NullPointerException error) { + throw new IllegalArgumentException("Incomplete saved CAN recording facts", error); + } + } + + private CanRecordedFacts readFrozen(Path configuredRoot, long requestId, CanRecordingSectionDto section) { + var frozen = copy(Objects.requireNonNull(section)); + if (frozen.getVersion() != 1 || !Long.toString(requestId).equals(frozen.getRequestId()) + || !("FINISHED".equals(frozen.getStatus()) || "FAILED".equals(frozen.getStatus()))) + throw new IllegalArgumentException("Unsupported, unfinished or foreign CAN recording"); + Path path = resolve(configuredRoot, frozen.getRelativePath()); + var query = new FileQuery(); + query.setRequestId(requestId); + var rows = files.list(query).stream().filter(row -> + Objects.equals(row.getRequestId(), requestId) + && Objects.equals(String.valueOf(row.getId()), frozen.getFileId()) + && Objects.equals(row.getBusinessId(), frozen.getBusinessId()) + && Objects.equals(row.getType(), FileTypeEnum.CAN_EVENTS.getType()) + && Objects.equals(row.getBusinessType(), FileBusinessTypeEnum.CALCULATE.getType()) + && Objects.equals(row.getFileUrl(), frozen.getRelativePath())).toList(); + if (rows.size() != 1) throw new IllegalArgumentException("CAN artifact has no exact registered request owner"); + try { + if (Files.size(path) != frozen.getByteLength() || !digest(path).equals(frozen.getSha256())) + throw new IllegalArgumentException("CAN artifact differs from its frozen manifest"); + var batches = new ArrayList(); + CanChannelFacts channels; + try (var reader = Files.newBufferedReader(path, StandardCharsets.UTF_8)) { + var header = JSON.readTree(Objects.requireNonNull(reader.readLine(), "CAN file header")); + String sourceRequestId = frozen.getSourceRequestId() == null ? frozen.getRequestId() : frozen.getSourceRequestId(); + if (header.path("version").asInt() != 1 + || !sourceRequestId.equals(header.path("requestId").asText())) + throw new IllegalArgumentException("CAN file header differs from its frozen request"); + var selected = new LinkedHashMap(); + frozen.getChannels().forEach((id, fact) -> selected.put(id, JSON.convertValue(fact, CanSignalChannel.class))); + channels = new CanChannelFacts(selected); + Map headerChannels = JSON.convertValue(header.required("channels"), new TypeReference<>() { }); + // The existing snapshot codec omits null fields; compare their typed frozen meaning. + if (!channels.channels().equals(headerChannels)) + throw new IllegalArgumentException("CAN file channel definitions differ from their frozen request"); + String line; + double previous = -1; + while ((line = reader.readLine()) != null) { + var node = JSON.readTree(line); + double observation = node.required("observationElapsedSeconds").doubleValue(); + var events = new ArrayList(); + for (var event : node.required("events")) { + String id = event.required("vchId").asText(); + if (!channels.channels().containsKey(id)) throw new IllegalArgumentException("Foreign recorded CAN member"); + Map provenance = JSON.convertValue(event.required("provenance"), new TypeReference<>() { }); + events.add(switch (event.required("kind").asText()) { + case "valid" -> new CanSignalEvent.ValidSample(id, event.required("physicalValue").doubleValue(), provenance); + case "invalid" -> new CanSignalEvent.InvalidState(id, + CanSignalEvent.InvalidReason.valueOf(event.required("reason").asText()), provenance); + case "gap" -> new CanSignalEvent.LossGap(id, event.path("droppedCount").isNull() + ? null : new BigInteger(event.required("droppedCount").asText()), provenance); + default -> throw new IllegalArgumentException("Unknown recorded CAN event variant"); + }); + } + if (observation < previous) throw new IllegalArgumentException("Recorded CAN time moved backwards"); + batches.add(new CanSignalBatch(observation, events)); + previous = observation; + } + } + if (batches.size() != frozen.getBatchCount()) throw new IllegalArgumentException("CAN batch manifest mismatch"); + return new CanRecordedFacts(channels, batches, frozen); + } catch (IOException error) { throw new UncheckedIOException(error); } + } + + public final class Recording implements AutoCloseable { + private final long requestId; + private final Path path; + private final CanChannelFacts channels; + private final CanRecordingSectionDto section = new CanRecordingSectionDto(); + private BufferedWriter writer; + private long committedBytes; + private double lastObservation = -1; + private Throwable writeFailure; + private Throwable stopFailure; + private boolean closed; + private boolean published; + + private Recording(Path root, long requestId, CanChannelFacts channels) { + this.requestId = requestId; + this.channels = channels; + section.setRequestId(Long.toString(requestId)); + section.setBusinessId(requestId + "_can_events_v1"); + section.setRelativePath(section.getBusinessId() + FileTypeEnum.CAN_EVENTS.getFileExtension()); + section.setChannels(JSON.convertValue(channels.channels(), new TypeReference<>() { })); + section.setClockAnchors(new ArrayList<>()); + section.setNativeFinishSnapshots(List.of()); + section.setStatus("RECORDING"); + path = resolve(root, section.getRelativePath()); + try { + Files.createDirectories(path.getParent()); + writer = new BufferedWriter(new OutputStreamWriter(writers.open(path), StandardCharsets.UTF_8)); + line(Map.of("version", 1, "requestId", section.getRequestId(), "channels", section.getChannels())); + committedBytes = Files.size(path); + var row = new File(); + row.setRequestId(requestId); + row.setBusinessId(section.getBusinessId()); + row.setBusinessType(FileBusinessTypeEnum.CALCULATE.getType()); + row.setType(FileTypeEnum.CAN_EVENTS.getType()); + row.setFileName(section.getRelativePath()); + row.setFileUrl(section.getRelativePath()); + row.setShardsNo(1); + try { + files.saveOrUpdateEntity(row); + section.setFileId(Objects.requireNonNull(row.getId(), "Registered CAN file ID").toString()); + } catch (RuntimeException error) { throw storage("register", error); } + publish(); + } catch (IOException error) { + closeAfterOpenFailure(error); + throw storage("write", error); + } catch (RuntimeException error) { + closeAfterOpenFailure(error); + throw error; + } + } + + private void closeAfterOpenFailure(Throwable failure) { + if (writer != null) try { writer.close(); } catch (IOException close) { failure.addSuppressed(close); } + } + + public synchronized void mapProgress(double observationSeconds, double recordingSeconds) { + requireOpen(); + time(observationSeconds); time(recordingSeconds); + var anchors = section.getClockAnchors(); + if (!anchors.isEmpty()) { + var previous = anchors.getLast(); + if (observationSeconds == previous.getObservationSeconds() + && recordingSeconds == previous.getRecordingSeconds()) return; + if (observationSeconds <= previous.getObservationSeconds() || recordingSeconds < previous.getRecordingSeconds()) + throw new IllegalArgumentException("CAN clock anchors must be ordered"); + } + anchors.add(new ClockAnchor(observationSeconds, recordingSeconds)); + } + + public synchronized void append(CanSignalBatch batch) { + requireOpen(); + if (section.getClockAnchors().isEmpty() + || batch.observationElapsedSeconds() < section.getClockAnchors().getFirst().getObservationSeconds() + || batch.observationElapsedSeconds() < lastObservation) + throw new IllegalArgumentException("CAN batch requires an ordered formal recorder clock mapping"); + var events = new ArrayList>(); + for (var event : batch.events()) { + if (!channels.channels().containsKey(event.vchId())) throw new IllegalArgumentException("Unselected CAN member"); + var value = new LinkedHashMap(); + value.put("vchId", event.vchId()); + value.put("provenance", event.provenance()); + if (event instanceof CanSignalEvent.ValidSample valid) { + value.put("kind", "valid"); value.put("physicalValue", valid.physicalValue()); + } else if (event instanceof CanSignalEvent.InvalidState invalid) { + value.put("kind", "invalid"); value.put("reason", invalid.reason().name()); + } else if (event instanceof CanSignalEvent.LossGap gap) { + value.put("kind", "gap"); value.put("droppedCount", gap.droppedCount() == null ? null : gap.droppedCount().toString()); + } + events.add(value); + } + try { + line(Map.of("observationElapsedSeconds", batch.observationElapsedSeconds(), "events", events)); + committedBytes = Files.size(path); + section.setBatchCount(section.getBatchCount() + 1); + lastObservation = batch.observationElapsedSeconds(); + } catch (IOException error) { + writeFailure = error; + throw storage("write", error); + } + } + + public synchronized CanRecordingSectionDto finish(double observationSeconds, double recordingSeconds, + List> nativeFinishSnapshots, String terminationReason) { + Throwable failure = "SOURCE_FAILURE".equals(terminationReason) || "sourceFailure".equals(terminationReason) + || "source-failure".equals(terminationReason) ? new IllegalStateException("CAN receive source failed") : null; + return finish(observationSeconds, recordingSeconds, nativeFinishSnapshots, terminationReason, failure); + } + + /** Marks a failed run without closing admission before the native sealed tail is written. */ + public synchronized void stopFailure(Throwable failure) { + requireOpen(); + if (stopFailure == null) stopFailure = Objects.requireNonNull(failure); + else if (stopFailure != failure) stopFailure.addSuppressed(failure); + } + + public synchronized CanRecordingSectionDto finish(double observationSeconds, double recordingSeconds, + List> nativeFinishSnapshots, String terminationReason, Throwable failure) { + if (closed) { + if (!published) throw new IllegalStateException("CAN recording did not finish"); + return copy(section); + } + if (observationSeconds < lastObservation) throw new IllegalArgumentException("CAN finish precedes written data"); + mapProgress(observationSeconds, recordingSeconds); + if (nativeFinishSnapshots.isEmpty()) throw new IllegalArgumentException("CAN finish requires native cutoff facts"); + for (var snapshot : nativeFinishSnapshots) { + if (!Boolean.TRUE.equals(snapshot.get("drained")) || !"finished".equals(snapshot.get("subscriptionState")) + || !(snapshot.get("cutoff") instanceof Map)) + throw new IllegalArgumentException("CAN subscription has not been sealed and drained"); + } + section.setNativeFinishSnapshots(JSON.convertValue(nativeFinishSnapshots, new TypeReference<>() { })); + section.setTerminationReason(Objects.requireNonNull(terminationReason)); + return settle(failure == null ? stopFailure : failure); + } + + /** Retains the last fully flushed batch; the caller must propagate the original failure. */ + public synchronized CanRecordingSectionDto fail(Throwable failure) { + Objects.requireNonNull(failure); + if (published && closed) return copy(section); + section.setTerminationReason("failure"); + return settle(failure); + } + + private CanRecordingSectionDto settle(Throwable failure) { + Throwable observed = failure == null ? writeFailure : failure; + boolean finalizationFailed = false; + if (!closed) { + closed = true; + try { writer.close(); } + catch (IOException error) { + finalizationFailed = true; + if (observed == null) observed = error; else observed.addSuppressed(error); + } + try (var channel = FileChannel.open(path, StandardOpenOption.WRITE)) { + channel.truncate(committedBytes); + channel.force(true); + } catch (IOException error) { + finalizationFailed = true; + if (observed == null) observed = error; else observed.addSuppressed(error); + } + } + section.setStatus(observed == null ? "FINISHED" : "FAILED"); + section.setFailure(observed == null ? null : observed.toString()); + try { + section.setByteLength(Files.size(path)); + section.setSha256(digest(path)); + publish(); + published = true; + } catch (IOException error) { + if (observed != null) error.addSuppressed(observed); + throw storage("write", error); + } + if (finalizationFailed || failure == null && observed != null) throw storage("write", observed); + return copy(section); + } + + private void publish() { + var frozen = copy(section); + try { + if (snapshots.mutate(requestId, snapshot -> { + var existing = snapshot.getCanRecording(); + if (existing != null && !Objects.equals(existing.getBusinessId(), frozen.getBusinessId())) + throw new IllegalStateException("Another CAN artifact owns this request"); + snapshot.setCanRecording(copy(frozen)); + }) == null) throw new IllegalStateException("CAN request disappeared during publication"); + } catch (RuntimeException error) { throw storage("publish", error); } + } + + private void requireOpen() { + if (closed || writeFailure != null) throw new IllegalStateException("CAN writer is closed or failed", writeFailure); + } + + private void line(Object value) throws IOException { + writer.write(JSON.writeValueAsString(value)); writer.write('\n'); writer.flush(); + } + + @Override public synchronized void close() { + if (!closed) fail(new IllegalStateException("CAN recording closed without sealed native completion")); + } + } + + private static CanOperationException storage(String operation, Throwable failure) { + int code = switch (operation) { case "write" -> 13103301; case "register" -> 13103302; case "publish" -> 13103303; + default -> throw new IllegalArgumentException("Unknown CAN storage operation"); }; + return new CanOperationException(code, "can.recorded.error." + operation, failure); + } + + static CanRecordingSectionDto copy(CanRecordingSectionDto section) { + return JSON.convertValue(section, CanRecordingSectionDto.class); + } + + static void time(double value) { + if (!Double.isFinite(value) || value < 0) throw new IllegalArgumentException("CAN time must be finite nonnegative seconds"); + } + + private static Path resolve(Path root, String relative) { + Path base = Objects.requireNonNull(root, "configured storage root").toAbsolutePath().normalize(); + if (relative == null || Path.of(relative).isAbsolute()) throw new IllegalArgumentException("CAN artifact requires a relative path"); + Path path = base.resolve(relative).normalize(); + if (!path.startsWith(base) || path.equals(base)) throw new IllegalArgumentException("CAN artifact escaped configured storage"); + return path; + } + + private static String digest(Path path) throws IOException { + try { + var digest = MessageDigest.getInstance("SHA-256"); + try (var input = new DigestInputStream(Files.newInputStream(path), digest)) { + input.transferTo(OutputStream.nullOutputStream()); + } + return HexFormat.of().formatHex(digest.digest()); + } catch (NoSuchAlgorithmException error) { throw new IllegalStateException(error); } + } +} diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/recording/measurement/SavedInputResolver.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/recording/measurement/SavedInputResolver.java index ee32138f..68cc9426 100644 --- a/apps/backend/crydaq-service/src/main/java/com/opentest/service/recording/measurement/SavedInputResolver.java +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/recording/measurement/SavedInputResolver.java @@ -2,6 +2,7 @@ import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; import com.opentest.common.enums.CalculateResultsEnum; +import com.opentest.common.enums.ChannelSourceEnum; import com.opentest.common.enums.FileBusinessTypeEnum; import com.opentest.common.enums.FileTypeEnum; import com.opentest.common.model.dto.ChannelDto; @@ -66,11 +67,14 @@ List resolve(FlowExecuteResult history, RecordedCallScope .map(RecordedWaveformPlanDto.Member::getChannel).toList(); else { var selected = SavedMeasurementInputFacts.readExecutionInputs(interpreter, configuration); + selected = selected.stream().filter(channel -> !ChannelSourceEnum.isCan(channel.getChannelSource())).toList(); var available = snapshot.getVirtualChannelExecutionChannels(); + if (available != null) available = available.stream() + .filter(channel -> !ChannelSourceEnum.isCan(channel.getChannelSource())).toList(); dependencies = virtualChannels.resolve(selected, available == null ? selected : available).stream() .filter(channel -> !channel.isMathChannel()).toList(); } - if (dependencies.isEmpty()) throw invalid("Saved capture dependencies are missing"); + if (dependencies.isEmpty() && snapshot.getCanRecording() == null) throw invalid("Saved capture dependencies are missing"); var resolved=new ArrayList(); for (ChannelDto input : dependencies) { var channel = MeasureProviderInputs.channel(input); diff --git a/apps/backend/crydaq-service/src/main/java/com/opentest/service/virtualchannel/VirtualChannelConfigValidator.java b/apps/backend/crydaq-service/src/main/java/com/opentest/service/virtualchannel/VirtualChannelConfigValidator.java index 58f29fcf..f1aa0c88 100644 --- a/apps/backend/crydaq-service/src/main/java/com/opentest/service/virtualchannel/VirtualChannelConfigValidator.java +++ b/apps/backend/crydaq-service/src/main/java/com/opentest/service/virtualchannel/VirtualChannelConfigValidator.java @@ -10,6 +10,7 @@ import com.opentest.common.enums.ChannelTypeEnum; import com.opentest.common.model.dto.BoxChannelDto; import com.opentest.common.model.dto.virtualchannel.VirtualChannelDefinition; +import com.opentest.service.can.CanProjectChannelService; import com.opentest.service.jni.UnitConversionService; import org.springframework.stereotype.Component; @@ -156,6 +157,9 @@ private void validateVirtualDependencies(Long projectId, if (dependencyChannel == null) { throw new CryBusinessException(ErrorCode.VIRTUAL_CHANNEL_DEPENDENCY_NOT_FOUND, definition.getCustomName(), dependency); } + if (ChannelSourceEnum.isCan(dependencyChannel.getChannelSource())) { + throw CanProjectChannelService.invalid("mathInput", "CAN signals cannot be used as Math inputs."); + } if ((definition.getMathSampleSemantics() == null || !definition.getMathSampleSemantics().rawFs()) && ChannelSourceEnum.isMath(dependencyChannel.getChannelSource()) && !StrUtil.equals(definition.getMathUnit(), dependencyChannel.getMathUnit())) { diff --git a/apps/backend/crydaq-service/src/test/java/com/opentest/service/BoxChannelCanProjectionTest.java b/apps/backend/crydaq-service/src/test/java/com/opentest/service/BoxChannelCanProjectionTest.java new file mode 100644 index 00000000..194e55f3 --- /dev/null +++ b/apps/backend/crydaq-service/src/test/java/com/opentest/service/BoxChannelCanProjectionTest.java @@ -0,0 +1,109 @@ +package com.opentest.service; + +import com.opentest.common.enums.ChannelIOEnum; +import com.opentest.common.model.dto.BoxChannelDto; +import com.opentest.common.model.dto.ChannelDto; +import com.opentest.common.model.entity.BoxChannel; +import com.opentest.common.model.entity.Device; +import com.opentest.common.model.query.BoxChannelQuery; +import com.opentest.service.mapper.BoxChannelStructMapper; +import com.opentest.common.utils.SpringContextHolder; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.springframework.context.ApplicationContext; +import org.springframework.context.MessageSource; +import org.springframework.context.support.StaticMessageSource; +import org.springframework.test.util.ReflectionTestUtils; + +import java.util.List; +import java.util.Set; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.verifyNoInteractions; +import static org.mockito.Mockito.when; + +class BoxChannelCanProjectionTest { + private Object previousContext; + @BeforeEach void messages() { + previousContext = ReflectionTestUtils.getField(SpringContextHolder.class, "context"); + ApplicationContext context = mock(ApplicationContext.class); + when(context.getBean(MessageSource.class)).thenReturn(new StaticMessageSource()); + ReflectionTestUtils.setField(SpringContextHolder.class, "context", context); + } + @AfterEach void restoreMessages() { ReflectionTestUtils.setField(SpringContextHolder.class, "context", previousContext); } + + @Test + void projectListAndAcquisitionProjectionKeepOfflineBindingWithoutAudioMetadata() { + BoxChannelService service = spy(new BoxChannelService()); + DeviceService devices = mock(DeviceService.class); + ChannelService physicalChannels = mock(ChannelService.class); + ProjectChannelViewAssembler ranges = mock(ProjectChannelViewAssembler.class); + BoxChannelStructMapper mapper = mock(BoxChannelStructMapper.class); + ReflectionTestUtils.setField(service, "deviceService", devices); + ReflectionTestUtils.setField(service, "channelService", physicalChannels); + ReflectionTestUtils.setField(service, "projectChannelViewAssembler", ranges); + ReflectionTestUtils.setField(service, "boxChannelStructMapper", mapper); + BoxChannel row = can(); + Device device = new Device(); + device.setId(22L); + device.setProtocol("OPENDAQ"); + device.setDeviceName("native-serial-A"); + device.setIpAddress("changed-address"); + device.setActiveState(0); + when(devices.findById(22L, false)).thenReturn(device); + doReturn(List.of(row)).when(service).list(any(BoxChannelQuery.class)); + + BoxChannelDto listed = service.entityToDto(List.of(row)).getFirst(); + assertEquals(22L, listed.getDeviceId()); + assertEquals(row.getCanDefinitionJson(), listed.getCanDefinitionJson()); + assertNull(listed.getChannel()); + assertNull(listed.getChannelId()); + assertNull(listed.getSamplingRate()); + assertNull(listed.getGain()); + + ChannelDto acquired = service.getChannelDtoMapByVchIdsWithoutDisplay(11L, + Set.of("CAN1"), ChannelIOEnum.INPUT, true).get("CAN1"); + assertEquals(33L, acquired.getBoxChannelId()); + assertEquals(22L, acquired.getDeviceId()); + assertEquals("changed-address", acquired.getIpAddress()); + assertEquals("native-serial-A", acquired.getDeviceName()); + assertEquals(2, acquired.getChannelSource()); + assertEquals(row.getCanDefinitionJson(), acquired.getCanDefinitionJson()); + assertNull(acquired.getSamplingRate()); + assertNull(acquired.getJniChannelNumber()); + assertNull(acquired.getSensitivity()); + assertNull(acquired.getGain()); + assertEquals(Set.of(), service.findUnboundPhysicalChannelVchIds(11L, Set.of("CAN1"), ChannelIOEnum.INPUT)); + verifyNoInteractions(physicalChannels, ranges, mapper); + } + + @Test + void missingDeviceDoesNotErasePersistedCanBinding() { + BoxChannelService service = new BoxChannelService(); + DeviceService devices = mock(DeviceService.class); + ReflectionTestUtils.setField(service, "deviceService", devices); + BoxChannelDto listed = service.entityToDto(List.of(can())).getFirst(); + assertEquals(22L, listed.getDeviceId()); + assertNull(listed.getDevice()); + } + + private BoxChannel can() { + BoxChannel row = new BoxChannel(); + row.setId(33L); + row.setProjectId(11L); + row.setTenantId(7L); + row.setDeviceId(22L); + row.setProtocol("OPENDAQ"); + row.setChannelSource(2); + row.setChannelIo(0); + row.setVchId("CAN1"); + row.setCanDefinitionJson("{\"schemaVersion\":1,\"portId\":\"can0\"}"); + return row; + } +} diff --git a/apps/backend/crydaq-service/src/test/java/com/opentest/service/ProjectServiceCanImportTest.java b/apps/backend/crydaq-service/src/test/java/com/opentest/service/ProjectServiceCanImportTest.java new file mode 100644 index 00000000..8a20b8c0 --- /dev/null +++ b/apps/backend/crydaq-service/src/test/java/com/opentest/service/ProjectServiceCanImportTest.java @@ -0,0 +1,127 @@ +package com.opentest.service; + +import com.baomidou.mybatisplus.core.conditions.Wrapper; +import com.opentest.common.exception.CryBusinessException; +import com.opentest.common.model.entity.BoxChannel; +import com.opentest.common.model.dto.ProjectExportDto; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.opentest.common.model.entity.Device; +import com.opentest.common.model.query.ChannelQuery; +import com.opentest.service.can.CanProjectChannelService; +import org.junit.jupiter.api.Test; +import org.mockito.ArgumentCaptor; +import org.springframework.test.util.ReflectionTestUtils; + +import java.util.List; +import java.util.Map; +import java.util.Set; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyList; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +class ProjectServiceCanImportTest { + @Test + void sameNativeDeviceIdentityMatchesAcrossAddressChangesWithoutSampledPositionFallback() { + ProjectService projects = new ProjectService(); + Device imported = device(22L, "native-serial-A", "old-address"); + Device other = device(99L, "native-serial-B", "old-address"); + Device current = device(88L, "native-serial-A", "new-address"); + assertSame(current, ReflectionTestUtils.invokeMethod(projects, "findMatchingCanDevice", + imported, List.of(other, current), Set.of())); + assertNull(ReflectionTestUtils.invokeMethod(projects, "findMatchingCanDevice", + imported, List.of(other), Set.of())); + assertThrows(CryBusinessException.class, () -> ReflectionTestUtils.invokeMethod(projects, + "findMatchingCanDevice", imported, List.of(current, device(89L, "native-serial-A", "third-address")), Set.of())); + } + + @Test + void canDeviceImportUsesStableIdentityEvenWhenSampledPositionsAreUnavailable() { + ProjectService projects = new ProjectService(); + DeviceService devices = mock(DeviceService.class); + ChannelService channels = mock(ChannelService.class); + ReflectionTestUtils.setField(projects, "deviceService", devices); + ReflectionTestUtils.setField(projects, "channelService", channels); + when(devices.list(any(Wrapper.class))).thenReturn(List.of(device(88L, "native-serial-A", "new-address"))); + when(channels.list(any(ChannelQuery.class))).thenReturn(List.of()); + Map remapped = ReflectionTestUtils.invokeMethod(projects, "createDevicesFromExport", + List.of(device(22L, "native-serial-A", "old-address")), List.of(), List.of(can())); + assertEquals(Map.of(22L, 88L), remapped); + verify(devices, never()).baseServiceBatchAdd(anyList()); + } + + @Test + void channelImportKeepsDefinitionAndLogicalIdentityButReissuesRuleAndProjectDeviceIds() throws Exception { + ProjectService projects = new ProjectService(); + BoxChannelService channels = mock(BoxChannelService.class); + CanProjectChannelService can = mock(CanProjectChannelService.class); + ReflectionTestUtils.setField(projects, "boxChannelService", channels); + ReflectionTestUtils.setField(projects, "canProjectChannelService", can); + BoxChannel source = can(); + source.setSamplingRate(48000); + source.setJniChannelNumber(7); + source.setSensitivity(42D); + ObjectMapper json = new ObjectMapper(); + ProjectExportDto exported = new ProjectExportDto(); + exported.setBoxChannels(List.of(source)); + ProjectExportDto reopened = json.readValue(json.writeValueAsBytes(exported), ProjectExportDto.class); + assertEquals(source.getCanDefinitionJson(), reopened.getBoxChannels().getFirst().getCanDefinitionJson()); + when(can.validateDefinition(source.getCanDefinitionJson(), 101L, "CAN4")) + .thenReturn("destination-definition-with-can:101:CAN4"); + ReflectionTestUtils.invokeMethod(projects, "createBoxChannelsFromExport", reopened.getBoxChannels(), 7L, 101L, + Map.of(22L, 88L), Map.of()); + ArgumentCaptor> rows = ArgumentCaptor.forClass(List.class); + verify(channels).baseServiceBatchAdd(rows.capture()); + BoxChannel imported = rows.getValue().getFirst(); + assertEquals(101L, imported.getProjectId()); + assertEquals(88L, imported.getDeviceId()); + assertEquals("CAN4", imported.getVchId()); + assertEquals("Engine", imported.getCustomName()); + assertEquals("destination-definition-with-can:101:CAN4", imported.getCanDefinitionJson()); + assertNull(imported.getSamplingRate()); + assertNull(imported.getJniChannelNumber()); + assertNull(imported.getSensitivity()); + assertNull(imported.getChannelId()); + } + + @Test + void missingCanDeviceMappingFailsBeforeWritingProjectRows() { + ProjectService projects = new ProjectService(); + BoxChannelService channels = mock(BoxChannelService.class); + ReflectionTestUtils.setField(projects, "boxChannelService", channels); + assertThrows(CryBusinessException.class, () -> ReflectionTestUtils.invokeMethod(projects, + "createBoxChannelsFromExport", List.of(can()), 7L, 101L, Map.of(), Map.of())); + verify(channels, never()).baseServiceBatchAdd(anyList()); + } + + private Device device(Long id, String nativeIdentity, String address) { + Device device = new Device(); + device.setId(id); + device.setTenantId(7L); + device.setProtocol("OPENDAQ"); + device.setDeviceName(nativeIdentity); + device.setIpAddress(address); + return device; + } + + private BoxChannel can() { + BoxChannel row = new BoxChannel(); + row.setId(33L); + row.setProjectId(11L); + row.setDeviceId(22L); + row.setChannelIo(0); + row.setChannelSource(2); + row.setVchId("CAN4"); + row.setVchIdNumber(4); + row.setCustomName("Engine"); + row.setCanDefinitionJson("source-definition"); + return row; + } +} diff --git a/apps/backend/crydaq-service/src/test/java/com/opentest/service/ProjectServiceCanRecordingRoundtripTest.java b/apps/backend/crydaq-service/src/test/java/com/opentest/service/ProjectServiceCanRecordingRoundtripTest.java new file mode 100644 index 00000000..95b5436c --- /dev/null +++ b/apps/backend/crydaq-service/src/test/java/com/opentest/service/ProjectServiceCanRecordingRoundtripTest.java @@ -0,0 +1,333 @@ +package com.opentest.service; + +import com.opentest.common.enums.FileTypeEnum; +import com.opentest.common.enums.BuiltinDashboardProvider; +import com.opentest.common.enums.FileBusinessTypeEnum; +import com.opentest.common.exception.CryBusinessException; +import com.opentest.common.model.dto.CanRecordingSectionDto; +import com.opentest.common.model.dto.DashboardConfigDto; +import com.opentest.common.model.dto.FlowExecuteSnapshotDataDto; +import com.opentest.common.model.dto.ProjectDto; +import com.opentest.common.model.dto.ProjectExportDto; +import com.opentest.common.model.dto.ProjectPackageManifestDto; +import com.opentest.common.model.entity.File; +import com.opentest.common.model.entity.DashboardConfig; +import com.opentest.common.model.entity.FlowExecuteResult; +import com.opentest.common.model.query.FileQuery; +import com.opentest.dashboard.api.capability.CanChannelFacts; +import com.opentest.dashboard.api.capability.CanSignalBatch; +import com.opentest.dashboard.api.capability.CanSignalEvent; +import com.opentest.dashboard.api.channel.CanPortBinding; +import com.opentest.dashboard.api.channel.CanSignalChannel; +import com.opentest.dashboard.api.channel.CanSignalQuantity; +import com.opentest.dashboard.api.channel.CanSignalUnits; +import com.opentest.service.project.ProjectOtPackageService; +import com.opentest.service.project.ProjectImportProgressListener; +import com.opentest.service.project.CanRecordedProjectArtifacts; +import com.opentest.service.recording.measurement.CanRecordedInputStore; +import com.opentest.service.snapshot.FlowExecuteSnapshotMutator; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.concurrent.atomic.AtomicLong; +import java.util.function.Consumer; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.io.TempDir; +import org.springframework.test.util.ReflectionTestUtils; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyList; +import static org.mockito.ArgumentMatchers.anyLong; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.doAnswer; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +class ProjectServiceCanRecordingRoundtripTest { + @TempDir Path temporary; + + @Test void normalImportRemapHooksRebindRecordedCanToTheNewRequestAndFileWithoutChangingBytes() throws Exception { + var f = new Fixture(temporary); + byte[] original = Files.readAllBytes(f.sourcePath()); + var source = f.requests.get(40L); + var imported = f.importRecord(source, f.rows.getFirst(), 99); + var section = FlowExecuteSnapshotDataDto.parseJson(imported.getSnapshotData()).getCanRecording(); + // This read fails on the original implementation: new request 4001 still carries section.requestId=40. + var offline = f.store.read(f.destination, imported.getId(), section); + assertNotEquals(source.getId(), imported.getId()); + assertEquals(imported.getId().toString(), section.getRequestId()); + assertNotEquals(f.saved.getFileId(), section.getFileId()); + assertNotEquals(f.saved.getRelativePath(), section.getRelativePath()); + assertArrayEquals(original, Files.readAllBytes(f.destination.resolve(section.getRelativePath()))); + assertEquals(f.saved.getSha256(), section.getSha256()); + assertEquals(f.store.read(f.source, 40, f.saved).channels(), offline.channels()); + assertEquals("9007199254740993", offline.batches().getFirst().events().getFirst().provenance().get("sequence")); + assertEquals("Frozen volts", offline.channels().channels().get("CAN4").displayName()); + assertThrows(IllegalArgumentException.class, () -> f.store.read(f.destination, imported.getId(), f.saved)); + String fileId = section.getFileId(); section.setFileId(f.saved.getFileId()); + assertThrows(IllegalArgumentException.class, () -> f.store.read(f.destination, imported.getId(), section)); + section.setFileId(fileId); section.setSourceRequestId(imported.getId().toString()); + assertThrows(IllegalArgumentException.class, () -> f.store.read(f.destination, imported.getId(), section)); + } + + @Test void normalPackageBuilderIncludesTheExactCanEventBytes() throws Exception { + var f = new Fixture(temporary); + var exported = f.exported(f.requests.get(40L), f.rows.getFirst()); + Object build = ReflectionTestUtils.invokeMethod(f.projects, "buildProjectPackageArtifacts", exported, true); + assertEquals(1, exported.getFiles().size(), "CAN-only history must not lose its event artifact"); + var manifest = (ProjectPackageManifestDto)ReflectionTestUtils.getField(build, "manifest"); + assertEquals(1, manifest.getArtifacts().size()); + assertEquals(f.saved.getSha256(), manifest.getArtifacts().getFirst().getShards().getFirst().getSha256()); + @SuppressWarnings("unchecked") + var entries = (List)ReflectionTestUtils.getField(build, "sourceEntries"); + var packages = new ProjectOtPackageService(); + Path archive = temporary.resolve("can-history.ot"); + packages.write(archive, exported, manifest, entries); + try (var read = packages.read(archive)) { + var shard = read.getManifest().getArtifacts().getFirst().getShards().getFirst(); + assertArrayEquals(Files.readAllBytes(f.sourcePath()), Files.readAllBytes(read.getEntryFiles().get(shard.getEntry()))); + } + } + + @Test void encryptedPackageReexportAndSecondImportKeepOriginalHeaderHashAndFactsUnderNewOwners() throws Exception { + var f = new Fixture(temporary); + byte[] original = Files.readAllBytes(f.sourcePath()); + var first = f.packageRoundtrip(f.requests.get(40L), f.rows.getFirst(), 99, temporary.resolve("first")); + var firstSnapshot = f.snapshots.read(first.getId()); + var firstSection = firstSnapshot.getCanRecording(); + assertEquals("40", firstSection.getSourceRequestId()); + File firstFile = f.rows.stream().filter(file -> file.getId().toString().equals(firstSection.getFileId())).findFirst().orElseThrow(); + var second = f.packageRoundtrip(first, firstFile, 101, temporary.resolve("second")); + var section = f.snapshots.read(second.getId()).getCanRecording(); + assertNotEquals(first.getId(), second.getId()); + assertEquals("40", section.getSourceRequestId()); + assertEquals(second.getId().toString(), section.getRequestId()); + assertNotEquals(firstSection.getFileId(), section.getFileId()); + assertEquals(f.saved.getSha256(), section.getSha256()); + assertEquals(f.saved.getByteLength(), section.getByteLength()); + assertArrayEquals(original, Files.readAllBytes(f.destination.resolve(section.getRelativePath()))); + var offline = f.store.read(f.destination, second.getId(), section); + assertEquals(2, offline.batches().size()); + assertEquals(f.saved.getNativeFinishSnapshots(), offline.section().getNativeFinishSnapshots()); + assertEquals(f.saved.getClockAnchors(), offline.section().getClockAnchors()); + assertEquals(3.5, ((CanSignalEvent.ValidSample)offline.at(0.2).get("CAN4")).physicalValue()); + assertEquals(CanSignalEvent.InvalidReason.TIMEOUT, ((CanSignalEvent.InvalidState)offline.at(1).get("CAN4")).reason()); + assertEquals(f.store.read(f.source, 40, f.saved).channels(), offline.channels()); + Path importedBytes = f.destination.resolve(section.getRelativePath()); + Files.writeString(importedBytes, "corrupt imported events"); + assertThrows(IllegalArgumentException.class, () -> f.store.read(f.destination, second.getId(), section)); + } + + @Test void missingWrongOwnerAndWrongHashCannotBeImportedOrSilentlyDropped() throws Exception { + var f = new Fixture(temporary); + var row = f.rows.getFirst(); + var request = f.requests.get(40L); + String originalBusiness = row.getBusinessId(); + row.setBusinessId("wrong_owner"); + assertThrows(IllegalArgumentException.class, () -> f.importRecord(request, row, 99)); + row.setBusinessId(originalBusiness); + String json = request.getSnapshotData(); + var altered = f.snapshots.read(40L); altered.getCanRecording().setSha256("0".repeat(64)); + request.setSnapshotData(altered.toJson()); + assertThrows(IllegalArgumentException.class, () -> f.importRecord(request, row, 99)); + request.setSnapshotData(json); + Files.delete(f.sourcePath()); + assertThrows(CryBusinessException.class, () -> f.importRecord(request, row, 99)); + var missing = f.exported(request, row); missing.setFiles(List.of()); + assertThrows(IllegalArgumentException.class, () -> ReflectionTestUtils.invokeMethod(f.projects, + "buildProjectPackageArtifacts", missing, true)); + var snapshot = f.snapshots.read(40L); + assertThrows(IllegalArgumentException.class, () -> CanRecordedProjectArtifacts.requireRebound(snapshot, 4001)); + Map mapping = ReflectionTestUtils.invokeMethod(f.projects, "createFlowExecuteResultsFromExport", + List.of(request), 99L, Map.of(2L, 3L), Map.of(), Map.of(), Map.of(), Map.of()); + assertThrows(IllegalArgumentException.class, () -> ReflectionTestUtils.invokeMethod(f.projects, + "requireImportedCanRecordings", mapping)); + } + + @Test void configurationOnlyExportAndGlobalRawHistoryDoNotCreateCanProjectArtifacts() throws Exception { + var f = new Fixture(temporary); + var exported = f.exported(f.requests.get(40L), f.rows.getFirst()); + Object configOnly = ReflectionTestUtils.invokeMethod(f.projects, "buildProjectPackageArtifacts", exported, false); + assertEquals(List.of(), exported.getFiles()); + assertEquals(List.of(), ((ProjectPackageManifestDto)ReflectionTestUtils.getField(configOnly, "manifest")).getArtifacts()); + var raw = new File(); raw.setId(500L); raw.setType(FileTypeEnum.TXT.getType()); + raw.setFileUrl("global/can-raw-history.jsonl"); raw.setBusinessId("global-raw"); + exported = f.exported(f.requests.get(40L), f.rows.getFirst()); + exported.setFiles(List.of(f.rows.getFirst(), raw)); + Object history = ReflectionTestUtils.invokeMethod(f.projects, "buildProjectPackageArtifacts", exported, true); + assertEquals(List.of(f.rows.getFirst()), exported.getFiles()); + assertEquals(1, ((ProjectPackageManifestDto)ReflectionTestUtils.getField(history, "manifest")).getArtifacts().size()); + } + + @Test void mixedOrdinaryAndCanArtifactsUseTheSamePackageStagingAndOwnerRemap() throws Exception { + var f = new Fixture(temporary); f.destination = f.source; + var ordinary = new File(); ordinary.setId(500L); ordinary.setRequestId(40L); + ordinary.setType(FileTypeEnum.CRYBIN.getType()); ordinary.setBusinessType(FileBusinessTypeEnum.CALCULATE.getType()); + ordinary.setBusinessId("40_2_Ch1_hash_Level_0_0_V"); ordinary.setShardsNo(1); + ordinary.setFileUrl("7/40/" + ordinary.getBusinessId() + "_1.crybin"); ordinary.setFileName(ordinary.getFileUrl()); + Path ordinaryPath = f.source.resolve(ordinary.getFileUrl()); Files.createDirectories(ordinaryPath.getParent()); + byte[] ordinaryBytes = {1, 2, 3, 4}; Files.write(ordinaryPath, ordinaryBytes); + var exported = f.exported(f.requests.get(40L), f.rows.getFirst()); exported.setFiles(List.of(f.rows.getFirst(), ordinary)); + var owner = new DashboardConfig(); owner.setId(2L); owner.setProviderId(BuiltinDashboardProvider.MONITOR.getProviderId()); + exported.setDashboardConfigs(List.of(owner)); + Object built = ReflectionTestUtils.invokeMethod(f.projects, "buildProjectPackageArtifacts", exported, true); + var manifest = (ProjectPackageManifestDto)ReflectionTestUtils.getField(built, "manifest"); + assertEquals(2, exported.getFiles().size()); assertEquals(2, manifest.getArtifacts().size()); + @SuppressWarnings("unchecked") + var entries = (List)ReflectionTestUtils.getField(built, "sourceEntries"); + Path archive = temporary.resolve("mixed.ot"); var packages = new ProjectOtPackageService(); + packages.write(archive, exported, manifest, entries); f.destination = temporary.resolve("mixed-destination"); + FlowExecuteResult imported; + try (var read = packages.read(archive)) { imported = f.importRead(read, 99); } + var numeric = f.rows.stream().filter(row -> row.getRequestId().equals(imported.getId()) + && row.getType().equals(FileTypeEnum.CRYBIN.getType())).findFirst().orElseThrow(); + assertTrue(numeric.getBusinessId().startsWith(imported.getId() + "_3_Ch1_")); + assertArrayEquals(ordinaryBytes, Files.readAllBytes(f.destination.resolve(numeric.getFileUrl()))); + var section = f.snapshots.read(imported.getId()).getCanRecording(); + assertEquals(2, f.store.read(f.destination, imported.getId(), section).batches().size()); + } + + private static final class Fixture { + final ProjectService projects = new ProjectService(); + final FileService files = mock(FileService.class); + final FlowExecuteResultService histories = mock(FlowExecuteResultService.class); + final VariablesService variables = mock(VariablesService.class); + final Map requests = new HashMap<>(); + final List rows = new ArrayList<>(); + final AtomicLong requestIds = new AtomicLong(4000); + final AtomicLong fileIds = new AtomicLong(90); + final Path source; + Path destination; + final CanRecordedInputStore store; + final CanRecordingSectionDto saved; + final FlowExecuteSnapshotMutator snapshots = new FlowExecuteSnapshotMutator() { + @Override public FlowExecuteSnapshotDataDto read(Long request) { + var row = requests.get(request); + return row == null ? null : FlowExecuteSnapshotDataDto.parseJson(row.getSnapshotData()); + } + @Override public FlowExecuteSnapshotDataDto mutate(Long request, Consumer mutation) { + var snapshot = read(request); mutation.accept(snapshot); requests.get(request).setSnapshotData(snapshot.toJson()); return snapshot; + } + }; + + Fixture(Path root) throws Exception { + source = root.resolve("source"); destination = root.resolve("destination"); + ReflectionTestUtils.setField(projects, "fileService", files); + ReflectionTestUtils.setField(projects, "flowExecuteResultService", histories); + ReflectionTestUtils.setField(projects, "variablesService", variables); + when(variables.getDefaultStoragePath()).thenAnswer(call -> destination.toString()); + doAnswer(call -> { File row = call.getArgument(0); row.setId(fileIds.incrementAndGet()); rows.add(row); return row; }) + .when(files).saveOrUpdateEntity(any(File.class)); + when(files.list(any(FileQuery.class))).thenAnswer(call -> new ArrayList<>(rows)); + doAnswer(call -> { + List added = call.getArgument(0); + for (var row : added) { if (row.getId() == null) row.setId(fileIds.incrementAndGet()); rows.add(row); } + return true; + }).when(files).baseServiceBatchAdd(anyList()); + doAnswer(call -> { + List added = call.getArgument(0); + for (var row : added) { row.setId(requestIds.incrementAndGet()); requests.put(row.getId(), row); } + return true; + }).when(histories).baseServiceBatchAdd(anyList()); + when(histories.findById(anyLong(), eq(false))).thenAnswer(call -> requests.get(call.getArgument(0))); + when(histories.compareAndSetSnapshotData(anyLong(), anyString(), anyString())).thenAnswer(call -> { + var row = requests.get(call.getArgument(0)); + if (row == null || !row.getSnapshotData().equals(call.getArgument(1))) return false; + row.setSnapshotData(call.getArgument(2)); return true; + }); + var snapshot = new FlowExecuteSnapshotDataDto(); snapshot.setInternalStoragePath(source.toString()); + var dashboard = new DashboardConfigDto(); dashboard.setId(2L); dashboard.setProjectId(7L); + dashboard.setProviderId(BuiltinDashboardProvider.MONITOR.getProviderId()); snapshot.setDashboardConfig(dashboard); + var request = new FlowExecuteResult(); request.setId(40L); request.setProjectId(7L); request.setDashboardId(2L); + request.setSnapshotData(snapshot.toJson()); requests.put(40L, request); + store = new CanRecordedInputStore(files, snapshots); + var channel = new CanSignalChannel("CAN4", "13", "7", "Frozen volts", 1, + new CanPortBinding("3", "CAN", "original-serial", "CAN0"), "{\"version\":1,\"factor\":0.1}", + new CanSignalUnits(CanSignalQuantity.VOLTAGE, "V", "V", null), "definition-v1"); + var recording = store.open(source, 40, new CanChannelFacts(Map.of("CAN4", channel))); + recording.mapProgress(10, 0); + recording.append(new CanSignalBatch(10.17, List.of(new CanSignalEvent.ValidSample("CAN4", 3.5, + Map.of("sequence", "9007199254740993", "nativeTime", "12345678901234567890"))))); + recording.append(new CanSignalBatch(10.31, List.of(new CanSignalEvent.InvalidState("CAN4", CanSignalEvent.InvalidReason.TIMEOUT, Map.of())))); + saved = recording.finish(11, 1, List.of(Map.of("drained", true, "subscriptionState", "finished", + "cutoff", Map.of("dispatchSequence", "9007199254740993"))), "normal"); + } + + Path sourcePath() { return source.resolve(saved.getRelativePath()); } + + ProjectExportDto exported(FlowExecuteResult request, File file) { + var exported = new ProjectExportDto(); + var project = new ProjectDto(); project.setId(request.getProjectId()); exported.setProject(project); + exported.setFlowExecuteResults(List.of(request)); exported.setFiles(List.of(file)); + return exported; + } + + FlowExecuteResult packageRoundtrip(FlowExecuteResult request, File file, long projectId, Path destinationRoot) throws Exception { + var exported = exported(request, file); + Object built = ReflectionTestUtils.invokeMethod(projects, "buildProjectPackageArtifacts", exported, true); + var manifest = (ProjectPackageManifestDto)ReflectionTestUtils.getField(built, "manifest"); + @SuppressWarnings("unchecked") + var entries = (List)ReflectionTestUtils.getField(built, "sourceEntries"); + Path packageFile = destinationRoot.resolveSibling("project-" + projectId + ".ot"); + var packages = new ProjectOtPackageService(); packages.write(packageFile, exported, manifest, entries); + destination = destinationRoot; + try (var read = packages.read(packageFile)) { return importRead(read, projectId); } + } + + FlowExecuteResult importRecord(FlowExecuteResult sourceRequest, File sourceFile, long project) { + var artifact = new ProjectPackageManifestDto.ProjectPackageArtifactDto(); + artifact.setArtifactKey("event-" + sourceFile.getId()); artifact.setSourceFileId(sourceFile.getId()); + artifact.setSourceRequestId(sourceRequest.getId()); artifact.setSourceBusinessId(sourceFile.getBusinessId()); + var shard = new ProjectPackageManifestDto.ProjectPackageShardDto(); shard.setIndex(1); + shard.setEntry("files/" + artifact.getArtifactKey() + "/1.can-events.jsonl"); + shard.setOriginalFileUrl(sourceFile.getFileUrl()); + var sourceSnapshot = snapshots.read(sourceRequest.getId()); + var section = sourceSnapshot.getCanRecording(); shard.setSha256(section.getSha256()); shard.setSize(section.getByteLength()); + artifact.getShards().add(shard); + var manifest = new ProjectPackageManifestDto(); manifest.getArtifacts().add(artifact); + var exported = exported(sourceRequest, sourceFile); + var read = new ProjectOtPackageService().new ReadResult(exported, manifest, + Map.of(shard.getEntry(), Path.of(sourceSnapshot.getInternalStoragePath()).resolve(sourceFile.getFileUrl())), null); + return importRead(read, project); + } + + FlowExecuteResult importRead(ProjectOtPackageService.ReadResult read, long project) { + var exported = read.getProjectExportDto(); + var sourceRequest = exported.getFlowExecuteResults().getFirst(); + try { + var constructor = Class.forName(ProjectService.class.getName() + "$ProjectImportArtifactRestorePlan").getDeclaredConstructor(); + constructor.setAccessible(true); + var plan = constructor.newInstance(); + try { + ReflectionTestUtils.invokeMethod(projects, "stageImportedArtifacts", exported, read, plan); + assertNotNull(ReflectionTestUtils.getField(plan, "staging"), "CAN event bytes must use normal import staging"); + Map mapping = ReflectionTestUtils.invokeMethod(projects, "createFlowExecuteResultsFromExport", + exported.getFlowExecuteResults(), project, Map.of(sourceRequest.getDashboardId(), 3L), Map.of(), Map.of(), Map.of(), Map.of()); + assertNotNull(mapping); + var imported = requests.get(mapping.get(sourceRequest.getId())); + System.out.println("Normal import request " + sourceRequest.getId() + " -> " + imported.getId() + + ", frozen owner before file restoration=" + snapshots.read(imported.getId()).getCanRecording().getRequestId()); + ReflectionTestUtils.invokeMethod(projects, "createFilesFromExport", exported.getFiles(), project, + Map.of(), Map.of(sourceRequest.getDashboardId(), 3L), Map.of(), mapping, read, + ProjectImportProgressListener.NOOP, plan); + ReflectionTestUtils.invokeMethod(projects, "requireImportedCanRecordings", mapping); + ReflectionTestUtils.invokeMethod(plan, "restoreAll"); + ReflectionTestUtils.invokeMethod(plan, "commitResourceChanges"); + return imported; + } catch (RuntimeException | Error failure) { + ReflectionTestUtils.invokeMethod(plan, "rollbackResourceChanges", failure); + throw failure; + } finally { ReflectionTestUtils.invokeMethod(plan, "cleanupStaging"); } + } catch (ReflectiveOperationException failure) { throw new IllegalStateException(failure); } + } + } +} diff --git a/apps/backend/crydaq-service/src/test/java/com/opentest/service/can/CanDbcServiceTest.java b/apps/backend/crydaq-service/src/test/java/com/opentest/service/can/CanDbcServiceTest.java new file mode 100644 index 00000000..a7ff6e94 --- /dev/null +++ b/apps/backend/crydaq-service/src/test/java/com/opentest/service/can/CanDbcServiceTest.java @@ -0,0 +1,121 @@ +package com.opentest.service.can; + +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.node.ObjectNode; +import com.opentest.common.exception.CryBusinessException; +import com.opentest.common.exception.JniBusinessException; +import com.opentest.core.jni.CanJNIBridge; +import java.nio.charset.StandardCharsets; +import java.util.ArrayList; +import java.util.Base64; +import java.util.List; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class CanDbcServiceTest { + static final ObjectMapper JSON = new ObjectMapper(); + static final byte[] BYTES = ("\uFEFFVERSION \"frozen\"\nBO_ 2147484032 Engine: 8 ECU\n" + + " SG_ Rpm : 0|16@1+ (0.1,-2) [0|6553.5] \"rpm\" ECU\n").getBytes(StandardCharsets.UTF_8); + + @Test void parseKeepsNativeDataIncludingExactIdsUnsupportedReasonsAndMetadata() throws Exception { + Bridge bridge = new Bridge(); + ObjectNode response = response(); + ObjectNode unsupported = ((ObjectNode) response.path("data").path("messages").get(0)) + .withArray("signals").addObject(); + unsupported.put("name", "Multiplexed").put("signalId", "other").put("unit", "").put("supported", false) + .put("unsupportedReason", "multiplexing is unsupported").putNull("definition"); + bridge.parseResponse = response.toString(); + assertEquals(response.path("data"), new CanDbcService(bridge).parse(BYTES)); + assertArrayEquals(BYTES, bridge.inputs.getFirst()); + assertEquals(0, bridge.validationCalls); + } + + @Test void parserFailureNeverExposesPartialSuccessAndKeepsLocalizedNativeCode() throws Exception { + Bridge bridge = new Bridge(); + ObjectNode failed = response().put("code", 13103001); + failed.put("message", "raw native diagnostic must not become user text"); + bridge.parseResponse = failed.toString(); + JniBusinessException error = assertThrows(JniBusinessException.class, () -> new CanDbcService(bridge).parse(BYTES)); + assertEquals(13103001, error.getErrcode()); + assertEquals("error.jni.native.13103001", error.getMsgKey()); + } + + @ParameterizedTest + @ValueSource(strings = {"null", "{}", "not json", "{\"code\":0,\"data\":null}", + "{\"code\":0,\"data\":{\"schemaVersion\":1,\"messages\":[]}}", + "{\"code\":0,\"code\":1}", "{\"code\":0} {}"}) + void malformedNativeResponsesFail(String response) { + Bridge bridge = new Bridge(); bridge.parseResponse = response; + assertThrows(CryBusinessException.class, () -> new CanDbcService(bridge).parse(BYTES)); + } + + @Test void sizeLimitIsInclusiveAndAppliedBeforeCallingNative() { + Bridge bridge = new Bridge(); + CanDbcService service = new CanDbcService(bridge); + assertThrows(CryBusinessException.class, () -> service.parse(null)); + assertThrows(CryBusinessException.class, () -> service.parse(new byte[0])); + assertThrows(CryBusinessException.class, () -> service.parse(new byte[CanDbcService.MAX_BYTES + 1])); + assertTrue(bridge.inputs.isEmpty()); + service.parse(new byte[CanDbcService.MAX_BYTES]); + assertEquals(CanDbcService.MAX_BYTES, bridge.inputs.getFirst().length); + } + + @Test void absentNativeParserUsesLocalizedFailure() { + CanJNIBridge bridge = new Bridge() { + @Override public String parseCanDbcV1(byte[] content) { throw new UnsatisfiedLinkError(); } + }; + assertThrows(CryBusinessException.class, () -> new CanDbcService(bridge).parse(BYTES)); + } + + static ObjectNode document() throws Exception { + ObjectNode root = JSON.createObjectNode().put("schemaVersion", 1).put("portId", "can0") + .put("decodeMethod", "dbc").put("quantity", "ROTATIONAL_SPEED") + .put("sourceUnit", "rpm").put("outputUnit", "rpm").putNull("tachoPpr"); + root.set("definition", response().path("data").path("messages").get(0).path("signals").get(0).path("definition").deepCopy()); + root.putObject("dbc").put("fileName", "original.dbc").put("contentBase64", Base64.getEncoder().encodeToString(BYTES)) + .put("messageId", "2147484032").put("signalName", "Rpm"); + return root; + } + + static ObjectNode response() throws Exception { + return (ObjectNode) JSON.readTree(""" + {"schemaVersion":1,"code":0,"message":"","data":{"schemaVersion":1, + "parser":"opentest-integer-dbc-subset-v1","encoding":"UTF-8", + "limits":{"inputBytes":5000000,"outputBytes":16777216,"messages":16384,"signals":32768}, + "messages":[{"messageId":"2147484032","canId":384,"idFormat":"extended","name":"Engine", + "length":8,"frameType":"any","signals":[{"name":"Rpm","signalId":"dbc-2147484032-Rpm", + "unit":"rpm","unitMetadata":{"category":"rotational-speed","normalizedUnit":"rpm","scaleToBase":1}, + "supported":true,"unsupportedReason":null,"definition":{"signalId":"dbc-2147484032-Rpm", + "canId":384,"idFormat":"extended","frameType":"any","byteOrder":"intel","valueType":"unsigned", + "startBit":0,"bitLength":16,"factor":0.1,"offset":-2,"timeoutMs":1000,"invalidRawValue":null,"unit":"rpm"}}]}]}} + """); + } + + /** Concrete Java overrides ensure no Mockito invocation can reach a native method. */ + static class Bridge extends CanJNIBridge { + String parseResponse; + final List inputs = new ArrayList<>(); + int validationCalls; + + Bridge() { + try { parseResponse = response().toString(); } + catch (Exception error) { throw new AssertionError(error); } + } + @Override public String parseCanDbcV1(byte[] bytes) { inputs.add(bytes.clone()); return parseResponse; } + @Override public String validateCanSignalDefinitionsV1(String payload) { + validationCalls++; + try { + ObjectNode result = JSON.createObjectNode().put("code", 0); + ObjectNode data = result.putObject("data").put("valid", true); + data.putArray("issues"); + data.set("signals", JSON.readTree(payload).path("signals")); + return result.toString(); + } catch (Exception error) { throw new AssertionError(error); } + } + } +} diff --git a/apps/backend/crydaq-service/src/test/java/com/opentest/service/can/CanErrorLocalizationTest.java b/apps/backend/crydaq-service/src/test/java/com/opentest/service/can/CanErrorLocalizationTest.java new file mode 100644 index 00000000..58d8a60e --- /dev/null +++ b/apps/backend/crydaq-service/src/test/java/com/opentest/service/can/CanErrorLocalizationTest.java @@ -0,0 +1,242 @@ +package com.opentest.service.can; + +import com.opentest.algorithm.api.AlgorithmException; +import com.opentest.common.exception.CryBusinessException; +import com.opentest.common.exception.ErrorCode; +import com.opentest.common.exception.JniBusinessException; +import com.opentest.common.utils.LocaleUtil; +import com.opentest.common.utils.SpringContextHolder; +import com.opentest.dashboard.api.execution.DashboardExecutionException; +import com.opentest.dashboard.api.execution.ExecutionValidationError; +import com.opentest.service.dashboard.framework.ProviderExecutionErrors; +import com.opentest.service.grpc.core.sender.GrpcWriter; +import com.opentest.service.proto.CommonProto; +import io.grpc.stub.StreamObserver; +import java.nio.file.Path; +import java.util.List; +import java.util.Locale; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionException; +import java.util.concurrent.TimeUnit; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; +import org.junit.jupiter.params.provider.ValueSource; +import org.springframework.context.support.ReloadableResourceBundleMessageSource; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.mockito.Mockito.mockStatic; + +class CanErrorLocalizationTest { + private static final String SOURCE_FAILED_EN = + "CAN reception ended with an error. Stop and release this reception first."; + private static final String SOURCE_FAILED_ZH = "CAN 接收已异常结束,请先停止并释放本次接收。"; + private static final String INVALID_STATE_EN = + "The current CAN state does not allow this operation. Check the enable switch, port configuration and reception state."; + + private ReloadableResourceBundleMessageSource messages() { + Path backend = Path.of(System.getProperty("can.test.backend", + Path.of(System.getProperty("basedir", ".")).resolve("..").toString())).toAbsolutePath(); + var source = new ReloadableResourceBundleMessageSource(); + source.setBasename(backend.resolve("crydaq-server/src/main/resources/lang/messages").toUri().toString()); + source.setDefaultEncoding("UTF-8"); + source.setFallbackToSystemLocale(false); + return source; + } + + @Test + void providerFailureResolvesTheOriginalKeyInTheResponseLanguage() { + try (var holder = mockStatic(SpringContextHolder.class)) { + holder.when(SpringContextHolder::getMessageSource).thenReturn(messages()); + var failure = LocaleUtil.runWithLocale(Locale.US, + () -> new CanOperationException(13103002, "can.error.sourceFailed")); + var mapped = LocaleUtil.runWithLocale(Locale.US, + () -> (CryBusinessException) ProviderExecutionErrors.executionFailure(failure)); + + assertEquals(13103002, mapped.getErrcode()); + assertEquals(SOURCE_FAILED_EN, mapped.resolveMessage(Locale.US)); + assertEquals(SOURCE_FAILED_ZH, mapped.resolveMessage(Locale.SIMPLIFIED_CHINESE)); + } + } + + @Test + void nativeCanFailureKeepsTheExistingStateExplanationAndDiagnosticCause() { + try (var holder = mockStatic(SpringContextHolder.class)) { + holder.when(SpringContextHolder::getMessageSource).thenReturn(messages()); + var cause = new IllegalStateException("diagnostic only"); + var failure = new CanOperationException(13103002, "error.jni.native.13103002", cause); + var mapped = (CryBusinessException) ProviderExecutionErrors.executionFailure(failure); + + assertEquals(13103002, mapped.getErrcode()); + assertEquals(INVALID_STATE_EN, mapped.resolveMessage(Locale.US)); + assertSame(cause, failure.getCause()); + } + } + + @Test + void diagnosticCanCauseDoesNotReplaceAnAlreadySelectedBusinessFailure() throws Exception { + try (var holder = mockStatic(SpringContextHolder.class)) { + holder.when(SpringContextHolder::getMessageSource).thenReturn(messages()); + var selected = new CryBusinessException(1090005, "Selected business failure"); + selected.initCause(new CanOperationException(13103002, "can.error.sourceFailed")); + var diagnostic = new IllegalStateException("sibling diagnostic"); + selected.addSuppressed(diagnostic); + + assertSame(selected, ProviderExecutionErrors.executionFailure(selected)); + assertSame(selected, ProviderExecutionErrors.stopFinalizationFailure(selected)); + + var sent = new CompletableFuture(); + try (var writer = new GrpcWriter(new StreamObserver<>() { + public void onNext(CommonProto.Response response) { sent.complete(response); } + public void onError(Throwable error) { sent.completeExceptionally(error); } + public void onCompleted() { } + })) { + writer.sendTaskOperationMsg(CommonProto.TaskOperationType.TOTAL_TASK_STOP, + selected, 3, 20L, 42L, Locale.US); + var response = sent.get(5, TimeUnit.SECONDS).getTaskOperationMsg(); + assertEquals(1090005, response.getErrorCode().getValue()); + assertEquals("Selected business failure", response.getErrorMsg().getValue()); + assertSame(diagnostic, selected.getSuppressed()[0]); + } + } + } + + @ParameterizedTest + @ValueSource(strings = {"execution", "finalization", "writer"}) + void mappedCanDiagnosticDoesNotReplaceASpecificBusinessFailure(String boundary) throws Exception { + try (var holder = mockStatic(SpringContextHolder.class)) { + holder.when(SpringContextHolder::getMessageSource).thenReturn(messages()); + var can = new CanOperationException(13103002, "can.error.sourceFailed"); + var mapped = LocaleUtil.runWithLocale(Locale.US, + () -> (CryBusinessException) ProviderExecutionErrors.executionFailure(can)); + var selected = new CryBusinessException(1090005, "Selected business failure"); + selected.initCause(mapped); + var diagnostic = new IllegalStateException("sibling diagnostic"); + selected.addSuppressed(diagnostic); + var reported = new CompletionException(selected); + + assertSame(can, mapped.getCause()); + assertEquals("can.error.sourceFailed", mapped.getMsgKey()); + assertEquals(SOURCE_FAILED_ZH, mapped.resolveMessage(Locale.SIMPLIFIED_CHINESE)); + if (boundary.equals("writer")) { + assertTaskFailure(reported, Locale.SIMPLIFIED_CHINESE, 1090005, "Selected business failure"); + } else { + assertSame(selected, boundary.equals("execution") + ? ProviderExecutionErrors.executionFailure(reported) + : ProviderExecutionErrors.stopFinalizationFailure(reported)); + } + assertSame(mapped, selected.getCause()); + assertSame(can, mapped.getCause()); + assertSame(diagnostic, selected.getSuppressed()[0]); + } + } + + @ParameterizedTest + @CsvSource({"direct, en", "completion, zh-CN", "service, en", "service, zh-CN"}) + void mappedCanFailureRetainsItsCodeCauseAndResponseLanguage(String wrapper, String language) throws Exception { + try (var holder = mockStatic(SpringContextHolder.class)) { + holder.when(SpringContextHolder::getMessageSource).thenReturn(messages()); + var can = new CanOperationException(13103002, "can.error.sourceFailed"); + var mapped = LocaleUtil.runWithLocale(Locale.US, + () -> (CryBusinessException) ProviderExecutionErrors.executionFailure(can)); + Exception reported = switch (wrapper) { + case "completion" -> new CompletionException(mapped); + case "service" -> new CryBusinessException(ErrorCode.FAILED, mapped); + default -> mapped; + }; + assertSame(mapped, ProviderExecutionErrors.executionFailure(reported)); + assertSame(can, mapped.getCause()); + assertTaskFailure(reported, Locale.forLanguageTag(language), 13103002, + language.equals("en") ? SOURCE_FAILED_EN : SOURCE_FAILED_ZH); + } + } + + @Test + void trueJniCauseKeepsItsPriorityOverASpecificBusinessFailure() throws Exception { + try (var holder = mockStatic(SpringContextHolder.class)) { + holder.when(SpringContextHolder::getMessageSource).thenReturn(messages()); + var nativeFailure = new JniBusinessException(13103002); + var selected = new CryBusinessException(1090005, "Selected business failure"); + selected.initCause(nativeFailure); + assertSame(nativeFailure, ProviderExecutionErrors.executionFailure(selected)); + assertSame(nativeFailure, ProviderExecutionErrors.stopFinalizationFailure(selected)); + assertTaskFailure(selected, Locale.US, 13103002, INVALID_STATE_EN); + assertSame(nativeFailure, selected.getCause()); + } + } + + @ParameterizedTest + @ValueSource(strings = {"business", "provider", "algorithm", "ordinary"}) + void genericFailureKeepsItsOriginalSelectionForNonCanCauses(String kind) { + try (var holder = mockStatic(SpringContextHolder.class)) { + holder.when(SpringContextHolder::getMessageSource).thenReturn(messages()); + Exception cause = switch (kind) { + case "business" -> new CryBusinessException(1090005, "Nested business failure"); + case "provider" -> new DashboardExecutionException( + new ExecutionValidationError("Nested provider failure", 1090005, List.of(), true), null); + case "algorithm" -> new AlgorithmException(13200001, "operation"); + default -> new IllegalStateException("diagnostic"); + }; + var selected = new CryBusinessException(ErrorCode.FAILED, cause); + assertSame(selected, ProviderExecutionErrors.executionFailure(selected)); + assertSame(selected, ProviderExecutionErrors.stopFinalizationFailure(selected)); + assertSame(cause, selected.getCause()); + } + } + + private void assertTaskFailure(Exception failure, Locale language, int code, String message) throws Exception { + var sent = new CompletableFuture(); + try (var writer = new GrpcWriter(new StreamObserver<>() { + public void onNext(CommonProto.Response response) { sent.complete(response); } + public void onError(Throwable error) { sent.completeExceptionally(error); } + public void onCompleted() { } + })) { + writer.sendTaskOperationMsg(CommonProto.TaskOperationType.TOTAL_TASK_STOP, failure, 3, 20L, 42L, language); + var response = sent.get(5, TimeUnit.SECONDS).getTaskOperationMsg(); + assertFalse(response.getSuccess()); + assertEquals(code, response.getErrorCode().getValue()); + assertEquals(message, response.getErrorMsg().getValue()); + } + } + + @ParameterizedTest + @CsvSource({ + "direct, TOTAL_TASK_STOP, en", + "completion, TOTAL_TASK_STOP, zh-CN", + "service, TOTAL_TASK_START, en", + "service, TOTAL_TASK_START, zh-CN" + }) + void taskOperationKeepsTheCanCodeAndLocalizedMessage(String wrapper, String operation, String language) + throws Exception { + try (var holder = mockStatic(SpringContextHolder.class)) { + holder.when(SpringContextHolder::getMessageSource).thenReturn(messages()); + var failure = new CanOperationException(13103002, "can.error.sourceFailed"); + Exception reported = switch (wrapper) { + case "completion" -> new CompletionException(failure); + case "service" -> new CryBusinessException(ErrorCode.FAILED, failure); + default -> failure; + }; + var sent = new CompletableFuture(); + try (var writer = new GrpcWriter(new StreamObserver<>() { + public void onNext(CommonProto.Response response) { sent.complete(response); } + public void onError(Throwable error) { sent.completeExceptionally(error); } + public void onCompleted() { } + })) { + writer.sendTaskOperationMsg(CommonProto.TaskOperationType.valueOf(operation), + reported, 3, 20L, 42L, Locale.forLanguageTag(language)); + var response = sent.get(5, TimeUnit.SECONDS).getTaskOperationMsg(); + + assertFalse(response.getSuccess()); + assertEquals(13103002, response.getErrorCode().getValue()); + assertEquals(language.equals("en") ? SOURCE_FAILED_EN : SOURCE_FAILED_ZH, + response.getErrorMsg().getValue()); + assertEquals(CommonProto.TaskOperationType.valueOf(operation), response.getOperationType()); + assertEquals(3, response.getSingleTaskIndex()); + assertEquals(20L, response.getDashboardId()); + assertEquals(42L, response.getRequestId()); + } + } + } +} diff --git a/apps/backend/crydaq-service/src/test/java/com/opentest/service/can/CanProjectChannelServiceTest.java b/apps/backend/crydaq-service/src/test/java/com/opentest/service/can/CanProjectChannelServiceTest.java new file mode 100644 index 00000000..6e7fb4cf --- /dev/null +++ b/apps/backend/crydaq-service/src/test/java/com/opentest/service/can/CanProjectChannelServiceTest.java @@ -0,0 +1,293 @@ +package com.opentest.service.can; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.node.ObjectNode; +import com.opentest.common.exception.CryBusinessException; +import com.opentest.common.exception.JniBusinessException; +import com.opentest.common.model.dto.BoxChannelDto; +import com.opentest.common.model.dto.CanChannelSaveRequestDto; +import com.opentest.common.model.entity.BoxChannel; +import com.opentest.common.model.entity.Device; +import com.opentest.common.model.entity.Project; +import com.opentest.common.model.query.BoxChannelQuery; +import com.opentest.core.jni.CanJNIBridge; +import com.opentest.service.BoxChannelService; +import com.opentest.service.DeviceService; +import com.opentest.service.ProjectService; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import org.mockito.ArgumentCaptor; + +import java.util.List; +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyLong; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.doAnswer; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoInteractions; +import static org.mockito.Mockito.verifyNoMoreInteractions; +import static org.mockito.Mockito.when; + +class CanProjectChannelServiceTest { + private static final ObjectMapper JSON = new ObjectMapper(); + static final String MANUAL = """ + {"schemaVersion":1,"portId":"can0","decodeMethod":"manual", + "definition":{"signalId":"browser-forgery","canId":384,"idFormat":"standard", + "frameType":"any","byteOrder":"intel","valueType":"unsigned","startBit":0, + "bitLength":16,"factor":1,"offset":0,"timeoutMs":1000,"unit":"rpm"}, + "quantity":"ROTATIONAL_SPEED","sourceUnit":"rpm","outputUnit":"rpm","tachoPpr":null} + """; + private final BoxChannelService channels = mock(BoxChannelService.class); + private final ProjectService projects = mock(ProjectService.class); + private final DeviceService devices = mock(DeviceService.class); + private final CanJNIBridge nativeCan = mock(OfflineCanBridge.class); + private final CanProjectChannelService service = new CanProjectChannelService(channels, projects, devices, nativeCan); + + // Mockito cannot intercept a native method; substitute only the external JNI boundary. + static class OfflineCanBridge extends CanJNIBridge { + @Override public String validateCanSignalDefinitionsV1(String definitions) { throw new UnsupportedOperationException(); } + } + + @BeforeEach + void setUp() { + Project project = new Project(); + project.setId(11L); + project.setTenantId(7L); + when(projects.findById(11L)).thenReturn(project); + Device device = new Device(); + device.setId(22L); + device.setTenantId(7L); + device.setProtocol("OPENDAQ"); + device.setDeviceName("native-serial-A"); + device.setActiveState(0); + when(devices.findById(22L)).thenReturn(device); + when(channels.list(any(BoxChannelQuery.class))).thenReturn(List.of()); + when(channels.getProjectInputChannelMap(11L)).thenReturn(Map.of()); + when(nativeCan.validateCanSignalDefinitionsV1(anyString())).thenAnswer(invocation -> + success(JSON.readTree(invocation.getArgument(0, String.class)).path("signals").get(0))); + doAnswer(invocation -> { + BoxChannel channel = invocation.getArgument(0); + if (channel.getId() == null) channel.setId(33L); + return channel; + }).when(channels).saveOrUpdateEntity(any(BoxChannel.class)); + when(channels.findDtoById(anyLong())).thenAnswer(invocation -> { + BoxChannelDto result = new BoxChannelDto(); + result.setId(invocation.getArgument(0)); + return result; + }); + } + + @Test + void savesOfflineWithServerIdentityAndNoAudioFactsOrReceptionCalls() throws Exception { + CanChannelSaveRequestDto request = request(); + service.save(request); + var saved = ArgumentCaptor.forClass(BoxChannel.class); + verify(channels).saveOrUpdateEntity(saved.capture()); + BoxChannel row = saved.getValue(); + assertEquals(2, row.getChannelSource()); + assertEquals("CAN1", row.getVchId()); + assertEquals("Engine speed", row.getCustomName()); + assertEquals(7L, row.getTenantId()); + assertEquals(22L, row.getDeviceId()); + assertNull(row.getChannelId()); + assertNull(row.getSamplingRate()); + assertNull(row.getJniChannelNumber()); + assertNull(row.getBitDepth()); + assertNull(row.getSensitivity()); + assertNull(row.getCalibrationDate()); + assertEquals("can:11:CAN1", JSON.readTree(row.getCanDefinitionJson()).path("definition").path("signalId").asText()); + verify(nativeCan).validateCanSignalDefinitionsV1(anyString()); + verifyNoMoreInteractions(nativeCan); + verify(projects).modifyCollectionInputConfig(eq(11L), any(), any()); + } + + @Test + void editingRetainsRowAndVchIdentityAndRefreshesOrdinaryReferences() { + BoxChannel existing = existing(); + when(channels.findById(33L)).thenReturn(existing); + CanChannelSaveRequestDto request = request(); + request.setId(33L); + request.setVchId("CAN9"); + service.save(request); + var saved = ArgumentCaptor.forClass(BoxChannel.class); + verify(channels).saveOrUpdateEntity(saved.capture()); + assertEquals(33L, saved.getValue().getId()); + assertEquals("CAN9", saved.getValue().getVchId()); + verify(channels).refreshCanChannelReferences(11L, existing); + } + + @Test + void explicitlyReplacingAnOfflineDeviceKeepsTheProjectChannelIdentityAndDoesNotOpenReception() { + BoxChannel existing = existing(); + when(channels.findById(33L)).thenReturn(existing); + Device replacement = new Device(); + replacement.setId(44L); + replacement.setTenantId(7L); + replacement.setProtocol("OPENDAQ"); + replacement.setDeviceName("native-serial-B"); + replacement.setActiveState(0); + when(devices.findById(44L)).thenReturn(replacement); + CanChannelSaveRequestDto request = request(); + request.setId(33L); + request.setVchId("CAN9"); + request.setDeviceId(44L); + + service.save(request); + + var saved = ArgumentCaptor.forClass(BoxChannel.class); + verify(channels).saveOrUpdateEntity(saved.capture()); + assertEquals(33L, saved.getValue().getId()); + assertEquals("CAN9", saved.getValue().getVchId()); + assertEquals(44L, saved.getValue().getDeviceId()); + assertEquals(22L, existing.getDeviceId()); + verify(channels).refreshCanChannelReferences(11L, existing); + verify(nativeCan).validateCanSignalDefinitionsV1(anyString()); + verifyNoMoreInteractions(nativeCan); + } + + @Test + void rejectsCrossProjectOrDeviceScopeAndForeignChannelSourceBeforeNative() { + BoxChannel existing = existing(); + existing.setProjectId(99L); + when(channels.findById(33L)).thenReturn(existing); + CanChannelSaveRequestDto request = request(); + request.setId(33L); + assertThrows(CryBusinessException.class, () -> service.save(request)); + Device device = devices.findById(22L); + device.setTenantId(99L); + request.setId(null); + assertThrows(CryBusinessException.class, () -> service.save(request)); + device.setTenantId(7L); + existing.setChannelSource(1); + request.setId(33L); + assertThrows(CryBusinessException.class, () -> service.save(request)); + verifyNoInteractions(nativeCan); + verify(channels, never()).saveOrUpdateEntity(any()); + } + + @Test + void rejectsNameCollisionWithAnyProjectChannel() { + BoxChannel physical = new BoxChannel(); + physical.setId(44L); + physical.setCustomName("Engine speed"); + when(channels.list(any(BoxChannelQuery.class))).thenReturn(List.of(physical)); + assertThrows(CryBusinessException.class, () -> service.save(request())); + verifyNoInteractions(nativeCan); + } + + @ParameterizedTest + @ValueSource(strings = { + "{}", "{\"code\":0,\"data\":{}}", + "{\"code\":0,\"data\":{\"valid\":false,\"issues\":[],\"signals\":[null]}}", + "{\"code\":0,\"data\":{\"valid\":true,\"issues\":[{\"index\":0}],\"signals\":[{}]}}", + "{\"code\":0,\"data\":{\"valid\":true,\"issues\":[],\"signals\":[]}}", + "{\"code\":0,\"data\":{\"valid\":true,\"issues\":[],\"signals\":[null]}}", + "{\"code\":0,\"data\":{\"valid\":true,\"issues\":[],\"signals\":[{\"signalId\":\"forged\"}]}}" + }) + void rejectsIncompleteOrInvalidNativeValidationEvenOnZeroCode(String response) { + when(nativeCan.validateCanSignalDefinitionsV1(anyString())).thenReturn(response); + assertThrows(CryBusinessException.class, () -> service.save(request())); + verify(channels, never()).saveOrUpdateEntity(any()); + verify(projects, never()).modifyCollectionInputConfig(any(), any(), any()); + } + + @Test + void preservesNativeErrorCodeAndDoesNotPersist() { + when(nativeCan.validateCanSignalDefinitionsV1(anyString())).thenReturn("{\"code\":13103001,\"data\":null}"); + JniBusinessException failure = assertThrows(JniBusinessException.class, () -> service.save(request())); + assertEquals(13103001, failure.getErrcode()); + verify(channels, never()).saveOrUpdateEntity(any()); + } + + @ParameterizedTest + @ValueSource(strings = {"0", "-1", "1.5", "\"48\"", "2147483648", "null"}) + void rejectsInvalidTachoPprBeforeNative(String ppr) throws Exception { + ObjectNode definition = (ObjectNode) JSON.readTree(MANUAL); + definition.put("quantity", "TACHO"); + definition.put("sourceUnit", "Hz"); + definition.set("tachoPpr", JSON.readTree(ppr)); + assertThrows(CryBusinessException.class, () -> service.validateDefinition(definition.toString(), 11L, "CAN1")); + verifyNoInteractions(nativeCan); + } + + @ParameterizedTest + @ValueSource(strings = {"FREQUENCY,V,rpm", "ROTATIONAL_SPEED,Hz,rpm", "SPEED,km/h,V", + "TEMPERATURE,degC,rpm", "VOLTAGE,rpm,V", "TACHO,kHz,rpm"}) + void rejectsIncompatibleSemanticUnits(String tuple) throws Exception { + String[] parts = tuple.split(","); + ObjectNode definition = (ObjectNode) JSON.readTree(MANUAL); + definition.put("quantity", parts[0]); + definition.put("sourceUnit", parts[1]); + definition.put("outputUnit", parts[2]); + if (parts[0].equals("TACHO")) definition.put("tachoPpr", 48); + assertThrows(CryBusinessException.class, () -> service.validateDefinition(definition.toString(), 11L, "CAN1")); + verifyNoInteractions(nativeCan); + } + + @Test + void genericPatchPreservesDefinitionAndRejectsAudioInjection() throws Exception { + BoxChannel existing = existing(); + when(channels.findById(33L)).thenReturn(existing); + service.patch(existing, JSON.readTree("{\"id\":\"33\",\"customName\":\"Renamed\"}")); + var saved = ArgumentCaptor.forClass(BoxChannel.class); + verify(channels).saveOrUpdateEntity(saved.capture()); + assertEquals("Renamed", saved.getValue().getCustomName()); + assertEquals("can:11:CAN9", JSON.readTree(saved.getValue().getCanDefinitionJson()).path("definition").path("signalId").asText()); + assertThrows(CryBusinessException.class, + () -> service.patch(existing, JSON.readTree("{\"samplingRate\":48000}"))); + } + + @Test + void deleteUsesNormalCascadeWithoutTouchingNative() { + BoxChannel existing = existing(); + when(channels.findById(33L)).thenReturn(existing); + when(channels.removeById(33L)).thenReturn(true); + assertTrue(service.delete(33L)); + verify(channels).removeById(33L); + verify(projects).modifyCollectionInputConfig(eq(11L), any(), any()); + verifyNoInteractions(nativeCan); + } + + private CanChannelSaveRequestDto request() { + CanChannelSaveRequestDto request = new CanChannelSaveRequestDto(); + request.setProjectId(11L); + request.setDeviceId(22L); + request.setCustomName(" Engine speed "); + request.setCanDefinitionJson(MANUAL); + return request; + } + + private BoxChannel existing() { + BoxChannel channel = new BoxChannel(); + channel.setId(33L); + channel.setProjectId(11L); + channel.setTenantId(7L); + channel.setDeviceId(22L); + channel.setVchId("CAN9"); + channel.setVchIdNumber(9); + channel.setChannelSource(2); + channel.setCanDefinitionJson(MANUAL); + channel.setCustomName("Old name"); + return channel; + } + + private String success(JsonNode definition) { + ObjectNode response = JSON.createObjectNode().put("code", 0); + ObjectNode data = response.putObject("data").put("valid", true); + data.putArray("issues"); + data.putArray("signals").add(definition); + return response.toString(); + } +} diff --git a/apps/backend/crydaq-service/src/test/java/com/opentest/service/can/CanProjectDbcChannelTest.java b/apps/backend/crydaq-service/src/test/java/com/opentest/service/can/CanProjectDbcChannelTest.java new file mode 100644 index 00000000..aea9dfac --- /dev/null +++ b/apps/backend/crydaq-service/src/test/java/com/opentest/service/can/CanProjectDbcChannelTest.java @@ -0,0 +1,233 @@ +package com.opentest.service.can; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.node.ObjectNode; +import com.opentest.common.exception.CryBusinessException; +import com.opentest.common.model.dto.CanChannelSaveRequestDto; +import com.opentest.common.model.dto.ChannelDto; +import com.opentest.common.model.dto.ProjectExportDto; +import com.opentest.common.model.entity.BoxChannel; +import com.opentest.common.model.entity.Device; +import com.opentest.common.model.entity.Project; +import com.opentest.common.model.query.BoxChannelQuery; +import com.opentest.dashboard.api.channel.CanSignalChannel; +import com.opentest.service.BoxChannelService; +import com.opentest.service.DeviceService; +import com.opentest.service.ProjectService; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.Base64; +import java.util.List; +import java.util.Map; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.io.TempDir; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import org.mockito.ArgumentCaptor; +import org.springframework.test.util.ReflectionTestUtils; +import static com.opentest.service.can.CanDbcServiceTest.BYTES; +import static com.opentest.service.can.CanDbcServiceTest.JSON; +import static com.opentest.service.can.CanDbcServiceTest.document; +import static com.opentest.service.can.CanDbcServiceTest.response; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyList; +import static org.mockito.ArgumentMatchers.anyLong; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +class CanProjectDbcChannelTest { + private final CanDbcServiceTest.Bridge bridge = new CanDbcServiceTest.Bridge(); + private final BoxChannelService channels = mock(BoxChannelService.class); + private final ProjectService projects = mock(ProjectService.class); + private final DeviceService devices = mock(DeviceService.class); + private final CanProjectChannelService service = new CanProjectChannelService(channels, projects, devices, bridge); + + @ParameterizedTest + @ValueSource(strings = {"canId", "idFormat", "byteOrder", "valueType", "startBit", "bitLength", "factor", "offset", "unit"}) + void forgedDecoderFieldsCannotBeSaved(String field) throws Exception { + ObjectNode root = document(); ObjectNode rule = (ObjectNode) root.path("definition"); + if (rule.path(field).isNumber()) rule.put(field, 99); + else rule.put(field, "forged"); + rejectSave(root); + assertEquals(0, bridge.validationCalls); + } + + @ParameterizedTest + @ValueSource(strings = {"messageId", "signalName", "fileName", "contentBase64", "extraField"}) + void invalidFileOrExactSelectionDoesNotPersist(String field) throws Exception { + ObjectNode root = document(); ObjectNode dbc = (ObjectNode) root.path("dbc"); + dbc.put(field, switch (field) { + case "messageId" -> "384"; + case "signalName" -> "rpm"; + case "fileName" -> "../original.dbc"; + case "contentBase64" -> "%%%"; + default -> "unapproved"; + }); + rejectSave(root); + } + + @Test void unsupportedSignalAndNativeFailureLeaveExistingDocumentIntact() throws Exception { + ObjectNode original = document(); + ObjectNode unsupported = response(); + ((ObjectNode) signal(unsupported)).put("supported", false).put("unsupportedReason", "floating point").putNull("definition"); + bridge.parseResponse = unsupported.toString(); rejectSave(original); + assertEquals(document(), original); + bridge.parseResponse = response().put("code", 13103001).toString(); rejectSave(original); + assertEquals(document(), original); + } + + @ParameterizedTest + @ValueSource(strings = {"rpm,rotational-speed,rpm,FREQUENCY", "Hz,frequency,hz,CUSTOM", "kHz,frequency,khz,TACHO", + "mV,voltage,mv,CUSTOM", "unknown,custom,unknown,VOLTAGE", "m/s,speed,m/s,CUSTOM", "degC,temperature,degc,CUSTOM"}) + void quantityCannotBypassNativeUnitMetadata(String tuple) throws Exception { + String[] parts = tuple.split(","); + ObjectNode root = withUnit(parts[0], parts[1], parts[2]); + root.put("quantity", parts[3]); + root.put("outputUnit", switch (parts[3]) { case "VOLTAGE" -> "V"; case "CUSTOM" -> parts[0]; default -> "rpm"; }); + if ("TACHO".equals(parts[3])) root.put("tachoPpr", 48); + rejectSave(root); + } + + @ParameterizedTest + @ValueSource(strings = {"Hz,frequency,hz,FREQUENCY,Hz", "Hz,frequency,hz,TACHO,rpm", "kHz,frequency,khz,FREQUENCY,Hz", + "MHz,frequency,mhz,FREQUENCY,rpm", "RPM,rotational-speed,rpm,ROTATIONAL_SPEED,rpm", "mV,voltage,mv,VOLTAGE,V", + "m/s,speed,m/s,SPEED,km/h", "degC,temperature,degc,TEMPERATURE,K", "\u2103,temperature,\u2103,TEMPERATURE,degF", + "\u2109,temperature,\u2109,TEMPERATURE,degC", "unknown,custom,unknown,CUSTOM,display"}) + void allowedNativeQuantitiesRetainSourceUnitVerbatim(String tuple) throws Exception { + String[] parts = tuple.split(","); + ObjectNode root = withUnit(parts[0], parts[1], parts[2]); + root.put("quantity", parts[3]).put("outputUnit", parts[4]); + if ("TACHO".equals(parts[3])) root.put("tachoPpr", 48); + JsonNode saved = JSON.readTree(service.validateDefinition(root.toString(), 11L, "CAN1")); + assertEquals(parts[0], saved.path("sourceUnit").asText()); + assertEquals(parts[0], saved.path("definition").path("unit").asText()); + } + + @Test void numericSpellingAgreesAndOnlyApprovedOverridesReachValidation() throws Exception { + ObjectNode root = document(); ObjectNode rule = (ObjectNode) root.path("definition"); + rule.put("startBit", 0.0).put("offset", -2.0).put("frameType", "fd") + .put("timeoutMs", 55).put("invalidRawValue", "0xFFFF").put("signalId", "browser-id"); + JsonNode saved = JSON.readTree(service.validateDefinition(root.toString(), 11L, "CAN1")); + JsonNode derived = saved.path("definition"); + assertEquals("can:11:CAN1", derived.path("signalId").asText()); + assertEquals("fd", derived.path("frameType").asText()); + assertEquals(55, derived.path("timeoutMs").intValue()); + assertEquals("0xFFFF", derived.path("invalidRawValue").asText()); + assertEquals(0.1, derived.path("factor").doubleValue()); + assertEquals(root.path("dbc"), saved.path("dbc")); + } + + @Test void repeatedImportAndEquivalentManualProduceSameDecoder() throws Exception { + String first = service.validateDefinition(document().toString(), 11L, "CAN1"); + String second = service.validateDefinition(first, 12L, "CAN1"); + String third = service.validateDefinition(second, 12L, "CAN1"); + ObjectNode manual = document(); manual.put("decodeMethod", "manual"); manual.remove("dbc"); + JsonNode savedManual = JSON.readTree(service.validateDefinition(manual.toString(), 12L, "CAN1")); + assertEquals(JSON.readTree(second), JSON.readTree(third)); + assertEquals(savedManual.path("definition"), JSON.readTree(second).path("definition")); + assertEquals("can:12:CAN1", savedManual.path("definition").path("signalId").asText()); + assertEquals(3, bridge.inputs.size()); + for (byte[] input : bridge.inputs) assertArrayEquals(BYTES, input); + } + + @Test void savePersistsCompleteDbcDocumentWithOrdinaryProjectIdentity() throws Exception { + Project project = new Project(); project.setId(11L); project.setTenantId(7L); + when(projects.findById(11L)).thenReturn(project); when(devices.findById(22L)).thenReturn(device(22L)); + when(channels.list(any(BoxChannelQuery.class))).thenReturn(List.of()); + when(channels.getProjectInputChannelMap(11L)).thenReturn(Map.of()); + CanChannelSaveRequestDto request = new CanChannelSaveRequestDto(); request.setProjectId(11L); + request.setDeviceId(22L); request.setCustomName(" Engine "); request.setCanDefinitionJson(document().toString()); + service.save(request); + ArgumentCaptor captured = ArgumentCaptor.forClass(BoxChannel.class); + verify(channels).saveOrUpdateEntity(captured.capture()); + BoxChannel saved = captured.getValue(); + assertEquals("CAN1", saved.getVchId()); assertEquals("Engine", saved.getCustomName()); + assertEquals(2, saved.getChannelSource()); assertEquals(0, saved.getChannelIo()); + JsonNode persisted = JSON.readTree(saved.getCanDefinitionJson()); + assertEquals(document().path("dbc"), persisted.path("dbc")); + assertEquals("can:11:CAN1", persisted.path("definition").path("signalId").asText()); + assertArrayEquals(BYTES, bridge.inputs.getFirst()); + } + + @Test void projectExportReopenAndRealImportUseFrozenBytesAfterOriginalFileDeletion(@TempDir Path directory) throws Exception { + Path file = directory.resolve("original.dbc"); Files.write(file, BYTES); + ObjectNode root = document(); + ((ObjectNode) root.path("dbc")).put("contentBase64", Base64.getEncoder().encodeToString(Files.readAllBytes(file))); + BoxChannel source = new BoxChannel(); source.setId(33L); source.setProjectId(11L); source.setTenantId(7L); + source.setDeviceId(22L); source.setProtocol("OPENDAQ"); source.setChannelIo(0); source.setChannelSource(2); + source.setVchId("CAN1"); source.setVchIdNumber(1); source.setCustomName("Engine"); + source.setCanDefinitionJson(service.validateDefinition(root.toString(), 11L, "CAN1")); + ProjectExportDto exported = new ProjectExportDto(); exported.setBoxChannels(List.of(source)); + byte[] archive = JSON.writeValueAsBytes(exported); Files.delete(file); + ProjectExportDto reopened = JSON.readValue(archive, ProjectExportDto.class); + ProjectService importer = new ProjectService(); + ReflectionTestUtils.setField(importer, "boxChannelService", channels); + ReflectionTestUtils.setField(importer, "canProjectChannelService", service); + ReflectionTestUtils.invokeMethod(importer, "createBoxChannelsFromExport", reopened.getBoxChannels(), 7L, 101L, + Map.of(22L, 88L), Map.of()); + ArgumentCaptor> captured = ArgumentCaptor.forClass(List.class); + verify(channels).baseServiceBatchAdd(captured.capture()); + BoxChannel imported = captured.getValue().getFirst(); + JsonNode saved = JSON.readTree(imported.getCanDefinitionJson()); + assertEquals(root.path("dbc"), saved.path("dbc")); + assertEquals("can:101:CAN1", saved.path("definition").path("signalId").asText()); + assertEquals(88L, imported.getDeviceId()); + assertEquals(2, bridge.inputs.size()); + assertArrayEquals(BYTES, bridge.inputs.getLast()); + + ChannelDto row = row(imported.getCanDefinitionJson(), 101L, 88L); + CanSignalChannel facts = CanProjectChannelFacts.resolve(row, device(88L)); + CanProjectChannelFacts.requireMatches(row, facts); + assertEquals(2, bridge.inputs.size()); + ObjectNode changed = (ObjectNode) saved.deepCopy(); ((ObjectNode) changed.path("dbc")).put("fileName", "renamed.dbc"); + assertNotEquals(facts.definitionFingerprint(), CanProjectChannelFacts.fingerprint(changed.toString())); + row.setCanDefinitionJson(changed.toString()); + assertThrows(IllegalArgumentException.class, () -> CanProjectChannelFacts.requireMatches(row, facts)); + } + + @Test void factsRejectMalformedFrozenMetadataWithoutParsingNative() throws Exception { + ObjectNode root = document(); ((ObjectNode) root.path("dbc")).put("contentBase64", "%%%"); + assertThrows(IllegalArgumentException.class, () -> CanProjectChannelFacts.resolve(row(root.toString(), 11L, 22L), device(22L))); + assertEquals(0, bridge.inputs.size()); + } + + private ObjectNode withUnit(String unit, String category, String normalized) throws Exception { + ObjectNode parsed = response(); ObjectNode signal = (ObjectNode) signal(parsed); + signal.put("unit", unit); ((ObjectNode) signal.path("definition")).put("unit", unit); + signal.putObject("unitMetadata").put("category", category).put("normalizedUnit", normalized); + bridge.parseResponse = parsed.toString(); + ObjectNode root = document(); root.put("sourceUnit", unit); ((ObjectNode) root.path("definition")).put("unit", unit); + return root; + } + + private static JsonNode signal(JsonNode response) { return response.path("data").path("messages").get(0).path("signals").get(0); } + + private void rejectSave(ObjectNode root) { + Project project = new Project(); project.setId(11L); project.setTenantId(7L); + when(projects.findById(11L)).thenReturn(project); when(devices.findById(22L)).thenReturn(device(22L)); + when(channels.list(any(BoxChannelQuery.class))).thenReturn(List.of()); + CanChannelSaveRequestDto request = new CanChannelSaveRequestDto(); request.setProjectId(11L); + request.setDeviceId(22L); request.setCustomName("Engine"); request.setCanDefinitionJson(root.toString()); + assertThrows(CryBusinessException.class, () -> service.save(request)); + verify(channels, never()).saveOrUpdateEntity(any()); + verify(channels, never()).baseServiceBatchAdd(anyList()); + verify(channels, never()).getProjectInputChannelMap(anyLong()); + } + + private static Device device(Long id) { + Device device = new Device(); device.setId(id); device.setTenantId(7L); + device.setProtocol("OPENDAQ"); device.setDeviceName("native-serial-A"); return device; + } + + private static ChannelDto row(String document, Long projectId, Long deviceId) { + ChannelDto row = new ChannelDto(); row.setBoxChannelId(33L); row.setProjectId(projectId); row.setDeviceId(deviceId); + row.setTenantId(7L); row.setChannelSource(2); row.setChannelIo(0); row.setVchId("CAN1"); row.setVchIdNumber(1); + row.setProtocol("OPENDAQ"); row.setCustomName("Engine"); row.setCanDefinitionJson(document); return row; + } +} diff --git a/apps/backend/crydaq-service/src/test/java/com/opentest/service/can/CanRawRecordingLifecycleTest.java b/apps/backend/crydaq-service/src/test/java/com/opentest/service/can/CanRawRecordingLifecycleTest.java new file mode 100644 index 00000000..906300d3 --- /dev/null +++ b/apps/backend/crydaq-service/src/test/java/com/opentest/service/can/CanRawRecordingLifecycleTest.java @@ -0,0 +1,422 @@ +package com.opentest.service.can; + +import cn.hutool.json.JSONArray; +import cn.hutool.json.JSONConfig; +import cn.hutool.json.JSONObject; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.opentest.common.model.entity.Device; +import com.opentest.dashboard.api.channel.CanPortBinding; +import com.opentest.dashboard.api.channel.CanSignalChannel; +import com.opentest.dashboard.api.channel.CanSignalQuantity; +import com.opentest.dashboard.api.channel.CanSignalUnits; +import com.opentest.service.DeviceService; +import com.opentest.service.jni.AudioJNIBridgeService; +import java.io.StringWriter; +import java.math.BigInteger; +import java.nio.file.Path; +import java.util.ArrayDeque; +import java.util.List; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.concurrent.atomic.AtomicReference; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.io.TempDir; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import org.springframework.test.util.ReflectionTestUtils; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyBoolean; +import static org.mockito.ArgumentMatchers.anyList; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.doThrow; +import static org.mockito.Mockito.doAnswer; +import static org.mockito.Mockito.clearInvocations; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +class CanRawRecordingLifecycleTest { + @TempDir Path directory; + private CanService service; + private CanNativeGateway nativeCan; + private CanRawRecordingStore store; + private final ArrayDeque queued = new ArrayDeque<>(); + private final AtomicReference state = new AtomicReference<>("running"); + private JSONObject lastFrame; + private long ordinal; + private boolean complete = true; + private JSONObject integrity; + + @BeforeEach void setup() { + DeviceService devices = mock(DeviceService.class); + AudioJNIBridgeService audio = mock(AudioJNIBridgeService.class); + Device device = new Device(); device.setProtocol("OPENDAQ"); device.setDeviceName("Raw device"); + device.setIpAddress("address"); + when(devices.findById(1L)).thenReturn(device); + when(audio.getJniDeviceId(device)).thenReturn("native-raw"); + nativeCan = mock(CanNativeGateway.class); + when(nativeCan.capabilities(anyString(), anyString())).thenReturn(new JSONObject().set("ports", + new JSONArray().put(new JSONObject().set("portId", "CAN1")))); + when(nativeCan.start(anyString(), anyString(), anyString(), any())).thenReturn(new JSONObject().set("receiveId", "raw-source")); + when(nativeCan.status(anyString(), anyString(), anyString())).thenAnswer(call -> + object().set("application", application())); + when(nativeCan.readFrames(anyString())).thenAnswer(call -> readBatch()); + when(nativeCan.validateDefinitions(any())).thenReturn(new JSONObject().set("valid", true)); + when(nativeCan.subscribe(anyString(), any())).thenReturn(new JSONObject().set("subscriptionId", "monitor-subscription")); + store = new CanRawRecordingStore(directory, new ObjectMapper()); + service = new CanService(devices, audio, nativeCan, mock(CanConfigurationStore.class)); + ReflectionTestUtils.setField(service, "recordings", store); + } + @AfterEach void close() { service.close(); } + private JSONObject object() { return new JSONObject(JSONConfig.create().setIgnoreNullValue(false)); } + + private JSONObject application() { + return object().set("receiveId", "raw-source").set("state", state.get()) + .set("complete", complete && "running".equals(state.get())).set("integrity", integrity) + .set("sourceObservations", object().set("lastFrameIdentity", lastFrame)) + .set("applicationStats", object().set("queuedFrames", Integer.toString(queued.size()))); + } + + private JSONObject readBatch() { + JSONArray batch = new JSONArray(); + while (!queued.isEmpty() && batch.size() < 64) batch.add(queued.removeFirst()); + return application().set("frames", batch).set("epoch", "1"); + } + + private void produce(int count) { + for (int index = 0; index < count; index++) { + String sequence = new BigInteger("9007199254740993").add(BigInteger.valueOf(ordinal++)).toString(); + lastFrame = object().set("sequence", sequence).set("sessionEpoch", "9007199254740995").set("canId", 384) + .set("flags", 0).set("idFormat", "standard").set("frameType", "classic") + .set("length", 8).set("dlc", 8).set("dataHex", "E803FA0000000000").set("source", "bus-rx") + .set("rawTimestampNs", "1700000000000000000").set("timestampSource", "device-software-rx") + .set("rawClockId", 0).set("mappingRevision", "1").set("measurementTimeValid", false) + .set("measurementTimeNs", null); + queued.addLast(lastFrame); + } + } + + @Test void stopDrainsOnlyFrozenPrefixAndPreviewsPostCutoffFramesInSameBatch() { + service.start(1L, "CAN1"); + produce(7); + String startSequence = lastFrame.getStr("sequence"); + String id = service.startRecording(1L, "CAN1").getJSONObject("recording").getStr("id"); + produce(130); + String stopSequence = lastFrame.getStr("sequence"); + clearInvocations(nativeCan); + doAnswer(call -> { + produce(64); + return readBatch(); + }).when(nativeCan).readFrames(anyString()); + JSONObject stopped = service.stopRecording(1L, "CAN1"); + assertEquals("running", stopped.getStr("state")); + assertNull(stopped.getJSONObject("recording")); + JSONObject saved = new CanRawRecordingStore(directory, new ObjectMapper()).history() + .getJSONArray("records").getJSONObject(0); + assertEquals("130", saved.getStr("frameCount")); + assertTrue(saved.getBool("complete")); + assertEquals(startSequence, saved.getJSONObject("startCutoff").getJSONObject("sourceObservations") + .getJSONObject("lastFrameIdentity").getStr("sequence")); + JSONObject cutoff = saved.getJSONObject("metadata").getJSONObject("stopCutoff"); + assertEquals(stopSequence, cutoff.getJSONObject("sourceObservations") + .getJSONObject("lastFrameIdentity").getStr("sequence")); + assertEquals("9007199254740995", cutoff.getJSONObject("sourceObservations") + .getJSONObject("lastFrameIdentity").getStr("sessionEpoch")); + assertEquals("137", cutoff.getJSONObject("applicationStats").getStr("queuedFrames")); + JSONArray frames = store.preview(id, 0, 1000).getJSONArray("frames"); + for (int index = 0; index < 130; index++) + assertEquals(new BigInteger(startSequence).add(BigInteger.valueOf(index + 1)).toString(), + frames.getJSONObject(index).getStr("sequence")); + StringWriter csv = new StringWriter(); store.csv(id, csv); + assertEquals(131, csv.toString().lines().count()); + assertEquals(192, service.frames(1L, "CAN1", "0").getJSONArray("frames").size()); + assertTrue(new BigInteger(service.frames(1L, "CAN1", "0").getStr("lastSequence")) + .compareTo(new BigInteger(stopSequence)) > 0); + assertFalse(queued.isEmpty()); + verify(nativeCan, times(3)).readFrames("raw-source"); + verify(nativeCan, times(1)).status(anyString(), anyString(), anyString()); + verify(nativeCan, never()).stop(anyString()); + verify(nativeCan, never()).close(anyString()); + } + + @Test void stopReceivingPersistsQueuedPrefixBeforeNativeStopAndExcludesLaterTail() { + service.start(1L, "CAN1"); + String id = service.startRecording(1L, "CAN1").getJSONObject("recording").getStr("id"); + produce(130); + when(nativeCan.stop("raw-source")).thenAnswer(call -> { + JSONObject saved = new CanRawRecordingStore(directory, new ObjectMapper()).history() + .getJSONArray("records").getJSONObject(0); + assertEquals("130", saved.getStr("frameCount")); + assertTrue(saved.getBool("complete")); + produce(5); + return object(); + }); + JSONObject stopped = service.stop(1L, "CAN1"); + assertEquals("stopped", stopped.getStr("state")); + assertNull(stopped.getStr("receiveId")); + assertEquals("130", store.preview(id, 0, 1000).getStr("frameCount")); + assertEquals(135, service.frames(1L, "CAN1", "0").getJSONArray("frames").size()); + verify(nativeCan).stop("raw-source"); + verify(nativeCan).close("raw-source"); + } + + @Test void emptyRecordingUsesCurrentStopMetadataWithoutReadingOrPreviewPreRoll() { + service.start(1L, "CAN1"); + produce(3); service.readSources(); + String boundary = lastFrame.getStr("sequence"); + service.startRecording(1L, "CAN1"); + clearInvocations(nativeCan); + service.stopRecording(1L, "CAN1"); + JSONObject saved = store.history().getJSONArray("records").getJSONObject(0); + assertEquals("0", saved.getStr("frameCount")); + assertTrue(saved.getBool("complete")); + assertEquals(boundary, saved.getJSONObject("metadata").getJSONObject("stopCutoff") + .getJSONObject("sourceObservations").getJSONObject("lastFrameIdentity").getStr("sequence")); + verify(nativeCan, never()).readFrames(anyString()); + } + + @Test void noFrameRecordingPreservesNullBoundaries() { + service.start(1L, "CAN1"); service.startRecording(1L, "CAN1"); + service.stopRecording(1L, "CAN1"); + JSONObject saved = store.history().getJSONArray("records").getJSONObject(0); + assertEquals("0", saved.getStr("frameCount")); + assertTrue(saved.getBool("complete")); + assertTrue(saved.getJSONObject("startCutoff").getJSONObject("sourceObservations").isNull("lastFrameIdentity")); + assertTrue(saved.getJSONObject("metadata").getJSONObject("stopCutoff") + .getJSONObject("sourceObservations").isNull("lastFrameIdentity")); + verify(nativeCan, never()).readFrames(anyString()); + } + + @Test void earlierQueueLossCannotBecomeCompleteAtStop() { + service.start(1L, "CAN1"); + integrity = object().set("complete", false).set("lostFrames", "17"); + service.startRecording(1L, "CAN1"); + integrity = null; + produce(130); + service.stopRecording(1L, "CAN1"); + JSONObject saved = store.history().getJSONArray("records").getJSONObject(0); + assertEquals("130", saved.getStr("frameCount")); + assertFalse(saved.getBool("complete")); + assertEquals("17", saved.getJSONObject("startCutoff").getJSONObject("integrity").getStr("lostFrames")); + } + + @Test void faultAtOperatorStopStillDrainsKnownPrefixAsPartial() { + service.start(1L, "CAN1"); service.startRecording(1L, "CAN1"); + produce(130); state.set("disconnected"); + service.stopRecording(1L, "CAN1"); + JSONObject saved = store.history().getJSONArray("records").getJSONObject(0); + assertEquals("130", saved.getStr("frameCount")); + assertFalse(saved.getBool("complete")); + assertEquals("disconnected", saved.getJSONObject("metadata").getJSONObject("stopCutoff").getStr("state")); + verify(nativeCan, never()).stop(anyString()); + } + + @ParameterizedTest + @ValueSource(ints = {0, 13103003, 13103006, 13103007}) + void disconnectedStopReleasesSourceWithoutChangingSealedRawPrefix(int closeError) { + service.start(1L, "CAN1"); service.startRecording(1L, "CAN1"); + produce(254); state.set("disconnected"); + service.readSources(); + JSONObject sealed = store.history().getJSONArray("records").getJSONObject(0); + String id = sealed.getStr("id"); + assertEquals("254", sealed.getStr("frameCount")); + assertFalse(sealed.getBool("complete")); + String before = sealed.toString(); + String framesBefore = store.preview(id, 0, 1000).getJSONArray("frames").toString(); + CanOperationException disconnected = new CanOperationException(13103007, "can.error.nativeFailure"); + when(nativeCan.stop("raw-source")).thenThrow(disconnected); + if (closeError != 0) when(nativeCan.close("raw-source")).thenThrow( + new CanOperationException(closeError, "can.error.nativeFailure")); + + CanOperationException failure = assertThrows(CanOperationException.class, () -> service.stop(1L, "CAN1")); + + assertEquals(disconnected, failure); + verify(nativeCan, times(1)).close("raw-source"); + JSONObject released = service.status(1L, "CAN1"); + assertNull(released.getStr("receiveId")); + assertNull(released.getJSONObject("recording")); + assertFalse(released.getBool("manualReceiving")); + assertEquals("stopped", released.getStr("state")); + assertEquals(13103007, released.getInt("lastErrorCode")); + verify(nativeCan, never()).enable(anyString(), anyString(), anyBoolean()); + verify(nativeCan, times(1)).start(anyString(), anyString(), anyString(), any()); + assertEquals(1, store.history().getJSONArray("records").size()); + assertEquals(before, store.history().getJSONArray("records").getJSONObject(0).toString()); + assertEquals(framesBefore, store.preview(id, 0, 1000).getJSONArray("frames").toString()); + assertEquals(254, store.preview(id, 0, 1000).getJSONArray("frames").size()); + } + + @Test void statusFailurePublishesPartialWithActualErrorAndDoesNotBlockLaterPortStop() { + service.start(1L, "CAN1"); service.startRecording(1L, "CAN1"); + produce(3); service.readSources(); + when(nativeCan.status(anyString(), anyString(), anyString())).thenThrow( + new CanOperationException(13103006, "can.error.deviceUnavailable")); + CanOperationException failure = assertThrows(CanOperationException.class, () -> service.stopRecording(1L, "CAN1")); + assertEquals(13103006, failure.code()); + assertEquals("can.error.deviceUnavailable", failure.messageKey()); + JSONObject saved = store.history().getJSONArray("records").getJSONObject(0); + assertEquals("3", saved.getStr("frameCount")); + assertFalse(saved.getBool("complete")); + assertEquals(13103006, saved.getJSONObject("metadata").getInt("recordingErrorCode")); + assertEquals("can.error.deviceUnavailable", saved.getJSONObject("metadata").getStr("recordingErrorKey")); + assertNull(service.stopRecording(1L, "CAN1").getJSONObject("recording")); + assertEquals("stopped", service.stop(1L, "CAN1").getStr("state")); + } + + @Test void readFailureKeepsDeliveredPrefixAndStopReceivingRemainsRetryable() { + service.start(1L, "CAN1"); service.startRecording(1L, "CAN1"); produce(130); + AtomicInteger reads = new AtomicInteger(); + doAnswer(call -> { + if (reads.incrementAndGet() == 2) + throw new CanOperationException(13103006, "can.error.deviceUnavailable"); + return readBatch(); + }).when(nativeCan).readFrames(anyString()); + CanOperationException failure = assertThrows(CanOperationException.class, () -> service.stop(1L, "CAN1")); + assertEquals(13103006, failure.code()); + JSONObject saved = store.history().getJSONArray("records").getJSONObject(0); + assertEquals("64", saved.getStr("frameCount")); + assertFalse(saved.getBool("complete")); + assertEquals(13103006, saved.getJSONObject("metadata").getInt("recordingErrorCode")); + assertEquals("stopped", service.stop(1L, "CAN1").getStr("state")); + verify(nativeCan).stop("raw-source"); + verify(nativeCan).close("raw-source"); + } + + @Test void emptyDeliveryBeforeCutoffFailsBoundedlyAndPreservesPartial() { + service.start(1L, "CAN1"); service.startRecording(1L, "CAN1"); produce(130); + doAnswer(call -> application().set("frames", new JSONArray())).when(nativeCan).readFrames(anyString()); + CanOperationException failure = assertThrows(CanOperationException.class, () -> service.stopRecording(1L, "CAN1")); + assertEquals("can.error.invalidResponse", failure.messageKey()); + JSONObject saved = store.history().getJSONArray("records").getJSONObject(0); + assertEquals("0", saved.getStr("frameCount")); + assertFalse(saved.getBool("complete")); + verify(nativeCan).readFrames("raw-source"); + verify(nativeCan, never()).stop(anyString()); + } + + @Test void stopReadStorageFailureIsIsolatedAndStillReleasesPort() { + var brokenStore = mock(CanRawRecordingStore.class); + var recording = mock(CanRawRecordingStore.Recording.class); + when(recording.id()).thenReturn("test-recording"); + when(recording.snapshot()).thenReturn(object().set("id", "test-recording")); + when(brokenStore.begin(any(), any())).thenReturn(recording); + doThrow(new CanOperationException(CanRawRecordingStore.STORAGE_ERROR, "can.recording.error.storage")) + .when(recording).append(anyList(), any()); + ReflectionTestUtils.setField(service, "recordings", brokenStore); + service.start(1L, "CAN1"); service.startRecording(1L, "CAN1"); produce(130); + CanOperationException failure = assertThrows(CanOperationException.class, () -> service.stop(1L, "CAN1")); + assertEquals(CanRawRecordingStore.STORAGE_ERROR, failure.code()); + verify(recording).finish(any(), eq(false)); + assertEquals("stopped", service.stop(1L, "CAN1").getStr("state")); + assertEquals(130, service.frames(1L, "CAN1", "0").getJSONArray("frames").size()); + verify(nativeCan).stop("raw-source"); + verify(nativeCan).close("raw-source"); + } + + @Test void finalizationStorageFailureKeepsReceptionHealthyAndDoesNotBlockStop() { + var brokenStore = mock(CanRawRecordingStore.class); + var recording = mock(CanRawRecordingStore.Recording.class); + when(recording.id()).thenReturn("test-recording"); + when(recording.snapshot()).thenReturn(object().set("id", "test-recording")); + when(brokenStore.begin(any(), any())).thenReturn(recording); + when(recording.finish(any(), anyBoolean())).thenThrow( + new CanOperationException(CanRawRecordingStore.STORAGE_ERROR, "can.recording.error.storage")); + ReflectionTestUtils.setField(service, "recordings", brokenStore); + service.start(1L, "CAN1"); service.startRecording(1L, "CAN1"); + CanOperationException failure = assertThrows(CanOperationException.class, () -> service.stopRecording(1L, "CAN1")); + assertEquals("can.recording.error.storage", failure.messageKey()); + JSONObject status = service.status(1L, "CAN1"); + assertEquals("running", status.getStr("state")); + assertNull(status.getInt("lastErrorCode")); + assertEquals(CanRawRecordingStore.STORAGE_ERROR, status.getInt("recordingErrorCode")); + assertNull(status.getJSONObject("recording")); + assertEquals("stopped", service.stop(1L, "CAN1").getStr("state")); + } + + @Test void recordingExcludesPreviewAndQueuedPreRollButCsvContainsMoreThanPreviewCapacity() { + service.start(1L, "CAN1"); + produce(25); service.readSources(); + produce(20); + JSONObject start = service.startRecording(1L, "CAN1"); + assertEquals("0", start.getJSONObject("recording").getStr("frameCount")); + String id = start.getJSONObject("recording").getStr("id"); + produce(1205); service.readSources(); + assertEquals(1000, service.frames(1L, "CAN1", "0").getJSONArray("frames").size()); + assertEquals("1205", service.status(1L, "CAN1").getJSONObject("recording").getStr("frameCount")); + JSONObject stopped = service.stopRecording(1L, "CAN1"); + assertNull(stopped.getJSONObject("recording")); + assertEquals("raw-source", stopped.getStr("receiveId")); + assertEquals("running", stopped.getStr("state")); + assertTrue(stopped.getBool("manualReceiving")); + JSONObject saved = new CanRawRecordingStore(directory, new ObjectMapper()).history().getJSONArray("records").getJSONObject(0); + assertEquals(id, saved.getStr("id")); + assertEquals("1205", saved.getStr("frameCount")); + JSONObject first = store.preview(id, 0, 1000).getJSONArray("frames").getJSONObject(0); + assertEquals(new BigInteger("9007199254740993").add(BigInteger.valueOf(45)).toString(), first.getStr("sequence")); + assertEquals("1", first.getJSONObject("origin").getStr("deviceId")); + StringWriter csv = new StringWriter(); store.csv(id, csv); + assertEquals(1206, csv.toString().lines().count()); + assertTrue(csv.toString().contains("1700000000000000000")); + verify(nativeCan, never()).stop(anyString()); + } + + @Test void recordingRetainsIndependentManualReceptionWhenMeasurementReleases() { + var signal = new CanSignalChannel("CAN1", "10", "20", "Speed", 1, + new CanPortBinding("1", "OPENDAQ", DeviceService.deviceIdentity("OPENDAQ", "Raw device", "address"), "CAN1"), + "{\"definition\":{\"canId\":384,\"bitLength\":16,\"startBit\":0}}", + new CanSignalUnits(CanSignalQuantity.ROTATIONAL_SPEED, "rpm", "rpm", null), "frozen"); + var monitor = service.acquire("monitor", "Monitor", List.of(signal)).getFirst(); + service.startRecording(1L, "CAN1"); + assertThrows(CanOperationException.class, () -> service.stop(1L, "CAN1")); + monitor.close(); + assertNotNull(service.status(1L, "CAN1").getJSONObject("recording")); + service.stopRecording(1L, "CAN1"); + verify(nativeCan, never()).stop(anyString()); + service.stop(1L, "CAN1"); + verify(nativeCan).stop("raw-source"); + } + + @Test void sourceFaultDrainsAllAvailableBatchesThenPublishesPartialWithoutResume() { + service.start(1L, "CAN1"); service.startRecording(1L, "CAN1"); + produce(130); state.set("disconnected"); + service.status(1L, "CAN1"); + service.readSources(); + JSONObject record = store.history().getJSONArray("records").getJSONObject(0); + assertEquals("130", record.getStr("frameCount")); + assertFalse(record.getBool("complete")); + assertNull(service.status(1L, "CAN1").getJSONObject("recording")); + state.set("running"); produce(5); service.readSources(); + assertEquals(1, store.history().getJSONArray("records").size()); + assertEquals("130", store.history().getJSONArray("records").getJSONObject(0).getStr("frameCount")); + } + + @Test void recordingWriteFailureDoesNotFailHealthyReception() { + var brokenStore = mock(CanRawRecordingStore.class); + var recording = mock(CanRawRecordingStore.Recording.class); + when(recording.id()).thenReturn("test-recording"); + when(recording.snapshot()).thenReturn(new JSONObject().set("id", "test-recording").set("frameCount", "0")); + when(brokenStore.begin(any(), any())).thenReturn(recording); + doThrow(new CanOperationException(CanRawRecordingStore.STORAGE_ERROR, "can.recording.error.storage")) + .when(recording).append(anyList(), any()); + ReflectionTestUtils.setField(service, "recordings", brokenStore); + service.start(1L, "CAN1"); service.startRecording(1L, "CAN1"); + produce(1); service.readSources(); + JSONObject status = service.status(1L, "CAN1"); + assertEquals("running", status.getStr("state")); + assertNull(status.getInt("lastErrorCode")); + assertEquals(CanRawRecordingStore.STORAGE_ERROR, status.getInt("recordingErrorCode")); + assertNull(status.getJSONObject("recording")); + assertEquals(1, service.frames(1L, "CAN1", "0").getJSONArray("frames").size()); + } +} diff --git a/apps/backend/crydaq-service/src/test/java/com/opentest/service/can/CanRawRecordingStoreTest.java b/apps/backend/crydaq-service/src/test/java/com/opentest/service/can/CanRawRecordingStoreTest.java new file mode 100644 index 00000000..9fd0799b --- /dev/null +++ b/apps/backend/crydaq-service/src/test/java/com/opentest/service/can/CanRawRecordingStoreTest.java @@ -0,0 +1,321 @@ +package com.opentest.service.can; + +import cn.hutool.json.JSONConfig; +import cn.hutool.json.JSONObject; +import cn.hutool.json.JSONUtil; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.io.TempDir; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +import java.io.IOException; +import java.io.Reader; +import java.io.StringWriter; +import java.io.Writer; +import java.math.BigInteger; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.List; +import java.util.UUID; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import java.util.stream.IntStream; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class CanRawRecordingStoreTest { + @TempDir Path base; + private final ObjectMapper mapper = new ObjectMapper(); + private CanRawRecordingStore store; + + @BeforeEach void setUp() { store = new CanRawRecordingStore(base, mapper); } + + @Test + void fullFramesDescriptorAndNullableFactsSurviveReopen() throws Exception { + JSONObject source = source().set("password", "do-not-persist").set("authorization", "do-not-persist"); + JSONObject cutoff = json("{\"sequence\":\"18446744073709551613\",\"epoch\":\"9007199254740999\"}"); + CanRawRecordingStore.Recording recording = store.begin(source, cutoff); + JsonNode initial = tree(recording.snapshot()); + assertTrue(initial.path("finishedAtEpochMs").isNull()); + assertEquals("0", initial.path("frameCount").textValue()); + assertEquals("9007199254740993", initial.path("deviceId").textValue()); + assertTrue(initial.path("startedAtEpochMs").isTextual()); + assertEquals(UUID.fromString(recording.id()).toString(), recording.id()); + assertEquals(0, store.history().getJSONArray("records").size()); + + JSONObject frame = frame("18446744073709551614"); + JsonNode expectedFrame = tree(frame); + JSONObject batch = json("{\"epoch\":\"9007199254740999\",\"complete\":false," + + "\"applicationStats\":{\"dropped\":\"18446744073709551615\",\"hardware\":null},\"frames\":[]}"); + recording.append(List.of(frame), batch); + frame.set("dataHex", "changed"); + cutoff.set("sequence", "changed"); + recording.snapshot().set("frameCount", "changed"); + JSONObject finished = recording.finish(json("{\"state\":\"stopped\",\"lastErrorCode\":null}"), true); + assertEquals("1", finished.getStr("frameCount")); + assertTrue(finished.getBool("complete")); + assertNotNull(finished.getStr("finishedAtEpochMs")); + + CanRawRecordingStore reopened = new CanRawRecordingStore(base, mapper); + JsonNode descriptor = tree(reopened.history()).path("records").get(0); + assertEquals(tree(finished), descriptor); + assertEquals("18446744073709551613", descriptor.path("startCutoff").path("sequence").textValue()); + assertEquals("18446744073709551615", descriptor.path("metadata").path("applicationStats").path("dropped").textValue()); + assertTrue(descriptor.path("metadata").path("applicationStats").path("hardware").isNull()); + assertTrue(descriptor.path("metadata").has("lastErrorCode")); + assertFalse(descriptor.path("metadata").has("frames")); + assertFalse(descriptor.toString().contains("do-not-persist")); + JsonNode preview = tree(reopened.preview(recording.id(), 0, 1000)); + assertEquals(expectedFrame, preview.path("frames").get(0)); + assertEquals("0", preview.path("offset").textValue()); + assertEquals("1", preview.path("nextOffset").textValue()); + assertEquals("1", preview.path("frameCount").textValue()); + assertTrue(preview.path("frames").get(0).path("measurementTimeNs").isNull()); + assertTrue(preview.path("frames").get(0).path("canId").isNumber()); + assertEquals(27, preview.path("frames").get(0).path("flags").intValue()); + Path directory = directory(recording.id()); + assertEquals(expectedFrame, mapper.readTree(Files.readString(directory.resolve("frames.jsonl")))); + try (var files = Files.list(directory)) { assertEquals(2, files.count()); } + } + + @Test + void sourceFaultSealsPartialRecordingWithoutLosingFramesOrTerminalFacts() throws Exception { + CanRawRecordingStore.Recording recording = store.begin(source(), json("{\"sequence\":\"8\"}")); + recording.append(List.of(frame("9"), frame("10")), json("{\"state\":\"running\",\"epoch\":\"42\"}")); + JSONObject ended = recording.finish(json("{\"state\":\"disconnected\",\"lastErrorCode\":13103018}"), false); + assertFalse(ended.getBool("complete")); + assertEquals("2", ended.getStr("frameCount")); + assertEquals("disconnected", ended.getJSONObject("metadata").getStr("state")); + assertEquals(13103018, ended.getJSONObject("metadata").getInt("lastErrorCode")); + assertEquals(tree(ended), tree(recording.finish(json("{\"state\":\"running\"}"), true))); + assertEquals(2, new CanRawRecordingStore(base, mapper).preview(recording.id(), 0, 10).getJSONArray("frames").size()); + assertThrows(CanOperationException.class, () -> recording.append(List.of(frame("11")), new JSONObject())); + } + + @Test + void csvStreamsEveryDiskFrameBeyondTheDisplayPageAndEscapesEveryField() throws Exception { + CanRawRecordingStore.Recording recording = store.begin(source(), new JSONObject()); + List frames = IntStream.range(0, 1507) + .mapToObj(index -> frame(new BigInteger("18446744073709551615").add(BigInteger.valueOf(index)).toString())).toList(); + recording.append(frames, new JSONObject()); + recording.finish(new JSONObject(), true); + CanRawRecordingStore reopened = new CanRawRecordingStore(base, mapper); + assertEquals(1000, reopened.preview(recording.id(), 0, 1000).getJSONArray("frames").size()); + JSONObject page = reopened.preview(recording.id(), 1000, 1000); + assertEquals(507, page.getJSONArray("frames").size()); + assertEquals("1507", page.getStr("nextOffset")); + assertEquals(0, reopened.preview(recording.id(), 1700, 10).getJSONArray("frames").size()); + + StringWriter output = new StringWriter(); + reopened.csv(recording.id(), output); + List> csv = csvRows(output.toString()); + assertEquals(1508, csv.size()); + int sequence = csv.get(0).indexOf("sequence"); + int deviceName = csv.get(0).indexOf("origin.deviceName"); + int frameJson = csv.get(0).indexOf("frameJson"); + for (int row = 1; row < csv.size(); row++) { + assertEquals(frames.get(row - 1).getStr("sequence"), csv.get(row).get(sequence)); + assertEquals("Device, \"quoted\"\r\nnext", csv.get(row).get(deviceName)); + assertEquals(tree(frames.get(row - 1)), mapper.readTree(csv.get(row).get(frameJson))); + } + } + + @Test + void deleteRemovesOnlyTheSelectedGlobalRecordingAndRejectsActiveDeletion() throws Exception { + Path project = Files.createDirectories(base.resolve("project-123")); + Files.writeString(project.resolve("retain.txt"), "project"); + CanRawRecordingStore.Recording first = store.begin(source(), new JSONObject()); + CanRawRecordingStore.Recording second = store.begin(source(), new JSONObject()); + assertEquals(CanRawRecordingStore.ACTIVE_RECORDING, + assertThrows(CanOperationException.class, () -> store.delete(first.id())).code()); + first.finish(new JSONObject(), true); + second.finish(new JSONObject(), false); + new CanRawRecordingStore(base, mapper).delete(first.id()); + assertFalse(Files.exists(directory(first.id()))); + assertTrue(Files.exists(directory(second.id()))); + assertEquals("project", Files.readString(project.resolve("retain.txt"))); + assertEquals(1, store.history().getJSONArray("records").size()); + assertEquals(CanRawRecordingStore.NOT_FOUND, + assertThrows(CanOperationException.class, () -> store.preview(first.id(), 0, 1)).code()); + } + + @ParameterizedTest + @ValueSource(strings = {"../outside", "/tmp/outside", "..\\outside", "file:recording", "not-a-uuid", ""}) + void callerPathsAreNeverRecordingIds(String id) { + assertEquals(CanRawRecordingStore.INVALID_REQUEST, + assertThrows(CanOperationException.class, () -> store.preview(id, 0, 1)).code()); + assertEquals(CanRawRecordingStore.INVALID_REQUEST, + assertThrows(CanOperationException.class, () -> store.delete(id)).code()); + assertEquals(CanRawRecordingStore.INVALID_REQUEST, + assertThrows(CanOperationException.class, () -> store.csv(id, new StringWriter())).code()); + } + + @Test + void rejectsInvalidPageSizesAndOffsets() { + assertThrows(CanOperationException.class, () -> store.preview(UUID.randomUUID().toString(), -1, 1)); + assertThrows(CanOperationException.class, () -> store.preview(UUID.randomUUID().toString(), 0, 0)); + assertThrows(CanOperationException.class, () -> store.preview(UUID.randomUUID().toString(), 0, 1001)); + } + + @Test + void symlinkedRecordingDirectoryAndFrameFileCannotEscapeStorage() throws Exception { + CanRawRecordingStore.Recording recording = store.begin(source(), new JSONObject()); + recording.finish(new JSONObject(), true); + Path external = Files.createDirectory(base.resolve("external")); + Path secret = Files.writeString(external.resolve("secret.txt"), "retain"); + Path frames = directory(recording.id()).resolve("frames.jsonl"); + Files.delete(frames); + Files.createSymbolicLink(frames, secret); + assertEquals(CanRawRecordingStore.STORAGE_ERROR, + assertThrows(CanOperationException.class, () -> store.csv(recording.id(), new StringWriter())).code()); + assertThrows(CanOperationException.class, () -> store.delete(recording.id())); + String linkedId = UUID.randomUUID().toString(); + Files.createSymbolicLink(directory(linkedId), external); + assertThrows(CanOperationException.class, () -> store.preview(linkedId, 0, 1)); + assertEquals("retain", Files.readString(secret)); + } + + @Test + void beginFailureIsLocalizedAndOrphanResourcesDoNotHideValidHistory() throws Exception { + Path blockedBase = Files.writeString(base.resolve("file-instead-of-directory"), "retain"); + CanRawRecordingStore blocked = new CanRawRecordingStore(blockedBase, mapper); + CanOperationException error = assertThrows(CanOperationException.class, () -> blocked.begin(source(), new JSONObject())); + assertEquals(CanRawRecordingStore.STORAGE_ERROR, error.code()); + assertEquals("can.recording.error.storage", error.messageKey()); + assertEquals("retain", Files.readString(blockedBase)); + CanRawRecordingStore.Recording recording = store.begin(source(), new JSONObject()); + recording.finish(new JSONObject(), true); + Files.createDirectory(directory(UUID.randomUUID().toString())); + assertEquals(1, store.history().getJSONArray("records").size()); + } + + @Test + void descriptorWriteFailurePreservesFullRowsAndPartialSnapshot() throws Exception { + CanRawRecordingStore.Recording recording = store.begin(source(), new JSONObject()); + recording.append(List.of(frame("1")), new JSONObject()); + Path descriptor = directory(recording.id()).resolve("descriptor.json"); + Files.delete(descriptor); + Files.createDirectory(descriptor); + Files.writeString(descriptor.resolve("block-replacement"), "retain"); + CanOperationException error = assertThrows(CanOperationException.class, + () -> recording.append(List.of(frame("2")), json("{\"state\":\"running\"}"))); + assertEquals(CanRawRecordingStore.STORAGE_ERROR, error.code()); + JsonNode partial = tree(recording.snapshot()); + assertEquals("2", partial.path("frameCount").textValue()); + assertFalse(partial.path("complete").booleanValue()); + assertTrue(partial.path("finishedAtEpochMs").isTextual()); + assertEquals(CanRawRecordingStore.STORAGE_ERROR, partial.path("metadata").path("recordingErrorCode").intValue()); + List lines = Files.readAllLines(directory(recording.id()).resolve("frames.jsonl")); + assertEquals(2, lines.size()); + assertEquals(tree(frame("1")), mapper.readTree(lines.get(0))); + assertEquals(tree(frame("2")), mapper.readTree(lines.get(1))); + assertThrows(CanOperationException.class, () -> recording.append(List.of(frame("3")), new JSONObject())); + } + + @ParameterizedTest + @ValueSource(booleans = {false, true}) + void historyQueriesDoNotAbortConcurrentAppendOrFinish(boolean finish) throws Exception { + CompletableFuture readerOpened = new CompletableFuture<>(); + CountDownLatch releaseReader = new CountDownLatch(1); + ObjectMapper heldReader = new ObjectMapper() { + @Override + public JsonNode readTree(Reader input) throws IOException { + readerOpened.complete(null); + try { + if (!releaseReader.await(5, TimeUnit.SECONDS)) throw new IOException("Reader release timed out"); + } catch (InterruptedException error) { + Thread.currentThread().interrupt(); + throw new IOException(error); + } + return super.readTree(input); + } + }; + CanRawRecordingStore concurrent = new CanRawRecordingStore(base, heldReader); + CanRawRecordingStore.Recording recording = concurrent.begin(source(), new JSONObject()); + recording.append(List.of(frame("1")), new JSONObject()); + CompletableFuture history = CompletableFuture.supplyAsync(concurrent::history); + CompletableFuture.anyOf(readerOpened, history).get(5, TimeUnit.SECONDS); + CompletableFuture writer = CompletableFuture.runAsync(() -> { + if (finish) recording.finish(new JSONObject(), true); + else recording.append(List.of(frame("2")), new JSONObject()); + }); + try { + writer.get(100, TimeUnit.MILLISECONDS); + } catch (TimeoutException waitingForReader) { + } finally { + releaseReader.countDown(); + } + writer.get(5, TimeUnit.SECONDS); + history.get(5, TimeUnit.SECONDS); + if (!finish) recording.finish(new JSONObject(), true); + CanRawRecordingStore reopened = new CanRawRecordingStore(base, mapper); + JSONObject descriptor = reopened.history().getJSONArray("records").getJSONObject(0); + assertTrue(descriptor.getBool("complete")); + assertEquals(finish ? "1" : "2", descriptor.getStr("frameCount")); + assertEquals(finish ? 1 : 2, reopened.preview(recording.id(), 0, 1000).getJSONArray("frames").size()); + } + + @Test + void aBrokenCsvDestinationDoesNotDeleteTheStoredRecord() throws Exception { + CanRawRecordingStore.Recording recording = store.begin(source(), new JSONObject()); + recording.append(List.of(frame("1")), new JSONObject()); + recording.finish(new JSONObject(), true); + Writer broken = new Writer() { + @Override public void write(char[] buffer, int offset, int length) throws IOException { throw new IOException("destination closed"); } + @Override public void flush() { } + @Override public void close() { } + }; + assertEquals(CanRawRecordingStore.STORAGE_ERROR, + assertThrows(CanOperationException.class, () -> store.csv(recording.id(), broken)).code()); + assertEquals(1, store.preview(recording.id(), 0, 1).getJSONArray("frames").size()); + } + + private Path directory(String id) { return base.resolve("can-raw-recordings").resolve(id); } + private JsonNode tree(JSONObject value) throws Exception { return mapper.readTree(value.toString()); } + private static JSONObject json(String text) { return JSONUtil.parseObj(text, JSONConfig.create().setIgnoreNullValue(false)); } + private static JSONObject source() { + return json("{\"deviceId\":\"9007199254740993\",\"deviceName\":\"device\",\"protocol\":\"SonoDAQ\"," + + "\"portId\":\"CAN2\",\"receiveId\":\"receive-2\"}"); + } + private static JSONObject frame(String sequence) { + return json("{\"canId\":536870911,\"idFormat\":\"extended\",\"frameType\":\"fd\",\"flags\":27," + + "\"length\":3,\"dlc\":3,\"dataHex\":\"00A1FF\",\"data\":[0,161,255],\"source\":\"local-tx-echo\"," + + "\"rawTimestampNs\":\"1794216167166000001\",\"timestampSource\":\"kernel-software\",\"rawClockId\":0," + + "\"sessionEpoch\":\"18446744073709551615\",\"mappingRevision\":\"9007199254740995\"," + + "\"measurementTimeValid\":false,\"measurementTimeNs\":null,\"receivedAtEpochMs\":\"1794216167166\"," + + "\"futureNativeField\":{\"available\":null,\"exact\":18446744073709551615}," + + "\"origin\":{\"deviceId\":\"9007199254740993\",\"deviceName\":\"Device, \\\"quoted\\\"\\r\\nnext\"," + + "\"protocol\":\"SonoDAQ\",\"portId\":\"CAN2\",\"receiveId\":\"receive-2\",\"epoch\":\"42\"}}") + .set("sequence", sequence); + } + + private static List> csvRows(String text) { + List> rows = new ArrayList<>(); + List row = new ArrayList<>(); + StringBuilder cell = new StringBuilder(); + boolean quoted = false; + for (int index = 0; index < text.length(); index++) { + char value = text.charAt(index); + if (value == '"') { + if (quoted && index + 1 < text.length() && text.charAt(index + 1) == '"') { cell.append('"'); index++; } + else quoted = !quoted; + } else if (value == ',' && !quoted) { row.add(cell.toString()); cell.setLength(0); } + else if (value == '\r' && !quoted && index + 1 < text.length() && text.charAt(index + 1) == '\n') { + row.add(cell.toString()); rows.add(row); row = new ArrayList<>(); cell.setLength(0); index++; + } else cell.append(value); + } + assertFalse(quoted); + assertEquals(0, cell.length()); + return rows; + } +} diff --git a/apps/backend/crydaq-service/src/test/java/com/opentest/service/can/CanServiceTest.java b/apps/backend/crydaq-service/src/test/java/com/opentest/service/can/CanServiceTest.java new file mode 100644 index 00000000..eb472985 --- /dev/null +++ b/apps/backend/crydaq-service/src/test/java/com/opentest/service/can/CanServiceTest.java @@ -0,0 +1,753 @@ +package com.opentest.service.can; + +import cn.hutool.json.JSONArray; +import cn.hutool.json.JSONObject; +import cn.hutool.json.JSONUtil; +import com.opentest.common.model.entity.Device; +import com.opentest.service.DeviceService; +import com.opentest.service.VariablesService; +import com.opentest.service.jni.AudioJNIBridgeService; +import com.opentest.dashboard.api.channel.CanPortBinding; +import com.opentest.dashboard.api.channel.CanSignalChannel; +import com.opentest.dashboard.api.channel.CanSignalQuantity; +import com.opentest.dashboard.api.channel.CanSignalUnits; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; +import org.junit.jupiter.params.provider.ValueSource; + +import java.util.HashMap; +import java.util.Map; +import java.util.List; +import java.util.concurrent.atomic.AtomicReference; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +class CanServiceTest { + private final FakeNative nativeCan = new FakeNative(); + private final AtomicReference saved = new AtomicReference<>(new JSONObject()); + private CanService service; + private CanConfigurationStore store; + private DeviceService devices; + private AudioJNIBridgeService audio; + private Device device; + private VariablesService variables; + + @BeforeEach + void setup() { + devices = mock(DeviceService.class); + audio = mock(AudioJNIBridgeService.class); + device = new Device(); + device.setProtocol("OPENDAQ"); device.setDeviceName("Sono-1293"); device.setIpAddress("192.168.1.3"); + when(devices.findById(1L)).thenReturn(device); + when(audio.getJniDeviceId(device)).thenAnswer(call -> device.getDeviceName() + "_" + device.getIpAddress()); + variables = mock(VariablesService.class); + when(variables.getCanPortConfigurations()).thenAnswer(call -> JSONUtil.parseObj(saved.get().toString())); + when(variables.saveCanPortConfigurations(any(JSONObject.class))).thenAnswer(call -> { + saved.set(JSONUtil.parseObj(call.getArgument(0).toString())); return true; + }); + store = new CanConfigurationStore(variables); + service = new CanService(devices, audio, nativeCan, store); + } + @AfterEach void cleanup() { service.close(); } + + private JSONObject config() { + return JSONUtil.parseObj("{schemaVersion:1,receiveMode:'listen-only',canMode:'fd',nominalBitrate:500000,dataBitrate:2000000,filters:[]}"); + } + private void applied(String port) { + service.enable(1L, true); + service.configuration(1L, port, config()); + } + + private CanSignalChannel signal(String vchId, String port) { + return signal(vchId, port, 1, "rpm"); + } + private CanSignalChannel signal(String vchId, String port, int factor, String outputUnit) { + var definition = new JSONObject().set("schemaVersion", 1).set("portId", port).set("decodeMethod", "manual") + .set("definition", JSONUtil.parseObj("{signalId:'untrusted-display-id',canId:384,idFormat:'standard'," + + "frameType:'any',byteOrder:'intel',valueType:'unsigned',startBit:0,bitLength:16,offset:0,timeoutMs:1000,unit:'rpm'}") + .set("factor", factor)); + return new CanSignalChannel(vchId, "row-" + vchId, "project-1", vchId, 1, + new CanPortBinding("1", "OPENDAQ", DeviceService.deviceIdentity("OPENDAQ", device.getDeviceName(), device.getIpAddress()), port), + definition.toString(), new CanSignalUnits(CanSignalQuantity.FREQUENCY, "rpm", outputUnit, null), "fingerprint"); + } + + @Test void manualAndTwoMeasurementsShareOnePortWithIndependentSubscriptions() { + applied("CAN1"); + String manual = service.start(1L, "CAN1").getStr("receiveId"); + var monitor = service.acquire("monitor-1", "Monitor", List.of(signal("CAN1", "CAN1"))).getFirst(); + var second = service.acquire("monitor-2", "Monitor", List.of(signal("CAN2", "CAN1"))).getFirst(); + assertEquals(manual, monitor.receiveId()); + assertEquals(manual, second.receiveId()); + assertFalse(monitor.subscriptionId().equals(second.subscriptionId())); + assertEquals(1, nativeCan.starts); + assertEquals(2, nativeCan.definitions.get(manual).getJSONArray("signals").size()); + assertThrows(CanOperationException.class, () -> service.stop(1L, "CAN1")); + + monitor.close(); + assertEquals(1, nativeCan.definitions.get(manual).getJSONArray("signals").size()); + assertNotNull(second.read().getJSONArray("samples")); + second.close(); + assertEquals(manual, service.status(1L, "CAN1").getStr("receiveId")); + assertTrue(service.status(1L, "CAN1").getBool("manualReceiving")); + assertEquals(0, nativeCan.closes); + } + + @Test void monitorFirstCanGainManualOwnershipAndLastOwnerClosesOnlyItsPort() { + applied("CAN1"); applied("CAN2"); + var monitor = service.acquire("monitor", "Monitor", List.of(signal("CAN1", "CAN1"))).getFirst(); + assertFalse(service.status(1L, "CAN1").getBool("manualReceiving")); + assertEquals(monitor.receiveId(), service.start(1L, "CAN1").getStr("receiveId")); + var other = service.acquire("other-port", "Monitor", List.of(signal("CAN2", "CAN2"))).getFirst(); + other.close(); + assertNull(service.status(1L, "CAN2").getStr("receiveId")); + assertEquals(monitor.receiveId(), service.status(1L, "CAN1").getStr("receiveId")); + monitor.close(); + service.stop(1L, "CAN1"); + assertEquals(2, nativeCan.closes); + assertTrue(nativeCan.enabled); + } + + @Test void changedRuleGetsItsOwnIdentityButOutputUnitDoesNotDuplicateDecoding() { + applied("CAN1"); + var first = service.acquire("first", "Monitor", List.of(signal("CAN1", "CAN1"))).getFirst(); + var converted = service.acquire("converted", "Monitor", List.of(signal("CAN1", "CAN1", 1, "Hz"))).getFirst(); + assertEquals(first.channels().keySet(), converted.channels().keySet()); + assertEquals(1, nativeCan.definitions.get(first.receiveId()).getJSONArray("signals").size()); + var changed = service.acquire("changed", "Monitor", List.of(signal("CAN1", "CAN1", 2, "rpm"))).getFirst(); + assertFalse(first.channels().keySet().equals(changed.channels().keySet())); + assertEquals(2, nativeCan.definitions.get(first.receiveId()).getJSONArray("signals").size()); + changed.close(); converted.close(); first.close(); + assertEquals(1, nativeCan.closes); + } + + @Test void failedNewSubscriptionRestoresRulesWithoutDisturbingExistingConsumer() { + applied("CAN1"); + var existing = service.acquire("existing", "Monitor", List.of(signal("CAN1", "CAN1"))).getFirst(); + String before = nativeCan.definitions.get(existing.receiveId()).toString(); + nativeCan.failSubscribe = true; + assertThrows(CanOperationException.class, + () -> service.acquire("new", "Monitor", List.of(signal("CAN2", "CAN1")))); + assertEquals(before, nativeCan.definitions.get(existing.receiveId()).toString()); + assertEquals(1, service.status(1L, "CAN1").getJSONArray("usages").size()); + assertNotNull(existing.read()); + assertEquals(0, nativeCan.closes); + nativeCan.failSubscribe = false; + existing.close(); + } + + @Test void failedBusinessReleaseRemainsVisibleAndOperatorCanRetryCleanup() { + applied("CAN1"); + var subscription = service.acquire("monitor", "Monitor", List.of(signal("CAN1", "CAN1"))).getFirst(); + nativeCan.failUnsubscribe = true; + assertThrows(CanOperationException.class, subscription::close); + JSONObject held = service.status(1L, "CAN1"); + assertFalse(held.getBool("manualReceiving")); + assertEquals("cleanup", held.getJSONArray("usages").getJSONObject(0).getStr("stage")); + assertNotNull(held.getStr("receiveId")); + nativeCan.failUnsubscribe = false; + assertNull(service.stop(1L, "CAN1").getStr("receiveId")); + subscription.close(); + assertEquals(1, nativeCan.closes); + } + + @ParameterizedTest + @ValueSource(ints = {0, 13103003, 13103006, 13103007}) + void failedFirstAcquisitionDoesNotRetainReleasedRulesAndAllowsTheSameUsageAgain(int closeError) { + applied("CAN1"); applied("CAN2"); + var otherPort = service.acquire("other-port", "Monitor", List.of(signal("CAN2", "CAN2"))).getFirst(); + nativeCan.failSubscribe = true; + nativeCan.stopError = 13103007; + nativeCan.closeError = closeError; + + var failure = assertThrows(CanOperationException.class, + () -> service.acquire("monitor", "Monitor", List.of(signal("failed", "CAN1")))); + assertEquals(13103018, failure.code()); + assertEquals(13103007, ((CanOperationException) failure.getSuppressed()[0]).code()); + JSONObject released = service.status(1L, "CAN1"); + assertNull(released.getStr("receiveId")); + assertEquals("stopped", released.getStr("state")); + assertEquals(13103007, released.getInt("lastErrorCode")); + assertTrue(released.getJSONArray("usages").isEmpty()); + assertEquals(otherPort.receiveId(), service.status(1L, "CAN2").getStr("receiveId")); + + nativeCan.failSubscribe = false; + nativeCan.stopError = nativeCan.closeError = 0; + var replacement = service.acquire("monitor", "Monitor", List.of(signal("replacement", "CAN1"))).getFirst(); + assertEquals(1, nativeCan.definitions.get(replacement.receiveId()).getJSONArray("signals").size()); + assertEquals(1, service.status(1L, "CAN1").getJSONArray("usages").size()); + assertNotNull(replacement.read()); + assertNotNull(otherPort.read()); + replacement.close(); + assertNull(service.status(1L, "CAN1").getStr("receiveId")); + otherPort.close(); + } + + @ParameterizedTest + @ValueSource(ints = {13103018, 13103019, 98765432}) + void failedFirstAcquisitionRetainsUnknownCloseOwnershipUntilCleanupSucceeds(int closeError) { + applied("CAN1"); + nativeCan.failSubscribe = true; + nativeCan.stopError = 13103007; + nativeCan.closeError = closeError; + + var failure = assertThrows(CanOperationException.class, + () -> service.acquire("monitor", "Monitor", List.of(signal("failed", "CAN1")))); + assertEquals(13103018, failure.code()); + var cleanup = (CanOperationException) failure.getSuppressed()[0]; + assertEquals(13103007, cleanup.code()); + assertEquals(closeError, ((CanOperationException) cleanup.getSuppressed()[0]).code()); + JSONObject held = service.status(1L, "CAN1"); + assertNotNull(held.getStr("receiveId")); + assertEquals("error", held.getStr("state")); + assertEquals("cleanup", held.getJSONArray("usages").getJSONObject(0).getStr("stage")); + assertThrows(IllegalStateException.class, + () -> service.acquire("monitor", "Monitor", List.of(signal("replacement", "CAN1")))); + + nativeCan.failSubscribe = false; + nativeCan.stopError = nativeCan.closeError = 0; + JSONObject released = service.stop(1L, "CAN1"); + assertNull(released.getStr("receiveId")); + assertTrue(released.getJSONArray("usages").isEmpty()); + service.acquire("monitor", "Monitor", List.of(signal("replacement", "CAN1"))).getFirst().close(); + } + + @Test void releasedNativeSourceDoesNotLeaveBusinessCleanupPermanentlyBusy() { + applied("CAN1"); + var subscription = service.acquire("monitor", "Monitor", List.of(signal("CAN1", "CAN1"))).getFirst(); + nativeCan.stopError = 13103008; + assertEquals(13103008, assertThrows(CanOperationException.class, subscription::close).code()); + assertEquals("cleanup", service.status(1L, "CAN1").getJSONArray("usages").getJSONObject(0).getStr("stage")); + assertEquals(0, nativeCan.closeAttempts); + + nativeCan.stopError = 13103003; + nativeCan.closeError = 13103003; + JSONObject stopped = service.stop(1L, "CAN1"); + assertNull(stopped.getStr("receiveId")); + assertTrue(stopped.getJSONArray("usages").isEmpty()); + assertEquals("stopped", stopped.getStr("state")); + assertEquals(1, nativeCan.closeAttempts); + + nativeCan.stopError = nativeCan.closeError = 0; + assertFalse(subscription.receiveId().equals(service.start(1L, "CAN1").getStr("receiveId"))); + } + + @Test void releasedManualSourceCanBeStoppedAndStartedAgain() { + applied("CAN1"); + String first = service.start(1L, "CAN1").getStr("receiveId"); + nativeCan.stopError = nativeCan.closeError = 13103003; + assertNull(service.stop(1L, "CAN1").getStr("receiveId")); + assertEquals(1, nativeCan.closeAttempts); + nativeCan.stopError = nativeCan.closeError = 0; + assertFalse(first.equals(service.start(1L, "CAN1").getStr("receiveId"))); + } + + @ParameterizedTest + @CsvSource({ + "13103006, 0, 0", + "13103007, 0, 0", + "0, 13103007, 0", + "13103007, 0, 13103003", + "13103007, 0, 13103006", + "0, 0, 13103007" + }) + void confirmedBusinessReleaseKeepsItsErrorWithoutLeavingCleanupForTheNextReception( + int stopError, int readError, int closeError) { + applied("CAN1"); applied("CAN2"); + var subscription = service.acquire("monitor", "Monitor", List.of(signal("CAN1", "CAN1"))).getFirst(); + var otherPort = service.acquire("other-port", "Monitor", List.of(signal("CAN2", "CAN2"))).getFirst(); + nativeCan.stopError = stopError; + nativeCan.readError = readError; + nativeCan.closeError = closeError; + int expectedError = stopError != 0 ? stopError : readError != 0 ? readError : closeError; + + assertEquals(expectedError, assertThrows(CanOperationException.class, subscription::close).code()); + JSONObject released = service.status(1L, "CAN1"); + assertNull(released.getStr("receiveId")); + assertEquals("stopped", released.getStr("state")); + assertEquals(expectedError, released.getInt("lastErrorCode")); + assertTrue(released.getJSONArray("usages").isEmpty()); + assertEquals(otherPort.receiveId(), service.status(1L, "CAN2").getStr("receiveId")); + + nativeCan.stopError = nativeCan.readError = nativeCan.closeError = 0; + String restarted = service.start(1L, "CAN1").getStr("receiveId"); + assertFalse(subscription.receiveId().equals(restarted)); + var replacement = service.acquire("monitor", "Monitor", List.of(signal("replacement", "CAN1"))).getFirst(); + var peer = service.acquire("peer", "Monitor", List.of(signal("peer", "CAN1"))).getFirst(); + String definitions = nativeCan.definitions.get(restarted).toString(); + int definitionUpdates = nativeCan.definitionUpdates; + int closes = nativeCan.closeAttempts; + + subscription.close(); + assertEquals(definitionUpdates, nativeCan.definitionUpdates); + assertEquals(closes, nativeCan.closeAttempts); + assertEquals(definitions, nativeCan.definitions.get(restarted).toString()); + JSONObject active = service.status(1L, "CAN1"); + assertEquals(restarted, active.getStr("receiveId")); + assertTrue(active.getBool("manualReceiving")); + assertEquals(3, active.getJSONArray("usages").size()); + assertNotNull(replacement.read()); + assertNotNull(peer.read()); + assertNotNull(otherPort.read()); + assertEquals(13103008, assertThrows(CanOperationException.class, () -> service.stop(1L, "CAN1")).code()); + + replacement.close(); peer.close(); + assertNull(service.stop(1L, "CAN1").getStr("receiveId")); + otherPort.close(); + } + + @ParameterizedTest + @ValueSource(ints = {13103018, 13103019, 98765432}) + void unconfirmedBusinessCloseRetainsCleanupAndCanBeRetried(int closeError) { + applied("CAN1"); + var subscription = service.acquire("monitor", "Monitor", List.of(signal("CAN1", "CAN1"))).getFirst(); + nativeCan.stopError = 13103007; + nativeCan.closeError = closeError; + + var failure = assertThrows(CanOperationException.class, subscription::close); + assertEquals(13103007, failure.code()); + assertEquals(closeError, ((CanOperationException) failure.getSuppressed()[0]).code()); + JSONObject held = service.status(1L, "CAN1"); + assertEquals(subscription.receiveId(), held.getStr("receiveId")); + assertEquals("error", held.getStr("state")); + assertEquals("cleanup", held.getJSONArray("usages").getJSONObject(0).getStr("stage")); + assertEquals(13103002, assertThrows(CanOperationException.class, () -> service.start(1L, "CAN1")).code()); + + nativeCan.stopError = nativeCan.closeError = 0; + subscription.close(); + JSONObject released = service.status(1L, "CAN1"); + assertNull(released.getStr("receiveId")); + assertTrue(released.getJSONArray("usages").isEmpty()); + assertFalse(subscription.receiveId().equals(service.start(1L, "CAN1").getStr("receiveId"))); + } + + @Test void lostHandleDuringDrainStillClosesTheNativeReservation() { + applied("CAN1"); + service.start(1L, "CAN1"); + nativeCan.readError = 13103003; + assertNull(service.stop(1L, "CAN1").getStr("receiveId")); + assertEquals(1, nativeCan.closes); + nativeCan.readError = 0; + } + + @Test void invalidStopHandleDoesNotHideAnUnconfirmedClose() { + applied("CAN1"); + service.start(1L, "CAN1"); + nativeCan.stopError = 13103003; + nativeCan.failClose = true; + assertEquals(13103018, assertThrows(CanOperationException.class, () -> service.stop(1L, "CAN1")).code()); + assertNotNull(service.status(1L, "CAN1").getStr("receiveId")); + assertThrows(CanOperationException.class, () -> service.configuration(1L, "CAN1", config())); + nativeCan.failClose = false; + assertNull(service.stop(1L, "CAN1").getStr("receiveId")); + nativeCan.stopError = 0; + } + + @ParameterizedTest + @CsvSource({ + "13103006, 0, 0", + "13103007, 0, 0", + "0, 13103006, 0", + "0, 13103007, 0", + "13103007, 0, 13103003", + "13103007, 0, 13103006", + "13103007, 0, 13103007", + "0, 0, 13103006", + "0, 0, 13103007" + }) + void terminalFailureClosesOnlyItsPortAndAllowsExplicitRecovery(int stopError, int readError, int closeError) { + applied("CAN1"); applied("CAN2"); + String first = service.start(1L, "CAN1").getStr("receiveId"); + String other = service.start(1L, "CAN2").getStr("receiveId"); + nativeCan.enabled = false; + nativeCan.stopError = stopError; + nativeCan.readError = readError; + nativeCan.closeError = closeError; + int expectedError = stopError != 0 ? stopError : readError != 0 ? readError : closeError; + + CanOperationException failure = assertThrows(CanOperationException.class, () -> service.stop(1L, "CAN1")); + + assertEquals(expectedError, failure.code()); + assertEquals("can.error.nativeFailure", failure.messageKey()); + assertEquals(1, nativeCan.closeAttempts); + JSONObject released = service.status(1L, "CAN1"); + assertNull(released.getStr("receiveId")); + assertFalse(released.getBool("manualReceiving")); + assertEquals("stopped", released.getStr("state")); + assertEquals(expectedError, released.getInt("lastErrorCode")); + assertTrue(released.getJSONArray("usages").isEmpty()); + assertFalse(nativeCan.pending.containsKey(first)); + assertTrue(nativeCan.pending.containsKey(other)); + JSONObject unaffected = service.status(1L, "CAN2"); + assertEquals(other, unaffected.getStr("receiveId")); + assertEquals("running", unaffected.getStr("state")); + assertTrue(unaffected.getBool("manualReceiving")); + assertNull(unaffected.getInt("lastErrorCode")); + assertEquals(2, nativeCan.starts); + assertEquals(2, nativeCan.enables); + assertFalse(nativeCan.enabled); + + nativeCan.stopError = nativeCan.readError = nativeCan.closeError = 0; + assertEquals(13103002, assertThrows(CanOperationException.class, () -> service.start(1L, "CAN1")).code()); + assertEquals(2, nativeCan.enables); + service.enable(1L, true); + JSONObject restarted = service.start(1L, "CAN1"); + assertFalse(first.equals(restarted.getStr("receiveId"))); + assertEquals("running", restarted.getStr("state")); + assertTrue(restarted.getBool("manualReceiving")); + assertNull(restarted.getInt("lastErrorCode")); + assertEquals(3, nativeCan.starts); + assertEquals(3, nativeCan.enables); + assertEquals(1, nativeCan.closeAttempts); + assertEquals(other, service.status(1L, "CAN2").getStr("receiveId")); + } + + @ParameterizedTest + @ValueSource(ints = {13103018, 13103019, 13103999}) + void disconnectedStopRetainsOwnershipAndBothErrorsWhenCloseIsUnconfirmed(int closeError) { + applied("CAN1"); applied("CAN2"); + String first = service.start(1L, "CAN1").getStr("receiveId"); + String other = service.start(1L, "CAN2").getStr("receiveId"); + nativeCan.stopError = 13103007; + nativeCan.closeError = closeError; + + CanOperationException failure = assertThrows(CanOperationException.class, () -> service.stop(1L, "CAN1")); + + assertEquals(13103007, failure.code()); + assertEquals(1, nativeCan.closeAttempts); + assertEquals(1, failure.getSuppressed().length); + assertEquals(closeError, ((CanOperationException) failure.getSuppressed()[0]).code()); + JSONObject held = service.status(1L, "CAN1"); + assertEquals(first, held.getStr("receiveId")); + assertTrue(held.getBool("manualReceiving")); + assertEquals("error", held.getStr("state")); + assertEquals(13103007, held.getInt("lastErrorCode")); + assertTrue(nativeCan.pending.containsKey(first)); + assertEquals(13103002, assertThrows(CanOperationException.class, () -> service.start(1L, "CAN1")).code()); + assertEquals(13103008, assertThrows(CanOperationException.class, + () -> service.configuration(1L, "CAN1", config())).code()); + assertEquals(2, nativeCan.starts); + assertEquals(2, nativeCan.enables); + assertEquals(1, nativeCan.closeAttempts); + assertEquals(other, service.status(1L, "CAN2").getStr("receiveId")); + assertTrue(nativeCan.pending.containsKey(other)); + } + + @ParameterizedTest + @ValueSource(booleans = {false, true}) + void disconnectedStopRetainsOwnershipWhenCloseThrowsUnexpectedly(boolean linkageFailure) { + applied("CAN1"); + String first = service.start(1L, "CAN1").getStr("receiveId"); + nativeCan.stopError = 13103007; + nativeCan.closeFailure = linkageFailure ? new UnsatisfiedLinkError("close unavailable") + : new IllegalStateException("close failed"); + + CanOperationException failure = assertThrows(CanOperationException.class, () -> service.stop(1L, "CAN1")); + + assertEquals(13103007, failure.code()); + assertEquals(1, nativeCan.closeAttempts); + assertEquals(1, failure.getSuppressed().length); + assertEquals(nativeCan.closeFailure, failure.getSuppressed()[0]); + JSONObject held = service.status(1L, "CAN1"); + assertEquals(first, held.getStr("receiveId")); + assertTrue(held.getBool("manualReceiving")); + assertEquals("error", held.getStr("state")); + assertEquals(13103007, held.getInt("lastErrorCode")); + } + + @ParameterizedTest + @ValueSource(ints = {13103008, 13103018}) + void nonterminalStopFailureDoesNotDiscardOwnership(int stopError) { + applied("CAN1"); + String first = service.start(1L, "CAN1").getStr("receiveId"); + nativeCan.stopError = stopError; + + assertEquals(stopError, assertThrows(CanOperationException.class, () -> service.stop(1L, "CAN1")).code()); + + assertEquals(0, nativeCan.closeAttempts); + assertEquals(first, service.status(1L, "CAN1").getStr("receiveId")); + assertTrue(service.status(1L, "CAN1").getBool("manualReceiving")); + } + + @Test void applyDoesNotStartAndUnknownReadbackIsNotInvented() { + applied("CAN1"); + assertEquals(0, nativeCan.starts); + JSONObject view = service.status(1L, "CAN1"); + assertNotNull(view.getJSONObject("appliedConfig")); + assertTrue(view.containsKey("receiveId")); + assertTrue(view.containsKey("lastErrorCode")); + assertTrue(view.containsKey("diagnostics")); + JSONObject capabilities = service.capabilities(1L); + assertNull(capabilities.getBool("enabled")); + assertEquals(true, capabilities.getBool("requestedEnabled")); + } + + @Test void refreshAndRepeatedStartReuseOneSourceAndStopLeavesSwitchEnabled() { + applied("CAN1"); + String id = service.start(1L, "CAN1").getStr("receiveId"); + assertEquals(id, service.status(1L, "CAN1").getStr("receiveId")); + assertEquals(id, service.start(1L, "CAN1").getStr("receiveId")); + assertEquals(1, nativeCan.starts); + assertTrue(nativeCan.request.getBool("rawFrames")); + assertTrue(nativeCan.request.getBool("decodedSignals")); + assertEquals("subscriptions", nativeCan.request.getStr("signalDelivery")); + assertEquals("stopped", service.stop(1L, "CAN1").getStr("state")); + assertTrue(nativeCan.enabled); + assertEquals(1, nativeCan.closes); + } + + @Test void applyAndDisableRejectOwnedPortButAnotherPortCanBeConfigured() { + applied("CAN1"); service.start(1L, "CAN1"); + assertEquals(13103008, assertThrows(CanOperationException.class, + () -> service.configuration(1L, "CAN1", config())).code()); + assertThrows(CanOperationException.class, () -> service.enable(1L, false)); + service.configuration(1L, "CAN2", config()); + assertEquals("running", service.status(1L, "CAN1").getStr("state")); + } + + @Test void readerDrainsWithoutAViewAndPreservesLargeSequenceText() { + applied("CAN1"); + String id = service.start(1L, "CAN1").getStr("receiveId"); + nativeCan.pending.get(id).add(new JSONObject().set("sequence", "18446744073709551614") + .set("rawTimestampNs", "1794216167166000000").set("canId", 384)); + service.readSources(); + JSONObject frame = service.frames(1L, "CAN1", "18446744073709551613").getJSONArray("frames").getJSONObject(0); + assertEquals("18446744073709551614", frame.getStr("sequence")); + assertTrue(nativeCan.pending.get(id).isEmpty()); + } + + @Test void rawPreviewRetainsNativeProvenanceAndAddsArrivalWithoutReadingAgain() { + applied("CAN1"); + String id = service.start(1L, "CAN1").getStr("receiveId"); + nativeCan.pending.get(id).add(JSONUtil.parseObj("{sequence:'9007199254740993',sessionEpoch:'18446744073709551614'," + + "rawTimestampNs:'1700000000000000000',source:'local-tx-echo',flags:11,dlc:9,payloadLength:12,data:[1,2,3]}")); + nativeCan.rawMetadata = JSONUtil.parseObj("{epoch:'native-epoch-1',complete:false,unknownDiagnostic:'retained'}"); + + service.readSources(); + int reads = nativeCan.reads; + JSONObject preview = service.frames(1L, "CAN1", "9007199254740992"); + JSONObject frame = preview.getJSONArray("frames").getJSONObject(0); + JSONObject origin = frame.getJSONObject("origin"); + + assertEquals("9007199254740993", frame.getStr("sequence")); + assertEquals("18446744073709551614", frame.getStr("sessionEpoch")); + assertEquals("local-tx-echo", frame.getStr("source")); + assertEquals(11, frame.getInt("flags")); + assertEquals("1", origin.getStr("deviceId")); + assertEquals(id, origin.getStr("receiveId")); + assertEquals("native-epoch-1", origin.getStr("epoch")); + assertTrue(Long.parseLong(frame.getStr("receivedAtEpochMs")) > 0); + assertEquals("retained", preview.getJSONObject("metadata").getStr("unknownDiagnostic")); + assertFalse(preview.getJSONObject("metadata").getBool("complete")); + assertFalse(preview.getJSONObject("metadata").containsKey("frames")); + JSONObject source = service.rawSources().getJSONArray("sources").getJSONObject(0); + assertEquals(id, source.getStr("receiveId")); + assertEquals("Sono-1293", source.getStr("deviceName")); + assertEquals(reads, nativeCan.reads); + + frame.set("sequence", "corrupted-client-copy"); + assertEquals("9007199254740993", service.frames(1L, "CAN1", "0") + .getJSONArray("frames").getJSONObject(0).getStr("sequence")); + } + + @Test void boundedRawPreviewResetsForNewReceptionAndReportsTerminalSourceState() { + applied("CAN1"); + String first = service.start(1L, "CAN1").getStr("receiveId"); + for (int i = 1; i <= 1005; i++) nativeCan.pending.get(first).add(new JSONObject().set("sequence", Integer.toString(i))); + service.readSources(); + JSONArray frames = service.frames(1L, "CAN1", "0").getJSONArray("frames"); + assertEquals(1000, frames.size()); + assertEquals("6", frames.getJSONObject(0).getStr("sequence")); + service.stop(1L, "CAN1"); + String second = service.start(1L, "CAN1").getStr("receiveId"); + assertFalse(first.equals(second)); + assertTrue(service.frames(1L, "CAN1", "0").getJSONArray("frames").isEmpty()); + + nativeCan.rawMetadata = new JSONObject().set("state", "disconnected"); + service.readSources(); + JSONObject source = service.rawSources().getJSONArray("sources").getJSONObject(0); + assertEquals("disconnected", source.getStr("state")); + assertTrue(source.getBool("manualReceiving")); + assertEquals(second, source.getStr("receiveId")); + } + + @Test void failedConfigureDoesNotReplaceSavedConfig() { + applied("CAN1"); + nativeCan.failConfigure = true; + assertThrows(CanOperationException.class, () -> service.configuration(1L, "CAN1", new JSONObject().set("nominalBitrate", 42))); + assertEquals(500000, service.status(1L, "CAN1").getJSONObject("appliedConfig").getInt("nominalBitrate")); + } + + @Test void startWithoutApplyUsesNativeFailureAndDoesNotApplyDefaults() { + service.enable(1L, true); + assertEquals(13103002, assertThrows(CanOperationException.class, () -> service.start(1L, "CAN1")).code()); + assertEquals(0, nativeCan.configures); + assertFalse(service.status(1L, "CAN1").getBool("manualReceiving")); + } + + @Test void failedCloseRetainsOwnershipAndBlocksApplyUntilCleanupSucceeds() { + applied("CAN1"); service.start(1L, "CAN1"); + nativeCan.failClose = true; + assertThrows(CanOperationException.class, () -> service.stop(1L, "CAN1")); + assertNotNull(service.status(1L, "CAN1").getStr("receiveId")); + assertThrows(CanOperationException.class, () -> service.configuration(1L, "CAN1", config())); + nativeCan.failClose = false; + assertNull(service.stop(1L, "CAN1").getStr("receiveId")); + } + + @Test void appliedConfigSurvivesNewServiceAndDeviceAddressChange() { + applied("CAN1"); + service.close(); + device.setIpAddress("192.168.1.8"); + service = new CanService(devices, audio, nativeCan, store); + assertEquals(500000, service.status(1L, "CAN1").getJSONObject("appliedConfig").getInt("nominalBitrate")); + service.start(1L, "CAN1"); + assertEquals("Sono-1293_192.168.1.8", nativeCan.lastNativeId); + } + + @Test void invalidCursorAndUnsupportedPortAreRejected() { + assertThrows(CanOperationException.class, () -> service.frames(1L, "CAN1", "NaN")); + assertThrows(CanOperationException.class, () -> service.frames(1L, "CAN1", "-1")); + assertThrows(CanOperationException.class, () -> service.status(1L, "CAN9")); + } + + @Test void existingSourceCanBeStoppedAfterDeviceSelectionDisappears() { + applied("CAN1"); service.start(1L, "CAN1"); + when(audio.getJniDeviceId(device)).thenThrow(new IllegalStateException("device disconnected")); + assertEquals("stopped", service.stop(1L, "CAN1").getStr("state")); + assertEquals(1, nativeCan.closes); + } + + @Test void nonOpenDaqDevicesWithSameNameAndDifferentAddressesDoNotShareSources() { + device.setProtocol("CAN_FIXTURE"); + applied("CAN1"); + String first = service.start(1L, "CAN1").getStr("receiveId"); + Device second = new Device(); + second.setProtocol("CAN_FIXTURE"); second.setDeviceName(device.getDeviceName()); second.setIpAddress("192.168.1.9"); + when(devices.findById(2L)).thenReturn(second); + when(audio.getJniDeviceId(second)).thenReturn("fixture-second"); + assertNull(service.status(2L, "CAN1").getJSONObject("appliedConfig")); + service.enable(2L, true); service.configuration(2L, "CAN1", config()); + assertFalse(first.equals(service.start(2L, "CAN1").getStr("receiveId"))); + assertEquals(2, nativeCan.starts); + } + + @Test void failedSaveReportsNativeAppliedStateSeparatelyFromSavedState() { + applied("CAN1"); + when(variables.saveCanPortConfigurations(any(JSONObject.class))).thenReturn(false); + JSONObject changed = config().set("nominalBitrate", 250000); + assertThrows(CanOperationException.class, () -> service.configuration(1L, "CAN1", changed)); + JSONObject status = service.status(1L, "CAN1"); + assertEquals(250000, status.getJSONObject("appliedConfig").getInt("nominalBitrate")); + assertEquals(500000, status.getJSONObject("savedConfig").getInt("nominalBitrate")); + assertFalse(status.getBool("configurationSaved")); + } + + @Test void shutdownNeverReadsAClosedHandle() { + applied("CAN1"); service.start(1L, "CAN1"); + service.close(); + int reads = nativeCan.reads; + service.readSources(); + assertEquals(reads, nativeCan.reads); + assertEquals(1, nativeCan.closes); + } + + @Test void startKeepsNativeAppliedConfigurationAfterPersistenceFailure() { + applied("CAN1"); + when(variables.saveCanPortConfigurations(any(JSONObject.class))).thenReturn(false); + assertThrows(CanOperationException.class, + () -> service.configuration(1L, "CAN1", config().set("nominalBitrate", 250000))); + + JSONObject started = service.start(1L, "CAN1"); + + assertEquals(250000, nativeCan.configs.get("CAN1").getInt("nominalBitrate")); + assertEquals(250000, started.getJSONObject("appliedConfig").getInt("nominalBitrate")); + assertEquals(500000, started.getJSONObject("savedConfig").getInt("nominalBitrate")); + assertFalse(started.getBool("configurationSaved")); + } + + private static final class FakeNative implements CanNativeGateway { + boolean enabled, failConfigure, failClose, failSubscribe, failUnsubscribe; + int starts, closes, configures, reads, enables; + int stopError, readError, closeError, closeAttempts; + Throwable closeFailure; + String lastNativeId; + JSONObject request; + JSONObject rawMetadata = new JSONObject(); + final Map configs = new HashMap<>(); + final Map pending = new HashMap<>(); + final Map definitions = new HashMap<>(); + int subscriptions, definitionUpdates; + public JSONObject capabilities(String protocol, String device) { + return new JSONObject().set("supported", true).set("enabled", null) + .set("ports", new JSONArray().put(new JSONObject().set("portId", "CAN1")).put(new JSONObject().set("portId", "CAN2"))); + } + public JSONObject enable(String protocol, String device, boolean value) { + enables++; enabled = value; return new JSONObject(); + } + public JSONObject configure(String protocol, String device, String port, JSONObject config) { + if (failConfigure) throw new CanOperationException(13103001, "can.error.nativeFailure"); + configures++; configs.put(port, config); return new JSONObject().set("configurationRevision", "1"); + } + public JSONObject start(String protocol, String device, String port, JSONObject input) { + if (!enabled || !configs.containsKey(port)) throw new CanOperationException(13103002, "can.error.nativeFailure"); + lastNativeId = device; request = input; + String id = "mock-" + ++starts; + pending.put(id, new JSONArray()); + return new JSONObject().set("receiveId", id).set("configurationRevision", "1"); + } + public JSONObject readFrames(String id) { + reads++; + if (readError != 0) throw new CanOperationException(readError, "can.error.nativeFailure"); + JSONArray frames = pending.get(id); + pending.put(id, new JSONArray()); + return JSONUtil.parseObj(rawMetadata.toString()).set("frames", frames); + } + public JSONObject status(String protocol, String device, String port) { return new JSONObject().set("state", "stopped"); } + public JSONObject stop(String id) { + if (stopError != 0) throw new CanOperationException(stopError, "can.error.nativeFailure"); + return new JSONObject().set("state", "stopped"); + } + public JSONObject close(String id) { + closeAttempts++; + if (closeFailure instanceof RuntimeException error) throw error; + if (closeFailure instanceof LinkageError error) throw error; + if (closeError != 0) { + if (closeError == 13103003 || closeError == 13103006 || closeError == 13103007) pending.remove(id); + throw new CanOperationException(closeError, "can.error.nativeFailure"); + } + if (failClose) throw new CanOperationException(13103018, "can.error.nativeFailure"); + pending.remove(id); + closes++; return new JSONObject(); + } + public JSONObject validateDefinitions(JSONObject definitions) { return new JSONObject().set("valid", true); } + public JSONObject updateDefinitions(String id, JSONObject definitions) { + definitionUpdates++; + this.definitions.put(id, JSONUtil.parseObj(definitions.toString())); return new JSONObject(); + } + public JSONObject subscribe(String id, JSONObject selection) { + if (failSubscribe) throw new CanOperationException(13103018, "can.error.nativeFailure"); + return new JSONObject().set("subscriptionId", "subscription-" + ++subscriptions); + } + public JSONObject readSignals(String id, String subscriptionId) { return new JSONObject().set("samples", new JSONArray()); } + public JSONObject resetSignals(String id, String subscriptionId, JSONObject selection) { return new JSONObject(); } + public JSONObject finishSignals(String id, String subscriptionId) { + return new JSONObject().set("samples", new JSONArray()).set("subscriptionState", "finished") + .set("drained", true).set("cutoff", new JSONObject().set("dispatchSequence", "0")); + } + public JSONObject unsubscribe(String id, String subscriptionId) { + if (failUnsubscribe) throw new CanOperationException(13103018, "can.error.nativeFailure"); + return new JSONObject(); + } + } +} diff --git a/apps/backend/crydaq-service/src/test/java/com/opentest/service/dashboard/framework/CanMeasurementInputBindingsTest.java b/apps/backend/crydaq-service/src/test/java/com/opentest/service/dashboard/framework/CanMeasurementInputBindingsTest.java new file mode 100644 index 00000000..742e76f3 --- /dev/null +++ b/apps/backend/crydaq-service/src/test/java/com/opentest/service/dashboard/framework/CanMeasurementInputBindingsTest.java @@ -0,0 +1,213 @@ +package com.opentest.service.dashboard.framework; + +import com.opentest.common.enums.ChannelIOEnum; +import com.opentest.common.enums.BuiltinDashboardProvider; +import com.opentest.common.model.dto.ChannelDto; +import com.opentest.common.model.entity.DashboardConfig; +import com.opentest.common.model.entity.Device; +import com.opentest.common.model.entity.BoxChannel; +import com.opentest.common.exception.CryBusinessException; +import com.opentest.common.exception.ErrorCode; +import com.opentest.dashboard.api.channel.ChannelDirection; +import com.opentest.dashboard.api.execution.ExecutionChannelFacts; +import com.opentest.dashboard.api.execution.SignalTriggerInputUse; +import com.opentest.dashboard.api.measurement.editing.InputDeclaration; +import com.opentest.service.BoxChannelService; +import com.opentest.service.DeviceService; +import com.opentest.service.can.CanProjectChannelFacts; +import com.opentest.service.jni.VirtualChannelJNIBridgeService; +import com.opentest.service.virtualchannel.VirtualChannelExecutionChannelResolver; +import com.opentest.service.virtualchannel.VirtualChannelExecutionPlanBuilder; +import com.opentest.service.virtualchannel.VirtualChannelFormulaAnalyzer; +import java.util.LinkedHashMap; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.OptionalInt; +import java.util.Set; +import org.junit.jupiter.api.Test; +import org.springframework.test.util.ReflectionTestUtils; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.ArgumentMatchers.anyMap; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anySet; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verifyNoMoreInteractions; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +class CanMeasurementInputBindingsTest { + static final String DEFINITION = """ + {"schemaVersion":1,"portId":"can0","decodeMethod":"manual","definition":{ + "canId":384,"idFormat":"standard","frameType":"any","byteOrder":"intel", + "valueType":"unsigned","startBit":0,"bitLength":16,"factor":1,"offset":0, + "timeoutMs":1000,"unit":"rpm"},"quantity":"ROTATIONAL_SPEED", + "sourceUnit":"rpm","outputUnit":"rpm","tachoPpr":null} + """; + + @Test void canOnlyBindingHasNoSampledMetadataAndKeepsCanInConfigurationCatalogue() { + var can = can(); + var fixture = new Fixture(List.of(can), true, List.of()); + var bound = fixture.bind(List.of("Can1")); + assertEquals(List.of("Can1"), ids(bound.selected())); + assertTrue(bound.sampledSelected().isEmpty()); + assertTrue(bound.captureDependencies().isEmpty()); + assertTrue(bound.channels().isEmpty()); + assertEquals("can0", bound.selectedCanChannels().getFirst().binding().portId()); + assertEquals(1, bound.licensedInputUsage()); + var refreshed = bound.withSamplingRates(Map.of("Can1", 48000)); + assertNull(refreshed.selected().getFirst().getSamplingRate()); + assertEquals(bound.canChannels(), refreshed.canChannels()); + assertTrue(bound.catalog().channels(ChannelDirection.INPUT).isEmpty()); + assertEquals(bound.canChannels(), bound.catalog().canInputs()); + var configuration = fixture.configuration(List.of("Can1")); + var configured = fixture.bindings.openConfiguration(fixture.owner, configuration, null, false, List.of()) + .orElseThrow().bind(configuration); + assertEquals(bound.canChannels(), configured.catalog().canInputs()); + var query = DashboardConfigurationChannels.loadCatalog(fixture.channels, 7L, + MeasurementInputBindings.FACTS.valueToTree(configuration), fixture.providers, + fixture.owner.getProviderId(), fixture.bindings); + assertEquals(bound.canChannels(), query.canInputs()); + } + + @Test void mixedSelectionPreservesOrderWhileOrdinaryUnboundSlotsStillSkip() { + var sampled = sampled("Ch1"); + var empty = sampled("Ch2"); empty.setSamplingRate(null); + var fixture = new Fixture(List.of(sampled, can(), empty), true, List.of()); + when(fixture.channels.findUnboundPhysicalChannelVchIds(eq(7L), anySet(), eq(ChannelIOEnum.INPUT))) + .thenReturn(Set.of("Ch2")); + var bound = fixture.bind(List.of("Can1", "Ch2", "Ch1")); + assertEquals(List.of("Can1", "Ch1"), ids(bound.selected())); + assertEquals(List.of("Ch1"), ids(bound.sampledSelected())); + assertEquals(List.of("Ch1"), ids(bound.captureDependencies())); + assertEquals(Set.of("Ch1"), bound.channels().keySet()); + assertFalse(bound.catalog().canInputs().channels().isEmpty()); + } + + @Test void invalidCanFailsInsteadOfBeingOmittedAsAnUnboundAudioSlot() { + var can = can(); can.setCanDefinitionJson(DEFINITION.replace("\"schemaVersion\":1", "\"schemaVersion\":2")); + var fixture = new Fixture(List.of(can), true, List.of()); + when(fixture.channels.findUnboundPhysicalChannelVchIds(eq(7L), anySet(), eq(ChannelIOEnum.INPUT))) + .thenReturn(Set.of("Can1")); + assertThrows(IllegalArgumentException.class, () -> fixture.bind(List.of("Can1"))); + } + + @Test void otherMeasurementsAndSignalTriggersRejectCan() { + assertThrows(IllegalArgumentException.class, + () -> new Fixture(List.of(can()), false, List.of()).bind(List.of("Can1"))); + assertThrows(IllegalArgumentException.class, + () -> new Fixture(List.of(can()), true, + List.of(new SignalTriggerInputUse("record", "trigger", "Can1", "rpm"))).bind(List.of("Can1"))); + } + + @Test void mathCannotConsumeCanAsASampledLeaf() { + var math = sampled("M1"); math.setChannelSource(1); math.setCustomName("Math"); + math.setMathFormula("Motor speed * 2"); math.setMathUnit("rpm"); + var rows = List.of(can(), math); + var fixture = new Fixture(rows, true, List.of()); + when(fixture.channels.getProjectInputChannelMap(7L)) + .thenReturn(Map.of("Can1", new BoxChannel(), "M1", new BoxChannel())); + var nativeMath = mock(VirtualChannelJNIBridgeService.class); + when(nativeMath.validate(eq("Motor speed * 2"), any())) + .thenReturn(Map.of("success", true, "dependencies", List.of("Motor speed"))); + var resolver = new VirtualChannelExecutionChannelResolver( + new VirtualChannelExecutionPlanBuilder(new VirtualChannelFormulaAnalyzer(nativeMath))); + ReflectionTestUtils.setField(fixture.bindings, "executionPlans", resolver); + var failure = assertThrows(CryBusinessException.class, () -> fixture.bind(List.of("M1"))); + assertEquals(ErrorCode.VIRTUAL_CHANNEL_DEPENDENCY_NOT_FOUND.getErrcode(), failure.getErrcode()); + } + + @Test void resolverUsesStableDeviceIdentityAndCanonicalDefinitionWithoutSourceCalls() throws Exception { + var row = can(); + var devices = mock(DeviceService.class); + var device = device(); when(devices.findById(9L)).thenReturn(device); + var resolver = new CanProjectChannelFacts(devices); + var first = resolver.resolve(row); + verify(devices).findById(9L); + verifyNoMoreInteractions(devices); + device.setIpAddress("changed-address"); + var moved = CanProjectChannelFacts.resolve(row, device); + assertEquals(first.binding(), moved.binding()); + var original = MeasurementInputBindings.FACTS.readTree(DEFINITION); + var reordered = MeasurementInputBindings.FACTS.createObjectNode(); + var keys = new ArrayList(); original.fieldNames().forEachRemaining(keys::add); + Collections.reverse(keys); keys.forEach(key -> reordered.set(key, original.get(key))); + assertEquals(first.definitionFingerprint(), CanProjectChannelFacts.fingerprint(reordered.toString())); + row.setCanDefinitionJson(DEFINITION.replace("\"factor\":1", "\"factor\":2")); + assertThrows(IllegalArgumentException.class, () -> CanProjectChannelFacts.requireMatches(row, first)); + device.setId(10L); + assertThrows(IllegalArgumentException.class, () -> CanProjectChannelFacts.resolve(can(), device)); + } + + static ChannelDto can() { + var row = new ChannelDto(); row.setId(51L); row.setBoxChannelId(51L); + row.setVchId("Can1"); row.setThreadChannelAlias("Can1"); row.setChannelIo(0); row.setChannelSource(2); + row.setProjectId(7L); row.setTenantId(1L); row.setDeviceId(9L); row.setProtocol("OPENDAQ"); + row.setCustomName("Motor speed"); row.setVchIdNumber(1); row.setCanDefinitionJson(DEFINITION); + return row; + } + + static Device device() { + var device = new Device(); device.setId(9L); device.setProtocol("OPENDAQ"); + device.setDeviceName("stable-native-id"); device.setIpAddress("old-address"); device.setTenantId(1L); + return device; + } + + static ChannelDto sampled(String id) { + var row = new ChannelDto(); row.setId(61L); row.setVchId(id); row.setThreadChannelAlias(id); + row.setChannelIo(0); row.setChannelSource(0); row.setProjectId(7L); row.setTenantId(1L); + row.setDeviceId(9L); row.setJniChannelNumber(1); row.setSamplingRate(48000); row.setChannelType(2); + return row; + } + + private static List ids(List rows) { return rows.stream().map(ChannelDto::getVchId).toList(); } + + private static final class Fixture { + final BoxChannelService channels = mock(BoxChannelService.class); + final PluginDashboardConfigurationResolver providers = mock(PluginDashboardConfigurationResolver.class); + final MeasurementInputBindings bindings = new MeasurementInputBindings(providers, channels, null); + final DashboardConfig owner = new DashboardConfig(); + + Fixture(List rows, boolean monitor, List triggers) { + owner.setProjectId(7L); owner.setTenantId(1L); + owner.setProviderId(monitor ? BuiltinDashboardProvider.MONITOR.getProviderId() : "other-measure"); + when(providers.find(eq(owner.getProviderId()), anyMap())).thenReturn( + new PluginDashboardConfigurationResolver.Registration(owner.getProviderId(), false, true, "1")); + when(providers.measurementConfiguration(owner.getProviderId())).thenReturn(true); + var interpreter = new MeasurementInputInterpreter() { + @Override public InputDeclaration declaration() { + return new InputDeclaration(List.of(), List.of(), List.of(), List.of(), triggers, OptionalInt.empty()); + } + @Override public List bind(Map configuration, ExecutionChannelFacts facts) { + return facts.selected().stream().map(ExecutionChannelFacts.Selection::unchanged).toList(); + } + }; + when(providers.measurementInputInterpreter(eq(owner.getProviderId()), anyMap(), any())) + .thenReturn(Optional.of(interpreter)); + when(providers.measurementInputInterpreter(eq(owner.getProviderId()), anyMap())).thenReturn(Optional.of(interpreter)); + for (boolean query : List.of(false, true)) + when(channels.getChannelMapByVchIdsV2(eq(7L), anySet(), eq(ChannelIOEnum.INPUT), eq(query))) + .thenAnswer(call -> { + Set ids = call.getArgument(1); + var selected = new LinkedHashMap(); + rows.stream().filter(row -> ids.contains(row.getVchId())).forEach(row -> selected.put(row.getVchId(), row)); + return selected; + }); + var devices = mock(DeviceService.class); when(devices.findById(9L)).thenReturn(device()); + ReflectionTestUtils.setField(bindings, "canProjectChannels", new CanProjectChannelFacts(devices)); + } + Map configuration(List ids) { return Map.of("collectConfig", Map.of("inputChannels", ids)); } + BoundMeasurementInputs bind(List ids) { + var configuration = configuration(ids); + return bindings.openCurrent(owner, configuration, null, false, List.of()).orElseThrow().bind(configuration); + } + } +} diff --git a/apps/backend/crydaq-service/src/test/java/com/opentest/service/dashboard/framework/CanMeasurementResultMemberFactsTest.java b/apps/backend/crydaq-service/src/test/java/com/opentest/service/dashboard/framework/CanMeasurementResultMemberFactsTest.java new file mode 100644 index 00000000..e5ecb5ba --- /dev/null +++ b/apps/backend/crydaq-service/src/test/java/com/opentest/service/dashboard/framework/CanMeasurementResultMemberFactsTest.java @@ -0,0 +1,103 @@ +package com.opentest.service.dashboard.framework; + +import com.opentest.common.model.dto.ChannelDto; +import com.opentest.dashboard.api.capability.CanChannelFacts; +import com.opentest.dashboard.api.channel.CanSignalChannel; +import com.opentest.dashboard.api.channel.ChannelDirection; +import com.opentest.dashboard.api.channel.ChannelMetadata; +import com.opentest.dashboard.api.channel.SignalType; +import com.opentest.dashboard.api.definition.ResultChannelDefinition; +import com.opentest.dashboard.api.definition.ResultChannelUnitFacts; +import com.opentest.dashboard.api.measurement.editing.InputDeclaration; +import com.opentest.dashboard.api.unit.GraphicUnitResolution; +import com.opentest.dashboard.api.unit.UnitCombination; +import com.opentest.service.can.CanProjectChannelFacts; +import java.util.List; +import java.util.Map; +import java.util.OptionalInt; +import java.util.Set; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertInstanceOf; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; + +class CanMeasurementResultMemberFactsTest { + private static final GraphicUnitResolution UNITS = new GraphicUnitResolution( + new UnitCombination("s", "rpm"), List.of(new UnitCombination("s", "rpm"))); + + @Test void frozenCanMemberUsesProjectRowAndNeverAcquiresSampledMetadata() { + var row = CanMeasurementInputBindingsTest.can(); + var can = CanProjectChannelFacts.resolve(row, CanMeasurementInputBindingsTest.device()); + var inputs = bound(List.of(row), List.of(row), can); + var fact = MeasurementResultMemberFacts.resolve(17, member(ChannelDirection.INPUT), inputs, null); + assertEquals(can, assertInstanceOf(MeasurementResultMemberFacts.CanSource.class, fact.source()).channel()); + assertThrows(IllegalArgumentException.class, fact::metadata); + var display = MeasurementResultMemberFacts.display(member(ChannelDirection.INPUT), inputs); + assertEquals("Motor speed", display.getCustomName()); + assertEquals("rpm", display.getChannelUnitY()); + assertEquals(2, display.getChannelSource()); + assertNull(display.getSamplingRate()); + assertNull(display.getJniChannelNumber()); + row.setCustomName("Edited later"); row.setCanDefinitionJson("{}"); + assertEquals("Motor speed", MeasurementResultMemberFacts.display(member(ChannelDirection.INPUT), inputs).getCustomName()); + } + + @Test void actualRowDirectionSelectionAndProjectIdentityCannotBeForgedByResultUnits() { + var row = CanMeasurementInputBindingsTest.can(); + var can = CanProjectChannelFacts.resolve(row, CanMeasurementInputBindingsTest.device()); + for (var direction : List.of(ChannelDirection.OUTPUT)) + assertThrows(IllegalArgumentException.class, () -> MeasurementResultMemberFacts.resolve(17, + member(direction), bound(List.of(row), List.of(row), can), null)); + assertThrows(IllegalArgumentException.class, () -> MeasurementResultMemberFacts.resolve(17, + member(null), bound(List.of(row), List.of(row), can), null)); + assertThrows(IllegalArgumentException.class, () -> MeasurementResultMemberFacts.resolve(17, + member(ChannelDirection.INPUT), bound(List.of(row), List.of(), can), null)); + assertThrows(IllegalArgumentException.class, () -> MeasurementResultMemberFacts.resolve(17, + member(ChannelDirection.INPUT), bound(List.of(row, row), List.of(row), can), null)); + for (String field : List.of("project", "box", "device", "port", "definition", "tenant", "source", "rate")) { + var altered = CanMeasurementInputBindingsTest.can(); + switch (field) { + case "project" -> altered.setProjectId(8L); + case "box" -> altered.setBoxChannelId(52L); + case "device" -> altered.setDeviceId(10L); + case "port" -> altered.setCanDefinitionJson(CanMeasurementInputBindingsTest.DEFINITION.replace("can0", "can1")); + case "definition" -> altered.setCanDefinitionJson(CanMeasurementInputBindingsTest.DEFINITION.replace("\"factor\":1", "\"factor\":2")); + case "tenant" -> altered.setTenantId(2L); + case "source" -> altered.setChannelSource(0); + case "rate" -> altered.setSamplingRate(48000); + default -> throw new AssertionError(field); + } + var invalid = bound(List.of(altered), List.of(row), can); + assertThrows(IllegalArgumentException.class, + () -> MeasurementResultMemberFacts.resolve(17, member(ChannelDirection.INPUT), invalid, null), field); + } + } + + @Test void resultMetadataCannotTurnCanIntoSampledSourceAndFingerprintIsChecked() { + var row = CanMeasurementInputBindingsTest.can(); + var can = CanProjectChannelFacts.resolve(row, CanMeasurementInputBindingsTest.device()); + var sampled = new ChannelMetadata("Can1", SignalType.AUDIO, 48000, "FS", null, null, null); + var forged = new ResultChannelDefinition("Can1", "Forged", ChannelDirection.INPUT, sampled, + new ResultChannelUnitFacts(SignalType.UNKNOWN, "rpm", UNITS)); + var inputs = bound(List.of(row), List.of(row), can); + assertThrows(IllegalArgumentException.class, () -> MeasurementResultMemberFacts.resolve(17, forged, inputs, null)); + assertThrows(IllegalArgumentException.class, () -> MeasurementResultMemberFacts.display(forged, inputs)); + var forgedCan = new CanSignalChannel(can.vchId(), can.projectChannelId(), can.projectId(), can.displayName(), + can.displayOrder(), can.binding(), can.persistedJson(), can.units(), "forged-fingerprint"); + assertThrows(IllegalArgumentException.class, () -> MeasurementResultMemberFacts.resolve(17, + member(ChannelDirection.INPUT), bound(List.of(row), List.of(row), forgedCan), null)); + } + + private static ResultChannelDefinition member(ChannelDirection direction) { + return new ResultChannelDefinition("Can1", "Motor speed", direction, null, + new ResultChannelUnitFacts(SignalType.UNKNOWN, "rpm", UNITS)); + } + + private static BoundMeasurementInputs bound(List available, List selected, CanSignalChannel can) { + return new BoundMeasurementInputs(new InputDeclaration(List.of(), List.of(), List.of(), List.of(), List.of(), OptionalInt.empty()), + Map.of(), selected, List.of(), List.of(), selected.size(), available, Set.of(), Set.of(), Map.of(), + new CanChannelFacts(Map.of(can.vchId(), can))); + } +} diff --git a/apps/backend/crydaq-service/src/test/java/com/opentest/service/dashboard/framework/CanProjectFactsWiringTest.java b/apps/backend/crydaq-service/src/test/java/com/opentest/service/dashboard/framework/CanProjectFactsWiringTest.java new file mode 100644 index 00000000..d9a23619 --- /dev/null +++ b/apps/backend/crydaq-service/src/test/java/com/opentest/service/dashboard/framework/CanProjectFactsWiringTest.java @@ -0,0 +1,37 @@ +package com.opentest.service.dashboard.framework; + +import com.opentest.service.BoxChannelService; +import com.opentest.service.DeviceService; +import com.opentest.service.can.CanProjectChannelFacts; +import com.opentest.service.jni.AudioJNIBridgeService; +import com.opentest.service.unit.PhysicalResultUnitOptionService; +import com.opentest.service.virtualchannel.VirtualChannelExecutionChannelResolver; +import org.junit.jupiter.api.Test; +import org.springframework.context.annotation.AnnotationConfigApplicationContext; + +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verifyNoInteractions; + +class CanProjectFactsWiringTest { + @Test void bindsRealCanFactsWithoutAProxyOrNativeDeviceLookupAtStartup() { + DeviceService devices = mock(DeviceService.class); + BoxChannelService channels = mock(BoxChannelService.class); + AudioJNIBridgeService audio = mock(AudioJNIBridgeService.class); + try (var context = new AnnotationConfigApplicationContext()) { + var beans = context.getBeanFactory(); + beans.registerSingleton("deviceService", devices); + beans.registerSingleton("boxChannelService", channels); + beans.registerSingleton("audioJNIBridgeService", audio); + beans.registerSingleton("pluginDashboardConfigurationResolver", mock(PluginDashboardConfigurationResolver.class)); + beans.registerSingleton("projectTriggerFacts", mock(ProjectTriggerFacts.class)); + beans.registerSingleton("virtualChannelExecutionChannelResolver", mock(VirtualChannelExecutionChannelResolver.class)); + beans.registerSingleton("physicalResultUnitOptionService", mock(PhysicalResultUnitOptionService.class)); + context.register(CanProjectChannelFacts.class, MeasurementInputBindings.class); + context.refresh(); + assertNotNull(context.getBean(MeasurementInputBindings.class)); + assertNotNull(context.getBean(CanProjectChannelFacts.class)); + verifyNoInteractions(devices, channels, audio); + } + } +} diff --git a/apps/backend/crydaq-service/src/test/java/com/opentest/service/dashboard/framework/CanStoredUnitSelectionTest.java b/apps/backend/crydaq-service/src/test/java/com/opentest/service/dashboard/framework/CanStoredUnitSelectionTest.java new file mode 100644 index 00000000..8111c227 --- /dev/null +++ b/apps/backend/crydaq-service/src/test/java/com/opentest/service/dashboard/framework/CanStoredUnitSelectionTest.java @@ -0,0 +1,106 @@ +package com.opentest.service.dashboard.framework; + +import com.fasterxml.jackson.core.type.TypeReference; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.opentest.common.model.dto.CanRecordingSectionDto; +import com.opentest.common.model.dto.ChannelDto; +import com.opentest.common.model.dto.FlowExecuteSnapshotDataDto; +import com.opentest.common.model.dto.SimpleChannelDto; +import com.opentest.common.model.dto.RenderDataDto; +import com.opentest.common.model.entity.File; +import com.opentest.dashboard.api.channel.CanPortBinding; +import com.opentest.dashboard.api.channel.CanSignalChannel; +import com.opentest.dashboard.api.channel.CanSignalQuantity; +import com.opentest.dashboard.api.channel.CanSignalUnits; +import com.opentest.dashboard.api.unit.UnitCombination; +import com.opentest.service.jni.UnitConversionService; +import com.opentest.service.can.CanStoredUnitConversion; +import com.opentest.service.liteflow.result.ResultUnitConversionService; +import java.util.List; +import java.util.Map; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class CanStoredUnitSelectionTest { + private static final String DEFINITION = """ + {"schemaVersion":1,"portId":"can0","decodeMethod":"manual","definition":{ + "canId":384,"idFormat":"standard","frameType":"any","byteOrder":"motorola", + "valueType":"signed","startBit":23,"bitLength":16,"factor":0.01,"offset":40, + "timeoutMs":1000},"quantity":"TEMPERATURE","sourceUnit":"degC","outputUnit":"degF"} + """; + + @Test void displayCelsiusSelectsTheSameFrozenFahrenheitFile() { + var file = new File(); file.setId(701L); file.setRequestId(200L); + var source = new SavedProviderArtifacts.Source(file, new UnitCombination("s", "degF"), null); + assertSame(source, SavedProviderArtifacts.select(List.of(source), "s", "degC", + member(), "CAN8", snapshot(), new UnitConversionService())); + } + + @Test void conversionChannelRetainsFrozenCanDefinitionWithoutSampledFields() { + var channel = SavedProviderArtifacts.channel(member(), "CAN8", snapshot(), null); + assertEquals(DEFINITION, channel.getCanDefinitionJson()); + assertEquals(2, channel.getChannelSource()); + } + + @Test void convertedSavedValuesDoNotApplyTheRawDecodeFactorOrOffsetAgain() { + var service = new UnitConversionService(); + assertArrayEquals(new double[]{24.64, Double.NaN}, service.convert(null, + new double[]{76.352, Double.NaN}, "degF", "degC", channel(), "CAN Viewer"), 1e-10); + } + + @Test void workerMetadataDescribesStoredValuesAndLeavesRawDecodeSettingsUnused() { + var conversion = CanStoredUnitConversion.display(snapshot(), "CAN8", "degF", "degC"); + assertEquals("degF", conversion.sourceUnit()); + assertEquals("degC", conversion.targetUnit()); + assertEquals(24.64, 76.352 * conversion.scale() + conversion.offset(), 1e-10); + } + + @Test void originalUnitExplicitlyClearsThePreviousDisplayConversion() { + var mapper = new ObjectMapper(); + mapper.setDefaultPropertyInclusion(JsonInclude.Include.NON_NULL); + var data = new RenderDataDto(); + var serialized = mapper.valueToTree(data); + assertTrue(serialized.has("canUnitConversion")); + assertTrue(serialized.get("canUnitConversion").isNull()); + } + + @Test void resultAndPooledReadersUseTheSameStoredUnitConversion() { + var service = new ResultUnitConversionService(new UnitConversionService()); + assertArrayEquals(new double[]{24.64}, service.convert(null, new double[]{76.352}, + "degF", "degC", channel(), "CAN Value"), 1e-10); + try (var values = service.convertPooled(null, new double[]{76.352, Double.NaN}, + "degF", "degC", channel(), "CAN Viewer")) { + assertArrayEquals(new double[]{24.64, Double.NaN}, values.array(), 1e-10); + } + } + + private static ChannelDto channel() { + var channel = new ChannelDto(); + channel.setVchId("CAN8"); channel.setChannelSource(2); channel.setCanDefinitionJson(DEFINITION); + return channel; + } + + private static SimpleChannelDto member() { + var member = new SimpleChannelDto(); + member.setVchId("CAN8"); member.setChannelSource(2); member.setChannelUnitY("degF"); + return member; + } + + private static FlowExecuteSnapshotDataDto snapshot() { + var frozen = new CanSignalChannel("CAN8", "51", "7", "Recorded temperature", 1, + new CanPortBinding("9", "OPENDAQ", "archived-device", "can0"), DEFINITION, + new CanSignalUnits(CanSignalQuantity.TEMPERATURE, "degC", "degF", null), "frozen"); + var section = new CanRecordingSectionDto(); + section.setRequestId("200"); section.setStatus("FINISHED"); + Map> facts = new ObjectMapper().convertValue( + Map.of("CAN8", frozen), new TypeReference<>() { }); + section.setChannels(facts); + var snapshot = new FlowExecuteSnapshotDataDto(); snapshot.setCanRecording(section); + return snapshot; + } +} diff --git a/apps/backend/crydaq-service/src/test/java/com/opentest/service/dashboard/framework/ProviderHistoricalCanUnitFactsTest.java b/apps/backend/crydaq-service/src/test/java/com/opentest/service/dashboard/framework/ProviderHistoricalCanUnitFactsTest.java new file mode 100644 index 00000000..282fda6f --- /dev/null +++ b/apps/backend/crydaq-service/src/test/java/com/opentest/service/dashboard/framework/ProviderHistoricalCanUnitFactsTest.java @@ -0,0 +1,321 @@ +package com.opentest.service.dashboard.framework; + +import com.fasterxml.jackson.databind.ObjectMapper; +import com.opentest.common.config.DashboardConfigurationJson; +import com.opentest.common.model.dto.ChannelDto; +import com.opentest.common.model.dto.DashboardConfigDto; +import com.opentest.common.model.dto.FlowExecuteSnapshotDataDto; +import com.opentest.common.model.dto.GraphicResultCodeDto; +import com.opentest.common.model.dto.dashboard.DashboardItemConfigDto; +import com.opentest.common.model.entity.DashboardResult; +import com.opentest.common.model.entity.FlowExecuteResult; +import com.opentest.common.model.query.ChartConfigQuery; +import com.opentest.common.model.query.DashboardResultItemQuery; +import com.opentest.common.utils.SpringContextHolder; +import com.opentest.dal.mapper.sqlite.DashboardConfigMapper; +import com.opentest.dal.mapper.sqlite.DashboardResultMapper; +import com.opentest.dal.mapper.sqlite.FlowExecuteResultMapper; +import com.opentest.dashboard.api.channel.ChannelCatalog; +import com.opentest.dashboard.api.channel.ChannelDirection; +import com.opentest.dashboard.api.channel.SignalType; +import com.opentest.dashboard.api.definition.DomainType; +import com.opentest.dashboard.api.definition.ResultChannelDefinition; +import com.opentest.dashboard.api.definition.ResultChannelUnitFacts; +import com.opentest.dashboard.api.definition.ResultSetDefinition; +import com.opentest.dashboard.api.definition.ResultType; +import com.opentest.dashboard.api.execution.ExecutionChannelFacts; +import com.opentest.dashboard.api.measurement.ResultDescription; +import com.opentest.dashboard.api.measurement.editing.InputDeclaration; +import com.opentest.dashboard.api.unit.GraphicUnitResolution; +import com.opentest.dashboard.api.unit.GraphicUnitScene; +import com.opentest.service.BoxChannelService; +import com.opentest.service.FileService; +import com.opentest.service.helper.DisplayTextResolver; +import java.util.ArrayList; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.OptionalInt; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import org.mockito.MockedStatic; +import org.springframework.test.util.ReflectionTestUtils; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyList; +import static org.mockito.ArgumentMatchers.anyMap; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.doAnswer; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.mockStatic; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.verifyNoInteractions; +import static org.mockito.Mockito.when; + +class ProviderHistoricalCanUnitFactsTest { + private static final String OWNER = "test:saved-can-units"; + private static final List CAN_UNITS = List.of("km/h", "m/s", "mph"); + private static final GraphicUnitResolution CAN_RESOLUTION = GraphicUnitResolution.choices( + "s", "m/s", CAN_UNITS.toArray(String[]::new)); + private static final GraphicUnitResolution AUDIO_RESOLUTION = GraphicUnitResolution.choices("s", "Pa", "Pa", "dB"); + private static final String CAN_DEFINITION = """ + {"schemaVersion":1,"portId":"can0","decodeMethod":"manual","definition":{ + "canId":384,"idFormat":"standard","frameType":"any","byteOrder":"intel", + "valueType":"unsigned","startBit":0,"bitLength":16,"factor":1,"offset":0, + "timeoutMs":1000},"quantity":"SPEED","sourceUnit":"km/h","outputUnit":"m/s"} + """; + private final ObjectMapper json = new ObjectMapper(); + private final DashboardResultMapper results = mock(DashboardResultMapper.class); + private final DashboardConfigMapper dashboards = mock(DashboardConfigMapper.class); + private final FlowExecuteResultMapper executions = mock(FlowExecuteResultMapper.class); + private final BoxChannelService currentChannels = mock(BoxChannelService.class); + private final FileService files = mock(FileService.class); + private final PluginDashboardConfigurationResolver providers = mock(PluginDashboardConfigurationResolver.class); + private final DashboardResult row = new DashboardResult(); + private final DashboardConfigDto dashboard = new DashboardConfigDto(); + private final FlowExecuteResult execution = new FlowExecuteResult(); + private ProviderGraphicUnitService service; + private ResultSetDefinition definition; + private MockedStatic text; + + @BeforeEach void setUp() throws Exception { + row.setId(100L); row.setSourceId(90L); row.setRequestId(200L); + row.setTenantId(30L); row.setProjectId(20L); row.setDashboardId(10L); + row.setPrimaryCode("CAN Viewer"); row.setHash("frozen"); row.setResultType(ResultType.TIME.ordinal()); + dashboard.setId(10L); dashboard.setTenantId(30L); dashboard.setProjectId(20L); dashboard.setProviderId(OWNER); + execution.setId(200L); execution.setTenantId(30L); execution.setProjectId(20L); execution.setDashboardId(10L); + when(results.selectById(100L)).thenReturn(row); + when(executions.selectById(200L)).thenReturn(execution); + when(providers.ready()).thenReturn(true); + when(providers.available(OWNER)).thenReturn(true); + when(providers.measurement(OWNER)).thenReturn(true); + var interpreter = new MeasurementInputInterpreter() { + @Override public InputDeclaration declaration() { + return new InputDeclaration(List.of(), List.of(), List.of(), List.of(), List.of(), OptionalInt.empty()); + } + @Override public List bind(Map configuration, + ExecutionChannelFacts facts) { + return facts.saved(List.of("collectConfig", "channels")).stream() + .filter(fact -> !Integer.valueOf(1).equals(fact.values().get("channelIo"))) + .map(ExecutionChannelFacts.Selection::unchanged).toList(); + } + }; + when(providers.measurementInputInterpreter(eq(OWNER), any())).thenReturn(Optional.of(interpreter)); + when(providers.describeResult(eq(OWNER), any(), any(), any(ChannelCatalog.class))) + .thenAnswer(call -> Optional.of(new ResultDescription(definition))); + when(files.getExactMapByRequestAndBusinessIds(eq(200L), anyList())).thenReturn(Map.of()); + service = spy(new ProviderGraphicUnitService(results, dashboards, null, providers, currentChannels, + files, json, executions, null)); + ReflectionTestUtils.setField(service, "providerResults", new ProviderDashboardResultReader(json, providers)); + text = mockStatic(DisplayTextResolver.class); + text.when(DisplayTextResolver::current).thenReturn(mock(DisplayTextResolver.class)); + configure(false, true); + } + + @AfterEach void closeText() { text.close(); } + + @ParameterizedTest @ValueSource(booleans = {false, true}) + void canOnlyAndMixedMenusReadFrozenUnitsWithoutSampledCanMetadata(boolean mixed) throws Exception { + for (boolean declaredFacts : List.of(false, true)) { + configure(mixed, declaredFacts); + declaredResolutionBoundary(); + String savedRow = json.writeValueAsString(row); + String savedSnapshot = execution.getSnapshotData(); + var menu = service.query(new ChartConfigQuery(), item()); + assertEquals(mixed ? 3 : 1, menu.getUnitsY().size()); + var can = menu.getUnitsY().getFirst(); + assertEquals(-1, can.getChannelType()); + assertEquals(List.of("Can1"), can.getChannelIds()); + assertEquals(CAN_UNITS, can.getUnit()); + assertEquals("m/s", can.getDefaultUnit()); + assertEquals(CAN_UNITS, service.memberOptions(100L, -1, false)); + assertEquals(List.of(), service.memberOptions(100L, -1, true)); + var metadata = service.memberMetadata(binding(), "Can1"); + assertEquals(0, metadata.getChannelSource()); + assertEquals("km/h", metadata.getSourceUnit()); + assertNull(metadata.getMathUnit()); + assertTrue(metadata.getUnitSwitchSupported()); + assertEquals(CAN_UNITS.size(), metadata.getUnitSets().size()); + assertTrue(metadata.getUnitSets().containsAll(CAN_UNITS)); + if (mixed) { + assertEquals(List.of("Pa", "dB"), service.memberOptions(100L, 2, true)); + assertEquals(1, service.memberMetadata(binding(), "Math1").getChannelSource()); + assertEquals("Pa", service.memberMetadata(binding(), "Math1").getMathUnit()); + } + assertEquals(savedRow, json.writeValueAsString(row)); + assertEquals(savedSnapshot, execution.getSnapshotData()); + } + verifyNoInteractions(currentChannels, dashboards, files); + } + + @ParameterizedTest @ValueSource(booleans = {false, true}) + void actualHistoryResolutionReceivesTypedCanAndKeepsAbsentArtifactsUnavailable(boolean mixed) throws Exception { + configure(mixed, true); + when(providers.resolveGraphicUnits(eq(OWNER), anyMap(), any(), any(), eq(GraphicUnitScene.HISTORY_VIEW), + anyMap(), any(), any(), any(), anyMap(), any(ChannelCatalog.class), eq("Can1"))).thenAnswer(call -> { + assertNull(call.getArgument(3), "CAN must not be projected as sampled ChannelMetadata"); + Map sampled = call.getArgument(9); + assertFalse(sampled.containsKey("Can1")); + ChannelCatalog catalog = call.getArgument(10); + var can = catalog.canInputs().channels().get("Can1"); + assertEquals(CAN_DEFINITION, can.persistedJson()); + assertEquals("OPENDAQ\u001farchived-device", can.binding().stableDeviceId()); + assertEquals("km/h", can.units().sourceUnit()); + assertEquals(CAN_RESOLUTION, call.getArgument(6)); + return CAN_RESOLUTION; + }); + assertTrue(service.resolve(row, "Can1", Map.of()).combinations().isEmpty()); + var menu = service.query(new ChartConfigQuery(), canItem()); + assertEquals(-1, menu.getUnitsY().getFirst().getChannelType()); + assertTrue(menu.getUnitsY().getFirst().getUnit().isEmpty()); + verifyNoInteractions(currentChannels, dashboards); + } + + @ParameterizedTest @ValueSource(strings = {"options", "metadata"}) + void canSourceUnitEntriesNeedNoSampledMetadata(String entry) throws Exception { + configure(false, false); + declaredResolutionBoundary(); + if (entry.equals("options")) { + assertEquals(CAN_UNITS, service.memberOptions(100L, -1, false)); + } else { + assertEquals("km/h", service.memberMetadata(binding(), "Can1").getSourceUnit()); + } + verifyNoInteractions(currentChannels, dashboards, files); + } + + @Test void archivedDbcUnitMenuDoesNotNeedCurrentDeviceOrDbcParser() throws Exception { + configure(false, false); + var can = can(); + can.setCanDefinitionJson(CAN_DEFINITION.replace("\"manual\"", "\"dbc\"") + .replace("\"definition\"", "\"dbc\":{\"fileName\":\"archived.dbc\",\"contentBase64\":\"AQID\"," + + "\"messageId\":\"384\",\"signalName\":\"speed\"},\"definition\"")); + saveChannels(List.of(can)); + declaredResolutionBoundary(); + try (var services = mockStatic(SpringContextHolder.class, call -> { + throw new AssertionError("Historical units must not query current services: " + call.getMethod()); + })) { + assertEquals(CAN_UNITS, service.query(new ChartConfigQuery(), item()).getUnitsY().getFirst().getUnit()); + assertEquals(CAN_UNITS, service.memberOptions(100L, -1, false)); + assertEquals("km/h", service.memberMetadata(binding(), "Can1").getSourceUnit()); + } + verifyNoInteractions(currentChannels, dashboards, files); + } + + @Test void sampledOutputWithCanInputIdRetainsItsDirectionAndUnits() throws Exception { + var output = sampled("Can1", 1, false); + saveChannels(List.of(can(), output)); + setMembers(List.of(ResultChannelDefinition.source("Can1", "Output", ChannelDirection.OUTPUT, AUDIO_RESOLUTION))); + declaredResolutionBoundary(); + assertEquals(2, service.query(new ChartConfigQuery(), item()).getUnitsY().getFirst().getChannelType()); + assertEquals(List.of("Pa", "dB"), service.memberOptions(100L, 2, false)); + assertEquals(List.of(), service.memberOptions(100L, -1, false)); + verifyNoInteractions(currentChannels, dashboards); + } + + @ParameterizedTest @ValueSource(strings = {"ordinary", "wrong-direction"}) + void missingSampledSourceAndCanInTheWrongDirectionStillFail(String kind) { + String id = kind.equals("ordinary") ? "MissingAudio" : "Can1"; + var direction = kind.equals("ordinary") ? ChannelDirection.INPUT : ChannelDirection.OUTPUT; + setMembers(List.of(ResultChannelDefinition.source(id, id, direction, AUDIO_RESOLUTION))); + assertThrows(IllegalArgumentException.class, () -> service.resolve(row, id, Map.of())); + declaredResolutionBoundary(); + assertThrows(IllegalArgumentException.class, () -> service.query(new ChartConfigQuery(), item())); + assertThrows(IllegalArgumentException.class, () -> service.memberOptions(100L, null, false)); + assertThrows(IllegalArgumentException.class, () -> service.memberMetadata(binding(), id)); + verifyNoInteractions(currentChannels, dashboards); + } + + @ParameterizedTest @ValueSource(strings = {"tenant", "project", "dashboard", "execution-dashboard"}) + void allHistoricalUnitEntriesValidateFrozenScope(String field) throws Exception { + switch (field) { + case "tenant" -> execution.setTenantId(999L); + case "project" -> execution.setProjectId(999L); + case "dashboard" -> dashboard.setId(999L); + case "execution-dashboard" -> execution.setDashboardId(999L); + default -> throw new AssertionError(field); + } + saveSnapshot(); + assertThrows(IllegalArgumentException.class, () -> service.query(new ChartConfigQuery(), item())); + assertThrows(IllegalArgumentException.class, () -> service.memberOptions(100L, null, false)); + assertThrows(IllegalArgumentException.class, () -> service.memberMetadata(binding(), "Can1")); + assertThrows(IllegalArgumentException.class, () -> service.resolve(row, "Can1", Map.of())); + verifyNoInteractions(currentChannels, dashboards); + } + + private void configure(boolean mixed, boolean declaredFacts) throws Exception { + var rows = new ArrayList(); rows.add(can()); + var members = new ArrayList(); + members.add(declaredFacts ? new ResultChannelDefinition("Can1", "Frozen speed", ChannelDirection.INPUT, null, + new ResultChannelUnitFacts(SignalType.UNKNOWN, "km/h", CAN_RESOLUTION)) + : ResultChannelDefinition.source("Can1", "Frozen speed", ChannelDirection.INPUT, CAN_RESOLUTION)); + if (mixed) { + rows.add(sampled("Audio", 0, false)); rows.add(sampled("Math1", 0, true)); + members.add(ResultChannelDefinition.source("Audio", "Audio", ChannelDirection.INPUT, AUDIO_RESOLUTION)); + members.add(ResultChannelDefinition.source("Math1", "Math", ChannelDirection.INPUT, AUDIO_RESOLUTION)); + } + setMembers(members); + saveChannels(rows); + } + + private void setMembers(List members) { + definition = new ResultSetDefinition("CAN Viewer", "frozen", "test.can", ResultType.TIME, + DomainType.TIME_DOMAIN, List.of(), Map.of(), members, Map.of()); + } + + private void saveChannels(List rows) throws Exception { + var values = rows.stream().map(channel -> json.convertValue(channel, LinkedHashMap.class)).toList(); + dashboard.setDashboardItemConfig(DashboardConfigurationJson.bind( + Map.of("collectConfig", Map.of("channels", values, + "inputChannels", rows.stream().map(ChannelDto::getVchId).distinct().toList())), DashboardItemConfigDto.class)); + saveSnapshot(); + } + + private void saveSnapshot() throws Exception { + var snapshot = new FlowExecuteSnapshotDataDto(); snapshot.setDashboardConfig(dashboard); + execution.setSnapshotData(json.writeValueAsString(snapshot)); + } + + private void declaredResolutionBoundary() { + // Readability is tested separately through the actual historical resolve entry. + doAnswer(call -> MeasurementResultFacts.requireMember(definition, call.getArgument(1)).declaredUnits()) + .when(service).resolve(eq(row), anyString(), anyMap()); + } + + private static ChannelDto can() { + var channel = new ChannelDto(); channel.setId(51L); channel.setBoxChannelId(51L); + channel.setProjectId(20L); channel.setDeviceId(9L); channel.setChannelIo(0); channel.setChannelSource(2); + channel.setVchId("Can1"); channel.setVchIdNumber(1); channel.setProtocol("OPENDAQ"); + channel.setDeviceName("archived-device"); channel.setCustomName("Frozen speed"); + channel.setCanDefinitionJson(CAN_DEFINITION); + return channel; + } + + private static ChannelDto sampled(String id, int direction, boolean math) { + var channel = new ChannelDto(); channel.setVchId(id); channel.setChannelIo(direction); + channel.setChannelSource(math ? 1 : 0); channel.setSamplingRate(48000); channel.setChannelType(2); + if (math) channel.setMathUnit("Pa"); + return channel; + } + + private static DashboardResultItemQuery item() { + var item = new DashboardResultItemQuery(); item.setDashboardResultId(100L); return item; + } + + private static DashboardResultItemQuery canItem() { + var item = item(); item.setChannelIds(List.of("Can1")); return item; + } + + private static GraphicResultCodeDto binding() { + var binding = new GraphicResultCodeDto(); binding.setDashboardResultId(100L); return binding; + } +} diff --git a/apps/backend/crydaq-service/src/test/java/com/opentest/service/dashboard/framework/SavedCanHistoryFactsTest.java b/apps/backend/crydaq-service/src/test/java/com/opentest/service/dashboard/framework/SavedCanHistoryFactsTest.java new file mode 100644 index 00000000..d33f5630 --- /dev/null +++ b/apps/backend/crydaq-service/src/test/java/com/opentest/service/dashboard/framework/SavedCanHistoryFactsTest.java @@ -0,0 +1,228 @@ +package com.opentest.service.dashboard.framework; + +import com.fasterxml.jackson.databind.ObjectMapper; +import com.opentest.common.config.DashboardConfigurationJson; +import com.opentest.common.model.dto.ChannelDto; +import com.opentest.common.model.dto.DashboardConfigDto; +import com.opentest.common.model.dto.dashboard.DashboardItemConfigDto; +import com.opentest.common.model.entity.DashboardResult; +import com.opentest.common.utils.SpringContextHolder; +import com.opentest.dashboard.api.channel.CanSignalQuantity; +import com.opentest.dashboard.api.channel.CanSignalUnits; +import com.opentest.dashboard.api.channel.ChannelCatalog; +import com.opentest.dashboard.api.channel.ChannelDirection; +import com.opentest.dashboard.api.channel.SignalType; +import com.opentest.dashboard.api.definition.DomainType; +import com.opentest.dashboard.api.definition.ResultChannelDefinition; +import com.opentest.dashboard.api.definition.ResultChannelUnitFacts; +import com.opentest.dashboard.api.definition.ResultSetDefinition; +import com.opentest.dashboard.api.definition.ResultType; +import com.opentest.dashboard.api.execution.ExecutionChannelFacts; +import com.opentest.dashboard.api.measurement.ResultDescription; +import com.opentest.dashboard.api.measurement.editing.InputDeclaration; +import com.opentest.dashboard.api.unit.GraphicUnitResolution; +import com.opentest.service.helper.DisplayTextResolver; +import com.opentest.service.plugin.MeasureProviderInputs; +import java.util.ArrayList; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.OptionalInt; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.mockStatic; +import static org.mockito.Mockito.when; + +class SavedCanHistoryFactsTest { + private static final String PROVIDER = "test:saved-can"; + private static final String DEFINITION = """ + {"schemaVersion":1,"portId":"can0","decodeMethod":"manual","definition":{ + "canId":384,"idFormat":"standard","frameType":"any","byteOrder":"intel", + "valueType":"unsigned","startBit":0,"bitLength":16,"factor":1,"offset":0, + "timeoutMs":1000},"quantity":"SPEED","sourceUnit":"km/h","outputUnit":"m/s"} + """; + private static final MeasurementInputInterpreter INTERPRETER = new MeasurementInputInterpreter() { + @Override public InputDeclaration declaration() { + return new InputDeclaration(List.of(), List.of(), List.of(), List.of(), List.of(), OptionalInt.empty()); + } + @Override public List bind(Map configuration, + ExecutionChannelFacts facts) { + return facts.saved(List.of("collectConfig", "channels")).stream() + .map(ExecutionChannelFacts.Selection::unchanged).toList(); + } + }; + + @Test void frozenCanWithoutAudioFieldsBuildsTypedCatalogueWithoutServiceLookup() { + var configuration = configuration(List.of(can())); + var rows = SavedMeasurementInputFacts.readChannelFacts(INTERPRETER, configuration); + assertNull(rows.getFirst().getSamplingRate()); + assertNull(rows.getFirst().getBitDepth()); + try (var services = mockStatic(SpringContextHolder.class, call -> { + throw new AssertionError("Saved CAN must not query Spring services: " + call.getMethod()); + })) { + var catalog = SavedMeasurementInputFacts.catalog(rows); + var frozen = catalog.canInputs().channels().get("Can1"); + assertEquals("51", frozen.projectChannelId()); + assertEquals("7", frozen.projectId()); + assertEquals("9", frozen.binding().deviceId()); + assertEquals("OPENDAQ", frozen.binding().protocol()); + assertEquals("OPENDAQ\u001farchived-device", frozen.binding().stableDeviceId()); + assertEquals("can0", frozen.binding().portId()); + assertEquals("Frozen speed", frozen.displayName()); + assertEquals(new CanSignalUnits(CanSignalQuantity.SPEED, "km/h", "m/s", null), frozen.units()); + assertEquals(List.of("km/h", "m/s", "mph"), frozen.units().outputUnits()); + assertEquals(DEFINITION, frozen.persistedJson()); + assertEquals(64, frozen.definitionFingerprint().length()); + assertTrue(catalog.channels(ChannelDirection.INPUT).isEmpty()); + assertNull(catalog.get(ChannelDirection.INPUT, "Can1")); + } + for (var read : List.of(SavedMeasurementInputFacts.read(INTERPRETER, configuration), + SavedMeasurementInputFacts.readCatalog(INTERPRETER, configuration), + SavedMeasurementInputFacts.readExecutionInputs(INTERPRETER, configuration))) { + assertNull(read.getFirst().getSamplingRate()); + assertNull(read.getFirst().getBitDepth()); + assertEquals(DEFINITION, read.getFirst().getCanDefinitionJson()); + } + } + + @Test void normalSavedResultReaderDescribesCanOnlyAndMixedMembersWithFrozenUnits() { + for (boolean mixed : List.of(false, true)) { + var rows = new ArrayList(); + rows.add(can()); + if (mixed) rows.add(sampled("Audio", 0, false)); + var dashboard = new DashboardConfigDto(); + dashboard.setProviderId(PROVIDER); + dashboard.setDashboardItemConfig(DashboardConfigurationJson.bind(configuration(rows), DashboardItemConfigDto.class)); + var providers = mock(PluginDashboardConfigurationResolver.class); + when(providers.ready()).thenReturn(true); + when(providers.available(PROVIDER)).thenReturn(true); + when(providers.measurement(PROVIDER)).thenReturn(true); + when(providers.measurementInputInterpreter(eq(PROVIDER), any())).thenReturn(Optional.of(INTERPRETER)); + when(providers.describeResult(eq(PROVIDER), any(), any(), any(ChannelCatalog.class))).thenAnswer(call -> { + ChannelCatalog catalog = call.getArgument(3); + var can = catalog.canInputs().channels().get("Can1"); + assertEquals(mixed ? 1 : 0, catalog.channels(ChannelDirection.INPUT).size()); + assertEquals("Frozen speed", can.displayName()); + var units = GraphicUnitResolution.choices("s", can.units().outputUnit(), + can.units().outputUnits().toArray(String[]::new)); + return Optional.of(new ResultDescription(new ResultSetDefinition("CAN Viewer", "frozen", + "result.saved", ResultType.TIME, DomainType.TIME_DOMAIN, List.of(), Map.of(), + List.of(new ResultChannelDefinition(can.vchId(), can.displayName(), ChannelDirection.INPUT, + null, new ResultChannelUnitFacts(SignalType.UNKNOWN, can.units().sourceUnit(), units))), + Map.of()))); + }); + var reader = new ProviderDashboardResultReader(new ObjectMapper(), providers); + var result = new DashboardResult(); + result.setPrimaryCode("CAN Viewer"); result.setHash("frozen"); result.setResultType(ResultType.TIME.ordinal()); + var definition = reader.describeSavedTableDefinition(dashboard, result).orElseThrow(); + assertEquals(List.of("km/h", "m/s", "mph"), definition.channels().getFirst().declaredUnits() + .combinations().stream().map(unit -> unit.unitY()).toList()); + try (var text = mockStatic(DisplayTextResolver.class)) { + text.when(DisplayTextResolver::current).thenReturn(mock(DisplayTextResolver.class)); + var member = reader.readSavedTableDefinition(result, dashboard, definition).getChannels().getFirst(); + assertEquals("Can1", member.getVchId()); + assertEquals("m/s", member.getChannelUnitY()); + assertEquals("km/h", member.getMathUnit()); + assertNull(member.getSamplingRate()); + assertNull(member.getBitDepth()); + } + assertEquals(rows.size(), reader.readSavedMeasurementInputs(dashboard).orElseThrow().size()); + assertEquals(rows.size(), reader.readSavedExecutionInputCatalog(dashboard).size()); + assertEquals(DEFINITION, reader.savedChannelFacts(dashboard).canInputs().channels().get("Can1").persistedJson()); + var metadata = reader.savedChannelMetadata(PROVIDER, + MeasureProviderInputs.jsonMap(dashboard.getDashboardItemConfig()), dashboard); + assertEquals(mixed ? List.of("Audio") : List.of(), new ArrayList<>(metadata.keySet())); + } + } + + @Test void mixedCatalogueRetainsMathAndInputOutputIdentityAndOldDiagnostics() { + var input = sampled("Shared", 0, false); + var output = sampled("Shared", 1, false); + output.setSamplingRate(96000); + var math = sampled("Math1", 0, true); + var catalog = SavedMeasurementInputFacts.catalog(List.of(can(), input, output, math)); + assertEquals(48000, catalog.get(ChannelDirection.INPUT, "Shared").sampleRate()); + assertEquals(96000, catalog.get(ChannelDirection.OUTPUT, "Shared").sampleRate()); + assertTrue(catalog.get(ChannelDirection.INPUT, "Math1").computed()); + assertEquals("Pa", catalog.get(ChannelDirection.INPUT, "Math1").waveformUnit()); + assertThrows(IllegalArgumentException.class, catalog::byId); + input.setSamplingRate(null); + assertEquals("MEASURE_CHANNEL_SAMPLE_RATE_REQUIRED", assertThrows(IllegalArgumentException.class, + () -> SavedMeasurementInputFacts.catalog(List.of(input))).getMessage()); + input.setChannelIo(null); + assertEquals("Saved channel direction is required", assertThrows(NullPointerException.class, + () -> SavedMeasurementInputFacts.catalog(List.of(input))).getMessage()); + } + + @Test void canDefinitionsRetainPprAndFrozenDbcWithoutNativeRevalidation() { + var can = can(); + can.setCanDefinitionJson(DEFINITION.replace("\"SPEED\"", "\"TACHO\"") + .replace("\"km/h\"", "\"Hz\"").replace("\"m/s\"", "\"rpm\"") + .replace("\"quantity\"", "\"tachoPpr\":8,\"quantity\"")); + assertEquals(new CanSignalUnits(CanSignalQuantity.TACHO, "Hz", "rpm", 8), + SavedMeasurementInputFacts.catalog(List.of(can)).canInputs().channels().get("Can1").units()); + can.setCanDefinitionJson(DEFINITION.replace("\"manual\"", "\"dbc\"") + .replace("\"definition\"", "\"dbc\":{\"fileName\":\"archived.dbc\",\"contentBase64\":\"AQID\"," + + "\"messageId\":\"384\",\"signalName\":\"speed\"},\"definition\"")); + assertEquals(CanSignalQuantity.SPEED, + SavedMeasurementInputFacts.catalog(List.of(can)).canInputs().channels().get("Can1").units().quantity()); + } + + @Test void rejectsConflictingCanAndSampledIdentitiesAndInvalidFrozenDefinitions() { + var first = can(); + assertEquals(1, SavedMeasurementInputFacts.catalog(List.of(first, can())).canInputs().channels().size()); + var altered = can(); altered.setDeviceId(10L); + assertThrows(IllegalArgumentException.class, () -> SavedMeasurementInputFacts.catalog(List.of(first, altered))); + assertThrows(IllegalArgumentException.class, + () -> SavedMeasurementInputFacts.catalog(List.of(first, sampled("Can1", 0, false)))); + assertEquals(1, SavedMeasurementInputFacts.catalog(List.of(first, sampled("Can1", 1, false))) + .canInputs().channels().size()); + for (String invalid : List.of("{}", DEFINITION.replace("\"km/h\"", "\"Pa\""), + DEFINITION.replace("\"m/s\"", "\"bogus\""), DEFINITION + "{}")) { + var row = can(); row.setCanDefinitionJson(invalid); + assertThrows(IllegalArgumentException.class, () -> SavedMeasurementInputFacts.catalog(List.of(row))); + } + var missing = can(); missing.setCanDefinitionJson(null); + assertThrows(NullPointerException.class, () -> SavedMeasurementInputFacts.catalog(List.of(missing))); + for (String field : List.of("protocol", "deviceName", "direction", "samplingRate")) { + var row = can(); + switch (field) { + case "protocol" -> row.setProtocol(null); + case "deviceName" -> row.setDeviceName(null); + case "direction" -> row.setChannelIo(1); + case "samplingRate" -> row.setSamplingRate(48000); + } + assertThrows(IllegalArgumentException.class, () -> SavedMeasurementInputFacts.catalog(List.of(row))); + } + } + + private static ChannelDto can() { + var row = new ChannelDto(); + row.setId(51L); row.setBoxChannelId(51L); row.setProjectId(7L); row.setDeviceId(9L); + row.setChannelIo(0); row.setChannelSource(2); row.setVchId("Can1"); row.setVchIdNumber(1); + row.setProtocol("OPENDAQ"); row.setDeviceName("archived-device"); row.setIpAddress("old-address"); + row.setCustomName("Frozen speed"); row.setCanDefinitionJson(DEFINITION); + return row; + } + + private static ChannelDto sampled(String id, int direction, boolean math) { + var row = new ChannelDto(); row.setVchId(id); row.setChannelIo(direction); + row.setChannelSource(math ? 1 : 0); row.setSamplingRate(48000); row.setChannelType(2); + if (math) row.setMathUnit("Pa"); + return row; + } + + private static Map configuration(List rows) { + var values = rows.stream().map(row -> MeasurementInputBindings.FACTS.convertValue(row, LinkedHashMap.class)).toList(); + return Map.of("collectConfig", Map.of("channels", values, + "inputChannels", rows.stream().map(ChannelDto::getVchId).toList())); + } +} diff --git a/apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/core/sync/CanOnlyTimeCompletionTest.java b/apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/core/sync/CanOnlyTimeCompletionTest.java new file mode 100644 index 00000000..cd033402 --- /dev/null +++ b/apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/core/sync/CanOnlyTimeCompletionTest.java @@ -0,0 +1,317 @@ +package com.opentest.service.grpc.core.sync; + +import com.opentest.common.enums.BuiltinDashboardProvider; +import com.opentest.common.enums.ChannelSourceEnum; +import com.opentest.common.enums.UnitEnum; +import com.opentest.common.exception.CryBusinessException; +import com.opentest.common.exception.ErrorCode; +import com.opentest.common.model.dto.ChannelDto; +import com.opentest.common.model.dto.DashboardConfigDto; +import com.opentest.common.model.dto.dashboard.CollectConfigDto; +import com.opentest.common.model.dto.dashboard.DashboardItemConfigDto; +import com.opentest.dashboard.api.capability.CanChannelFacts; +import com.opentest.dashboard.api.channel.CanPortBinding; +import com.opentest.dashboard.api.channel.CanSignalChannel; +import com.opentest.dashboard.api.channel.CanSignalQuantity; +import com.opentest.dashboard.api.channel.CanSignalUnits; +import com.opentest.dashboard.api.measurement.editing.InputDeclaration; +import com.opentest.service.dashboard.framework.BoundMeasurementInputs; +import com.opentest.service.grpc.core.ChannelListenerManager; +import com.opentest.service.grpc.core.ChannelListenerManagers; +import com.opentest.service.grpc.core.DashboardCompletionDisposition; +import com.opentest.service.grpc.core.DashboardHandlerStopPreparation; +import com.opentest.service.grpc.core.sender.GrpcWriter; +import com.opentest.service.grpc.provider.ProviderPipelineDashboardHandler; +import com.opentest.service.helper.SequenceExecutionGraphRuntimeCache; +import com.opentest.service.jni.ContinueCaptureManager; +import java.util.List; +import java.util.Map; +import java.util.OptionalInt; +import java.util.Set; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CompletionStage; +import java.util.concurrent.atomic.AtomicLong; +import java.util.concurrent.atomic.AtomicReference; +import org.junit.jupiter.api.Test; +import org.springframework.test.util.ReflectionTestUtils; +import org.springframework.util.ReflectionUtils; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; +import static org.mockito.Mockito.RETURNS_DEFAULTS; + +class CanOnlyTimeCompletionTest { + @Test + void fourSecondCanOnlyRecordingFinishesWithoutAnySampleCallbackOrCanEvent() { + Fixture fixture = new Fixture(); + fixture.handler.markCaptureRuntimeReady(); + assertEquals(Boolean.FALSE, fixture.handler.getFinished()); + + fixture.clock.set(3_999_999_999L); + fixture.sweep(); + assertEquals(0, fixture.handler.stops); + fixture.clock.set(4_000_000_000L); + fixture.sweep(); + + assertEquals(1, fixture.handler.stops); + assertNull(fixture.handler.failure); + assertTrue(fixture.runtime.isCompleted()); + assertFalse(fixture.runtime.isFailed()); + fixture.sweep(); + assertEquals(1, fixture.handler.stops); + } + + @Test + void timeSpentWaitingForCaptureReadinessDoesNotCountTowardRecording() { + Fixture fixture = new Fixture(); + fixture.clock.set(30_000_000_000L); + fixture.sweep(); + assertEquals(0, fixture.handler.stops); + + fixture.handler.markCaptureRuntimeReady(); + fixture.clock.addAndGet(3_999_999_999L); + fixture.sweep(); + assertEquals(0, fixture.handler.stops); + fixture.clock.incrementAndGet(); + fixture.sweep(); + assertEquals(1, fixture.handler.stops); + } + + @Test + void captureReadyBeforeScheduledGateWaitsAndStartsWithoutAnEventWhenGateOpens() { + Fixture fixture = new Fixture(); + fixture.handler.setRecordStartEnabled(false); + fixture.handler.markCaptureRuntimeReady(); + fixture.clock.set(20_000_000_000L); + fixture.sweep(); + assertNull(fixture.handler.getFinished()); + assertEquals(0, fixture.handler.stops); + + fixture.handler.setRecordStartEnabled(true); + fixture.handler.recordStartFunc(null); + assertEquals(Boolean.FALSE, fixture.handler.getFinished()); + fixture.clock.addAndGet(4_000_000_000L); + fixture.sweep(); + assertEquals(1, fixture.handler.stops); + } + + @Test + void scheduledGateBeforeCaptureReadyStartsOnlyAfterReadinessWithoutAnEvent() { + Fixture fixture = new Fixture(); + fixture.handler.setRecordStartEnabled(false); + fixture.handler.setRecordStartEnabled(true); + fixture.handler.recordStartFunc(null); + fixture.clock.set(20_000_000_000L); + assertNull(fixture.handler.getFinished()); + + fixture.handler.markCaptureRuntimeReady(); + fixture.clock.addAndGet(4_000_000_000L); + fixture.sweep(); + assertEquals(1, fixture.handler.stops); + } + + @Test + void originMayBeNegativeAndZeroWithoutChangingTheElapsedThreshold() { + for (long origin : List.of(-10_000_000_000L, 0L)) { + Fixture fixture = new Fixture(); + fixture.clock.set(origin); + fixture.handler.markCaptureRuntimeReady(); + fixture.clock.addAndGet(4_000_000_000L); + fixture.sweep(); + assertEquals(1, fixture.handler.stops, "origin=" + origin); + } + } + + @Test + void recordingStartCallbackCannotCompleteBeforeTheFormalEpochIsPublished() { + Fixture fixture = new Fixture(); + fixture.handler.setRecordStartedFunc(() -> { + fixture.clock.set(80_000_000_000L); + fixture.sweep(); + assertEquals(0, fixture.handler.stops); + }); + + fixture.handler.markCaptureRuntimeReady(); + fixture.clock.addAndGet(3_999_999_999L); + fixture.sweep(); + assertEquals(0, fixture.handler.stops); + fixture.clock.incrementAndGet(); + fixture.sweep(); + assertEquals(1, fixture.handler.stops); + } + + @Test + void unsuccessfulParticipantStartupNeverPublishesSuccessfulElapsedCompletion() { + RuntimeException startupFailure = new IllegalStateException("CAN startup failed"); + Fixture fixture = new Fixture(false, startupFailure); + assertSame(startupFailure, + assertThrows(IllegalStateException.class, fixture.handler::markCaptureRuntimeReady)); + + fixture.clock.set(80_000_000_000L); + fixture.sweep(); + assertEquals(0, fixture.handler.stops); + assertFalse(fixture.runtime.isCompleted()); + } + + @Test + void staleCompletionObservationCannotStopTheReplacementRoundAndEachRoundHasItsOwnEpoch() { + Fixture first = new Fixture(); + Fixture replacement = new Fixture(); + first.handler.markCaptureRuntimeReady(); + first.clock.set(4_000_000_000L); + first.handler.onClockRead = () -> first.runtime.setCurrentHandler(replacement.handler); + + first.sweep(); + + assertSame(replacement.handler, first.runtime.getCurrentHandler()); + assertEquals(0, first.handler.stops); + assertEquals(0, replacement.handler.stops); + replacement.clock.set(100_000_000_000L); + replacement.handler.markCaptureRuntimeReady(); + replacement.clock.addAndGet(3_999_999_999L); + first.sweep(); + assertEquals(0, replacement.handler.stops); + replacement.clock.incrementAndGet(); + first.sweep(); + assertEquals(1, replacement.handler.stops); + } + + @Test + void mixedCanAndOrdinaryRecordingWaitsForItsExactSampleCompletion() { + Fixture fixture = new Fixture(true); + ChannelListenerManager samples = mock(ChannelListenerManager.class); + ReflectionTestUtils.setField(fixture.handler, "channelListenerManager", samples); + fixture.handler.finished().set(false); + fixture.clock.set(60_000_000_000L); + fixture.sweep(); + assertEquals(0, fixture.handler.stops); + + when(samples.checkProcessAllData()).thenReturn(true); + fixture.sweep(); + assertEquals(1, fixture.handler.stops); + } + + @Test + void stopRequestBeforeTheDueSweepRetainsItsCancellationDisposition() { + Fixture fixture = new Fixture(); + fixture.handler.markCaptureRuntimeReady(); + fixture.clock.set(4_000_000_000L); + fixture.manager.stop(null, DashboardCompletionDisposition.CANCEL); + fixture.sweep(); + assertEquals(1, fixture.handler.stops); + assertEquals(DashboardCompletionDisposition.CANCEL, fixture.handler.getCompletionDisposition()); + } + + @Test + void sourceFailureBeforeTheDueSweepRetainsItsOriginalFailure() { + Fixture fixture = new Fixture(); + fixture.handler.markCaptureRuntimeReady(); + fixture.clock.set(4_000_000_000L); + CryBusinessException failure = new CryBusinessException(ErrorCode.FAILED); + fixture.manager.stop(failure, DashboardCompletionDisposition.FAILURE); + fixture.sweep(); + assertEquals(1, fixture.handler.stops); + assertSame(failure, fixture.handler.failure); + assertEquals(DashboardCompletionDisposition.FAILURE, fixture.handler.getCompletionDisposition()); + } + + private static final class Fixture { + final AtomicLong clock = new AtomicLong(); + final TestHandler handler = new TestHandler(clock); + final SyncMeasurementRecorderManager manager; + final SyncMeasurementMemberRuntime runtime; + + Fixture() { this(false); } + + Fixture(boolean mixed) { this(mixed, null); } + + Fixture(boolean mixed, RuntimeException startupFailure) { + ChannelDto can = new ChannelDto(); + can.setId(6L); + can.setVchId("CAN6"); + can.setChannelSource(ChannelSourceEnum.CAN.getValue()); + ChannelDto physical = new ChannelDto(); + physical.setId(1L); + physical.setVchId("Ch1"); + physical.setDeviceName("Device1"); + physical.setSamplingRate(1_000); + List selected = mixed ? List.of(can, physical) : List.of(can); + List dependencies = mixed ? List.of(physical) : List.of(); + CanSignalChannel signal = new CanSignalChannel("CAN6", "10", "1", "Speed", 0, + new CanPortBinding("2", "CAN", "stable", "can0"), "{}", + new CanSignalUnits(CanSignalQuantity.SPEED, "km/h", "km/h", null), "frozen"); + InputDeclaration declaration = new InputDeclaration( + List.of(), List.of(), List.of(), List.of(), List.of(), OptionalInt.empty()); + handler.bindMeasurementInputs(new BoundMeasurementInputs(declaration, Map.of(), selected, + dependencies, List.of(), selected.size(), selected, Set.of(), Set.of(), Map.of(), + new CanChannelFacts(Map.of("CAN6", signal)))); + Object participant = mock(ReflectionUtils.findField(TestHandler.class, "canInputs").getType(), call -> { + if (call.getMethod().getName().equals("channels")) + return new CanChannelFacts(Map.of("CAN6", signal)); + if (call.getMethod().getName().equals("start") && startupFailure != null) throw startupFailure; + return RETURNS_DEFAULTS.answer(call); + }); + ReflectionTestUtils.setField(handler, "canInputs", participant); + CollectConfigDto collect = new CollectConfigDto(); + collect.setStopMethod(CollectConfigDto.STOP_METHOD_TIME); + collect.setAcquisitionTime(4_000); + collect.setTimeUnit(UnitEnum.MILLISECOND.getCode()); + collect.setChannels(selected); + collect.setExecutionChannels(dependencies); + DashboardItemConfigDto item = new DashboardItemConfigDto(); + item.setCollectConfig(collect); + DashboardConfigDto dashboard = new DashboardConfigDto(); + dashboard.setProviderId(BuiltinDashboardProvider.MONITOR.getProviderId()); + dashboard.setDashboardItemConfig(item); + handler.setDashboard(dashboard); + handler.setGrpcWriter(mock(GrpcWriter.class)); + manager = new SyncMeasurementRecorderManager(List.of(handler), mock(ContinueCaptureManager.class), + mock(ChannelListenerManagers.class), null, mock(SequenceExecutionGraphRuntimeCache.class), + null, null, null); + runtime = (SyncMeasurementMemberRuntime) ((List) ReflectionTestUtils.getField(manager, "members")).getFirst(); + } + + void sweep() { ReflectionTestUtils.invokeMethod(manager, "checkRecordsFinish", (Object) null); } + } + + private static final class TestHandler extends ProviderPipelineDashboardHandler { + private final AtomicLong clock; + int stops; + CryBusinessException failure; + Runnable onClockRead; + + TestHandler(AtomicLong clock) { this.clock = clock; } + + protected long recordingNanoTime() { + Runnable action = onClockRead; + onClockRead = null; + if (action != null) action.run(); + return clock.get(); + } + + @Override public CompletionStage measurementResourcesReleased() { + return CompletableFuture.completedFuture(null); + } + + @SuppressWarnings("unchecked") + AtomicReference finished() { + return (AtomicReference) ReflectionTestUtils.getField(this, "finished"); + } + + @Override public DashboardHandlerStopPreparation beginStop() { + boolean prepared = finished().getAndSet(true) == null; + return new DashboardHandlerStopPreparation(true, prepared, null); + } + + @Override public void finishStop(DashboardHandlerStopPreparation preparation, CryBusinessException problem) { + stops++; + failure = problem; + } + } +} diff --git a/apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/core/sync/MeasurementOperatorStopTest.java b/apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/core/sync/MeasurementOperatorStopTest.java new file mode 100644 index 00000000..67819d56 --- /dev/null +++ b/apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/core/sync/MeasurementOperatorStopTest.java @@ -0,0 +1,70 @@ +package com.opentest.service.grpc.core.sync; + +import com.opentest.common.model.dto.dashboard.CollectConfigDto; +import com.opentest.service.grpc.core.ChannelListenerManagers; +import com.opentest.service.grpc.core.DashboardHandlerStopPreparation; +import com.opentest.service.grpc.provider.ProviderExecutionSession; +import com.opentest.service.grpc.provider.ProviderPipelineDashboardHandler; +import com.opentest.service.helper.SequenceExecutionGraphRuntimeCache; +import com.opentest.service.jni.ContinueCaptureManager; +import java.util.List; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.concurrent.atomic.AtomicReference; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.doAnswer; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +class MeasurementOperatorStopTest { + @ParameterizedTest + @ValueSource(booleans = {true, false}) + void operatorStopWaitsForTheProvidersInputEndAndThenReleasesTheGroup(boolean continuousDisplay) throws Exception { + var handler = mock(ProviderPipelineDashboardHandler.class); + var execution = mock(ProviderExecutionSession.class); + var collect = mock(CollectConfigDto.class); + when(handler.getEffectiveCollectConfig()).thenReturn(collect); + when(handler.isContinuousDisplayExecution()).thenReturn(continuousDisplay); + when(handler.measurementSession()).thenReturn(execution); + when(handler.requiresAsyncStopFinalization()).thenReturn(true); + when(handler.measurementResourcesReleased()).thenReturn(CompletableFuture.completedFuture(null)); + when(execution.released()).thenReturn(CompletableFuture.completedFuture(null)); + var finished = new AtomicBoolean(); + when(handler.getFinished()).thenAnswer(ignored -> finished.get()); + when(handler.beginStop()).thenAnswer(ignored -> { + finished.set(true); + return new DashboardHandlerStopPreparation(true, false, null); + }); + var inputEnded = new AtomicReference(); + doAnswer(invocation -> { + inputEnded.set(invocation.getArgument(0)); + return null; + }).when(handler).setStopTriggerFunc(any()); + var manager = new SyncMeasurementRecorderManager(List.of(handler), mock(ContinueCaptureManager.class), + mock(ChannelListenerManagers.class), null, mock(SequenceExecutionGraphRuntimeCache.class), + null, null, null); + try { + manager.start(Runnable::run, Runnable::run, null, 0); + assertNotNull(inputEnded.get()); + assertTrue(manager.requestOperatorStop(), "Provider owns the normal stop response"); + verify(execution).requestOperatorStop(); + + inputEnded.get().run(); + + manager.stopCompletion().toCompletableFuture().get(2, TimeUnit.SECONDS); + assertTrue(finished.get(), "Operator stop must finalize the acknowledged input"); + verify(handler, times(1)).finishStop(any(), any()); + } finally { + manager.stop(null); + manager.stopCompletion().handle((ignored, failure) -> null).toCompletableFuture().get(5, TimeUnit.SECONDS); + } + } +} diff --git a/apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/core/sync/TimeStopTargetInstallationTest.java b/apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/core/sync/TimeStopTargetInstallationTest.java index 22e7e048..95c3bccc 100644 --- a/apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/core/sync/TimeStopTargetInstallationTest.java +++ b/apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/core/sync/TimeStopTargetInstallationTest.java @@ -2,11 +2,19 @@ import com.opentest.common.enums.UnitEnum; import com.opentest.common.enums.BuiltinDashboardProvider; +import com.opentest.common.enums.ChannelSourceEnum; import com.opentest.common.exception.CryBusinessException; import com.opentest.common.model.dto.ChannelDto; import com.opentest.common.model.dto.DashboardConfigDto; import com.opentest.common.model.dto.dashboard.CollectConfigDto; import com.opentest.common.model.dto.dashboard.DashboardItemConfigDto; +import com.opentest.dashboard.api.capability.CanChannelFacts; +import com.opentest.dashboard.api.channel.CanPortBinding; +import com.opentest.dashboard.api.channel.CanSignalChannel; +import com.opentest.dashboard.api.channel.CanSignalQuantity; +import com.opentest.dashboard.api.channel.CanSignalUnits; +import com.opentest.dashboard.api.measurement.editing.InputDeclaration; +import com.opentest.service.dashboard.framework.BoundMeasurementInputs; import com.opentest.service.grpc.core.AbstractDashboardHandler; import com.opentest.service.grpc.core.TimeStopSampleTargets; import com.opentest.service.grpc.core.ChannelListenerManagers; @@ -24,17 +32,44 @@ import java.util.ArrayList; import java.util.List; import java.util.Map; +import java.util.OptionalInt; import java.util.Set; +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.inOrder; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; class TimeStopTargetInstallationTest { + @Test + void canOnlyTimeRecordingIsAdmittedWithoutInventingSampleFacts() { + ChannelDto can = new ChannelDto(); + can.setId(6L); + can.setVchId("CAN6"); + can.setChannelSource(ChannelSourceEnum.CAN.getValue()); + ProviderPipelineDashboardHandler handler = provider(List.of(can), List.of()); + CanSignalChannel signal = new CanSignalChannel("CAN6", "10", "1", "Speed", 0, + new CanPortBinding("2", "CAN", "stable", "can0"), "{}", + new CanSignalUnits(CanSignalQuantity.SPEED, "km/h", "km/h", null), "frozen"); + InputDeclaration declaration = new InputDeclaration( + List.of(), List.of(), List.of(), List.of(), List.of(), OptionalInt.empty()); + handler.bindMeasurementInputs(new BoundMeasurementInputs(declaration, Map.of(), List.of(can), + List.of(), List.of(), 1, List.of(can), Set.of(), Set.of(), Map.of(), + new CanChannelFacts(Map.of("CAN6", signal)))); + + assertDoesNotThrow(() -> ReflectionTestUtils.invokeMethod(recorder(handler), "validateTimeStopTargets")); + + assertTrue(handler.getPhysicalWaveformSourceChannelsSnapshot().isEmpty()); + assertNull(can.getSamplingRate()); + assertNull(can.getBitDepth()); + } + @Test void wavOnlyProviderUsesFrozenPhysicalSourcesForTargetsAndCaptureLeases() { ChannelDto physical = channel(1L, "Ch1", 192_000, false); @@ -126,7 +161,7 @@ void installsPhysicalCompletionAndMathAdmissionBeforeHandlerStarts() { InOrder order = inOrder(handler); order.verify(handler).configureTimeStopSampleTargets( - org.mockito.ArgumentMatchers.any(TimeStopSampleTargets.class)); + any(TimeStopSampleTargets.class)); order.verify(handler).start(); ArgumentCaptor targets = ArgumentCaptor.forClass(TimeStopSampleTargets.class); diff --git a/apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/provider/CompletedGraphicResultPublisherTest.java b/apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/provider/CompletedGraphicResultPublisherTest.java index d19c98bb..fee46428 100644 --- a/apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/provider/CompletedGraphicResultPublisherTest.java +++ b/apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/provider/CompletedGraphicResultPublisherTest.java @@ -3,6 +3,8 @@ import com.opentest.common.model.dto.ChannelDto; import com.opentest.common.model.dto.DashboardResultDto; import com.opentest.common.model.dto.GraphicConfigSnapshotDto; +import com.opentest.common.model.dto.GraphicResultCodeDto; +import com.opentest.common.model.dto.UnitInfo; import com.opentest.core.jni.model.CalResult; import com.opentest.dashboard.api.result.CompletedResultTiming; import org.mockito.ArgumentCaptor; @@ -10,7 +12,10 @@ import com.opentest.service.grpc.core.AbstractDashboardHandler; import com.opentest.service.proto.CommonProto; import java.nio.ByteOrder; +import java.util.ArrayList; +import java.util.LinkedHashMap; import java.util.List; +import java.util.Map; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.CsvSource; @@ -19,6 +24,214 @@ import static org.mockito.Mockito.*; class CompletedGraphicResultPublisherTest { + @ParameterizedTest + @ValueSource(strings = {"CAN Viewer", "CAN Value"}) + void multipleMemberBindingsRouteEachUnitOnlyToItsOwnGraphic(String code) { + var handler = mock(AbstractDashboardHandler.class); + var writer = mock(MmapWriter.class); + when(handler.getMmapWriter()).thenReturn(writer); + when(handler.getDashboardId()).thenReturn(20L); + when(handler.getRequestId()).thenReturn(30L); + var row = new DashboardResultDto(); + row.setId(7L); row.setPrimaryCode(code); row.setHash("frozen"); + when(handler.getPreloadedDashboardAllResults()).thenReturn(List.of(row)); + var celsius = memberGraphic(8, code, "degC"); + var fahrenheit = memberGraphic(9, code, "degF"); + when(handler.getByVchIdAndDashboardResultId("CAN9", 7L)).thenReturn(List.of(celsius, fahrenheit)); + when(handler.resolveRealtimeMmapGraphicConfigId(celsius, row, "CAN9")).thenReturn(8L); + when(handler.resolveRealtimeMmapGraphicConfigId(fahrenheit, row, "CAN9")).thenReturn(9L); + when(writer.write(any(CommonProto.MultiGraphicData.class))).thenReturn(true); + var publisher = new CompletedGraphicResultPublisher(handler, List.of()); + for (var unit : List.of("degC", "degF")) { + var curve = new CalResult(); + curve.setChannelId("CAN9"); curve.setResultCode(code); curve.setYDefaultUnit(unit); + curve.setY(new double[]{unit.equals("degC") ? 24.64 : 76.352}); + publisher.publishMeasurement(curve, null, + new MeasurementCompletedTargetPolicy.Target(7, code, "frozen", "CAN9", null, unit)); + } + var frames = ArgumentCaptor.forClass(CommonProto.MultiGraphicData.class); + verify(writer, times(2)).write(frames.capture()); + assertEquals(List.of(1, 1), frames.getAllValues().stream().map(CommonProto.MultiGraphicData::getItemsCount).toList()); + assertEquals(List.of(8L, 9L), frames.getAllValues().stream().map(frame -> frame.getItems(0).getGraphicConfigId()).toList()); + assertEquals(List.of("degC", "degF"), frames.getAllValues().stream().map(frame -> frame.getItems(0).getUnitY()).toList()); + } + + private static GraphicConfigSnapshotDto memberGraphic(long id, String code, String temperatureUnit) { + var graphic = new GraphicConfigSnapshotDto(); graphic.setId(id); + var bindings = new ArrayList(); + for (var member : List.of("CAN6", "CAN9")) { + var binding = new GraphicResultCodeDto(); + binding.setDashboardResultId(7L); binding.setResultCode(code); binding.setChannelIds(List.of(member)); + var unit = new UnitInfo(); unit.setChannelIds(List.of(member)); + unit.setUnit(member.equals("CAN6") ? "rpm" : temperatureUnit); + binding.setUnitInfos(List.of(unit)); bindings.add(binding); + } + graphic.setResultCodes(bindings); return graphic; + } + + @ParameterizedTest + @CsvSource({ + "CAN Value, degF, degC, 1", + "CAN Value, degC, degF, 1", + "CAN Viewer, degF, degC, 1", + "CAN Viewer, degC, degF, 1", + "CAN Value, degF, degC, 0", + "CAN Value, degC, degF, 0" + }) + void memberLessPlaceholderBindingsNeverLetAnotherUnitReachAGraphic(String code, String firstUnit, + String secondUnit, int leadingPlaceholders) { + var handler = mock(AbstractDashboardHandler.class); + var writer = mock(MmapWriter.class); + when(handler.getMmapWriter()).thenReturn(writer); + when(handler.getDashboardId()).thenReturn(20L); + var row = new DashboardResultDto(); + row.setId(7L); row.setPrimaryCode(code); row.setHash("frozen"); + when(handler.getPreloadedDashboardAllResults()).thenReturn(List.of(row)); + var fahrenheit = canGraphicWithPlaceholders(160L, code, "degF", leadingPlaceholders, 2); + var celsius = canGraphicWithPlaceholders(162L, code, "degC", leadingPlaceholders, 2); + var separate = canGraphicWithPlaceholders(833L, code, "degF", 0, 0); + when(handler.getByVchIdAndDashboardResultId("CAN8", 7L)).thenReturn(List.of(fahrenheit, celsius, separate)); + for (var graphic : List.of(fahrenheit, celsius, separate)) + when(handler.resolveRealtimeMmapGraphicConfigId(graphic, row, "CAN8")).thenReturn(graphic.getId()); + when(writer.write(any(CommonProto.MultiGraphicData.class))).thenReturn(true); + var publisher = new CompletedGraphicResultPublisher(handler, List.of()); + for (var unit : List.of(firstUnit, secondUnit)) { + var curve = new CalResult(); + curve.setChannelId("CAN8"); curve.setResultCode(code); curve.setYDefaultUnit(unit); + curve.setY(new double[]{unit.equals("degC") ? 24.64 : 76.352}); + publisher.publishMeasurement(curve, null, + new MeasurementCompletedTargetPolicy.Target(7, code, "frozen", "CAN8", null, unit)); + } + var frames = ArgumentCaptor.forClass(CommonProto.MultiGraphicData.class); + verify(writer, atLeastOnce()).write(frames.capture()); + var received = new LinkedHashMap>(); + for (var frame : frames.getAllValues()) { + for (var item : frame.getItemsList()) { + var y = new double[1]; + item.getYData().asReadOnlyByteBuffer().order(ByteOrder.LITTLE_ENDIAN).asDoubleBuffer().get(y); + received.computeIfAbsent(item.getGraphicConfigId(), id -> new ArrayList<>()) + .add(item.getUnitY() + "=" + y[0]); + } + } + assertEquals(Map.of(160L, List.of("degF=76.352"), 162L, List.of("degC=24.64"), + 833L, List.of("degF=76.352")), received); + } + + /** A saved project graphic keeps member-less bindings of the same result next to its member bindings. */ + private static GraphicConfigSnapshotDto canGraphicWithPlaceholders(long id, String code, String temperatureUnit, + int leadingPlaceholders, int trailingPlaceholders) { + var graphic = new GraphicConfigSnapshotDto(); graphic.setId(id); + var bindings = new ArrayList(); + for (int i = 0; i < leadingPlaceholders; i++) bindings.add(placeholderBinding(code)); + for (var member : List.of("CAN6", "CAN7", "CAN8", "CAN9")) { + var binding = new GraphicResultCodeDto(); + binding.setDashboardResultId(7L); binding.setResultCode(code); binding.setChannelIds(List.of(member)); + var unit = new UnitInfo(); unit.setChannelIds(List.of(member)); + unit.setUnit(member.equals("CAN6") || member.equals("CAN7") ? "rpm" : temperatureUnit); + binding.setUnitInfos(List.of(unit)); bindings.add(binding); + } + for (int i = 0; i < trailingPlaceholders; i++) bindings.add(placeholderBinding(code)); + graphic.setResultCodes(bindings); return graphic; + } + + private static GraphicResultCodeDto placeholderBinding(String code) { + var binding = new GraphicResultCodeDto(); + binding.setDashboardResultId(7L); binding.setResultCode(code); + binding.setChannelIds(List.of()); binding.setUnitInfos(List.of()); + return binding; + } + + @Test void ordinaryMemberBindingsStillRouteEachUnitOnlyToItsOwnGraphic() { + var code = "Background LZeq"; + var handler = mock(AbstractDashboardHandler.class); + var writer = mock(MmapWriter.class); + when(handler.getMmapWriter()).thenReturn(writer); + when(handler.getDashboardId()).thenReturn(20L); + var row = new DashboardResultDto(); + row.setId(7L); row.setPrimaryCode(code); row.setHash("frozen"); + when(handler.getPreloadedDashboardAllResults()).thenReturn(List.of(row)); + var zWeighted = plainGraphic(8L, code, "mic-1", "dBZ"); + var aWeighted = plainGraphic(9L, code, "mic-1", "dBA"); + when(handler.getByVchIdAndDashboardResultId("mic-1", 7L)).thenReturn(List.of(zWeighted, aWeighted)); + when(handler.resolveRealtimeMmapGraphicConfigId(zWeighted, row, "mic-1")).thenReturn(8L); + when(handler.resolveRealtimeMmapGraphicConfigId(aWeighted, row, "mic-1")).thenReturn(9L); + when(writer.write(any(CommonProto.MultiGraphicData.class))).thenReturn(true); + var publisher = new CompletedGraphicResultPublisher(handler, List.of()); + for (var unit : List.of("dBZ", "dBA")) { + var curve = new CalResult(); + curve.setChannelId("mic-1"); curve.setResultCode(code); curve.setYDefaultUnit(unit); curve.setY(new double[]{42}); + publisher.publishMeasurement(curve, null, + new MeasurementCompletedTargetPolicy.Target(7, code, "frozen", "mic-1", null, unit)); + } + var frames = ArgumentCaptor.forClass(CommonProto.MultiGraphicData.class); + verify(writer, times(2)).write(frames.capture()); + assertEquals(List.of(8L, 9L), frames.getAllValues().stream().map(frame -> frame.getItems(0).getGraphicConfigId()).toList()); + assertEquals(List.of("dBZ", "dBA"), frames.getAllValues().stream().map(frame -> frame.getItems(0).getUnitY()).toList()); + assertEquals(List.of(1, 1), frames.getAllValues().stream().map(CommonProto.MultiGraphicData::getItemsCount).toList()); + } + + private static GraphicConfigSnapshotDto plainGraphic(long id, String code, String member, String unitName) { + var graphic = new GraphicConfigSnapshotDto(); graphic.setId(id); + var binding = new GraphicResultCodeDto(); + binding.setDashboardResultId(7L); binding.setResultCode(code); binding.setChannelIds(List.of(member)); + var unit = new UnitInfo(); unit.setChannelIds(List.of(member)); unit.setUnit(unitName); + binding.setUnitInfos(List.of(unit)); graphic.setResultCodes(List.of(binding)); + return graphic; + } + + /** Legacy projects can carry a graphic whose only binding for the result names no member. */ + @Test void ordinaryGraphicWhoseOnlyBindingForTheResultIsMemberLessStillReceivesEveryUnit() { + var code = "Background LZeq"; + var legacy = new GraphicConfigSnapshotDto(); legacy.setId(8L); + legacy.setResultCodes(List.of(placeholderBinding(code))); + assertEquals(Map.of(8L, List.of("dBZ", "dBA")), + deliveredUnitsByGraphic(code, "mic-1", List.of(legacy), List.of("dBZ", "dBA"))); + } + + @Test void ordinaryPlaceholderAheadOfAMemberBindingStillDeliversItsOwnUnitAndOnlyThat() { + var code = "Background LZeq"; + var zWeighted = withLeadingPlaceholder(plainGraphic(8L, code, "mic-1", "dBZ"), code); + var aWeighted = plainGraphic(9L, code, "mic-1", "dBA"); + assertEquals(Map.of(8L, List.of("dBZ"), 9L, List.of("dBA")), + deliveredUnitsByGraphic(code, "mic-1", List.of(zWeighted, aWeighted), List.of("dBZ", "dBA"))); + } + + private static GraphicConfigSnapshotDto withLeadingPlaceholder(GraphicConfigSnapshotDto graphic, String code) { + var bindings = new ArrayList(); + bindings.add(placeholderBinding(code)); bindings.addAll(graphic.getResultCodes()); + graphic.setResultCodes(bindings); return graphic; + } + + /** Publishes one frame per unit through the real publisher and reports the units each graphic received. */ + private static Map> deliveredUnitsByGraphic(String code, String member, + List graphics, List units) { + var handler = mock(AbstractDashboardHandler.class); + var writer = mock(MmapWriter.class); + when(handler.getMmapWriter()).thenReturn(writer); + when(handler.getDashboardId()).thenReturn(20L); + var row = new DashboardResultDto(); + row.setId(7L); row.setPrimaryCode(code); row.setHash("frozen"); + when(handler.getPreloadedDashboardAllResults()).thenReturn(List.of(row)); + when(handler.getByVchIdAndDashboardResultId(member, 7L)).thenReturn(graphics); + for (var graphic : graphics) + when(handler.resolveRealtimeMmapGraphicConfigId(graphic, row, member)).thenReturn(graphic.getId()); + when(writer.write(any(CommonProto.MultiGraphicData.class))).thenReturn(true); + var publisher = new CompletedGraphicResultPublisher(handler, List.of()); + for (var unit : units) { + var curve = new CalResult(); + curve.setChannelId(member); curve.setResultCode(code); curve.setYDefaultUnit(unit); curve.setY(new double[]{42}); + publisher.publishMeasurement(curve, null, + new MeasurementCompletedTargetPolicy.Target(7, code, "frozen", member, null, unit)); + } + var frames = ArgumentCaptor.forClass(CommonProto.MultiGraphicData.class); + verify(writer, atLeastOnce()).write(frames.capture()); + var delivered = new LinkedHashMap>(); + for (var frame : frames.getAllValues()) + for (var item : frame.getItemsList()) + delivered.computeIfAbsent(item.getGraphicConfigId(), id -> new ArrayList<>()).add(item.getUnitY()); + return delivered; + } + @Test void selectedAndAuxiliaryGraphicsPublishButTriggerOnlyDependencyHasNoGraphic() { var handler = mock(AbstractDashboardHandler.class); var writer = mock(MmapWriter.class); diff --git a/apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/provider/MeasurementFileOutputAliasesTest.java b/apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/provider/MeasurementFileOutputAliasesTest.java index 53c9dc05..23769811 100644 --- a/apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/provider/MeasurementFileOutputAliasesTest.java +++ b/apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/provider/MeasurementFileOutputAliasesTest.java @@ -2,6 +2,10 @@ import com.opentest.dashboard.api.channel.MathSampleSemantics; import com.opentest.dashboard.api.channel.ChannelDirection; +import com.opentest.dashboard.api.channel.CanPortBinding; +import com.opentest.dashboard.api.channel.CanSignalChannel; +import com.opentest.dashboard.api.channel.CanSignalQuantity; +import com.opentest.dashboard.api.channel.CanSignalUnits; import com.opentest.service.FileService; import com.opentest.service.SharedFilePublicationJournal; @@ -26,6 +30,47 @@ import static org.mockito.Mockito.*; class MeasurementFileOutputAliasesTest { + @Test void canonicalCanTargetsBindWithoutSampledAliasesForCanOnlyAndMixedInputs() { + var source = new ResultRequirement(17L, "CAN Viewer", "can-hash", Map.of(), "Can1", "s", "rpm"); + var channel = new CanSignalChannel("Can1", "51", "7", "Motor speed", 1, + new CanPortBinding("9", "OPENDAQ", "native-id", "can0"), "{}", + new CanSignalUnits(CanSignalQuantity.ROTATIONAL_SPEED, "rpm", "rpm", null), "frozen-fingerprint"); + var units = new GraphicUnitResolution(new UnitCombination("s", "rpm"), List.of(new UnitCombination("s", "rpm"))); + var fact = new MeasurementResultMemberFacts.Fact( + ResultChannelDefinition.source("Can1", "Motor speed", ChannelDirection.INPUT, units), + new MeasurementResultMemberFacts.CanSource(channel), units); + var canonical = MeasurementResultFileMetadata.Target.can(17L, + new MeasurementResultFileMetadata.Key("CAN Viewer", "can-hash", "Can1", "s", "rpm"), + channel, source.fileUnitIdentity()); + for (var sampled : List.of(List.of(), List.of(CHANNEL))) { + var outputs = new ExecutionOutputs(7, 5, 11L, sampled, List.of(source), List.of()); + var bound = MeasurementFileOutputAliases.bind(outputs, + Map.of(new MeasurementResultMemberFacts.Key(17L, "Can1"), fact), List.of(canonical), List.of()); + assertTrue(bound.aliases().isEmpty()); + var raw = ResultFrame.explicitX("CAN Viewer", "can-hash", "Can1", "s", "rpm", + new double[]{0.75}, new double[]{Double.NaN}, 750, null); + var frame = raw.withDashboardResultId(17L); + raw.release(); + try { assertEquals(new MeasurementResultFileMetadata.CanSource(channel), + new MeasurementResultFileMetadata(bound.targets()).require(frame).source()); } + finally { frame.release(); } + } + } + + @Test void canLiveRequirementCannotBeAliasedToASampledWaveform() { + var requirement = new ResultRequirement(17L, "CAN Viewer", "can-hash", Map.of(), "Can1", "s", "rpm"); + var channel = new CanSignalChannel("Can1", "51", "7", "Motor speed", 1, + new CanPortBinding("9", "OPENDAQ", "native-id", "can0"), "{}", + new CanSignalUnits(CanSignalQuantity.ROTATIONAL_SPEED, "rpm", "rpm", null), "frozen-fingerprint"); + var units = new GraphicUnitResolution(new UnitCombination("s", "rpm"), List.of(new UnitCombination("s", "rpm"))); + var fact = new MeasurementResultMemberFacts.Fact( + ResultChannelDefinition.source("Can1", "Motor speed", ChannelDirection.INPUT, units), + new MeasurementResultMemberFacts.CanSource(channel), units); + var output = new ExecutionOutputs(7, 5, 11L, List.of(), List.of(requirement), List.of()); + assertThrows(IllegalArgumentException.class, () -> MeasurementFileOutputAliases.bind(output, + Map.of(new MeasurementResultMemberFacts.Key(17L, "Can1"), fact), List.of(), + List.of(new ResultFileOutputAlias(requirement, "alias", "waveform", "s", "rpm")))); + } private static final ChannelMetadata CHANNEL = new ChannelMetadata("input-1", SignalType.AUDIO, 48000, "FS", 1D, 1D, null); private static final ResultRequirement SOURCE = new ResultRequirement(17L, "Acquired Background Waveform", diff --git a/apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/provider/MeasurementLiveGraphicUnitsTest.java b/apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/provider/MeasurementLiveGraphicUnitsTest.java new file mode 100644 index 00000000..b856a1e3 --- /dev/null +++ b/apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/provider/MeasurementLiveGraphicUnitsTest.java @@ -0,0 +1,95 @@ +package com.opentest.service.grpc.provider; + +import com.opentest.common.model.dto.DashboardResultDto; +import com.opentest.dashboard.api.channel.CanPortBinding; +import com.opentest.dashboard.api.channel.CanSignalChannel; +import com.opentest.dashboard.api.channel.CanSignalQuantity; +import com.opentest.dashboard.api.channel.CanSignalUnits; +import com.opentest.dashboard.api.channel.ChannelDirection; +import com.opentest.dashboard.api.definition.ResultChannelDefinition; +import com.opentest.dashboard.api.result.CompletedResultCurve; +import com.opentest.dashboard.api.result.CompletedResultStorage; +import com.opentest.dashboard.api.result.GraphicTarget; +import com.opentest.dashboard.api.result.ResultRequirement; +import com.opentest.dashboard.api.unit.GraphicUnitResolution; +import com.opentest.dashboard.api.unit.UnitCombination; +import com.opentest.service.dashboard.framework.MeasurementResultMemberFacts; +import java.util.List; +import java.util.Map; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +class MeasurementLiveGraphicUnitsTest { + @Test void viewerAndValueAcceptFrozenGraphicUnitsWithoutChangingTheirSavedUnits() { + for (String code : List.of("CAN Viewer", "CAN Value")) { + var graphic = graphic(code, 7, "saved", "CAN8", "degC"); + var policy = policy(code, List.of(graphic, graphic)); + var live = curve(code, "CAN8", "degC", null); + assertEquals("degC", policy.resolveLive(live).target().unitY()); + assertEquals(24.64, policy.resolveLive(live).curve().y()[0]); + assertEquals("degF", policy.resolve(curve(code, "CAN8", "degF", storage(code))).target().unitY()); + assertThrows(IllegalArgumentException.class, + () -> policy.resolveLive(curve(code, "CAN8", "degC", storage(code)))); + } + } + + @Test void supportedUnitsStillNeedAFrozenGraphicAndTheExactResultMember() { + var policy = policy("CAN Viewer", List.of(graphic("CAN Viewer", 7, "saved", "CAN8", "degC"))); + assertThrows(IllegalArgumentException.class, () -> policy.resolveLive(curve("CAN Viewer", "CAN8", "K", null))); + assertThrows(IllegalArgumentException.class, () -> policy.resolveLive(curve("CAN Viewer", "CAN9", "degC", null))); + assertThrows(IllegalArgumentException.class, () -> policy.resolveLive( + curve("CAN Viewer", "CAN8", "degC", null).withDashboardResultId(8))); + } + + @Test void matchingGraphicCannotIntroduceAForeignResultHashOrUnit() { + for (var graphic : List.of( + graphic("CAN Viewer", 7, "foreign", "CAN8", "degC"), + graphic("CAN Value", 7, "saved", "CAN8", "degC"), + graphic("CAN Viewer", 7, "saved", "CAN8", "rpm"))) { + assertThrows(IllegalArgumentException.class, () -> policy("CAN Viewer", List.of(graphic))); + } + } + + @Test void unrelatedGraphicsCannotAuthorizeAnOutput() { + var policy = policy("CAN Viewer", List.of( + graphic("CAN Viewer", 8, "saved", "CAN8", "degC"), + graphic("CAN Viewer", 7, "saved", "CAN9", "degC"))); + assertThrows(IllegalArgumentException.class, () -> policy.resolveLive(curve("CAN Viewer", "CAN8", "degC", null))); + } + + private static MeasurementCompletedTargetPolicy policy(String code, List graphics) { + var x = xUnit(code); + var preferred = new UnitCombination(x, "degF"); + var units = new GraphicUnitResolution(preferred, List.of(preferred, + new UnitCombination(x, "degC"), new UnitCombination(x, "K"))); + var channel = new CanSignalChannel("CAN8", "51", "9", "Temperature", 1, + new CanPortBinding("11", "OPENDAQ", "native", "can0"), "{}", + new CanSignalUnits(CanSignalQuantity.TEMPERATURE, "degC", "degF", null), "frozen"); + var fact = new MeasurementResultMemberFacts.Fact( + ResultChannelDefinition.source("CAN8", "Temperature", ChannelDirection.INPUT, units), + new MeasurementResultMemberFacts.CanSource(channel), units); + var row = new DashboardResultDto(); + row.setId(7L); row.setPrimaryCode(code); row.setHash("saved"); + var requirement = new ResultRequirement(7L, code, "saved", Map.of(), "CAN8", x, "degF"); + return new MeasurementCompletedTargetPolicy(List.of(requirement), List.of(row), + Map.of(new MeasurementResultMemberFacts.Key(7, "CAN8"), fact), List.of(), graphics); + } + + private static GraphicTarget graphic(String code, long resultId, String hash, String member, String y) { + return new GraphicTarget(17L, resultId, code, hash, member, xUnit(code), y); + } + + private static CompletedResultCurve curve(String code, String member, String y, CompletedResultStorage storage) { + return new CompletedResultCurve(member, null, code, "saved", xUnit(code) == null ? null : new double[]{.1}, + new double[]{24.64}, xUnit(code), y, null, null, null, null, null, null, null, null, storage, + null, null, 7L); + } + + private static CompletedResultStorage storage(String code) { + return new CompletedResultStorage(false, false, null, code, "saved", List.of()); + } + + private static String xUnit(String code) { return code.equals("CAN Viewer") ? "s" : null; } +} diff --git a/apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/provider/ProviderCanHostRecordingTest.java b/apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/provider/ProviderCanHostRecordingTest.java new file mode 100644 index 00000000..768cf66f --- /dev/null +++ b/apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/provider/ProviderCanHostRecordingTest.java @@ -0,0 +1,260 @@ +package com.opentest.service.grpc.provider; + +import com.opentest.common.model.dto.FlowExecuteSnapshotDataDto; +import com.opentest.common.model.dto.ChannelDto; +import com.opentest.common.model.dto.DashboardConfigDto; +import com.opentest.common.model.dto.RecordedWaveformPlanDto.Encoding; +import com.opentest.common.model.dto.RecordedWaveformPlanDto.Stage; +import com.opentest.common.enums.ChannelSourceEnum; +import com.opentest.common.model.entity.File; +import com.opentest.dashboard.api.capability.CanChannelFacts; +import com.opentest.dashboard.api.capability.CanSignalBatch; +import com.opentest.dashboard.api.capability.CanSignalProjection; +import com.opentest.dashboard.api.capability.LiveResultOutput; +import com.opentest.dashboard.api.channel.CanPortBinding; +import com.opentest.dashboard.api.channel.CanSignalChannel; +import com.opentest.dashboard.api.channel.CanSignalQuantity; +import com.opentest.dashboard.api.channel.CanSignalUnits; +import com.opentest.dashboard.api.execution.ResultPersistenceScope; +import com.opentest.dashboard.api.frame.ResultFrame; +import com.opentest.dashboard.api.measurement.ExecutionOutputs; +import com.opentest.dashboard.api.pipeline.ProcessorContext; +import com.opentest.dashboard.api.result.CompletedResultCurve; +import com.opentest.dashboard.api.result.ResultRequirement; +import com.opentest.dashboard.standard.result.CrybinArtifactRegistrar; +import com.opentest.dashboard.standard.result.PersistResultSinkProcessor; +import com.opentest.service.FileService; +import com.opentest.service.can.CanService; +import com.opentest.service.snapshot.FlowExecuteSnapshotMutator; +import com.opentest.service.dashboard.framework.BoundMeasurementInputs; +import com.opentest.dashboard.api.measurement.editing.InputDeclaration; +import com.opentest.common.enums.BuiltinDashboardProvider; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.OptionalInt; +import java.util.Set; +import java.util.function.Consumer; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.io.TempDir; +import org.springframework.test.util.ReflectionTestUtils; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.doAnswer; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verifyNoInteractions; +import static org.mockito.Mockito.when; + +class ProviderCanHostRecordingTest { + private static final CanSignalChannel CHANNEL = new CanSignalChannel("can", "10", "1", "Speed", 0, + new CanPortBinding("2", "CAN", "stable", "can0"), "{}", + new CanSignalUnits(CanSignalQuantity.SPEED, "km/h", "km/h", null), "frozen"); + private static final CanChannelFacts FACTS = new CanChannelFacts(Map.of("can", CHANNEL)); + + @TempDir Path root; + + @Test void scalarFramesUseCommonSecondsAndPersistBeforeLiveWithoutSampleFacts() { + var order = new ArrayList(); + var files = new CapturedFiles(order); + var live = live(order); + var projection = new ProviderPipelineDashboardHandler.CanNumericProjection((facts, outputs, output) -> batch -> { + output.observe(curve(null, "km/h", Double.NaN), false); + output.observe(curve(null, "m/s", 10), false); + }, FACTS, outputs(null), live, files); + + projection.accept(new CanSignalBatch(1.75, List.of())); + projection.close(); + + assertEquals(List.of("file", "live", "live", "closed"), order); + assertEquals(1, files.frames.size()); + var frame = files.frames.getFirst(); + try { + assertArrayEquals(new double[]{1.75}, frame.x()); + assertTrue(Double.isNaN(frame.y()[0])); + assertEquals(1750, frame.taskRelativeTimeMs()); + assertEquals(9L, frame.dashboardResultId()); + assertNull(frame.xStep()); + assertNull(frame.frameStepMs()); + assertNull(frame.unitX()); + } finally { frame.release(); } + } + + @Test void viewerKeepsIrregularExplicitSecondsAndProjectionClosesBeforeFileFlush() { + var order = new ArrayList(); + var files = new CapturedFiles(order); + var projection = new ProviderPipelineDashboardHandler.CanNumericProjection((facts, outputs, output) -> + new CanSignalProjection() { + public void accept(CanSignalBatch batch) { output.observe(curve(new double[]{batch.observationElapsedSeconds()}, "km/h", 20), true); } + public void close() { order.add("projection closed"); } + }, FACTS, outputs("s"), live(order), files); + projection.accept(new CanSignalBatch(0.125, List.of())); + projection.accept(new CanSignalBatch(0.9375, List.of())); + projection.close(); + try { + assertArrayEquals(new double[]{0.125}, files.frames.getFirst().x()); + assertArrayEquals(new double[]{0.9375}, files.frames.getLast().x()); + assertEquals(List.of("file", "live", "file", "live", "projection closed", "closed"), order); + } finally { files.frames.forEach(ResultFrame::release); } + } + + @Test void fileFailurePropagatesBeforeLiveAndProjectionCloseStillFlushesFiles() { + var problem = new IllegalStateException("disk full"); + var order = new ArrayList(); + var files = new CapturedFiles(order) { + @Override public void accept(ResultFrame frame) { throw problem; } + }; + var projection = new ProviderPipelineDashboardHandler.CanNumericProjection((facts, outputs, output) -> + new CanSignalProjection() { + public void accept(CanSignalBatch batch) { output.observe(curve(null, "km/h", 1), false); } + public void close() { throw problem; } + }, FACTS, outputs(null), live(order), files); + assertSame(problem, assertThrows(IllegalStateException.class, + () -> projection.accept(new CanSignalBatch(0, List.of())))); + assertSame(problem, assertThrows(IllegalStateException.class, projection::close)); + assertEquals(List.of("closed"), order); + } + + @Test void onlyCurrentRequestOpensEventsAndUnstartedAbortRetainsRegisteredPartialFile() throws Exception { + for (var scope : ResultPersistenceScope.values()) { + var files = mock(FileService.class); + doAnswer(call -> { call.getArgument(0, File.class).setId(99L); return null; }) + .when(files).saveOrUpdateEntity(any(File.class)); + var snapshot = new FlowExecuteSnapshotDataDto(); + var snapshots = mock(FlowExecuteSnapshotMutator.class); + when(snapshots.mutate(eq(3L), any())).thenAnswer(call -> { + call.>getArgument(1).accept(snapshot); + return snapshot; + }); + var service = mock(CanService.class); + var participant = new ProviderCanSignalInputs(service, FACTS, failure -> { throw new AssertionError(failure); }); + var handler = new ProviderPipelineDashboardHandler() { + @Override protected String resolveInternalStoragePath() { return root.resolve(scope.name()).toString(); } + }; + handler.setRequestId(3L); + ReflectionTestUtils.setField(handler, "providerFileService", files); + ReflectionTestUtils.setField(handler, "providerSnapshotMutator", snapshots); + ReflectionTestUtils.setField(handler, "canInputs", participant); + ReflectionTestUtils.setField(handler, "canPersistenceScope", scope); + try { + ReflectionTestUtils.invokeMethod(handler, "attachCanRecording"); + if (scope == ResultPersistenceScope.CURRENT_REQUEST) { + assertEquals("RECORDING", snapshot.getCanRecording().getStatus()); + assertTrue(Files.isRegularFile(root.resolve(scope.name()).resolve(snapshot.getCanRecording().getRelativePath()))); + assertTrue(snapshot.getCanRecording().getClockAnchors().isEmpty()); + assertEquals(0, snapshot.getCanRecording().getBatchCount()); + } else { + assertNull(snapshot.getCanRecording()); + verifyNoInteractions(files, snapshots); + } + } finally { ReflectionTestUtils.invokeMethod(handler, "closeCanInputs", new IllegalStateException("start aborted")); } + if (scope == ResultPersistenceScope.CURRENT_REQUEST) { + assertEquals("FAILED", snapshot.getCanRecording().getStatus()); + assertFalse(snapshot.getCanRecording().getSha256().isBlank()); + } + } + } + + @Test void frozenCanSelectionDoesNotRequireALegacySampledChannel() { + var can = new ChannelDto(); + can.setVchId("CAN1"); can.setChannelSource(ChannelSourceEnum.CAN.getValue()); + var handler = waveformHandler(List.of(can), List.of()); + assertEquals(List.of("CAN1"), handler.frozenMeasurementInputs().selected().stream() + .map(ChannelDto::getVchId).toList()); + assertTrue(handler.getDashboardSelectedChannelsSnapshot().isEmpty()); + assertNull(handler.selectedWaveformPlan()); + } + + private ProviderPipelineDashboardHandler waveformHandler(List selected, List dependencies) { + var declaration = new InputDeclaration(List.of(), List.of(), List.of(), List.of(), List.of(), OptionalInt.empty()); + var bound = new BoundMeasurementInputs(declaration, Map.of(), selected, dependencies, List.of(), + selected.size(), selected, Set.of(), Set.of(), Map.of(), FACTS); + var handler = new ProviderPipelineDashboardHandler(); + handler.bindMeasurementInputs(bound); + return handler; + } + + @Test void canOnlyHasNoWaveformPlanAndMixedRecordingKeepsOnlyTheOrdinaryWaveform() { + var can = new ChannelDto(); + can.setVchId("CAN1"); can.setChannelSource(ChannelSourceEnum.CAN.getValue()); + var sampled = new ChannelDto(); + sampled.setVchId("Ch1"); sampled.setChannelSource(ChannelSourceEnum.PHYSICAL.getValue()); + sampled.setSamplingRate(48000); sampled.setBitDepth(24); + assertNull(waveformHandler(List.of(can), List.of()).selectedWaveformPlan()); + var plan = waveformHandler(List.of(can, sampled), List.of(sampled)).selectedWaveformPlan(); + assertEquals(List.of("Ch1"), plan.validatedMembers(false).stream() + .map(member -> member.getChannel().getVchId()).toList()); + assertEquals(48000, plan.getMembers().getFirst().getChannel().getSamplingRate()); + assertNull(can.getSamplingRate()); + assertNull(can.getBitDepth()); + assertThrows(IllegalArgumentException.class, () -> waveformHandler(List.of(), List.of()).selectedWaveformPlan()); + } + + @Test void frozenMathRecordingDoesNotIncludeItsCaptureDependencyOrCan() { + var can = new ChannelDto(); + can.setVchId("CAN1"); can.setChannelSource(ChannelSourceEnum.CAN.getValue()); + var math = new ChannelDto(); + math.setVchId("M2"); math.setChannelSource(ChannelSourceEnum.MATH.getValue()); + math.setSamplingRate(48000); + var physical = new ChannelDto(); + physical.setVchId("Ch1"); physical.setChannelSource(ChannelSourceEnum.PHYSICAL.getValue()); + physical.setSamplingRate(48000); physical.setBitDepth(24); + var handler = waveformHandler(List.of(can, math), List.of(physical)); + assertEquals(List.of("M2"), handler.getDashboardSelectedChannelsSnapshot().stream() + .map(ChannelDto::getVchId).toList()); + var plan = handler.selectedWaveformPlan(); + assertEquals(List.of("M2"), plan.validatedMembers(false).stream() + .map(member -> member.getChannel().getVchId()).toList()); + assertEquals(Stage.MATH_EVALUATED, plan.getMembers().getFirst().getStage()); + assertEquals(Encoding.IEEE_FLOAT64, plan.getMembers().getFirst().getEncoding()); + assertEquals(64, plan.getMembers().getFirst().getBitDepth()); + } + + @Test void physicalCaptureSnapshotExcludesCanRatherThanInventingItsAudioFormat() { + var can = new ChannelDto(); + can.setVchId("CAN1"); can.setChannelSource(ChannelSourceEnum.CAN.getValue()); + var sampled = new ChannelDto(); + sampled.setVchId("Ch1"); sampled.setChannelSource(ChannelSourceEnum.PHYSICAL.getValue()); + var handler = new ProviderPipelineDashboardHandler() { + @Override public boolean isWavOnlyRecordingPlan() { return false; } + @Override public List getDashboardExecutionChannelsSnapshot() { return List.of(can, sampled); } + }; + var dashboard = new DashboardConfigDto(); + dashboard.setProviderId(BuiltinDashboardProvider.MONITOR.getProviderId()); + handler.setDashboard(dashboard); + assertEquals(List.of(sampled), handler.getPhysicalWaveformSourceChannelsSnapshot()); + } + + private static ExecutionOutputs outputs(String x) { + return new ExecutionOutputs(1, 2, 3L, List.of(), List.of(new ResultRequirement(9L, + x == null ? "CAN Value" : "CAN Viewer", "hash", Map.of(), "can", x, "km/h")), List.of()); + } + private static CompletedResultCurve curve(double[] x, String yUnit, double value) { + return new CompletedResultCurve("can", null, x == null ? "CAN Value" : "CAN Viewer", "hash", x, + new double[]{value}, x == null ? null : "s", yUnit, null, null, null, null, null, null, null, + null, null, null, null, 9L); + } + private static LiveResultOutput live(List order) { + return new LiveResultOutput() { + public void publish(CompletedResultCurve curve, long generation, boolean append) { throw new AssertionError(); } + public void observe(CompletedResultCurve curve, boolean append) { order.add("live"); } + }; + } + private static class CapturedFiles implements PersistResultSinkProcessor.FileOutput { + final List frames = new ArrayList<>(); + final List order; + CapturedFiles(List order) { this.order = order; } + public void start(ProcessorContext context, CrybinArtifactRegistrar registrar) { } + public void accept(ResultFrame frame) { order.add("file"); frames.add(frame.retain()); } + public void close() { order.add("closed"); } + } +} diff --git a/apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/provider/ProviderCanSignalInputsTest.java b/apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/provider/ProviderCanSignalInputsTest.java new file mode 100644 index 00000000..7f01cb55 --- /dev/null +++ b/apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/provider/ProviderCanSignalInputsTest.java @@ -0,0 +1,346 @@ +package com.opentest.service.grpc.provider; + +import cn.hutool.json.JSONArray; +import cn.hutool.json.JSONObject; +import com.opentest.common.model.entity.Device; +import com.opentest.dashboard.api.capability.CanChannelFacts; +import com.opentest.dashboard.api.capability.CanSignalBatch; +import com.opentest.dashboard.api.capability.CanSignalEvent; +import com.opentest.dashboard.api.capability.CanSignalProjection; +import com.opentest.dashboard.api.channel.CanPortBinding; +import com.opentest.dashboard.api.channel.CanSignalChannel; +import com.opentest.dashboard.api.channel.CanSignalQuantity; +import com.opentest.dashboard.api.channel.CanSignalUnits; +import com.opentest.service.DeviceService; +import com.opentest.service.can.CanConfigurationStore; +import com.opentest.service.can.CanNativeGateway; +import com.opentest.service.can.CanService; +import com.opentest.service.jni.AudioJNIBridgeService; +import com.opentest.service.recording.measurement.CanRecordedInputStore; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.Queue; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ConcurrentLinkedQueue; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.concurrent.atomic.AtomicReference; +import java.util.concurrent.atomic.AtomicInteger; +import com.opentest.service.can.CanOperationException; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.ArgumentMatchers.anyDouble; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.ArgumentMatchers.isNull; +import static org.mockito.Mockito.doAnswer; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +class ProviderCanSignalInputsTest { + private CanNativeGateway nativeCan; + private CanService service; + private ProviderCanSignalInputs participant; + private final Queue pending = new ConcurrentLinkedQueue<>(); + private final Queue observed = new ConcurrentLinkedQueue<>(); + private final AtomicReference ruleId = new AtomicReference<>(); + private final AtomicReference failure = new AtomicReference<>(); + private final CountDownLatch failed = new CountDownLatch(1); + + @BeforeEach void setup() { + var devices = mock(DeviceService.class); + var audio = mock(AudioJNIBridgeService.class); + nativeCan = mock(CanNativeGateway.class); + Device device = new Device(); device.setDeviceName("CAN-TEST"); device.setProtocol("OPENDAQ"); device.setIpAddress("test-address"); + when(devices.findById(1L)).thenReturn(device); + when(audio.getJniDeviceId(device)).thenReturn("native-test"); + when(nativeCan.capabilities(anyString(), anyString())).thenReturn(new JSONObject() + .set("ports", new JSONArray().put(new JSONObject().set("portId", "can0")))); + when(nativeCan.start(anyString(), anyString(), anyString(), any())).thenReturn(new JSONObject().set("receiveId", "source-1")); + when(nativeCan.validateDefinitions(any())).thenReturn(new JSONObject().set("valid", true)); + when(nativeCan.updateDefinitions(anyString(), any())).thenAnswer(call -> { + var definitions = call.getArgument(1, JSONObject.class).getJSONArray("signals"); + if (!definitions.isEmpty()) ruleId.set(definitions.getJSONObject(0).getStr("signalId")); + return new JSONObject(); + }); + when(nativeCan.subscribe(anyString(), any())).thenReturn(new JSONObject().set("subscriptionId", "consumer-1")); + when(nativeCan.readSignals(anyString(), anyString())).thenAnswer(call -> { + JSONObject value = pending.poll(); return value == null ? batch() : value; + }); + when(nativeCan.resetSignals(anyString(), anyString(), any())).thenReturn(new JSONObject()); + when(nativeCan.readFrames(anyString())).thenReturn(new JSONObject().set("frames", new JSONArray())); + when(nativeCan.status(anyString(), anyString(), anyString())).thenReturn(new JSONObject()); + service = new CanService(devices, audio, nativeCan, mock(CanConfigurationStore.class)); + var channel = new CanSignalChannel("CAN1", "10", "20", "Speed", 1, + new CanPortBinding("1", "OPENDAQ", DeviceService.deviceIdentity("OPENDAQ", "CAN-TEST", "test-address"), "can0"), + "{\"schemaVersion\":1,\"definition\":{\"canId\":384,\"startBit\":0,\"bitLength\":16,\"factor\":10}}", + new CanSignalUnits(CanSignalQuantity.ROTATIONAL_SPEED, "rpm", "rpm", null), "frozen"); + participant = new ProviderCanSignalInputs(service, new CanChannelFacts(Map.of("CAN1", channel)), value -> { + failure.set(value); failed.countDown(); + }); + } + @AfterEach void cleanup() { participant.close(); service.close(); } + + private JSONObject batch() { + return new JSONObject().set("state", "running").set("lostSamples", "0") + .set("samples", new JSONArray()); + } + private JSONObject sample(boolean valid, String reason) { + return new JSONObject().set("signalId", ruleId.get()).set("valid", valid).set("reason", reason) + .set("physicalValue", valid ? 1234.5 : null).set("sequence", "9007199254740993") + .set("rawTimestampNs", "1700000000000000000").set("definitionRevision", "2"); + } + private void bind(CanSignalProjection projection) { + participant.prepare(); + participant.projectWith((facts, outputs, output) -> projection); + participant.bind(null, null); + } + + @Test void zeroAudioStartPublishesMissingThenExactDecodedValuesAndInvalidRecovery() throws Exception { + CountDownLatch delivered = new CountDownLatch(3); + bind(value -> { + observed.add(value); + if (value.events().stream().noneMatch(event -> event.provenance().isEmpty())) delivered.countDown(); + }); + pending.add(batch().set("samples", new JSONArray().put(sample(true, "")))); + pending.add(batch().set("samples", new JSONArray().put(sample(false, "timeout")))); + pending.add(batch().set("samples", new JSONArray().put(sample(true, "")))); + participant.start(); + assertTrue(delivered.await(3, TimeUnit.SECONDS)); + participant.close(); + var events = observed.stream().flatMap(value -> value.events().stream()).toList(); + assertEquals(CanSignalEvent.InvalidReason.NO_DATA, ((CanSignalEvent.InvalidState) events.getFirst()).reason()); + assertEquals(1234.5, ((CanSignalEvent.ValidSample) events.get(1)).physicalValue()); + assertEquals("9007199254740993", events.get(1).provenance().get("sequence")); + assertEquals(CanSignalEvent.InvalidReason.TIMEOUT, ((CanSignalEvent.InvalidState) events.get(2)).reason()); + assertTrue(events.get(3) instanceof CanSignalEvent.ValidSample); + assertNull(failure.get()); + assertTrue(participant.released().isDone()); + verify(nativeCan).unsubscribe("source-1", "consumer-1"); + } + + @Test void stopJoinsAlreadyReadCallbackBeforeUnsubscribeAndResourceRelease() throws Exception { + CountDownLatch entered = new CountDownLatch(1), allowDelivery = new CountDownLatch(1); + AtomicBoolean delivered = new AtomicBoolean(); + bind(value -> { + if (value.events().stream().anyMatch(CanSignalEvent.ValidSample.class::isInstance)) { + entered.countDown(); + try { assertTrue(allowDelivery.await(3, TimeUnit.SECONDS)); } + catch (InterruptedException interrupted) { throw new IllegalStateException(interrupted); } + delivered.set(true); + } + }); + doAnswer(call -> { assertTrue(delivered.get()); return new JSONObject(); }) + .when(nativeCan).unsubscribe("source-1", "consumer-1"); + pending.add(batch().set("samples", new JSONArray().put(sample(true, "")))); + participant.start(); + try { + assertTrue(entered.await(3, TimeUnit.SECONDS)); + var stopping = CompletableFuture.runAsync(participant::close); + assertFalse(participant.released().isDone()); + verify(nativeCan, never()).unsubscribe(anyString(), anyString()); + allowDelivery.countDown(); + stopping.get(3, TimeUnit.SECONDS); + assertTrue(delivered.get()); + assertTrue(participant.released().isDone()); + } finally { allowDelivery.countDown(); } + } + + @Test void subscriptionLossMakesOneGapWhileHealthyReceptionContinues() throws Exception { + CountDownLatch delivered = new CountDownLatch(2); + bind(value -> { + observed.add(value); + if (value.events().stream().anyMatch(CanSignalEvent.ValidSample.class::isInstance)) delivered.countDown(); + }); + pending.add(batch().set("lostSamples", "7").set("samples", new JSONArray().put(sample(true, "")))); + pending.add(batch().set("lostSamples", "7").set("samples", new JSONArray().put(sample(true, "")))); + participant.start(); + assertTrue(delivered.await(3, TimeUnit.SECONDS)); + participant.close(); + var gaps = observed.stream().flatMap(value -> value.events().stream()).filter(CanSignalEvent.LossGap.class::isInstance).toList(); + assertEquals(1, gaps.size()); + assertEquals("7", ((CanSignalEvent.LossGap) gaps.getFirst()).droppedCount().toString()); + assertNull(failure.get()); + } + + @Test void terminalSourceFailsExecutionAndReleasesSourceWithoutRuleUpdateOnDeadPort() throws Exception { + bind(observed::add); + pending.add(batch().set("state", "disconnected")); + participant.start(); + assertTrue(failed.await(3, TimeUnit.SECONDS)); + participant.close(); + verify(nativeCan).stop("source-1"); + verify(nativeCan).close("source-1"); + assertTrue(service.rawSources().getJSONArray("sources").getJSONObject(0).getJSONArray("usages").isEmpty()); + } + + @Test void cancellationBeforePreparationCannotAcquireOrStartAndProjectionRegistrationIsOnce() { + participant.close(); + assertThrows(IllegalStateException.class, participant::prepare); + participant.start(); + verify(nativeCan, never()).start(anyString(), anyString(), anyString(), any()); + } + + @Test void recorderStopSealsEveryTailBatchAndFlushesBeforeUnsubscribe() { + var order = new ArrayList(); + var recording = mock(CanRecordedInputStore.Recording.class); + bind(new CanSignalProjection() { + public void accept(CanSignalBatch batch) { observed.add(batch); } + public void close() { order.add("projection-close"); } + }); + participant.attachRecording(recording, () -> 0.5); + var tail = new JSONArray(); + for (int i = 0; i < 256; i++) tail.put(sample(true, "")); + when(nativeCan.finishSignals("source-1", "consumer-1")).thenAnswer(call -> { + order.add("native-seal"); + return batch().set("subscriptionState", "finished").set("drained", false) + .set("cutoff", new JSONObject().set("dispatchSequence", "9007199254740999")) + .set("samples", tail); + }).thenAnswer(call -> { + order.add("native-tail"); + return batch().set("subscriptionState", "finished").set("drained", true) + .set("cutoff", new JSONObject().set("dispatchSequence", "9007199254740999")) + .set("samples", new JSONArray().put(sample(false, "timeout"))); + }); + doAnswer(call -> { + var batch = call.getArgument(0, CanSignalBatch.class); + if (batch.events().stream().anyMatch(event -> event.provenance().containsKey("source"))) order.add("append-tail"); + return null; + }).when(recording).append(any()); + when(recording.finish(anyDouble(), anyDouble(), any(), eq("STOPPED"), isNull())).thenAnswer(call -> { + List> cutoffs = call.getArgument(2); + assertEquals(1, cutoffs.size()); + assertEquals("9007199254740999", ((Map) cutoffs.getFirst().get("cutoff")).get("dispatchSequence")); + order.add("writer-finish"); return null; + }); + when(nativeCan.unsubscribe("source-1", "consumer-1")).thenAnswer(call -> { + order.add("unsubscribe"); return new JSONObject(); + }); + participant.start(); + participant.close(); + assertEquals(List.of("native-seal", "append-tail", "native-tail", "append-tail", "writer-finish", + "projection-close", "unsubscribe"), order); + assertEquals(257, observed.stream().flatMap(batch -> batch.events().stream()) + .filter(event -> event.provenance().containsKey("source")).count()); + assertTrue(participant.released().isDone()); + assertFalse(participant.released().isCompletedExceptionally()); + } + + @Test void sourceFailureFinishesPartialWithCutoffInsteadOfDiscardingItsTail() throws Exception { + var recording = mock(CanRecordedInputStore.Recording.class); + bind(observed::add); + participant.attachRecording(recording, () -> 1.0); + when(nativeCan.finishSignals(anyString(), anyString())).thenReturn(batch().set("state", "disconnected") + .set("subscriptionState", "finished").set("drained", true) + .set("cutoff", new JSONObject().set("dispatchSequence", "23")) + .set("samples", new JSONArray().put(sample(false, "source-error")))); + pending.add(batch().set("state", "disconnected")); + participant.start(); + assertTrue(failed.await(3, TimeUnit.SECONDS)); + participant.close(); + verify(recording).finish(anyDouble(), anyDouble(), any(), eq("SOURCE_FAILURE"), eq(failure.get())); + assertTrue(observed.stream().flatMap(batch -> batch.events().stream()).anyMatch(event -> + event instanceof CanSignalEvent.InvalidState invalid + && invalid.reason() == CanSignalEvent.InvalidReason.SOURCE_FAILURE)); + verify(nativeCan).unsubscribe("source-1", "consumer-1"); + } + + @Test void recorderAdmissionDiscardsPreparationEventsAndBaselinesEarlierSourceLoss() throws Exception { + var recording = mock(CanRecordedInputStore.Recording.class); + var delivered = new CountDownLatch(1); + bind(batch -> { + observed.add(batch); + if (batch.events().stream().anyMatch(CanSignalEvent.ValidSample.class::isInstance)) delivered.countDown(); + }); + participant.attachRecording(recording, () -> 0); + var baseline = new JSONObject().set("forwardSequenceGaps", "11").set("timeDomainChanges", "3"); + when(nativeCan.resetSignals(anyString(), anyString(), any())).thenAnswer(call -> { + pending.clear(); + return new JSONObject().set("lostSamples", "9").set("discardedSamples", "1") + .set("sourceObservations", baseline); + }); + when(nativeCan.readSignals(anyString(), anyString())).thenAnswer(call -> { + var batch = pending.poll(); + return (batch == null ? batch() : batch).set("lostSamples", "9").set("sourceObservations", baseline); + }); + when(nativeCan.finishSignals(anyString(), anyString())).thenReturn(batch().set("subscriptionState", "finished") + .set("drained", true).set("cutoff", new JSONObject().set("dispatchSequence", "23")) + .set("lostSamples", "9").set("sourceObservations", baseline)); + pending.add(batch().set("samples", new JSONArray().put(sample(true, "").set("physicalValue", 55)))); + participant.start(); + pending.add(batch().set("samples", new JSONArray().put(sample(true, "")))); + assertTrue(delivered.await(3, TimeUnit.SECONDS)); + participant.close(); + var events = observed.stream().flatMap(batch -> batch.events().stream()).toList(); + assertTrue(events.getFirst().provenance().containsKey("admission")); + assertEquals(List.of(1234.5), events.stream().filter(CanSignalEvent.ValidSample.class::isInstance) + .map(event -> ((CanSignalEvent.ValidSample) event).physicalValue()).toList()); + assertTrue(events.stream().noneMatch(CanSignalEvent.LossGap.class::isInstance)); + } + + @Test void writerFinalizationFailureFailsCompletionAfterSealingAndStillReleasesPort() { + var recording = mock(CanRecordedInputStore.Recording.class); + bind(observed::add); + participant.attachRecording(recording, () -> 0); + when(nativeCan.finishSignals(anyString(), anyString())).thenReturn(batch().set("subscriptionState", "finished") + .set("drained", true).set("cutoff", new JSONObject().set("dispatchSequence", "23"))); + var writeFailure = new IllegalStateException("test writer flush failed"); + when(recording.finish(anyDouble(), anyDouble(), any(), eq("STOPPED"), isNull())).thenThrow(writeFailure); + participant.start(); + var closing = participant; + participant = new ProviderCanSignalInputs(service, new CanChannelFacts(Map.of()), failure::set); + assertEquals(writeFailure, assertThrows(IllegalStateException.class, closing::close)); + assertTrue(closing.released().isCompletedExceptionally()); + verify(recording).fail(writeFailure); + verify(nativeCan).finishSignals("source-1", "consumer-1"); + verify(nativeCan).unsubscribe("source-1", "consumer-1"); + verify(nativeCan).close("source-1"); + } + + @Test void failedMultiPortPreparationStillOwnsAndRetriesItsFailedCompensation() { + participant.close(); + var first = participant.channels().channels().get("CAN1"); + var second = new CanSignalChannel("CAN2", "11", "20", "Other port", 2, + new CanPortBinding("1", "OPENDAQ", first.binding().stableDeviceId(), "can1"), + first.persistedJson(), first.units(), "second"); + participant = new ProviderCanSignalInputs(service, new CanChannelFacts(Map.of("CAN1", first, "CAN2", second)), failure::set); + when(nativeCan.capabilities(anyString(), anyString())).thenReturn(new JSONObject().set("ports", + new JSONArray().put(new JSONObject().set("portId", "can0")).put(new JSONObject().set("portId", "can1")))); + AtomicInteger sources = new AtomicInteger(), subscriptions = new AtomicInteger(), unsubscribes = new AtomicInteger(); + when(nativeCan.start(anyString(), anyString(), anyString(), any())).thenAnswer(call -> + new JSONObject().set("receiveId", "source-" + sources.incrementAndGet())); + when(nativeCan.subscribe(anyString(), any())).thenAnswer(call -> { + if (subscriptions.incrementAndGet() == 2) throw new CanOperationException(13103018, "can.error.nativeFailure"); + return new JSONObject().set("subscriptionId", "consumer-1"); + }); + when(nativeCan.unsubscribe(anyString(), anyString())).thenAnswer(call -> { + if (unsubscribes.incrementAndGet() == 1) throw new CanOperationException(13103018, "can.error.nativeFailure"); + return new JSONObject(); + }); + + assertThrows(CanOperationException.class, participant::prepare); + assertTrue(service.rawSources().getJSONArray("sources").stream().anyMatch(value -> + !((JSONObject) value).getJSONArray("usages").isEmpty())); + participant.close(); + for (Object value : service.rawSources().getJSONArray("sources")) { + JSONObject source = (JSONObject) value; + assertTrue(source.getJSONArray("usages").isEmpty()); + assertNull(source.getStr("receiveId")); + } + assertTrue(participant.released().isDone()); + verify(nativeCan, times(2)).close(anyString()); + } +} diff --git a/apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/replay/RecordedProviderFactsPlanningTest.java b/apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/replay/RecordedProviderFactsPlanningTest.java index fe47a34d..d4712193 100644 --- a/apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/replay/RecordedProviderFactsPlanningTest.java +++ b/apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/replay/RecordedProviderFactsPlanningTest.java @@ -16,6 +16,22 @@ import com.opentest.service.mapper.DashboardResultDtoMapper; import com.opentest.service.mapper.GraphicConfigSnapshotDtoMapper; import com.opentest.service.unit.artifact.RawHistoricalArtifactGenerationClassifier; +import com.opentest.common.model.entity.File; +import com.opentest.common.model.query.FileQuery; +import com.opentest.dashboard.api.capability.CanChannelFacts; +import com.opentest.dashboard.api.capability.CanSignalBatch; +import com.opentest.dashboard.api.capability.CanSignalEvent; +import com.opentest.dashboard.api.channel.CanPortBinding; +import com.opentest.dashboard.api.channel.CanSignalChannel; +import com.opentest.dashboard.api.channel.CanSignalQuantity; +import com.opentest.dashboard.api.channel.CanSignalUnits; +import com.opentest.dashboard.api.channel.ChannelDirection; +import com.opentest.service.recording.measurement.CanRecordedInputStore; +import com.opentest.service.snapshot.FlowExecuteSnapshotMutator; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.function.Consumer; +import org.junit.jupiter.api.io.TempDir; import org.mapstruct.factory.Mappers; import com.opentest.common.model.dto.DashboardConfigDto; @@ -79,12 +95,76 @@ import static org.mockito.ArgumentMatchers.anyMap; import static org.mockito.ArgumentMatchers.anyString; import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.doAnswer; import static org.mockito.Mockito.never; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verifyNoInteractions; import static org.mockito.Mockito.when; class RecordedProviderFactsPlanningTest { + @Test void normalCanHistoryPlannerAndExportUseRegisteredFrozenEventsWithNoSampledOrDeviceInputs(@TempDir Path root) throws Exception { + var f = new Fixture(); + var snapshot = FlowExecuteSnapshotDataDto.parseJson(f.history.getSnapshotData()); + snapshot.setInternalStoragePath(root.toString()); + f.history.setSnapshotData(snapshot.toJson()); + var mutator = new FlowExecuteSnapshotMutator() { + @Override public FlowExecuteSnapshotDataDto read(Long requestId) { + return FlowExecuteSnapshotDataDto.parseJson(f.history.getSnapshotData()); + } + @Override public FlowExecuteSnapshotDataDto mutate(Long requestId, Consumer mutation) { + var current = read(requestId); mutation.accept(current); f.history.setSnapshotData(current.toJson()); return current; + } + }; + var registered = new ArrayList(); + doAnswer(call -> { File file = call.getArgument(0); file.setId(99L); registered.add(file); return file; }) + .when(f.files).saveOrUpdateEntity(any(File.class)); + when(f.files.list(any(FileQuery.class))).thenReturn(registered); + var can = new CanSignalChannel("can", "5", "7", "Frozen volts", 1, + new CanPortBinding("3", "CAN", "serial", "CAN0"), "{\"version\":1}", + new CanSignalUnits(CanSignalQuantity.VOLTAGE, "V", "V", null), "frozen-v1"); + var store = new CanRecordedInputStore(f.files, mutator); + var recording = store.open(root, 40, new CanChannelFacts(Map.of("can", can))); + recording.mapProgress(10, 0); + recording.append(new CanSignalBatch(10.2, List.of(new CanSignalEvent.ValidSample("can", 3, Map.of())))); + var saved = recording.finish(11, 1, List.of(Map.of("drained", true, "subscriptionState", "finished", + "cutoff", Map.of("dispatchSequence", "9007199254740993"))), "normal"); + ReflectionTestUtils.setField(f.planner, "snapshotMutator", mutator); + var units = GraphicUnitResolution.choices("s", "V", "V"); + var member = new ResultChannelDefinition("can", "Frozen volts", ChannelDirection.INPUT, null, + new ResultChannelUnitFacts(SignalType.UNKNOWN, "V", units)); + var descriptions = (ProviderDashboardResultReader) ReflectionTestUtils.getField(f.planner, "descriptions"); + var definition = new ResultSetDefinition("CAN Viewer", "hash", "CAN Viewer", ResultType.TIME, + DomainType.TIME_DOMAIN, List.of(), Map.of(), List.of(member), Map.of()); + when(descriptions.describeSavedTableDefinition(any(), any())).thenReturn(Optional.of(definition)); + f.rows.selectById(101L).setPrimaryCode("CAN Viewer"); + f.result.setPrimaryCode("CAN Viewer"); + when(f.plugins.recordedMeasurementInputMode(anyString(), anyMap(), any())).thenReturn(RecordedInputMode.WAVEFORM_STREAM); + var interpreted = new ArrayList(); + when(f.plugins.bindRecordedMeasurementUse(anyString(), any(), anyMap(), anyMap(), any(), any(), anyList(), any())) + .thenAnswer(call -> { interpreted.addAll(call.getArgument(6)); return RecordedUseInterpretation.identity(); }); + var exported = f.planner.previewExportRequirement(40, 101, "can", "V", f.caller); + assertEquals("Frozen volts", exported.getChannel().getChannelName()); + try (var data = new DashboardExportDataContext(40L, List.of())) { + var prepared = f.planner.prepare(40, f.caller, f.authority, List.of(f.result), + new DashboardOutputSelection(Set.of(DashboardResultChannelKey.of(101L, "can")), Map.of()), + Map.of(), null, data, ExecutionInputPurpose.RECORDED_GRAPHIC_EXPORT, mock(DashboardWavReplayRunner.class)); + try { + prepared.verify().run(); + assertEquals(RecordedInputMode.PROVIDER_FACTS, prepared.inputMode()); + try (var timeline = prepared.openTimeline(List.of())) { assertFalse(timeline.hasNext()); } + } finally { prepared.execution().close(); } + assertEquals(List.of(), prepared.sources()); + } + assertEquals("Frozen volts", ((RecordedOutputSelection.CanSource)interpreted.getFirst().source()).channel().displayName()); + assertEquals(2, interpreted.size()); + verify(f.inputs, never()).admit(any(), any()); + Files.writeString(root.resolve(saved.getRelativePath()), "tampered"); + try (var data = new DashboardExportDataContext(40L, List.of())) { + assertThrows(IllegalArgumentException.class, () -> f.planner.prepare(40, f.caller, f.authority, List.of(f.result), + new DashboardOutputSelection(Set.of(DashboardResultChannelKey.of(101L, "can")), Map.of()), + Map.of(), null, data, ExecutionInputPurpose.RECORDED_GRAPHIC_EXPORT, mock(DashboardWavReplayRunner.class))); + } + } @Test void realSavedPlannerAdmitsProviderFactsWithoutCanonicalWavRowsAndCreatesTheNoMediaTimeline() throws Exception { var f = new Fixture(); try (var data = new DashboardExportDataContext(40L,List.of())) { diff --git a/apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/replay/RecordedResultMembersTest.java b/apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/replay/RecordedResultMembersTest.java index 02fa53d7..4c43cbd1 100644 --- a/apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/replay/RecordedResultMembersTest.java +++ b/apps/backend/crydaq-service/src/test/java/com/opentest/service/grpc/replay/RecordedResultMembersTest.java @@ -5,9 +5,12 @@ import com.opentest.common.model.dto.DynamicResultChannelBatchDto; import com.opentest.common.model.dto.DynamicResultChannelDto; import com.opentest.common.model.dto.FlowExecuteSnapshotDataDto; +import com.opentest.common.model.dto.ChannelDto; import com.opentest.service.dashboard.framework.BoundMeasurementInputs; import java.util.List; import java.util.Map; +import java.util.OptionalInt; +import com.opentest.dashboard.api.measurement.editing.InputDeclaration; import org.junit.jupiter.api.Test; import com.opentest.dashboard.api.channel.ChannelMetadata; import com.opentest.dashboard.api.channel.SignalType; @@ -24,11 +27,17 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.mockito.Mockito.mock; class RecordedResultMembersTest { + @Test void directCanMemberCannotEnterLegacySampledReplay() { + var channel = new ChannelDto(); channel.setVchId("a"); channel.setChannelSource(2); channel.setChannelIo(0); + var inputs = new BoundMeasurementInputs(emptyInputs().declaration(), Map.of(), List.of(channel), List.of(), + List.of(), 1, List.of(channel)); + assertThrows(IllegalArgumentException.class, + () -> RecordedResultMembers.resolve(snapshot("a", 30), 30, 20, 7, definition(), "a", inputs)); + } @Test void restoresOnlyPublishedCycleAndKeepsItsSourceCalibrationAndResultId() { - var member = RecordedResultMembers.resolve(snapshot("a", 30), 30, 20, 7, definition(), "a_Cycle2", mock(BoundMeasurementInputs.class)); + var member = RecordedResultMembers.resolve(snapshot("a", 30), 30, 20, 7, definition(), "a_Cycle2", emptyInputs()); assertEquals("a", member.sourceId()); assertEquals("a_Cycle2", member.declaration().resultMetadata().vchId()); assertEquals(50D, member.declaration().resultMetadata().sensitivity()); @@ -44,9 +53,13 @@ class RecordedResultMembersTest { @Test void nameAloneOrAnotherRequestsDeclarationCannotAuthorizeACycle() { for (var snapshot : List.of(snapshot("b", 30), snapshot(null, 30), snapshot("a", 31))) assertThrows(IllegalArgumentException.class, () -> RecordedResultMembers.resolve(snapshot, 30, 20, 7, - definition(), "a_Cycle2", mock(BoundMeasurementInputs.class))); + definition(), "a_Cycle2", emptyInputs())); assertThrows(IllegalArgumentException.class, () -> RecordedResultMembers.resolve(snapshot("a", 30), 30, 20, 7, - definition(), "a_Cycle3", mock(BoundMeasurementInputs.class))); + definition(), "a_Cycle3", emptyInputs())); + } + private static BoundMeasurementInputs emptyInputs() { + return new BoundMeasurementInputs(new InputDeclaration(List.of(), List.of(), List.of(), List.of(), List.of(), OptionalInt.empty()), + Map.of(), List.of(), List.of(), List.of(), 0, List.of()); } private static ResultSetDefinition definition() { var units = new GraphicUnitResolution(new UnitCombination("Hz", "s"), List.of(new UnitCombination("Hz", "s"))); diff --git a/apps/backend/crydaq-service/src/test/java/com/opentest/service/recording/measurement/CanRecordedInputStoreTest.java b/apps/backend/crydaq-service/src/test/java/com/opentest/service/recording/measurement/CanRecordedInputStoreTest.java new file mode 100644 index 00000000..28b0f231 --- /dev/null +++ b/apps/backend/crydaq-service/src/test/java/com/opentest/service/recording/measurement/CanRecordedInputStoreTest.java @@ -0,0 +1,229 @@ +package com.opentest.service.recording.measurement; + +import com.opentest.common.model.dto.FlowExecuteSnapshotDataDto; +import com.opentest.common.model.entity.File; +import com.opentest.common.model.query.FileQuery; +import com.opentest.common.exception.CryBusinessException; +import com.opentest.common.exception.ErrorCode; +import com.opentest.service.can.CanOperationException; +import com.opentest.dashboard.api.capability.CanChannelFacts; +import com.opentest.dashboard.api.capability.CanSignalBatch; +import com.opentest.dashboard.api.capability.CanSignalEvent; +import com.opentest.dashboard.api.measurement.ExecutionOutputs; +import com.opentest.service.grpc.replay.RecordedCanSignalInputs; +import com.opentest.dashboard.api.channel.CanPortBinding; +import com.opentest.dashboard.api.channel.CanSignalChannel; +import com.opentest.dashboard.api.channel.CanSignalQuantity; +import com.opentest.dashboard.api.channel.CanSignalUnits; +import com.opentest.service.FileService; +import com.opentest.service.snapshot.FlowExecuteSnapshotMutator; +import java.io.FilterOutputStream; +import java.io.IOException; +import java.math.BigInteger; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.function.Consumer; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.io.TempDir; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertInstanceOf; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.doAnswer; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +class CanRecordedInputStoreTest { + @TempDir Path root; + private final FileService files = mock(FileService.class); + private final List rows = new ArrayList<>(); + private final FlowExecuteSnapshotDataDto snapshot = new FlowExecuteSnapshotDataDto(); + private final FlowExecuteSnapshotMutator snapshots = new FlowExecuteSnapshotMutator() { + @Override public FlowExecuteSnapshotDataDto read(Long request) { return snapshot; } + @Override public FlowExecuteSnapshotDataDto mutate(Long request, Consumer mutation) { + mutation.accept(snapshot); return snapshot; + } + }; + + private CanRecordedInputStore store() { + doAnswer(call -> { File row = call.getArgument(0); row.setId(9L); rows.add(row); return row; }) + .when(files).saveOrUpdateEntity(any(File.class)); + when(files.list(any(FileQuery.class))).thenReturn(rows); + return new CanRecordedInputStore(files, snapshots); + } + + private static CanChannelFacts channels() { + var channel = new CanSignalChannel("can-a", "3", "2", "Frozen RPM", 1, + new CanPortBinding("5", "CAN", "serial-5", "CAN0"), "{\"version\":1,\"factor\":0.1}", + new CanSignalUnits(CanSignalQuantity.ROTATIONAL_SPEED, "rpm", "rpm", null), "fingerprint-v1"); + return new CanChannelFacts(Map.of(channel.vchId(), channel)); + } + + private static List> cutoff() { + return List.of(Map.of("subscriptionState", "finished", "drained", true, "complete", true, + "cutoff", Map.of("dispatchSequence", "9007199254740993", "steadyTimeMs", "12345678901234567890"))); + } + + @Test void registrationAndSnapshotPublicationFailuresUseDistinctLocalizedStorageErrors() { + var store = store(); + doAnswer(call -> { throw new IllegalStateException("database registration failed"); }) + .when(files).saveOrUpdateEntity(any(File.class)); + assertEquals("can.recorded.error.register", assertThrows(CanOperationException.class, + () -> store.open(root, 40, channels())).messageKey()); + store(); + var failingSnapshots = new FlowExecuteSnapshotMutator() { + @Override public FlowExecuteSnapshotDataDto read(Long request) { return snapshot; } + @Override public FlowExecuteSnapshotDataDto mutate(Long request, Consumer mutation) { + throw new IllegalStateException("snapshot publication failed"); + } + }; + var failing = new CanRecordedInputStore(files, failingSnapshots); + assertEquals("can.recorded.error.publish", assertThrows(CanOperationException.class, + () -> failing.open(root.resolve("publish"), 40, channels())).messageKey()); + } + + @Test void replayAndSeekUseSavedCommonProgressAndRetainInvalidGapsAfterRewind() { + var store = store(); var recording = store.open(root, 40, channels()); + recording.mapProgress(10, 0); + recording.mapProgress(10.2, 0.1); + recording.append(new CanSignalBatch(10.2, List.of(new CanSignalEvent.ValidSample("can-a", 5, Map.of())))); + recording.mapProgress(10.8, 0.3); + recording.append(new CanSignalBatch(10.8, List.of(new CanSignalEvent.InvalidState("can-a", CanSignalEvent.InvalidReason.INVALID_RAW, Map.of())))); + var facts = store.read(root, 40, recording.finish(11, 0.4, cutoff(), "normal")); + var replayed = new ArrayList(); + facts.replay(0, 0.4, replayed::add); + assertEquals(List.of(0.1, 0.3), replayed.stream().map(CanSignalBatch::observationElapsedSeconds).toList()); + assertEquals(10.2, facts.batches().getFirst().observationElapsedSeconds()); + var generations = new ArrayList>(); + try (var replay = new RecordedCanSignalInputs(facts)) { + replay.projectWith((selected, outputs, output) -> { + var generation = new ArrayList(); generations.add(generation); + return generation::add; + }); + replay.bind(new ExecutionOutputs(2, 3, 40, List.of(), List.of(), List.of()), (curve, generation, append) -> { }); + replay.advance(0.2); + assertInstanceOf(CanSignalEvent.ValidSample.class, generations.getLast().getLast().events().getFirst()); + replay.advance(0.4); + assertInstanceOf(CanSignalEvent.InvalidState.class, generations.getLast().getLast().events().getFirst()); + replay.seek(0.2); + assertEquals(2, generations.size()); + assertEquals(0.1, generations.getLast().getLast().observationElapsedSeconds()); + assertInstanceOf(CanSignalEvent.ValidSample.class, generations.getLast().getLast().events().getFirst()); + replay.advance(0.4); + assertEquals(0.3, generations.getLast().getLast().observationElapsedSeconds()); + } + } + + @Test void realFileRoundTripKeepsIrregularTimeInvalidityExactProvenanceAndFrozenChannel() throws Exception { + var store = store(); + var recording = store.open(root, 40, channels()); + recording.mapProgress(10, 0); + recording.append(new CanSignalBatch(10.07, List.of(new CanSignalEvent.ValidSample("can-a", 123.5, + Map.of("sequence", "9007199254740993", "raw", "-9007199254740993"))))); + recording.append(new CanSignalBatch(10.13, List.of(new CanSignalEvent.InvalidState("can-a", + CanSignalEvent.InvalidReason.TIMEOUT, Map.of("reason", "timeout"))))); + recording.append(new CanSignalBatch(10.19, List.of(new CanSignalEvent.LossGap("can-a", new BigInteger("9007199254740993"), Map.of())))); + recording.append(new CanSignalBatch(10.41, List.of(new CanSignalEvent.ValidSample("can-a", 200, Map.of())))); + var saved = recording.finish(11, 1, cutoff(), "normal"); + assertEquals("FINISHED", saved.getStatus()); + assertEquals(4, saved.getBatchCount()); + assertEquals(1, rows.size()); + assertNotNull(saved.getFileId()); + assertTrue(Files.size(root.resolve(saved.getRelativePath())) > 0); + assertTrue(Files.list(root).noneMatch(path -> path.toString().endsWith(".wav"))); + // Persist and reopen through the actual mixed Hutool/Jackson snapshot codec. + var reopened = FlowExecuteSnapshotDataDto.parseJson(snapshot.toJson()); + assertNotNull(reopened); + var offline = store.read(root, 40, reopened.getCanRecording()); + assertEquals("Frozen RPM", offline.channels().channels().get("can-a").displayName()); + assertEquals("fingerprint-v1", offline.channels().channels().get("can-a").definitionFingerprint()); + assertEquals(10.07, offline.batches().getFirst().observationElapsedSeconds()); + assertEquals(0.07, offline.through(0.1).getFirst().observationElapsedSeconds(), 1e-10); + assertInstanceOf(CanSignalEvent.InvalidState.class, offline.at(0.15).get("can-a")); + var gap = assertInstanceOf(CanSignalEvent.LossGap.class, offline.at(0.3).get("can-a")); + assertEquals(new BigInteger("9007199254740993"), gap.droppedCount()); + assertEquals(200, assertInstanceOf(CanSignalEvent.ValidSample.class, offline.at(1).get("can-a")).physicalValue()); + assertEquals(cutoff(), offline.section().getNativeFinishSnapshots()); + saved.getChannels().clear(); + assertEquals(1, offline.channels().channels().size()); + } + + @Test void sourceFailureRetainsNativeCutoffsAndLastValidPrefix() { + var store = store(); var recording = store.open(root, 40, channels()); + recording.mapProgress(0, 0); + recording.append(new CanSignalBatch(0.2, List.of(new CanSignalEvent.ValidSample("can-a", 1, Map.of())))); + recording.stopFailure(new IllegalStateException("disconnected")); + recording.append(new CanSignalBatch(0.3, List.of(new CanSignalEvent.InvalidState("can-a", CanSignalEvent.InvalidReason.SOURCE_FAILURE, Map.of())))); + var saved = recording.finish(0.4, 0.4, cutoff(), "sourceFailure"); + assertEquals("FAILED", saved.getStatus()); + assertEquals(cutoff(), store.read(root, 40, saved).section().getNativeFinishSnapshots()); + assertEquals(2, store.read(root, 40, saved).batches().size()); + } + + @Test void midBatchDiskFailureRetainsOnlyFullyFlushedPrefixAndFailsFurtherAdmission() { + store(); + var reject = new AtomicBoolean(); + var store = new CanRecordedInputStore(files, snapshots, path -> new FilterOutputStream(Files.newOutputStream(path)) { + @Override public void write(byte[] data, int offset, int length) throws IOException { + if (reject.get()) { out.write(data, offset, Math.min(7, length)); throw new IOException("disk full"); } + out.write(data, offset, length); + } + }); + var recording = store.open(root, 40, channels()); recording.mapProgress(0, 0); + recording.append(new CanSignalBatch(0.1, List.of(new CanSignalEvent.ValidSample("can-a", 3, Map.of())))); + reject.set(true); + var error = assertThrows(CanOperationException.class, () -> recording.append( + new CanSignalBatch(0.3, List.of(new CanSignalEvent.ValidSample("can-a", 9, Map.of()))))); + assertEquals("can.recorded.error.write", error.messageKey()); + assertThrows(IllegalStateException.class, () -> recording.append(new CanSignalBatch(0.4, List.of()))); + var saved = recording.fail(error); + assertEquals("FAILED", saved.getStatus()); + assertEquals(1, saved.getBatchCount()); + assertEquals(3, assertInstanceOf(CanSignalEvent.ValidSample.class, store.read(root, 40, saved).at(1).get("can-a")).physicalValue()); + } + + @Test void closeFailureIsPublishedAsPartialAndReachesCaller() { + store(); + var store = new CanRecordedInputStore(files, snapshots, path -> new FilterOutputStream(Files.newOutputStream(path)) { + @Override public void close() throws IOException { super.close(); throw new IOException("close failed"); } + }); + var recording = store.open(root, 40, channels()); recording.mapProgress(0, 0); + assertEquals("can.recorded.error.write", assertThrows(CanOperationException.class, + () -> recording.finish(1, 1, cutoff(), "normal")).messageKey()); + assertEquals("FAILED", snapshot.getCanRecording().getStatus()); + assertTrue(snapshot.getCanRecording().getFailure().contains("close failed")); + } + + @Test void tamperedMissingForeignAndUnsealedArtifactsCannotBeReplayed() throws Exception { + var store = store(); var recording = store.open(root, 40, channels()); recording.mapProgress(0, 0); + assertThrows(IllegalArgumentException.class, () -> recording.finish(1, 1, List.of(Map.of("drained", false)), "normal")); + var saved = recording.finish(1, 1, cutoff(), "normal"); + assertThrows(IllegalArgumentException.class, () -> store.read(root, 41, saved)); + var foreign = CanRecordedInputStore.copy(saved); foreign.setFileId("99"); + assertThrows(IllegalArgumentException.class, () -> store.read(root, 40, foreign)); + Files.writeString(root.resolve(saved.getRelativePath()), "changed"); + assertThrows(IllegalArgumentException.class, () -> store.read(root, 40, saved)); + Files.delete(root.resolve(saved.getRelativePath())); + assertEquals(ErrorCode.LOCAL_FILE_READ_ERROR.getErrcode(), assertThrows(CryBusinessException.class, + () -> store.read(root, 40, saved)).getErrcode()); + } + + @Test void legacySnapshotStillHasNoCanSectionAndOrderedMappingIsRequired() { + assertNull(FlowExecuteSnapshotDataDto.parseJson("{\"recordTime\":1}").getCanRecording()); + var store = store(); var recording = store.open(root, 40, channels()); + assertThrows(IllegalArgumentException.class, () -> recording.append(new CanSignalBatch(0, List.of()))); + recording.mapProgress(10, 0); recording.mapProgress(12, 1); + assertThrows(IllegalArgumentException.class, () -> recording.mapProgress(11, 2)); + var saved = recording.finish(14, 2, cutoff(), "normal"); + assertEquals(0.5, store.read(root, 40, saved).recordingSeconds(11)); + recording.close(); + assertThrows(IllegalStateException.class, () -> store.open(root, 40, channels())); + } +} diff --git a/apps/backend/crydaq-service/src/test/java/com/opentest/service/virtualchannel/VirtualChannelCanDependencyTest.java b/apps/backend/crydaq-service/src/test/java/com/opentest/service/virtualchannel/VirtualChannelCanDependencyTest.java new file mode 100644 index 00000000..7ff6c893 --- /dev/null +++ b/apps/backend/crydaq-service/src/test/java/com/opentest/service/virtualchannel/VirtualChannelCanDependencyTest.java @@ -0,0 +1,51 @@ +package com.opentest.service.virtualchannel; + +import com.opentest.common.exception.CryBusinessException; +import com.opentest.common.exception.LocalizedMessage; +import com.opentest.common.model.dto.BoxChannelDto; +import com.opentest.dashboard.api.channel.MathSampleSemantics; +import com.opentest.service.jni.UnitConversionService; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.EnumSource; +import org.junit.jupiter.params.provider.NullSource; + +import java.util.List; +import java.util.Locale; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertInstanceOf; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verifyNoInteractions; + +class VirtualChannelCanDependencyTest { + @ParameterizedTest + @NullSource + @EnumSource(MathSampleSemantics.class) + void mathCannotConsumeCanThroughEitherWholeProjectOrNewChannelValidation(MathSampleSemantics semantics) { + UnitConversionService units = mock(UnitConversionService.class); + VirtualChannelConfigValidator validator = new VirtualChannelConfigValidator( + VirtualChannelTestSupport.formulaAnalyzer(), units, new VirtualChannelDependencyGraph()); + BoxChannelDto can = new BoxChannelDto(); + can.setChannelSource(2); + can.setCustomName("Engine"); + can.setVchId("CAN1"); + BoxChannelDto math = new BoxChannelDto(); + math.setChannelSource(1); + math.setChannelType(5); + math.setCustomName("Derived"); + math.setVchId("Math1"); + math.setMathFormula("'Engine' * 2"); + math.setMathUnit("rpm"); + math.setMathSampleSemantics(semantics); + var projectFailure = assertThrows(CryBusinessException.class, + () -> validator.validateProjectConfig(11L, List.of(can, math))); + var newChannelFailure = assertThrows(CryBusinessException.class, + () -> validator.validateNewChannelConfig(11L, List.of(can, math), "Derived")); + for (var failure : List.of(projectFailure, newChannelFailure)) { + assertEquals("CAN signals cannot be used as Math inputs.", + assertInstanceOf(LocalizedMessage.class, failure.getMsgArgs()[0]).resolve(Locale.ENGLISH)); + } + verifyNoInteractions(units); + } +} diff --git a/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/capability/CanChannelFacts.java b/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/capability/CanChannelFacts.java new file mode 100644 index 00000000..04539f0b --- /dev/null +++ b/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/capability/CanChannelFacts.java @@ -0,0 +1,19 @@ +package com.opentest.dashboard.api.capability; + +import com.opentest.dashboard.api.channel.CanSignalChannel; +import java.util.Collections; +import java.util.LinkedHashMap; +import java.util.Map; +import java.util.Objects; + +public record CanChannelFacts(Map channels) { + public CanChannelFacts { + var copy = new LinkedHashMap<>(Objects.requireNonNull(channels, "channels")); + copy.forEach((id, channel) -> { + if (!Objects.requireNonNull(channel, "channel").vchId().equals(id)) + throw new IllegalArgumentException("CAN channel key must equal vchId"); + }); + channels = Collections.unmodifiableMap(copy); + } + public static CanChannelFacts empty() { return new CanChannelFacts(Map.of()); } +} diff --git a/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/capability/CanSignalBatch.java b/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/capability/CanSignalBatch.java new file mode 100644 index 00000000..742a1dba --- /dev/null +++ b/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/capability/CanSignalBatch.java @@ -0,0 +1,12 @@ +package com.opentest.dashboard.api.capability; + +import java.util.List; + +/** Ordered host observations in seconds since the Java monotonic formal-start origin. */ +public record CanSignalBatch(double observationElapsedSeconds, List events) { + public CanSignalBatch { + if (!Double.isFinite(observationElapsedSeconds) || observationElapsedSeconds < 0) + throw new IllegalArgumentException("Invalid CAN observation time"); + events = List.copyOf(events); + } +} diff --git a/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/capability/CanSignalEvent.java b/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/capability/CanSignalEvent.java new file mode 100644 index 00000000..6aa49c02 --- /dev/null +++ b/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/capability/CanSignalEvent.java @@ -0,0 +1,40 @@ +package com.opentest.dashboard.api.capability; + +import com.opentest.dashboard.api.internal.ImmutableValues; +import java.math.BigInteger; +import java.util.Map; +import java.util.Objects; + +/** Native scaling is already applied. Exact Native clocks, revisions and integers remain provenance. */ +public sealed interface CanSignalEvent { + String vchId(); + Map provenance(); + + record ValidSample(String vchId, double physicalValue, Map provenance) implements CanSignalEvent { + public ValidSample { + requireIdentity(vchId); + if (!Double.isFinite(physicalValue)) throw new IllegalArgumentException("Valid CAN value must be finite"); + provenance = ImmutableValues.jsonMap(provenance); + } + } + record InvalidState(String vchId, InvalidReason reason, Map provenance) implements CanSignalEvent { + public InvalidState { + requireIdentity(vchId); + Objects.requireNonNull(reason, "reason"); + provenance = ImmutableValues.jsonMap(provenance); + } + } + record LossGap(String vchId, BigInteger droppedCount, Map provenance) implements CanSignalEvent { + public LossGap { + requireIdentity(vchId); + if (droppedCount != null && droppedCount.signum() < 0) + throw new IllegalArgumentException("Dropped count must not be negative"); + provenance = ImmutableValues.jsonMap(provenance); + } + } + enum InvalidReason { NO_DATA, TIMEOUT, INVALID_RAW, INVALID_RULE, SHORT_PAYLOAD, SOURCE_FAILURE } + + private static void requireIdentity(String id) { + if (Objects.requireNonNull(id, "vchId").isBlank()) throw new IllegalArgumentException("vchId must not be blank"); + } +} diff --git a/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/capability/CanSignalInputs.java b/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/capability/CanSignalInputs.java new file mode 100644 index 00000000..7ec96c07 --- /dev/null +++ b/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/capability/CanSignalInputs.java @@ -0,0 +1,8 @@ +package com.opentest.dashboard.api.capability; + +/** Execution-scoped input attachment. The host owns preparation, delivery, drain and release. */ +public interface CanSignalInputs { + CanChannelFacts channels(); + /** Install exactly once before finishPreparation; the host creates it after output reservation. */ + void projectWith(CanSignalProjection.Factory factory); +} diff --git a/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/capability/CanSignalProjection.java b/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/capability/CanSignalProjection.java new file mode 100644 index 00000000..59547d7c --- /dev/null +++ b/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/capability/CanSignalProjection.java @@ -0,0 +1,13 @@ +package com.opentest.dashboard.api.capability; + +import com.opentest.dashboard.api.measurement.ExecutionOutputs; + +public interface CanSignalProjection extends AutoCloseable { + void accept(CanSignalBatch batch); + @Override default void close() { } + + @FunctionalInterface + interface Factory { + CanSignalProjection create(CanChannelFacts channels, ExecutionOutputs outputs, LiveResultOutput output); + } +} diff --git a/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/channel/CanPortBinding.java b/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/channel/CanPortBinding.java new file mode 100644 index 00000000..6051f5ef --- /dev/null +++ b/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/channel/CanPortBinding.java @@ -0,0 +1,11 @@ +package com.opentest.dashboard.api.channel; + +import java.util.Objects; + +public record CanPortBinding(String deviceId, String protocol, String stableDeviceId, String portId) { + public CanPortBinding { + for (String value : new String[]{deviceId, protocol, stableDeviceId, portId}) + if (Objects.requireNonNull(value, "CAN binding identity").isBlank()) + throw new IllegalArgumentException("CAN binding identity must not be blank"); + } +} diff --git a/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/channel/CanSignalChannel.java b/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/channel/CanSignalChannel.java new file mode 100644 index 00000000..96c1560e --- /dev/null +++ b/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/channel/CanSignalChannel.java @@ -0,0 +1,16 @@ +package com.opentest.dashboard.api.channel; + +import java.util.Objects; + +/** Frozen project identity and complete versioned project wire definition, without an audio clock. */ +public record CanSignalChannel(String vchId, String projectChannelId, String projectId, + String displayName, Integer displayOrder, CanPortBinding binding, + String persistedJson, CanSignalUnits units, String definitionFingerprint) { + public CanSignalChannel { + for (String value : new String[]{vchId, projectChannelId, projectId, displayName, persistedJson, definitionFingerprint}) + if (Objects.requireNonNull(value, "CAN channel fact").isBlank()) + throw new IllegalArgumentException("CAN channel fact must not be blank"); + Objects.requireNonNull(binding, "binding"); + Objects.requireNonNull(units, "units"); + } +} diff --git a/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/channel/CanSignalQuantity.java b/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/channel/CanSignalQuantity.java new file mode 100644 index 00000000..8345eb2f --- /dev/null +++ b/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/channel/CanSignalQuantity.java @@ -0,0 +1,5 @@ +package com.opentest.dashboard.api.channel; + +public enum CanSignalQuantity { + FREQUENCY, TACHO, ROTATIONAL_SPEED, SPEED, TEMPERATURE, VOLTAGE, CUSTOM +} diff --git a/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/channel/CanSignalUnitConversion.java b/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/channel/CanSignalUnitConversion.java new file mode 100644 index 00000000..6777b240 --- /dev/null +++ b/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/channel/CanSignalUnitConversion.java @@ -0,0 +1,84 @@ +package com.opentest.dashboard.api.channel; + +import java.util.Locale; + +public final class CanSignalUnitConversion { + public static double convert(double physicalValue, CanSignalUnits units, String target) { + if (!units.outputUnits().contains(target)) throw new IllegalArgumentException("Unsupported CAN output unit: " + target); + String source = units.sourceUnit().trim().toLowerCase(Locale.ROOT); + return switch (units.quantity()) { + case FREQUENCY -> { + double hz = switch (source) { + case "hz" -> physicalValue; + case "khz" -> physicalValue * 1000; + case "mhz" -> physicalValue * 1000000; + case "rpm", "rev/min", "r/min" -> physicalValue / 60; + default -> throw sourceError(units); + }; + yield target.equals("rpm") ? hz * 60 : hz; + } + case TACHO -> { + double hz = switch (source) { + case "hz" -> physicalValue; + case "rpm", "rev/min", "r/min" -> physicalValue * units.tachoPpr() / 60; + default -> throw sourceError(units); + }; + yield target.equals("rpm") ? hz * 60 / units.tachoPpr() : hz; + } + case ROTATIONAL_SPEED -> switch (source) { + case "rpm", "rev/min", "r/min" -> physicalValue; + default -> throw sourceError(units); + }; + case SPEED -> { + double metersPerSecond = switch (source) { + case "km/h", "kmh", "kph" -> physicalValue / 3.6; + case "m/s", "mps" -> physicalValue; + case "mph" -> physicalValue * 0.44704; + default -> throw sourceError(units); + }; + yield switch (target) { + case "km/h" -> metersPerSecond * 3.6; + case "m/s" -> metersPerSecond; + case "mph" -> metersPerSecond / 0.44704; + default -> throw new IllegalArgumentException("Unsupported CAN speed unit"); + }; + } + case TEMPERATURE -> { + double celsius = switch (source) { + case "degc", "c", "\u00b0c", "\u2103", "celsius" -> physicalValue; + case "degf", "f", "\u00b0f", "\u2109", "fahrenheit" -> (physicalValue - 32) * 5 / 9; + case "k", "kelvin" -> physicalValue - 273.15; + default -> throw sourceError(units); + }; + yield switch (target) { + case "degC" -> celsius; + case "degF" -> celsius * 9 / 5 + 32; + case "K" -> celsius + 273.15; + default -> throw new IllegalArgumentException("Unsupported CAN temperature unit"); + }; + } + case VOLTAGE -> physicalValue * switch (source) { + case "v" -> 1; + case "mv" -> 0.001; + case "uv", "\u00b5v", "\u03bcv" -> 0.000001; + case "kv" -> 1000; + default -> throw sourceError(units); + }; + case CUSTOM -> physicalValue; + }; + } + + public static double convertStored(double value, CanSignalUnits frozen, String storedUnit, String displayUnit) { + if (!frozen.outputUnits().contains(storedUnit)) + throw new IllegalArgumentException("Unsupported CAN stored unit: " + storedUnit); + if (!frozen.outputUnits().contains(displayUnit)) + throw new IllegalArgumentException("Unsupported CAN output unit: " + displayUnit); + var stored = new CanSignalUnits(frozen.quantity(), storedUnit, displayUnit, frozen.tachoPpr()); + return convert(value, stored, displayUnit); + } + + private static IllegalArgumentException sourceError(CanSignalUnits units) { + return new IllegalArgumentException("Unsupported CAN source unit for " + units.quantity() + ": " + units.sourceUnit()); + } + private CanSignalUnitConversion() { } +} diff --git a/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/channel/CanSignalUnits.java b/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/channel/CanSignalUnits.java new file mode 100644 index 00000000..623cf2db --- /dev/null +++ b/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/channel/CanSignalUnits.java @@ -0,0 +1,43 @@ +package com.opentest.dashboard.api.channel; + +import java.util.Objects; +import java.util.List; +import java.util.Locale; + +public record CanSignalUnits(CanSignalQuantity quantity, String sourceUnit, String outputUnit, Integer tachoPpr) { + public CanSignalUnits { + Objects.requireNonNull(quantity, "quantity"); + Objects.requireNonNull(sourceUnit, "sourceUnit"); + Objects.requireNonNull(outputUnit, "outputUnit"); + if (quantity == CanSignalQuantity.TACHO && (tachoPpr == null || tachoPpr <= 0)) + throw new IllegalArgumentException("Tacho PPR must be positive"); + if (quantity != CanSignalQuantity.TACHO && tachoPpr != null) + throw new IllegalArgumentException("PPR applies only to Tacho"); + String source = sourceUnit.trim().toLowerCase(Locale.ROOT); + boolean supported = switch (quantity) { + case FREQUENCY -> List.of("hz", "khz", "mhz", "rpm", "rev/min", "r/min").contains(source); + case TACHO -> List.of("hz", "rpm", "rev/min", "r/min").contains(source); + case ROTATIONAL_SPEED -> List.of("rpm", "rev/min", "r/min").contains(source); + case SPEED -> List.of("km/h", "kmh", "kph", "m/s", "mps", "mph").contains(source); + case TEMPERATURE -> List.of("degc", "c", "\u00b0c", "\u2103", "celsius", "degf", "f", "\u00b0f", "\u2109", "fahrenheit", "k", "kelvin").contains(source); + case VOLTAGE -> List.of("v", "mv", "uv", "\u00b5v", "\u03bcv", "kv").contains(source); + case CUSTOM -> true; + }; + if (!supported) throw new IllegalArgumentException("Unsupported CAN source unit for " + quantity + ": " + sourceUnit); + if (!outputUnits(quantity, outputUnit).contains(outputUnit)) + throw new IllegalArgumentException("Unsupported CAN output unit for " + quantity + ": " + outputUnit); + } + + public List outputUnits() { return outputUnits(quantity, outputUnit); } + + private static List outputUnits(CanSignalQuantity quantity, String customUnit) { + return switch (quantity) { + case FREQUENCY, TACHO -> List.of("Hz", "rpm"); + case ROTATIONAL_SPEED -> List.of("rpm"); + case SPEED -> List.of("km/h", "m/s", "mph"); + case TEMPERATURE -> List.of("degC", "degF", "K"); + case VOLTAGE -> List.of("V"); + case CUSTOM -> List.of(customUnit); + }; + } +} diff --git a/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/channel/ChannelCatalog.java b/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/channel/ChannelCatalog.java index 458e8920..157662b7 100644 --- a/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/channel/ChannelCatalog.java +++ b/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/channel/ChannelCatalog.java @@ -1,6 +1,7 @@ package com.opentest.dashboard.api.channel; import com.opentest.dashboard.api.unit.UnitChannelFacts; +import com.opentest.dashboard.api.capability.CanChannelFacts; import java.util.Collections; import java.util.EnumMap; import java.util.LinkedHashMap; @@ -14,6 +15,7 @@ public final class ChannelCatalog { private final Map unambiguous; private final Map> unboundSlots; private final Map> currentUnits; + private final CanChannelFacts canInputs; /** Current presentation facts do not declare an acquisition clock or hardware binding. */ public record CurrentUnitFacts(UnitChannelFacts units, String displayName) { @@ -33,6 +35,12 @@ public ChannelCatalog(Map> channe public ChannelCatalog(Map> channels, Map> unboundSlots, Map> currentUnits) { + this(channels, unboundSlots, currentUnits, CanChannelFacts.empty()); + } + + public ChannelCatalog(Map> channels, + Map> unboundSlots, + Map> currentUnits, CanChannelFacts canInputs) { var copy = new EnumMap>(ChannelDirection.class); Objects.requireNonNull(channels, "Channel facts are required").forEach((direction, facts) -> { Objects.requireNonNull(direction, "Channel direction is required"); @@ -69,6 +77,13 @@ public ChannelCatalog(Map> channe units.put(direction, Collections.unmodifiableMap(checked)); }); this.currentUnits = Collections.unmodifiableMap(units); + this.canInputs = Objects.requireNonNull(canInputs, "canInputs"); + for (String id : canInputs.channels().keySet()) { + if (copy.getOrDefault(ChannelDirection.INPUT, Map.of()).containsKey(id) + || slots.getOrDefault(ChannelDirection.INPUT, Set.of()).contains(id) + || units.getOrDefault(ChannelDirection.INPUT, Map.of()).containsKey(id)) + throw new IllegalArgumentException("CAN identity collides with sampled input: " + id); + } } private ChannelCatalog(Map channels, boolean globallyUnique) { @@ -76,8 +91,11 @@ private ChannelCatalog(Map channels, boolean globallyUn unambiguous = checked(channels); unboundSlots = Map.of(); currentUnits = Map.of(); + canInputs = CanChannelFacts.empty(); } + public CanChannelFacts canInputs() { return canInputs; } + public CurrentUnitFacts currentUnitFacts(ChannelDirection direction, String id) { return currentUnitFacts(direction).get(id); } diff --git a/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/measurement/recorded/RecordedOutputSelection.java b/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/measurement/recorded/RecordedOutputSelection.java index 349240dd..d5dfa004 100644 --- a/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/measurement/recorded/RecordedOutputSelection.java +++ b/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/measurement/recorded/RecordedOutputSelection.java @@ -3,15 +3,40 @@ import java.util.Map; import java.util.Objects; import com.opentest.dashboard.api.channel.ChannelMetadata; +import com.opentest.dashboard.api.channel.CanSignalChannel; import com.opentest.dashboard.api.internal.ImmutableValues; import com.opentest.dashboard.api.unit.*; /** Frozen display selection and member declaration; file units are interpreted separately. */ public record RecordedOutputSelection(RecordedPlanSelection result, ChannelMetadata channel, GraphicUnitResolution declaredUnits, UnitCombination displayUnits, - Long graphicId, Map graphic) { + Long graphicId, Map graphic, Source source) { + public sealed interface Source permits SampledSource, CanSource { } + public record SampledSource(ChannelMetadata metadata) implements Source { + public SampledSource { Objects.requireNonNull(metadata); } + } + public record CanSource(CanSignalChannel channel) implements Source { + public CanSource { Objects.requireNonNull(channel); } + } + public RecordedOutputSelection(RecordedPlanSelection result, ChannelMetadata channel, + GraphicUnitResolution declaredUnits, UnitCombination displayUnits, Long graphicId, Map graphic) { + this(result, channel, declaredUnits, displayUnits, graphicId, graphic, new SampledSource(channel)); + } + public static RecordedOutputSelection can(RecordedPlanSelection result, CanSignalChannel channel, + GraphicUnitResolution declaredUnits, UnitCombination displayUnits, Long graphicId, Map graphic) { + return new RecordedOutputSelection(result, null, declaredUnits, displayUnits, graphicId, graphic, new CanSource(channel)); + } + public ChannelMetadata channel() { + if (source instanceof SampledSource sampled) return sampled.metadata(); + throw new IllegalArgumentException("Recorded CAN output has no sampled channel metadata"); + } public RecordedOutputSelection { - Objects.requireNonNull(result); Objects.requireNonNull(channel); + Objects.requireNonNull(result); Objects.requireNonNull(source); + String memberId = source instanceof SampledSource sampled ? sampled.metadata().vchId() : ((CanSource)source).channel().vchId(); + if (!result.memberId().equals(memberId)) throw new IllegalArgumentException("Recorded output member differs from its source"); + if (source instanceof SampledSource sampled && !sampled.metadata().equals(channel) + || source instanceof CanSource && channel != null) + throw new IllegalArgumentException("Recorded output source disagrees with sampled metadata"); Objects.requireNonNull(declaredUnits); Objects.requireNonNull(displayUnits); graphic = ImmutableValues.jsonMap(graphic); } diff --git a/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/pipeline/CapabilityRegistry.java b/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/pipeline/CapabilityRegistry.java index 9e3bbaa4..1f98a73a 100644 --- a/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/pipeline/CapabilityRegistry.java +++ b/apps/backend/opentest-dashboard-api/src/main/java/com/opentest/dashboard/api/pipeline/CapabilityRegistry.java @@ -1,6 +1,8 @@ package com.opentest.dashboard.api.pipeline; import com.opentest.dashboard.api.capability.CaptureStages; +import com.opentest.dashboard.api.capability.CanChannelFacts; +import com.opentest.dashboard.api.capability.CanSignalInputs; import com.opentest.dashboard.api.capability.ResultStorageMode; import com.opentest.dashboard.api.capability.CaptureFrameStore; import com.opentest.dashboard.api.capability.LiveResultOutput; @@ -32,6 +34,8 @@ final class CapabilityRegistry { private static final Set OFFICIAL_CAPABILITY_TYPES = Set.of( DoubleArrayPool.class.getName(), CaptureStages.class.getName(), + CanChannelFacts.class.getName(), + CanSignalInputs.class.getName(), CaptureFrameStore.Factory.class.getName(), LiveResultOutput.class.getName(), ExecutionStatePublisher.class.getName(), diff --git a/apps/backend/opentest-dashboard-api/src/test/java/com/opentest/dashboard/api/CanChannelFactsContractTest.java b/apps/backend/opentest-dashboard-api/src/test/java/com/opentest/dashboard/api/CanChannelFactsContractTest.java new file mode 100644 index 00000000..38f07011 --- /dev/null +++ b/apps/backend/opentest-dashboard-api/src/test/java/com/opentest/dashboard/api/CanChannelFactsContractTest.java @@ -0,0 +1,107 @@ +package com.opentest.dashboard.api; + +import com.opentest.dashboard.api.capability.CanChannelFacts; +import com.opentest.dashboard.api.capability.CanSignalBatch; +import com.opentest.dashboard.api.capability.CanSignalEvent; +import com.opentest.dashboard.api.channel.CanPortBinding; +import com.opentest.dashboard.api.channel.CanSignalChannel; +import com.opentest.dashboard.api.channel.CanSignalQuantity; +import com.opentest.dashboard.api.channel.CanSignalUnits; +import com.opentest.dashboard.api.channel.ChannelCatalog; +import com.opentest.dashboard.api.channel.ChannelDirection; +import com.opentest.dashboard.api.channel.ChannelMetadata; +import com.opentest.dashboard.api.channel.SignalType; +import java.math.BigInteger; +import java.util.ArrayList; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class CanChannelFactsContractTest { + @Test void catalogueKeepsCanOutsideSampledAndUnboundDirectories() { + var channels = new LinkedHashMap(); + channels.put("can", channel()); + var facts = new CanChannelFacts(channels); + channels.clear(); + var catalogue = new ChannelCatalog(Map.of(), Map.of(), Map.of(), facts); + assertEquals(List.of("can"), new ArrayList<>(catalogue.canInputs().channels().keySet())); + assertNull(catalogue.get(ChannelDirection.INPUT, "can")); + assertTrue(catalogue.byId().isEmpty()); + assertTrue(catalogue.channels(ChannelDirection.INPUT).isEmpty()); + assertTrue(catalogue.unboundSlots(ChannelDirection.INPUT).isEmpty()); + assertTrue(catalogue.currentUnitFacts(ChannelDirection.INPUT).isEmpty()); + assertTrue(new ChannelCatalog(Map.of()).canInputs().channels().isEmpty()); + assertThrows(UnsupportedOperationException.class, () -> facts.channels().clear()); + assertThrows(IllegalArgumentException.class, () -> new CanChannelFacts(Map.of("wrong", channel()))); + assertThrows(IllegalArgumentException.class, () -> new ChannelCatalog(Map.of(), + Map.of(ChannelDirection.INPUT, Set.of("can")), Map.of(), facts)); + var sampled = new ChannelMetadata("can", SignalType.VOLTAGE, 48000, "FS", null, 2D, null); + assertThrows(IllegalArgumentException.class, () -> new ChannelCatalog( + Map.of(ChannelDirection.INPUT, Map.of("can", sampled)), Map.of(), Map.of(), facts)); + } + + @Test void orderedEventsAndExactProvenanceAreImmutableAndLossCanRemainUnknown() { + var provenance = new LinkedHashMap(); + var times = new ArrayList<>(List.of("18446744073709551615")); + provenance.put("timestamps", times); + var valid = new CanSignalEvent.ValidSample("can", 17.25, provenance); + times.clear(); provenance.clear(); + assertEquals(List.of("18446744073709551615"), valid.provenance().get("timestamps")); + assertThrows(UnsupportedOperationException.class, () -> valid.provenance().put("raw", "0")); + var events = new ArrayList(List.of(valid)); + var batch = new CanSignalBatch(1.25, events); + events.clear(); + assertEquals(List.of(valid), batch.events()); + assertThrows(UnsupportedOperationException.class, () -> batch.events().clear()); + assertNull(new CanSignalEvent.LossGap("can", null, Map.of()).droppedCount()); + assertEquals(new BigInteger("18446744073709551615"), new CanSignalEvent.LossGap("can", + new BigInteger("18446744073709551615"), Map.of()).droppedCount()); + assertThrows(IllegalArgumentException.class, () -> new CanSignalEvent.LossGap("can", BigInteger.valueOf(-1), Map.of())); + assertThrows(IllegalArgumentException.class, () -> new CanSignalEvent.ValidSample("can", Double.NaN, Map.of())); + assertThrows(IllegalArgumentException.class, () -> new CanSignalBatch(Double.POSITIVE_INFINITY, List.of())); + assertThrows(IllegalArgumentException.class, () -> new CanSignalBatch(-1, List.of())); + } + + @Test void quantitySourceOutputAndPprAreValidatedAtConstruction() { + for (var quantity : CanSignalQuantity.values()) { + String source = switch (quantity) { + case FREQUENCY, TACHO -> "Hz"; + case ROTATIONAL_SPEED -> "rpm"; + case SPEED -> "m/s"; + case TEMPERATURE -> "degC"; + case VOLTAGE -> "mV"; + case CUSTOM -> "user text"; + }; + String output = switch (quantity) { + case FREQUENCY, TACHO, ROTATIONAL_SPEED -> "rpm"; + case SPEED -> "mph"; + case TEMPERATURE -> "degF"; + case VOLTAGE -> "V"; + case CUSTOM -> "display text"; + }; + Integer ppr = quantity == CanSignalQuantity.TACHO ? 48 : null; + var units = new CanSignalUnits(quantity, source, output, ppr); + assertTrue(units.outputUnits().contains(output)); + if (quantity != CanSignalQuantity.CUSTOM) { + assertThrows(IllegalArgumentException.class, () -> new CanSignalUnits(quantity, "invalid source", output, ppr)); + assertThrows(IllegalArgumentException.class, () -> new CanSignalUnits(quantity, source, "invalid output", ppr)); + } + } + assertThrows(IllegalArgumentException.class, () -> new CanSignalUnits(CanSignalQuantity.TACHO, "Hz", "rpm", null)); + assertThrows(IllegalArgumentException.class, () -> new CanSignalUnits(CanSignalQuantity.TACHO, "Hz", "rpm", -1)); + assertThrows(IllegalArgumentException.class, () -> new CanSignalUnits(CanSignalQuantity.FREQUENCY, "Hz", "rpm", 48)); + assertThrows(IllegalArgumentException.class, () -> new CanSignalUnits(CanSignalQuantity.ROTATIONAL_SPEED, "Hz", "rpm", null)); + } + + private static CanSignalChannel channel() { + return new CanSignalChannel("can", "1", "2", "CAN 1", 1, + new CanPortBinding("device", "CAN", "serial", "can0"), "{\"schemaVersion\":1}", + new CanSignalUnits(CanSignalQuantity.VOLTAGE, "mV", "V", null), "fingerprint"); + } +} diff --git a/apps/backend/opentest-dashboard-api/src/test/java/com/opentest/dashboard/api/channel/CanSignalUnitConversionTest.java b/apps/backend/opentest-dashboard-api/src/test/java/com/opentest/dashboard/api/channel/CanSignalUnitConversionTest.java new file mode 100644 index 00000000..d00a4e1a --- /dev/null +++ b/apps/backend/opentest-dashboard-api/src/test/java/com/opentest/dashboard/api/channel/CanSignalUnitConversionTest.java @@ -0,0 +1,50 @@ +package com.opentest.dashboard.api.channel; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class CanSignalUnitConversionTest { + @Test void storedFahrenheitConvertsFromItsStoredUnitInsteadOfTheOriginalCelsiusSource() { + var frozen = new CanSignalUnits(CanSignalQuantity.TEMPERATURE, "degC", "degF", null); + + assertEquals(24.64, CanSignalUnitConversion.convertStored(76.352, frozen, "degF", "degC"), 1e-8); + assertEquals(76.352, CanSignalUnitConversion.convertStored(24.64, frozen, "degC", "degF"), 1e-8); + } + + @Test void storedFrequencyAndTachoKeepTheirDistinctPulseSemanticsInBothDirections() { + var frequency = new CanSignalUnits(CanSignalQuantity.FREQUENCY, "kHz", "rpm", null); + assertEquals(480, CanSignalUnitConversion.convertStored(8, frequency, "Hz", "rpm"), 1e-8); + assertEquals(8, CanSignalUnitConversion.convertStored(480, frequency, "rpm", "Hz"), 1e-8); + + var tacho = new CanSignalUnits(CanSignalQuantity.TACHO, "Hz", "rpm", 48); + assertEquals(600, CanSignalUnitConversion.convertStored(480, tacho, "Hz", "rpm"), 1e-8); + assertEquals(480, CanSignalUnitConversion.convertStored(600, tacho, "rpm", "Hz"), 1e-8); + } + + @Test void storedVoltageDoesNotApplyItsOriginalSourcePrefixAgain() { + var frozen = new CanSignalUnits(CanSignalQuantity.VOLTAGE, "mV", "V", null); + + assertEquals(2, CanSignalUnitConversion.convertStored(2, frozen, "V", "V"), 1e-8); + } + + @Test void sourceAndStoredConversionsPreserveInvalidValueGaps() { + var frozen = new CanSignalUnits(CanSignalQuantity.TEMPERATURE, "degC", "degF", null); + + assertTrue(Double.isNaN(CanSignalUnitConversion.convert(Double.NaN, frozen, "degF"))); + assertTrue(Double.isNaN(CanSignalUnitConversion.convertStored(Double.NaN, frozen, "degF", "degC"))); + } + + @Test void storedAndDisplayUnitsMustBothBelongToFrozenOutputChoices() { + var frozen = new CanSignalUnits(CanSignalQuantity.VOLTAGE, "mV", "V", null); + + assertThrows(IllegalArgumentException.class, + () -> CanSignalUnitConversion.convertStored(2, frozen, "mV", "V")); + assertThrows(IllegalArgumentException.class, + () -> CanSignalUnitConversion.convertStored(2, frozen, "V", "mV")); + assertThrows(IllegalArgumentException.class, + () -> CanSignalUnitConversion.convertStored(Double.NaN, frozen, "V", "mV")); + } +} diff --git a/apps/backend/opentest-monitor-tools/plugin/locales/en-US.json b/apps/backend/opentest-monitor-tools/plugin/locales/en-US.json index fcdde72c..8d818a21 100644 --- a/apps/backend/opentest-monitor-tools/plugin/locales/en-US.json +++ b/apps/backend/opentest-monitor-tools/plugin/locales/en-US.json @@ -23,5 +23,7 @@ "results.thd-ratio": "THD Ratio", "results.crosstalk": "Crosstalk", "results.synchronization-accuracy": "Synchronization Accuracy", - "results.phase": "Phase" + "results.phase": "Phase", + "results.can-viewer": "CAN Viewer", + "results.can-value": "CAN Value" } diff --git a/apps/backend/opentest-monitor-tools/plugin/locales/zh-CN.json b/apps/backend/opentest-monitor-tools/plugin/locales/zh-CN.json index fcdde72c..7831e926 100644 --- a/apps/backend/opentest-monitor-tools/plugin/locales/zh-CN.json +++ b/apps/backend/opentest-monitor-tools/plugin/locales/zh-CN.json @@ -23,5 +23,7 @@ "results.thd-ratio": "THD Ratio", "results.crosstalk": "Crosstalk", "results.synchronization-accuracy": "Synchronization Accuracy", - "results.phase": "Phase" + "results.phase": "Phase", + "results.can-viewer": "CAN 趋势", + "results.can-value": "CAN 当前值" } diff --git a/apps/backend/opentest-monitor-tools/src/main/java/com/opentest/plugins/monitor/measure/MonitorCanProjection.java b/apps/backend/opentest-monitor-tools/src/main/java/com/opentest/plugins/monitor/measure/MonitorCanProjection.java new file mode 100644 index 00000000..c80b4ed4 --- /dev/null +++ b/apps/backend/opentest-monitor-tools/src/main/java/com/opentest/plugins/monitor/measure/MonitorCanProjection.java @@ -0,0 +1,71 @@ +package com.opentest.plugins.monitor.measure; + +import com.opentest.dashboard.api.capability.CanChannelFacts; +import com.opentest.dashboard.api.capability.CanSignalBatch; +import com.opentest.dashboard.api.capability.CanSignalEvent; +import com.opentest.dashboard.api.capability.CanSignalProjection; +import com.opentest.dashboard.api.capability.LiveResultOutput; +import com.opentest.dashboard.api.channel.CanSignalChannel; +import com.opentest.dashboard.api.measurement.ExecutionOutputs; +import com.opentest.dashboard.api.result.CompletedResultCurve; +import com.opentest.dashboard.api.result.ResultRequirement; +import java.util.List; +import java.util.LinkedHashSet; +import java.util.Objects; + +/** The host serializes delivery and closes this projector only after admitted callbacks drain. */ +final class MonitorCanProjection implements CanSignalProjection { + private record Target(ResultRequirement result, CanSignalChannel channel) { } + private final CanChannelFacts channels; + private final List targets; + private final LiveResultOutput output; + + MonitorCanProjection(CanChannelFacts channels, ExecutionOutputs outputs, LiveResultOutput output) { + this.channels = Objects.requireNonNull(channels); + this.output = Objects.requireNonNull(output); + var requirements = new LinkedHashSet(); + for (var result : outputs.results()) { + if (!MonitorCanUnits.supports(result.resultCode())) continue; + requirements.add(result); + for (var graphic : outputs.graphics()) { + if (!result.dashboardResultId().equals(graphic.dashboardResultId()) || !result.vchId().equals(graphic.vchId())) continue; + if (!result.resultCode().equals(graphic.resultCode()) || !result.hash().equals(graphic.hash())) + throw new IllegalArgumentException("CAN graphic differs from frozen result identity"); + if (Objects.equals(result.requestedUnitX(), graphic.unitX()) && Objects.equals(result.requestedUnitY(), graphic.unitY())) continue; + requirements.add(new ResultRequirement(result.dashboardResultId(), result.resultCode(), result.hash(), + result.variableParameters(), result.vchId(), graphic.unitX(), graphic.unitY(), + result.executionFacts(), result.fileUnitIdentity())); + } + } + targets = requirements.stream() + .map(result -> { + var channel = channels.channels().get(result.vchId()); + if (channel == null) throw new IllegalArgumentException("CAN output lacks frozen input: " + result.vchId()); + String x = result.resultCode().equals("CAN Viewer") ? "s" : null; + if (!Objects.equals(x, result.requestedUnitX())) + throw new IllegalArgumentException("CAN output has invalid X unit"); + MonitorCanUnits.convert(0, channel.units(), result.requestedUnitY()); + return new Target(result, channel); + }).toList(); + } + + @Override public void accept(CanSignalBatch batch) { + for (var event : batch.events()) { + if (!channels.channels().containsKey(event.vchId())) + throw new IllegalArgumentException("CAN event lacks frozen input: " + event.vchId()); + for (var target : targets) { + var result = target.result(); + if (!result.vchId().equals(event.vchId())) continue; + double value = event instanceof CanSignalEvent.ValidSample valid + ? MonitorCanUnits.convert(valid.physicalValue(), target.channel().units(), result.requestedUnitY()) + : Double.NaN; + boolean viewer = result.resultCode().equals("CAN Viewer"); + var curve = new CompletedResultCurve(result.vchId(), null, result.resultCode(), result.hash(), + viewer ? new double[]{batch.observationElapsedSeconds()} : null, new double[]{value}, + result.requestedUnitX(), result.requestedUnitY(), null, null, null, null, null, + null, null, null, null, null, null, result.dashboardResultId()); + output.observe(curve, viewer); + } + } + } +} diff --git a/apps/backend/opentest-monitor-tools/src/main/java/com/opentest/plugins/monitor/measure/MonitorCanUnits.java b/apps/backend/opentest-monitor-tools/src/main/java/com/opentest/plugins/monitor/measure/MonitorCanUnits.java new file mode 100644 index 00000000..61c4e189 --- /dev/null +++ b/apps/backend/opentest-monitor-tools/src/main/java/com/opentest/plugins/monitor/measure/MonitorCanUnits.java @@ -0,0 +1,26 @@ +package com.opentest.plugins.monitor.measure; + +import com.opentest.dashboard.api.channel.CanSignalUnitConversion; +import com.opentest.dashboard.api.channel.CanSignalUnits; +import com.opentest.dashboard.api.unit.GraphicUnitResolution; +import java.util.List; + +final class MonitorCanUnits { + static boolean supports(String code) { return code.equals("CAN Viewer") || code.equals("CAN Value"); } + + static List outputs(CanSignalUnits units) { + return units.outputUnits(); + } + + static GraphicUnitResolution resolution(String code, CanSignalUnits units) { + convert(0, units, units.outputUnit()); + return GraphicUnitResolution.choices(code.equals("CAN Viewer") ? "s" : null, + units.outputUnit(), outputs(units).toArray(String[]::new)); + } + + static double convert(double physicalValue, CanSignalUnits units, String target) { + return CanSignalUnitConversion.convert(physicalValue, units, target); + } + + private MonitorCanUnits() { } +} diff --git a/apps/backend/opentest-monitor-tools/src/main/java/com/opentest/plugins/monitor/measure/MonitorDashboardProvider.java b/apps/backend/opentest-monitor-tools/src/main/java/com/opentest/plugins/monitor/measure/MonitorDashboardProvider.java index 5d2bb565..c3f3220b 100644 --- a/apps/backend/opentest-monitor-tools/src/main/java/com/opentest/plugins/monitor/measure/MonitorDashboardProvider.java +++ b/apps/backend/opentest-monitor-tools/src/main/java/com/opentest/plugins/monitor/measure/MonitorDashboardProvider.java @@ -11,6 +11,8 @@ import com.opentest.algorithm.api.AlgorithmService; import com.opentest.algorithm.api.SignalAlgorithmService; import com.opentest.dashboard.api.capability.AudioPreviewOutput; +import com.opentest.dashboard.api.capability.CanChannelFacts; +import com.opentest.dashboard.api.capability.CanSignalInputs; import com.opentest.dashboard.api.capability.GeneratorConfigurationView; import com.opentest.dashboard.api.capability.MeasurementCalculationMode; import com.opentest.dashboard.api.capability.RecordedInputTopology; @@ -18,6 +20,7 @@ import com.opentest.dashboard.api.capability.SavedRecordingFacts; import com.opentest.dashboard.api.capability.SavedResultCatalog; import com.opentest.dashboard.api.channel.ChannelMetadata; +import com.opentest.dashboard.api.channel.ChannelCatalog; import com.opentest.dashboard.api.channel.ChannelDirection; import com.opentest.dashboard.api.definition.ResultSetConfig; import com.opentest.dashboard.api.definition.ResultSetDefinition; @@ -88,6 +91,8 @@ private static ResultSetDefinition savedIdentity(ResultSetDefinition result, } @Override public GraphicUnitResolution resolveGraphicUnits( com.opentest.dashboard.api.measurement.GraphicUnitQuery query) { + if (query.resultFacts() != null && MonitorCanUnits.supports(query.resultFacts().resultCode())) + return query.requireDeclaredUnits(); if (query.scene() == GraphicUnitScene.CURRENT_VIEW && query.resultFacts() != null) MonitorAmplitudeUnits.validate(query.resultFacts().resultCode(), query.resultFacts().variableParameters(), query.resultFacts().custom().get("parametersPresent") instanceof Boolean present ? present : null); @@ -131,6 +136,14 @@ private static ResultSetDefinition savedIdentity(ResultSetDefinition result, execution.selectCollectConfiguration(Optional.empty()); execution.validateInputs(); var channels=execution.prepareInputs(Optional.empty()); + var canFacts = CanChannelFacts.empty(); + CanSignalInputs canInputs; + try { canInputs = execution.service(CanSignalInputs.class); } + catch (IllegalStateException absent) { canInputs = null; } + if (canInputs != null) { + canFacts = canInputs.channels(); + if (!canFacts.channels().isEmpty()) canInputs.projectWith(MonitorCanProjection::new); + } if (execution.purpose() == ExecutionInputPurpose.CAPTURE_STREAM) MonitorFilterValidation.execution(configuration, channels); var services=new LinkedHashMap,Object>(); services.put(AlgorithmService.class,execution.service(AlgorithmService.class)); @@ -147,9 +160,10 @@ private static ResultSetDefinition savedIdentity(ResultSetDefinition result, services.put(RecordedInputTopology.class,execution.service(RecordedInputTopology.class)); services.put(RecordedResultOutput.class,execution.service(RecordedResultOutput.class)); validateRecorded(channels,calculationMode,(SavedRecordingFacts)services.get(SavedRecordingFacts.class), - (SavedResultCatalog)services.get(SavedResultCatalog.class)); + (SavedResultCatalog)services.get(SavedResultCatalog.class),canFacts); } - var context=new DashboardProviderContext(index(channels),services).withInputPurpose(purpose) + var catalog = new ChannelCatalog(Map.of(ChannelDirection.INPUT, index(channels)), Map.of(), Map.of(), canFacts); + var context=new DashboardProviderContext(catalog,services).withInputPurpose(purpose) .withDefinitionPurpose(DefinitionPurpose.EXECUTION); var prepared=execution.finishPreparation(); prepared.compile(MonitorExecution.plan(configuration,parameters,context)); @@ -159,12 +173,18 @@ private static ResultSetDefinition savedIdentity(ResultSetDefinition result, static void validateRecorded(List channels,MeasurementCalculationMode mode, SavedRecordingFacts recording,SavedResultCatalog catalog){ + validateRecorded(channels,mode,recording,catalog,CanChannelFacts.empty()); + } + + static void validateRecorded(List channels,MeasurementCalculationMode mode, + SavedRecordingFacts recording,SavedResultCatalog catalog,CanChannelFacts canFacts){ var results=catalog.results().stream().map(result->{ var row=new LinkedHashMap();row.put("resultId",result.resultId()); row.put("resultCode",result.resultCode());row.put("parametersPresent",!result.parameters().isEmpty()); row.put("variableParameters",result.parameters());return Map.copyOf(row); }).toList(); var roots=mode.outputRoots()==null?List.>of():mode.outputRoots().stream() + .filter(root->!canFacts.channels().containsKey(root.vchId())) .map(root->Map.of("resultId",root.resultId(),"vchId",root.vchId())).toList(); var channelFacts=channels.stream().map(channel->Map.of("vchId",channel.vchId())).toList(); if(!roots.isEmpty())MonitorRecordedSnapshot.validatePlan(Map.of("results",results,"outputRoots",roots,"channels",channelFacts)); diff --git a/apps/backend/opentest-monitor-tools/src/main/java/com/opentest/plugins/monitor/measure/MonitorDefinitions.java b/apps/backend/opentest-monitor-tools/src/main/java/com/opentest/plugins/monitor/measure/MonitorDefinitions.java index 70910299..56bf7307 100644 --- a/apps/backend/opentest-monitor-tools/src/main/java/com/opentest/plugins/monitor/measure/MonitorDefinitions.java +++ b/apps/backend/opentest-monitor-tools/src/main/java/com/opentest/plugins/monitor/measure/MonitorDefinitions.java @@ -7,6 +7,8 @@ import java.util.Map; import java.util.Set; import com.opentest.dashboard.api.channel.ChannelDirection; +import com.opentest.dashboard.api.channel.SignalType; +import com.opentest.dashboard.api.definition.ResultChannelUnitFacts; import com.opentest.dashboard.api.definition.AxisConfig; import com.opentest.dashboard.api.definition.ChannelInputDefinition; import com.opentest.dashboard.api.definition.DashboardDefinition; @@ -45,12 +47,18 @@ else if (context.definitionPurpose() == DefinitionPurpose.CONFIGURATION_UPDATE selected = context.existingResultSets().stream() .map(row -> new ResultSetConfig(row.resultCode(), row.resultType(), row.variableParameters())).toList(); else selected = requested.isEmpty() ? defaults() : requested; - var channels = inputs.stream().map(id -> new ResultChannelDefinition(id, + var canInputs = context.channelFacts().canInputs().channels(); + var sampledChannels = inputs.stream().filter(id -> !canInputs.containsKey(id)).map(id -> new ResultChannelDefinition(id, inputDisplayName(context, id), ChannelDirection.INPUT)).toList(); var results = new ArrayList(); var graphics = new ArrayList(); for (var selection : selected) { var template = MonitorResultCatalog.find(selection.resultCode(), selection.resultType().ordinal()); + boolean can = MonitorCanUnits.supports(template.code()); + var channels = can ? inputs.stream().filter(canInputs::containsKey).map(canInputs::get) + .map(channel -> new ResultChannelDefinition(channel.vchId(), channel.displayName(), ChannelDirection.INPUT, + null, new ResultChannelUnitFacts(SignalType.UNKNOWN, channel.units().sourceUnit(), + MonitorCanUnits.resolution(template.code(), channel.units()), false))).toList() : sampledChannels; String hash = ResultHashes.generateAlgorithmHash(selection.resultCode(), selection.variableParameters()); var saved = context.existingResultSets().stream().filter(row -> row.resultCode().equals(selection.resultCode()) && row.resultType() == selection.resultType() && row.variableParameters().equals(selection.variableParameters())).toList(); @@ -75,13 +83,13 @@ else if (context.definitionPurpose() == DefinitionPurpose.CONFIGURATION_UPDATE case "Crosstalk"->List.of("frequencyPoint"); default->List.of(); }); - custom.put("unitRule", MonitorUnits.rule(template.code())); + if (!can) custom.put("unitRule", MonitorUnits.rule(template.code())); var presentation=new LinkedHashMap(); presentation.put("defaultGraphic",defaultGraphic(template));presentation.put("axisNameFromResult",true); presentation.put("physicalChannelDisplayProjection", true); presentation.put("isolatedWaveformSelection", template.code().equals("Scope Waveform")); presentation.put("multiValueSelection", template.graphicType() == 10); - presentation.put("projectUnconfiguredSlots", true); + presentation.put("projectUnconfiguredSlots", !can); presentation.put("waveformUnitsX", TimeAxisDisplayUnits.choices(List.of("s"), !template.code().equals("Scope Waveform"))); presentation.put("explicitAmplitudeBasis", true); @@ -104,7 +112,7 @@ else if (Set.of("Cross Spectrum", "Cross Spectrum Real", "Cross Spectrum Imagina DomainType.valueOf(template.domain())))); if (context.definitionPurpose() == DefinitionPurpose.INITIALIZATION && template.defaultGraphic()) graphics.add(new GraphicDefinition(List.of(new ResultSetReference(template.code(), hash, selection.resultType())), - GraphicType.values()[template.graphicType()], null, inputs.isEmpty() || template.graphicType()==10 ? null : axis(template.yConfig()), inputs.stream().sorted().toList(), true, presentation(template))); + GraphicType.values()[template.graphicType()], null, channels.isEmpty() || template.graphicType()==10 ? null : axis(template.yConfig()), channels.stream().map(ResultChannelDefinition::vchId).sorted().toList(), true, presentation(template))); } return new DashboardDefinition(new ChannelInputDefinition(inputs), results, graphics, "monitor"); } diff --git a/apps/backend/opentest-monitor-tools/src/main/java/com/opentest/plugins/monitor/measure/MonitorRecordedUse.java b/apps/backend/opentest-monitor-tools/src/main/java/com/opentest/plugins/monitor/measure/MonitorRecordedUse.java index cca64eba..6c197ce7 100644 --- a/apps/backend/opentest-monitor-tools/src/main/java/com/opentest/plugins/monitor/measure/MonitorRecordedUse.java +++ b/apps/backend/opentest-monitor-tools/src/main/java/com/opentest/plugins/monitor/measure/MonitorRecordedUse.java @@ -28,7 +28,9 @@ public final class MonitorRecordedUse implements RecordedUseContribution query){ requirePurpose(query.purpose()); - var results=query.selections().stream().map(selection->Map.of( + var results=query.selections().stream() + .filter(selection->selection.source() instanceof RecordedOutputSelection.SampledSource) + .map(selection->Map.of( "resultCode",selection.result().resultCode(),"parametersPresent",!selection.result().variableParameters().isEmpty(), "variableParameters",selection.result().variableParameters())).toList(); var errors=MonitorRecordedSnapshot.validate(query.recording().values(),results); @@ -42,11 +44,13 @@ public RecordedOutputAvailability availability(RecordedOutputSelection selection public long progressMillis(long rawMillis){return rawMillis;} public UnitCombination fileUnits(RecordedOutputSelection selection){ Objects.requireNonNull(selection); - return MonitorRecordedUse.fileUnits(selection.displayUnits()); + return selection.source() instanceof RecordedOutputSelection.CanSource + ? selection.displayUnits() : MonitorRecordedUse.fileUnits(selection.displayUnits()); } }; } static RecordedOutputAvailability availability(RecordedOutputSelection selection,List channels){ + if(selection.source() instanceof RecordedOutputSelection.CanSource)return RecordedOutputAvailability.REQUIRED; if(!"Crosstalk".equals(selection.result().resultCode()))return RecordedOutputAvailability.REQUIRED; Object base=selection.result().variableParameters().get("baseChannel"); var reference=channels.stream().filter(channel->channel.vchId().equals(base)).findFirst().orElseThrow( diff --git a/apps/backend/opentest-monitor-tools/src/main/java/com/opentest/plugins/monitor/measure/MonitorResultCatalog.java b/apps/backend/opentest-monitor-tools/src/main/java/com/opentest/plugins/monitor/measure/MonitorResultCatalog.java index 75c3d8f5..69def0e5 100644 --- a/apps/backend/opentest-monitor-tools/src/main/java/com/opentest/plugins/monitor/measure/MonitorResultCatalog.java +++ b/apps/backend/opentest-monitor-tools/src/main/java/com/opentest/plugins/monitor/measure/MonitorResultCatalog.java @@ -46,7 +46,9 @@ record Template(String code, int resultType, int graphicType, String domain, Str new Template("THD Level", 3, 10, "TIME_DOMAIN", "s", "dBFS", null, false, true, Map.of(), Map.of(), Map.of()), new Template("THD Ratio", 3, 10, "TIME_DOMAIN", "s", "x/y", null, true, true, Map.of(), Map.of(), Map.of()), new Template("Crosstalk", 3, 10, "TIME_DOMAIN", "s", "dB", null, true, true, Map.of(), Map.of(), Map.ofEntries(Map.entry("primaryCode", "Crosstalk"), Map.entry("baseChannel", "Ch1"), Map.entry("mode", "GENERATOR"))), - new Template("Synchronization Accuracy", 3, 10, "TIME_DOMAIN", "s", "s", null, false, true, Map.of(), Map.of(), Map.ofEntries(Map.entry("primaryCode", "Synchronization Accuracy"), Map.entry("baseChannel", "")))); + new Template("Synchronization Accuracy", 3, 10, "TIME_DOMAIN", "s", "s", null, false, true, Map.of(), Map.of(), Map.ofEntries(Map.entry("primaryCode", "Synchronization Accuracy"), Map.entry("baseChannel", ""))), + new Template("CAN Viewer", 2, 2, "TIME_DOMAIN", "s", null, "results.can-viewer", false, true, Map.of(), Map.of(), Map.of()), + new Template("CAN Value", 3, 10, "TIME_DOMAIN", null, null, "results.can-value", false, true, Map.of(), Map.of(), Map.of())); // The legacy add endpoint accepts saved Meter Phase rows, although the initializer omits them. private static final List