Use Symfony locks to prevent a distribution from being resolved multiple times at once

Author: codedmonkey

src/Package/PackageDistributionResolver.php

@@ -11,6 +11,7 @@
 use CodedMonkey\Dirigent\Message\ResolveDistribution;
 use Symfony\Component\DependencyInjection\Attribute\Autowire;
 use Symfony\Component\Filesystem\Filesystem;
+use Symfony\Component\Lock\LockFactory;
 use Symfony\Component\Messenger\MessageBusInterface;
 use Symfony\Component\Messenger\Stamp\TransportNamesStamp;
 
@@ -23,6 +24,7 @@ public function __construct(
         private MessageBusInterface $messenger,
         private ComposerClient $composer,
         private DistributionRepository $distributionRepository,
+        private LockFactory $lockFactory,
         #[Autowire(param: 'dirigent.distributions.dev_versions')]
         private bool $includeDevVersions,
         #[Autowire(param: 'dirigent.storage.path')]
@@ -74,23 +76,34 @@ public function resolve(Metadata $metadata, string $reference, string $type, boo
             return false;
         }
 
-        if (null === $distribution = $this->distributionRepository->findOneByReferenceAndType($metadata, $reference, $type)) {
-            $distribution = new Distribution($metadata, $reference, $type);
-        }
-
         $distributionUrl = $metadata->getDistributionUrl();
         $path = $this->path($metadata, $reference, $type);
 
-        $this->filesystem->mkdir(dirname($path));
+        $lock = $this->lockFactory->createLock('distribution.' . hash('sha256', $path), ttl: null);
+        $lock->acquire(blocking: true);
+
+        try {
+            if ($this->filesystem->exists($path)) {
+                return true;
+            }
+
+            if (null === $distribution = $this->distributionRepository->findOneByReferenceAndType($metadata, $reference, $type)) {
+                $distribution = new Distribution($metadata, $reference, $type);
+            }
 
-        $httpDownloader = $this->composer->createHttpDownloader();
-        $httpDownloader->copy($distributionUrl, $path);
+            $this->filesystem->mkdir(dirname($path));
 
-        $distribution->setSource($distributionUrl);
-        $distribution->setResolvedAt();
+            $httpDownloader = $this->composer->createHttpDownloader();
+            $httpDownloader->copy($distributionUrl, $path);
 
-        $this->distributionRepository->save($distribution, true);
+            $distribution->setSource($distributionUrl);
+            $distribution->setResolvedAt();
 
-        return true;
+            $this->distributionRepository->save($distribution, true);
+
+            return true;
+        } finally {
+            $lock->release();
+        }
     }
 }

tests/UnitTests/Package/PackageDistributionResolverTest.php

@@ -0,0 +1,75 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CodedMonkey\Dirigent\Tests\UnitTests\Package;
+
+use CodedMonkey\Dirigent\Composer\ComposerClient;
+use CodedMonkey\Dirigent\Doctrine\Repository\DistributionRepository;
+use CodedMonkey\Dirigent\Package\PackageDistributionResolver;
+use CodedMonkey\Dirigent\Tests\Helper\MockEntityFactoryTrait;
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Filesystem\Filesystem;
+use Symfony\Component\Lock\LockFactory;
+use Symfony\Component\Lock\SharedLockInterface;
+use Symfony\Component\Messenger\MessageBusInterface;
+
+#[CoversClass(PackageDistributionResolver::class)]
+class PackageDistributionResolverTest extends TestCase
+{
+    use MockEntityFactoryTrait;
+
+    private string $storagePath;
+
+    #[\Override]
+    protected function setUp(): void
+    {
+        $this->storagePath = sys_get_temp_dir() . '/dirigent-distribution-resolver-' . uniqid();
+    }
+
+    #[\Override]
+    protected function tearDown(): void
+    {
+        new Filesystem()->remove($this->storagePath);
+    }
+
+    public function testResolveRechecksForDistributionAfterAcquiringLock(): void
+    {
+        [, , $metadata] = $this->createMockPackageWithMetadata();
+        $metadata->setDistributionReference('reference');
+        $metadata->setDistributionType('zip');
+        $metadata->setDistributionUrl('https://example.com/distribution.zip');
+
+        $repository = $this->createMock(DistributionRepository::class);
+        $repository->expects(self::never())->method('findOneByReferenceAndType');
+
+        $lock = $this->createMock(SharedLockInterface::class);
+        $lockFactory = $this->createMock(LockFactory::class);
+        $resolver = new PackageDistributionResolver(
+            $this->createStub(MessageBusInterface::class),
+            $this->createStub(ComposerClient::class),
+            $repository,
+            $lockFactory,
+            true,
+            $this->storagePath,
+        );
+        $path = $resolver->path($metadata, 'reference', 'zip');
+
+        $lockFactory->expects(self::once())
+            ->method('createLock')
+            ->with('distribution.' . hash('sha256', $path), null)
+            ->willReturn($lock);
+        $lock->expects(self::once())
+            ->method('acquire')
+            ->with(true)
+            ->willReturnCallback(static function () use ($path): bool {
+                new Filesystem()->dumpFile($path, 'distribution');
+
+                return true;
+            });
+        $lock->expects(self::once())->method('release');
+
+        self::assertTrue($resolver->resolve($metadata, 'reference', 'zip', async: false));
+    }
+}