Staging -> prod

.github/workflows/reusable-stage-prod-deployment.yml

@@ -102,6 +102,7 @@ jobs:
             --set browserless.connectionTimeout=${{ vars.BROWSERLESS_CONNECTION_TIMEOUT_MS || '30000' }} \
             --set browserless.resources.requests.cpu=${{ vars.BROWSERLESS_CPU || '500m' }} \
             --set browserless.resources.requests.memory=${{ vars.BROWSERLESS_MEMORY || '800Mi' }} \
+            --set api.num_threads=${{ vars.API_NUM_THREADS != null && vars.API_NUM_THREADS || null }} \
             --set api.resources.requests.cpu=${{ vars.PHP_CPU || '1000m' }} \
             --set api.resources.requests.memory=${{ vars.PHP_MEMORY || '500Mi' }} \
             --set api.resources.limits.cpu=${{ vars.PHP_CPULIMIT || '1900m' }} \

.helm/.env-example

@@ -6,6 +6,7 @@ POSTGRES_URL=
 POSTGRES_ADMIN_URL=
 
 API_CACHE_ENABLED=false
+#API_NUM_THREADS=16
 
 BASIC_AUTH_ENABLED=false
 BASIC_AUTH_USERNAME=test

.helm/deploy-to-cluster.sh

@@ -52,6 +52,9 @@ for i in 1; do
   if [ -n "$API_SENTRY_DSN" ]; then
     values="$values --set api.sentryDsn=$API_SENTRY_DSN"
   fi
+  if [ -n "$API_NUM_THREADS" ]; then
+    values="$values --set api.num_threads=$API_NUM_THREADS"
+  fi
   if [ -n "$FRONTEND_SENTRY_DSN" ]; then
     values="$values --set frontend.sentryDsn=$FRONTEND_SENTRY_DSN"
   fi

.helm/ecamp3/templates/api_configmap.yaml

@@ -29,3 +29,6 @@ data:
   {{- else }}
   VARNISH_API_URL: {{ "" | quote }}
   {{- end}}
+  {{- if .Values.api.num_threads }}
+  NUM_THREADS: {{ .Values.api.num_threads | quote }}
+  {{- end }}

.helm/ecamp3/values.yaml

@@ -62,6 +62,7 @@ api:
       clientId: 'WrKABq7GwmC6h1F0W73OGX_fOTHWWXnKXfrPMHOdQWY'
       clientSecret: 'oQ164RDMIAocL6PhmCoeT1Ymcg-7WcOJZdxCnIph5gM'
       baseUrl: 'https://jubla.puzzle.ch'
+  num_threads:
   resources:
     requests:
       cpu: 10m

api/Dockerfile

@@ -12,6 +12,8 @@ FROM dunglas/frankenphp:1.2-php8.3.13 AS frankenphp_upstream
 # Base FrankenPHP image
 FROM frankenphp_upstream AS frankenphp_base
 
+ENV NUM_THREADS=4
+
 WORKDIR /app
 
 # persistent / runtime deps

api/config/services.yaml

@@ -53,6 +53,9 @@ services:
         tags:
             - 'app.input_filter'
 
+    App\Doctrine\Orm\Extension\FilterEagerLoadingsExtension:
+        decorates: 'api_platform.doctrine.orm.query_extension.filter_eager_loading'
+
     App\Serializer\Normalizer\RelatedCollectionLinkNormalizer:
         decorates: 'api_platform.hal.normalizer.item'
         arguments:

api/docker/caddy/Caddyfile

@@ -5,6 +5,7 @@
 	{$CADDY_GLOBAL_OPTIONS}
 
 	frankenphp {
+		num_threads {$NUM_THREADS}
 		{$FRANKENPHP_CONFIG}
 	}
 

api/src/Doctrine/Orm/Extension/FilterEagerLoadingsExtension.php

@@ -0,0 +1,148 @@
+<?php
+
+namespace App\Doctrine\Orm\Extension;
+
+use ApiPlatform\Doctrine\Orm\Extension\QueryCollectionExtensionInterface;
+use ApiPlatform\Doctrine\Orm\Util\QueryNameGeneratorInterface;
+use ApiPlatform\Metadata\Exception\InvalidArgumentException;
+use ApiPlatform\Metadata\Operation;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\Mapping\ClassMetadata;
+use Doctrine\ORM\Mapping\ToManyInverseSideMapping;
+use Doctrine\ORM\Query\Expr\Andx;
+use Doctrine\ORM\Query\Expr\Comparison;
+use Doctrine\ORM\Query\Expr\Func;
+use Doctrine\ORM\Query\Expr\Join;
+use Doctrine\ORM\Query\Expr\Orx;
+use Doctrine\ORM\QueryBuilder;
+
+final class FilterEagerLoadingsExtension implements QueryCollectionExtensionInterface {
+    public function __construct(private QueryCollectionExtensionInterface $decorated) {}
+
+    public function applyToCollection(
+        QueryBuilder $queryBuilder,
+        QueryNameGeneratorInterface $queryNameGenerator,
+        ?string $resourceClass = null,
+        ?Operation $operation = null,
+        array $context = []
+    ): void {
+        if (null === $resourceClass) {
+            throw new InvalidArgumentException('The "$resourceClass" parameter must not be null');
+        }
+
+        $em = $queryBuilder->getEntityManager();
+        $classMetadata = $em->getClassMetadata($resourceClass);
+
+        // If no where part, nothing to do
+        $wherePart = $queryBuilder->getDQLPart('where');
+
+        if (!$wherePart) {
+            return;
+        }
+
+        $joinParts = $queryBuilder->getDQLPart('join');
+        $originAlias = $queryBuilder->getRootAliases()[0];
+
+        if (!$joinParts || !isset($joinParts[$originAlias])) {
+            return;
+        }
+
+        $aliasMap = $this->buildAliasMap($em, $classMetadata, $joinParts, $originAlias);
+        $usesToManyAlias = $this->usesAnyToMany($aliasMap, $wherePart);
+
+        if ($usesToManyAlias) {
+            $this->decorated->applyToCollection($queryBuilder, $queryNameGenerator, $resourceClass, $operation, $context);
+        }
+    }
+
+    private function buildAliasMap(EntityManagerInterface $em, ClassMetadata $classMetadata, array $joinParts, $originAlias) {
+        // $alias => [ ClassMetadata $classMetadata, bool $is[One/Many]ToManyJoin ]
+        $aliasMap = [$originAlias => [$classMetadata, false]];
+        $joins = $joinParts[$originAlias];
+
+        foreach ($joins as $join) {
+            // @var Join $join
+            list($fromAlias, $fromProperty) = explode('.', $join->getJoin(), 2);
+            $toAlias = $join->getAlias();
+
+            $fromClassMetadata = $aliasMap[$fromAlias][0];
+            $association = $fromClassMetadata->getAssociationMapping($fromProperty);
+            $m = $em->getClassMetadata($association['targetEntity']);
+
+            $isToMany = $aliasMap[$fromAlias][1] || ($association instanceof ToManyInverseSideMapping);
+
+            $aliasMap[$toAlias] = [$m, $isToMany];
+        }
+
+        return $aliasMap;
+    }
+
+    private function usesAnyToMany($toManyAliases, $wherePart) {
+        if ($wherePart instanceof Andx) {
+            return $this->usesAnyToManyAndx($toManyAliases, $wherePart);
+        }
+        if ($wherePart instanceof Orx) {
+            return $this->usesAnyToManyOrx($toManyAliases, $wherePart);
+        }
+        if ($wherePart instanceof Comparison) {
+            return $this->usesAnyToManyComparison($toManyAliases, $wherePart);
+        }
+        if ($wherePart instanceof Func) {
+            return $this->usesAnyToManyFunc($toManyAliases, $wherePart);
+        }
+        if (is_string($wherePart)) {
+            return $this->usesAnyToManyString($toManyAliases, $wherePart);
+        }
+
+        throw new \Exception('Not Implemented: FilterEagerLoadingsExtension->usesToManyAlias for '.$wherePart);
+    }
+
+    private function usesAnyToManyAndx($toManyAliases, Andx $and) {
+        foreach ($and->getParts() as $part) {
+            if ($this->usesAnyToMany($toManyAliases, $part)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private function usesAnyToManyOrx($toManyAliases, Orx $or) {
+        foreach ($or->getParts() as $part) {
+            if ($this->usesAnyToMany($toManyAliases, $part)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private function usesAnyToManyComparison($toManyAliases, Comparison $comparison) {
+        return
+            $this->usesAnyToMany($toManyAliases, $comparison->getLeftExpr())
+            || $this->usesAnyToMany($toManyAliases, $comparison->getRightExpr());
+    }
+
+    private function usesAnyToManyFunc($toManyAliases, Func $func) {
+        foreach ($func->getArguments() as $argument) {
+            if ($this->usesAnyToMany($toManyAliases, $argument)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private function usesAnyToManyString($toManyAliases, string $comparison) {
+        $elements = explode('.', $comparison, 2);
+
+        if (2 == count($elements)) {
+            $alias = $elements[0];
+            if (isset($toManyAliases[$alias])) {
+                return $toManyAliases[$alias][1];
+            }
+        }
+
+        return false;
+    }
+}