asset walker (WIP)

This commit is contained in:
2026-03-24 13:42:49 +00:00
parent 5b2e2b023f
commit 92c74c7bd0
43 changed files with 1565 additions and 726 deletions
@@ -1,134 +0,0 @@
package p.packer.services;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.ObjectMapper;
import p.packer.exceptions.PackerRegistryException;
import p.packer.messages.PackerProjectContext;
import p.packer.models.PackerRegistryEntry;
import p.packer.models.PackerRegistryState;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.*;
public final class FileSystemPackerRegistryRepository implements PackerRegistryRepository {
private static final ObjectMapper MAPPER = new ObjectMapper();
private static final int REGISTRY_SCHEMA_VERSION = 1;
@Override
public PackerRegistryState load(PackerProjectContext project) {
final Path registryPath = PackerWorkspacePaths.registryPath(project);
if (!Files.isRegularFile(registryPath)) {
return emptyState();
}
try {
final RegistryDocument document = MAPPER.readValue(registryPath.toFile(), RegistryDocument.class);
final int schemaVersion = document.schemaVersion <= 0 ? REGISTRY_SCHEMA_VERSION : document.schemaVersion;
if (schemaVersion != REGISTRY_SCHEMA_VERSION) {
throw new p.packer.exceptions.PackerRegistryException("Unsupported registry schema_version: " + schemaVersion);
}
final List<PackerRegistryEntry> entries = new ArrayList<>();
if (document.assets != null) {
for (RegistryAssetDocument asset : document.assets) {
if (asset == null) {
continue;
}
entries.add(new PackerRegistryEntry(
asset.assetId,
asset.assetUuid,
normalizeRoot(asset.root),
asset.includedInBuild == null || asset.includedInBuild));
}
}
validateEntries(entries);
final int nextAssetId = document.nextAssetId > 0
? document.nextAssetId
: entries.stream().mapToInt(PackerRegistryEntry::assetId).max().orElse(0) + 1;
return new PackerRegistryState(
schemaVersion,
nextAssetId,
entries.stream().sorted(Comparator.comparingInt(PackerRegistryEntry::assetId)).toList());
} catch (IOException exception) {
throw new p.packer.exceptions.PackerRegistryException("Unable to load registry: " + registryPath, exception);
}
}
@Override
public void save(PackerProjectContext project, PackerRegistryState state) {
final Path registryDirectory = PackerWorkspacePaths.registryDirectory(project);
final Path registryPath = PackerWorkspacePaths.registryPath(project);
validateEntries(state.assets());
try {
Files.createDirectories(registryDirectory);
final RegistryDocument document = new RegistryDocument();
document.schemaVersion = state.schemaVersion();
document.nextAssetId = state.nextAssetId();
document.assets = state.assets().stream()
.map(entry -> new RegistryAssetDocument(
entry.assetId(),
entry.assetUuid(),
entry.root(),
entry.includedInBuild()))
.toList();
MAPPER.writerWithDefaultPrettyPrinter().writeValue(registryPath.toFile(), document);
} catch (IOException exception) {
throw new p.packer.exceptions.PackerRegistryException("Unable to save registry: " + registryPath, exception);
}
}
private PackerRegistryState emptyState() {
return new PackerRegistryState(REGISTRY_SCHEMA_VERSION, 1, List.of());
}
private void validateEntries(List<PackerRegistryEntry> entries) throws PackerRegistryException {
final Set<Integer> assetIds = new HashSet<>();
final Set<String> assetUuids = new HashSet<>();
final Set<String> roots = new HashSet<>();
for (PackerRegistryEntry entry : entries) {
if (!assetIds.add(entry.assetId())) {
throw new PackerRegistryException("Duplicate asset_id in registry: " + entry.assetId());
}
if (!assetUuids.add(entry.assetUuid())) {
throw new PackerRegistryException("Duplicate asset_uuid in registry: " + entry.assetUuid());
}
if (!roots.add(entry.root())) {
throw new PackerRegistryException("Duplicate asset root in registry: " + entry.root());
}
}
}
private String normalizeRoot(String root) {
if (root == null || root.isBlank()) {
throw new PackerRegistryException("Registry asset root must not be blank");
}
final String normalized = root.trim().replace('\\', '/');
final Path normalizedPath = Path.of(normalized).normalize();
if (normalizedPath.isAbsolute() || normalizedPath.startsWith("..")) {
throw new PackerRegistryException("Registry asset root is outside the trusted assets boundary: " + normalized);
}
return normalized;
}
@JsonIgnoreProperties(ignoreUnknown = true)
private static final class RegistryDocument {
@JsonProperty("schema_version")
public int schemaVersion;
@JsonProperty("next_asset_id")
public int nextAssetId;
@JsonProperty("assets")
public List<RegistryAssetDocument> assets = List.of();
}
@JsonIgnoreProperties(ignoreUnknown = true)
private record RegistryAssetDocument(
@JsonProperty("asset_id") int assetId,
@JsonProperty("asset_uuid") String assetUuid,
@JsonProperty("root") String root,
@JsonProperty("included_in_build") Boolean includedInBuild) {
}
}
@@ -3,6 +3,7 @@ package p.packer.services;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import p.packer.PackerWorkspacePaths;
import p.packer.PackerWorkspaceService;
import p.packer.events.PackerEventKind;
import p.packer.events.PackerEventSink;
@@ -12,6 +13,7 @@ import p.packer.messages.assets.*;
import p.packer.messages.diagnostics.PackerDiagnosticCategory;
import p.packer.messages.diagnostics.PackerDiagnosticSeverity;
import p.packer.models.*;
import p.packer.repositories.PackerRuntimeRegistry;
import java.io.IOException;
import java.nio.file.Files;
@@ -57,14 +59,14 @@ public final class FileSystemPackerWorkspaceService implements PackerWorkspaceSe
@Override
public ListAssetsResult listAssets(ListAssetsRequest request) {
final PackerProjectContext project = Objects.requireNonNull(request, "request").project();
final PackerRuntimeSnapshot snapshot = request.deepSync()
final var project = Objects.requireNonNull(request, "request").project();
final var snapshot = request.deepSync()
? runtimeRegistry.refresh(project).snapshot()
: runtimeRegistry.getOrLoad(project).snapshot();
final PackerOperationEventEmitter events = new PackerOperationEventEmitter(project, eventSink);
final PackerRegistryState registry = snapshot.registry();
final var events = new PackerOperationEventEmitter(project, eventSink);
final var registry = snapshot.registry();
final Map<Path, PackerRegistryEntry> registryByRoot = new HashMap<>();
for (PackerRegistryEntry entry : registry.assets()) {
for (final var entry : registry.assets()) {
registryByRoot.put(PackerWorkspacePaths.assetRoot(project, entry.root()), entry);
}
@@ -75,15 +77,15 @@ public final class FileSystemPackerWorkspaceService implements PackerWorkspaceSe
final List<PackerRuntimeAsset> runtimeAssets = snapshot.assets();
final int total = runtimeAssets.size();
for (int index = 0; index < runtimeAssets.size(); index += 1) {
final PackerRuntimeAsset runtimeAsset = runtimeAssets.get(index);
final Path assetRoot = runtimeAsset.assetRoot();
final Path assetManifestPath = runtimeAsset.manifestPath();
final var runtimeAsset = runtimeAssets.get(index);
final var assetRoot = runtimeAsset.assetRoot();
final var assetManifestPath = runtimeAsset.manifestPath();
discoveredRoots.add(assetRoot);
final PackerRegistryEntry registryEntry = registryByRoot.get(assetRoot);
final PackerAssetDeclarationParseResult parsed = runtimeAsset.parsedDeclaration();
final var registryEntry = registryByRoot.get(assetRoot);
final var parsed = runtimeAsset.parsedDeclaration();
diagnostics.addAll(parsed.diagnostics());
diagnostics.addAll(identityMismatchDiagnostics(registryEntry, parsed, assetManifestPath));
final PackerAssetSummary summary = buildSummary(project, assetRoot, registryEntry, parsed);
final var summary = buildSummary(project, assetRoot, registryEntry, parsed);
assets.add(summary);
events.emit(
PackerEventKind.ASSET_DISCOVERED,
@@ -92,8 +94,8 @@ public final class FileSystemPackerWorkspaceService implements PackerWorkspaceSe
List.of(summary.identity().assetName()));
}
for (PackerRegistryEntry entry : registry.assets()) {
final Path registeredRoot = PackerWorkspacePaths.assetRoot(project, entry.root());
for (final var entry : registry.assets()) {
final var registeredRoot = PackerWorkspacePaths.assetRoot(project, entry.root());
if (!discoveredRoots.contains(registeredRoot)) {
diagnostics.add(new PackerDiagnostic(
PackerDiagnosticSeverity.ERROR,
@@ -107,7 +109,7 @@ public final class FileSystemPackerWorkspaceService implements PackerWorkspaceSe
assets.sort(Comparator
.comparing((PackerAssetSummary asset) -> asset.identity().assetRoot().toString(), String.CASE_INSENSITIVE_ORDER)
.thenComparing(summary -> summary.identity().assetName(), String.CASE_INSENSITIVE_ORDER));
final PackerOperationStatus status = diagnostics.stream().anyMatch(PackerDiagnostic::blocking)
final var status = diagnostics.stream().anyMatch(PackerDiagnostic::blocking)
? PackerOperationStatus.PARTIAL
: PackerOperationStatus.SUCCESS;
if (!diagnostics.isEmpty()) {
@@ -1,10 +1,12 @@
package p.packer.services;
import p.packer.PackerWorkspacePaths;
import p.packer.messages.*;
import p.packer.messages.assets.AssetAction;
import p.packer.messages.diagnostics.PackerDiagnosticCategory;
import p.packer.messages.diagnostics.PackerDiagnosticSeverity;
import p.packer.models.*;
import p.packer.repositories.PackerRuntimeRegistry;
import java.nio.file.Path;
import java.util.ArrayList;
@@ -16,7 +16,7 @@ import java.nio.file.Path;
import java.util.*;
public final class PackerAssetDeclarationParser {
private static final int SUPPORTED_SCHEMA_VERSION = 1;
private static final Set<Integer> SUPPORTED_SCHEMA_VERSIONS = Set.of(1);
private final ObjectMapper mapper;
@@ -40,17 +40,17 @@ public final class PackerAssetDeclarationParser {
return new PackerAssetDeclarationParseResult(null, diagnostics);
}
final Integer schemaVersion = requiredInt(root, "schema_version", diagnostics, manifestPath);
final String assetUuid = requiredText(root, "asset_uuid", diagnostics, manifestPath);
final String name = requiredText(root, "name", diagnostics, manifestPath);
final AssetFamilyCatalog assetFamily = requiredAssetFamily(root, diagnostics, manifestPath);
final Map<String, List<String>> inputsByRole = requiredInputs(root.path("inputs"), diagnostics, manifestPath);
final OutputFormatCatalog outputFormat = requiredOutputFormat(root.path("output"), diagnostics, manifestPath);
final OutputCodecCatalog outputCodec = requiredOutputCodec(root.path("output"), diagnostics, manifestPath);
final Map<String, String> outputMetadata = optionalOutputMetadata(root.path("output"), diagnostics, manifestPath);
final Boolean preloadEnabled = requiredBoolean(root.path("preload"), "enabled", diagnostics, manifestPath);
final var schemaVersion = requiredInt(root, "schema_version", diagnostics, manifestPath);
final var assetUuid = requiredText(root, "asset_uuid", diagnostics, manifestPath);
final var name = requiredText(root, "name", diagnostics, manifestPath);
final var assetFamily = requiredAssetFamily(root, diagnostics, manifestPath);
final var inputsByRole = requiredInputs(root.path("inputs"), diagnostics, manifestPath);
final var outputFormat = requiredOutputFormat(root.path("output"), diagnostics, manifestPath);
final var outputCodec = requiredOutputCodec(root.path("output"), diagnostics, manifestPath);
final var outputMetadata = optionalOutputMetadata(root.path("output"), diagnostics, manifestPath);
final var preloadEnabled = requiredBoolean(root.path("preload"), "enabled", diagnostics, manifestPath);
if (schemaVersion != null && schemaVersion != SUPPORTED_SCHEMA_VERSION) {
if (schemaVersion != null && !SUPPORTED_SCHEMA_VERSIONS.contains(schemaVersion)) {
diagnostics.add(new PackerDiagnostic(
PackerDiagnosticSeverity.ERROR,
PackerDiagnosticCategory.VERSIONING,
@@ -77,7 +77,11 @@ public final class PackerAssetDeclarationParser {
diagnostics);
}
private Integer requiredInt(JsonNode node, String fieldName, List<PackerDiagnostic> diagnostics, Path manifestPath) {
private Integer requiredInt(
final JsonNode node,
final String fieldName,
final List<PackerDiagnostic> diagnostics,
final Path manifestPath) {
final JsonNode field = node.path(fieldName);
if (!field.isInt()) {
diagnostics.add(missingOrInvalid(fieldName, "integer", manifestPath));
@@ -86,7 +90,11 @@ public final class PackerAssetDeclarationParser {
return field.intValue();
}
private String requiredText(JsonNode node, String fieldName, List<PackerDiagnostic> diagnostics, Path manifestPath) {
private String requiredText(
final JsonNode node,
final String fieldName,
final List<PackerDiagnostic> diagnostics,
final Path manifestPath) {
final JsonNode field = node.path(fieldName);
if (!field.isTextual() || field.asText().isBlank()) {
diagnostics.add(missingOrInvalid(fieldName, "non-blank string", manifestPath));
@@ -95,7 +103,10 @@ public final class PackerAssetDeclarationParser {
return field.asText().trim();
}
private AssetFamilyCatalog requiredAssetFamily(JsonNode node, List<PackerDiagnostic> diagnostics, Path manifestPath) {
private AssetFamilyCatalog requiredAssetFamily(
final JsonNode node,
final List<PackerDiagnostic> diagnostics,
final Path manifestPath) {
final String manifestType = requiredText(node, "type", diagnostics, manifestPath);
if (manifestType == null) {
return null;
@@ -113,7 +124,11 @@ public final class PackerAssetDeclarationParser {
return assetFamily;
}
private Boolean requiredBoolean(JsonNode node, String fieldName, List<PackerDiagnostic> diagnostics, Path manifestPath) {
private Boolean requiredBoolean(
final JsonNode node,
final String fieldName,
final List<PackerDiagnostic> diagnostics,
final Path manifestPath) {
final JsonNode field = node.path(fieldName);
if (!field.isBoolean()) {
diagnostics.add(missingOrInvalid(fieldName, "boolean", manifestPath));
@@ -122,7 +137,10 @@ public final class PackerAssetDeclarationParser {
return field.booleanValue();
}
private OutputFormatCatalog requiredOutputFormat(JsonNode node, List<PackerDiagnostic> diagnostics, Path manifestPath) {
private OutputFormatCatalog requiredOutputFormat(
final JsonNode node,
final List<PackerDiagnostic> diagnostics,
final Path manifestPath) {
final String fmtValue = requiredText(node, "format", diagnostics, manifestPath);
if (fmtValue == null) {
return null;
@@ -140,7 +158,10 @@ public final class PackerAssetDeclarationParser {
return outputFormat;
}
private OutputCodecCatalog requiredOutputCodec(JsonNode node, List<PackerDiagnostic> diagnostics, Path manifestPath) {
private OutputCodecCatalog requiredOutputCodec(
final JsonNode node,
final List<PackerDiagnostic> diagnostics,
final Path manifestPath) {
final String codecValue = requiredText(node, "codec", diagnostics, manifestPath);
if (codecValue == null) {
return null;
@@ -159,10 +180,10 @@ public final class PackerAssetDeclarationParser {
}
private Map<String, String> optionalOutputMetadata(
JsonNode outputNode,
List<PackerDiagnostic> diagnostics,
Path manifestPath) {
final JsonNode metadataNode = outputNode.path("metadata");
final JsonNode node,
final List<PackerDiagnostic> diagnostics,
final Path manifestPath) {
final JsonNode metadataNode = node.path("metadata");
if (metadataNode.isMissingNode() || metadataNode.isNull()) {
return Map.of();
}
@@ -205,14 +226,17 @@ public final class PackerAssetDeclarationParser {
return Map.copyOf(metadata);
}
private Map<String, List<String>> requiredInputs(JsonNode inputsNode, List<PackerDiagnostic> diagnostics, Path manifestPath) {
if (!inputsNode.isObject()) {
private Map<String, List<String>> requiredInputs(
final JsonNode node,
final List<PackerDiagnostic> diagnostics,
final Path manifestPath) {
if (!node.isObject()) {
diagnostics.add(missingOrInvalid("inputs", "object of input roles", manifestPath));
return Map.of();
}
final Map<String, List<String>> result = new LinkedHashMap<>();
inputsNode.fields().forEachRemaining(entry -> {
node.fields().forEachRemaining(entry -> {
if (!entry.getValue().isArray()) {
diagnostics.add(new PackerDiagnostic(
PackerDiagnosticSeverity.ERROR,
@@ -250,12 +274,15 @@ public final class PackerAssetDeclarationParser {
return Map.copyOf(result);
}
private boolean isTrustedRelativePath(String value) {
private boolean isTrustedRelativePath(final String value) {
final Path path = Path.of(value).normalize();
return !path.isAbsolute() && !path.startsWith("..");
}
private PackerDiagnostic missingOrInvalid(String fieldName, String expected, Path manifestPath) {
private PackerDiagnostic missingOrInvalid(
final String fieldName,
final String expected,
final Path manifestPath) {
return new PackerDiagnostic(
PackerDiagnosticSeverity.ERROR,
PackerDiagnosticCategory.STRUCTURAL,
@@ -1,10 +1,12 @@
package p.packer.services;
import p.packer.PackerWorkspacePaths;
import p.packer.messages.*;
import p.packer.messages.assets.*;
import p.packer.messages.diagnostics.PackerDiagnosticCategory;
import p.packer.messages.diagnostics.PackerDiagnosticSeverity;
import p.packer.models.*;
import p.packer.repositories.PackerRuntimeRegistry;
import java.nio.file.Path;
import java.util.*;
@@ -1,5 +1,6 @@
package p.packer.services;
import p.packer.PackerWorkspacePaths;
import p.packer.messages.AssetReference;
import p.packer.messages.PackerProjectContext;
import p.packer.messages.diagnostics.PackerDiagnosticCategory;
@@ -1,5 +1,6 @@
package p.packer.services;
import p.packer.PackerWorkspacePaths;
import p.packer.messages.PackerProjectContext;
import p.packer.models.PackerRegistryEntry;
import p.packer.models.PackerRegistryState;
@@ -58,13 +58,13 @@ final class PackerOutputContractCatalog {
"tile_size",
"TileSize",
PackerCodecConfigurationFieldType.ENUM,
"16",
"16x16",
true,
List.of("8", "16", "32")));
List.of("8x8", "16x16", "32x32")));
case SOUND_V1 -> List.of(
new PackerCodecConfigurationField(
"sample_rate",
"Frame Rate",
"Sample Rate",
PackerCodecConfigurationFieldType.ENUM,
"44100",
true,
@@ -1,5 +1,6 @@
package p.packer.services;
import p.packer.PackerWorkspacePaths;
import p.packer.messages.PackerProjectContext;
import p.packer.models.PackerRegistryEntry;
import p.packer.models.PackerRegistryState;
@@ -1,10 +0,0 @@
package p.packer.services;
import p.packer.messages.PackerProjectContext;
import p.packer.models.PackerRegistryState;
public interface PackerRegistryRepository {
PackerRegistryState load(PackerProjectContext project);
void save(PackerProjectContext project, PackerRegistryState state);
}
@@ -1,69 +0,0 @@
package p.packer.services;
import p.packer.messages.InitWorkspaceRequest;
import p.packer.messages.PackerProjectContext;
import p.packer.models.PackerRegistryEntry;
import p.packer.models.PackerRegistryState;
import p.packer.models.PackerRuntimeAsset;
import p.packer.models.PackerRuntimeSnapshot;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.*;
import java.util.stream.Collectors;
public final class PackerRuntimeLoader implements PackerRuntimeSnapshotLoader {
private final PackerWorkspaceFoundation workspaceFoundation;
private final PackerAssetDeclarationParser parser;
public PackerRuntimeLoader(
PackerWorkspaceFoundation workspaceFoundation,
PackerAssetDeclarationParser parser) {
this.workspaceFoundation = Objects.requireNonNull(workspaceFoundation, "workspaceFoundation");
this.parser = Objects.requireNonNull(parser, "parser");
}
private boolean isAssetJson(Path path, BasicFileAttributes attrs) {
return attrs.isRegularFile() && path.getFileName().toString().equals("asset.json");
}
@Override
public PackerRuntimeSnapshot load(PackerProjectContext project, long generation) {
final PackerProjectContext safeProject = Objects.requireNonNull(project, "project");
workspaceFoundation.initWorkspace(new InitWorkspaceRequest(safeProject));
final PackerRegistryState registry = workspaceFoundation.loadRegistry(safeProject);
final Map<Path, PackerRegistryEntry> registryByRoot = registry.assets().stream()
.collect(Collectors.toMap(
entry -> PackerWorkspacePaths.assetRoot(safeProject, entry.root()),
entry -> entry));
final List<PackerRuntimeAsset> assets = new ArrayList<>();
final var assetsRoot = PackerWorkspacePaths.assetsRoot(safeProject);
if (Files.isDirectory(assetsRoot)) {
try (final var paths = Files.find(assetsRoot, Integer.MAX_VALUE, this::isAssetJson)) {
final var manifests = paths
.map(path -> path.toAbsolutePath().normalize())
.sorted(Comparator.naturalOrder())
.toList();
for (final var manifestPath : manifests) {
final var assetRoot = manifestPath.getParent();
final var registryEntry = Optional.ofNullable(registryByRoot.get(assetRoot));
assets.add(new PackerRuntimeAsset(
assetRoot,
manifestPath,
registryEntry,
parser.parse(manifestPath)));
}
} catch (IOException exception) {
throw new p.packer.exceptions.PackerRegistryException(
"Unable to build runtime snapshot for " + safeProject.projectId(),
exception);
}
}
return new PackerRuntimeSnapshot(generation, registry, assets);
}
}
@@ -1,94 +0,0 @@
package p.packer.services;
import p.packer.messages.PackerProjectContext;
import p.packer.models.PackerRuntimeSnapshot;
import java.nio.file.Path;
import java.util.Objects;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.atomic.AtomicLong;
import java.util.function.BiFunction;
public final class PackerRuntimeRegistry {
private final PackerRuntimeSnapshotLoader loader;
private final ConcurrentMap<ProjectKey, PackerProjectRuntime> runtimes = new ConcurrentHashMap<>();
private final AtomicLong nextGeneration = new AtomicLong(1L);
public PackerRuntimeRegistry(PackerRuntimeSnapshotLoader loader) {
this.loader = Objects.requireNonNull(loader, "loader");
}
public PackerProjectRuntime getOrLoad(PackerProjectContext project) {
final PackerProjectContext safeProject = Objects.requireNonNull(project, "project");
final ProjectKey key = ProjectKey.from(safeProject);
return runtimes.compute(key, (ignored, current) -> {
if (current != null && !current.disposed()) {
return current;
}
return new PackerProjectRuntime(safeProject, loader.load(safeProject, nextGeneration.getAndIncrement()));
});
}
public Optional<PackerProjectRuntime> find(PackerProjectContext project) {
return Optional.ofNullable(runtimes.get(ProjectKey.from(Objects.requireNonNull(project, "project"))));
}
public PackerProjectRuntime refresh(PackerProjectContext project) {
final PackerProjectContext safeProject = Objects.requireNonNull(project, "project");
final ProjectKey key = ProjectKey.from(safeProject);
return runtimes.compute(key, (ignored, current) -> {
final var snapshot = loader.load(safeProject, nextGeneration.getAndIncrement());
if (current == null || current.disposed()) {
return new PackerProjectRuntime(safeProject, snapshot);
}
current.replaceSnapshot(snapshot);
return current;
});
}
public PackerProjectRuntime update(
PackerProjectContext project,
BiFunction<PackerRuntimeSnapshot, Long, PackerRuntimeSnapshot> updater) {
final PackerProjectContext safeProject = Objects.requireNonNull(project, "project");
final BiFunction<PackerRuntimeSnapshot, Long, PackerRuntimeSnapshot> safeUpdater =
Objects.requireNonNull(updater, "updater");
final ProjectKey key = ProjectKey.from(safeProject);
return runtimes.compute(key, (ignored, current) -> {
if (current == null || current.disposed()) {
return new PackerProjectRuntime(safeProject, loader.load(safeProject, nextGeneration.getAndIncrement()));
}
try {
final long generation = nextGeneration.getAndIncrement();
current.updateSnapshot(snapshot -> safeUpdater.apply(snapshot, generation));
} catch (RuntimeException exception) {
current.replaceSnapshot(loader.load(safeProject, nextGeneration.getAndIncrement()));
}
return current;
});
}
public void dispose(PackerProjectContext project) {
final PackerProjectRuntime removed = runtimes.remove(ProjectKey.from(Objects.requireNonNull(project, "project")));
if (removed != null) {
removed.dispose();
}
}
public void disposeAll() {
runtimes.values().forEach(PackerProjectRuntime::dispose);
runtimes.clear();
}
private record ProjectKey(
String projectId,
Path rootPath) {
private static ProjectKey from(PackerProjectContext project) {
return new ProjectKey(
Objects.requireNonNull(project.projectId(), "projectId"),
Objects.requireNonNull(project.rootPath(), "rootPath").toAbsolutePath().normalize());
}
}
}
@@ -1,9 +0,0 @@
package p.packer.services;
import p.packer.messages.PackerProjectContext;
import p.packer.models.PackerRuntimeSnapshot;
@FunctionalInterface
public interface PackerRuntimeSnapshotLoader {
PackerRuntimeSnapshot load(PackerProjectContext project, long generation);
}
@@ -1,11 +1,14 @@
package p.packer.services;
import com.fasterxml.jackson.databind.ObjectMapper;
import p.packer.PackerWorkspacePaths;
import p.packer.messages.InitWorkspaceRequest;
import p.packer.messages.InitWorkspaceResult;
import p.packer.messages.PackerOperationStatus;
import p.packer.messages.PackerProjectContext;
import p.packer.models.PackerRegistryEntry;
import p.packer.models.PackerRegistryState;
import p.packer.repositories.FileSystemPackerRegistryRepository;
import java.nio.file.Files;
import java.nio.file.Path;
@@ -17,8 +20,8 @@ public final class PackerWorkspaceFoundation {
private final PackerIdentityAllocator identityAllocator;
private final PackerRegistryLookup registryLookup;
public PackerWorkspaceFoundation() {
this(new FileSystemPackerRegistryRepository(), new PackerIdentityAllocator(), new PackerRegistryLookup());
public PackerWorkspaceFoundation(final ObjectMapper mapper) {
this(new FileSystemPackerRegistryRepository(mapper), new PackerIdentityAllocator(), new PackerRegistryLookup());
}
public PackerWorkspaceFoundation(
@@ -1,35 +0,0 @@
package p.packer.services;
import p.packer.messages.PackerProjectContext;
import java.nio.file.Path;
import java.util.Objects;
public final class PackerWorkspacePaths {
private static final String ASSETS_DIR = "assets";
private static final String PROMETEU_DIR = ".prometeu";
private static final String REGISTRY_FILE = "index.json";
private PackerWorkspacePaths() {
}
public static Path assetsRoot(PackerProjectContext project) {
return Objects.requireNonNull(project, "project").rootPath().resolve(ASSETS_DIR).toAbsolutePath().normalize();
}
public static Path registryDirectory(PackerProjectContext project) {
return assetsRoot(project).resolve(PROMETEU_DIR).toAbsolutePath().normalize();
}
public static Path registryPath(PackerProjectContext project) {
return registryDirectory(project).resolve(REGISTRY_FILE).toAbsolutePath().normalize();
}
public static Path assetRoot(PackerProjectContext project, String relativeRoot) {
return assetsRoot(project).resolve(relativeRoot).toAbsolutePath().normalize();
}
public static String relativeAssetRoot(PackerProjectContext project, Path assetRoot) {
return assetsRoot(project).relativize(assetRoot.toAbsolutePath().normalize()).toString().replace('\\', '/');
}
}