Autocheck for new DOMjudge releases

Discussed during the hackathon in 2023. We allow admins to toggle an
autoquery to domjudge.org for 2 reasons:
- Alerting users that a new version might exist, helping us in case of
  security releases.
- Giving a gentle nudge for people to upgrade making support easier.
- Getting some information on what installations are out there.

Co-authored-by: Tobias Werth <[email protected]>

Author: vmcj

etc/db-config.yaml

@@ -393,6 +393,12 @@
             description: Time in seconds after an external contest source reader last checked in before showing its status as `critical`.
             regex: /^\d+$/
             error_message: A non-negative number is required.
+        -   name: check_new_version
+            type: enum
+            enum_class: App\Utils\UpdateStrategy
+            default_value: none
+            public: false
+            description: Automatically check and notify for new DOMjudge releases?
         -   name: adminer_enabled
             type: bool
             default_value: false

webapp/src/Service/DOMJudgeService.php

@@ -31,16 +31,19 @@
 use App\Entity\Testcase;
 use App\Entity\User;
 use App\Utils\FreezeData;
+use App\Utils\UpdateStrategy;
 use App\Utils\Utils;
 use DateTime;
 use Doctrine\ORM\EntityManagerInterface;
 use Doctrine\ORM\NonUniqueResultException;
 use Doctrine\ORM\NoResultException;
 use Doctrine\ORM\Query\Expr\Join;
 use Doctrine\ORM\QueryBuilder;
+use Exception;
 use InvalidArgumentException;
 use Psr\Log\LoggerInterface;
 use ReflectionClass;
+use Symfony\Component\Cache\Adapter\FilesystemAdapter;
 use Symfony\Component\DependencyInjection\Attribute\Autowire;
 use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
 use Symfony\Component\HttpFoundation\Cookie;
@@ -62,6 +65,7 @@
 use Symfony\Component\Security\Core\Authentication\Token\UsernamePasswordToken;
 use Symfony\Component\Security\Core\Authorization\AuthorizationCheckerInterface;
 use Symfony\Component\Security\Core\User\UserInterface;
+use Symfony\Contracts\Cache\ItemInterface;
 use Twig\Environment;
 use ZipArchive;
 
@@ -108,6 +112,10 @@ public function __construct(
         protected string $projectDir,
         #[Autowire('%domjudge.vendordir%')]
         protected string $vendorDir,
+        #[Autowire('%domjudge.version%')]
+        protected readonly string $domjudgeVersion,
+        #[Autowire('%domjudge.installmethod%')]
+        protected readonly string $domjudgeInstallMethod,
     ) {}
 
     /**
@@ -1699,4 +1707,89 @@ public function getAllowedLanguagesForContest(?Contest $contest) : array {
             ->getQuery()
             ->getResult();
     }
+
+    /**
+     * Returns either the next strictly higher version or false when nothing is found/requested.
+     */
+    public function checkNewVersion(): string|false {
+        if ($this->config->get('check_new_version', false) === UpdateStrategy::Strategy_none) {
+            return false;
+        }
+        // The local version is something like "x.y.z / commit hash", e.g. "8.4.0DEV/4e25adb13" for development
+        // or 8.3.2 for a released version
+        // In case of development we remove the commit hash for some anonymity but keep the DEV to not count those as the (possibly) released version
+        $localVersionString = strtok($this->domjudgeVersion, "/");
+        $localVersion = explode(".", $localVersionString);
+        if (count($localVersion) !== 3) {
+            // Unknown version, someone might have locally modified and used their own versioning
+            return false;
+        }
+
+        $cache = new FilesystemAdapter();
+        $versions = $cache->get('domjudge_versions', function (ItemInterface $item, string $localVersionString): string|false {
+            $item->expiresAfter(86400);
+
+            $versionUrl = 'https://versions.domjudge.org';
+            $options = ['http' => ['timeout' => 1, 'method' => 'GET', 'header' => "User-Agent: DOMjudge#" . $this->domjudgeInstallMethod . "/" . $localVersionString . "\r\n"]];
+            $context = stream_context_create($options);
+            $response = @file_get_contents($versionUrl, false, $context);
+            if ($response === false) {
+                return false;
+            }
+            // Assume we get a one-level unordered JSON list with the released versions e.g. ["10.0.0", "9.11.0", "12.0.12", "10.0.1"]
+            $tmp_versions = json_decode($response, true);
+            natsort($tmp_versions);
+            return array_reverse($tmp_versions);
+        });
+
+        if (!$versions) {
+            return false;
+        }
+
+        preg_match("/\d.\d.\d/", $this->domjudgeVersion, $matches);
+        $extractedLocalVersionString = $matches[0];
+        if ($this->config->get('check_new_version', false) === UpdateStrategy::Strategy_incremental) {
+            /* Steer towards the nearest highest patch release first
+             * So the expected path would be:
+             * DJ6.0.0 -> DJ6.0.6 -> DJ6.6.0 -> DJ9.1.2 instead of
+             *         -> DJ6.0.[1..6] -> DJ6.[1..6].* -> DJ[7..9].*.*
+             * skipping all patch releases in between, when no patch release
+             * is available, try the highest minor and otherwise the highest Major
+             * instead of going to the latest release:
+             * DJ6.0.0 -> DJ9.1.2
+             */
+            $patch = "/" . $localVersion[0] . "." . $localVersion[1] . ".\d/";
+            $minor = "/" . $localVersion[0] . ".\d.\d/";
+            $major = "/\d.\d.\d/";
+            foreach ([$patch, $minor, $major] as $regex) {
+                foreach ($versions as $release) {
+                    if (preg_match($regex, $release)) {
+                        if (strnatcmp($release, $extractedLocalVersionString) === 1) {
+                            return $release;
+                        }
+                        if (strnatcmp($release, $extractedLocalVersionString) === 0 && str_contains($localVersionString, "DEV")) {
+                            // Special case, the development version is now released
+                            return $release;
+                        }
+                    }
+                }
+            }
+        }
+        elseif ($this->config->get('check_new_version', false) === UpdateStrategy::Strategy_major_release) {
+            /* Steer towards the latest version directly
+             * So the expected path would be:
+             * DJ6.0.0 -> DJ9.1.2
+             * This should be safe as doctrine migrations check for upgrades regardless of current DOMjudge release
+             */
+            $latest = $versions[0];
+            if (strnatcmp($latest, $extractedLocalVersionString) === 1) {
+                return $latest;
+            }
+            if (strnatcmp($latest, $extractedLocalVersionString) === 0 && str_contains($localVersionString, "DEV")) {
+                // Special case, the development version is now released
+                return $latest;
+            }
+        }
+        return false;
+    }
 }

webapp/src/Twig/TwigExtension.php

@@ -163,6 +163,7 @@ public function getGlobals(): array
             'doc_links'                     => $this->dj->getDocLinks(),
             'allow_registration'            => $selfRegistrationCategoriesCount !== 0,
             'enable_ranking'                => $this->config->get('enable_ranking'),
+            'new_version_available'         => $this->dj->checkNewVersion(),
             'editor_themes'                 => [
                 'vs'                        => ['name' => 'Visual Studio (light)'],
                 'vs-dark'                   => ['name' => 'Visual Studio (dark)'],

webapp/src/Utils/UpdateStrategy.php

@@ -0,0 +1,19 @@
+<?php declare(strict_types=1);
+
+namespace App\Utils;
+
+enum UpdateStrategy: string
+{
+    case Strategy_incremental = 'incremental';
+    case Strategy_major_release = 'major';
+    case Strategy_none = 'none';
+
+    public function getConfigDescription(): string
+    {
+        return match ($this) {
+            self::Strategy_incremental => 'Report on next patch releases, favoring reliability over features',
+            self::Strategy_major_release => 'Report on newest Major/minor releases, favoring being close to the version maintainers run',
+            self::Strategy_none => 'Do not report on any new versions',
+        };
+    }
+}

webapp/templates/jury/menu.html.twig

@@ -93,6 +93,13 @@
                 </li>
             </ul>
         {% endif %}
+        {% if new_version_available %}
+            <ul class="navbar-nav">
+                <li class="nav-item">
+                    <a class="nav-link" href="https://www.domjudge.org/download"><i class="fa-solid fa-ship fa-2x"></i> New release {{ new_version_available }} available.</a>
+                </li>
+            </ul>
+        {% endif %}
 
         <ul class="navbar-nav ml-auto">