Add distribution builder

Author: codedmonkey

src/Package/PackageDistributionResolver.php

@@ -5,12 +5,20 @@
 namespace CodedMonkey\Dirigent\Package;
 
 use CodedMonkey\Dirigent\Composer\ComposerClient;
+use CodedMonkey\Dirigent\Composer\ConfigFactory;
 use CodedMonkey\Dirigent\Doctrine\Entity\Distribution;
 use CodedMonkey\Dirigent\Doctrine\Entity\Metadata;
 use CodedMonkey\Dirigent\Doctrine\Entity\Package;
 use CodedMonkey\Dirigent\Doctrine\Entity\Version;
 use CodedMonkey\Dirigent\Doctrine\Repository\DistributionRepository;
+use CodedMonkey\Dirigent\Entity\PackageFetchStrategy;
 use CodedMonkey\Dirigent\Message\ResolveDistribution;
+use Composer\IO\NullIO;
+use Composer\Pcre\Preg;
+use Composer\Util\Filesystem as ComposerFilesystem;
+use Composer\Util\Git as GitUtility;
+use Composer\Util\ProcessExecutor;
+use Composer\Util\Url;
 use Symfony\Component\DependencyInjection\Attribute\Autowire;
 use Symfony\Component\Filesystem\Filesystem;
 use Symfony\Component\Lock\LockFactory;
@@ -28,6 +36,10 @@ public function __construct(
         private ComposerClient $composer,
         private DistributionRepository $distributionRepository,
         private LockFactory $lockFactory,
+        #[Autowire(param: 'dirigent.distributions.build')]
+        private bool $buildDistributions,
+        #[Autowire(param: 'dirigent.distributions.mirror')]
+        private bool $mirrorDistributions,
         #[Autowire(param: 'dirigent.distributions.dev_versions')]
         private bool $includeDevVersions,
         #[Autowire(param: 'dirigent.storage.path')]
@@ -37,7 +49,7 @@ public function __construct(
         $this->storagePath = "$storagePath/distribution";
     }
 
-    public function exists(Metadata|string $metadataOrPath, string $reference, string $type): bool
+    public function exists(Metadata|string $metadataOrPath, ?string $reference = null, ?string $type = null): bool
     {
         if ($metadataOrPath instanceof Metadata) {
             return $this->filesystem->exists($this->path($metadataOrPath, $reference, $type));
@@ -102,15 +114,20 @@ public function removeVersion(Version $version): void
 
     public function resolve(Metadata $metadata, string $reference, string $type, bool $async): bool
     {
-        if ($this->exists($metadata, $reference, $type)) {
+        $path = $this->path($metadata, $reference, $type);
+
+        if ($this->exists($path)) {
             return true;
         }
 
-        if ($reference !== $metadata->getDistributionReference() || $type !== $metadata->getDistributionType()) {
+        if (null === $strategy = $this->getFetchStrategy($metadata)) {
             return false;
         }
 
-        if ($metadata->getVersion()->isDevelopment() && !$this->includeDevVersions) {
+        $currentReference = $strategy->isMirror() ? $metadata->getDistributionReference() : $metadata->getSourceReference();
+        $currentType = $strategy->isMirror() ? $metadata->getDistributionType() : 'zip';
+
+        if ($reference !== $currentReference || $type !== $currentType) {
             return false;
         }
 
@@ -124,41 +141,119 @@ public function resolve(Metadata $metadata, string $reference, string $type, boo
             return false;
         }
 
-        $distributionUrl = $metadata->getDistributionUrl();
-        $path = $this->path($metadata, $reference, $type);
-
         $lock = $this->createDistributionLock($path);
 
         try {
-            if ($this->filesystem->exists($path)) {
-                return true;
-            }
-
             if (null === $distribution = $this->distributionRepository->findOneByReferenceAndType($metadata, $reference, $type)) {
                 $distribution = new Distribution($metadata, $reference, $type);
             }
 
-            $this->filesystem->mkdir(dirname($path));
-
-            $httpDownloader = $this->composer->createHttpDownloader();
-            $httpDownloader->copy($distributionUrl, $path);
+            $result = false;
+
+            // Build the distribution from VCS source
+            if ($strategy->isVcs()) {
+                $result = $this->build($distribution);
+
+                if (
+                    !$result
+                    && $this->mirrorDistributions
+                    && $metadata->hasDistribution()
+                    && $reference === $metadata->getDistributionReference()
+                    && $type === $metadata->getDistributionType()
+                ) {
+                    // Mirror the distribution if it failed to build from source
+                    // todo log fallback
+                    $strategy = PackageFetchStrategy::Mirror;
+                }
+            }
 
-            $distribution->setSource($distributionUrl);
-            $distribution->setResolvedAt();
+            if ($strategy->isMirror()) {
+                $result = $this->mirror($distribution, $path);
+            }
 
-            $this->distributionRepository->save($distribution, true);
+            if ($result) {
+                $distribution->setResolvedAt();
+                $this->distributionRepository->save($distribution, true);
+            }
 
-            return true;
+            return $result;
         } finally {
             $lock->release();
         }
     }
 
+    private function build(Distribution $distribution): bool
+    {
+        $metadata = $distribution->getMetadata();
+        $reference = $distribution->getReference();
+
+        $package = $metadata->getPackage();
+        $repositoryUrl = $package->getRepositoryUrl();
+        $distributionPath = $this->path($metadata, $reference, 'zip');
+
+        $composerConfig = ConfigFactory::createForVcsRepository($repositoryUrl, $package->getRepositoryCredentials());
+
+        $gitUtility = new GitUtility(
+            $io = new NullIO(),
+            $composerConfig,
+            $process = new ProcessExecutor($io),
+            new ComposerFilesystem($process),
+        );
+
+        $cacheRepositoryName = Preg::replace('{[^a-z0-9.]}i', '-', Url::sanitize($repositoryUrl));
+        $cachePath = $composerConfig->get('cache-vcs-dir') . '/' . $cacheRepositoryName . '/';
+
+        $this->filesystem->mkdir(dirname($distributionPath));
+
+        $gitUtility->runCommands([
+            ['git', 'archive', '--format=zip', "--output=$distributionPath", $reference],
+        ], $repositoryUrl, $cachePath);
+
+        $distribution->setSource(null);
+
+        return true;
+    }
+
+    private function mirror(Distribution $distribution, string $path): bool
+    {
+        $url = $distribution->getMetadata()->getDistributionUrl();
+
+        $this->filesystem->mkdir(dirname($path));
+
+        $httpDownloader = $this->composer->createHttpDownloader();
+        $httpDownloader->copy($url, $path);
+
+        $distribution->setSource($url);
+
+        return true;
+    }
+
     private function createDistributionLock(string $path): SharedLockInterface
     {
         $lock = $this->lockFactory->createLock('distribution.' . hash('sha256', $path), ttl: null);
         $lock->acquire(blocking: true);
 
         return $lock;
     }
+
+    private function getFetchStrategy(Metadata $metadata): ?PackageFetchStrategy
+    {
+        $fetchStrategy = $metadata->getPackage()->getFetchStrategy();
+
+        if (!$this->includeDevVersions && $metadata->getVersion()->isDevelopment()) {
+            // Development versions are not supported by the configuration
+            return null;
+        } elseif ($this->buildDistributions && $fetchStrategy->isVcs()) {
+            // Only build distributions if the fetch strategy is VCS (not source because it might not contain VCS data)
+            return PackageFetchStrategy::Vcs;
+        } elseif (
+            $this->mirrorDistributions
+            && ($fetchStrategy->isMirror() || $metadata->hasDistribution())
+        ) {
+            // Always mirror distributions if building from source is not supported and a distribution is available
+            return PackageFetchStrategy::Mirror;
+        }
+
+        return null;
+    }
 }

tests/UnitTests/Package/PackageDistributionResolverTest.php

@@ -46,6 +46,8 @@ public function testRemoveDeletesDistributionFile(): void
             $this->createStub(DistributionRepository::class),
             $lockFactory = $this->createMock(LockFactory::class),
             true,
+            true,
+            true,
             $this->storagePath,
         );
 
@@ -77,6 +79,8 @@ public function testRemoveKeepsNonEmptyPackageDirectory(): void
             $this->createStub(DistributionRepository::class),
             $this->createStub(LockFactory::class),
             true,
+            true,
+            true,
             $this->storagePath,
         );