Fixing lock behaviour

Author: moufmouf

src/GlobControllerQueryProvider.php

@@ -101,31 +101,26 @@ private function getInstancesList(): array
             $this->instancesList = $this->cache->get($key);
             if ($this->instancesList === null) {
                 $lock = $this->lockFactory->createLock('buildInstanceList_'.$this->namespace, 5);
-                if ($lock->isAcquired()) {
+                if (!$lock->acquire()) {
                     // Lock is being held right now. Generation is happening.
                     // Let's wait and fetch the result from the cache.
                     $lock->acquire(true);
                     $lock->release();
                     return $this->getInstancesList();
                 }
+                $lock->acquire(true);
+                try {
+                    return $this->buildInstancesList();
+                } finally {
+                    $lock->release();
+                }
 
-                $this->instancesList = $this->lockAndBuildInstanceList($lock);
                 $this->cache->set($key, $this->instancesList, $this->cacheTtl);
             }
         }
         return $this->instancesList;
     }
 
-    private function lockAndBuildInstanceList(Lock $lock): array
-    {
-        $lock->acquire(true);
-        try {
-            return $this->buildInstancesList();
-        } finally {
-            $lock->release();
-        }
-    }
-
     /**
      * @return string[]
      */

src/Mappers/GlobTypeMapper.php

@@ -169,14 +169,18 @@ private function getMaps(): array
                 $this->mapInputNameToFactory
             ) {
                 $lock = $this->lockFactory->createLock('buildmap_'.$this->namespace, 5);
-                if ($lock->isAcquired()) {
+                if (!$lock->acquire()) {
                     // Lock is being held right now. Generation is happening.
                     // Let's wait and fetch the result from the cache.
                     $lock->acquire(true);
                     $lock->release();
                     return $this->getMaps();
                 }
-                $this->lockAndBuildMap($lock);
+                try {
+                    $this->buildMap();
+                } finally {
+                    $lock->release();
+                }
                 // 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);
@@ -222,15 +226,19 @@ private function getMapClassToExtendTypeArray(): array
             $this->mapClassToExtendTypeArray = $this->cache->get($keyExtendClassCache);
             if ($this->mapClassToExtendTypeArray === null) {
                 $lock = $this->lockFactory->createLock('buildmapclassextend_'.$this->namespace, 5);
-                if ($lock->isAcquired()) {
+                if (!$lock->acquire()) {
                     // Lock is being held right now. Generation is happening.
                     // Let's wait and fetch the result from the cache.
                     $lock->acquire(true);
                     $lock->release();
                     return $this->getMapClassToExtendTypeArray();
                 }
-
-                $this->buildMapClassToExtendTypeArray($lock);
+                $lock->acquire(true);
+                try {
+                    $this->buildMapClassToExtendTypeArray($lock);
+                } finally {
+                    $lock->release();
+                }
                 // 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($keyExtendClassCache, $this->mapClassToExtendTypeArray, $this->globTtl);
@@ -248,15 +256,19 @@ private function getMapNameToExtendType(RecursiveTypeMapperInterface $recursiveT
             $this->mapNameToExtendType = $this->cache->get($keyExtendNameCache);
             if ($this->mapNameToExtendType === null) {
                 $lock = $this->lockFactory->createLock('buildmapnameextend_'.$this->namespace, 5);
-                if ($lock->isAcquired()) {
+                if (!$lock->acquire()) {
                     // Lock is being held right now. Generation is happening.
                     // Let's wait and fetch the result from the cache.
                     $lock->acquire(true);
                     $lock->release();
                     return $this->getMapNameToExtendType($recursiveTypeMapper);
                 }
-
-                $this->buildMapNameToExtendTypeArray($lock, $recursiveTypeMapper);
+                $lock->acquire(true);
+                try {
+                    $this->buildMapNameToExtendTypeArray($recursiveTypeMapper);
+                } finally {
+                    $lock->release();
+                }
                 // 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($keyExtendNameCache, $this->mapNameToExtendType, $this->globTtl);
@@ -292,16 +304,6 @@ private function getClassList(): array
         return $this->classes;
     }
 
-    private function lockAndBuildMap(Lock $lock): void
-    {
-        $lock->acquire(true);
-        try {
-            $this->buildMap();
-        } finally {
-            $lock->release();
-        }
-    }
-
     private function buildMap(): void
     {
         $this->mapClassToTypeArray = [];
@@ -363,21 +365,16 @@ private function buildMapClassToExtendTypeArray(Lock $lock): void
         }
     }
 
-    private function buildMapNameToExtendTypeArray(Lock $lock, RecursiveTypeMapperInterface $recursiveTypeMapper): void
+    private function buildMapNameToExtendTypeArray(RecursiveTypeMapperInterface $recursiveTypeMapper): void
     {
-        $lock->acquire(true);
-        try {
-            $this->mapNameToExtendType = [];
-            $classes = $this->getClassList();
-            foreach ($classes as $className => $refClass) {
-                $extendType = $this->annotationReader->getExtendTypeAnnotation($refClass);
+        $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();
         }
     }