19.0 vanilla

odoo-bringout-oca-ocb-base/odoo/orm/models_transient.py

@@ -0,0 +1,82 @@
+import datetime
+
+from odoo.tools import SQL, config, lazy_classproperty
+from odoo.tools.constants import GC_UNLINK_LIMIT
+
+from . import decorators as api
+from .models import Model
+
+
+class TransientModel(Model):
+    """ Model super-class for transient records, meant to be temporarily
+    persistent, and regularly vacuum-cleaned.
+
+    A TransientModel has a simplified access rights management, all users can
+    create new records, and may only access the records they created. The
+    superuser has unrestricted access to all TransientModel records.
+    """
+    _auto: bool = True          # automatically create database backend
+    _register: bool = False     # not visible in ORM registry, meant to be python-inherited only
+    _abstract = False           # not abstract
+    _transient = True           # transient
+
+    # default values for _transient_vacuum()
+    _transient_max_count = lazy_classproperty(lambda _: int(config.get('osv_memory_count_limit')))
+    "maximum number of transient records, unlimited if ``0``"
+    _transient_max_hours = lazy_classproperty(lambda _: float(config.get('transient_age_limit')))
+    "maximum idle lifetime (in hours), unlimited if ``0``"
+
+    @api.autovacuum
+    def _transient_vacuum(self):
+        """Clean the transient records.
+
+        This unlinks old records from the transient model tables whenever the
+        :attr:`_transient_max_count` or :attr:`_transient_max_hours` conditions
+        (if any) are reached.
+
+        Actual cleaning will happen only once every 5 minutes. This means this
+        method can be called frequently (e.g. whenever a new record is created).
+
+        Example with both max_hours and max_count active:
+
+        Suppose max_hours = 0.2 (aka 12 minutes), max_count = 20, there are
+        55 rows in the table, 10 created/changed in the last 5 minutes, an
+        additional 12 created/changed between 5 and 10 minutes ago, the rest
+        created/changed more than 12 minutes ago.
+
+        - age based vacuum will leave the 22 rows created/changed in the last 12
+          minutes
+        - count based vacuum will wipe out another 12 rows. Not just 2,
+          otherwise each addition would immediately cause the maximum to be
+          reached again.
+        - the 10 rows that have been created/changed the last 5 minutes will NOT
+          be deleted
+        """
+        has_remaining = False
+        if self._transient_max_hours:
+            # Age-based expiration
+            has_remaining |= self._transient_clean_rows_older_than(self._transient_max_hours * 60 * 60)
+
+        if self._transient_max_count:
+            # Count-based expiration
+            has_remaining |= self._transient_clean_old_rows(self._transient_max_count)
+        # This method is shared by all transient models therefore,
+        # return the model name to be logged and if whether there are more rows to process
+        return self._name, has_remaining
+
+    def _transient_clean_old_rows(self, max_count: int) -> bool:
+        # Check how many rows we have in the table
+        self._cr.execute(SQL("SELECT count(*) FROM %s", SQL.identifier(self._table)))
+        [count] = self._cr.fetchone()
+        if count > max_count:
+            return self._transient_clean_rows_older_than(300)
+        return False
+
+    def _transient_clean_rows_older_than(self, seconds: int) -> bool:
+        # Never delete rows used in last 5 minutes
+        seconds = max(seconds, 300)
+        now = self.env.cr.now()
+        domain = [('write_date', '<', now - datetime.timedelta(seconds=seconds))]
+        records = self.sudo().search(domain, limit=GC_UNLINK_LIMIT)
+        records.unlink()
+        return len(records) == GC_UNLINK_LIMIT