implements packer PR-05 sensitive mutations and studio write adapter

This commit is contained in:
2026-03-24 13:42:42 +00:00
parent 924ab587e8
commit c4fc6e0041
9 changed files with 1039 additions and 7 deletions
@@ -56,17 +56,31 @@ public final class AssetWorkspace implements Workspace {
private String searchQuery = "";
public AssetWorkspace(ProjectReference projectReference) {
this(projectReference, new PackerBackedAssetWorkspaceService(), new FileSystemAssetWorkspaceMutationService());
this(
projectReference,
new PackerBackedAssetWorkspaceService(),
defaultWorkspaceBus(),
null);
}
public AssetWorkspace(
ProjectReference projectReference,
AssetWorkspaceService assetWorkspaceService,
AssetWorkspaceMutationService mutationService) {
this(projectReference, assetWorkspaceService, defaultWorkspaceBus(), mutationService);
}
private AssetWorkspace(
ProjectReference projectReference,
AssetWorkspaceService assetWorkspaceService,
StudioWorkspaceEventBus workspaceBus,
AssetWorkspaceMutationService mutationService) {
this.projectReference = Objects.requireNonNull(projectReference, "projectReference");
this.assetWorkspaceService = Objects.requireNonNull(assetWorkspaceService, "assetWorkspaceService");
this.mutationService = Objects.requireNonNull(mutationService, "mutationService");
this.workspaceBus = new StudioWorkspaceEventBus(WorkspaceId.ASSETS, Container.events());
this.workspaceBus = Objects.requireNonNull(workspaceBus, "workspaceBus");
this.mutationService = mutationService == null
? new PackerBackedAssetWorkspaceMutationService(this.workspaceBus)
: Objects.requireNonNull(mutationService, "mutationService");
root.getStyleClass().add("assets-workspace");
root.setCenter(buildLayout());
@@ -98,6 +112,10 @@ public final class AssetWorkspace implements Workspace {
return state;
}
private static StudioWorkspaceEventBus defaultWorkspaceBus() {
return new StudioWorkspaceEventBus(WorkspaceId.ASSETS, Container.events());
}
private VBox buildLayout() {
inlineProgressLabel.getStyleClass().add("assets-workspace-inline-progress-label");
inlineProgressLabel.setText(Container.i18n().text(I18n.ASSETS_PROGRESS_IDLE));
@@ -699,7 +717,6 @@ public final class AssetWorkspace implements Workspace {
final AssetWorkspaceMutationPreview preview = mutationService.preview(projectReference, selectedAsset, action);
stagedMutationPreview = preview;
appendLog("Preview ready for " + actionLabel(action) + ".");
workspaceBus.publish(new StudioAssetsMutationPreviewReadyEvent(projectReference, action, 1));
renderState();
}
@@ -802,13 +819,11 @@ public final class AssetWorkspace implements Workspace {
try {
mutationService.apply(projectReference, preview);
appendLog("Applied " + actionLabel(preview.action()) + ".");
workspaceBus.publish(new StudioAssetsMutationAppliedEvent(projectReference, preview.action(), 1));
stagedMutationPreview = null;
refresh();
} catch (RuntimeException runtimeException) {
final String message = rootCauseMessage(runtimeException);
appendLog("Mutation failed: " + message);
workspaceBus.publish(new StudioAssetsMutationFailedEvent(projectReference, preview.action(), message));
stagedMutationPreview = preview;
renderState();
}
@@ -0,0 +1,170 @@
package p.studio.workspaces.assets;
import p.packer.api.PackerOperationClass;
import p.packer.api.PackerProjectContext;
import p.packer.api.events.PackerEvent;
import p.packer.api.events.PackerEventKind;
import p.packer.api.mutations.PackerMutationPreview;
import p.packer.api.mutations.PackerMutationRequest;
import p.packer.api.mutations.PackerMutationType;
import p.packer.api.mutations.PackerProposedAction;
import p.packer.declarations.PackerAssetDetailsService;
import p.packer.foundation.PackerWorkspaceFoundation;
import p.packer.mutations.FileSystemPackerMutationService;
import p.packer.mutations.PackerProjectWriteCoordinator;
import p.studio.events.StudioAssetsMutationAppliedEvent;
import p.studio.events.StudioAssetsMutationFailedEvent;
import p.studio.events.StudioAssetsMutationPreviewReadyEvent;
import p.studio.events.StudioWorkspaceEventBus;
import p.studio.projects.ProjectReference;
import java.nio.file.Path;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
public final class PackerBackedAssetWorkspaceMutationService implements AssetWorkspaceMutationService {
private final FileSystemPackerMutationService packerMutationService;
private final StudioWorkspaceEventBus eventBus;
private final ConcurrentMap<AssetWorkspaceMutationPreview, OperationSession> previewSessions = new ConcurrentHashMap<>();
private final ConcurrentMap<String, OperationSession> operationSessions = new ConcurrentHashMap<>();
public PackerBackedAssetWorkspaceMutationService(StudioWorkspaceEventBus eventBus) {
this(eventBus, new PackerWorkspaceFoundation(), new PackerAssetDetailsService(), new PackerProjectWriteCoordinator());
}
PackerBackedAssetWorkspaceMutationService(
StudioWorkspaceEventBus eventBus,
PackerWorkspaceFoundation workspaceFoundation,
PackerAssetDetailsService detailsService,
PackerProjectWriteCoordinator writeCoordinator) {
this.eventBus = Objects.requireNonNull(eventBus, "eventBus");
this.packerMutationService = new FileSystemPackerMutationService(
Objects.requireNonNull(workspaceFoundation, "workspaceFoundation"),
Objects.requireNonNull(detailsService, "detailsService"),
Objects.requireNonNull(writeCoordinator, "writeCoordinator"),
this::forwardLifecycleEvent);
}
@Override
public AssetWorkspaceMutationPreview preview(ProjectReference projectReference, AssetWorkspaceAssetSummary asset, AssetWorkspaceAction action) {
Objects.requireNonNull(projectReference, "projectReference");
Objects.requireNonNull(asset, "asset");
final PackerMutationPreview packerPreview = packerMutationService.preview(
new PackerMutationRequest(
project(projectReference),
mutationType(action),
assetReference(projectReference, asset),
null));
final AssetWorkspaceMutationPreview studioPreview = mapPreview(action, asset, packerPreview);
final OperationSession session = new OperationSession(projectReference, action, studioPreview, packerPreview);
previewSessions.put(studioPreview, session);
operationSessions.put(packerPreview.operationId(), session);
eventBus.publish(new StudioAssetsMutationPreviewReadyEvent(projectReference, action, 1));
return studioPreview;
}
@Override
public void apply(ProjectReference projectReference, AssetWorkspaceMutationPreview preview) {
Objects.requireNonNull(projectReference, "projectReference");
final OperationSession session = previewSessions.get(Objects.requireNonNull(preview, "preview"));
if (session == null) {
throw new IllegalStateException("Mutation preview is not backed by a packer preview.");
}
try {
packerMutationService.apply(session.packerPreview());
} catch (RuntimeException exception) {
throw exception;
}
}
void forwardLifecycleEvent(PackerEvent event) {
final OperationSession session = operationSessions.get(Objects.requireNonNull(event, "event").operationId());
if (session == null) {
return;
}
if (event.kind() == PackerEventKind.ACTION_APPLIED) {
previewSessions.remove(session.studioPreview());
operationSessions.remove(event.operationId());
eventBus.publish(new StudioAssetsMutationAppliedEvent(
session.projectReference(),
session.action(),
affectedAssetCount(event)));
return;
}
if (event.kind() == PackerEventKind.ACTION_FAILED) {
eventBus.publish(new StudioAssetsMutationFailedEvent(
session.projectReference(),
session.action(),
event.summary()));
}
}
private AssetWorkspaceMutationPreview mapPreview(
AssetWorkspaceAction action,
AssetWorkspaceAssetSummary asset,
PackerMutationPreview preview) {
final List<AssetWorkspaceMutationChange> changes = preview.proposedActions().stream()
.map(this::mapChange)
.toList();
return new AssetWorkspaceMutationPreview(
action,
asset,
preview.blockers(),
preview.warnings(),
preview.safeFixes(),
changes,
preview.highRisk(),
preview.targetAssetRoot());
}
private AssetWorkspaceMutationChange mapChange(PackerProposedAction action) {
return new AssetWorkspaceMutationChange(
scope(action.operationClass()),
action.verb(),
action.target());
}
private AssetWorkspaceMutationChangeScope scope(PackerOperationClass operationClass) {
return switch (operationClass) {
case REGISTRY_MUTATION -> AssetWorkspaceMutationChangeScope.REGISTRY;
case WORKSPACE_MUTATION, READ_ONLY -> AssetWorkspaceMutationChangeScope.WORKSPACE;
};
}
private PackerMutationType mutationType(AssetWorkspaceAction action) {
return switch (Objects.requireNonNull(action, "action")) {
case ADOPT -> PackerMutationType.ADOPT_ASSET;
case REGISTER -> PackerMutationType.REGISTER_ASSET;
case QUARANTINE -> PackerMutationType.QUARANTINE_ASSET;
case RELOCATE -> PackerMutationType.RELOCATE_ASSET;
case FORGET -> PackerMutationType.FORGET_ASSET;
case REMOVE -> PackerMutationType.REMOVE_ASSET;
case DOCTOR, BUILD -> throw new IllegalArgumentException("Action is not supported by the staged mutation flow: " + action);
};
}
private PackerProjectContext project(ProjectReference projectReference) {
return new PackerProjectContext(projectReference.name(), projectReference.rootPath());
}
private String assetReference(ProjectReference projectReference, AssetWorkspaceAssetSummary asset) {
if (asset.assetId() != null) {
return Integer.toString(asset.assetId());
}
final Path assetsRoot = projectReference.rootPath().resolve("assets").toAbsolutePath().normalize();
return assetsRoot.relativize(asset.assetRoot().toAbsolutePath().normalize()).toString().replace('\\', '/');
}
private int affectedAssetCount(PackerEvent event) {
return event.affectedAssets().isEmpty() ? 1 : event.affectedAssets().size();
}
private record OperationSession(
ProjectReference projectReference,
AssetWorkspaceAction action,
AssetWorkspaceMutationPreview studioPreview,
PackerMutationPreview packerPreview) {
}
}
@@ -0,0 +1,148 @@
package p.studio.workspaces.assets;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import p.packer.declarations.PackerAssetDetailsService;
import p.packer.foundation.PackerWorkspaceFoundation;
import p.packer.mutations.PackerProjectWriteCoordinator;
import p.studio.events.StudioAssetsMutationAppliedEvent;
import p.studio.events.StudioAssetsMutationFailedEvent;
import p.studio.events.StudioAssetsMutationPreviewReadyEvent;
import p.studio.events.StudioEventBus;
import p.studio.events.StudioWorkspaceEventBus;
import p.studio.projects.ProjectReference;
import p.studio.workspaces.WorkspaceId;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import static org.junit.jupiter.api.Assertions.*;
final class PackerBackedAssetWorkspaceMutationServiceTest {
@TempDir
Path tempDir;
@Test
void previewMapsPackerImpactAndPublishesPreviewReadyEvent() throws Exception {
final Path projectRoot = createManagedAssetProject();
final StudioEventBus globalBus = new StudioEventBus();
final List<StudioAssetsMutationPreviewReadyEvent> previewEvents = new ArrayList<>();
globalBus.subscribe(StudioAssetsMutationPreviewReadyEvent.class, previewEvents::add);
final PackerBackedAssetWorkspaceMutationService service = service(globalBus);
final AssetWorkspaceMutationPreview preview = service.preview(
project("Main", projectRoot),
managedAsset(projectRoot),
AssetWorkspaceAction.QUARANTINE);
assertEquals(1, previewEvents.size());
assertTrue(preview.canApply());
assertNotNull(preview.targetAssetRoot());
assertEquals(1, preview.changes().stream().filter(change -> change.scope() == AssetWorkspaceMutationChangeScope.REGISTRY).count());
assertEquals(1, preview.changes().stream().filter(change -> change.scope() == AssetWorkspaceMutationChangeScope.WORKSPACE).count());
}
@Test
void applyPublishesAppliedEventFromPackerLifecycle() throws Exception {
final Path projectRoot = createManagedAssetProject();
final StudioEventBus globalBus = new StudioEventBus();
final List<StudioAssetsMutationAppliedEvent> appliedEvents = new ArrayList<>();
globalBus.subscribe(StudioAssetsMutationAppliedEvent.class, appliedEvents::add);
final PackerBackedAssetWorkspaceMutationService service = service(globalBus);
final AssetWorkspaceMutationPreview preview = service.preview(
project("Main", projectRoot),
managedAsset(projectRoot),
AssetWorkspaceAction.RELOCATE);
service.apply(project("Main", projectRoot), preview);
assertEquals(1, appliedEvents.size());
assertEquals(AssetWorkspaceAction.RELOCATE, appliedEvents.getFirst().action());
assertTrue(Files.isDirectory(preview.targetAssetRoot()));
}
@Test
void applyFailurePublishesFailedEventFromPackerLifecycle() throws Exception {
final Path projectRoot = createManagedAssetProject();
final StudioEventBus globalBus = new StudioEventBus();
final List<StudioAssetsMutationFailedEvent> failedEvents = new ArrayList<>();
globalBus.subscribe(StudioAssetsMutationFailedEvent.class, failedEvents::add);
final PackerBackedAssetWorkspaceMutationService service = service(globalBus);
final AssetWorkspaceMutationPreview preview = service.preview(
project("Main", projectRoot),
managedAsset(projectRoot),
AssetWorkspaceAction.RELOCATE);
deleteRecursively(projectRoot.resolve("assets/ui/atlas"));
assertThrows(RuntimeException.class, () -> service.apply(project("Main", projectRoot), preview));
assertEquals(1, failedEvents.size());
assertEquals(AssetWorkspaceAction.RELOCATE, failedEvents.getFirst().action());
assertFalse(failedEvents.getFirst().message().isBlank());
}
private PackerBackedAssetWorkspaceMutationService service(StudioEventBus globalBus) {
return new PackerBackedAssetWorkspaceMutationService(
new StudioWorkspaceEventBus(WorkspaceId.ASSETS, globalBus),
new PackerWorkspaceFoundation(),
new PackerAssetDetailsService(),
new PackerProjectWriteCoordinator());
}
private Path createManagedAssetProject() throws Exception {
final Path projectRoot = tempDir.resolve("main");
final Path assetRoot = projectRoot.resolve("assets/ui/atlas");
Files.createDirectories(assetRoot);
Files.createDirectories(projectRoot.resolve("assets/.prometeu"));
Files.writeString(assetRoot.resolve("asset.json"), """
{
"schema_version": 1,
"name": "ui_atlas",
"type": "image_bank",
"preload": { "enabled": true }
}
""");
Files.writeString(projectRoot.resolve("assets/.prometeu/index.json"), """
{
"schema_version": 1,
"next_asset_id": 2,
"assets": [
{
"asset_id": 1,
"asset_uuid": "uuid-1",
"root": "ui/atlas"
}
]
}
""");
return projectRoot;
}
private AssetWorkspaceAssetSummary managedAsset(Path projectRoot) {
return new AssetWorkspaceAssetSummary(
new AssetWorkspaceSelectionKey.ManagedAsset(1),
"ui_atlas",
AssetWorkspaceAssetState.MANAGED,
1,
"image_bank",
projectRoot.resolve("assets/ui/atlas"),
true,
false);
}
private ProjectReference project(String name, Path root) {
return new ProjectReference(name, "1.0.0", "pbs", 1, root);
}
private void deleteRecursively(Path root) throws IOException {
try (var stream = Files.walk(root)) {
for (Path path : stream.sorted(Comparator.reverseOrder()).toList()) {
Files.deleteIfExists(path);
}
}
}
}