implements PR-021

This commit is contained in:
2026-03-24 13:42:46 +00:00
parent 4278d045c2
commit 223f9a0f87
10 changed files with 293 additions and 9 deletions
@@ -32,11 +32,13 @@ public final class Packer implements Closeable {
runtimeRegistry,
assetReferenceResolver,
workspaceFoundation.lookup());
final PackerRuntimePatchService runtimePatchService = new PackerRuntimePatchService(declarationParser);
final PackerProjectWriteCoordinator writeCoordinator = new PackerProjectWriteCoordinator();
return new Packer(new FileSystemPackerWorkspaceService(
workspaceFoundation,
assetDetailsService,
assetActionReadService,
runtimePatchService,
runtimeRegistry,
writeCoordinator,
resolvedEventSink), runtimeRegistry, writeCoordinator);
@@ -47,6 +47,7 @@ public final class FileSystemPackerWorkspaceService implements PackerWorkspaceSe
private final PackerWorkspaceFoundation workspaceFoundation;
private final PackerAssetDetailsService detailsService;
private final PackerAssetActionReadService actionReadService;
private final PackerRuntimePatchService runtimePatchService;
private final PackerRuntimeRegistry runtimeRegistry;
private final PackerProjectWriteCoordinator writeCoordinator;
private final PackerEventSink eventSink;
@@ -55,12 +56,14 @@ public final class FileSystemPackerWorkspaceService implements PackerWorkspaceSe
PackerWorkspaceFoundation workspaceFoundation,
PackerAssetDetailsService detailsService,
PackerAssetActionReadService actionReadService,
PackerRuntimePatchService runtimePatchService,
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.runtimePatchService = Objects.requireNonNull(runtimePatchService, "runtimePatchService");
this.runtimeRegistry = Objects.requireNonNull(runtimeRegistry, "runtimeRegistry");
this.writeCoordinator = Objects.requireNonNull(writeCoordinator, "writeCoordinator");
this.eventSink = Objects.requireNonNull(eventSink, "eventSink");
@@ -218,7 +221,13 @@ public final class FileSystemPackerWorkspaceService implements PackerWorkspaceSe
writeManifest(manifestPath, request, entry.assetUuid());
final PackerRegistryState updated = workspaceFoundation.appendAllocatedEntry(registry, entry);
workspaceFoundation.saveRegistry(project, updated);
runtimeRegistry.refresh(project);
runtimeRegistry.update(project, (snapshot, generation) -> runtimePatchService.afterCreateAsset(
snapshot,
generation,
updated,
entry,
assetRoot,
manifestPath));
final CreateAssetResult result = new CreateAssetResult(
PackerOperationStatus.SUCCESS,
"Asset created: " + relativeAssetRoot,
@@ -262,7 +271,12 @@ public final class FileSystemPackerWorkspaceService implements PackerWorkspaceSe
declaration.assetUuid());
final PackerRegistryState updated = workspaceFoundation.appendAllocatedEntry(registry, entry);
workspaceFoundation.saveRegistry(project, updated);
runtimeRegistry.refresh(project);
runtimeRegistry.update(project, (currentSnapshot, generation) -> runtimePatchService.afterRegisterAsset(
currentSnapshot,
generation,
updated,
entry,
assetRoot));
final RegisterAssetResult result = new RegisterAssetResult(
PackerOperationStatus.SUCCESS,
"Asset registered: " + relativeAssetRoot,
@@ -6,6 +6,7 @@ import p.packer.models.PackerRuntimeSnapshot;
import java.util.Objects;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.UnaryOperator;
public final class PackerProjectRuntime {
private final PackerProjectContext project;
@@ -31,6 +32,13 @@ public final class PackerProjectRuntime {
snapshot.set(Objects.requireNonNull(nextSnapshot, "nextSnapshot"));
}
public PackerRuntimeSnapshot updateSnapshot(UnaryOperator<PackerRuntimeSnapshot> updater) {
ensureActive();
return snapshot.updateAndGet(current -> Objects.requireNonNull(
Objects.requireNonNull(updater, "updater").apply(current),
"updatedSnapshot"));
}
public boolean disposed() {
return disposed.get();
}
@@ -19,7 +19,7 @@ import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public final class PackerRuntimeLoader {
public final class PackerRuntimeLoader implements PackerRuntimeSnapshotLoader {
private final PackerWorkspaceFoundation workspaceFoundation;
private final PackerAssetDeclarationParser parser;
@@ -30,6 +30,7 @@ public final class PackerRuntimeLoader {
this.parser = Objects.requireNonNull(parser, "parser");
}
@Override
public PackerRuntimeSnapshot load(PackerProjectContext project, long generation) {
final PackerProjectContext safeProject = Objects.requireNonNull(project, "project");
workspaceFoundation.initWorkspace(new InitWorkspaceRequest(safeProject));
@@ -0,0 +1,68 @@
package p.packer.services;
import p.packer.models.PackerAssetDeclarationParseResult;
import p.packer.models.PackerRegistryEntry;
import p.packer.models.PackerRegistryState;
import p.packer.models.PackerRuntimeAsset;
import p.packer.models.PackerRuntimeSnapshot;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
public final class PackerRuntimePatchService {
private final PackerAssetDeclarationParser declarationParser;
public PackerRuntimePatchService(PackerAssetDeclarationParser declarationParser) {
this.declarationParser = Objects.requireNonNull(declarationParser, "declarationParser");
}
public PackerRuntimeSnapshot afterCreateAsset(
PackerRuntimeSnapshot snapshot,
long generation,
PackerRegistryState updatedRegistry,
PackerRegistryEntry entry,
Path assetRoot,
Path manifestPath) {
final PackerAssetDeclarationParseResult parsed = declarationParser.parse(manifestPath);
final List<PackerRuntimeAsset> updatedAssets = new ArrayList<>(snapshot.assets().stream()
.filter(candidate -> !candidate.assetRoot().equals(assetRoot.toAbsolutePath().normalize()))
.toList());
updatedAssets.add(new PackerRuntimeAsset(
assetRoot,
manifestPath,
Optional.of(entry),
parsed));
updatedAssets.sort(Comparator.comparing(asset -> asset.assetRoot().toString(), String.CASE_INSENSITIVE_ORDER));
return new PackerRuntimeSnapshot(generation, updatedRegistry, updatedAssets);
}
public PackerRuntimeSnapshot afterRegisterAsset(
PackerRuntimeSnapshot snapshot,
long generation,
PackerRegistryState updatedRegistry,
PackerRegistryEntry entry,
Path assetRoot) {
final List<PackerRuntimeAsset> updatedAssets = new ArrayList<>();
boolean patched = false;
for (PackerRuntimeAsset asset : snapshot.assets()) {
if (asset.assetRoot().equals(assetRoot.toAbsolutePath().normalize())) {
updatedAssets.add(new PackerRuntimeAsset(
asset.assetRoot(),
asset.manifestPath(),
Optional.of(entry),
asset.parsedDeclaration()));
patched = true;
} else {
updatedAssets.add(asset);
}
}
if (!patched) {
throw new IllegalStateException("Unable to patch runtime snapshot for unregistered asset: " + assetRoot);
}
return new PackerRuntimeSnapshot(generation, updatedRegistry, updatedAssets);
}
}
@@ -1,8 +1,10 @@
package p.packer.services;
import p.packer.messages.PackerProjectContext;
import p.packer.models.PackerRuntimeSnapshot;
import java.nio.file.Path;
import java.util.function.BiFunction;
import java.util.Objects;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
@@ -10,11 +12,11 @@ import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.atomic.AtomicLong;
public final class PackerRuntimeRegistry {
private final PackerRuntimeLoader loader;
private final PackerRuntimeSnapshotLoader loader;
private final ConcurrentMap<ProjectKey, PackerProjectRuntime> runtimes = new ConcurrentHashMap<>();
private final AtomicLong nextGeneration = new AtomicLong(1L);
public PackerRuntimeRegistry(PackerRuntimeLoader loader) {
public PackerRuntimeRegistry(PackerRuntimeSnapshotLoader loader) {
this.loader = Objects.requireNonNull(loader, "loader");
}
@@ -46,6 +48,27 @@ public final class PackerRuntimeRegistry {
});
}
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) {
@@ -0,0 +1,9 @@
package p.packer.services;
import p.packer.messages.PackerProjectContext;
import p.packer.models.PackerRuntimeSnapshot;
@FunctionalInterface
public interface PackerRuntimeSnapshotLoader {
PackerRuntimeSnapshot load(PackerProjectContext project, long generation);
}
@@ -147,6 +147,32 @@ final class FileSystemPackerWorkspaceServiceTest {
assertTrue(detailsResult.diagnostics().isEmpty());
}
@Test
void createAssetPatchesLoadedSnapshotWithoutWholeProjectReload() throws Exception {
final Path projectRoot = tempDir.resolve("created-no-reload");
final CountingLoader loader = countingLoader();
final FileSystemPackerWorkspaceService service = service(ignored -> { }, loader);
service.listAssets(new ListAssetsRequest(project(projectRoot)));
assertEquals(1, loader.loadCount());
final CreateAssetResult createResult = service.createAsset(new CreateAssetRequest(
project(projectRoot),
"ui/new-atlas",
"new_atlas",
AssetFamilyCatalog.IMAGE_BANK,
OutputFormatCatalog.TILES_INDEXED_V1,
OutputCodecCatalog.NONE,
true));
assertEquals(PackerOperationStatus.SUCCESS, createResult.status());
assertEquals(1, loader.loadCount());
final var detailsResult = service.getAssetDetails(new GetAssetDetailsRequest(project(projectRoot), createResult.assetReference()));
assertEquals(PackerOperationStatus.SUCCESS, detailsResult.status());
assertEquals(1, loader.loadCount());
}
@Test
void exposesRegisterActionForValidUnregisteredAsset() throws Exception {
final Path projectRoot = copyFixture("workspaces/orphan-valid", tempDir.resolve("orphan-actions"));
@@ -201,6 +227,29 @@ final class FileSystemPackerWorkspaceServiceTest {
assertTrue(events.stream().anyMatch(event -> event.kind() == PackerEventKind.ACTION_APPLIED));
}
@Test
void registerAssetPatchesLoadedSnapshotWithoutWholeProjectReload() throws Exception {
final Path projectRoot = copyFixture("workspaces/orphan-valid", tempDir.resolve("register-no-reload"));
final CountingLoader loader = countingLoader();
final FileSystemPackerWorkspaceService service = service(ignored -> { }, loader);
service.listAssets(new ListAssetsRequest(project(projectRoot)));
assertEquals(1, loader.loadCount());
final RegisterAssetResult registerResult = service.registerAsset(new RegisterAssetRequest(
project(projectRoot),
AssetReference.forRelativeAssetRoot("orphans/ui_sounds")));
assertEquals(PackerOperationStatus.SUCCESS, registerResult.status());
assertEquals(1, loader.loadCount());
final var actionsResult = service.getAssetActions(new GetAssetActionsRequest(
project(projectRoot),
registerResult.assetReference()));
assertTrue(actionsResult.actions().isEmpty());
assertEquals(1, loader.loadCount());
}
@Test
void blocksRegisterActionForInvalidDeclaration() throws Exception {
final Path projectRoot = copyFixture("workspaces/invalid-missing-fields", tempDir.resolve("invalid-actions"));
@@ -341,27 +390,59 @@ final class FileSystemPackerWorkspaceServiceTest {
}
private FileSystemPackerWorkspaceService service() {
return service(ignored -> {
});
return service(ignored -> { });
}
private FileSystemPackerWorkspaceService service(p.packer.events.PackerEventSink eventSink) {
return service(eventSink, countingLoader());
}
private FileSystemPackerWorkspaceService service(
p.packer.events.PackerEventSink eventSink,
PackerRuntimeSnapshotLoader loader) {
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 runtimeRegistry = new p.packer.services.PackerRuntimeRegistry(loader);
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 runtimePatchService = new p.packer.services.PackerRuntimePatchService(parser);
final var writeCoordinator = new p.packer.services.PackerProjectWriteCoordinator();
return new FileSystemPackerWorkspaceService(
foundation,
detailsService,
actionReadService,
runtimePatchService,
runtimeRegistry,
writeCoordinator,
eventSink);
}
private CountingLoader countingLoader() {
final var foundation = new p.packer.services.PackerWorkspaceFoundation();
final var parser = new p.packer.services.PackerAssetDeclarationParser();
return new CountingLoader(new p.packer.services.PackerRuntimeLoader(foundation, parser));
}
private static final class CountingLoader implements PackerRuntimeSnapshotLoader {
private final PackerRuntimeSnapshotLoader delegate;
private int loadCount;
private CountingLoader(PackerRuntimeSnapshotLoader delegate) {
this.delegate = delegate;
}
@Override
public synchronized p.packer.models.PackerRuntimeSnapshot load(PackerProjectContext project, long generation) {
loadCount += 1;
return delegate.load(project, generation);
}
private synchronized int loadCount() {
return loadCount;
}
}
private Path copyFixture(String relativePath, Path targetRoot) throws Exception {
final Path sourceRoot = PackerFixtureLocator.fixtureRoot(relativePath);
try (var stream = Files.walk(sourceRoot)) {