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
@@ -3,6 +3,7 @@ package p.packer.api.mutations;
import p.packer.api.PackerOperationStatus;
import p.packer.api.diagnostics.PackerDiagnostic;
import java.nio.file.Path;
import java.util.List;
import java.util.Objects;
@@ -14,7 +15,10 @@ public record PackerMutationPreview(
List<PackerProposedAction> proposedActions,
List<PackerDiagnostic> diagnostics,
List<String> blockers,
boolean highRisk) {
List<String> warnings,
List<String> safeFixes,
boolean highRisk,
Path targetAssetRoot) {
public PackerMutationPreview {
Objects.requireNonNull(status, "status");
@@ -24,6 +28,9 @@ public record PackerMutationPreview(
proposedActions = List.copyOf(Objects.requireNonNull(proposedActions, "proposedActions"));
diagnostics = List.copyOf(Objects.requireNonNull(diagnostics, "diagnostics"));
blockers = List.copyOf(Objects.requireNonNull(blockers, "blockers"));
warnings = List.copyOf(Objects.requireNonNull(warnings, "warnings"));
safeFixes = List.copyOf(Objects.requireNonNull(safeFixes, "safeFixes"));
targetAssetRoot = targetAssetRoot == null ? null : targetAssetRoot.toAbsolutePath().normalize();
if (summary.isBlank() || operationId.isBlank()) {
throw new IllegalArgumentException("summary and operationId must not be blank");
}
@@ -0,0 +1,412 @@
package p.packer.mutations;
import p.packer.api.PackerOperationClass;
import p.packer.api.PackerOperationStatus;
import p.packer.api.PackerProjectContext;
import p.packer.api.assets.PackerAssetDetails;
import p.packer.api.assets.PackerAssetState;
import p.packer.api.diagnostics.PackerDiagnostic;
import p.packer.api.events.PackerEvent;
import p.packer.api.events.PackerEventKind;
import p.packer.api.events.PackerEventSink;
import p.packer.api.mutations.PackerMutationPreview;
import p.packer.api.mutations.PackerMutationRequest;
import p.packer.api.mutations.PackerMutationResult;
import p.packer.api.mutations.PackerMutationService;
import p.packer.api.mutations.PackerMutationType;
import p.packer.api.mutations.PackerProposedAction;
import p.packer.api.workspace.GetAssetDetailsRequest;
import p.packer.declarations.PackerAssetDetailsService;
import p.packer.foundation.PackerRegistryEntry;
import p.packer.foundation.PackerRegistryState;
import p.packer.foundation.PackerWorkspaceFoundation;
import p.packer.foundation.PackerWorkspacePaths;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.Instant;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.UUID;
import java.util.stream.Stream;
public final class FileSystemPackerMutationService implements PackerMutationService {
private static final String RECOVERED_DIR = "recovered";
private static final String QUARANTINE_DIR = "quarantine";
private final PackerWorkspaceFoundation workspaceFoundation;
private final PackerAssetDetailsService detailsService;
private final PackerProjectWriteCoordinator writeCoordinator;
private final PackerEventSink eventSink;
public FileSystemPackerMutationService() {
this(new PackerWorkspaceFoundation(), new PackerAssetDetailsService(), new PackerProjectWriteCoordinator(), PackerEventSink.noop());
}
public FileSystemPackerMutationService(
PackerWorkspaceFoundation workspaceFoundation,
PackerAssetDetailsService detailsService,
PackerProjectWriteCoordinator writeCoordinator,
PackerEventSink eventSink) {
this.workspaceFoundation = Objects.requireNonNull(workspaceFoundation, "workspaceFoundation");
this.detailsService = Objects.requireNonNull(detailsService, "detailsService");
this.writeCoordinator = Objects.requireNonNull(writeCoordinator, "writeCoordinator");
this.eventSink = Objects.requireNonNull(eventSink, "eventSink");
}
@Override
public PackerOperationClass operationClass() {
return PackerOperationClass.WORKSPACE_MUTATION;
}
@Override
public PackerMutationPreview preview(PackerMutationRequest request) {
final ResolvedMutationContext context = resolveContext(Objects.requireNonNull(request, "request"));
final PackerMutationPreview preview = buildPreview(context);
emit(context.project(), preview.operationId(), 0L, PackerEventKind.PREVIEW_READY, preview.summary(), affectedAssets(preview));
return preview;
}
@Override
public PackerMutationResult apply(PackerMutationPreview preview) {
Objects.requireNonNull(preview, "preview");
final PackerProjectContext project = preview.request().project();
try {
if (!preview.canApply()) {
throw new PackerMutationException("Cannot apply mutation preview with blockers");
}
final PackerMutationResult result = writeCoordinator.withWriteLock(project, () -> applyLocked(preview));
emit(project, result.operationId(), 1L, PackerEventKind.ACTION_APPLIED, result.summary(), affectedAssets(preview));
return result;
} catch (RuntimeException exception) {
emit(project, preview.operationId(), 1L, PackerEventKind.ACTION_FAILED, rootCauseMessage(exception), affectedAssets(preview));
throw exception;
}
}
private PackerMutationResult applyLocked(PackerMutationPreview preview) {
final PackerProjectContext project = preview.request().project();
final PackerRegistryState registry = workspaceFoundation.loadRegistry(project);
final ResolvedMutationContext context = resolveContext(preview.request());
final Path assetRoot = context.assetDetails().summary().identity().assetRoot();
return switch (preview.request().type()) {
case REGISTER_ASSET, ADOPT_ASSET -> applyRegister(project, registry, assetRoot, preview);
case FORGET_ASSET -> applyForget(project, registry, assetRoot, preview);
case REMOVE_ASSET -> applyRemove(project, registry, assetRoot, preview);
case QUARANTINE_ASSET -> applyQuarantine(project, registry, assetRoot, preview);
case RELOCATE_ASSET -> applyRelocate(project, registry, assetRoot, preview);
};
}
private PackerMutationResult applyRegister(
PackerProjectContext project,
PackerRegistryState registry,
Path assetRoot,
PackerMutationPreview preview) {
final String relativeRoot = PackerWorkspacePaths.relativeAssetRoot(project, assetRoot);
final Optional<PackerRegistryEntry> existing = workspaceFoundation.lookup().findByRoot(project, registry, assetRoot);
if (existing.isPresent()) {
return new PackerMutationResult(
PackerOperationStatus.SUCCESS,
"Asset is already registered.",
preview.operationId(),
List.of(),
List.of());
}
final PackerRegistryEntry entry = workspaceFoundation.allocateIdentity(project, registry, assetRoot);
final PackerRegistryState updated = workspaceFoundation.appendAllocatedEntry(registry, entry);
workspaceFoundation.saveRegistry(project, updated);
return new PackerMutationResult(
PackerOperationStatus.SUCCESS,
"Asset registered: " + relativeRoot,
preview.operationId(),
preview.proposedActions(),
List.of());
}
private PackerMutationResult applyForget(
PackerProjectContext project,
PackerRegistryState registry,
Path assetRoot,
PackerMutationPreview preview) {
final PackerRegistryState updated = registry.withAssets(
registry.assets().stream()
.filter(entry -> !PackerWorkspacePaths.assetRoot(project, entry.root()).equals(assetRoot))
.toList(),
registry.nextAssetId());
workspaceFoundation.saveRegistry(project, updated);
return new PackerMutationResult(PackerOperationStatus.SUCCESS, "Asset forgotten.", preview.operationId(), preview.proposedActions(), List.of());
}
private PackerMutationResult applyRemove(
PackerProjectContext project,
PackerRegistryState registry,
Path assetRoot,
PackerMutationPreview preview) {
final PackerRegistryState updated = registry.withAssets(
registry.assets().stream()
.filter(entry -> !PackerWorkspacePaths.assetRoot(project, entry.root()).equals(assetRoot))
.toList(),
registry.nextAssetId());
workspaceFoundation.saveRegistry(project, updated);
deleteRecursively(assetRoot);
return new PackerMutationResult(PackerOperationStatus.SUCCESS, "Asset removed from workspace.", preview.operationId(), preview.proposedActions(), List.of());
}
private PackerMutationResult applyQuarantine(
PackerProjectContext project,
PackerRegistryState registry,
Path assetRoot,
PackerMutationPreview preview) {
final PackerRegistryState updated = registry.withAssets(
registry.assets().stream()
.filter(entry -> !PackerWorkspacePaths.assetRoot(project, entry.root()).equals(assetRoot))
.toList(),
registry.nextAssetId());
workspaceFoundation.saveRegistry(project, updated);
moveAssetRoot(assetRoot, requireTarget(preview));
return new PackerMutationResult(PackerOperationStatus.SUCCESS, "Asset moved to quarantine.", preview.operationId(), preview.proposedActions(), List.of());
}
private PackerMutationResult applyRelocate(
PackerProjectContext project,
PackerRegistryState registry,
Path assetRoot,
PackerMutationPreview preview) {
final Path targetRoot = requireTarget(preview);
final PackerRegistryState updated = registry.withAssets(
registry.assets().stream()
.map(entry -> PackerWorkspacePaths.assetRoot(project, entry.root()).equals(assetRoot)
? new PackerRegistryEntry(entry.assetId(), entry.assetUuid(), PackerWorkspacePaths.relativeAssetRoot(project, targetRoot))
: entry)
.toList(),
registry.nextAssetId());
workspaceFoundation.saveRegistry(project, updated);
moveAssetRoot(assetRoot, targetRoot);
return new PackerMutationResult(PackerOperationStatus.SUCCESS, "Asset root relocated.", preview.operationId(), preview.proposedActions(), List.of());
}
private PackerMutationPreview buildPreview(ResolvedMutationContext context) {
final PackerMutationRequest request = context.request();
final PackerAssetDetails assetDetails = context.assetDetails();
final Path assetRoot = assetDetails.summary().identity().assetRoot();
final String relativeRoot = PackerWorkspacePaths.relativeAssetRoot(context.project(), assetRoot);
final boolean managed = assetDetails.summary().identity().assetId() != null;
final List<PackerProposedAction> actions = new ArrayList<>();
final List<String> blockers = new ArrayList<>(context.initialBlockers());
final List<String> warnings = new ArrayList<>();
final List<String> safeFixes = new ArrayList<>();
Path targetAssetRoot = null;
switch (request.type()) {
case REGISTER_ASSET, ADOPT_ASSET -> {
if (managed) {
blockers.add("Asset is already managed.");
}
if (assetDetails.summary().state() == PackerAssetState.INVALID) {
blockers.add("Asset declaration must be valid before registration.");
}
if (!blockers.isEmpty()) {
break;
}
actions.add(new PackerProposedAction(PackerOperationClass.REGISTRY_MUTATION, "ADD", relativeRoot));
if (assetDetails.summary().hasDiagnostics()) {
warnings.add("Asset currently reports diagnostics and will still be registered.");
}
}
case FORGET_ASSET -> {
if (!managed) {
blockers.add("Only managed assets can be forgotten.");
} else {
actions.add(new PackerProposedAction(PackerOperationClass.REGISTRY_MUTATION, "REMOVE", relativeRoot));
warnings.add("The asset will leave the managed build set.");
}
}
case REMOVE_ASSET -> {
if (managed) {
actions.add(new PackerProposedAction(PackerOperationClass.REGISTRY_MUTATION, "REMOVE", relativeRoot));
}
actions.add(new PackerProposedAction(PackerOperationClass.WORKSPACE_MUTATION, "DELETE", relativeRoot));
warnings.add("Physical files inside the asset root will be deleted.");
}
case QUARANTINE_ASSET -> {
if (isInsideQuarantine(context.project(), assetRoot)) {
blockers.add("Asset is already inside quarantine.");
} else {
targetAssetRoot = request.targetRoot() != null
? request.targetRoot()
: nextAvailablePath(quarantineRoot(context.project()), sanitizeSegment(assetDetails.summary().identity().assetName()));
if (managed) {
actions.add(new PackerProposedAction(PackerOperationClass.REGISTRY_MUTATION, "REMOVE", relativeRoot));
warnings.add("Quarantining a managed asset removes it from the active registry.");
}
actions.add(new PackerProposedAction(
PackerOperationClass.WORKSPACE_MUTATION,
"MOVE",
relativeRoot + " -> " + PackerWorkspacePaths.relativeAssetRoot(context.project(), targetAssetRoot)));
warnings.add("Quarantine is explicit and reversible, but the asset will leave its current workspace location.");
}
}
case RELOCATE_ASSET -> {
targetAssetRoot = request.targetRoot() != null
? request.targetRoot()
: relocationTarget(context.project(), assetRoot, assetDetails.summary().identity().assetName());
final String targetRelativeRoot = PackerWorkspacePaths.relativeAssetRoot(context.project(), targetAssetRoot);
if (assetRoot.equals(targetAssetRoot)) {
blockers.add("Asset is already at the planned relocation target.");
} else {
if (managed) {
actions.add(new PackerProposedAction(PackerOperationClass.REGISTRY_MUTATION, "UPDATE", relativeRoot + " -> " + targetRelativeRoot));
}
actions.add(new PackerProposedAction(PackerOperationClass.WORKSPACE_MUTATION, "MOVE", relativeRoot + " -> " + targetRelativeRoot));
warnings.add("Relocation preserves asset identity, but it changes the root path seen by the workspace.");
}
}
}
return new PackerMutationPreview(
blockers.isEmpty() ? PackerOperationStatus.SUCCESS : PackerOperationStatus.PARTIAL,
"Mutation preview ready for " + request.type().name().toLowerCase(),
UUID.randomUUID().toString(),
request,
actions,
assetDetails.diagnostics(),
blockers,
warnings,
safeFixes,
request.type() == PackerMutationType.REMOVE_ASSET || request.type() == PackerMutationType.RELOCATE_ASSET,
targetAssetRoot);
}
private ResolvedMutationContext resolveContext(PackerMutationRequest request) {
final PackerAssetDetails assetDetails = detailsService.getAssetDetails(
new GetAssetDetailsRequest(request.project(), request.assetReference())).details();
final List<String> initialBlockers = assetDetails.diagnostics().stream()
.filter(PackerDiagnostic::blocking)
.map(PackerDiagnostic::message)
.filter(message -> request.type() != PackerMutationType.FORGET_ASSET
&& request.type() != PackerMutationType.REMOVE_ASSET
&& request.type() != PackerMutationType.QUARANTINE_ASSET
&& request.type() != PackerMutationType.RELOCATE_ASSET)
.toList();
return new ResolvedMutationContext(request.project(), request, assetDetails, initialBlockers);
}
private Path quarantineRoot(PackerProjectContext project) {
return PackerWorkspacePaths.registryDirectory(project).resolve(QUARANTINE_DIR).toAbsolutePath().normalize();
}
private boolean isInsideQuarantine(PackerProjectContext project, Path assetRoot) {
return assetRoot.toAbsolutePath().normalize().startsWith(quarantineRoot(project));
}
private Path relocationTarget(PackerProjectContext project, Path assetRoot, String assetName) {
if (isInsideQuarantine(project, assetRoot)) {
return nextAvailablePath(PackerWorkspacePaths.assetsRoot(project).resolve(RECOVERED_DIR), sanitizeSegment(assetName));
}
final Path siblingParent = assetRoot.getParent() == null ? PackerWorkspacePaths.assetsRoot(project) : assetRoot.getParent();
return nextAvailablePath(siblingParent, assetRoot.getFileName().toString() + "-relocated");
}
private Path nextAvailablePath(Path parent, String baseName) {
final Path normalizedParent = parent.toAbsolutePath().normalize();
Path candidate = normalizedParent.resolve(baseName);
int index = 2;
while (Files.exists(candidate)) {
candidate = normalizedParent.resolve(baseName + "-" + index);
index += 1;
}
return candidate;
}
private String sanitizeSegment(String value) {
final String sanitized = value == null
? "asset"
: value.trim()
.replaceAll("[^A-Za-z0-9._-]+", "-")
.replaceAll("-{2,}", "-")
.replaceAll("^[.-]+|[.-]+$", "");
return sanitized.isBlank() ? "asset" : sanitized;
}
private void moveAssetRoot(Path sourceRoot, Path targetRoot) {
if (sourceRoot.equals(targetRoot)) {
return;
}
try {
Files.createDirectories(targetRoot.getParent());
Files.move(sourceRoot, targetRoot);
} catch (IOException exception) {
throw new UncheckedIOException(exception);
}
}
private void deleteRecursively(Path root) {
if (!Files.exists(root)) {
return;
}
try (Stream<Path> stream = Files.walk(root)) {
stream.sorted(Comparator.reverseOrder()).forEach(path -> {
try {
Files.deleteIfExists(path);
} catch (IOException exception) {
throw new UncheckedIOException(exception);
}
});
} catch (IOException exception) {
throw new UncheckedIOException(exception);
}
}
private Path requireTarget(PackerMutationPreview preview) {
if (preview.targetAssetRoot() == null) {
throw new PackerMutationException("Mutation preview does not define a target asset root");
}
return preview.targetAssetRoot();
}
private void emit(
PackerProjectContext project,
String operationId,
long sequence,
PackerEventKind kind,
String summary,
List<String> affectedAssets) {
eventSink.publish(new PackerEvent(
project.projectId(),
operationId,
sequence,
kind,
Instant.now(),
summary,
null,
affectedAssets));
}
private List<String> affectedAssets(PackerMutationPreview preview) {
return List.of(preview.request().assetReference());
}
private String rootCauseMessage(Throwable throwable) {
Throwable current = throwable;
while (current.getCause() != null) {
current = current.getCause();
}
return current.getMessage() == null || current.getMessage().isBlank()
? current.getClass().getSimpleName()
: current.getMessage();
}
private record ResolvedMutationContext(
PackerProjectContext project,
PackerMutationRequest request,
PackerAssetDetails assetDetails,
List<String> initialBlockers) {
}
}
@@ -0,0 +1,11 @@
package p.packer.mutations;
public final class PackerMutationException extends RuntimeException {
public PackerMutationException(String message) {
super(message);
}
public PackerMutationException(String message, Throwable cause) {
super(message, cause);
}
}
@@ -0,0 +1,25 @@
package p.packer.mutations;
import p.packer.api.PackerProjectContext;
import java.nio.file.Path;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.Supplier;
public final class PackerProjectWriteCoordinator {
private final ConcurrentMap<Path, ReentrantLock> locks = new ConcurrentHashMap<>();
public <T> T withWriteLock(PackerProjectContext project, Supplier<T> work) {
final Path key = Objects.requireNonNull(project, "project").rootPath().toAbsolutePath().normalize();
final ReentrantLock lock = locks.computeIfAbsent(key, ignored -> new ReentrantLock());
lock.lock();
try {
return Objects.requireNonNull(work, "work").get();
} finally {
lock.unlock();
}
}
}