implements PR-020
This commit is contained in:
@@ -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);
|
||||
|
||||
+20
@@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
+20
@@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
+20
@@ -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"));
|
||||
}
|
||||
}
|
||||
+85
@@ -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('\\', '/');
|
||||
}
|
||||
}
|
||||
|
||||
+131
@@ -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);
|
||||
}
|
||||
}
|
||||
+9
-71
@@ -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"));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+88
@@ -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();
|
||||
}
|
||||
}
|
||||
+24
@@ -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");
|
||||
|
||||
+16
@@ -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());
|
||||
}
|
||||
}
|
||||
|
||||
+8
@@ -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);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user