WIPWIPWIP: testing, will rebase.

Author: tuupke

webapp/src/Controller/API/JudgehostController.php

@@ -32,6 +32,7 @@
 use Doctrine\DBAL\ArrayParameterType;
 use Doctrine\DBAL\Exception;
 use Doctrine\DBAL\Exception as DBALException;
+use Doctrine\DBAL\TransactionIsolationLevel;
 use Doctrine\ORM\AbstractQuery;
 use Doctrine\ORM\EntityManager;
 use Doctrine\ORM\EntityManagerInterface;
@@ -348,9 +349,10 @@ public function updateJudgingAction(
 
                     $rowsAffected = $this->em->createQueryBuilder()
                         ->update(Submission::class, 's')
-                        ->set('entry_point', $newEntryPoint)
-                        ->where('submitid = :id')
-                        ->andWhere('entry_point IS NULL')
+                        ->set('s.entry_point', ':entrypoint')
+                        ->where('s.submitid = :id')
+                        ->andWhere('s.entry_point IS NULL')
+                        ->setParameter('entrypoint', $newEntryPoint)
                         ->setParameter('id', $submission->getSubmitid())
                         ->getQuery()
                         ->execute();
@@ -1387,6 +1389,28 @@ public function checkVersions(Request $request, string $judgetaskid): array
         if ($request->request->has('runner')) {
             $reportedVersions['runner'] = base64_decode($request->request->get('runner'));
         }
+
+        // We want the version update to be both lock-free manner while keeping one latest version exposed.
+        // To ensure this is the case a READ_UNCOMMITTED transaction is used. This is not ideal, but does keep both
+        // constraints. The updating threads might see multiple versions, but only the newest one is exposed.
+        //
+        // Keep in mind that there might be multiple concurrent updates while reading the explanation.
+        // - First insert a new version assuming it will be the latest version.
+        // - Retrieve all 'new versions', not newest 'new versions' stop processing.
+        // - The newest 'new version' assumes it is the latest version and updates all "older" 'new versions' to
+        //   not be the latest.
+        // Age is determined by `judgetaskid`. The greatest `judgetaskid` is the newest. It might be possible that yet
+        // another thread is inserting versions. Though unfortunate there is no way to prevent this.
+        // Runs in a READ_UNCOMMITTED transaction to make sure concurrent threads see, and can update,
+        // required values.
+        $this->em->wrapInTransaction(function ($em) {
+            $isoLevel = $this->em->getConnection()->getTransactionIsolation();
+            $em->getConnection()->setTransactionIsolation(TransactionIsolationLevel::READ_UNCOMMITTED);
+
+            // Restore the isolation level.
+            $em->getConnection()->setTransactionIsolation($isoLevel);
+        });
+
         $this->em->wrapInTransaction(function () use (
             $judgehost,
             $reportedVersions,
@@ -1396,10 +1420,12 @@ public function checkVersions(Request $request, string $judgetaskid): array
             $activeVersion = $this->em->getRepository(Version::class)
                 ->findOneBy(['language' => $language, 'judgehost' => $judgehost, 'active' => true]);
 
-            $isNewVersion = false;
-            if (!$activeVersion) {
-                $isNewVersion = true;
-            } else {
+            $isNewVersion = !$activeVersion ||
+                $activeVersion->getCompilerVersion() !== @$reportedVersions['compiler'] ||
+                $activeVersion->getRunnerVersion() !== @$reportedVersions['runner'];
+
+            $isNewVersion = !$activeVersion;
+            if (!$isNewVersion) {
                 $reportedCompilerVersion = $reportedVersions['compiler'] ?? null;
                 if ($activeVersion->getCompilerVersion() !== $reportedCompilerVersion) {
                     $isNewVersion = true;