From e2376436495e4a3093a079e6a2a32ff3a74191ae Mon Sep 17 00:00:00 2001
From: Guewen Baconnier <guewen.baconnier@qoqa.com>
Date: Mon, 17 Aug 2026 17:59:36 +0200
Subject: [PATCH 1/2] [ADD] queue_job: add jobrunner config on channels

Not used at this point by the jobrunner, but the changes on channels
trigger a notify to the jobrunner.
---
 queue_job/jobrunner/channels.py             |   1 +
 queue_job/models/queue_job_channel.py       | 101 +++++++++++++++-
 queue_job/tests/test_model_job_channel.py   | 127 ++++++++++++++++++++
 queue_job/views/queue_job_channel_views.xml |  80 +++++++++---
 4 files changed, 291 insertions(+), 18 deletions(-)

diff --git a/queue_job/jobrunner/channels.py b/queue_job/jobrunner/channels.py
index 7d6642dab8..36e77bee07 100644
--- a/queue_job/jobrunner/channels.py
+++ b/queue_job/jobrunner/channels.py
@@ -10,6 +10,7 @@
 from ..exception import ChannelNotFound
 from ..job import CANCELLED, DONE, ENQUEUED, FAILED, PENDING, STARTED, WAIT_DEPENDENCIES
 
+RELOAD_PAYLOAD = "reload"
 NOT_DONE = (WAIT_DEPENDENCIES, PENDING, ENQUEUED, STARTED, FAILED)
 JobSortingKey = namedtuple("SortingKey", "eta priority date_created seq")
 
diff --git a/queue_job/models/queue_job_channel.py b/queue_job/models/queue_job_channel.py
index 4aabb0188c..96dc8e9d8e 100644
--- a/queue_job/models/queue_job_channel.py
+++ b/queue_job/models/queue_job_channel.py
@@ -4,12 +4,28 @@
 
 from odoo import _, api, exceptions, fields, models
 
+from ..jobrunner.channels import RELOAD_PAYLOAD
+
 
 class QueueJobChannel(models.Model):
     _name = "queue.job.channel"
     _description = "Job Channels"
     _rec_name = "complete_name"
 
+    # fields that trigger a reload of the jobrunner for this database when changed
+    _JOBRUNNER_CONFIG_FIELDS = frozenset(
+        (
+            "capacity",
+            "sequential",
+            "throttle",
+            "paused",
+            "name",
+            "parent_id",
+            "capacity_default",
+            "sequential_default",
+        )
+    )
+
     name = fields.Char()
     complete_name = fields.Char(
         compute="_compute_complete_name", store=True, readonly=True, recursive=True
@@ -23,13 +39,68 @@ class QueueJobChannel(models.Model):
         string="Job Functions",
     )
     removal_interval = fields.Integer(
-        default=lambda self: self.env["queue.job"]._removal_interval, required=True
+        default=lambda self: self.env["queue.job"]._removal_interval,
+        required=True,
+        help="Number of days after which done jobs are deleted.",
+    )
+    capacity = fields.Integer(
+        help="Maximum number of jobs running at the same time in this channel. "
+        "0 means no limit, but they are still limited by the capacity of the parent "
+        "channel. On the root channel, 0 is limited by the global server-side "
+        "configuration."
+    )
+    sequential = fields.Boolean(
+        help="Jobs are executed one after the other and failed jobs block the channel. "
+        "Requires a capacity of 1."
+    )
+    throttle = fields.Integer(
+        help="Minimum delay in seconds between the start of two jobs in this channel."
+    )
+    paused = fields.Boolean(
+        help="A paused channel (an its sub-channels) do not execute any jobs until "
+        "resumed."
+    )
+    capacity_default = fields.Integer(
+        help="Default capacity for unconfigured sub-channels. "
+        "0 means they would have the same capacity as the current channel."
+    )
+    sequential_default = fields.Boolean(
+        help="If sequential is enabled for unconfigured sub-channels."
     )
 
     _sql_constraints = [
         ("name_uniq", "unique(complete_name)", "Channel complete name must be unique")
     ]
 
+    @api.constrains(
+        "capacity", "sequential", "throttle", "capacity_default", "sequential_default"
+    )
+    def _check_jobrunner_configuration(self):
+        for record in self:
+            if record.capacity < 0:
+                raise exceptions.ValidationError(
+                    self.env._("The capacity of a channel cannot be negative.")
+                )
+            if record.throttle < 0:
+                raise exceptions.ValidationError(
+                    self.env._("The throttle of a channel cannot be negative.")
+                )
+            if record.sequential and record.capacity != 1:
+                raise exceptions.ValidationError(
+                    self.env._("A sequential channel must have a capacity of 1.")
+                )
+            if record.capacity_default < 0:
+                raise exceptions.ValidationError(
+                    self.env._("The default capacity of a channel cannot be negative.")
+                )
+            if record.sequential_default and record.capacity_default != 1:
+                raise exceptions.ValidationError(
+                    self.env._(
+                        "A channel with a sequential default must have a "
+                        "default capacity of 1."
+                    )
+                )
+
     @api.depends("name", "parent_id.complete_name")
     def _compute_complete_name(self):
         for record in self:
@@ -70,8 +141,17 @@ def create(self, vals_list):
                 new_vals_list.append(vals)
             vals_list = new_vals_list
         records |= super().create(vals_list)
+        records._notify_channel_config_changed()
         return records
 
+    @api.onchange("capacity")
+    def _onchange_capacity(self):
+        self.capacity_default = self.capacity
+
+    @api.onchange("sequential")
+    def _onchange_sequential(self):
+        self.sequential_default = self.sequential
+
     def write(self, values):
         for channel in self:
             if (
@@ -80,10 +160,25 @@ def write(self, values):
                 and ("name" in values or "parent_id" in values)
             ):
                 raise exceptions.UserError(_("Cannot change the root channel"))
-        return super().write(values)
+        res = super().write(values)
+        if self._JOBRUNNER_CONFIG_FIELDS.intersection(values):
+            self._notify_channel_config_changed()
+        return res
 
     def unlink(self):
         for channel in self:
             if channel.name == "root":
                 raise exceptions.UserError(_("Cannot remove the root channel"))
-        return super().unlink()
+        res = super().unlink()
+        self._notify_channel_config_changed()
+        return res
+
+    def action_pause(self):
+        self.write({"paused": True})
+
+    def action_resume(self):
+        self.write({"paused": False})
+
+    def _notify_channel_config_changed(self):
+        """Notify the jobrunner to reload its configuration"""
+        self.env.cr.execute("SELECT pg_notify('queue_job', %s)", (RELOAD_PAYLOAD,))
diff --git a/queue_job/tests/test_model_job_channel.py b/queue_job/tests/test_model_job_channel.py
index 20ebbc0bfe..37a1f89485 100644
--- a/queue_job/tests/test_model_job_channel.py
+++ b/queue_job/tests/test_model_job_channel.py
@@ -1,9 +1,12 @@
 # copyright 2018 Camptocamp
 # license lgpl-3.0 or later (http://www.gnu.org/licenses/lgpl.html)
 
+from unittest import mock
+
 from psycopg2 import IntegrityError
 
 import odoo
+from odoo import exceptions
 from odoo.tests import common
 
 
@@ -57,3 +60,127 @@ def test_channel_display_name(self):
             {"name": "test", "parent_id": self.root_channel.id}
         )
         self.assertEqual(channel.display_name, channel.complete_name)
+
+    def test_capacity_should_not_be_negative(self):
+        with self.assertRaisesRegex(
+            exceptions.ValidationError,
+            "The capacity of a channel cannot be negative.",
+        ):
+            self.Channel.create(
+                {
+                    "name": "test_capacity",
+                    "parent_id": self.root_channel.id,
+                    "capacity": -1,
+                }
+            )
+
+    def test_capacity_default_should_not_be_negative(self):
+        with self.assertRaisesRegex(
+            exceptions.ValidationError,
+            "The default capacity of a channel cannot be negative.",
+        ):
+            self.Channel.create(
+                {
+                    "name": "test_capacity_default",
+                    "parent_id": self.root_channel.id,
+                    "capacity_default": -1,
+                }
+            )
+
+    def test_throttle_should_not_be_negative(self):
+        with self.assertRaisesRegex(
+            exceptions.ValidationError,
+            "The throttle of a channel cannot be negative.",
+        ):
+            self.Channel.create(
+                {
+                    "name": "test_throttle",
+                    "parent_id": self.root_channel.id,
+                    "throttle": -1,
+                }
+            )
+
+    def test_sequential_should_have_capacity_one(self):
+        with self.assertRaisesRegex(
+            exceptions.ValidationError,
+            "A sequential channel must have a capacity of 1.",
+        ):
+            self.Channel.create(
+                {
+                    "name": "test_sequential",
+                    "parent_id": self.root_channel.id,
+                    "sequential": True,
+                    "capacity": 2,
+                }
+            )
+
+    def test_sequential_default_should_have_capacity_default_one(self):
+        with self.assertRaisesRegex(
+            exceptions.ValidationError,
+            "A channel with a sequential default must have a default capacity of 1.",
+        ):
+            self.Channel.create(
+                {
+                    "name": "test_sequential_default",
+                    "parent_id": self.root_channel.id,
+                    "sequential_default": True,
+                    "capacity_default": 2,
+                }
+            )
+
+    def test_action_pause(self):
+        self.root_channel.action_pause()
+        self.assertTrue(self.root_channel.paused)
+
+    def test_action_resume(self):
+        self.root_channel.paused = True
+        self.root_channel.action_resume()
+        self.assertFalse(self.root_channel.paused)
+
+    def _patch_notify(self):
+        return mock.patch.object(
+            type(self.Channel), "_notify_channel_config_changed", autospec=True
+        )
+
+    def test_notify_create_channel(self):
+        with self._patch_notify() as notify:
+            self.Channel.create(
+                {
+                    "name": "create_notify",
+                    "parent_id": self.root_channel.id,
+                    "capacity": 2,
+                }
+            )
+        notify.assert_called_once()
+
+    def test_notify_write_jobrunner_config(self):
+        channel = self.Channel.create(
+            {"name": "write_notify", "parent_id": self.root_channel.id}
+        )
+        with self._patch_notify() as notify:
+            channel.capacity = 3
+        notify.assert_called_once()
+
+        with self._patch_notify() as notify:
+            channel.paused = True
+        notify.assert_called_once()
+
+        with self._patch_notify() as notify:
+            channel.removal_interval = 60
+        notify.assert_not_called()
+
+        with self._patch_notify() as notify:
+            channel.capacity_default = 1
+        notify.assert_called_once()
+
+        with self._patch_notify() as notify:
+            channel.sequential_default = True
+        notify.assert_called_once()
+
+    def test_notify_unlink_channel(self):
+        channel = self.Channel.create(
+            {"name": "unlink_notify", "parent_id": self.root_channel.id}
+        )
+        with self._patch_notify() as notify:
+            channel.unlink()
+        notify.assert_called_once()
diff --git a/queue_job/views/queue_job_channel_views.xml b/queue_job/views/queue_job_channel_views.xml
index 50c245716b..70e309531f 100644
--- a/queue_job/views/queue_job_channel_views.xml
+++ b/queue_job/views/queue_job_channel_views.xml
@@ -5,23 +5,66 @@
         <field name="model">queue.job.channel</field>
         <field name="arch" type="xml">
             <form string="Channels">
-                <group>
-                    <field
-                        name="name"
-                        required="name != 'root'"
-                        readonly="name == 'root'"
+                <header>
+                    <button
+                        name="action_pause"
+                        type="object"
+                        string="Pause"
+                        class="oe_highlight"
+                        invisible="paused"
                     />
-                    <field
-                        name="parent_id"
-                        required="name != 'root'"
-                        readonly="name == 'root'"
+                    <button
+                        name="action_resume"
+                        type="object"
+                        string="Resume"
+                        class="oe_highlight"
+                        invisible="not paused"
                     />
-                    <field name="complete_name" />
-                    <field name="removal_interval" />
-                </group>
-                <group>
-                    <field name="job_function_ids" widget="many2many_tags" />
-                </group>
+                </header>
+                <sheet>
+                    <widget
+                        name="web_ribbon"
+                        text="Paused"
+                        bg_color="text-bg-danger"
+                        invisible="not paused"
+                    />
+                    <group>
+                        <field
+                            name="name"
+                            required="name != 'root'"
+                            readonly="name == 'root'"
+                        />
+                        <field
+                            name="parent_id"
+                            required="name != 'root'"
+                            readonly="name == 'root'"
+                        />
+                        <field name="complete_name" />
+                        <field name="removal_interval" />
+                    </group>
+                    <group string="Job Functions">
+                        <field
+                            name="job_function_ids"
+                            widget="many2many_tags"
+                            nolabel="1"
+                        />
+                    </group>
+                    <group string="Job Runner">
+                        <p class="text-muted" colspan="2">
+                            These properties will be used only if the server-side
+                            channels configuration is not used.
+                        </p>
+                        <group>
+                            <field name="capacity" />
+                            <field name="sequential" />
+                            <field name="throttle" />
+                        </group>
+                        <group>
+                            <field name="capacity_default" />
+                            <field name="sequential_default" />
+                        </group>
+                    </group>
+                </sheet>
             </form>
         </field>
     </record>
@@ -32,6 +75,8 @@
         <field name="arch" type="xml">
             <list>
                 <field name="complete_name" />
+                <field name="capacity" />
+                <field name="paused" widget="boolean_toggle" />
             </list>
         </field>
     </record>
@@ -44,6 +89,11 @@
                 <field name="name" />
                 <field name="complete_name" />
                 <field name="parent_id" />
+                <filter
+                    string="Paused"
+                    name="paused"
+                    domain="[('paused', '=', True)]"
+                />
             </search>
         </field>
     </record>

From 9d0b7f450fa7ee4c3b75cb64d3b6aea4a1ab06f7 Mon Sep 17 00:00:00 2001
From: Guewen Baconnier <guewen.baconnier@qoqa.com>
Date: Tue, 18 Aug 2026 11:45:10 +0200
Subject: [PATCH 2/2] [ADD] queue_job: implement per-database channels

---
 queue_job/README.rst                    | 125 ++++++-
 queue_job/jobrunner/__init__.py         |  12 +-
 queue_job/jobrunner/channels.py         |  24 ++
 queue_job/jobrunner/runner.py           | 373 ++++++++++++++++++--
 queue_job/readme/CONFIGURE.md           | 119 ++++++-
 queue_job/static/description/index.html | 111 +++++-
 queue_job/tests/test_runner_runner.py   | 442 +++++++++++++++++++++++-
 7 files changed, 1139 insertions(+), 67 deletions(-)

diff --git a/queue_job/README.rst b/queue_job/README.rst
index 555196bde1..a284086532 100644
--- a/queue_job/README.rst
+++ b/queue_job/README.rst
@@ -123,22 +123,100 @@ Be sure to have the ``requests`` library.
 Configuration
 =============
 
-- Using environment variables and command line:
+There are two ways to configure the job runner:
+
+Set ``channels`` (or ``ODOO_QUEUE_JOB_CHANNELS``) and every database
+shares the same channel tree (we will call it server-side channels):
+
+.. code:: ini
+
+   [queue_job]
+   channels = root:10,root.priority:3,root.slow:1
+
+Leave ``channels`` unset and set ``max_capacity`` instead. The job
+runner then builds a separate channel tree for each database, based on
+the *Job Channels* configured on each database (we will call it
+per-database channels).
+
+.. code:: ini
+
+   [queue_job]
+   max_capacity = 10
+
+``channels`` always has precedence over ``max_capacity``. If
+``channels`` is set, the per-database configuration is not used. If
+neither ``channels`` nor ``max_capacity`` are set, the default execution
+mode is per-database channels with a ``max_capacity`` of 1.
+
+In the per-database mode, channels are configured from the *Job
+Channels* menu (or by XML data, see the Usage) instead of a global
+configuration string.
+
+Alongside ``max_capacity``, a global configuration ``db_max_capacity``
+can be set. It represents the max number of jobs executed at the same
+time for a single database (capped by the ``max_capacity`` anyway):
+
+.. code:: ini
+
+   [queue_job]
+   max_capacity = 10
+   db_max_capacity = 3  # no more than 3 simultaneous jobs per database
+
+``db_max_capacity`` may be an integer or a pattern such as
+``prod_*:20,staging:2,*:5``, where the first match wins. When using a
+pattern, unmatched databases can be configured by a global pattern at
+the end (``*:n``), otherwise they will use the ``max_capacity``.
+
+The root channel capacity of a database can still be set independently,
+however, will in any case be capped by the global ``max_capacity`` and
+``db_max_capacity`` parameters.
+
+When set to 0, ``max_capacity`` or ``db_max_capacity`` means there is no
+jobs executed.
+
+Editing a channel's capacity, sequential flag, throttle or set it to
+pause from the *Job Channels* menu **is applied live on the job
+runner**.
+
+.. note::
+
+   A new database still needs the jobrunner to be restarted.
+
+When using the server-side channels, the configuration is static and
+loaded at startup of the jobrunner.
+
+The execution of channels by the job runner is defined by:
+
+- ``capacity``: max number of jobs running at once in the channel (``0``
+  means no limit of its own, the parent channel and ``max_capacity`` or
+  ``db_max_capacity`` still apply)
+- ``sequential``: jobs run one after the other, and a failed job blocks
+  the channel (requires a capacity of 1)
+- ``throttle``: minimum delay, in seconds, between the start of two jobs
+- ``paused``: stop running jobs in this channel and its sub-channels
+
+**Job Runner Configuration Parameters**
+
+- Using environment variables:
 
   - Adjust environment variables (optional):
 
-    - ``ODOO_QUEUE_JOB_CHANNELS=root:4`` or any other channels
-      configuration. The default is ``root:1``
+    - ``ODOO_QUEUE_JOB_CHANNELS=root:4`` or any other channels for
+      server-side channels
+    - ``ODOO_QUEUE_JOB_MAX_CAPACITY=4``, max number of concurrent jobs
+      (not used if ``ODOO_QUEUE_JOB_CHANNELS`` is set) for per-database
+      channels
+    - ``ODOO_QUEUE_JOB_DB_MAX_CAPACITY=2``, max number of concurrent
+      jobs per DB (not used if ``ODOO_QUEUE_JOB_CHANNELS`` is set)
     - ``ODOO_QUEUE_JOB_PORT=8069``, default ``--http-port``
     - ``ODOO_QUEUE_JOB_SCHEME=https``, default ``http``
     - ``ODOO_QUEUE_JOB_HOST=load-balancer``, default
       ``--http-interface`` or ``localhost`` if unset
     - ``ODOO_QUEUE_JOB_HTTP_AUTH_USER=jobrunner``, default empty
     - ``ODOO_QUEUE_JOB_HTTP_AUTH_PASSWORD=s3cr3t``, default empty
-    - Start Odoo with ``--load=web,queue_job`` and ``--workers`` greater
-      than 1. [1]_
 
-- Using the Odoo configuration file:
+- Using the Odoo configuration file (set either ``channels``, either
+  ``max_capacity`` and/or ``db_max_capacity``)
 
 .. code:: ini
 
@@ -150,12 +228,26 @@ Configuration
    (...)
    [queue_job]
    channels = root:2
+   max_capacity = 8
+   db_max_capacity = 3
    scheme = https
    host = load-balancer
    port = 443
    http_auth_user = jobrunner
    http_auth_password = s3cr3t
 
+- Odoo has to be started with ``queue_job`` as server-wide module,
+  either using the command line option ``--load=web,queue_job``, either
+  by setting it in the Odoo configuration file, and ``--workers``
+  greater than 1. [1]_
+
+.. code:: ini
+
+   [options]
+   (...)
+   workers = 6
+   server_wide_modules = web,queue_job
+
 - Confirm the runner is starting correctly by checking the odoo log
   file:
 
@@ -166,14 +258,25 @@ Configuration
    ...INFO...queue_job.jobrunner.runner: queue job runner ready for db <dbname>
    ...INFO...queue_job.jobrunner.runner: database connections ready
 
-- Create jobs (eg using ``base_import_async``) and observe they start
-  immediately and in parallel.
+- Create jobs (you can create test jobs by opening
+  ``https://yourodoourl/queue_job/create_test_job``) and observe they
+  start immediately and in parallel.
 - Tip: to enable debug logging for the queue job, use
   ``--log-handler=odoo.addons.queue_job:DEBUG``
 
-- Jobs that remain in ``enqueued`` or ``started`` state (because, for
-  instance, their worker has been killed) will be automatically
-  re-queued.
+**Migrating from server-side channels to per-database channels**
+
+As long as ``channels`` (or ``ODOO_QUEUE_JOB_CHANNELS``) is set, the job
+runner keeps using the server-side channels.
+
+To move to channels per database:
+
+1. Configure the channels you need on each database, from the *Job
+   Channels* menu: capacity, sequential, throttle, pause
+2. Once this configuration is done, remove the ``channels`` options and
+   set ``max_capacity`` (and optionally ``db_max_capacity``) instead (or
+   their corresponding environment variables)
+3. Restart the job runner
 
 .. [1]
    It works with the threaded Odoo server too, although this way of
diff --git a/queue_job/jobrunner/__init__.py b/queue_job/jobrunner/__init__.py
index e2561b0e74..2a1168707b 100644
--- a/queue_job/jobrunner/__init__.py
+++ b/queue_job/jobrunner/__init__.py
@@ -20,7 +20,7 @@
     queue_job_config = config.misc.get("queue_job", {})
 
 
-from .runner import QueueJobRunner, _channels
+from .runner import QueueJobRunner, _channels, _max_capacity
 
 _logger = logging.getLogger(__name__)
 
@@ -87,7 +87,12 @@ def signal_time_expired_handler(self, n, stack):
 
 
 def _is_runner_enabled():
-    return not _channels().strip().startswith("root:0")
+    channel_config = _channels()
+    if channel_config and channel_config.strip().startswith("root:0"):
+        return False
+    elif channel_config:
+        return True
+    return _max_capacity() != 0
 
 
 def _start_runner_thread(server_type):
@@ -100,7 +105,8 @@ def _start_runner_thread(server_type):
         else:
             _logger.info(
                 "jobrunner thread (in %s) NOT started, "
-                "because the root channel's capacity is set to 0",
+                "because the root channel's capacity or the max capacity "
+                "is set to 0",
                 server_type,
             )
 
diff --git a/queue_job/jobrunner/channels.py b/queue_job/jobrunner/channels.py
index 36e77bee07..636338d112 100644
--- a/queue_job/jobrunner/channels.py
+++ b/queue_job/jobrunner/channels.py
@@ -3,6 +3,7 @@
 # License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html)
 import logging
 from collections import namedtuple
+from dataclasses import asdict, dataclass
 from functools import total_ordering
 from heapq import heappop, heappush
 from weakref import WeakValueDictionary
@@ -17,6 +18,19 @@
 _logger = logging.getLogger(__name__)
 
 
+@dataclass
+class ChannelConfig:
+    """Configuration of a channel"""
+
+    name: str
+    capacity: int = 0
+    sequential: bool = False
+    throttle: int = 0
+    paused: bool = False
+    capacity_default: int = 0
+    sequential_default: bool = False
+
+
 class PriorityQueue:
     """A priority queue that supports removing arbitrary objects.
 
@@ -1024,6 +1038,11 @@ def simple_configure(self, config_string):
         for config in ChannelManager.parse_simple_config(config_string):
             self.get_channel_from_config(config)
 
+    def configure(self, configs):
+        """Configure the channel manager from list of :class:`ChannelConfig`"""
+        for config in configs:
+            self.get_channel_from_config(asdict(config))
+
     def get_channel_from_config(self, config):
         """Return a Channel object from a parsed configuration.
 
@@ -1174,3 +1193,8 @@ def get_jobs_to_run(self, now):
 
     def get_wakeup_time(self):
         return self._root_channel.get_wakeup_time()
+
+    @property
+    def running_count(self) -> int:
+        """Number of jobs currently running"""
+        return len(self._root_channel._running)
diff --git a/queue_job/jobrunner/runner.py b/queue_job/jobrunner/runner.py
index 95e134ba44..62a713fff8 100644
--- a/queue_job/jobrunner/runner.py
+++ b/queue_job/jobrunner/runner.py
@@ -19,11 +19,13 @@
   anonymous ``/queue_job/runjob`` HTTP request.
 """
 
+import fnmatch
 import logging
 import os
 import selectors
 import threading
 import time
+from collections import deque
 from contextlib import closing, contextmanager
 
 import psycopg2
@@ -34,7 +36,7 @@
 from odoo.tools import config
 
 from . import queue_job_config
-from .channels import ENQUEUED, NOT_DONE, ChannelManager
+from .channels import ENQUEUED, NOT_DONE, RELOAD_PAYLOAD, ChannelConfig, ChannelManager
 
 SELECT_TIMEOUT = 60
 ERROR_RECOVERY_DELAY = 5
@@ -57,14 +59,93 @@ class MasterElectionLost(Exception):
 # so we check it in addition to the environment variables.
 
 
-def _channels():
+def _max_capacity() -> int:
+    """Maximum number of jobs running at the same time across all databases
+
+    It comes from the ``ODOO_QUEUE_JOB_MAX_CAPACITY`` environment
+    variable, then ``max_capacity`` in the ``[queue_job]`` section of the
+    configuration file.
+
+    If none is configured, the max capacity defaults to 1.
+    An explicit value of 0 means no job is dispatched at all.
+    """
+    value = os.environ.get("ODOO_QUEUE_JOB_MAX_CAPACITY") or queue_job_config.get(
+        "max_capacity"
+    )
+    if value:
+        return int(value)
+    return 1
+
+
+def _db_max_capacity() -> str:
     return (
-        os.environ.get("ODOO_QUEUE_JOB_CHANNELS")
-        or queue_job_config.get("channels")
-        or "root:1"
+        os.environ.get("ODOO_QUEUE_JOB_DB_MAX_CAPACITY")
+        or queue_job_config.get("db_max_capacity")
+        or ""
     )
 
 
+def parse_db_max_capacity(spec):
+    """Parse a per-database max capacity configuration string
+
+    The string is a comma-separated list of ``pattern:capacity`` items, where
+    ``pattern`` matches database names with fnmatch wildcards.
+
+    The first matching pattern wins, so specific patterns must be first in the
+    string.
+
+    A single integer is applied to all databases, as a shorthand for
+    ``*:capacity``.
+
+    >>> parse_db_max_capacity('prod_*:20,staging:2,*:5')
+    [('prod_*', 20), ('staging', 2), ('*', 5)]
+    >>> parse_db_max_capacity('8')
+    [('*', 8)]
+    >>> parse_db_max_capacity('')
+    []
+    >>> parse_db_max_capacity(None)
+    []
+    """
+    rules = []
+    if not spec:
+        return rules
+    for item in spec.replace("\n", ",").split(","):
+        item = item.strip()
+        if not item:
+            continue
+        pattern, sep, capacity = item.rpartition(":")
+        if not sep:
+            pattern = "*"
+        try:
+            rules.append((pattern.strip(), int(capacity)))
+        except ValueError as ex:
+            raise ValueError(f"Invalid db max capacity {spec}: {capacity}") from ex
+    return rules
+
+
+def db_max_capacity_for(db_name, rules, default=None):
+    """Max capacity of a database, first match wins
+
+    >>> rules = parse_db_max_capacity('prod_*:20,staging:2,*:5')
+    >>> db_max_capacity_for('prod_foo', rules)
+    20
+    >>> db_max_capacity_for('staging', rules)
+    2
+    >>> db_max_capacity_for('dev', rules)
+    5
+    >>> db_max_capacity_for('dev', [], default=7)
+    7
+    """
+    for pattern, capacity in rules:
+        if fnmatch.fnmatch(db_name, pattern):
+            return capacity
+    return default
+
+
+def _channels():
+    return os.environ.get("ODOO_QUEUE_JOB_CHANNELS") or queue_job_config.get("channels")
+
+
 def _odoo_now():
     # important: this must return the same as postgresql
     # EXTRACT(EPOCH FROM TIMESTAMP dt)
@@ -123,9 +204,11 @@ def __init__(self, db_name):
         try:
             self.conn.set_isolation_level(ISOLATION_LEVEL_AUTOCOMMIT)
             self.has_queue_job = self._has_queue_job()
+            self.has_channel_config_columns = False
             if self.has_queue_job:
                 self._acquire_master_lock()
                 self._initialize()
+                self.has_channel_config_columns = self._has_channel_config_columns()
         except BaseException:
             self.close()
             raise
@@ -182,6 +265,64 @@ def _initialize(self):
         with closing(self.conn.cursor()) as cr:
             cr.execute("LISTEN queue_job")
 
+    def _has_channel_config_columns(self):
+        with closing(self.conn.cursor()) as cr:
+            cr.execute(
+                """
+                SELECT count(*)
+                FROM information_schema.columns
+                WHERE table_name = %s
+                AND column_name IN (
+                    'capacity',
+                    'sequential',
+                    'throttle',
+                    'paused',
+                    'capacity_default',
+                    'sequential_default'
+                )
+                """,
+                ("queue_job_channel",),
+            )
+            return cr.fetchone()[0] == 6
+
+    def load_channels_config(self):
+        """Return the channels configuration stored in the database"""
+        if not self.has_channel_config_columns:
+            return None
+        with closing(self.conn.cursor()) as cr:
+            cr.execute(
+                "SELECT complete_name, "
+                "COALESCE(capacity, 0), "
+                "COALESCE(sequential, false), "
+                "COALESCE(throttle, 0), "
+                "COALESCE(paused, false), "
+                "COALESCE(capacity_default, 0), "
+                "COALESCE(sequential_default, false) "
+                "FROM queue_job_channel "
+            )
+            rows = cr.fetchall()
+            configs = [
+                ChannelConfig(
+                    name=name,
+                    capacity=capacity,
+                    sequential=sequential,
+                    throttle=throttle,
+                    paused=paused,
+                    capacity_default=capacity_default,
+                    sequential_default=sequential_default,
+                )
+                for (
+                    name,
+                    capacity,
+                    sequential,
+                    throttle,
+                    paused,
+                    capacity_default,
+                    sequential_default,
+                ) in rows
+            ]
+            return configs
+
     @contextmanager
     def select_jobs(self, where, args):
         # pylint: disable=sql-injection
@@ -321,16 +462,40 @@ def __init__(
         user=None,
         password=None,
         channel_config_string=None,
+        max_capacity=None,
+        db_max_capacity=None,
     ):
         self.scheme = scheme
         self.host = host
         self.port = port
         self.user = user
         self.password = password
-        self.channel_manager = ChannelManager()
+
         if channel_config_string is None:
             channel_config_string = _channels()
-        self.channel_manager.simple_configure(channel_config_string)
+
+        self._server_side_channel_manager = None
+        if channel_config_string:
+            channel_manager = ChannelManager()
+            channel_manager.simple_configure(channel_config_string)
+            self._server_side_channel_manager = channel_manager
+            # max_capacity is always equal to the root channel in server-side
+            # configuration
+            max_capacity = channel_manager.get_channel_by_name("root").capacity
+
+        if max_capacity is None:
+            max_capacity = _max_capacity()
+        self.max_capacity = max(0, max_capacity)
+
+        if db_max_capacity is None:
+            db_max_capacity = _db_max_capacity()
+        self.db_max_capacity_rules = parse_db_max_capacity(db_max_capacity)
+
+        self._channel_manager_by_db = {}
+        self._channel_managers = []
+
+        self._round_robin_offset = 0
+
         self.db_by_name = {}
         self._stop = False
         self._stop_pipe = os.pipe()
@@ -387,11 +552,88 @@ def close_databases(self, remove_jobs=True):
         for db_name, db in self.db_by_name.items():
             try:
                 if remove_jobs:
-                    self.channel_manager.remove_db(db_name)
+                    self._channel_manager_by_db[db_name].remove_db(db_name)
                 db.close()
             except Exception:
                 _logger.warning("error closing database %s", db_name, exc_info=True)
         self.db_by_name = {}
+        self._channel_manager_by_db = {}
+        self._channel_managers = []
+
+    @staticmethod
+    def _unique_channel_managers(channel_managers):
+        seen = set()
+        result = []
+        for channel_manager in channel_managers:
+            if id(channel_manager) not in seen:
+                seen.add(id(channel_manager))
+                result.append(channel_manager)
+        return result
+
+    def _build_channel_manager(self, db):
+        """Build and configure the channel manager of a database"""
+        db_max = max(
+            0,
+            db_max_capacity_for(
+                db.db_name, self.db_max_capacity_rules, default=self.max_capacity
+            ),
+        )
+        channel_manager = ChannelManager()
+
+        channels_config = db.load_channels_config()
+        if channels_config is None:
+            # database not updated to the proper schema,
+            # no job execution until it is properly upgraded
+            _logger.error(
+                "database %s schema is outdated, -u queue_job required", db.db_name
+            )
+            channel_manager.configure([ChannelConfig(name="root", capacity=0)])
+            return channel_manager
+
+        root_config = next(
+            (config for config in channels_config if config.name == "root"), None
+        )
+        if root_config is None:
+            root_config = ChannelConfig("root")
+            channels_config.insert(0, root_config)
+
+        if not db_max:
+            # if a database is set at 0, it does not run any jobs, pause it
+            root_config.paused = True
+        elif not root_config.capacity:
+            root_config.capacity = db_max
+        else:
+            root_config.capacity = min(root_config.capacity, db_max)
+        channel_manager.configure(channels_config)
+        return channel_manager
+
+    def _reconfigure_db(self, db_name):
+        """Rebuild the channel manager for a database and reload its jobs"""
+        db = self.db_by_name.get(db_name)
+        if db is None:
+            return
+        if self._server_side_channel_manager:
+            channel_manager = self._server_side_channel_manager
+        else:
+            try:
+                channel_manager = self._build_channel_manager(db)
+            except ValueError:
+                # a bad channel configuration on a single database
+                # (e.g. sequential with a capacity != 1) should not
+                # break other databases, skip it
+                _logger.warning("error configuring db %s", db_name, exc_info=True)
+                return
+        with db.select_jobs("state in %s", (NOT_DONE,)) as cr:
+            for job_data in cr:
+                channel_manager.notify(db_name, *job_data)
+        self._register_channel_manager(db_name, channel_manager)
+        _logger.info("channels configuration loaded for db %s", db_name)
+
+    def _register_channel_manager(self, db_name, channel_manager):
+        self._channel_manager_by_db[db_name] = channel_manager
+        self._channel_managers = self._unique_channel_managers(
+            self._channel_manager_by_db.values()
+        )
 
     def initialize_databases(self):
         for db_name in sorted(self.get_db_names()):
@@ -399,9 +641,7 @@ def initialize_databases(self):
             db = Database(db_name)
             if db.has_queue_job:
                 self.db_by_name[db_name] = db
-                with db.select_jobs("state in %s", (NOT_DONE,)) as cr:
-                    for job_data in cr:
-                        self.channel_manager.notify(db_name, *job_data)
+                self._reconfigure_db(db_name)
                 _logger.info("queue job runner ready for db %s", db_name)
             else:
                 db.close()
@@ -411,24 +651,71 @@ def requeue_dead_jobs(self):
             if db.has_queue_job:
                 db.requeue_dead_jobs()
 
-    def run_jobs(self):
-        now = _odoo_now()
-        for job in self.channel_manager.get_jobs_to_run(now):
-            if self._stop:
-                break
-            _logger.info("asking Odoo to run job %s on db %s", job.uuid, job.db_name)
-            self.db_by_name[job.db_name].set_job_enqueued(job.uuid)
-            _async_http_get(
-                self.scheme,
-                self.host,
-                self.port,
-                self.user,
-                self.password,
-                job.db_name,
-                job.uuid,
+    def _all_running_count(self) -> int:
+        return sum(
+            channel_manager.running_count for channel_manager in self._channel_managers
+        )
+
+    def _dispatch_job(self, job):
+        _logger.info("asking Odoo to run job %s on db %s", job.uuid, job.db_name)
+        self.db_by_name[job.db_name].set_job_enqueued(job.uuid)
+        _async_http_get(
+            self.scheme,
+            self.host,
+            self.port,
+            self.user,
+            self.password,
+            job.db_name,
+            job.uuid,
+        )
+
+    def _round_robin_jobs(self, channel_managers, now):
+        managers_count = len(channel_managers)
+        # Ensure the channel managers are ordered in way that all have
+        # equal chances to enqueue jobs. The manager that was last last
+        # time will be first the next time and so on.
+        job_generators = deque(
+            (
+                # store the actual position of the channel manager in the channel
+                # managers list
+                index % managers_count,
+                channel_managers[index % managers_count].get_jobs_to_run(now),
             )
+            for index in range(
+                self._round_robin_offset, self._round_robin_offset + managers_count
+            )
+        )
+        while job_generators:
+            index, job_generator = job_generators.popleft()
+            job = next(job_generator, None)
+            if job is None:
+                # generator exhausted for this tick, remove from the deque
+                # it will come back next time
+                continue
+            job_generators.append((index, job_generator))
+            self._round_robin_offset = index + 1
+            yield job
+
+    def run_jobs(self):
+        channel_managers = self._channel_managers
+        if not channel_managers:
+            return
+
+        jobs = self._round_robin_jobs(channel_managers, _odoo_now())
+        while not self._stop:
+            if self._all_running_count() >= self.max_capacity:
+                _logger.debug(
+                    "max capacity of %s reached, waiting for capacity",
+                    self.max_capacity,
+                )
+                return
+            job = next(jobs, None)
+            if job is None:
+                return
+            self._dispatch_job(job)
 
     def process_notifications(self):
+        reload_db_names = set()
         for db in self.db_by_name.values():
             if not db.conn.notifies:
                 # If there are no activity in the queue_job table it seems that
@@ -440,13 +727,39 @@ def process_notifications(self):
                 if self._stop:
                     break
                 notification = db.conn.notifies.pop()
-                uuid = notification.payload
+                payload = notification.payload
+                if payload == RELOAD_PAYLOAD and not self._server_side_channel_manager:
+                    reload_db_names.add(db.db_name)
+                    continue
+
+                uuid = payload
+                channel_manager = self._channel_manager_by_db[db.db_name]
                 with db.select_jobs("uuid = %s", (uuid,)) as cr:
                     job_datas = cr.fetchone()
                     if job_datas:
-                        self.channel_manager.notify(db.db_name, *job_datas)
+                        channel_manager.notify(db.db_name, *job_datas)
                     else:
-                        self.channel_manager.remove_job(uuid)
+                        channel_manager.remove_job(uuid)
+
+        for db_name in reload_db_names:
+            self._reconfigure_db(db_name)
+
+    def next_wakeup_time(self):
+        # A wake-up time of 0 does not mean to wake immediately, but to stop
+        # until we get new notifications (practically, set a SELECT_TIMEOUT,
+        # and wait for notifications). Wake-ups of more than 0 are used to
+        # dispatch jobs with ETA, as these will not notify anything when they
+        # actually have to start.
+        # So when getting the next wake-up time, we find the first channel
+        # manager with ETA jobs (a wake-up time more than 0), and if none,
+        # a wake-up time of zero is returned to go back to the select waiting
+        # for notifications.
+        wakeup_times = [
+            wakeup_time
+            for channel_manager in self._channel_managers
+            if (wakeup_time := channel_manager.get_wakeup_time())
+        ]
+        return min(wakeup_times, default=0)
 
     def wait_notification(self):
         for db in self.db_by_name.values():
@@ -458,7 +771,7 @@ def wait_notification(self):
         conns = [db.conn for db in self.db_by_name.values()]
         conns.append(self._stop_pipe[0])
         # look if the channels specify a wakeup time
-        wakeup_time = self.channel_manager.get_wakeup_time()
+        wakeup_time = self.next_wakeup_time()
         if not wakeup_time:
             # this could very well be no timeout at all, because
             # any activity in the job queue will wake us up, but
diff --git a/queue_job/readme/CONFIGURE.md b/queue_job/readme/CONFIGURE.md
index 7239106218..95dd380748 100644
--- a/queue_job/readme/CONFIGURE.md
+++ b/queue_job/readme/CONFIGURE.md
@@ -1,16 +1,89 @@
-- Using environment variables and command line:
+There are two ways to configure the job runner:
+
+Set `channels` (or `ODOO_QUEUE_JOB_CHANNELS`) and every database shares the
+same channel tree (we will call it server-side channels):
+
+``` ini
+[queue_job]
+channels = root:10,root.priority:3,root.slow:1
+```
+
+Leave `channels` unset and set `max_capacity` instead. The job runner then
+builds a separate channel tree for each database, based on the *Job Channels*
+configured on each database (we will call it per-database channels).
+
+``` ini
+[queue_job]
+max_capacity = 10
+```
+
+`channels` always has precedence over `max_capacity`. If `channels` is set, the
+per-database configuration is not used. If neither `channels` nor
+`max_capacity` are set, the default execution mode is per-database channels
+with a `max_capacity` of 1.
+
+In the per-database mode, channels are configured from the *Job Channels* menu
+(or by XML data, see the Usage) instead of a global configuration string.
+
+Alongside `max_capacity`, a global configuration `db_max_capacity` can be set.
+It represents the max number of jobs executed at the same time for a single
+database (capped by the `max_capacity` anyway):
+
+``` ini
+[queue_job]
+max_capacity = 10
+db_max_capacity = 3  # no more than 3 simultaneous jobs per database
+```
+
+`db_max_capacity` may be an integer or a pattern such as
+`prod_*:20,staging:2,*:5`, where the first match wins. When using a pattern,
+unmatched databases can be configured by a global pattern at the end (`*:n`),
+otherwise they will use the `max_capacity`.
+
+The root channel capacity of a database can still be set independently,
+however, will in any case be capped by the global `max_capacity` and
+`db_max_capacity` parameters.
+
+When set to 0, `max_capacity` or `db_max_capacity` means there is no jobs executed.
+
+Editing a channel's capacity, sequential flag, throttle or set it to pause from
+the *Job Channels* menu **is applied live on the job runner**.
+
+> [!NOTE]
+> A new database still needs the jobrunner to be restarted.
+
+When using the server-side channels, the configuration is static and loaded at
+startup of the jobrunner.
+
+The execution of channels by the job runner is defined by:
+
+- `capacity`: max number of jobs running at once in the channel (`0` means no
+  limit of its own, the parent channel and `max_capacity` or `db_max_capacity`
+  still apply)
+- `sequential`: jobs run one after the other, and a failed job blocks the
+  channel (requires a capacity of 1)
+- `throttle`: minimum delay, in seconds, between the start of two jobs
+- `paused`: stop running jobs in this channel and its sub-channels
+
+
+**Job Runner Configuration Parameters**
+
+- Using environment variables:
   - Adjust environment variables (optional):
-    - `ODOO_QUEUE_JOB_CHANNELS=root:4` or any other channels
-      configuration. The default is `root:1`
+    - `ODOO_QUEUE_JOB_CHANNELS=root:4` or any other channels for server-side
+      channels
+    - `ODOO_QUEUE_JOB_MAX_CAPACITY=4`, max number of concurrent jobs (not used
+      if `ODOO_QUEUE_JOB_CHANNELS` is set) for per-database channels
+    - `ODOO_QUEUE_JOB_DB_MAX_CAPACITY=2`, max number of concurrent jobs per DB
+      (not used if `ODOO_QUEUE_JOB_CHANNELS` is set)
     - `ODOO_QUEUE_JOB_PORT=8069`, default `--http-port`
     - `ODOO_QUEUE_JOB_SCHEME=https`, default `http`
     - `ODOO_QUEUE_JOB_HOST=load-balancer`, default `--http-interface`
       or `localhost` if unset
     - `ODOO_QUEUE_JOB_HTTP_AUTH_USER=jobrunner`, default empty
     - `ODOO_QUEUE_JOB_HTTP_AUTH_PASSWORD=s3cr3t`, default empty
-    - Start Odoo with `--load=web,queue_job` and `--workers` greater than
-      1.[^1]
-- Using the Odoo configuration file:
+- Using the Odoo configuration file (set either `channels`, either
+  `max_capacity` and/or `db_max_capacity`)
 
 ``` ini
 [options]
@@ -21,6 +94,8 @@ server_wide_modules = web,queue_job
 (...)
 [queue_job]
 channels = root:2
+max_capacity = 8
+db_max_capacity = 3
 scheme = https
 host = load-balancer
 port = 443
@@ -28,17 +103,29 @@ http_auth_user = jobrunner
 http_auth_password = s3cr3t
 ```
 
+- Odoo has to be started with `queue_job` as server-wide module, either using
+  the command line option `--load=web,queue_job`, either by setting it in the
+  Odoo configuration file, and `--workers` greater than 1.[^1]
+
+``` ini
+[options]
+(...)
+workers = 6
+server_wide_modules = web,queue_job
+```
+
 - Confirm the runner is starting correctly by checking the odoo log
   file:
 
-``` 
+```
 ...INFO...queue_job.jobrunner.runner: starting
 ...INFO...queue_job.jobrunner.runner: initializing database connections
 ...INFO...queue_job.jobrunner.runner: queue job runner ready for db <dbname>
 ...INFO...queue_job.jobrunner.runner: database connections ready
 ```
 
-- Create jobs (eg using `base_import_async`) and observe they start
+- Create jobs (you can create test jobs by opening
+  `https://yourodoourl/queue_job/create_test_job`) and observe they start
   immediately and in parallel.
 - Tip: to enable debug logging for the queue job, use
   `--log-handler=odoo.addons.queue_job:DEBUG`
@@ -46,5 +133,17 @@ http_auth_password = s3cr3t
 [^1]: It works with the threaded Odoo server too, although this way of
     running Odoo is obviously not for production purposes.
 
-* Jobs that remain in `enqueued` or `started` state (because, for instance,
-  their worker has been killed) will be automatically re-queued.
+
+**Migrating from server-side channels to per-database channels**
+
+As long as `channels` (or `ODOO_QUEUE_JOB_CHANNELS`) is set, the job
+runner keeps using the server-side channels.
+
+To move to channels per database:
+
+1. Configure the channels you need on each database, from the *Job
+   Channels* menu: capacity, sequential, throttle, pause
+2. Once this configuration is done, remove the `channels` options and set
+   `max_capacity` (and optionally `db_max_capacity`) instead (or their
+   corresponding environment variables)
+3. Restart the job runner
diff --git a/queue_job/static/description/index.html b/queue_job/static/description/index.html
index 445a3c2eff..81f0c3f788 100644
--- a/queue_job/static/description/index.html
+++ b/queue_job/static/description/index.html
@@ -3,7 +3,7 @@
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
 <meta name="generator" content="Docutils: https://docutils.sourceforge.io/" />
-<title>README.rst</title>
+<title>Job Queue</title>
 <style type="text/css">
 
 /*
@@ -484,24 +484,87 @@ <h2><a class="toc-backref" href="#toc-entry-2">Installation</a></h2>
 </div>
 <div class="section" id="configuration">
 <h2><a class="toc-backref" href="#toc-entry-3">Configuration</a></h2>
+<p>There are two ways to configure the job runner:</p>
+<p>Set <tt class="docutils literal">channels</tt> (or <tt class="docutils literal">ODOO_QUEUE_JOB_CHANNELS</tt>) and every database
+shares the same channel tree (we will call it server-side channels):</p>
+<pre class="code ini literal-block">
+<span class="k">[queue_job]</span><span class="w">
+</span><span class="na">channels</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">root:10,root.priority:3,root.slow:1</span>
+</pre>
+<p>Leave <tt class="docutils literal">channels</tt> unset and set <tt class="docutils literal">max_capacity</tt> instead. The job
+runner then builds a separate channel tree for each database, based on
+the <em>Job Channels</em> configured on each database (we will call it
+per-database channels).</p>
+<pre class="code ini literal-block">
+<span class="k">[queue_job]</span><span class="w">
+</span><span class="na">max_capacity</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">10</span>
+</pre>
+<p><tt class="docutils literal">channels</tt> always has precedence over <tt class="docutils literal">max_capacity</tt>. If
+<tt class="docutils literal">channels</tt> is set, the per-database configuration is not used. If
+neither <tt class="docutils literal">channels</tt> nor <tt class="docutils literal">max_capacity</tt> are set, the default execution
+mode is per-database channels with a <tt class="docutils literal">max_capacity</tt> of 1.</p>
+<p>In the per-database mode, channels are configured from the <em>Job
+Channels</em> menu (or by XML data, see the Usage) instead of a global
+configuration string.</p>
+<p>Alongside <tt class="docutils literal">max_capacity</tt>, a global configuration <tt class="docutils literal">db_max_capacity</tt>
+can be set. It represents the max number of jobs executed at the same
+time for a single database (capped by the <tt class="docutils literal">max_capacity</tt> anyway):</p>
+<pre class="code ini literal-block">
+<span class="k">[queue_job]</span><span class="w">
+</span><span class="na">max_capacity</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">10</span><span class="w">
+</span><span class="na">db_max_capacity</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">3</span><span class="w">  </span><span class="c1"># no more than 3 simultaneous jobs per database</span>
+</pre>
+<p><tt class="docutils literal">db_max_capacity</tt> may be an integer or a pattern such as
+<tt class="docutils literal"><span class="pre">prod_*:20,staging:2,*:5</span></tt>, where the first match wins. When using a
+pattern, unmatched databases can be configured by a global pattern at
+the end (<tt class="docutils literal">*:n</tt>), otherwise they will use the <tt class="docutils literal">max_capacity</tt>.</p>
+<p>The root channel capacity of a database can still be set independently,
+however, will in any case be capped by the global <tt class="docutils literal">max_capacity</tt> and
+<tt class="docutils literal">db_max_capacity</tt> parameters.</p>
+<p>When set to 0, <tt class="docutils literal">max_capacity</tt> or <tt class="docutils literal">db_max_capacity</tt> means there is no
+jobs executed.</p>
+<p>Editing a channel’s capacity, sequential flag, throttle or set it to
+pause from the <em>Job Channels</em> menu <strong>is applied live on the job
+runner</strong>.</p>
+<div class="admonition note">
+<p class="first admonition-title">Note</p>
+<p class="last">A new database still needs the jobrunner to be restarted.</p>
+</div>
+<p>When using the server-side channels, the configuration is static and
+loaded at startup of the jobrunner.</p>
+<p>The execution of channels by the job runner is defined by:</p>
+<ul class="simple">
+<li><tt class="docutils literal">capacity</tt>: max number of jobs running at once in the channel (<tt class="docutils literal">0</tt>
+means no limit of its own, the parent channel and <tt class="docutils literal">max_capacity</tt> or
+<tt class="docutils literal">db_max_capacity</tt> still apply)</li>
+<li><tt class="docutils literal">sequential</tt>: jobs run one after the other, and a failed job blocks
+the channel (requires a capacity of 1)</li>
+<li><tt class="docutils literal">throttle</tt>: minimum delay, in seconds, between the start of two jobs</li>
+<li><tt class="docutils literal">paused</tt>: stop running jobs in this channel and its sub-channels</li>
+</ul>
+<p><strong>Job Runner Configuration Parameters</strong></p>
 <ul class="simple">
-<li>Using environment variables and command line:<ul>
+<li>Using environment variables:<ul>
 <li>Adjust environment variables (optional):<ul>
-<li><tt class="docutils literal">ODOO_QUEUE_JOB_CHANNELS=root:4</tt> or any other channels
-configuration. The default is <tt class="docutils literal">root:1</tt></li>
+<li><tt class="docutils literal">ODOO_QUEUE_JOB_CHANNELS=root:4</tt> or any other channels for
+server-side channels</li>
+<li><tt class="docutils literal">ODOO_QUEUE_JOB_MAX_CAPACITY=4</tt>, max number of concurrent jobs
+(not used if <tt class="docutils literal">ODOO_QUEUE_JOB_CHANNELS</tt> is set) for per-database
+channels</li>
+<li><tt class="docutils literal">ODOO_QUEUE_JOB_DB_MAX_CAPACITY=2</tt>, max number of concurrent
+jobs per DB (not used if <tt class="docutils literal">ODOO_QUEUE_JOB_CHANNELS</tt> is set)</li>
 <li><tt class="docutils literal">ODOO_QUEUE_JOB_PORT=8069</tt>, default <tt class="docutils literal"><span class="pre">--http-port</span></tt></li>
 <li><tt class="docutils literal">ODOO_QUEUE_JOB_SCHEME=https</tt>, default <tt class="docutils literal">http</tt></li>
 <li><tt class="docutils literal"><span class="pre">ODOO_QUEUE_JOB_HOST=load-balancer</span></tt>, default
 <tt class="docutils literal"><span class="pre">--http-interface</span></tt> or <tt class="docutils literal">localhost</tt> if unset</li>
 <li><tt class="docutils literal">ODOO_QUEUE_JOB_HTTP_AUTH_USER=jobrunner</tt>, default empty</li>
 <li><tt class="docutils literal">ODOO_QUEUE_JOB_HTTP_AUTH_PASSWORD=s3cr3t</tt>, default empty</li>
-<li>Start Odoo with <tt class="docutils literal"><span class="pre">--load=web,queue_job</span></tt> and <tt class="docutils literal"><span class="pre">--workers</span></tt> greater
-than 1. <a class="footnote-reference" href="#footnote-1" id="footnote-reference-1">[1]</a></li>
 </ul>
 </li>
 </ul>
 </li>
-<li>Using the Odoo configuration file:</li>
+<li>Using the Odoo configuration file (set either <tt class="docutils literal">channels</tt>, either
+<tt class="docutils literal">max_capacity</tt> and/or <tt class="docutils literal">db_max_capacity</tt>)</li>
 </ul>
 <pre class="code ini literal-block">
 <span class="k">[options]</span><span class="w">
@@ -512,6 +575,8 @@ <h2><a class="toc-backref" href="#toc-entry-3">Configuration</a></h2>
 </span><span class="na">(...)</span><span class="w">
 </span><span class="k">[queue_job]</span><span class="w">
 </span><span class="na">channels</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">root:2</span><span class="w">
+</span><span class="na">max_capacity</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">8</span><span class="w">
+</span><span class="na">db_max_capacity</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">3</span><span class="w">
 </span><span class="na">scheme</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">https</span><span class="w">
 </span><span class="na">host</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">load-balancer</span><span class="w">
 </span><span class="na">port</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">443</span><span class="w">
@@ -519,6 +584,18 @@ <h2><a class="toc-backref" href="#toc-entry-3">Configuration</a></h2>
 </span><span class="na">http_auth_password</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">s3cr3t</span>
 </pre>
 <ul class="simple">
+<li>Odoo has to be started with <tt class="docutils literal">queue_job</tt> as server-wide module,
+either using the command line option <tt class="docutils literal"><span class="pre">--load=web,queue_job</span></tt>, either
+by setting it in the Odoo configuration file, and <tt class="docutils literal"><span class="pre">--workers</span></tt>
+greater than 1. <a class="footnote-reference" href="#footnote-1" id="footnote-reference-1">[1]</a></li>
+</ul>
+<pre class="code ini literal-block">
+<span class="k">[options]</span><span class="w">
+</span><span class="na">(...)</span><span class="w">
+</span><span class="na">workers</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">6</span><span class="w">
+</span><span class="na">server_wide_modules</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">web,queue_job</span>
+</pre>
+<ul class="simple">
 <li>Confirm the runner is starting correctly by checking the odoo log
 file:</li>
 </ul>
@@ -529,14 +606,24 @@ <h2><a class="toc-backref" href="#toc-entry-3">Configuration</a></h2>
 ...INFO...queue_job.jobrunner.runner: database connections ready
 </pre>
 <ul class="simple">
-<li>Create jobs (eg using <tt class="docutils literal">base_import_async</tt>) and observe they start
-immediately and in parallel.</li>
+<li>Create jobs (you can create test jobs by opening
+<tt class="docutils literal"><span class="pre">https://yourodoourl/queue_job/create_test_job</span></tt>) and observe they
+start immediately and in parallel.</li>
 <li>Tip: to enable debug logging for the queue job, use
 <tt class="docutils literal"><span class="pre">--log-handler=odoo.addons.queue_job:DEBUG</span></tt></li>
-<li>Jobs that remain in <tt class="docutils literal">enqueued</tt> or <tt class="docutils literal">started</tt> state (because, for
-instance, their worker has been killed) will be automatically
-re-queued.</li>
 </ul>
+<p><strong>Migrating from server-side channels to per-database channels</strong></p>
+<p>As long as <tt class="docutils literal">channels</tt> (or <tt class="docutils literal">ODOO_QUEUE_JOB_CHANNELS</tt>) is set, the job
+runner keeps using the server-side channels.</p>
+<p>To move to channels per database:</p>
+<ol class="arabic simple">
+<li>Configure the channels you need on each database, from the <em>Job
+Channels</em> menu: capacity, sequential, throttle, pause</li>
+<li>Once this configuration is done, remove the <tt class="docutils literal">channels</tt> options and
+set <tt class="docutils literal">max_capacity</tt> (and optionally <tt class="docutils literal">db_max_capacity</tt>) instead (or
+their corresponding environment variables)</li>
+<li>Restart the job runner</li>
+</ol>
 <table class="docutils footnote" frame="void" id="footnote-1" rules="none">
 <colgroup><col class="label" /><col /></colgroup>
 <tbody valign="top">
diff --git a/queue_job/tests/test_runner_runner.py b/queue_job/tests/test_runner_runner.py
index 04c3fc1946..6dc923f7bb 100644
--- a/queue_job/tests/test_runner_runner.py
+++ b/queue_job/tests/test_runner_runner.py
@@ -2,12 +2,16 @@
 # License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html)
 import doctest
 import os
+from unittest import mock
 
 from odoo.tests import BaseCase, tagged
+from odoo.tools import mute_logger
+
+from odoo.addons.queue_job.jobrunner import runner
 
 # pylint: disable=odoo-addons-relative-import
 # we are testing, we want to test as we were an external consumer of the API
-from odoo.addons.queue_job.jobrunner import runner
+from odoo.addons.queue_job.jobrunner.channels import ChannelConfig, ChannelManager
 
 
 @tagged("doctest")
@@ -21,6 +25,46 @@ def test_doctest(self):
 
 @tagged("-at_install", "post_install")
 class TestRunner(BaseCase):
+    def setUp(self):
+        super().setUp()
+        # ensure there is no collision with actual environment variables/config
+        env_patcher = mock.patch.dict(
+            "os.environ",
+            {
+                "ODOO_QUEUE_JOB_MAX_CAPACITY": "",
+                "ODOO_QUEUE_JOB_DB_MAX_CAPACITY": "",
+                "ODOO_QUEUE_JOB_CHANNELS": "",
+            },
+        )
+        env_patcher.start()
+        self.addCleanup(env_patcher.stop)
+
+        conf_patcher = mock.patch.object(runner, "queue_job_config", {})
+        conf_patcher.start()
+        self.addCleanup(conf_patcher.stop)
+
+    @staticmethod
+    def _mock_db(db_name, channels_config):
+        """Mock a Database
+
+        :param channels_config: list of ChannelConfig as configured in the DB
+        """
+        return mock.MagicMock(
+            db_name=db_name,
+            load_channels_config=mock.MagicMock(return_value=channels_config),
+        )
+
+    def _new_channel_manager(self, jobrunner, db_name, channel_config, pending_jobs=0):
+        channel_manager = ChannelManager()
+        channel_manager.configure(channel_config)
+        jobrunner._register_channel_manager(db_name, channel_manager)
+        jobrunner.db_by_name[db_name] = mock.MagicMock(name=f"Database({db_name})")
+        for number in range(pending_jobs):
+            channel_manager.notify(
+                db_name, "root", f"{db_name}-{number}", number, 0, 10, None, "pending"
+            )
+        return channel_manager
+
     @classmethod
     def _is_open_file_descriptor(cls, fd):
         try:
@@ -62,3 +106,399 @@ def test_runner_file_closed_write_descriptor(self):
 
         self.assertFalse(self._is_open_file_descriptor(read_fd))
         self.assertFalse(self._is_open_file_descriptor(write_fd))
+
+    def test_max_capacity_from_env(self):
+        with (
+            mock.patch.dict(
+                os.environ, {"ODOO_QUEUE_JOB_MAX_CAPACITY": "5"}, clear=True
+            ),
+            mock.patch.object(runner, "queue_job_config", {}),
+        ):
+            self.assertEqual(runner._max_capacity(), 5)
+
+    def test_max_capacity_from_odoo_config(self):
+        with (
+            mock.patch.dict(os.environ, {}, clear=True),
+            mock.patch.object(runner, "queue_job_config", {"max_capacity": "3"}),
+        ):
+            self.assertEqual(runner._max_capacity(), 3)
+
+    def test_max_capacity_env_priority_over_odoo_config(self):
+        with (
+            mock.patch.dict(
+                os.environ, {"ODOO_QUEUE_JOB_MAX_CAPACITY": "5"}, clear=True
+            ),
+            mock.patch.object(runner, "queue_job_config", {"max_capacity": "3"}),
+        ):
+            self.assertEqual(runner._max_capacity(), 5)
+
+    def test_max_capacity_default(self):
+        with (
+            mock.patch.dict(os.environ, {}, clear=True),
+            mock.patch.object(runner, "queue_job_config", {}),
+        ):
+            self.assertEqual(runner._max_capacity(), 1)
+
+    def test_max_capacity_zero(self):
+        with (
+            mock.patch.dict(
+                os.environ, {"ODOO_QUEUE_JOB_MAX_CAPACITY": "0"}, clear=True
+            ),
+            mock.patch.object(runner, "queue_job_config", {}),
+        ):
+            self.assertEqual(runner._max_capacity(), 0)
+
+    def test_db_max_capacity_from_env(self):
+        with (
+            mock.patch.dict(
+                os.environ, {"ODOO_QUEUE_JOB_DB_MAX_CAPACITY": "prod_*:20,*:5"}
+            ),
+            mock.patch.object(runner, "queue_job_config", {}),
+        ):
+            self.assertEqual(runner._db_max_capacity(), "prod_*:20,*:5")
+
+    def test_db_max_capacity_from_odoo_config(self):
+        with (
+            mock.patch.dict(os.environ, {}, clear=True),
+            mock.patch.object(
+                runner, "queue_job_config", {"db_max_capacity": "prod_*:20,*:5"}
+            ),
+        ):
+            self.assertEqual(runner._db_max_capacity(), "prod_*:20,*:5")
+
+    def test_db_max_capacity_env_priority_over_odoo_config(self):
+        with (
+            mock.patch.dict(os.environ, {"ODOO_QUEUE_JOB_DB_MAX_CAPACITY": "*:5"}),
+            mock.patch.object(runner, "queue_job_config", {"db_max_capacity": "*:3"}),
+        ):
+            self.assertEqual(runner._db_max_capacity(), "*:5")
+
+    def test_db_max_capacity_default(self):
+        with (
+            mock.patch.dict(os.environ, {}, clear=True),
+            mock.patch.object(runner, "queue_job_config", {}),
+        ):
+            self.assertEqual(runner._db_max_capacity(), "")
+
+    def test_max_capacity_negative(self):
+        jobrunner = runner.QueueJobRunner(max_capacity=-5)
+        self.assertEqual(jobrunner.max_capacity, 0)
+
+    def test_max_capacity_equals_to_channel_config_string(self):
+        jobrunner = runner.QueueJobRunner(channel_config_string="root:3")
+        self.assertEqual(jobrunner.max_capacity, 3)
+
+    def test_max_capacity_server_side_has_priority(self):
+        jobrunner = runner.QueueJobRunner(
+            channel_config_string="root:3", max_capacity=1
+        )
+        self.assertEqual(jobrunner.max_capacity, 3)
+
+    def test_max_capacity_channel_config_no_root(self):
+        jobrunner = runner.QueueJobRunner(channel_config_string="sub:3")
+        self.assertEqual(jobrunner.max_capacity, 1)
+
+    def test_no_job_dispatched_when_no_database_channel_manager(self):
+        jobrunner = runner.QueueJobRunner(max_capacity=3)
+        with mock.patch.object(jobrunner, "_dispatch_job") as dispatch:
+            jobrunner.run_jobs()
+        dispatch.assert_not_called()
+
+    def test_global_capacity_across_databases(self):
+        jobrunner = runner.QueueJobRunner(max_capacity=3)
+        manager_a = self._new_channel_manager(
+            jobrunner, "db_a", [ChannelConfig("root", 5)], pending_jobs=4
+        )
+        manager_b = self._new_channel_manager(
+            jobrunner, "db_b", [ChannelConfig("root", 5)], pending_jobs=4
+        )
+        with mock.patch.object(jobrunner, "_dispatch_job") as dispatch:
+            jobrunner.run_jobs()
+        # number of running jobs must be limited by max_capacity
+        self.assertEqual(dispatch.call_count, 3)
+        self.assertEqual(manager_a.running_count + manager_b.running_count, 3)
+
+    def test_round_robin(self):
+        jobrunner = runner.QueueJobRunner(max_capacity=3)
+        self._new_channel_manager(
+            jobrunner, "db_a", [ChannelConfig("root", 3)], pending_jobs=2
+        )
+        self._new_channel_manager(
+            jobrunner, "db_b", [ChannelConfig("root", 3)], pending_jobs=2
+        )
+        dispatched = []
+        with mock.patch.object(
+            jobrunner, "_dispatch_job", side_effect=lambda job: dispatched.append(job)
+        ):
+            jobrunner.run_jobs()
+            # with max_capacity=3 and 2 pending jobs per db, the first
+            # run_jobs() will dispatch 3 jobs in alternating order
+            self.assertEqual(
+                [job.db_name for job in dispatched], ["db_a", "db_b", "db_a"]
+            )
+            # notify the first dispatched job as done so a slot is freed up
+            # so we can check that the next call to run_jobs() continues
+            # to round-robin
+            jobrunner._channel_manager_by_db[dispatched[0].db_name].notify(
+                dispatched[0].db_name,
+                "root",
+                dispatched[0].uuid,
+                dispatched[0].seq,
+                0,
+                10,
+                None,
+                "done",
+            )
+            jobrunner.run_jobs()
+        # round-robin continues on the next dispatch "ticks"
+        self.assertEqual(
+            [job.db_name for job in dispatched], ["db_a", "db_b", "db_a", "db_b"]
+        )
+
+    def test_round_robin_empty_channel_manager(self):
+        jobrunner = runner.QueueJobRunner(max_capacity=3)
+        self._new_channel_manager(
+            jobrunner, "db_a", [ChannelConfig("root", 3)], pending_jobs=1
+        )
+        self._new_channel_manager(
+            jobrunner, "db_b", [ChannelConfig("root", 3)], pending_jobs=3
+        )
+        dispatched = []
+        with mock.patch.object(
+            jobrunner, "_dispatch_job", side_effect=lambda job: dispatched.append(job)
+        ):
+            jobrunner.run_jobs()
+        # round-robin continues with the only channel manager still having pending jobs
+        self.assertEqual([job.db_name for job in dispatched], ["db_a", "db_b", "db_b"])
+
+    def test_build_channel_manager_root_db_max_capacity(self):
+        jobrunner = runner.QueueJobRunner(max_capacity=10)
+        db = self._mock_db("db_a", [])
+        channel_manager = jobrunner._build_channel_manager(db)
+        root = channel_manager.get_channel_by_name("root")
+        # the root channels inherits the global max capacity
+        self.assertEqual(root.capacity, 10)
+
+    def test_build_channel_manager_db_max_zero(self):
+        jobrunner = runner.QueueJobRunner(max_capacity=3, db_max_capacity="db_a:0,*:5")
+        db = self._mock_db("db_a", [ChannelConfig("root", 5)])
+        channel_manager = jobrunner._build_channel_manager(db)
+        root = channel_manager.get_channel_by_name("root")
+        # when db max capacity is at 0, the root channel of the channel manager
+        # is considered paused
+        self.assertTrue(root.paused)
+
+    def test_build_channel_manager_db_max_negative(self):
+        jobrunner = runner.QueueJobRunner(max_capacity=3, db_max_capacity="db_a:-1,*:5")
+        db = self._mock_db("db_a", [ChannelConfig("root", 5)])
+        channel_manager = jobrunner._build_channel_manager(db)
+        root = channel_manager.get_channel_by_name("root")
+        # negative value is handled as 0, which is paused
+        self.assertTrue(root.paused)
+
+    def test_build_channel_manager_root_capacity_db(self):
+        jobrunner = runner.QueueJobRunner(max_capacity=3, db_max_capacity="*:2")
+        db = self._mock_db("db_a", [ChannelConfig("root", 20)])
+        channel_manager = jobrunner._build_channel_manager(db)
+        root = channel_manager.get_channel_by_name("root")
+        # the root channel is set to the db max capacity
+        self.assertEqual(root.capacity, 2)
+
+    @mute_logger("odoo.addons.queue_job.jobrunner.runner")
+    def test_build_channel_manager_schema_error(self):
+        jobrunner = runner.QueueJobRunner(max_capacity=3)
+        # when the database schema has no columns, None is returned as channels config
+        db = self._mock_db("db_a", None)
+        channel_manager = jobrunner._build_channel_manager(db)
+        root = channel_manager.get_channel_by_name("root")
+        self.assertEqual(root.capacity, 0)
+
+    def test_build_channel_manager_handle_missing_root(self):
+        jobrunner = runner.QueueJobRunner(max_capacity=3)
+        # the configuration does not have root
+        db = self._mock_db("db_a", [ChannelConfig("sub", 2)])
+        channel_manager = jobrunner._build_channel_manager(db)
+        # does not raise, "root" is automatically added
+        root = channel_manager.get_channel_by_name("root", autocreate=False)
+        self.assertEqual(root.capacity, 3)
+
+    def test_server_side_channel_manager_register_unique(self):
+        jobrunner = runner.QueueJobRunner(channel_config_string="root:3")
+        global_manager = jobrunner._server_side_channel_manager
+        jobrunner._register_channel_manager("db_a", global_manager)
+        jobrunner._register_channel_manager("db_b", global_manager)
+        # channel manager is registered once
+        self.assertEqual(len(jobrunner._channel_managers), 1)
+
+    def test_max_capacity_zero_no_dispatch(self):
+        jobrunner = runner.QueueJobRunner(max_capacity=0)
+        self._new_channel_manager(
+            jobrunner, "db_a", [ChannelConfig("root", 10)], pending_jobs=4
+        )
+        self._new_channel_manager(
+            jobrunner, "db_b", [ChannelConfig("root", 10)], pending_jobs=4
+        )
+        with mock.patch.object(jobrunner, "_dispatch_job") as dispatch:
+            jobrunner.run_jobs()
+        dispatch.assert_not_called()
+
+    def test_max_capacity_unconfigured_defaults_to_one(self):
+        jobrunner = runner.QueueJobRunner()
+        self.assertEqual(jobrunner.max_capacity, 1)
+        self._new_channel_manager(
+            jobrunner, "db_a", [ChannelConfig("root", 10)], pending_jobs=4
+        )
+        self._new_channel_manager(
+            jobrunner, "db_b", [ChannelConfig("root", 10)], pending_jobs=4
+        )
+        with mock.patch.object(jobrunner, "_dispatch_job") as dispatch:
+            jobrunner.run_jobs()
+        self.assertEqual(dispatch.call_count, 1)
+
+    def test_notify_reload(self):
+        jobrunner = runner.QueueJobRunner(max_capacity=3)
+        db = self._mock_db("db_a", [])
+        db.conn.notifies = [mock.Mock(payload=runner.RELOAD_PAYLOAD)]
+        jobrunner.db_by_name = {"db_a": db}
+        with mock.patch.object(jobrunner, "_reconfigure_db") as reconfigure:
+            jobrunner.process_notifications()
+        reconfigure.assert_called_once_with("db_a")
+
+    def test_notify_reload_ignored_with_server_side_channels(self):
+        jobrunner = runner.QueueJobRunner(channel_config_string="root:3")
+        db = self._mock_db("db_a", [])
+        db.conn.notifies = [mock.Mock(payload=runner.RELOAD_PAYLOAD)]
+        jobrunner.db_by_name = {"db_a": db}
+        jobrunner._channel_manager_by_db = {"db_a": mock.MagicMock()}
+        with mock.patch.object(jobrunner, "_reconfigure_db") as reconfigure:
+            jobrunner.process_notifications()
+        reconfigure.assert_not_called()
+
+    def test_notify_job_started(self):
+        jobrunner = runner.QueueJobRunner(max_capacity=3)
+        channel_manager = ChannelManager()
+        channel_manager.configure([ChannelConfig("root", 3)])
+        jobrunner._register_channel_manager("db_a", channel_manager)
+
+        db = self._mock_db("db_a", None)
+        db.conn.notifies = [mock.Mock(payload="job-1")]
+        # channel, uuid, seq, date_created, priority, eta, state
+        job_row = ("root", "job-1", 0, 0, 10, None, "started")
+        db.select_jobs.return_value.__enter__.return_value.fetchone.return_value = (
+            job_row
+        )
+        jobrunner.db_by_name = {"db_a": db}
+
+        jobrunner.process_notifications()
+
+        db.select_jobs.assert_called_once_with("uuid = %s", ("job-1",))
+        # the channel manager now counts the job as a running job
+        self.assertEqual(channel_manager.running_count, 1)
+
+    def test_reconfigure_db_unknown_noop(self):
+        jobrunner = runner.QueueJobRunner(max_capacity=3)
+        jobrunner._reconfigure_db("unknown_db")
+        self.assertEqual(jobrunner._channel_manager_by_db, {})
+
+    @mute_logger("odoo.addons.queue_job.jobrunner.runner")
+    def test_reconfigure_db_error_skip(self):
+        jobrunner = runner.QueueJobRunner(max_capacity=3)
+        db = self._mock_db("db_a", [ChannelConfig("root", 3)])
+        jobrunner.db_by_name = {"db_a": db}
+        with mock.patch.object(
+            jobrunner,
+            "_build_channel_manager",
+            side_effect=ValueError("channel configuration error"),
+        ):
+            jobrunner._reconfigure_db("db_a")
+        # nothing has been raised, the failing db has not been registered
+        self.assertEqual(jobrunner._channel_manager_by_db, {})
+
+    def test_reconfigure_db_select_jobs(self):
+        jobrunner = runner.QueueJobRunner(max_capacity=3)
+        db = self._mock_db("db_a", [ChannelConfig("root", 3)])
+        # channel, uuid, seq, date_created, priority, eta, state
+        job_row = ("root", "db_a-job1", 0, 0, 10, None, "pending")
+        db.select_jobs.return_value.__enter__.return_value = [job_row]
+
+        jobrunner.db_by_name = {"db_a": db}
+
+        jobrunner._reconfigure_db("db_a")
+
+        db.select_jobs.assert_called_once_with("state in %s", (runner.NOT_DONE,))
+        channel_manager = jobrunner._channel_manager_by_db["db_a"]
+        pending_jobs = list(channel_manager.get_jobs_to_run(0))
+        self.assertEqual([job.uuid for job in pending_jobs], ["db_a-job1"])
+
+    def test_reconfigure_db_server_side_channels_unique_channel_manager(self):
+        jobrunner = runner.QueueJobRunner(channel_config_string="root:3")
+        db_a = self._mock_db("db_a", [])
+        db_b = self._mock_db("db_b", [])
+        jobrunner.db_by_name = {"db_a": db_a, "db_b": db_b}
+
+        jobrunner._reconfigure_db("db_a")
+        jobrunner._reconfigure_db("db_b")
+
+        self.assertIs(
+            jobrunner._channel_manager_by_db["db_a"],
+            jobrunner._channel_manager_by_db["db_b"],
+        )
+        self.assertIs(
+            jobrunner._channel_manager_by_db["db_a"],
+            jobrunner._server_side_channel_manager,
+        )
+
+    def test_close_databases_reset_state(self):
+        jobrunner = runner.QueueJobRunner(max_capacity=3)
+        channel_manager = self._new_channel_manager(
+            jobrunner, "db_a", [ChannelConfig("root", 3)], pending_jobs=1
+        )
+        db = jobrunner.db_by_name["db_a"]
+
+        jobrunner.close_databases()
+
+        self.assertEqual(list(channel_manager.get_jobs_to_run(0)), [])
+        db.close.assert_called_once()
+        self.assertEqual(jobrunner.db_by_name, {})
+        self.assertEqual(jobrunner._channel_manager_by_db, {})
+        self.assertEqual(jobrunner._channel_managers, [])
+
+    def test_close_databases_remove_jobs_false(self):
+        jobrunner = runner.QueueJobRunner(max_capacity=3)
+        channel_manager = self._new_channel_manager(
+            jobrunner, "db_a", [ChannelConfig("root", 3)], pending_jobs=1
+        )
+
+        jobrunner.close_databases(remove_jobs=False)
+
+        # job is kept when remove_jobs=False
+        self.assertEqual(len(list(channel_manager.get_jobs_to_run(0))), 1)
+
+    def test_next_wakeup_time_no_channel_managers(self):
+        jobrunner = runner.QueueJobRunner(max_capacity=3)
+        self.assertEqual(jobrunner.next_wakeup_time(), 0)
+
+    def test_next_wakeup_time_one_db_with_eta(self):
+        jobrunner = runner.QueueJobRunner(max_capacity=3)
+        channel_manager = self._new_channel_manager(
+            jobrunner, "db_a", [ChannelConfig("root", 3)]
+        )
+        channel_manager.notify("db_a", "root", "db_a-0", 0, 0, 10, 500, "pending")
+        self.assertEqual(jobrunner.next_wakeup_time(), 500)
+
+    def test_next_wakeup_time_several_db(self):
+        jobrunner = runner.QueueJobRunner(max_capacity=3)
+        channel_manager_a = self._new_channel_manager(
+            jobrunner, "db_a", [ChannelConfig("root", 3)]
+        )
+        channel_manager_b = self._new_channel_manager(
+            jobrunner, "db_b", [ChannelConfig("root", 3)]
+        )
+        channel_manager_c = self._new_channel_manager(
+            jobrunner, "db_c", [ChannelConfig("root", 3)]
+        )
+        # channel, uuid, seq, date_created, priority, eta, state
+        channel_manager_a.notify("db_a", "root", "db_a-0", 0, 0, 10, 500, "pending")
+        channel_manager_b.notify("db_b", "root", "db_b-0", 0, 0, 10, 200, "pending")
+        channel_manager_c.notify("db_c", "root", "db_b-0", 0, 0, 10, 0, "pending")
+        self.assertEqual(jobrunner.next_wakeup_time(), 200)