diff --git a/src/Main.cpp b/src/Main.cpp index 83df3aa78..88521cd3f 100644 --- a/src/Main.cpp +++ b/src/Main.cpp @@ -46,6 +46,7 @@ #include "NativeMixerSessionSaveWorker.h" #include "NativeLogicalMixerControl.h" #include "PlayerSetlistArchive.h" +#include "PlayerSetlistRepository.h" #include "NativeHotkeyRegistry.h" #include "NativeHotkeyCommandPlan.h" #include "NativeFxParameterHotkey.h" @@ -3907,40 +3908,35 @@ class ConsoleWindow final : public juce::DocumentWindow, private juce::Timer, pr playerOutputPendingIndex_=-1; playerUndoRemove_={}; } - // Player archive owns only v1/v2/v3 JSON policy and deterministic mapping. - // ConsoleWindow retains the sole disk writer, set activation and deck. + // The repository owns only durable Player JSON I/O. ConsoleWindow + // retains the single deck, live selection and accepted native control. void restorePlayerLibrary() { playerSets_.clear(); - const auto file=settingsDirectory().getChildFile("player-library.json"); - if(!file.existsAsFile()) { + auto result=armix::player::PlayerSetlistRepository::load( + settingsDirectory().getChildFile("player-library.json")); + if(result.status==armix::player::PlayerSetlistRepository::LoadStatus::missing) { playerSets_.push_back({"My Setlist",{},{}}); return; } - auto parsed=armix::player::PlayerSetlistArchive::parse( - juce::JSON::parse(file.loadFileAsString())); - if(!parsed) { + if(!result.document) { playerSets_.push_back({"My Setlist",{},{}}); playerError_="Setlists could not be read; no music files were changed"; return; } - playerSets_=std::move(parsed->sets); - activatePlayerSet(parsed->active); - playerAutoNext_=parsed->autoNext; - playerFadeMilliseconds_=parsed->fadeMs; + auto& parsed=*result.document; + playerSets_=std::move(parsed.sets); + activatePlayerSet(parsed.active); + playerAutoNext_=parsed.autoNext; + playerFadeMilliseconds_=parsed.fadeMs; } void persistPlayerLibrary() { saveActivePlayerSet(); - const auto document=armix::player::PlayerSetlistArchive::serialize( + const auto result=armix::player::PlayerSetlistRepository::save( + settingsDirectory().getChildFile("player-library.json"), playerSets_,playerActiveSet_,playerAutoNext_,playerFadeMilliseconds_); - if(!document.isObject()) { + if(result==armix::player::PlayerSetlistRepository::SaveStatus::invalidState) playerError_="Unable to save setlists; invalid setlist state"; - return; - } - const auto target=settingsDirectory().getChildFile("player-library.json"); - juce::TemporaryFile staging(target); - if(!staging.getFile().replaceWithText( - juce::JSON::toString(document,false)) || - !staging.overwriteTargetFileWithTemporary()) + else if(result==armix::player::PlayerSetlistRepository::SaveStatus::ioError) playerError_="Unable to save setlists; check folder permissions"; } bool playerShowMaySwitchSet() { diff --git a/src/PlayerSetlistRepository.h b/src/PlayerSetlistRepository.h new file mode 100644 index 000000000..4f76b4c71 --- /dev/null +++ b/src/PlayerSetlistRepository.h @@ -0,0 +1,44 @@ +// SPDX-License-Identifier: AGPL-3.0-only +#pragma once +#include "PlayerSetlistArchive.h" +#include +#include + +// N-MOD-15: one control-thread disk boundary around the pure Player archive. +// Callers still own the active deck, song selection, engine and status ACK. +// This class never manipulates media paths, PCM, WebView or session routing. +namespace armix::player { +class PlayerSetlistRepository final { +public: + enum class LoadStatus { missing, loaded, invalid }; + enum class SaveStatus { saved, invalidState, ioError }; + struct LoadResult { + LoadStatus status; + std::optional document; + }; + static LoadResult load(const juce::File& target) { + if (!target.existsAsFile()) + return {LoadStatus::missing,std::nullopt}; + auto parsed=PlayerSetlistArchive::parse( + juce::JSON::parse(target.loadFileAsString())); + if (!parsed)return {LoadStatus::invalid,std::nullopt}; + return {LoadStatus::loaded,std::move(parsed)}; + } + static SaveStatus save(const juce::File& target, + const std::vector& sets, + int active,bool autoNext,int fadeMs) { + // Do not begin writing until *every* set is loadable by the codec. + const auto document=PlayerSetlistArchive::serialize( + sets,active,autoNext,fadeMs); + if (!document.isObject())return SaveStatus::invalidState; + // JUCE creates a sibling staging file and replaces only after the + // complete payload was written. Never mutate live media files. + juce::TemporaryFile staging(target); + if (!staging.getFile().replaceWithText( + juce::JSON::toString(document,false)) || + !staging.overwriteTargetFileWithTemporary()) + return SaveStatus::ioError; + return SaveStatus::saved; + } +}; +} // namespace armix::player diff --git a/tests/native_caption_wire_geometry_contract.test.cjs b/tests/native_caption_wire_geometry_contract.test.cjs index 00657552b..e1a879d30 100644 --- a/tests/native_caption_wire_geometry_contract.test.cjs +++ b/tests/native_caption_wire_geometry_contract.test.cjs @@ -138,6 +138,17 @@ assert.match(main, /PlayerSetlistArchive::canUndoRemove/); assert.match(main, /Setlist is full; remove a song before undoing/); assert.doesNotMatch(main, /const int next=static_cast\(playerSets_\.size\(\)\)\+1/); assert.match(main, /using PlayerTrackSettings=armix::player::PlayerTrackSettings/); +const playerRepository=read('src/PlayerSetlistRepository.h'); +assert.match(playerRepository, /class PlayerSetlistRepository final/); +assert.match(playerRepository, /juce::TemporaryFile staging\(target\)/); +assert.match(playerRepository, /overwriteTargetFileWithTemporary\(\)/); +assert.match(main, /PlayerSetlistRepository::load/); +assert.match(main, /PlayerSetlistRepository::save/); +const persistence=main.slice(main.indexOf('void restorePlayerLibrary()'), + main.indexOf('bool playerShowMaySwitchSet()')); +assert.doesNotMatch(persistence, + /JSON::parse|JSON::toString|loadFileAsString|replaceWithText|juce::TemporaryFile/); + const cuePolicy=read('engine/player/PlayerCueEditPolicy.h'); assert.match(cuePolicy, /struct PlayerCueEditPolicy/); assert.match(main, /CuePolicy::plan/); diff --git a/tests/player_setlist_archive_test.cpp b/tests/player_setlist_archive_test.cpp index 431425598..9b15c4259 100644 --- a/tests/player_setlist_archive_test.cpp +++ b/tests/player_setlist_archive_test.cpp @@ -6,6 +6,7 @@ #include #include #include "../src/PlayerSetlistArchive.h" +#include "../src/PlayerSetlistRepository.h" using Archive=armix::player::PlayerSetlistArchive; using SavedSet=armix::player::PlayerSavedSet; @@ -225,6 +226,48 @@ int main() { full[0].controls.insert(full[0].controls.begin()+1000,removedPreset); assert(!Archive::serialize(full,0,false,180).isObject()); + // N-MOD-15: REAL disk adapter regression. Use an isolated directory, + // never the operator's settings or media library. + using Store=armix::player::PlayerSetlistRepository; + const auto sandbox=juce::File::getSpecialLocation( + juce::File::tempDirectory).getChildFile( + "arsonmix-nmod15-"+juce::Uuid().toString()); + assert(sandbox.createDirectory().wasOk()); + const auto target=sandbox.getChildFile("player-library.json"); + assert(Store::load(target).status==Store::LoadStatus::missing); + assert(Store::save(target,doc->sets,doc->active,true,250) + ==Store::SaveStatus::saved); + const auto roundTrip=Store::load(target); + assert(roundTrip.status==Store::LoadStatus::loaded); + assert(roundTrip.document && roundTrip.document->sets.size()==2); + assert(roundTrip.document->active==1 && roundTrip.document->autoNext); + assert(roundTrip.document->fadeMs==250); + assert(roundTrip.document->sets[0].controls[0].cueOut==9.0); + const auto acceptedBytes=target.loadFileAsString(); + assert(Store::save(target,broken,0,false,180) + ==Store::SaveStatus::invalidState); + assert(target.loadFileAsString()==acceptedBytes); + // An invalid parent (it is a regular file, NOT a folder) must fail + // atomically without modifying the already accepted setlist. + const auto notDirectory=sandbox.getChildFile("not-a-directory"); + assert(notDirectory.replaceWithText("must not be replaced")); + const auto blocked=notDirectory.getChildFile("player-library.json"); + assert(Store::save(blocked,doc->sets,doc->active,true,250) + ==Store::SaveStatus::ioError); + assert(notDirectory.loadFileAsString()=="must not be replaced"); + assert(target.loadFileAsString()==acceptedBytes); + assert(target.replaceWithText("{bad JSON")); + assert(Store::load(target).status==Store::LoadStatus::invalid); + assert(target.loadFileAsString()=="{bad JSON"); + // A valid operator save recovers a corrupt archive without touching + // the media paths referenced by song records. + assert(Store::save(target,fullReload->sets,0,false,180) + ==Store::SaveStatus::saved); + const auto largeReload=Store::load(target); + assert(largeReload.document && largeReload.document->sets[0].files.size()==2000); + assert(largeReload.document->sets[0].controls.size()==2000); + assert(sandbox.deleteRecursively()); + // Legacy empty v3 content migrates to a non-destructive default setlist. const auto empty=Archive::parse(juce::JSON::parse("{\"version\":3}")); assert(empty && empty->sets.size()==1);