Adding a lock mechanism on cache rebuild

When a cache expires, it needs to be recomputed. If the website is under heavy load, the recompute will be started by many processes at once and will slow down the server.
Adding a lock allows us to perform this recompute only once.

Author: moufmouf

composer.json

@@ -20,7 +20,8 @@
         "phpdocumentor/reflection-docblock": "^4.3",
         "phpdocumentor/type-resolver": "^0.4",
         "psr/http-message": "^1",
-        "ecodev/graphql-upload": "^4.0"
+        "ecodev/graphql-upload": "^4.0",
+        "symfony/lock": "^3 || ^4"
     },
     "require-dev": {
         "phpunit/phpunit": "^6.1",

src/GlobControllerQueryProvider.php

@@ -6,8 +6,10 @@
 use Mouf\Composer\ClassNameMapper;
 use Psr\Container\ContainerInterface;
 use Psr\SimpleCache\CacheInterface;
+use Symfony\Component\Lock\Store\SemaphoreStore;
 use TheCodingMachine\ClassExplorer\Glob\GlobClassExplorer;
 use TheCodingMachine\GraphQLite\Mappers\RecursiveTypeMapperInterface;
+use Symfony\Component\Lock\Factory as LockFactory;
 
 /**
  * Scans all the classes in a given namespace of the main project (not the vendor directory).
@@ -53,6 +55,10 @@ final class GlobControllerQueryProvider implements QueryProviderInterface
      * @var bool
      */
     private $recursive;
+    /**
+     * @var LockFactory
+     */
+    private $lockFactory;
 
     /**
      * @param string $namespace The namespace that contains the GraphQL types (they must have a `@Type` annotation)
@@ -72,6 +78,9 @@ public function __construct(string $namespace, FieldsBuilderFactory $fieldsBuild
         $this->fieldsBuilderFactory = $fieldsBuilderFactory;
         $this->recursiveTypeMapper = $recursiveTypeMapper;
         $this->recursive = $recursive;
+        $store = new SemaphoreStore();
+        $this->lockFactory = new LockFactory($store);
+
     }
 
     private function getAggregateControllerQueryProvider(): AggregateControllerQueryProvider
@@ -93,13 +102,24 @@ private function getInstancesList(): array
             $key = 'globQueryProvider_'.str_replace('\\', '_', $this->namespace);
             $this->instancesList = $this->cache->get($key);
             if ($this->instancesList === null) {
-                $this->instancesList = $this->buildInstancesList();
+                $this->instancesList = $this->lockAndBuildInstanceList();
                 $this->cache->set($key, $this->instancesList, $this->cacheTtl);
             }
         }
         return $this->instancesList;
     }
 
+    private function lockAndBuildInstanceList(): array
+    {
+        $lock = $this->lockFactory->createLock('buildInstanceList_'.$this->namespace, 5);
+        $lock->acquire(true);
+        try {
+            return $this->buildInstancesList();
+        } finally {
+            $lock->release();
+        }
+    }
+
     /**
      * @return string[]
      */

src/Mappers/GlobTypeMapper.php

@@ -12,6 +12,8 @@
 use Psr\SimpleCache\CacheInterface;
 use ReflectionClass;
 use ReflectionMethod;
+use Symfony\Component\Lock\Factory as LockFactory;
+use Symfony\Component\Lock\Store\SemaphoreStore;
 use TheCodingMachine\ClassExplorer\Glob\GlobClassExplorer;
 use TheCodingMachine\GraphQLite\AnnotationReader;
 use TheCodingMachine\GraphQLite\Annotations\ExtendType;
@@ -119,6 +121,10 @@ final class GlobTypeMapper implements TypeMapperInterface
      * @var bool
      */
     private $recursive;
+    /**
+     * @var LockFactory
+     */
+    private $lockFactory;
 
     /**
      * @param string $namespace The namespace that contains the GraphQL types (they must have a `@Type` annotation)
@@ -136,6 +142,8 @@ public function __construct(string $namespace, TypeGenerator $typeGenerator, Inp
         $this->inputTypeGenerator = $inputTypeGenerator;
         $this->inputTypeUtils = $inputTypeUtils;
         $this->recursive = $recursive;
+        $store = new SemaphoreStore();
+        $this->lockFactory = new LockFactory($store);
     }
 
     /**
@@ -160,7 +168,7 @@ private function getMaps(): array
                 $this->mapClassToFactory === null ||
                 $this->mapInputNameToFactory
             ) {
-                $this->buildMap();
+                $this->lockAndBuildMap();
                 // This is a very short lived cache. Useful to avoid overloading a server in case of heavy load.
                 // Defaults to 2 seconds.
                 $this->cache->set($keyClassCache, $this->mapClassToTypeArray, $this->globTtl);
@@ -258,6 +266,17 @@ private function getClassList(): array
         return $this->classes;
     }
 
+    private function lockAndBuildMap(): void
+    {
+        $lock = $this->lockFactory->createLock('buildmap_'.$this->namespace, 5);
+        $lock->acquire(true);
+        try {
+            $this->buildMap();
+        } finally {
+            $lock->release();
+        }
+    }
+
     private function buildMap(): void
     {
         $this->mapClassToTypeArray = [];
@@ -303,27 +322,39 @@ private function buildMap(): void
 
     private function buildMapClassToExtendTypeArray(): void
     {
-        $this->mapClassToExtendTypeArray = [];
-        $classes = $this->getClassList();
-        foreach ($classes as $className => $refClass) {
-            $extendType = $this->annotationReader->getExtendTypeAnnotation($refClass);
+        $lock = $this->lockFactory->createLock('buildmapclassextend_'.$this->namespace, 5);
+        $lock->acquire(true);
+        try {
+            $this->mapClassToExtendTypeArray = [];
+            $classes = $this->getClassList();
+            foreach ($classes as $className => $refClass) {
+                $extendType = $this->annotationReader->getExtendTypeAnnotation($refClass);
 
-            if ($extendType !== null) {
-                $this->storeExtendTypeMapperByClassInCache($className, $extendType, $refClass->getFileName());
+                if ($extendType !== null) {
+                    $this->storeExtendTypeMapperByClassInCache($className, $extendType, $refClass->getFileName());
+                }
             }
+        } finally {
+            $lock->release();
         }
     }
 
     private function buildMapNameToExtendTypeArray(RecursiveTypeMapperInterface $recursiveTypeMapper): void
     {
-        $this->mapNameToExtendType = [];
-        $classes = $this->getClassList();
-        foreach ($classes as $className => $refClass) {
-            $extendType = $this->annotationReader->getExtendTypeAnnotation($refClass);
+        $lock = $this->lockFactory->createLock('buildmapnameextend_'.$this->namespace, 5);
+        $lock->acquire(true);
+        try {
+            $this->mapNameToExtendType = [];
+            $classes = $this->getClassList();
+            foreach ($classes as $className => $refClass) {
+                $extendType = $this->annotationReader->getExtendTypeAnnotation($refClass);
 
-            if ($extendType !== null) {
-                $this->storeExtendTypeMapperByNameInCache($className, $extendType, $refClass->getFileName(), $recursiveTypeMapper);
+                if ($extendType !== null) {
+                    $this->storeExtendTypeMapperByNameInCache($className, $extendType, $refClass->getFileName(), $recursiveTypeMapper);
+                }
             }
+        } finally {
+            $lock->release();
         }
     }