implements PR-020

This commit is contained in:
2026-03-24 13:42:45 +00:00
parent 60a0b571f8
commit 4278d045c2
29 changed files with 943 additions and 80 deletions
@@ -9,5 +9,9 @@ public interface PackerWorkspaceService {
GetAssetDetailsResult getAssetDetails(GetAssetDetailsRequest request);
GetAssetActionsResult getAssetActions(GetAssetActionsRequest request);
CreateAssetResult createAsset(CreateAssetRequest request);
RegisterAssetResult registerAsset(RegisterAssetRequest request);
}
@@ -0,0 +1,20 @@
package p.packer.dtos;
import p.packer.messages.assets.AssetAction;
import java.util.Objects;
public record PackerAssetActionAvailabilityDTO(
AssetAction action,
boolean enabled,
boolean visible,
String reason) {
public PackerAssetActionAvailabilityDTO {
Objects.requireNonNull(action, "action");
reason = reason == null ? null : reason.trim();
if (reason != null && reason.isBlank()) {
reason = null;
}
}
}
@@ -0,0 +1,13 @@
package p.packer.messages;
import java.util.Objects;
public record GetAssetActionsRequest(
PackerProjectContext project,
AssetReference assetReference) {
public GetAssetActionsRequest {
Objects.requireNonNull(project, "project");
Objects.requireNonNull(assetReference, "assetReference");
}
}
@@ -0,0 +1,24 @@
package p.packer.messages;
import p.packer.dtos.PackerAssetActionAvailabilityDTO;
import p.packer.dtos.PackerDiagnosticDTO;
import java.util.List;
import java.util.Objects;
public record GetAssetActionsResult(
PackerOperationStatus status,
String summary,
List<PackerAssetActionAvailabilityDTO> actions,
List<PackerDiagnosticDTO> diagnostics) {
public GetAssetActionsResult {
Objects.requireNonNull(status, "status");
summary = Objects.requireNonNull(summary, "summary").trim();
actions = List.copyOf(Objects.requireNonNull(actions, "actions"));
diagnostics = List.copyOf(Objects.requireNonNull(diagnostics, "diagnostics"));
if (summary.isBlank()) {
throw new IllegalArgumentException("summary must not be blank");
}
}
}
@@ -0,0 +1,13 @@
package p.packer.messages;
import java.util.Objects;
public record RegisterAssetRequest(
PackerProjectContext project,
AssetReference assetReference) {
public RegisterAssetRequest {
Objects.requireNonNull(project, "project");
Objects.requireNonNull(assetReference, "assetReference");
}
}
@@ -0,0 +1,26 @@
package p.packer.messages;
import java.nio.file.Path;
import java.util.Objects;
public record RegisterAssetResult(
PackerOperationStatus status,
String summary,
AssetReference assetReference,
Path assetRoot,
Path manifestPath) {
public RegisterAssetResult {
Objects.requireNonNull(status, "status");
summary = Objects.requireNonNull(summary, "summary").trim();
if (summary.isBlank()) {
throw new IllegalArgumentException("summary must not be blank");
}
if (assetRoot != null) {
assetRoot = assetRoot.toAbsolutePath().normalize();
}
if (manifestPath != null) {
manifestPath = manifestPath.toAbsolutePath().normalize();
}
}
}
@@ -0,0 +1,5 @@
package p.packer.messages.assets;
public enum AssetAction {
REGISTER
}
@@ -26,11 +26,17 @@ public final class Packer implements Closeable {
final PackerAssetDeclarationParser declarationParser = new PackerAssetDeclarationParser();
final PackerRuntimeRegistry runtimeRegistry = new PackerRuntimeRegistry(
new PackerRuntimeLoader(workspaceFoundation, declarationParser));
final PackerAssetDetailsService assetDetailsService = new PackerAssetDetailsService(runtimeRegistry);
final PackerAssetReferenceResolver assetReferenceResolver = new PackerAssetReferenceResolver(workspaceFoundation.lookup());
final PackerAssetDetailsService assetDetailsService = new PackerAssetDetailsService(runtimeRegistry, assetReferenceResolver);
final PackerAssetActionReadService assetActionReadService = new PackerAssetActionReadService(
runtimeRegistry,
assetReferenceResolver,
workspaceFoundation.lookup());
final PackerProjectWriteCoordinator writeCoordinator = new PackerProjectWriteCoordinator();
return new Packer(new FileSystemPackerWorkspaceService(
workspaceFoundation,
assetDetailsService,
assetActionReadService,
runtimeRegistry,
writeCoordinator,
resolvedEventSink), runtimeRegistry, writeCoordinator);
@@ -0,0 +1,20 @@
package p.packer.models;
import p.packer.messages.assets.AssetAction;
import java.util.Objects;
public record PackerAssetActionAvailability(
AssetAction action,
boolean enabled,
boolean visible,
String reason) {
public PackerAssetActionAvailability {
Objects.requireNonNull(action, "action");
reason = reason == null ? null : reason.trim();
if (reason != null && reason.isBlank()) {
reason = null;
}
}
}
@@ -0,0 +1,20 @@
package p.packer.models;
import java.util.List;
import java.util.Objects;
public record PackerRegisterAssetEvaluation(
PackerResolvedAssetReference resolved,
List<PackerDiagnostic> diagnostics,
boolean canRegister,
String reason) {
public PackerRegisterAssetEvaluation {
Objects.requireNonNull(resolved, "resolved");
diagnostics = List.copyOf(Objects.requireNonNull(diagnostics, "diagnostics"));
reason = reason == null ? null : reason.trim();
if (reason != null && reason.isBlank()) {
reason = null;
}
}
}
@@ -0,0 +1,20 @@
package p.packer.models;
import java.nio.file.Path;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
public record PackerResolvedAssetReference(
Path assetRoot,
Optional<PackerRegistryEntry> registryEntry,
Optional<PackerRuntimeAsset> runtimeAsset,
List<PackerDiagnostic> diagnostics) {
public PackerResolvedAssetReference {
assetRoot = Objects.requireNonNull(assetRoot, "assetRoot").toAbsolutePath().normalize();
registryEntry = Objects.requireNonNull(registryEntry, "registryEntry");
runtimeAsset = Objects.requireNonNull(runtimeAsset, "runtimeAsset");
diagnostics = List.copyOf(Objects.requireNonNull(diagnostics, "diagnostics"));
}
}
@@ -5,6 +5,8 @@ import p.packer.messages.PackerOperationStatus;
import p.packer.messages.PackerProjectContext;
import p.packer.messages.assets.AssetFamilyCatalog;
import p.packer.messages.AssetReference;
import p.packer.messages.GetAssetActionsRequest;
import p.packer.messages.GetAssetActionsResult;
import p.packer.messages.assets.OutputFormatCatalog;
import p.packer.messages.assets.PackerAssetState;
import p.packer.messages.assets.PackerBuildParticipation;
@@ -21,9 +23,12 @@ import p.packer.messages.InitWorkspaceRequest;
import p.packer.messages.InitWorkspaceResult;
import p.packer.messages.ListAssetsRequest;
import p.packer.messages.ListAssetsResult;
import p.packer.messages.RegisterAssetRequest;
import p.packer.messages.RegisterAssetResult;
import p.packer.PackerWorkspaceService;
import p.packer.models.PackerAssetDeclarationParseResult;
import p.packer.models.PackerAssetIdentity;
import p.packer.models.PackerRegisterAssetEvaluation;
import p.packer.models.PackerAssetSummary;
import p.packer.models.PackerDiagnostic;
import p.packer.models.PackerRegistryEntry;
@@ -41,6 +46,7 @@ public final class FileSystemPackerWorkspaceService implements PackerWorkspaceSe
private static final ObjectMapper MAPPER = new ObjectMapper();
private final PackerWorkspaceFoundation workspaceFoundation;
private final PackerAssetDetailsService detailsService;
private final PackerAssetActionReadService actionReadService;
private final PackerRuntimeRegistry runtimeRegistry;
private final PackerProjectWriteCoordinator writeCoordinator;
private final PackerEventSink eventSink;
@@ -48,11 +54,13 @@ public final class FileSystemPackerWorkspaceService implements PackerWorkspaceSe
public FileSystemPackerWorkspaceService(
PackerWorkspaceFoundation workspaceFoundation,
PackerAssetDetailsService detailsService,
PackerAssetActionReadService actionReadService,
PackerRuntimeRegistry runtimeRegistry,
PackerProjectWriteCoordinator writeCoordinator,
PackerEventSink eventSink) {
this.workspaceFoundation = Objects.requireNonNull(workspaceFoundation, "workspaceFoundation");
this.detailsService = Objects.requireNonNull(detailsService, "detailsService");
this.actionReadService = Objects.requireNonNull(actionReadService, "actionReadService");
this.runtimeRegistry = Objects.requireNonNull(runtimeRegistry, "runtimeRegistry");
this.writeCoordinator = Objects.requireNonNull(writeCoordinator, "writeCoordinator");
this.eventSink = Objects.requireNonNull(eventSink, "eventSink");
@@ -133,6 +141,11 @@ public final class FileSystemPackerWorkspaceService implements PackerWorkspaceSe
return detailsService.getAssetDetails(request);
}
@Override
public GetAssetActionsResult getAssetActions(GetAssetActionsRequest request) {
return actionReadService.getAssetActions(request);
}
@Override
public CreateAssetResult createAsset(CreateAssetRequest request) {
final CreateAssetRequest safeRequest = Objects.requireNonNull(request, "request");
@@ -142,6 +155,14 @@ public final class FileSystemPackerWorkspaceService implements PackerWorkspaceSe
return writeCoordinator.execute(project, () -> createAssetInWriteLane(safeRequest, events));
}
@Override
public RegisterAssetResult registerAsset(RegisterAssetRequest request) {
final RegisterAssetRequest safeRequest = Objects.requireNonNull(request, "request");
final PackerProjectContext project = safeRequest.project();
final PackerOperationEventEmitter events = new PackerOperationEventEmitter(project, eventSink);
return writeCoordinator.execute(project, () -> registerAssetInWriteLane(safeRequest, events));
}
private CreateAssetResult createAssetInWriteLane(
CreateAssetRequest request,
PackerOperationEventEmitter events) {
@@ -216,6 +237,50 @@ public final class FileSystemPackerWorkspaceService implements PackerWorkspaceSe
}
}
private RegisterAssetResult registerAssetInWriteLane(
RegisterAssetRequest request,
PackerOperationEventEmitter events) {
final PackerProjectContext project = request.project();
workspaceFoundation.initWorkspace(new InitWorkspaceRequest(project));
final PackerRuntimeSnapshot snapshot = runtimeRegistry.getOrLoad(project).snapshot();
final PackerRegisterAssetEvaluation evaluation = actionReadService.evaluateRegister(snapshot, project, request.assetReference());
final Path assetRoot = evaluation.resolved().assetRoot();
final Path manifestPath = assetRoot.resolve("asset.json");
final String relativeAssetRoot = relativeAssetRoot(project, assetRoot);
if (!evaluation.canRegister()) {
final String summary = Objects.requireNonNullElse(evaluation.reason(), "Asset cannot be registered.");
return registerFailureResult(events, summary, assetRoot, manifestPath, List.of(relativeAssetRoot));
}
final var declaration = evaluation.resolved().runtimeAsset().orElseThrow().parsedDeclaration().declaration();
try {
final PackerRegistryState registry = workspaceFoundation.loadRegistry(project);
final PackerRegistryEntry entry = workspaceFoundation.registerExistingAsset(
project,
registry,
assetRoot,
declaration.assetUuid());
final PackerRegistryState updated = workspaceFoundation.appendAllocatedEntry(registry, entry);
workspaceFoundation.saveRegistry(project, updated);
runtimeRegistry.refresh(project);
final RegisterAssetResult result = new RegisterAssetResult(
PackerOperationStatus.SUCCESS,
"Asset registered: " + relativeAssetRoot,
AssetReference.forAssetId(entry.assetId()),
assetRoot,
manifestPath);
events.emit(PackerEventKind.ACTION_APPLIED, result.summary(), List.of(relativeAssetRoot));
return result;
} catch (RuntimeException exception) {
return registerFailureResult(
events,
"Unable to register asset: " + exception.getMessage(),
assetRoot,
manifestPath,
List.of(relativeAssetRoot));
}
}
private CreateAssetResult failureResult(
PackerOperationEventEmitter events,
String summary,
@@ -232,6 +297,22 @@ public final class FileSystemPackerWorkspaceService implements PackerWorkspaceSe
return result;
}
private RegisterAssetResult registerFailureResult(
PackerOperationEventEmitter events,
String summary,
Path assetRoot,
Path manifestPath,
List<String> affectedAssets) {
final RegisterAssetResult result = new RegisterAssetResult(
PackerOperationStatus.FAILED,
summary,
null,
assetRoot,
manifestPath);
events.emit(PackerEventKind.ACTION_FAILED, result.summary(), affectedAssets);
return result;
}
private void writeManifest(Path manifestPath, CreateAssetRequest request, String assetUuid) throws IOException {
final Map<String, Object> manifest = new LinkedHashMap<>();
manifest.put("schema_version", 1);
@@ -321,4 +402,8 @@ public final class FileSystemPackerWorkspaceService implements PackerWorkspaceSe
.toString()
.replace('\\', '/'));
}
private String relativeAssetRoot(PackerProjectContext project, Path assetRoot) {
return PackerWorkspacePaths.relativeAssetRoot(project, assetRoot).replace('\\', '/');
}
}
@@ -0,0 +1,131 @@
package p.packer.services;
import p.packer.dtos.PackerAssetActionAvailabilityDTO;
import p.packer.messages.AssetReference;
import p.packer.messages.GetAssetActionsRequest;
import p.packer.messages.GetAssetActionsResult;
import p.packer.messages.PackerOperationStatus;
import p.packer.messages.PackerProjectContext;
import p.packer.messages.assets.AssetAction;
import p.packer.messages.diagnostics.PackerDiagnosticCategory;
import p.packer.messages.diagnostics.PackerDiagnosticSeverity;
import p.packer.models.PackerAssetActionAvailability;
import p.packer.models.PackerAssetDeclaration;
import p.packer.models.PackerAssetDeclarationParseResult;
import p.packer.models.PackerDiagnostic;
import p.packer.models.PackerRegisterAssetEvaluation;
import p.packer.models.PackerRegistryEntry;
import p.packer.models.PackerResolvedAssetReference;
import p.packer.models.PackerRuntimeAsset;
import p.packer.models.PackerRuntimeSnapshot;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
public final class PackerAssetActionReadService {
private final PackerRuntimeRegistry runtimeRegistry;
private final PackerAssetReferenceResolver assetReferenceResolver;
private final PackerRegistryLookup registryLookup;
public PackerAssetActionReadService(
PackerRuntimeRegistry runtimeRegistry,
PackerAssetReferenceResolver assetReferenceResolver,
PackerRegistryLookup registryLookup) {
this.runtimeRegistry = Objects.requireNonNull(runtimeRegistry, "runtimeRegistry");
this.assetReferenceResolver = Objects.requireNonNull(assetReferenceResolver, "assetReferenceResolver");
this.registryLookup = Objects.requireNonNull(registryLookup, "registryLookup");
}
public GetAssetActionsResult getAssetActions(GetAssetActionsRequest request) {
final PackerProjectContext project = Objects.requireNonNull(request, "request").project();
final PackerRuntimeSnapshot snapshot = runtimeRegistry.getOrLoad(project).snapshot();
final PackerRegisterAssetEvaluation registerEvaluation = evaluateRegister(snapshot, project, request.assetReference());
final List<PackerAssetActionAvailability> actions = new ArrayList<>();
if (registerEvaluation.resolved().registryEntry().isEmpty()) {
actions.add(new PackerAssetActionAvailability(
AssetAction.REGISTER,
registerEvaluation.canRegister(),
true,
registerEvaluation.reason()));
}
final PackerOperationStatus status;
if (registerEvaluation.resolved().runtimeAsset().isEmpty()) {
status = PackerOperationStatus.FAILED;
} else if (registerEvaluation.diagnostics().stream().anyMatch(PackerDiagnostic::blocking)) {
status = PackerOperationStatus.PARTIAL;
} else {
status = PackerOperationStatus.SUCCESS;
}
return new GetAssetActionsResult(
status,
"Asset action capabilities resolved from runtime snapshot.",
PackerReadMessageMapper.toAssetActionAvailabilityDTOs(actions),
PackerReadMessageMapper.toDiagnosticDTOs(registerEvaluation.diagnostics()));
}
public PackerRegisterAssetEvaluation evaluateRegister(
PackerRuntimeSnapshot snapshot,
PackerProjectContext project,
AssetReference assetReference) {
final PackerResolvedAssetReference resolved = assetReferenceResolver.resolve(project, snapshot, assetReference);
final List<PackerDiagnostic> diagnostics = new ArrayList<>(resolved.diagnostics());
if (resolved.registryEntry().isPresent()) {
return new PackerRegisterAssetEvaluation(resolved, diagnostics, false, "Asset is already registered.");
}
if (resolved.runtimeAsset().isEmpty()) {
diagnostics.add(new PackerDiagnostic(
PackerDiagnosticSeverity.ERROR,
PackerDiagnosticCategory.STRUCTURAL,
"asset.json was not found for the requested asset root.",
resolved.assetRoot().resolve("asset.json"),
true));
return new PackerRegisterAssetEvaluation(resolved, diagnostics, false, "asset.json was not found for the requested asset root.");
}
final PackerRuntimeAsset runtimeAsset = resolved.runtimeAsset().get();
final PackerAssetDeclarationParseResult parsed = runtimeAsset.parsedDeclaration();
diagnostics.addAll(parsed.diagnostics());
if (!parsed.valid()) {
return new PackerRegisterAssetEvaluation(resolved, diagnostics, false, firstBlockingReason(diagnostics, "Asset declaration is invalid."));
}
final PackerAssetDeclaration declaration = parsed.declaration();
final Optional<PackerRegistryEntry> sameUuidEntry = registryLookup.findByAssetUuid(snapshot.registry(), declaration.assetUuid());
if (sameUuidEntry.isPresent()) {
final Path registeredRoot = PackerWorkspacePaths.assetRoot(project, sameUuidEntry.get().root());
if (!registeredRoot.equals(resolved.assetRoot())) {
diagnostics.add(new PackerDiagnostic(
PackerDiagnosticSeverity.ERROR,
PackerDiagnosticCategory.STRUCTURAL,
"Field 'asset_uuid' is already registered to another asset root.",
runtimeAsset.manifestPath(),
true));
return new PackerRegisterAssetEvaluation(
resolved,
diagnostics,
false,
"Asset UUID is already registered by another asset.");
}
}
final Optional<PackerRegistryEntry> sameRootEntry = registryLookup.findByRoot(project, snapshot.registry(), resolved.assetRoot());
if (sameRootEntry.isPresent()) {
return new PackerRegisterAssetEvaluation(resolved, diagnostics, false, "Asset root is already registered.");
}
return new PackerRegisterAssetEvaluation(resolved, diagnostics, true, null);
}
private String firstBlockingReason(List<PackerDiagnostic> diagnostics, String fallback) {
return diagnostics.stream()
.filter(PackerDiagnostic::blocking)
.map(PackerDiagnostic::message)
.filter(message -> message != null && !message.isBlank())
.findFirst()
.orElse(fallback);
}
}
@@ -18,6 +18,7 @@ import p.packer.models.PackerAssetIdentity;
import p.packer.models.PackerAssetSummary;
import p.packer.models.PackerDiagnostic;
import p.packer.models.PackerRegistryEntry;
import p.packer.models.PackerResolvedAssetReference;
import p.packer.models.PackerRuntimeAsset;
import p.packer.models.PackerRuntimeSnapshot;
@@ -31,15 +32,19 @@ import java.util.Optional;
public final class PackerAssetDetailsService {
private final PackerRuntimeRegistry runtimeRegistry;
private final PackerAssetReferenceResolver assetReferenceResolver;
public PackerAssetDetailsService(PackerRuntimeRegistry runtimeRegistry) {
public PackerAssetDetailsService(
PackerRuntimeRegistry runtimeRegistry,
PackerAssetReferenceResolver assetReferenceResolver) {
this.runtimeRegistry = Objects.requireNonNull(runtimeRegistry, "runtimeRegistry");
this.assetReferenceResolver = Objects.requireNonNull(assetReferenceResolver, "assetReferenceResolver");
}
public GetAssetDetailsResult getAssetDetails(GetAssetDetailsRequest request) {
final PackerProjectContext project = Objects.requireNonNull(request, "request").project();
final PackerRuntimeSnapshot snapshot = runtimeRegistry.getOrLoad(project).snapshot();
final ResolvedAssetReference resolved = resolveReference(project, snapshot, request.assetReference());
final PackerResolvedAssetReference resolved = assetReferenceResolver.resolve(project, snapshot, request.assetReference());
final List<PackerDiagnostic> diagnostics = new ArrayList<>(resolved.diagnostics());
if (resolved.runtimeAsset().isEmpty()) {
@@ -100,7 +105,7 @@ public final class PackerAssetDetailsService {
private GetAssetDetailsResult failureResult(
PackerProjectContext project,
AssetReference requestedReference,
ResolvedAssetReference resolved,
PackerResolvedAssetReference resolved,
List<PackerDiagnostic> diagnostics) {
final PackerAssetState state = resolved.registryEntry().isPresent()
? PackerAssetState.REGISTERED
@@ -157,44 +162,6 @@ public final class PackerAssetDetailsService {
true));
}
private ResolvedAssetReference resolveReference(PackerProjectContext project, PackerRuntimeSnapshot snapshot, AssetReference assetReference) {
final PackerRegistryLookup lookup = new PackerRegistryLookup();
final String reference = Objects.requireNonNull(assetReference, "assetReference").rawValue();
final Optional<PackerRegistryEntry> byId = parseAssetId(reference).flatMap(assetId -> lookup.findByAssetId(snapshot.registry(), assetId));
if (byId.isPresent()) {
final Path assetRoot = PackerWorkspacePaths.assetRoot(project, byId.get().root());
return new ResolvedAssetReference(assetRoot, byId, findRuntimeAsset(snapshot, assetRoot), List.of());
}
final Optional<PackerRegistryEntry> byUuid = lookup.findByAssetUuid(snapshot.registry(), reference);
if (byUuid.isPresent()) {
final Path assetRoot = PackerWorkspacePaths.assetRoot(project, byUuid.get().root());
return new ResolvedAssetReference(assetRoot, byUuid, findRuntimeAsset(snapshot, assetRoot), List.of());
}
final Path candidateRoot = PackerWorkspacePaths.assetRoot(project, reference);
final Optional<PackerRuntimeAsset> runtimeAsset = findRuntimeAsset(snapshot, candidateRoot);
if (runtimeAsset.isPresent()) {
return new ResolvedAssetReference(candidateRoot, lookup.findByRoot(project, snapshot.registry(), candidateRoot), runtimeAsset, List.of());
}
final Optional<PackerRegistryEntry> registryEntry = lookup.findByRoot(project, snapshot.registry(), candidateRoot);
if (registryEntry.isPresent()) {
return new ResolvedAssetReference(candidateRoot, registryEntry, Optional.empty(), List.of());
}
return new ResolvedAssetReference(
candidateRoot,
Optional.empty(),
Optional.empty(),
List.of(new PackerDiagnostic(
PackerDiagnosticSeverity.ERROR,
PackerDiagnosticCategory.STRUCTURAL,
"Requested asset reference could not be resolved.",
candidateRoot,
true)));
}
private AssetReference canonicalReference(
PackerProjectContext project,
Path assetRoot,
@@ -211,39 +178,10 @@ public final class PackerAssetDetailsService {
private AssetReference canonicalReferenceOrRequested(
PackerProjectContext project,
AssetReference requestedReference,
ResolvedAssetReference resolved) {
PackerResolvedAssetReference resolved) {
if (resolved.registryEntry().isPresent() || resolved.runtimeAsset().isPresent()) {
return canonicalReference(project, resolved.assetRoot(), resolved.registryEntry());
}
return requestedReference;
}
private Optional<Integer> parseAssetId(String reference) {
try {
return Optional.of(Integer.parseInt(reference.trim()));
} catch (NumberFormatException ignored) {
return Optional.empty();
}
}
private Optional<PackerRuntimeAsset> findRuntimeAsset(PackerRuntimeSnapshot snapshot, Path assetRoot) {
final Path normalizedRoot = Objects.requireNonNull(assetRoot, "assetRoot").toAbsolutePath().normalize();
return snapshot.assets().stream()
.filter(candidate -> candidate.assetRoot().equals(normalizedRoot))
.findFirst();
}
private record ResolvedAssetReference(
Path assetRoot,
Optional<PackerRegistryEntry> registryEntry,
Optional<PackerRuntimeAsset> runtimeAsset,
List<PackerDiagnostic> diagnostics) {
private ResolvedAssetReference {
assetRoot = Objects.requireNonNull(assetRoot, "assetRoot").toAbsolutePath().normalize();
registryEntry = Objects.requireNonNull(registryEntry, "registryEntry");
runtimeAsset = Objects.requireNonNull(runtimeAsset, "runtimeAsset");
diagnostics = List.copyOf(Objects.requireNonNull(diagnostics, "diagnostics"));
}
}
}
@@ -0,0 +1,88 @@
package p.packer.services;
import p.packer.messages.AssetReference;
import p.packer.messages.PackerProjectContext;
import p.packer.messages.diagnostics.PackerDiagnosticCategory;
import p.packer.messages.diagnostics.PackerDiagnosticSeverity;
import p.packer.models.PackerDiagnostic;
import p.packer.models.PackerRegistryEntry;
import p.packer.models.PackerResolvedAssetReference;
import p.packer.models.PackerRuntimeAsset;
import p.packer.models.PackerRuntimeSnapshot;
import java.nio.file.Path;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
public final class PackerAssetReferenceResolver {
private final PackerRegistryLookup lookup;
public PackerAssetReferenceResolver() {
this(new PackerRegistryLookup());
}
public PackerAssetReferenceResolver(PackerRegistryLookup lookup) {
this.lookup = Objects.requireNonNull(lookup, "lookup");
}
public PackerResolvedAssetReference resolve(
PackerProjectContext project,
PackerRuntimeSnapshot snapshot,
AssetReference assetReference) {
final String reference = Objects.requireNonNull(assetReference, "assetReference").rawValue();
final Optional<PackerRegistryEntry> byId = parseAssetId(reference)
.flatMap(assetId -> lookup.findByAssetId(snapshot.registry(), assetId));
if (byId.isPresent()) {
final Path assetRoot = PackerWorkspacePaths.assetRoot(project, byId.get().root());
return new PackerResolvedAssetReference(assetRoot, byId, findRuntimeAsset(snapshot, assetRoot), List.of());
}
final Optional<PackerRegistryEntry> byUuid = lookup.findByAssetUuid(snapshot.registry(), reference);
if (byUuid.isPresent()) {
final Path assetRoot = PackerWorkspacePaths.assetRoot(project, byUuid.get().root());
return new PackerResolvedAssetReference(assetRoot, byUuid, findRuntimeAsset(snapshot, assetRoot), List.of());
}
final Path candidateRoot = PackerWorkspacePaths.assetRoot(project, reference);
final Optional<PackerRuntimeAsset> runtimeAsset = findRuntimeAsset(snapshot, candidateRoot);
if (runtimeAsset.isPresent()) {
return new PackerResolvedAssetReference(
candidateRoot,
lookup.findByRoot(project, snapshot.registry(), candidateRoot),
runtimeAsset,
List.of());
}
final Optional<PackerRegistryEntry> registryEntry = lookup.findByRoot(project, snapshot.registry(), candidateRoot);
if (registryEntry.isPresent()) {
return new PackerResolvedAssetReference(candidateRoot, registryEntry, Optional.empty(), List.of());
}
return new PackerResolvedAssetReference(
candidateRoot,
Optional.empty(),
Optional.empty(),
List.of(new PackerDiagnostic(
PackerDiagnosticSeverity.ERROR,
PackerDiagnosticCategory.STRUCTURAL,
"Requested asset reference could not be resolved.",
candidateRoot,
true)));
}
private Optional<Integer> parseAssetId(String reference) {
try {
return Optional.of(Integer.parseInt(reference.trim()));
} catch (NumberFormatException ignored) {
return Optional.empty();
}
}
private Optional<PackerRuntimeAsset> findRuntimeAsset(PackerRuntimeSnapshot snapshot, Path assetRoot) {
final Path normalizedRoot = Objects.requireNonNull(assetRoot, "assetRoot").toAbsolutePath().normalize();
return snapshot.assets().stream()
.filter(candidate -> candidate.assetRoot().equals(normalizedRoot))
.findFirst();
}
}
@@ -26,6 +26,30 @@ public final class PackerIdentityAllocator {
return new PackerRegistryEntry(state.nextAssetId(), UUID.randomUUID().toString(), relativeRoot);
}
public PackerRegistryEntry registerExisting(
PackerProjectContext project,
PackerRegistryState state,
Path assetRoot,
String assetUuid) {
Objects.requireNonNull(project, "project");
Objects.requireNonNull(state, "state");
final Path normalizedAssetRoot = Objects.requireNonNull(assetRoot, "assetRoot").toAbsolutePath().normalize();
final String relativeRoot = PackerWorkspacePaths.relativeAssetRoot(project, normalizedAssetRoot);
final String normalizedAssetUuid = Objects.requireNonNull(assetUuid, "assetUuid").trim();
if (normalizedAssetUuid.isBlank()) {
throw new IllegalArgumentException("assetUuid must not be blank");
}
final boolean alreadyRegisteredRoot = state.assets().stream().anyMatch(entry -> entry.root().equals(relativeRoot));
if (alreadyRegisteredRoot) {
throw new p.packer.exceptions.PackerRegistryException("Asset root is already registered: " + relativeRoot);
}
final boolean alreadyRegisteredUuid = state.assets().stream().anyMatch(entry -> entry.assetUuid().equals(normalizedAssetUuid));
if (alreadyRegisteredUuid) {
throw new p.packer.exceptions.PackerRegistryException("Asset UUID is already registered: " + normalizedAssetUuid);
}
return new PackerRegistryEntry(state.nextAssetId(), normalizedAssetUuid, relativeRoot);
}
public PackerRegistryState append(PackerRegistryState state, PackerRegistryEntry entry) {
Objects.requireNonNull(state, "state");
Objects.requireNonNull(entry, "entry");
@@ -1,11 +1,13 @@
package p.packer.services;
import p.packer.dtos.PackerAssetDetailsDTO;
import p.packer.dtos.PackerAssetActionAvailabilityDTO;
import p.packer.dtos.PackerAssetIdentityDTO;
import p.packer.dtos.PackerAssetSummaryDTO;
import p.packer.dtos.PackerCodecConfigurationFieldDTO;
import p.packer.dtos.PackerDiagnosticDTO;
import p.packer.messages.assets.OutputCodecCatalog;
import p.packer.models.PackerAssetActionAvailability;
import p.packer.models.PackerAssetDetails;
import p.packer.models.PackerAssetIdentity;
import p.packer.models.PackerAssetSummary;
@@ -50,6 +52,11 @@ public final class PackerReadMessageMapper {
return diagnostics.stream().map(PackerReadMessageMapper::toDiagnosticDTO).toList();
}
public static List<PackerAssetActionAvailabilityDTO> toAssetActionAvailabilityDTOs(
List<PackerAssetActionAvailability> actions) {
return actions.stream().map(PackerReadMessageMapper::toAssetActionAvailabilityDTO).toList();
}
private static PackerAssetIdentityDTO toAssetIdentityDTO(PackerAssetIdentity identity) {
return new PackerAssetIdentityDTO(
identity.assetId(),
@@ -85,4 +92,13 @@ public final class PackerReadMessageMapper {
diagnostic.evidencePath(),
diagnostic.blocking());
}
private static PackerAssetActionAvailabilityDTO toAssetActionAvailabilityDTO(
PackerAssetActionAvailability action) {
return new PackerAssetActionAvailabilityDTO(
action.action(),
action.enabled(),
action.visible(),
action.reason());
}
}
@@ -58,6 +58,14 @@ public final class PackerWorkspaceFoundation {
return identityAllocator.allocate(project, state, assetRoot);
}
public PackerRegistryEntry registerExistingAsset(
PackerProjectContext project,
PackerRegistryState state,
java.nio.file.Path assetRoot,
String assetUuid) {
return identityAllocator.registerExisting(project, state, assetRoot, assetUuid);
}
public PackerRegistryState appendAllocatedEntry(PackerRegistryState state, PackerRegistryEntry entry) {
return identityAllocator.append(state, entry);
}
@@ -14,8 +14,12 @@ import p.packer.events.PackerEvent;
import p.packer.events.PackerEventKind;
import p.packer.messages.CreateAssetRequest;
import p.packer.messages.CreateAssetResult;
import p.packer.messages.GetAssetActionsRequest;
import p.packer.messages.GetAssetDetailsRequest;
import p.packer.messages.ListAssetsRequest;
import p.packer.messages.RegisterAssetRequest;
import p.packer.messages.RegisterAssetResult;
import p.packer.messages.assets.AssetAction;
import p.packer.testing.PackerFixtureLocator;
import java.nio.file.Files;
@@ -143,6 +147,143 @@ final class FileSystemPackerWorkspaceServiceTest {
assertTrue(detailsResult.diagnostics().isEmpty());
}
@Test
void exposesRegisterActionForValidUnregisteredAsset() throws Exception {
final Path projectRoot = copyFixture("workspaces/orphan-valid", tempDir.resolve("orphan-actions"));
final FileSystemPackerWorkspaceService service = service();
final var result = service.getAssetActions(new GetAssetActionsRequest(
project(projectRoot),
AssetReference.forRelativeAssetRoot("orphans/ui_sounds")));
assertEquals(PackerOperationStatus.SUCCESS, result.status());
assertEquals(1, result.actions().size());
assertEquals(AssetAction.REGISTER, result.actions().getFirst().action());
assertTrue(result.actions().getFirst().visible());
assertTrue(result.actions().getFirst().enabled());
assertNull(result.actions().getFirst().reason());
}
@Test
void hidesRegisterActionForRegisteredAsset() throws Exception {
final Path projectRoot = copyFixture("workspaces/managed-basic", tempDir.resolve("managed-actions"));
final FileSystemPackerWorkspaceService service = service();
final var result = service.getAssetActions(new GetAssetActionsRequest(
project(projectRoot),
AssetReference.forAssetId(1)));
assertEquals(PackerOperationStatus.SUCCESS, result.status());
assertTrue(result.actions().isEmpty());
}
@Test
void registersExistingUnregisteredAssetAndRefreshesRuntimeView() throws Exception {
final Path projectRoot = copyFixture("workspaces/orphan-valid", tempDir.resolve("register-orphan"));
final List<PackerEvent> events = new CopyOnWriteArrayList<>();
final FileSystemPackerWorkspaceService service = service(events::add);
final RegisterAssetResult registerResult = service.registerAsset(new RegisterAssetRequest(
project(projectRoot),
AssetReference.forRelativeAssetRoot("orphans/ui_sounds")));
assertEquals(PackerOperationStatus.SUCCESS, registerResult.status());
assertNotNull(registerResult.assetReference());
assertTrue(registerResult.assetReference().isAssetIdReference());
final var detailsResult = service.getAssetDetails(new GetAssetDetailsRequest(
project(projectRoot),
registerResult.assetReference()));
assertEquals(PackerOperationStatus.SUCCESS, detailsResult.status());
assertEquals(PackerAssetState.REGISTERED, detailsResult.details().summary().state());
assertEquals("orphan-uuid-1", detailsResult.details().summary().identity().assetUuid());
assertTrue(events.stream().anyMatch(event -> event.kind() == PackerEventKind.ACTION_APPLIED));
}
@Test
void blocksRegisterActionForInvalidDeclaration() throws Exception {
final Path projectRoot = copyFixture("workspaces/invalid-missing-fields", tempDir.resolve("invalid-actions"));
final FileSystemPackerWorkspaceService service = service();
final var result = service.getAssetActions(new GetAssetActionsRequest(
project(projectRoot),
AssetReference.forRelativeAssetRoot("bad")));
assertEquals(PackerOperationStatus.PARTIAL, result.status());
assertEquals(1, result.actions().size());
assertFalse(result.actions().getFirst().enabled());
assertNotNull(result.actions().getFirst().reason());
}
@Test
void rejectsRegisterWhenAssetUuidIsAlreadyRegisteredElsewhere() throws Exception {
final Path projectRoot = tempDir.resolve("duplicate-uuid");
Files.createDirectories(projectRoot.resolve("assets/registered/ui_atlas"));
Files.createDirectories(projectRoot.resolve("assets/orphans/ui_clone"));
Files.createDirectories(projectRoot.resolve("assets/.prometeu"));
Files.writeString(projectRoot.resolve("assets/registered/ui_atlas/asset.json"), """
{
"schema_version": 1,
"asset_uuid": "shared-uuid",
"name": "ui_atlas",
"type": "IMAGE/bank",
"inputs": {},
"output": {
"format": "TILES/indexed_v1",
"codec": "none"
},
"preload": {
"enabled": true
}
}
""");
Files.writeString(projectRoot.resolve("assets/orphans/ui_clone/asset.json"), """
{
"schema_version": 1,
"asset_uuid": "shared-uuid",
"name": "ui_clone",
"type": "IMAGE/bank",
"inputs": {},
"output": {
"format": "TILES/indexed_v1",
"codec": "none"
},
"preload": {
"enabled": false
}
}
""");
Files.writeString(projectRoot.resolve("assets/.prometeu/index.json"), """
{
"schema_version": 1,
"next_asset_id": 2,
"assets": [
{
"asset_id": 1,
"asset_uuid": "shared-uuid",
"root": "registered/ui_atlas",
"included_in_build": true
}
]
}
""");
final FileSystemPackerWorkspaceService service = service();
final var actions = service.getAssetActions(new GetAssetActionsRequest(
project(projectRoot),
AssetReference.forRelativeAssetRoot("orphans/ui_clone")));
assertEquals(1, actions.actions().size());
assertFalse(actions.actions().getFirst().enabled());
assertNotNull(actions.actions().getFirst().reason());
final RegisterAssetResult registerResult = service.registerAsset(new RegisterAssetRequest(
project(projectRoot),
AssetReference.forRelativeAssetRoot("orphans/ui_clone")));
assertEquals(PackerOperationStatus.FAILED, registerResult.status());
assertNull(registerResult.assetReference());
}
@Test
void rejectsUnsupportedFormatForSelectedFamily() {
final Path projectRoot = tempDir.resolve("unsupported");
@@ -208,9 +349,17 @@ final class FileSystemPackerWorkspaceServiceTest {
final var foundation = new p.packer.services.PackerWorkspaceFoundation();
final var parser = new p.packer.services.PackerAssetDeclarationParser();
final var runtimeRegistry = new p.packer.services.PackerRuntimeRegistry(new p.packer.services.PackerRuntimeLoader(foundation, parser));
final var detailsService = new p.packer.services.PackerAssetDetailsService(runtimeRegistry);
final var resolver = new p.packer.services.PackerAssetReferenceResolver(foundation.lookup());
final var detailsService = new p.packer.services.PackerAssetDetailsService(runtimeRegistry, resolver);
final var actionReadService = new p.packer.services.PackerAssetActionReadService(runtimeRegistry, resolver, foundation.lookup());
final var writeCoordinator = new p.packer.services.PackerProjectWriteCoordinator();
return new FileSystemPackerWorkspaceService(foundation, detailsService, runtimeRegistry, writeCoordinator, eventSink);
return new FileSystemPackerWorkspaceService(
foundation,
detailsService,
actionReadService,
runtimeRegistry,
writeCoordinator,
eventSink);
}
private Path copyFixture(String relativePath, Path targetRoot) throws Exception {
@@ -88,7 +88,9 @@ final class PackerAssetDetailsServiceTest {
private PackerAssetDetailsService service() {
final var foundation = new p.packer.services.PackerWorkspaceFoundation();
final var parser = new PackerAssetDeclarationParser();
return new PackerAssetDetailsService(new PackerRuntimeRegistry(new PackerRuntimeLoader(foundation, parser)));
final var runtimeRegistry = new PackerRuntimeRegistry(new PackerRuntimeLoader(foundation, parser));
final var resolver = new PackerAssetReferenceResolver(foundation.lookup());
return new PackerAssetDetailsService(runtimeRegistry, resolver);
}
private Path copyFixture(String relativePath, Path targetRoot) throws Exception {