Drive releases off a metadata files instead of manually

This, together with the previous cve changes, makes it possible to do a
complete release in just one "git push", instead of a combination of
editing files and timing it with making changes in the database
manually in the right order.

In passing also dynamically drive the text about when it's time to
upgrade from the eoldate listed in the database, and start showing the
warning at 180 days.

Author: mhagander

data/releases/2026-05-14.yaml

@@ -0,0 +1,21 @@
+date: 2026-05-14
+versions:
+  - 18.3
+  - 17.9
+  - 16.13
+  - 15.17
+  - 14.22
+news:
+  id: 3297
+cve:
+  - 2026-6472
+  - 2026-6473
+  - 2026-6474
+  - 2026-6475
+  - 2026-6476
+  - 2026-6477
+  - 2026-6478
+  - 2026-6479
+  - 2026-6575
+  - 2026-6637
+  - 2026-6638

data/releases/2026-06-04.yaml

@@ -0,0 +1,5 @@
+date: 2026-06-04
+versions:
+  - 19beta1
+news:
+  id: 3313

data/releases/release.template

@@ -0,0 +1,11 @@
+# This is a template file with all keys that can do in a release yaml file
+date: 2026-06-04       # Date of the release, in yyyy-mm-dd format
+versions:              # List of which versions are being released. minor expects >= 1 entry, all others expect 1
+  - 19.0               # Each version should always have the full <major>.<minor> format (must be .0 for major release), or <major>beta<num> (etc for alpha and rc)
+news:
+  id: 1656             # id of the news article with the release announcement
+announcetext: |        # IFF this is type=major or override, the actual HTML to use in the text
+  <p>
+  This is the big text to be <b>overridden</b>.
+  </p>
+nooldestwarning: true  # Set to true to exclude the warning to upgrade from the oldest version

pgweb/core/models.py

@@ -4,6 +4,7 @@
 from pgweb.util.misc import varnish_purge
 
 import base64
+from datetime import date, timedelta
 from decimal import Decimal
 
 from pgweb.util.moderation import TwostateModerateModel
@@ -36,6 +37,10 @@ def __str__(self):
     def versionstring(self):
         return self.buildversionstring(self.latestminor)
 
+    @property
+    def versionstring_spaced(self):
+        return self.buildversionstring(self.latestminor, True)
+
     @property
     def numtree(self):
         # Return the proper numeric tree version, taking into account that PostgreSQL 10
@@ -61,9 +66,11 @@ def relnotes(self):
             # Should never happen so return something broken
             return 'x'
 
-    def buildversionstring(self, minor):
+    def buildversionstring(self, minor, spaced=False):
         if not self.testing:
             return "%s.%s" % (self.numtree, minor)
+        elif spaced:
+            return "%s %s %s" % (self.numtree, TESTING_SHORTSTRING[self.testing].capitalize(), minor)
         else:
             return "%s%s%s" % (self.numtree, TESTING_SHORTSTRING[self.testing], minor)
 
@@ -89,6 +96,10 @@ def save(self, update_fields=None):
         # free to save this one.
         super(Version, self).save(update_fields=update_fields)
 
+    @property
+    def soon_eol(self):
+        return self.supported and self.eoldate < date.today() + timedelta(days=180)
+
     class Meta:
         ordering = ('-tree', )
 

pgweb/core/views.py

@@ -32,6 +32,7 @@
 from pgweb.util.sitestruct import get_all_pages_struct
 from pgweb.mailqueue.util import send_simple_mail
 from pgweb.account.views import OAUTH_PASSWORD_STORE
+from pgweb.release.util import CurrentRelease
 
 # models needed for the pieces on the frontpage
 from pgweb.news.models import NewsArticle, NewsTag
@@ -68,15 +69,18 @@ def home(request):
     community_event_queryset = event_base_queryset.filter(badged=True).order_by('enddate', 'startdate')[:(7 - other_events.count())]
     # now, return all the events in one unioned array!
     events = community_event_queryset.union(other_events).order_by('enddate', 'startdate').all()
-    versions = Version.objects.filter(supported=True)
+    versions = list(Version.objects.filter(supported=True))
     planet = ImportedRSSItem.objects.filter(feed__internalname="planet").order_by("-posttime")[:9]
 
+    release = CurrentRelease.get()
+
     return render(request, 'index.html', {
         'title': 'The world\'s most advanced open source database',
         'news': news,
         'events': events,
         'versions': versions,
         'planet': planet,
+        'release': release,
         'og': {
             'url': '/',
             'author': 'PostgreSQL Global Development Group',

pgweb/release/README.md

@@ -0,0 +1,45 @@
+# Release flow
+
+The release flow is triggered automatically after each migration, and picks up the latest
+file in data/releases/ (ordered by filename, must end in `.yaml`) and makes a release
+accordingly.
+
+## User steps
+
+* Create a news embargo
+* Create a news article with all details, leaving as unapproved
+* Create a `data/releases/<date>.yaml` file
+* If this is the first alpha/beta/rc, create a Version record for this version
+* `git push`
+
+### Version mixing
+
+Normally, on a *major release* or on *first beta version*, a single
+release should be in the `yaml` file. This will trigger a "full"
+announcement on the website. In these cases, set the `announcetext`
+key in the yaml to the full details.
+
+If more than one version is listed, it is *always* treated as a set of
+minor releases. This can either be a general set of scheduled minor
+releases, or it can be a combination of a beta and minors for
+example. Even a major version can be included, but it will be treated
+as a minor version on the website.
+
+## Resulting actions
+
+* Release date is adjusted to date from yaml file
+* Latest minor version on the Version object is adjusted to the one
+  from the `yaml` file (note that this happens even if it's
+  decreased!) This includes setting alpha/beta/rc number on testing
+  releases.
+* If the previous version was a testing one and the new one is a `.0`
+  major release, the testing flag is turned off and the new `.0` is
+  set to both current and supported. Note that if a release directly
+  moves from alpha/beta/rc to a minor (such as a `.1`), only the minor
+  numbers will be updated and it will not be set to supported/current
+  (because this is a non-standard workflow).
+* All CVEs listed in the `yaml` (normally only on minor, but
+  works for all) set to public and has their announcement linked to
+  the news article specified
+* News article has date set to date from yaml file and is
+  approved, bypassing embargo, and emailed

pgweb/release/apps.py

@@ -0,0 +1,14 @@
+from django.apps import AppConfig
+from django.db.models.signals import post_migrate
+
+
+def do_post_migrate(sender, **kwargs):
+    from .migrate import do_migrate
+    do_migrate()
+
+
+class ReleaseAppConfig(AppConfig):
+    name = "pgweb.release"
+
+    def ready(self):
+        post_migrate.connect(do_post_migrate, sender=self)

pgweb/release/migrate.py

@@ -0,0 +1,100 @@
+from django.db import transaction
+
+from datetime import date
+
+from pgweb.core.models import Version, TESTING_SHORTSTRING
+from pgweb.news.models import NewsArticle, PinnedNewsArticle
+from pgweb.security.models import SecurityPatch
+from pgweb.util.moderation import ModerationState
+from pgweb.util.versions import ParsedVersion
+
+from pgweb.release.util import CurrentRelease
+
+
+@transaction.atomic
+def do_migrate():
+    # Runs after migrations. Process the current release into being an actual release, if we can.
+    release = CurrentRelease.get()
+
+    if release.get('noprocess', False):
+        print("Noprocess flag set on release, not processing")
+        return
+
+    if not isinstance(release['date'], date):
+        raise Exception("Incorrect format of date {}".format(release['date']))
+
+    if release['type'] in ('major', 'override') and not release.get('announcetext', None):
+        raise Exception("Release type {} must specify an announcetext".format(release['type']))
+
+    newsid = release.get('news', {}).get('id', None)
+    if not newsid:
+        print("No news specified for release, cannot approve news or connect CVEs")
+        news = None
+    else:
+        try:
+            news = NewsArticle.objects.get(pk=newsid)
+        except NewsArticle.DoesNotExist:
+            print("Could not find news article with id {}, cannot approve news or connect CVEs".format(release['news']['id']))
+            news = None
+
+    # Update latest available version
+    for ver in release['versions']:
+        try:
+            v = Version.objects.only('tree', 'latestminor', 'reldate', 'testing').get(tree=ver.major)
+            uf = []
+            if v.latestminor != ver.minor:
+                v.latestminor = ver.minor
+                uf.append('latestminor')
+                print("Set latestminor={} for version {}".format(v.latestminor, v.numtree))
+            if v.reldate != release['date']:
+                v.reldate = release['date']
+                uf.append('reldate')
+                print("Set reldate={} for version {}".format(v.reldate, v.numtree))
+
+            if ver.testing and v.testing != ver.testing:
+                v.testing = ver.testing
+                v.current = False
+                v.supported = False
+                uf.extend(['testing', 'current', 'supported'])
+                print("Set testing={}, current=False, supported=False for version {}".format(ver.type, v.numtree))
+
+            # If we are transitioning beta -> release, set testing and supported flags.
+            if v.testing != 0 and ver.type == 'major':
+                v.testing = 0
+                v.supported = True
+                v.current = True
+                uf.extend(['testing', 'supported', 'current'])
+                print("Set testing=Release, supported=True and current=True for major version {}".format(v.numtree))
+
+            if uf:
+                v.save(update_fields=list(set(uf)))
+        except Version.DoesNotExist:
+            print("Could not find version tree {}, cannot update latest minor".format(ver.major))
+
+    # If there are any CVEs attached to this release, add the news article to them if there is one
+    if news:
+        for cve in release.get('cve', []):
+            try:
+                patch = SecurityPatch.objects.get(cve=cve)
+                patch.newspost = news
+                patch.public = True
+                patch.save(update_fields=['newspost', 'public'])
+                print("Attached news article {} to CVE-{}".format(news.id, cve))
+            except SecurityPatch.DoesNotExist:
+                print("Could not find CVE {}, cannot connect to announcement")
+
+    # If the news article isn't approved yet, bypass approval and do it!
+    if news:
+        if news.modstate != ModerationState.APPROVED:
+            print("Approving news item {}".format(news.id))
+            news.modstate = ModerationState.APPROVED
+            news.date = release['date']
+            news.save(update_fields=['modstate', 'date'])
+            print("Sending announcement email for news item")
+            news.on_approval(None)
+
+        pa = PinnedNewsArticle.objects.all()[0]
+        if pa.pinnedarticle != news:
+            print("Pinning news item {}".format(news.id))
+            pa.pinnedarticle = news
+            pa.save(update_fields=['pinnedarticle'])

pgweb/release/models.py

@@ -0,0 +1 @@
+# Empty file needed for post_migrate() to run

pgweb/release/util.py

@@ -0,0 +1,61 @@
+import os
+import os.path
+
+import yaml
+
+from pgweb.util.versions import ParsedVersion
+
+
+def determine_release_type(release):
+    if any(v for v in release['versions'] if v.type == 'major'):
+        if len(release['versions']) != 1:
+            raise Exception("Major versions should have exactly one version listed")
+        return 'major'
+    elif len(release['versions']) == 1:
+        # A single release, so just copy the type
+        return release['versions'][0].type
+    else:
+        # Any case of >1 release is treated like a minor
+        return 'minor'
+
+
+class Release:
+    def __init__(self):
+        self._current_release = None
+        self._current_release_file = None
+        self._current_release_file_timestamp = None
+
+    def get(self):
+        from pgweb.news.models import NewsArticle
+
+        currname = self._get_current_release_filename()
+
+        if self._current_release_file and self._current_release_file_timestamp and self._current_release_file == currname and self._current_release_file_timestamp == os.stat(currname).st_mtime:
+            # We have it loaded and there has been no changes
+            return self._current_release
+
+        # Either we haven't loaded yet, or it has changed, so reload
+        self._current_release_file = currname
+        self._current_release_file_timestamp = os.stat(currname).st_mtime
+        with open(self._current_release_file) as f:
+            self._current_release = yaml.load(f, Loader=yaml.SafeLoader)
+            self._current_release['versions'] = [ParsedVersion(str(v)) for v in self._current_release['versions']]
+            try:
+                self._current_release['type'] = determine_release_type(self._current_release)
+            except Exception:
+                self._current_release['type'] = 'unknown'
+            newsid = self._current_release.get('news', {}).get('id', None)
+            if newsid:
+                try:
+                    self._current_release['news']['url'] = NewsArticle.objects.only('id', 'title').get(pk=self._current_release['news']['id']).permanenturl
+                except NewsArticle.DoesNotExist:
+                    self._current_release['news']['url'] = '/about/news/{}/'.format(self._current_release['news']['id'])
+
+        return self._current_release
+
+    def _get_current_release_filename(self):
+        basepath = os.path.abspath(os.path.join(__file__, '../../../data/releases'))
+        return os.path.join(basepath, max(f for f in os.listdir(basepath) if f.endswith('.yaml')))
+
+
+CurrentRelease = Release()