python-rac 0.2.0__py3-none-any.whl

pyrac/web/app.py

@@ -0,0 +1,2835 @@
+"""Tiny read-only WSGI dashboard; bind to loopback unless protected by a proxy."""
+import html
+import asyncio
+import hmac
+import re
+from urllib.parse import parse_qs, quote, unquote, urlsplit
+from uuid import UUID
+from ..client import RacClient, RacError
+from ..read_service import CLUSTER_LISTS, PROFILE_ACL_LISTS, SERVER_LISTS, ReadService
+
+
+class InvalidAclQuery(ValueError):
+    """An invalid client-supplied ACL filter, not a RAS failure."""
+
+
+def render_section(title, rows, path, *, allow_cluster_remove=False, allow_admin_remove=False):
+    rows = [ReadService.public_data(row) for row in rows]
+    searchable = title.lower() in ('clusters', 'infobases', 'sessions', 'infobase sessions',
+                                   'servers', 'working servers', 'processes', 'working processes',
+                                   'server processes',
+                                   'connections', 'process connections', 'infobase connections',
+                                   'managers', 'limits', 'counters', 'profiles', 'rules',
+                                   'service settings', 'agent administrators',
+                                   'cluster administrators', 'locks', 'infobase locks',
+                                   'connection locks', 'services', 'transfer directories',
+                                   'binary data storages', 'counter values',
+                                   'counter accumulated-values') or title.lower() in tuple(
+                                       kind + ' acl' for kind in PROFILE_ACL_LISTS)
+    if searchable:
+        infobase_cluster = (re.fullmatch(r'/clusters/([0-9a-fA-F-]{36})(?:/infobases)?', path)
+                            if title.lower() == 'infobases' else None)
+        scoped_kind = ('servers' if title.lower().endswith('servers') else 'processes')
+        scoped_cluster = (re.fullmatch(r'/clusters/([0-9a-fA-F-]{36})(?:/(servers|processes))?', path)
+                          if title.lower() in ('servers', 'working servers',
+                                               'processes', 'working processes') else None)
+        server_processes = (re.fullmatch(
+            r'/clusters/([0-9a-fA-F-]{36})/servers/([0-9a-fA-F-]{36})/processes', path)
+            if title.lower() == 'server processes' else None)
+        scoped_connections = (re.fullmatch(
+            r'/clusters/([0-9a-fA-F-]{36})/(processes|infobases)/([0-9a-fA-F-]{36})/connections', path)
+            if title.lower() in ('process connections', 'infobase connections') else None)
+        cluster_inventory = (re.fullmatch(r'/clusters/([0-9a-fA-F-]{36})/(connections|managers|limits|counters)', path)
+                             if title.lower() in ('connections', 'managers', 'limits', 'counters') else None)
+        server_inventory = (re.fullmatch(
+            r'/clusters/([0-9a-fA-F-]{36})/servers/([0-9a-fA-F-]{36})/(rules|service-settings)', path)
+            if title.lower() in ('rules', 'service settings') else None)
+        profile_cluster = (re.fullmatch(r'/clusters/([0-9a-fA-F-]{36})/profiles', path)
+                           if title.lower() == 'profiles' else None)
+        admin_list = (path == '/agent/admins' and title.lower() == 'agent administrators'
+                      or re.fullmatch(r'/clusters/[0-9a-fA-F-]{36}/admins', path)
+                      and title.lower() == 'cluster administrators')
+        session_cluster = (re.fullmatch(
+            r'/clusters/([0-9a-fA-F-]{36})(?:/infobases/[0-9a-fA-F-]{36})?/sessions', path)
+            if title.lower() in ('sessions', 'infobase sessions') else None)
+        columns = list(dict.fromkeys(key for row in rows for key in row))
+        hidden_key = None
+        if path == '/clusters':
+            hidden_key = 'cluster'
+        elif infobase_cluster:
+            hidden_key = 'infobase'
+        elif scoped_cluster:
+            hidden_key = 'server' if scoped_kind == 'servers' else 'process'
+        elif server_processes:
+            hidden_key = 'process'
+        elif scoped_connections:
+            hidden_key = 'connection'
+        elif cluster_inventory:
+            hidden_key = {'connections': 'connection', 'managers': 'manager'}.get(
+                cluster_inventory.group(2))
+        elif server_inventory:
+            hidden_key = {'rules': 'rule', 'service-settings': 'setting'}.get(
+                server_inventory.group(3))
+        elif session_cluster:
+            hidden_key = 'session_id'
+        if hidden_key is not None:
+            columns = [key for key in columns if key != hidden_key]
+        if hidden_key in ('rule', 'setting') and 'name' not in columns:
+            columns.insert(0, 'name')
+        if not columns:
+            columns = ['name']
+        heading = ''.join('<th scope="col">' + html.escape(str(key)) + '</th>' for key in columns)
+        if (path == '/clusters' or infobase_cluster or scoped_cluster or server_processes
+                or scoped_connections
+                or cluster_inventory or server_inventory or profile_cluster or admin_list):
+            heading += '<th scope="col">Actions</th>'
+        records = []
+        for row in rows:
+            cells = ''
+            for key in columns:
+                raw = row.get(key, '')
+                if hidden_key in ('rule', 'setting') and key == 'name':
+                    if (not isinstance(raw, str) or not ReadService._valid_search_text(raw)
+                            or not raw.strip()):
+                        actual_key = 'object-type' if hidden_key == 'rule' else 'service-name'
+                        actual = row.get(actual_key)
+                        raw = (actual if isinstance(actual, str) and
+                               ReadService._valid_search_text(actual) and actual.strip() else
+                               'Assignment rule' if hidden_key == 'rule' else 'Service setting')
+                if key == 'name' and hidden_key in ('cluster', 'infobase', 'server'):
+                    if (not isinstance(raw, str) or not ReadService._valid_search_text(raw)
+                            or not raw.strip()):
+                        host_key = 'host' if hidden_key == 'cluster' else 'host_name'
+                        host = row.get(host_key)
+                        if (hidden_key != 'infobase' and isinstance(host, str)
+                                and ReadService._valid_search_text(host) and host.strip()):
+                            raw = host
+                        else:
+                            raw = {'cluster': 'Unnamed cluster', 'infobase': 'Unnamed infobase',
+                                   'server': 'Unnamed server'}[hidden_key]
+                if (session_cluster and key == 'user_name' and
+                        (not isinstance(raw, str) or not ReadService._valid_search_text(raw)
+                         or not raw.strip())):
+                    raw = ''
+                if hidden_key == 'process' and key == 'pid':
+                    text = str(raw)
+                    if (isinstance(raw, bool) or not isinstance(raw, (str, int))
+                            or not text.isdecimal() or not ReadService._valid_search_text(text)):
+                        raw = 'Working process'
+                if (hidden_key in ('connection', 'manager') and key == 'host' and
+                        (not isinstance(raw, str) or not ReadService._valid_search_text(raw)
+                         or not raw.strip())):
+                    if hidden_key == 'manager':
+                        raw = 'Cluster manager'
+                    else:
+                        number = row.get('conn-id')
+                        raw = (f'Connection {number}' if type(number) is int and number >= 0
+                               else 'Connection')
+                value = html.escape(str(raw))
+                cells += '<td>' + value + '</td>'
+            if session_cluster:
+                try:
+                    session_id = str(UUID(str(row['session_id'])))
+                except (KeyError, ValueError, TypeError):
+                    session_id = None
+                if session_id:
+                    user = row.get('user_name')
+                    if (isinstance(user, str) and ReadService._valid_search_text(user)
+                            and user.strip()):
+                        label = user
+                    else:
+                        number = row.get('id')
+                        label = f'Session {number}' if type(number) is int and number >= 0 else 'Session'
+                    cells += (f'<td><a href="/clusters/{session_cluster.group(1)}/sessions/'
+                              f'{session_id}">{html.escape(label)}</a></td>')
+                else:
+                    cells += '<td></td>'
+            elif path == '/clusters':
+                try:
+                    cluster_id = str(UUID(str(row['cluster'])))
+                except (KeyError, ValueError, TypeError):
+                    cluster_id = None
+                actions = (f'<a href="/clusters/{quote(cluster_id)}">Open cluster</a>'
+                           if cluster_id else '')
+                if cluster_id and allow_cluster_remove:
+                    actions += (f' <a href="/clusters/{quote(cluster_id)}/remove">'
+                                'Remove cluster</a>')
+                cells += '<td>' + actions + '</td>'
+            elif infobase_cluster:
+                try:
+                    infobase_id = str(UUID(str(row['infobase'])))
+                except (KeyError, ValueError, TypeError):
+                    infobase_id = None
+                actions = ''
+                if infobase_id:
+                    base = f'/clusters/{infobase_cluster.group(1)}/infobases/{infobase_id}'
+                    for kind in ('summary', 'info', 'binary-storages',
+                                 'sessions', 'connections', 'locks'):
+                        actions += (f'<a href="{base}/{kind}">{kind.replace("-", " ")}</a> ')
+                cells += '<td>' + actions + '</td>'
+            elif scoped_cluster:
+                key = 'server' if scoped_kind == 'servers' else 'process'
+                try:
+                    object_id = str(UUID(str(row[key])))
+                except (KeyError, ValueError, TypeError):
+                    object_id = None
+                actions = ''
+                if object_id:
+                    base = f'/clusters/{scoped_cluster.group(1)}/{scoped_kind}/{object_id}'
+                    if scoped_kind == 'servers' and scoped_cluster.group(2):
+                        kinds = (('', 'info'), *((f'/{kind}', kind) for kind in SERVER_LISTS))
+                    elif scoped_kind == 'processes' and scoped_cluster.group(2):
+                        kinds = (('', 'info'), ('/connections', 'connections'))
+                    else:
+                        kinds = (('', 'info'),)
+                    actions = ' '.join(f'<a href="{base}{suffix}">{label}</a>'
+                                       for suffix, label in kinds)
+                cells += '<td>' + actions + '</td>'
+            elif server_processes:
+                try:
+                    process_id = str(UUID(str(row['process'])))
+                except (KeyError, ValueError, TypeError):
+                    process_id = None
+                actions = ''
+                if process_id:
+                    base = f'/clusters/{server_processes.group(1)}/processes/{process_id}'
+                    actions = f'<a href="{base}">info</a> <a href="{base}/connections">connections</a>'
+                cells += '<td>' + actions + '</td>'
+            elif scoped_connections:
+                try:
+                    connection_id = str(UUID(str(row['connection'])))
+                except (KeyError, ValueError, TypeError):
+                    connection_id = None
+                actions = ''
+                if connection_id:
+                    base = f'/clusters/{scoped_connections.group(1)}/connections/{connection_id}'
+                    actions = f'<a href="{base}">info</a> <a href="{base}/locks">locks</a>'
+                cells += '<td>' + actions + '</td>'
+            elif cluster_inventory or server_inventory:
+                match = cluster_inventory or server_inventory
+                assert match is not None
+                group = match.group(2) if cluster_inventory else match.group(3)
+                key = {'connections': 'connection', 'managers': 'manager', 'limits': 'name',
+                       'counters': 'name', 'rules': 'rule', 'service-settings': 'setting'}[group]
+                value = row.get(key)
+                actions = ''
+                if isinstance(value, str):
+                    if key != 'name':
+                        try:
+                            value = str(UUID(value))
+                        except ValueError:
+                            value = None
+                    elif not value or len(value.encode('utf-8')) > 1024:
+                        value = None
+                    if value is not None:
+                        base = f'/clusters/{match.group(1)}'
+                        if server_inventory:
+                            base += f'/servers/{match.group(2)}'
+                        base += f'/{group}/{quote(value, safe="")}'
+                        actions = f'<a href="{base}">info</a>'
+                        if group == 'connections':
+                            actions += f' <a href="{base}/locks">locks</a>'
+                cells += '<td>' + actions + '</td>'
+            elif profile_cluster:
+                name = row.get('name')
+                actions = ''
+                if (isinstance(name, str) and name and '\x00' not in name
+                        and len(name.encode('utf-8')) <= 1024):
+                    encoded = quote(name, safe='')
+                    base = f'/clusters/{profile_cluster.group(1)}/profiles'
+                    actions = (f'<a href="{base}/overview?name={encoded}">'
+                               f'{html.escape(name)}: overview</a> '
+                               f'<a href="{base}/by-name?name={encoded}">'
+                               f'{html.escape(name)}: info</a> ' +
+                               ' '.join(f'<a href="{base}/{encoded}/acl/{kind}">{kind}</a>'
+                                        for kind in PROFILE_ACL_LISTS))
+                cells += '<td>' + actions + '</td>'
+            elif admin_list:
+                name = row.get('name')
+                actions = ''
+                if (allow_admin_remove and isinstance(name, str) and name and
+                        '/' not in name and '\\' not in name and '\x00' not in name and
+                        len(name.encode('utf-8')) <= 1024):
+                    actions = f'<a href="{path}/{quote(name, safe="")}/remove">Remove {html.escape(name)}</a>'
+                cells += '<td>' + actions + '</td>'
+            search_key = ''
+            if hidden_key is not None:
+                try:
+                    search_key = str(UUID(str(row[hidden_key])))
+                except (KeyError, TypeError, ValueError):
+                    pass
+            if search_key:
+                cells = cells.replace('<td>', f'<td data-search-key="{search_key}">', 1)
+            records.append('<tr data-searchable-row>' + cells + '</tr>')
+        search = ('<label>Search ' + html.escape(title.lower()) +
+                  ' <input type="search" aria-label="Search ' + html.escape(title.lower()) +
+                  '" oninput="this.closest(\'section\').querySelectorAll(\'[data-searchable-row]\')'
+                  '.forEach(row=>row.hidden=!(row.textContent+" "+'
+                  '(row.querySelector("[data-search-key]")?.dataset.searchKey||""))'
+                  '.toLocaleLowerCase().includes('
+                  'this.value.toLocaleLowerCase()))" placeholder="Name or UUID"></label>')
+        return ('<section><h1>' + html.escape(title) + '</h1>' + search +
+                '<div class="table-scroll"><table><thead><tr>' + heading +
+                '</tr></thead><tbody>' + ''.join(records) + '</tbody></table></div></section>')
+    links = []
+    for row in rows:
+        entries = ''.join(f'<dt>{html.escape(str(k))}</dt><dd>{html.escape(str(v))}</dd>'
+                          for k, v in row.items())
+        cluster_id = row.get('cluster') if path == '/clusters' else None
+        try:
+            cluster_uuid = str(UUID(str(cluster_id))) if cluster_id else None
+        except ValueError:
+            cluster_uuid = None
+        link = (f'<a href="/clusters/{quote(cluster_uuid)}">Open cluster</a>'
+                if cluster_uuid else '')
+        if cluster_uuid and allow_cluster_remove:
+            link += (f' <a href="/clusters/{quote(cluster_uuid)}/remove">'
+                     'Remove cluster</a>')
+        links.append(f'<li>{link}<dl>{entries}</dl></li>')
+    return ('<section><h1>' + html.escape(title) + '</h1><ul>' +
+            ''.join(links) + '</ul></section>')
+
+
+def render_page(title, rows, path, *, allow_cluster_remove=False):
+    return render_document(title, render_section(title, rows, path,
+                                                allow_cluster_remove=allow_cluster_remove))
+
+
+def render_document(title, content, *, workspace_tree=None, inspector=None):
+    return ('<!doctype html><html lang="ru"><head><meta charset="utf-8">'
+            '<meta name="viewport" content="width=device-width, initial-scale=1">'
+            '<title>' + html.escape(title) + ' · Python RAC</title>'
+            '<style>'
+            ':root{font:15px system-ui,sans-serif;color:#dce5f4;background:#101827}'
+            '.ui-icon{display:inline-grid;place-items:center;width:1.4em;height:1.4em;'
+            'border-radius:6px;background:#6678ee20;color:#7887ed;font-weight:700;margin-right:5px}'
+            '*{box-sizing:border-box}body{margin:0;min-height:100vh;display:grid;grid-template-columns:220px 1fr}'
+            'body>nav{background:#172235;padding:28px 18px;display:flex;flex-direction:column;gap:12px;'
+            'border-right:1px solid #334358}body>nav:before{content:"◆  Python RAC";font-weight:700;'
+            'color:#8cd9d0;margin-bottom:24px}a{color:#78d9cc;text-decoration:none}a:hover{text-decoration:underline}'
+            'main{padding:32px clamp(18px,4vw,60px);min-width:0;max-width:1400px}'
+            'h1{font-size:1.7rem;letter-spacing:-.025em}h2{font-size:1.1rem}'
+            'section{background:#1b293c;border:1px solid #324258;border-radius:16px;padding:22px;'
+            'margin:0 0 22px;box-shadow:0 12px 32px #090e1933}'
+            'section>ul{list-style:none;padding:0;display:grid;gap:10px}'
+            'section>ul>li{background:#132031;padding:15px;border-radius:10px;overflow-wrap:anywhere}'
+            '.table-scroll{overflow:auto;max-height:min(72vh,760px);margin-top:16px;border:1px solid #324258;'
+            'border-radius:10px}table{border-collapse:collapse;width:100%;min-width:520px;font-size:14px}'
+            'th,td{text-align:left;padding:10px 13px;border-bottom:1px solid #324258;white-space:nowrap}'
+            'th{position:sticky;top:0;background:#23354a;color:#bed0e5;z-index:1}'
+            'tbody tr:nth-child(even){background:#18283a}tbody tr:hover{background:#285064}'
+            '[hidden]{display:none!important}'
+            'dl{display:grid;grid-template-columns:minmax(130px,210px) 1fr;gap:6px 16px;margin:12px 0 0}'
+            'dt{color:#99aeca}dd{margin:0;overflow-wrap:anywhere}'
+            'input,select,button{background:#142338;color:#f0f7ff;border:1px solid #52657f;'
+            'border-radius:8px;padding:10px;font:inherit;max-width:100%}'
+            'button{background:#177f77;border-color:#21a799;cursor:pointer;font-weight:650}'
+            'button:hover{background:#1a988d}form{display:flex;flex-wrap:wrap;align-items:end;gap:12px}'
+            'label{display:grid;gap:5px}nav a{display:inline-block;margin:3px 9px 3px 0}'
+            '@media(max-width:750px){body{display:block}body>nav{border:0;border-bottom:1px solid #334358;'
+            'padding:14px;flex-direction:row;flex-wrap:wrap}body>nav:before{margin:0 10px 0 0}main{padding:18px}}'
+            + ('''body.workspace-console{display:grid;grid-template-columns:240px minmax(0,1fr) 290px;
+                grid-template-rows:48px minmax(0,1fr);height:100vh;min-height:0;color:#243449;
+                background:#e9edf2;font:13px "Segoe UI",Arial,sans-serif}
+                .workspace-console .console-top{grid-column:1/-1;background:#21364d;color:#f2f6fa;
+                display:flex;align-items:center;justify-content:space-between;padding:0 18px;
+                border-bottom:2px solid #4d9ca6;font-size:14px;font-weight:600}
+                .workspace-console .console-top a{color:#e0f4f3}
+                .workspace-console .console-tree{background:#f5f7fa;border-right:1px solid #cdd6e0;
+                overflow:auto;padding:18px 12px}
+                .console-tree h2,.console-inspector h2{font-size:12px;text-transform:uppercase;
+                letter-spacing:.07em;color:#63758b;margin:0 0 14px}
+                .console-tree a{color:#2a455e;display:block;padding:6px 9px;border-radius:4px}
+                .console-tree a:hover,.console-tree a:focus-visible{background:#dcecf0;text-decoration:none}
+                .console-tree ul{list-style:none;padding:0 0 0 11px;margin:0}
+                .console-tree .tree-node{font-weight:650;overflow-wrap:anywhere}
+                .workspace-console .console-main{max-width:none;min-width:0;padding:0;overflow:auto}
+                .console-main section{margin:0;background:#fff;border:0;border-radius:0;
+                box-shadow:none;min-height:100%;padding:20px 24px}
+                .console-main h1{font-size:20px;margin:0 0 12px}
+                .console-main form{background:#f3f6fa;border:1px solid #d8e0e8;padding:9px;
+                border-radius:5px;margin-bottom:14px}
+                .console-main input,.console-main select,.console-main button{background:#fff;color:#26394d;
+                border-color:#b7c4d1;border-radius:4px;padding:6px 9px}
+                .console-main button{background:#276d79;color:#fff;border-color:#276d79}
+                .console-main a{color:#1b6676}
+                .console-main .table-scroll{border-color:#cbd6e0;border-radius:4px;margin-top:10px;
+                max-height:none}
+                .console-main th,.console-main td{padding:7px 10px;border-bottom:1px solid #e0e6ed}
+                .console-main th{background:#e7edf3;color:#38516b}
+                .console-main tbody tr:nth-child(even){background:#f7f9fb}
+                .console-main tbody tr:hover{background:#e5f2f4}
+                .console-main .selectable-row{cursor:pointer}
+                .console-main .selectable-row:focus-visible{outline:2px solid #276d79;outline-offset:-2px}
+                .console-main .selectable-row.is-selected{background:#d3edf0}
+                .console-inspector{background:#f7f9fb;border-left:1px solid #cdd6e0;
+                overflow:auto;padding:18px 16px}
+                .console-inspector dl{grid-template-columns:80px 1fr;gap:8px}
+                .console-inspector dt{color:#63758b}
+                .console-inspector dd{overflow-wrap:anywhere}
+                @media(max-width:1000px){body.workspace-console{grid-template-columns:200px minmax(0,1fr)}
+                .console-inspector{display:none}}
+                @media(max-width:660px){body.workspace-console{display:block;height:auto}
+                .workspace-console .console-tree{max-height:200px}.workspace-console .console-main{overflow:visible}}
+                ''' if workspace_tree is not None else '') +
+            '''body.workspace-console{background:#10141f;color:#e7ebf7;font:14px system-ui,sans-serif;
+                grid-template-columns:248px minmax(0,1fr) 270px;grid-template-rows:60px minmax(0,1fr)}
+                .workspace-console .console-top{background:#171d2d;border-bottom:1px solid #30394f;
+                padding:0 24px;letter-spacing:.01em;box-shadow:0 4px 18px #080b1266}
+                .console-top .ui-icon{background:#6d79eb;color:white;width:30px;height:30px;
+                font-size:20px;margin-right:10px;vertical-align:middle}
+                .workspace-console .console-top a{color:#c9d2ff;background:#ffffff0b;
+                border:1px solid #ffffff1a;border-radius:9px;padding:7px 13px}
+                .workspace-console .console-top a:hover{background:#ffffff19;text-decoration:none}
+                .workspace-console .console-tree{background:#171d2b;border-color:#30394f;padding:22px 13px}
+                .console-tree h2,.console-inspector h2{color:#8d9abb;font-size:11px}
+                .console-tree a{color:#b6c1da;border-radius:8px;padding:8px 10px}
+                .console-tree a:hover,.console-tree a:focus-visible{background:#303958;color:#fff}
+                .console-tree .tree-node{color:#eef0ff;font-weight:650}
+                .workspace-console .console-main{background:#10141f}
+                .console-main section{background:#10141f;color:#e7ebf7;padding:30px 34px}
+                .console-main h1{font-size:26px;letter-spacing:-.035em;margin:0 0 16px}
+                .console-main h2{color:#e7ebf7}
+                .console-main p{color:#acb7d1;line-height:1.85}
+                .console-main form{background:#1a2132;border:1px solid #34405a;
+                border-radius:12px;padding:16px;margin:18px 0;gap:16px}
+                .console-main td form{margin:0;padding:0;background:transparent;border:0}
+                .console-main input,.console-main select{background:#121827;color:#edf1ff;
+                border:1px solid #42506b;border-radius:8px;padding:9px 12px}
+                .console-main input:focus-visible,.console-main select:focus-visible,
+                .console-main button:focus-visible,.console-tree a:focus-visible{
+                outline:2px solid #98a4ff;outline-offset:2px}
+                .console-main button{background:#6674db;color:#fff;border:1px solid #7d89e8;
+                border-radius:8px;padding:9px 16px;cursor:pointer}
+                .console-main button:hover{background:#7c88ee}
+                .console-main button.danger-button{background:#352331;border-color:#69405c;color:#ffc3d6}
+                .console-main a{color:#aab8ff}
+                .console-main .table-scroll{border:1px solid #34405a;border-radius:12px;
+                background:#1a2132;margin-top:20px;overflow:auto}
+                .console-main th,.console-main td{padding:13px 17px;border-bottom:1px solid #30394f}
+                .console-main th{background:#242d42;color:#bfcafa}
+                .console-main tbody tr:nth-child(even){background:#1d2639}
+                .console-main tbody tr:hover{background:#303c59}
+                .console-main .selectable-row:focus-visible{outline:2px solid #98a4ff}
+                .console-main .selectable-row.is-selected{background:#35436b}
+                .console-inspector{background:#171d2b;color:#d8e0f1;border-color:#30394f;
+                padding:24px 18px}.console-inspector dt{color:#8d9abb}
+                @media(max-width:1000px){body.workspace-console{grid-template-columns:200px minmax(0,1fr)}}
+                @media(max-width:660px){body.workspace-console{display:block;height:auto}
+                .workspace-console .console-tree{max-height:200px}.workspace-console .console-main{overflow:visible}
+                .console-main section{padding:22px 17px}}
+                ''' +
+            '</style>' + ('<script src="/ras/inspector.js" defer></script>'
+                         if workspace_tree is not None else '') +
+            '</head><body' + (' class="workspace-console"' if workspace_tree is not None else '') + '>' +
+            (('<header class="console-top"><span><span class="ui-icon" aria-hidden="true">◈</span> Python RAC · Консоль кластеров</span>'
+              '<a href="/ras/search"><span class="ui-icon" aria-hidden="true">⌕</span> Поиск по серверам</a></header>'
+              '<nav class="console-tree" aria-label="Навигация по RAS">' + workspace_tree + '</nav>'
+              '<main class="console-main">' + content + '</main>'
+              '<aside class="console-inspector" aria-label="Свойства объекта">' +
+              (inspector or '<h2>Свойства</h2><p>Выберите объект, чтобы просмотреть свойства.</p>') + '</aside>')
+             if workspace_tree is not None else
+             ('<nav><a href="/ras"><span class="ui-icon" aria-hidden="true">▣</span> Серверы RAS</a> '
+              '<a href="/clusters"><span class="ui-icon" aria-hidden="true">◈</span> Кластеры</a> '
+              '<a href="/agent/version">Версия агента</a> '
+              '<a href="/agent/admins">Администраторы агента</a></nav><main>'
+              + content + '</main>')) + '</body></html>')
+
+
+def create_app(client_factory, *, allow_process_turn_off=False,
+               allow_cluster_remove=False, allow_cluster_insert=False,
+               allow_agent_admin_register=False, allow_cluster_admin_register=False,
+               allow_agent_admin_remove=False, allow_cluster_admin_remove=False,
+               allow_rule_apply=False, allow_service_settings_apply=False,
+               allow_service_setting_remove=False, allow_service_setting_update=False,
+               allow_service_setting_insert=False,
+               allow_cluster_name_update=False, allow_cluster_expiration_timeout_update=False,
+               allow_cluster_security_level_update=False,
+               allow_cluster_session_fault_tolerance_level_update=False,
+               allow_cluster_load_balancing_mode_update=False,
+               allow_cluster_kill_problem_processes_update=False,
+               allow_cluster_kill_by_memory_with_dump_update=False,
+               allow_cluster_audit_update=False,
+               allow_cluster_ping_update=False,
+               allow_cluster_restart_schedule_update=False,
+               allow_server_restart_schedule_update=False,
+               allow_server_infobases_limit_update=False,
+               allow_server_connections_limit_update=False,
+               allow_server_safe_call_memory_limit_update=False,
+               allow_server_critical_total_memory_update=False,
+               allow_server_temporary_total_memory_update=False,
+               allow_server_temporary_memory_time_limit_update=False,
+               allow_server_spn_update=False,
+               allow_server_dedicate_managers_update=False,
+               allow_server_port_ranges_update=False, csrf_token=None, read_timeout=None):
+    if (allow_process_turn_off or allow_cluster_remove or allow_cluster_insert or
+            allow_agent_admin_register or allow_cluster_admin_register or
+            allow_agent_admin_remove or allow_cluster_admin_remove or allow_rule_apply or
+            allow_service_settings_apply or allow_service_setting_remove or
+            allow_service_setting_update or allow_service_setting_insert or
+            allow_cluster_name_update or
+            allow_cluster_expiration_timeout_update or allow_cluster_security_level_update or
+            allow_cluster_session_fault_tolerance_level_update or
+            allow_cluster_load_balancing_mode_update or
+            allow_cluster_kill_problem_processes_update or
+            allow_cluster_kill_by_memory_with_dump_update or
+            allow_cluster_audit_update or
+            allow_cluster_ping_update or allow_cluster_restart_schedule_update or
+            allow_server_restart_schedule_update or allow_server_infobases_limit_update or
+            allow_server_connections_limit_update or
+            allow_server_safe_call_memory_limit_update or
+            allow_server_critical_total_memory_update or
+            allow_server_temporary_total_memory_update or
+            allow_server_temporary_memory_time_limit_update or allow_server_spn_update or
+            allow_server_dedicate_managers_update or allow_server_port_ranges_update) and (
+            not isinstance(csrf_token, str) or len(csrf_token) < 16):
+        raise ValueError('Web mutation requires an unpredictable CSRF token')
+
+    def application(environ, start_response):
+        path = environ.get('PATH_INFO', '/')
+        method = environ.get('REQUEST_METHOD', 'GET')
+        setting_insert = re.fullmatch(
+            r'/clusters/([0-9a-fA-F-]{36})/servers/([0-9a-fA-F-]{36})/'
+            r'service-settings/insert', path)
+        if setting_insert and allow_service_setting_insert:
+            headers = [('Content-Type', 'text/html; charset=utf-8'),
+                       ('Cache-Control', 'no-store'), ('X-Content-Type-Options', 'nosniff'),
+                       ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')]
+            if method not in ('GET', 'POST'):
+                start_response('405 Method Not Allowed', [('Allow', 'GET, POST'),
+                                                          ('Content-Type', 'text/plain')])
+                return [b'Method not allowed']
+            try:
+                cluster, server = (UUID(value) for value in setting_insert.groups())
+                if tuple(map(str, (cluster, server))) != setting_insert.groups():
+                    raise ValueError('Noncanonical UUID')
+                host = environ.get('HTTP_HOST', '')
+                if (host not in ('localhost', '127.0.0.1', '[::1]') and
+                        not re.fullmatch(r'(localhost|127\.0\.0\.1|\[::1\]):[0-9]{1,5}', host)):
+                    raise ValueError('Invalid mutation host')
+                if environ.get('REMOTE_ADDR') not in ('127.0.0.1', '::1'):
+                    raise ValueError('Mutation requires loopback peer')
+                if method == 'GET':
+                    content = (f'<form method="post" action="{html.escape(path, quote=True)}">'
+                               f'<input type="hidden" name="csrf_token" value="{html.escape(csrf_token, quote=True)}">'
+                               '<label>Service name <input name="service_name" required></label>'
+                               '<label>Infobase name <input name="infobase_name"></label>'
+                               '<label>Service data directory <input name="service_data_dir"></label>'
+                               '<label>Type exact cluster UUID:server UUID:service name:infobase name '
+                               '<input name="confirm_cluster_server_service_infobase" required></label>'
+                               '<button type="submit">Insert service setting</button></form>')
+                    body = render_document('Confirm service setting insert', content)
+                else:
+                    origin = urlsplit(environ.get('HTTP_ORIGIN', ''))
+                    if (origin.scheme != 'http' or origin.netloc != host or
+                            origin.path or origin.query or origin.fragment):
+                        raise ValueError('Invalid mutation origin')
+                    if environ.get('CONTENT_TYPE', '').split(';', 1)[0] != 'application/x-www-form-urlencoded':
+                        raise ValueError('Invalid mutation content type')
+                    length = int(environ.get('CONTENT_LENGTH', '-1'))
+                    if not 0 <= length <= 4096:
+                        raise ValueError('Invalid mutation body length')
+                    raw_body = environ['wsgi.input'].read(length)
+                    if len(raw_body) != length:
+                        raise ValueError('Incomplete mutation body')
+                    fields = parse_qs(raw_body.decode('utf-8', errors='strict'),
+                                      keep_blank_values=True, strict_parsing=True)
+                    if (set(fields) != {'csrf_token', 'service_name', 'infobase_name',
+                                        'service_data_dir', 'confirm_cluster_server_service_infobase'} or
+                            any(len(values) != 1 for values in fields.values()) or
+                            not hmac.compare_digest(fields['csrf_token'][0], csrf_token)):
+                        raise ValueError('Invalid mutation form')
+                    service_name, infobase_name, directory = (
+                        fields[key][0] for key in ('service_name', 'infobase_name', 'service_data_dir'))
+                    if (not service_name.strip() or any('\x00' in value or
+                            len(value.encode('utf-8')) > 1024 for value in
+                            (service_name, infobase_name, directory)) or
+                            fields['confirm_cluster_server_service_infobase'][0] !=
+                            f'{cluster}:{server}:{service_name}:{infobase_name}'):
+                        raise ValueError('Invalid mutation confirmation')
+                    async def insert():
+                        async with client_factory() as client:
+                            return await client.insert_service_setting(
+                                cluster, server, service_name, infobase_name=infobase_name,
+                                service_data_dir=directory)
+                    row = asyncio.run(insert())
+                    body = render_document('Service setting insertion verified by full read-back',
+                                           render_section('Service setting', [row], ''))
+            except (RacError, ValueError, OSError, TimeoutError, UnicodeError, RuntimeError):
+                start_response('403 Forbidden' if method == 'POST' else '503 Service Unavailable',
+                               [('Content-Type', 'text/plain; charset=utf-8'), ('Cache-Control', 'no-store'),
+                                ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')])
+                return [b'Service setting insert failed' if method == 'POST'
+                        else b'RAC unavailable']
+            start_response('200 OK', headers)
+            return [body.encode('utf-8')]
+        setting_update = re.fullmatch(
+            r'/clusters/([0-9a-fA-F-]{36})/servers/([0-9a-fA-F-]{36})/'
+            r'service-settings/([0-9a-fA-F-]{36})/update', path)
+        if setting_update and allow_service_setting_update:
+            headers = [('Content-Type', 'text/html; charset=utf-8'),
+                       ('Cache-Control', 'no-store'), ('X-Content-Type-Options', 'nosniff'),
+                       ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')]
+            if method not in ('GET', 'POST'):
+                start_response('405 Method Not Allowed', [('Allow', 'GET, POST'),
+                                                          ('Content-Type', 'text/plain')])
+                return [b'Method not allowed']
+            try:
+                cluster, server, setting = (UUID(value) for value in setting_update.groups())
+                if tuple(map(str, (cluster, server, setting))) != setting_update.groups():
+                    raise ValueError('Noncanonical UUID')
+                host = environ.get('HTTP_HOST', '')
+                if (host not in ('localhost', '127.0.0.1', '[::1]') and
+                        not re.fullmatch(r'(localhost|127\.0\.0\.1|\[::1\]):[0-9]{1,5}', host)):
+                    raise ValueError('Invalid mutation host')
+                if environ.get('REMOTE_ADDR') not in ('127.0.0.1', '::1'):
+                    raise ValueError('Mutation requires loopback peer')
+                if method == 'GET':
+                    async def selected_setting():
+                        async with client_factory() as client:
+                            return [row for row in await client.list_service_settings(cluster, server)
+                                    if row.get('setting') == str(setting)]
+                    rows = asyncio.run(selected_setting())
+                    if len(rows) != 1:
+                        raise ValueError('Service setting not found or not unique')
+                    content = (render_section('Service setting', rows, '') +
+                               f'<form method="post" action="{html.escape(path, quote=True)}">'
+                               f'<input type="hidden" name="csrf_token" value="{html.escape(csrf_token, quote=True)}">'
+                               '<label>New service data directory '
+                               '<input name="service_data_dir" required></label>'
+                               '<label>Type exact cluster UUID:server UUID:setting UUID to confirm '
+                               '<input name="confirm_cluster_server_setting" required></label>'
+                               '<button type="submit">Update service setting</button></form>')
+                    body = render_document('Confirm service setting update', content)
+                else:
+                    origin = urlsplit(environ.get('HTTP_ORIGIN', ''))
+                    if (origin.scheme != 'http' or origin.netloc != host or
+                            origin.path or origin.query or origin.fragment):
+                        raise ValueError('Invalid mutation origin')
+                    if environ.get('CONTENT_TYPE', '').split(';', 1)[0] != 'application/x-www-form-urlencoded':
+                        raise ValueError('Invalid mutation content type')
+                    length = int(environ.get('CONTENT_LENGTH', '-1'))
+                    if not 0 <= length <= 4096:
+                        raise ValueError('Invalid mutation body length')
+                    raw_body = environ['wsgi.input'].read(length)
+                    if len(raw_body) != length:
+                        raise ValueError('Incomplete mutation body')
+                    fields = parse_qs(raw_body.decode('utf-8', errors='strict'),
+                                      keep_blank_values=True, strict_parsing=True)
+                    if (set(fields) != {'csrf_token', 'confirm_cluster_server_setting',
+                                        'service_data_dir'} or
+                            any(len(values) != 1 for values in fields.values()) or
+                            not hmac.compare_digest(fields['csrf_token'][0], csrf_token) or
+                            fields['confirm_cluster_server_setting'][0] !=
+                            f'{cluster}:{server}:{setting}'):
+                        raise ValueError('Invalid mutation confirmation')
+                    directory = fields['service_data_dir'][0]
+                    if '\x00' in directory or len(directory.encode('utf-8')) > 1024:
+                        raise ValueError('Invalid service data directory')
+                    async def update():
+                        async with client_factory() as client:
+                            return await client.update_service_setting(cluster, server, setting, directory)
+                    row = asyncio.run(update())
+                    body = render_document('Service setting path verified by full read-back',
+                                           render_section('Service setting', [row], ''))
+            except (RacError, ValueError, OSError, TimeoutError, UnicodeError, RuntimeError):
+                start_response('403 Forbidden' if method == 'POST' else '503 Service Unavailable',
+                               [('Content-Type', 'text/plain; charset=utf-8'), ('Cache-Control', 'no-store'),
+                                ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')])
+                return [b'Service setting update failed' if method == 'POST'
+                        else b'RAC unavailable']
+            start_response('200 OK', headers)
+            return [body.encode('utf-8')]
+        setting_remove = re.fullmatch(
+            r'/clusters/([0-9a-fA-F-]{36})/servers/([0-9a-fA-F-]{36})/'
+            r'service-settings/([0-9a-fA-F-]{36})/remove', path)
+        if setting_remove and allow_service_setting_remove:
+            headers = [('Content-Type', 'text/html; charset=utf-8'),
+                       ('Cache-Control', 'no-store'), ('X-Content-Type-Options', 'nosniff'),
+                       ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')]
+            if method not in ('GET', 'POST'):
+                start_response('405 Method Not Allowed', [('Allow', 'GET, POST'),
+                                                          ('Content-Type', 'text/plain')])
+                return [b'Method not allowed']
+            try:
+                cluster, server, setting = (UUID(value) for value in setting_remove.groups())
+                if tuple(map(str, (cluster, server, setting))) != setting_remove.groups():
+                    raise ValueError('Noncanonical UUID')
+                host = environ.get('HTTP_HOST', '')
+                if (host not in ('localhost', '127.0.0.1', '[::1]') and
+                        not re.fullmatch(r'(localhost|127\.0\.0\.1|\[::1\]):[0-9]{1,5}', host)):
+                    raise ValueError('Invalid mutation host')
+                if environ.get('REMOTE_ADDR') not in ('127.0.0.1', '::1'):
+                    raise ValueError('Mutation requires loopback peer')
+                if method == 'GET':
+                    async def selected_setting():
+                        async with client_factory() as client:
+                            return [row for row in await client.list_service_settings(cluster, server)
+                                    if row.get('setting') == str(setting)]
+                    rows = asyncio.run(selected_setting())
+                    if len(rows) != 1:
+                        raise ValueError('Service setting not found or not unique')
+                    content = (render_section('Service setting', rows, '') +
+                               f'<form method="post" action="{html.escape(path, quote=True)}">'
+                               f'<input type="hidden" name="csrf_token" value="{html.escape(csrf_token, quote=True)}">'
+                               '<label>Type exact cluster UUID:server UUID:setting UUID to confirm removal '
+                               '<input name="confirm_cluster_server_setting" required></label>'
+                               '<button type="submit">Remove service setting</button></form>')
+                    body = render_document('Confirm service setting removal', content)
+                else:
+                    origin = urlsplit(environ.get('HTTP_ORIGIN', ''))
+                    if (origin.scheme != 'http' or origin.netloc != host or
+                            origin.path or origin.query or origin.fragment):
+                        raise ValueError('Invalid mutation origin')
+                    if environ.get('CONTENT_TYPE', '').split(';', 1)[0] != 'application/x-www-form-urlencoded':
+                        raise ValueError('Invalid mutation content type')
+                    length = int(environ.get('CONTENT_LENGTH', '-1'))
+                    if not 0 <= length <= 4096:
+                        raise ValueError('Invalid mutation body length')
+                    raw_body = environ['wsgi.input'].read(length)
+                    if len(raw_body) != length:
+                        raise ValueError('Incomplete mutation body')
+                    fields = parse_qs(raw_body.decode('utf-8', errors='strict'),
+                                      keep_blank_values=True, strict_parsing=True)
+                    if (set(fields) != {'csrf_token', 'confirm_cluster_server_setting'} or
+                            any(len(values) != 1 for values in fields.values()) or
+                            not hmac.compare_digest(fields['csrf_token'][0], csrf_token) or
+                            fields['confirm_cluster_server_setting'][0] !=
+                            f'{cluster}:{server}:{setting}'):
+                        raise ValueError('Invalid mutation confirmation')
+                    async def remove():
+                        async with client_factory() as client:
+                            await client.remove_service_setting(cluster, server, setting)
+                    asyncio.run(remove())
+                    body = render_document('Service setting removal verified by full read-back',
+                                           '<p>Service setting removal verified by full read-back.</p>')
+            except (RacError, ValueError, OSError, TimeoutError, UnicodeError, RuntimeError):
+                start_response('403 Forbidden' if method == 'POST' else '503 Service Unavailable',
+                               [('Content-Type', 'text/plain; charset=utf-8'), ('Cache-Control', 'no-store'),
+                                ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')])
+                return [b'Service setting removal failed' if method == 'POST'
+                        else b'RAC unavailable']
+            start_response('200 OK', headers)
+            return [body.encode('utf-8')]
+        settings_apply = re.fullmatch(
+            r'/clusters/([0-9a-fA-F-]{36})/servers/([0-9a-fA-F-]{36})/service-settings/apply', path)
+        if settings_apply and allow_service_settings_apply:
+            headers = [('Content-Type', 'text/html; charset=utf-8'),
+                       ('Cache-Control', 'no-store'), ('X-Content-Type-Options', 'nosniff'),
+                       ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')]
+            if method not in ('GET', 'POST'):
+                start_response('405 Method Not Allowed', [('Allow', 'GET, POST'),
+                                                          ('Content-Type', 'text/plain')])
+                return [b'Method not allowed']
+            try:
+                cluster, server = (UUID(value) for value in settings_apply.groups())
+                host = environ.get('HTTP_HOST', '')
+                if (host not in ('localhost', '127.0.0.1', '[::1]') and
+                        not re.fullmatch(r'(localhost|127\.0\.0\.1|\[::1\]):[0-9]{1,5}', host)):
+                    raise ValueError('Invalid mutation host')
+                if environ.get('REMOTE_ADDR') not in ('127.0.0.1', '::1'):
+                    raise ValueError('Mutation requires loopback peer')
+                if method == 'GET':
+                    content = (f'<form method="post" action="{html.escape(path, quote=True)}">'
+                               f'<input type="hidden" name="csrf_token" value="{html.escape(csrf_token, quote=True)}">'
+                               '<label>Type exact cluster UUID:server UUID to confirm '
+                               '<input name="confirm_cluster_server" required></label>'
+                               '<button type="submit">Apply service settings</button></form>')
+                    body = render_document('Confirm service settings apply', content)
+                else:
+                    origin = urlsplit(environ.get('HTTP_ORIGIN', ''))
+                    if (origin.scheme != 'http' or origin.netloc != host or
+                            origin.path or origin.query or origin.fragment):
+                        raise ValueError('Invalid mutation origin')
+                    if environ.get('CONTENT_TYPE', '').split(';', 1)[0] != 'application/x-www-form-urlencoded':
+                        raise ValueError('Invalid mutation content type')
+                    length = int(environ.get('CONTENT_LENGTH', '-1'))
+                    if not 0 <= length <= 4096:
+                        raise ValueError('Invalid mutation body length')
+                    raw_body = environ['wsgi.input'].read(length)
+                    if len(raw_body) != length:
+                        raise ValueError('Incomplete mutation body')
+                    fields = parse_qs(raw_body.decode('utf-8', errors='strict'),
+                                      keep_blank_values=True, strict_parsing=True)
+                    if (set(fields) != {'csrf_token', 'confirm_cluster_server'} or
+                            any(len(values) != 1 for values in fields.values()) or
+                            not hmac.compare_digest(fields['csrf_token'][0], csrf_token) or
+                            fields['confirm_cluster_server'][0] != f'{cluster}:{server}'):
+                        raise ValueError('Invalid mutation confirmation')
+                    async def apply():
+                        async with client_factory() as client:
+                            return await client.apply_service_settings(cluster, server)
+                    result = asyncio.run(apply())
+                    body = render_document(
+                        'Service settings active flags verified',
+                        '<p>Service settings active flags verified by full read-back; '
+                        'runtime service behaviour not independently verified.</p>' +
+                        render_section('Service settings', result, ''))
+            except (RacError, ValueError, OSError, TimeoutError, UnicodeError, RuntimeError):
+                start_response('403 Forbidden' if method == 'POST' else '503 Service Unavailable',
+                               [('Content-Type', 'text/plain; charset=utf-8'), ('Cache-Control', 'no-store'),
+                                ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')])
+                return [b'Service settings apply not verified' if method == 'POST'
+                        else b'RAC unavailable']
+            start_response('200 OK', headers)
+            return [body.encode('utf-8')]
+        rule_apply = re.fullmatch(r'/clusters/([0-9a-fA-F-]{36})/rules/apply', path)
+        if rule_apply and allow_rule_apply:
+            headers = [('Content-Type', 'text/html; charset=utf-8'),
+                       ('Cache-Control', 'no-store'), ('X-Content-Type-Options', 'nosniff'),
+                       ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')]
+            if method not in ('GET', 'POST'):
+                start_response('405 Method Not Allowed', [('Allow', 'GET, POST'),
+                                                          ('Content-Type', 'text/plain')])
+                return [b'Method not allowed']
+            try:
+                cluster = UUID(rule_apply.group(1))
+                host = environ.get('HTTP_HOST', '')
+                if (host not in ('localhost', '127.0.0.1', '[::1]') and
+                        not re.fullmatch(r'(localhost|127\.0\.0\.1|\[::1\]):[0-9]{1,5}', host)):
+                    raise ValueError('Invalid mutation host')
+                if environ.get('REMOTE_ADDR') not in ('127.0.0.1', '::1'):
+                    raise ValueError('Mutation requires loopback peer')
+                if method == 'GET':
+                    content = (f'<form method="post" action="{html.escape(path, quote=True)}">'
+                               f'<input type="hidden" name="csrf_token" value="{html.escape(csrf_token, quote=True)}">'
+                               '<label>Apply mode <select name="mode"><option value="partial">partial</option>'
+                               '<option value="full">full</option></select></label>'
+                               '<label>Type exact cluster UUID to confirm '
+                               '<input name="confirm_cluster_id" required></label>'
+                               '<button type="submit">Apply rules</button></form>'
+                               '<p>Effective placement cannot be verified by rule list/info.</p>')
+                    body = render_document('Confirm rule apply', content)
+                else:
+                    origin = urlsplit(environ.get('HTTP_ORIGIN', ''))
+                    if (origin.scheme != 'http' or origin.netloc != host or
+                            origin.path or origin.query or origin.fragment):
+                        raise ValueError('Invalid mutation origin')
+                    if environ.get('CONTENT_TYPE', '').split(';', 1)[0] != 'application/x-www-form-urlencoded':
+                        raise ValueError('Invalid mutation content type')
+                    length = int(environ.get('CONTENT_LENGTH', '-1'))
+                    if not 0 <= length <= 4096:
+                        raise ValueError('Invalid mutation body length')
+                    raw_body = environ['wsgi.input'].read(length)
+                    if len(raw_body) != length:
+                        raise ValueError('Incomplete mutation body')
+                    fields = parse_qs(raw_body.decode('utf-8', errors='strict'),
+                                      keep_blank_values=True, strict_parsing=True)
+                    if (set(fields) != {'csrf_token', 'mode', 'confirm_cluster_id'} or
+                            any(len(values) != 1 for values in fields.values()) or
+                            not hmac.compare_digest(fields['csrf_token'][0], csrf_token) or
+                            fields['mode'][0] not in ('partial', 'full') or
+                            fields['confirm_cluster_id'][0] != str(cluster)):
+                        raise ValueError('Invalid mutation confirmation')
+                    async def apply():
+                        async with client_factory() as client:
+                            return await client.apply_rules(cluster, full=fields['mode'][0] == 'full')
+                    result = asyncio.run(apply())
+                    body = render_document(
+                        'Rule apply acknowledged; rules unchanged',
+                        '<p>Rule apply acknowledged; rules unchanged; effective placement not verified.</p>' +
+                        ''.join(render_section('Rules on server ' + str(server), rules, '')
+                                for server, rules in result.items()))
+            except (RacError, ValueError, OSError, TimeoutError, UnicodeError, RuntimeError):
+                start_response('403 Forbidden' if method == 'POST' else '503 Service Unavailable',
+                               [('Content-Type', 'text/plain; charset=utf-8'), ('Cache-Control', 'no-store'),
+                                ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')])
+                return [b'Rule apply not verified' if method == 'POST' else b'RAC unavailable']
+            start_response('200 OK', headers)
+            return [body.encode('utf-8')]
+        cluster_admin_remove = re.fullmatch(
+            r'/clusters/([0-9a-fA-F-]{36})/admins/([^/]{1,1024})/remove', path)
+        if cluster_admin_remove and allow_cluster_admin_remove:
+            headers = [('Content-Type', 'text/html; charset=utf-8'),
+                       ('Cache-Control', 'no-store'), ('X-Content-Type-Options', 'nosniff'),
+                       ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')]
+            if method not in ('GET', 'POST'):
+                start_response('405 Method Not Allowed', [('Allow', 'GET, POST'),
+                                                          ('Content-Type', 'text/plain')])
+                return [b'Method not allowed']
+            try:
+                cluster = UUID(cluster_admin_remove.group(1))
+                name = unquote(cluster_admin_remove.group(2), encoding='utf-8', errors='strict')
+                if (not name or '/' in name or '\\' in name or '\x00' in name or
+                        len(name.encode('utf-8')) > 1024):
+                    raise ValueError('Invalid administrator name')
+                host = environ.get('HTTP_HOST', '')
+                if (host not in ('localhost', '127.0.0.1', '[::1]') and
+                        not re.fullmatch(r'(localhost|127\.0\.0\.1|\[::1\]):[0-9]{1,5}', host)):
+                    raise ValueError('Invalid mutation host')
+                if environ.get('REMOTE_ADDR') not in ('127.0.0.1', '::1'):
+                    raise ValueError('Mutation requires loopback peer')
+                if method == 'GET':
+                    async def admins():
+                        async with client_factory() as client:
+                            return await client.list_cluster_admins(cluster)
+                    rows = [row for row in asyncio.run(admins()) if row.get('name') == name]
+                    if len(rows) != 1:
+                        raise ValueError('Administrator not found or not unique')
+                    content = (render_section('Cluster administrator', rows, '') +
+                               f'<form method="post" action="{html.escape(path, quote=True)}">'
+                               f'<input type="hidden" name="csrf_token" value="{html.escape(csrf_token, quote=True)}">'
+                               '<label>Type exact cluster UUID:administrator name to confirm removal '
+                               '<input name="confirm_cluster_name" required></label>'
+                               '<button type="submit">Remove cluster administrator</button></form>')
+                    body = render_document('Confirm cluster administrator removal', content)
+                else:
+                    origin = urlsplit(environ.get('HTTP_ORIGIN', ''))
+                    if (origin.scheme != 'http' or origin.netloc != host or
+                            origin.path or origin.query or origin.fragment):
+                        raise ValueError('Invalid mutation origin')
+                    if environ.get('CONTENT_TYPE', '').split(';', 1)[0] != 'application/x-www-form-urlencoded':
+                        raise ValueError('Invalid mutation content type')
+                    length = int(environ.get('CONTENT_LENGTH', '-1'))
+                    if not 0 <= length <= 4096:
+                        raise ValueError('Invalid mutation body length')
+                    raw_body = environ['wsgi.input'].read(length)
+                    if len(raw_body) != length:
+                        raise ValueError('Incomplete mutation body')
+                    fields = parse_qs(raw_body.decode('utf-8', errors='strict'),
+                                      keep_blank_values=True, strict_parsing=True)
+                    if (set(fields) != {'csrf_token', 'confirm_cluster_name'} or
+                            any(len(values) != 1 for values in fields.values()) or
+                            not hmac.compare_digest(fields['csrf_token'][0], csrf_token) or
+                            fields['confirm_cluster_name'][0] != f'{cluster}:{name}'):
+                        raise ValueError('Invalid mutation confirmation')
+                    async def remove_admin():
+                        async with client_factory() as client:
+                            return await client.remove_cluster_admin(cluster, name)
+                    result = asyncio.run(remove_admin())
+                    body = render_page('Verified cluster administrator removal', result, '')
+            except (RacError, ValueError, OSError, TimeoutError, UnicodeError, RuntimeError):
+                start_response('403 Forbidden' if method == 'POST' else '503 Service Unavailable',
+                               [('Content-Type', 'text/plain; charset=utf-8'), ('Cache-Control', 'no-store'),
+                                ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')])
+                return [b'Cluster administrator removal not verified' if method == 'POST'
+                        else b'RAC unavailable']
+            start_response('200 OK', headers)
+            return [body.encode('utf-8')]
+        agent_admin_remove = re.fullmatch(r'/agent/admins/([^/]{1,1024})/remove', path)
+        if agent_admin_remove and allow_agent_admin_remove:
+            headers = [('Content-Type', 'text/html; charset=utf-8'),
+                       ('Cache-Control', 'no-store'), ('X-Content-Type-Options', 'nosniff'),
+                       ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')]
+            if method not in ('GET', 'POST'):
+                start_response('405 Method Not Allowed', [('Allow', 'GET, POST'),
+                                                          ('Content-Type', 'text/plain')])
+                return [b'Method not allowed']
+            try:
+                name = unquote(agent_admin_remove.group(1), encoding='utf-8', errors='strict')
+                if (not name or '/' in name or '\\' in name or '\x00' in name or
+                        len(name.encode('utf-8')) > 1024):
+                    raise ValueError('Invalid administrator name')
+                host = environ.get('HTTP_HOST', '')
+                if (host not in ('localhost', '127.0.0.1', '[::1]') and
+                        not re.fullmatch(r'(localhost|127\.0\.0\.1|\[::1\]):[0-9]{1,5}', host)):
+                    raise ValueError('Invalid mutation host')
+                if environ.get('REMOTE_ADDR') not in ('127.0.0.1', '::1'):
+                    raise ValueError('Mutation requires loopback peer')
+                if method == 'GET':
+                    async def admins():
+                        async with client_factory() as client:
+                            return await client.list_agent_admins()
+                    rows = [row for row in asyncio.run(admins()) if row.get('name') == name]
+                    if len(rows) != 1:
+                        raise ValueError('Administrator not found or not unique')
+                    content = (render_section('Agent administrator', rows, '') +
+                               f'<form method="post" action="{html.escape(path, quote=True)}">'
+                               f'<input type="hidden" name="csrf_token" value="{html.escape(csrf_token, quote=True)}">'
+                               '<label>Type exact administrator name to confirm removal '
+                               '<input name="confirm_name" required></label>'
+                               '<button type="submit">Remove agent administrator</button></form>')
+                    body = render_document('Confirm agent administrator removal', content)
+                else:
+                    origin = urlsplit(environ.get('HTTP_ORIGIN', ''))
+                    if (origin.scheme != 'http' or origin.netloc != host or
+                            origin.path or origin.query or origin.fragment):
+                        raise ValueError('Invalid mutation origin')
+                    if environ.get('CONTENT_TYPE', '').split(';', 1)[0] != 'application/x-www-form-urlencoded':
+                        raise ValueError('Invalid mutation content type')
+                    length = int(environ.get('CONTENT_LENGTH', '-1'))
+                    if not 0 <= length <= 4096:
+                        raise ValueError('Invalid mutation body length')
+                    raw_body = environ['wsgi.input'].read(length)
+                    if len(raw_body) != length:
+                        raise ValueError('Incomplete mutation body')
+                    fields = parse_qs(raw_body.decode('utf-8', errors='strict'),
+                                      keep_blank_values=True, strict_parsing=True)
+                    if (set(fields) != {'csrf_token', 'confirm_name'} or
+                            any(len(values) != 1 for values in fields.values()) or
+                            not hmac.compare_digest(fields['csrf_token'][0], csrf_token) or
+                            fields['confirm_name'][0] != name):
+                        raise ValueError('Invalid mutation confirmation')
+                    async def remove_admin():
+                        async with client_factory() as client:
+                            return await client.remove_agent_admin(name)
+                    result = asyncio.run(remove_admin())
+                    body = render_page('Verified agent administrator removal', result, '')
+            except (RacError, ValueError, OSError, TimeoutError, UnicodeError, RuntimeError):
+                start_response('403 Forbidden' if method == 'POST' else '503 Service Unavailable',
+                               [('Content-Type', 'text/plain; charset=utf-8'), ('Cache-Control', 'no-store'),
+                                ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')])
+                return [b'Agent administrator removal not verified' if method == 'POST'
+                        else b'RAC unavailable']
+            start_response('200 OK', headers)
+            return [body.encode('utf-8')]
+        cluster_admin_register = re.fullmatch(
+            r'/clusters/([0-9a-fA-F-]{36})/admins/register', path)
+        if cluster_admin_register and allow_cluster_admin_register:
+            headers = [('Content-Type', 'text/html; charset=utf-8'),
+                       ('Cache-Control', 'no-store'), ('X-Content-Type-Options', 'nosniff'),
+                       ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')]
+            if method not in ('GET', 'POST'):
+                start_response('405 Method Not Allowed', [('Allow', 'GET, POST'),
+                                                          ('Content-Type', 'text/plain')])
+                return [b'Method not allowed']
+            try:
+                cluster = UUID(cluster_admin_register.group(1))
+                host = environ.get('HTTP_HOST', '')
+                if (host not in ('localhost', '127.0.0.1', '[::1]') and
+                        not re.fullmatch(r'(localhost|127\.0\.0\.1|\[::1\]):[0-9]{1,5}', host)):
+                    raise ValueError('Invalid mutation host')
+                if environ.get('REMOTE_ADDR') not in ('127.0.0.1', '::1'):
+                    raise ValueError('Mutation requires loopback peer')
+                if method == 'GET':
+                    content = (f'<form method="post" action="{html.escape(path, quote=True)}">'
+                               f'<input type="hidden" name="csrf_token" value="{html.escape(csrf_token, quote=True)}">'
+                               '<label>Administrator name <input name="name" required></label>'
+                               '<label>OS user <input name="os_user" required></label>'
+                               '<label>Description <input name="descr"></label>'
+                               '<label>Type exact cluster UUID:name:os_user to confirm '
+                               '<input name="confirm_cluster_name_os_user" required></label>'
+                               '<button type="submit">Register cluster administrator</button></form>')
+                    body = render_document('Confirm cluster administrator registration', content)
+                else:
+                    origin = urlsplit(environ.get('HTTP_ORIGIN', ''))
+                    if (origin.scheme != 'http' or origin.netloc != host or
+                            origin.path or origin.query or origin.fragment):
+                        raise ValueError('Invalid mutation origin')
+                    if environ.get('CONTENT_TYPE', '').split(';', 1)[0] != 'application/x-www-form-urlencoded':
+                        raise ValueError('Invalid mutation content type')
+                    length = int(environ.get('CONTENT_LENGTH', '-1'))
+                    if not 0 <= length <= 4096:
+                        raise ValueError('Invalid mutation body length')
+                    raw_body = environ['wsgi.input'].read(length)
+                    if len(raw_body) != length:
+                        raise ValueError('Incomplete mutation body')
+                    fields = parse_qs(raw_body.decode('utf-8', errors='strict'),
+                                      keep_blank_values=True, strict_parsing=True)
+                    if (set(fields) != {'csrf_token', 'name', 'os_user', 'descr',
+                                        'confirm_cluster_name_os_user'} or
+                            any(len(values) != 1 for values in fields.values()) or
+                            not hmac.compare_digest(fields['csrf_token'][0], csrf_token)):
+                        raise ValueError('Invalid mutation fields')
+                    name, os_user, descr = (fields[key][0] for key in ('name', 'os_user', 'descr'))
+                    if (not name or not os_user or any('\x00' in value or
+                            len(value.encode('utf-8')) > 1024 for value in (name, os_user, descr)) or
+                            fields['confirm_cluster_name_os_user'][0] != f'{cluster}:{name}:{os_user}'):
+                        raise ValueError('Invalid administrator registration or confirmation')
+                    async def register_admin():
+                        async with client_factory() as client:
+                            return await client.register_cluster_admin(cluster, name, os_user, descr=descr)
+                    result = asyncio.run(register_admin())
+                    body = render_page('Verified cluster administrator registration', [result], '')
+            except (RacError, ValueError, OSError, TimeoutError, UnicodeError, RuntimeError):
+                start_response('403 Forbidden' if method == 'POST' else '503 Service Unavailable',
+                               [('Content-Type', 'text/plain; charset=utf-8'), ('Cache-Control', 'no-store'),
+                                ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')])
+                return [b'Cluster administrator registration not verified' if method == 'POST'
+                        else b'RAC unavailable']
+            start_response('200 OK', headers)
+            return [body.encode('utf-8')]
+        if path == '/agent/admins/register' and allow_agent_admin_register:
+            headers = [('Content-Type', 'text/html; charset=utf-8'),
+                       ('Cache-Control', 'no-store'), ('X-Content-Type-Options', 'nosniff'),
+                       ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')]
+            if method not in ('GET', 'POST'):
+                start_response('405 Method Not Allowed', [('Allow', 'GET, POST'),
+                                                          ('Content-Type', 'text/plain')])
+                return [b'Method not allowed']
+            try:
+                host = environ.get('HTTP_HOST', '')
+                if (host not in ('localhost', '127.0.0.1', '[::1]') and
+                        not re.fullmatch(r'(localhost|127\.0\.0\.1|\[::1\]):[0-9]{1,5}', host)):
+                    raise ValueError('Invalid mutation host')
+                if environ.get('REMOTE_ADDR') not in ('127.0.0.1', '::1'):
+                    raise ValueError('Mutation requires loopback peer')
+                if method == 'GET':
+                    content = (f'<form method="post" action="/agent/admins/register">'
+                               f'<input type="hidden" name="csrf_token" value="{html.escape(csrf_token, quote=True)}">'
+                               '<label>Administrator name <input name="name" required></label>'
+                               '<label>OS user <input name="os_user" required></label>'
+                               '<label>Description <input name="descr"></label>'
+                               '<label>Type exact name:os_user to confirm '
+                               '<input name="confirm_name_os_user" required></label>'
+                               '<button type="submit">Register agent administrator</button></form>')
+                    body = render_document('Confirm agent administrator registration', content)
+                else:
+                    origin = urlsplit(environ.get('HTTP_ORIGIN', ''))
+                    if (origin.scheme != 'http' or origin.netloc != host or
+                            origin.path or origin.query or origin.fragment):
+                        raise ValueError('Invalid mutation origin')
+                    if environ.get('CONTENT_TYPE', '').split(';', 1)[0] != 'application/x-www-form-urlencoded':
+                        raise ValueError('Invalid mutation content type')
+                    length = int(environ.get('CONTENT_LENGTH', '-1'))
+                    if not 0 <= length <= 4096:
+                        raise ValueError('Invalid mutation body length')
+                    raw_body = environ['wsgi.input'].read(length)
+                    if len(raw_body) != length:
+                        raise ValueError('Incomplete mutation body')
+                    fields = parse_qs(raw_body.decode('utf-8', errors='strict'),
+                                      keep_blank_values=True, strict_parsing=True)
+                    if (set(fields) != {'csrf_token', 'name', 'os_user', 'descr',
+                                        'confirm_name_os_user'} or
+                            any(len(values) != 1 for values in fields.values()) or
+                            not hmac.compare_digest(fields['csrf_token'][0], csrf_token)):
+                        raise ValueError('Invalid mutation fields')
+                    name, os_user, descr = (fields[key][0] for key in ('name', 'os_user', 'descr'))
+                    if (not name or not os_user or any('\x00' in value or
+                            len(value.encode('utf-8')) > 1024 for value in (name, os_user, descr)) or
+                            fields['confirm_name_os_user'][0] != f'{name}:{os_user}'):
+                        raise ValueError('Invalid administrator registration or confirmation')
+                    async def register_admin():
+                        async with client_factory() as client:
+                            return await client.register_agent_admin(name, os_user, descr=descr)
+                    result = asyncio.run(register_admin())
+                    body = render_page('Verified agent administrator registration', [result], '')
+            except (RacError, ValueError, OSError, TimeoutError, UnicodeError, RuntimeError):
+                start_response('403 Forbidden' if method == 'POST' else '503 Service Unavailable',
+                               [('Content-Type', 'text/plain; charset=utf-8'), ('Cache-Control', 'no-store'),
+                                ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')])
+                return [b'Agent administrator registration not verified' if method == 'POST'
+                        else b'RAC unavailable']
+            start_response('200 OK', headers)
+            return [body.encode('utf-8')]
+        if path == '/clusters/insert' and allow_cluster_insert:
+            headers = [('Content-Type', 'text/html; charset=utf-8'),
+                       ('Cache-Control', 'no-store'), ('X-Content-Type-Options', 'nosniff'),
+                       ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')]
+            try:
+                host = environ.get('HTTP_HOST', '')
+                if (host not in ('localhost', '127.0.0.1', '[::1]') and
+                        not re.fullmatch(r'(localhost|127\.0\.0\.1|\[::1\]):[0-9]{1,5}', host)):
+                    raise ValueError('Invalid mutation host')
+                if environ.get('REMOTE_ADDR') not in ('127.0.0.1', '::1'):
+                    raise ValueError('Mutation requires loopback peer')
+                if method == 'GET':
+                    content = (f'<form method="post" action="/clusters/insert">'
+                               f'<input type="hidden" name="csrf_token" value="{html.escape(csrf_token, quote=True)}">'
+                               '<label>Cluster host <input name="host" required></label>'
+                               '<label>Cluster port <input name="port" required></label>'
+                               '<label>Cluster name <input name="name"></label>'
+                               '<label>Access-right audit recording <select name="audit">'
+                               '<option value="off">off</option><option value="on">on</option></select></label>'
+                               '<fieldset><legend>Verified cluster settings (optional)</legend>'
+                               '<label>Expiration timeout <input name="expiration_timeout" type="number" min="0"></label>'
+                               '<label>Security level <input name="security_level" type="number" min="0"></label>'
+                               '<label>Session fault tolerance <input name="session_fault_tolerance_level" type="number" min="0"></label>'
+                               '<label>Load balancing <select name="load_balancing_mode">'
+                               '<option value="performance">performance</option><option value="memory">memory</option>'
+                               '</select></label>'
+                               '<label>Kill problem processes <select name="kill_problem_processes">'
+                               '<option value="yes">yes</option><option value="no">no</option></select></label>'
+                               '<label>Kill by memory with dump <select name="kill_by_memory_with_dump">'
+                               '<option value="no">no</option><option value="yes">yes</option></select></label>'
+                               '<label>Restart schedule (six integers) <input name="restart_schedule"></label>'
+                               '<label>Ping period <input name="ping_period" type="number" min="0"></label>'
+                               '<label>Ping timeout <input name="ping_timeout" type="number" min="0"></label>'
+                               '</fieldset>'
+                               '<label>Type exact host:port to confirm '
+                               '<input name="confirm_host_port" required></label>'
+                               '<button type="submit">Insert cluster</button></form>')
+                    body = render_document('Confirm cluster insertion', content)
+                elif method == 'POST':
+                    origin = urlsplit(environ.get('HTTP_ORIGIN', ''))
+                    if (origin.scheme != 'http' or origin.netloc != host or
+                            origin.path or origin.query or origin.fragment):
+                        raise ValueError('Invalid mutation origin')
+                    if environ.get('CONTENT_TYPE', '').split(';', 1)[0] != 'application/x-www-form-urlencoded':
+                        raise ValueError('Invalid mutation content type')
+                    length = int(environ.get('CONTENT_LENGTH', '-1'))
+                    if not 0 <= length <= 4096:
+                        raise ValueError('Invalid mutation body length')
+                    raw_body = environ['wsgi.input'].read(length)
+                    if len(raw_body) != length:
+                        raise ValueError('Incomplete mutation body')
+                    fields = parse_qs(raw_body.decode('utf-8', errors='strict'),
+                                      keep_blank_values=True, strict_parsing=True)
+                    optional = {'expiration_timeout', 'security_level',
+                                'session_fault_tolerance_level', 'load_balancing_mode',
+                                'kill_problem_processes', 'kill_by_memory_with_dump',
+                                'restart_schedule', 'ping_period', 'ping_timeout'}
+                    if (not {'csrf_token', 'host', 'port', 'name', 'audit',
+                             'confirm_host_port'} <= set(fields)
+                            or set(fields) - {'csrf_token', 'host', 'port', 'name',
+                                              'audit', 'confirm_host_port'} - optional or
+                            any(len(values) != 1 for values in fields.values()) or
+                            not hmac.compare_digest(fields['csrf_token'][0], csrf_token)):
+                        raise ValueError('Invalid mutation fields')
+                    defaults = {'expiration_timeout': 60, 'security_level': 0,
+                                'session_fault_tolerance_level': 0,
+                                'load_balancing_mode': 'performance',
+                                'kill_problem_processes': True,
+                                'kill_by_memory_with_dump': False, 'restart_schedule': '',
+                                'ping_period': 0, 'ping_timeout': 0}
+                    options = {}
+                    for key in ('expiration_timeout', 'security_level',
+                                'session_fault_tolerance_level', 'ping_period', 'ping_timeout'):
+                        text = fields.get(key, [''])[0]
+                        if text:
+                            if not re.fullmatch(r'(0|[1-9][0-9]{0,9})', text) or int(text) >= 2**31:
+                                raise ValueError('Invalid cluster numeric setting')
+                            options[key] = int(text)
+                    for key in ('kill_problem_processes', 'kill_by_memory_with_dump'):
+                        text = fields.get(key, [''])[0]
+                        if text:
+                            if text not in ('yes', 'no'):
+                                raise ValueError('Invalid cluster boolean setting')
+                            options[key] = text == 'yes'
+                    if 'load_balancing_mode' in fields:
+                        value = fields['load_balancing_mode'][0]
+                        if value not in ('performance', 'memory'):
+                            raise ValueError('Invalid cluster load balancing mode')
+                        options['load_balancing_mode'] = value
+                    if 'restart_schedule' in fields:
+                        schedule = fields['restart_schedule'][0]
+                        if ('\x00' in schedule or len(schedule.encode('utf-8')) > 256 or
+                                (schedule and (len(schedule.split()) != 6 or any(
+                                    not part.isascii() or not part.isdecimal()
+                                    for part in schedule.split())))):
+                            raise ValueError('Invalid cluster restart schedule')
+                        options['restart_schedule'] = schedule
+                    period = options.get('ping_period', 0)
+                    timeout = options.get('ping_timeout', 0)
+                    if not (period == timeout == 0 or 0 < period < timeout):
+                        raise ValueError('Invalid cluster ping period/timeout pair')
+                    options = {key: value for key, value in options.items() if value != defaults[key]}
+                    cluster_host, port_text, name = (fields[key][0] for key in ('host', 'port', 'name'))
+                    if (not cluster_host or '\x00' in cluster_host or
+                            len(cluster_host.encode('utf-8')) > 255 or
+                            not re.fullmatch(r'[1-9][0-9]{0,4}', port_text) or
+                            not 1 <= int(port_text) <= 65535 or '\x00' in name or
+                            len(name.encode('utf-8')) > 256 or
+                            fields['audit'][0] not in ('on', 'off') or
+                            fields['confirm_host_port'][0] != f'{cluster_host}:{port_text}'):
+                        raise ValueError('Invalid cluster insertion parameters or confirmation')
+                    async def insert_cluster():
+                        async with client_factory() as client:
+                            return await client.insert_cluster(cluster_host, int(port_text), name,
+                                                               audit=fields['audit'][0] == 'on', **options)
+                    result = asyncio.run(insert_cluster())
+                    body = render_page('Verified cluster insertion', [result], '')
+                else:
+                    start_response('405 Method Not Allowed', [('Allow', 'GET, POST'),
+                                                              ('Content-Type', 'text/plain')])
+                    return [b'Method not allowed']
+            except (RacError, ValueError, OSError, TimeoutError, UnicodeError, RuntimeError):
+                start_response('403 Forbidden' if method == 'POST' else '503 Service Unavailable',
+                               [('Content-Type', 'text/plain; charset=utf-8'), ('Cache-Control', 'no-store'),
+                                ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')])
+                return [b'Cluster insertion not verified' if method == 'POST' else b'RAC unavailable']
+            start_response('200 OK', headers)
+            return [body.encode('utf-8')]
+        cluster_remove = re.fullmatch(r'/clusters/([0-9a-fA-F-]{36})/remove', path)
+        if cluster_remove and allow_cluster_remove:
+            headers = [('Content-Type', 'text/html; charset=utf-8'),
+                       ('Cache-Control', 'no-store'), ('X-Content-Type-Options', 'nosniff'),
+                       ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')]
+            try:
+                cluster = UUID(cluster_remove.group(1))
+                host = environ.get('HTTP_HOST', '')
+                if (host not in ('localhost', '127.0.0.1', '[::1]') and
+                        not re.fullmatch(r'(localhost|127\.0\.0\.1|\[::1\]):[0-9]{1,5}', host)):
+                    raise ValueError('Invalid mutation host')
+                if environ.get('REMOTE_ADDR') not in ('127.0.0.1', '::1'):
+                    raise ValueError('Mutation requires loopback peer')
+                if method == 'GET':
+                    async def cluster_info():
+                        async with client_factory() as client:
+                            return await client.get_cluster(cluster)
+                    row = asyncio.run(cluster_info())
+                    content = (render_section('Cluster', [row], '') +
+                               f'<form method="post" action="{html.escape(path, quote=True)}">'
+                               f'<input type="hidden" name="csrf_token" value="{html.escape(csrf_token, quote=True)}">'
+                               '<label>Type exact cluster UUID to confirm removal '
+                               '<input name="confirm_cluster_id" required></label>'
+                               '<button type="submit">Remove cluster</button></form>')
+                    body = render_document('Confirm cluster removal', content)
+                elif method == 'POST':
+                    origin = urlsplit(environ.get('HTTP_ORIGIN', ''))
+                    if (origin.scheme != 'http' or origin.netloc != host or
+                            origin.path or origin.query or origin.fragment):
+                        raise ValueError('Invalid mutation origin')
+                    if environ.get('CONTENT_TYPE', '').split(';', 1)[0] != 'application/x-www-form-urlencoded':
+                        raise ValueError('Invalid mutation content type')
+                    length = int(environ.get('CONTENT_LENGTH', '-1'))
+                    if not 0 <= length <= 4096:
+                        raise ValueError('Invalid mutation body length')
+                    raw_body = environ['wsgi.input'].read(length)
+                    if len(raw_body) != length:
+                        raise ValueError('Incomplete mutation body')
+                    fields = parse_qs(raw_body.decode('utf-8', errors='strict'),
+                                      keep_blank_values=True, strict_parsing=True)
+                    if (set(fields) != {'csrf_token', 'confirm_cluster_id'} or
+                            any(len(values) != 1 for values in fields.values()) or
+                            not hmac.compare_digest(fields['csrf_token'][0], csrf_token) or
+                            fields['confirm_cluster_id'][0] != str(cluster)):
+                        raise ValueError('Invalid mutation confirmation')
+                    async def remove_cluster():
+                        async with client_factory() as client:
+                            return await client.remove_cluster(cluster)
+                    result = asyncio.run(remove_cluster())
+                    body = render_page('Verified cluster removal', result, '/clusters')
+                else:
+                    start_response('405 Method Not Allowed', [('Allow', 'GET, POST'),
+                                                              ('Content-Type', 'text/plain')])
+                    return [b'Method not allowed']
+            except (RacError, ValueError, OSError, TimeoutError, UnicodeError, RuntimeError):
+                start_response('403 Forbidden' if method == 'POST' else '503 Service Unavailable',
+                               [('Content-Type', 'text/plain; charset=utf-8'), ('Cache-Control', 'no-store'),
+                                ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')])
+                return [b'Cluster removal not verified' if method == 'POST' else b'RAC unavailable']
+            start_response('200 OK', headers)
+            return [body.encode('utf-8')]
+        server_ranges_update = re.fullmatch(
+            r'/clusters/([0-9a-fA-F-]{36})/servers/([0-9a-fA-F-]{36})/port-ranges', path)
+        if server_ranges_update and allow_server_port_ranges_update:
+            headers = [('Content-Type', 'text/html; charset=utf-8'),
+                       ('Cache-Control', 'no-store'), ('X-Content-Type-Options', 'nosniff'),
+                       ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')]
+            try:
+                cluster, server = UUID(server_ranges_update.group(1)), UUID(server_ranges_update.group(2))
+                host = environ.get('HTTP_HOST', '')
+                if (host not in ('localhost', '127.0.0.1', '[::1]') and
+                        not re.fullmatch(r'(localhost|127\.0\.0\.1|\[::1\]):[0-9]{1,5}', host)):
+                    raise ValueError('Invalid mutation host')
+                if environ.get('REMOTE_ADDR') not in ('127.0.0.1', '::1'):
+                    raise ValueError('Mutation requires loopback peer')
+                if method == 'GET':
+                    async def server_info():
+                        async with client_factory() as client:
+                            return await client.get_server(cluster, server)
+                    row = asyncio.run(server_info())
+                    content = (render_section('Working server', [row], '') +
+                               f'<form method="post" action="{html.escape(path, quote=True)}">'
+                               f'<input type="hidden" name="csrf_token" value="{html.escape(csrf_token, quote=True)}">'
+                               '<label>Port ranges (start:end, comma separated; 1..65535) '
+                               '<input name="ranges" required></label>'
+                               '<label>Type exact server UUID to confirm '
+                               '<input name="confirm_server_id" required></label>'
+                               '<button type="submit">Update server port ranges</button></form>')
+                    body = render_document('Confirm server port ranges update', content)
+                elif method == 'POST':
+                    origin = urlsplit(environ.get('HTTP_ORIGIN', ''))
+                    if (origin.scheme != 'http' or origin.netloc != host or
+                            origin.path or origin.query or origin.fragment):
+                        raise ValueError('Invalid mutation origin')
+                    if environ.get('CONTENT_TYPE', '').split(';', 1)[0] != 'application/x-www-form-urlencoded':
+                        raise ValueError('Invalid mutation content type')
+                    length = int(environ.get('CONTENT_LENGTH', '-1'))
+                    if not 0 <= length <= 4096:
+                        raise ValueError('Invalid mutation body length')
+                    raw_body = environ['wsgi.input'].read(length)
+                    if len(raw_body) != length:
+                        raise ValueError('Incomplete mutation body')
+                    fields = parse_qs(raw_body.decode('utf-8', errors='strict'),
+                                      keep_blank_values=True, strict_parsing=True)
+                    if (set(fields) != {'csrf_token', 'confirm_server_id', 'ranges'} or
+                            any(len(values) != 1 for values in fields.values()) or
+                            not hmac.compare_digest(fields['csrf_token'][0], csrf_token) or
+                            fields['confirm_server_id'][0] != str(server)):
+                        raise ValueError('Invalid mutation confirmation')
+                    parts = fields['ranges'][0].split(',')
+                    if not 1 <= len(parts) <= 64:
+                        raise ValueError('Invalid server port ranges')
+                    ranges = []
+                    for part in parts:
+                        pair = part.strip().split(':')
+                        if len(pair) != 2 or any(not value.isascii() or not value.isdecimal() for value in pair):
+                            raise ValueError('Invalid server port ranges')
+                        first, last = map(int, pair)
+                        if not 1 <= first <= last <= 65535:
+                            raise ValueError('Invalid server port ranges')
+                        ranges.append((first, last))
+                    ordered = sorted(ranges)
+                    if any(left[1] >= right[0] for left, right in zip(ordered, ordered[1:])):
+                        raise ValueError('Overlapping server port ranges')
+                    async def update_ranges():
+                        async with client_factory() as client:
+                            return await client.update_server_port_ranges(cluster, server, ranges)
+                    result = asyncio.run(update_ranges())
+                    body = render_page('Verified server port ranges update', [result], '')
+                else:
+                    start_response('405 Method Not Allowed', [('Allow', 'GET, POST'),
+                                                              ('Content-Type', 'text/plain')])
+                    return [b'Method not allowed']
+            except (RacError, ValueError, OSError, TimeoutError, UnicodeError, RuntimeError):
+                start_response('403 Forbidden' if method == 'POST' else '503 Service Unavailable',
+                               [('Content-Type', 'text/plain; charset=utf-8'), ('Cache-Control', 'no-store'),
+                                ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')])
+                return [b'Server port ranges update not verified' if method == 'POST' else b'RAC unavailable']
+            start_response('200 OK', headers)
+            return [body.encode('utf-8')]
+        server_managers_update = re.fullmatch(
+            r'/clusters/([0-9a-fA-F-]{36})/servers/([0-9a-fA-F-]{36})/dedicate-managers', path)
+        if server_managers_update and allow_server_dedicate_managers_update:
+            headers = [('Content-Type', 'text/html; charset=utf-8'),
+                       ('Cache-Control', 'no-store'), ('X-Content-Type-Options', 'nosniff'),
+                       ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')]
+            try:
+                cluster, server = UUID(server_managers_update.group(1)), UUID(server_managers_update.group(2))
+                host = environ.get('HTTP_HOST', '')
+                if (host not in ('localhost', '127.0.0.1', '[::1]') and
+                        not re.fullmatch(r'(localhost|127\.0\.0\.1|\[::1\]):[0-9]{1,5}', host)):
+                    raise ValueError('Invalid mutation host')
+                if environ.get('REMOTE_ADDR') not in ('127.0.0.1', '::1'):
+                    raise ValueError('Mutation requires loopback peer')
+                if method == 'GET':
+                    async def server_info():
+                        async with client_factory() as client:
+                            return await client.get_server(cluster, server)
+                    row = asyncio.run(server_info())
+                    content = (render_section('Working server', [row], '') +
+                               f'<form method="post" action="{html.escape(path, quote=True)}">'
+                               f'<input type="hidden" name="csrf_token" value="{html.escape(csrf_token, quote=True)}">'
+                               '<label>Dedicated managers <select name="choice">'
+                               '<option value="none">none</option><option value="all">all</option>'
+                               '</select></label><label>Type exact server UUID to confirm '
+                               '<input name="confirm_server_id" required></label>'
+                               '<button type="submit">Update server dedicated managers</button></form>')
+                    body = render_document('Confirm server dedicated managers update', content)
+                elif method == 'POST':
+                    origin = urlsplit(environ.get('HTTP_ORIGIN', ''))
+                    if (origin.scheme != 'http' or origin.netloc != host or
+                            origin.path or origin.query or origin.fragment):
+                        raise ValueError('Invalid mutation origin')
+                    if environ.get('CONTENT_TYPE', '').split(';', 1)[0] != 'application/x-www-form-urlencoded':
+                        raise ValueError('Invalid mutation content type')
+                    length = int(environ.get('CONTENT_LENGTH', '-1'))
+                    if not 0 <= length <= 4096:
+                        raise ValueError('Invalid mutation body length')
+                    raw_body = environ['wsgi.input'].read(length)
+                    if len(raw_body) != length:
+                        raise ValueError('Incomplete mutation body')
+                    fields = parse_qs(raw_body.decode('utf-8', errors='strict'),
+                                      keep_blank_values=True, strict_parsing=True)
+                    if (set(fields) != {'csrf_token', 'confirm_server_id', 'choice'} or
+                            any(len(values) != 1 for values in fields.values()) or
+                            not hmac.compare_digest(fields['csrf_token'][0], csrf_token) or
+                            fields['confirm_server_id'][0] != str(server) or
+                            fields['choice'][0] not in ('all', 'none')):
+                        raise ValueError('Invalid mutation confirmation')
+                    choice = fields['choice'][0]
+                    async def update_managers():
+                        async with client_factory() as client:
+                            return await client.update_server_dedicate_managers(cluster, server, choice)
+                    result = asyncio.run(update_managers())
+                    body = render_page('Verified server dedicated managers update', [result], '')
+                else:
+                    start_response('405 Method Not Allowed', [('Allow', 'GET, POST'),
+                                                              ('Content-Type', 'text/plain')])
+                    return [b'Method not allowed']
+            except (RacError, ValueError, OSError, TimeoutError, UnicodeError, RuntimeError):
+                start_response('403 Forbidden' if method == 'POST' else '503 Service Unavailable',
+                               [('Content-Type', 'text/plain; charset=utf-8'), ('Cache-Control', 'no-store'),
+                                ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')])
+                return [b'Server dedicated managers update not verified' if method == 'POST' else b'RAC unavailable']
+            start_response('200 OK', headers)
+            return [body.encode('utf-8')]
+        server_spn_update = re.fullmatch(
+            r'/clusters/([0-9a-fA-F-]{36})/servers/([0-9a-fA-F-]{36})/spn', path)
+        if server_spn_update and allow_server_spn_update:
+            headers = [('Content-Type', 'text/html; charset=utf-8'),
+                       ('Cache-Control', 'no-store'), ('X-Content-Type-Options', 'nosniff'),
+                       ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')]
+            try:
+                cluster, server = UUID(server_spn_update.group(1)), UUID(server_spn_update.group(2))
+                host = environ.get('HTTP_HOST', '')
+                if (host not in ('localhost', '127.0.0.1', '[::1]') and
+                        not re.fullmatch(r'(localhost|127\.0\.0\.1|\[::1\]):[0-9]{1,5}', host)):
+                    raise ValueError('Invalid mutation host')
+                if environ.get('REMOTE_ADDR') not in ('127.0.0.1', '::1'):
+                    raise ValueError('Mutation requires loopback peer')
+                if method == 'GET':
+                    async def server_info():
+                        async with client_factory() as client:
+                            return await client.get_server(cluster, server)
+                    row = asyncio.run(server_info())
+                    content = (render_section('Working server', [row], '') +
+                               f'<form method="post" action="{html.escape(path, quote=True)}">'
+                               f'<input type="hidden" name="csrf_token" value="{html.escape(csrf_token, quote=True)}">'
+                               '<label>Service principal name (empty clears; max 256 UTF-8 bytes) '
+                               '<input name="name" maxlength="256"></label>'
+                               '<label>Type exact server UUID to confirm '
+                               '<input name="confirm_server_id" required></label>'
+                               '<button type="submit">Update server SPN</button></form>')
+                    body = render_document('Confirm server SPN update', content)
+                elif method == 'POST':
+                    origin = urlsplit(environ.get('HTTP_ORIGIN', ''))
+                    if (origin.scheme != 'http' or origin.netloc != host or
+                            origin.path or origin.query or origin.fragment):
+                        raise ValueError('Invalid mutation origin')
+                    if environ.get('CONTENT_TYPE', '').split(';', 1)[0] != 'application/x-www-form-urlencoded':
+                        raise ValueError('Invalid mutation content type')
+                    length = int(environ.get('CONTENT_LENGTH', '-1'))
+                    if not 0 <= length <= 4096:
+                        raise ValueError('Invalid mutation body length')
+                    raw_body = environ['wsgi.input'].read(length)
+                    if len(raw_body) != length:
+                        raise ValueError('Incomplete mutation body')
+                    fields = parse_qs(raw_body.decode('utf-8', errors='strict'),
+                                      keep_blank_values=True, strict_parsing=True)
+                    if (set(fields) != {'csrf_token', 'confirm_server_id', 'name'} or
+                            any(len(values) != 1 for values in fields.values()) or
+                            not hmac.compare_digest(fields['csrf_token'][0], csrf_token) or
+                            fields['confirm_server_id'][0] != str(server)):
+                        raise ValueError('Invalid mutation confirmation')
+                    name = fields['name'][0]
+                    if '\x00' in name or len(name.encode('utf-8')) > 256:
+                        raise ValueError('Invalid working-server SPN')
+                    async def update_spn():
+                        async with client_factory() as client:
+                            return await client.update_server_service_principal_name(cluster, server, name)
+                    result = asyncio.run(update_spn())
+                    body = render_page('Verified server SPN update', [result], '')
+                else:
+                    start_response('405 Method Not Allowed', [('Allow', 'GET, POST'),
+                                                              ('Content-Type', 'text/plain')])
+                    return [b'Method not allowed']
+            except (RacError, ValueError, OSError, TimeoutError, UnicodeError, RuntimeError):
+                start_response('403 Forbidden' if method == 'POST' else '503 Service Unavailable',
+                               [('Content-Type', 'text/plain; charset=utf-8'), ('Cache-Control', 'no-store'),
+                                ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')])
+                return [b'Server SPN update not verified' if method == 'POST' else b'RAC unavailable']
+            start_response('200 OK', headers)
+            return [body.encode('utf-8')]
+        server_limit_update = re.fullmatch(
+            r'/clusters/([0-9a-fA-F-]{36})/servers/([0-9a-fA-F-]{36})/(infobases-limit|connections-limit|safe-call-memory-limit|critical-total-memory|temporary-total-memory|temporary-memory-time-limit)', path)
+        if server_limit_update and ((server_limit_update.group(3) == 'infobases-limit' and
+                                    allow_server_infobases_limit_update) or
+                                   (server_limit_update.group(3) == 'connections-limit' and
+                                    allow_server_connections_limit_update) or
+                                   (server_limit_update.group(3) == 'safe-call-memory-limit' and
+                                    allow_server_safe_call_memory_limit_update) or
+                                   (server_limit_update.group(3) == 'critical-total-memory' and
+                                    allow_server_critical_total_memory_update) or
+                                   (server_limit_update.group(3) == 'temporary-total-memory' and
+                                    allow_server_temporary_total_memory_update) or
+                                   (server_limit_update.group(3) == 'temporary-memory-time-limit' and
+                                    allow_server_temporary_memory_time_limit_update)):
+            is_connections = server_limit_update.group(3) == 'connections-limit'
+            is_safe_call = server_limit_update.group(3) == 'safe-call-memory-limit'
+            is_critical = server_limit_update.group(3) == 'critical-total-memory'
+            is_temporary = server_limit_update.group(3) == 'temporary-total-memory'
+            is_temporary_time = server_limit_update.group(3) == 'temporary-memory-time-limit'
+            label = ('temporary memory time limit' if is_temporary_time else 'temporary allowed total memory'
+                     if is_temporary else 'critical total memory' if is_critical else 'safe-call memory'
+                     if is_safe_call else 'connections' if is_connections else 'infobases')
+            maximum = 2**63 - 1 if is_safe_call or is_critical or is_temporary or is_temporary_time else 2_147_483_647
+            suffix = '' if is_critical or is_temporary or is_temporary_time else ' limit'
+            headers = [('Content-Type', 'text/html; charset=utf-8'),
+                       ('Cache-Control', 'no-store'), ('X-Content-Type-Options', 'nosniff'),
+                       ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')]
+            try:
+                cluster, server = UUID(server_limit_update.group(1)), UUID(server_limit_update.group(2))
+                host = environ.get('HTTP_HOST', '')
+                if (host not in ('localhost', '127.0.0.1', '[::1]') and
+                        not re.fullmatch(r'(localhost|127\.0\.0\.1|\[::1\]):[0-9]{1,5}', host)):
+                    raise ValueError('Invalid mutation host')
+                if environ.get('REMOTE_ADDR') not in ('127.0.0.1', '::1'):
+                    raise ValueError('Mutation requires loopback peer')
+                if method == 'GET':
+                    async def server_limit_info():
+                        async with client_factory() as client:
+                            return await client.get_server(cluster, server)
+                    row = asyncio.run(server_limit_info())
+                    content = (render_section('Working server', [row], '') +
+                               f'<form method="post" action="{html.escape(path, quote=True)}">'
+                               f'<input type="hidden" name="csrf_token" value="{html.escape(csrf_token, quote=True)}">'
+                               f'<label>{label.capitalize()}{suffix} '
+                               f'<input name="limit" type="number" min="0" max="{maximum}" required></label>'
+                               '<label>Type exact server UUID to confirm '
+                               '<input name="confirm_server_id" required></label>'
+                               f'<button type="submit">Update server {label}{suffix}</button></form>')
+                    body = render_document(f'Confirm server {label}{suffix} update', content)
+                elif method == 'POST':
+                    origin = urlsplit(environ.get('HTTP_ORIGIN', ''))
+                    if (origin.scheme != 'http' or origin.netloc != host or
+                            origin.path or origin.query or origin.fragment):
+                        raise ValueError('Invalid mutation origin')
+                    if environ.get('CONTENT_TYPE', '').split(';', 1)[0] != 'application/x-www-form-urlencoded':
+                        raise ValueError('Invalid mutation content type')
+                    length = int(environ.get('CONTENT_LENGTH', '-1'))
+                    if not 0 <= length <= 4096:
+                        raise ValueError('Invalid mutation body length')
+                    raw_body = environ['wsgi.input'].read(length)
+                    if len(raw_body) != length:
+                        raise ValueError('Incomplete mutation body')
+                    fields = parse_qs(raw_body.decode('utf-8', errors='strict'),
+                                      keep_blank_values=True, strict_parsing=True)
+                    if (set(fields) != {'csrf_token', 'confirm_server_id', 'limit'} or
+                            any(len(values) != 1 for values in fields.values()) or
+                            not hmac.compare_digest(fields['csrf_token'][0], csrf_token) or
+                            fields['confirm_server_id'][0] != str(server) or
+                            not re.fullmatch(r'(0|[1-9][0-9]{0,18})' if is_safe_call or is_critical or is_temporary or is_temporary_time else
+                                             r'(0|[1-9][0-9]{0,9})', fields['limit'][0])):
+                        raise ValueError('Invalid mutation confirmation')
+                    limit = int(fields['limit'][0])
+                    if limit > maximum:
+                        raise ValueError('Invalid working-server limit')
+                    async def update_server_limit():
+                        async with client_factory() as client:
+                            if is_safe_call:
+                                return await client.update_server_safe_call_memory_limit(cluster, server, limit)
+                            if is_critical:
+                                return await client.update_server_critical_total_memory(cluster, server, limit)
+                            if is_temporary:
+                                return await client.update_server_temporary_allowed_total_memory(cluster, server, limit)
+                            if is_temporary_time:
+                                return await client.update_server_temporary_allowed_total_memory_time_limit(cluster, server, limit)
+                            if is_connections:
+                                return await client.update_server_connections_limit(cluster, server, limit)
+                            return await client.update_server_infobases_limit(cluster, server, limit)
+                    result = asyncio.run(update_server_limit())
+                    body = render_page(f'Verified server {label}{suffix} update', [result], '')
+                else:
+                    start_response('405 Method Not Allowed', [('Allow', 'GET, POST'),
+                                                              ('Content-Type', 'text/plain')])
+                    return [b'Method not allowed']
+            except (RacError, ValueError, OSError, TimeoutError, UnicodeError, RuntimeError):
+                start_response('403 Forbidden' if method == 'POST' else '503 Service Unavailable',
+                               [('Content-Type', 'text/plain; charset=utf-8'), ('Cache-Control', 'no-store'),
+                                ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')])
+                return [f'Server {label}{suffix} update not verified'.encode() if method == 'POST'
+                        else b'RAC unavailable']
+            start_response('200 OK', headers)
+            return [body.encode('utf-8')]
+        server_schedule_update = re.fullmatch(
+            r'/clusters/([0-9a-fA-F-]{36})/servers/([0-9a-fA-F-]{36})/restart-schedule', path)
+        if server_schedule_update and allow_server_restart_schedule_update:
+            headers = [('Content-Type', 'text/html; charset=utf-8'),
+                       ('Cache-Control', 'no-store'), ('X-Content-Type-Options', 'nosniff'),
+                       ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')]
+            try:
+                cluster, server = UUID(server_schedule_update.group(1)), UUID(server_schedule_update.group(2))
+                host = environ.get('HTTP_HOST', '')
+                if (host not in ('localhost', '127.0.0.1', '[::1]') and
+                        not re.fullmatch(r'(localhost|127\.0\.0\.1|\[::1\]):[0-9]{1,5}', host)):
+                    raise ValueError('Invalid mutation host')
+                if environ.get('REMOTE_ADDR') not in ('127.0.0.1', '::1'):
+                    raise ValueError('Mutation requires loopback peer')
+                if method == 'GET':
+                    async def server_schedule_info():
+                        async with client_factory() as client:
+                            return await client.get_server(cluster, server)
+                    row = asyncio.run(server_schedule_info())
+                    content = (render_section('Working server', [row], '') +
+                               f'<form method="post" action="{html.escape(path, quote=True)}">'
+                               f'<input type="hidden" name="csrf_token" value="{html.escape(csrf_token, quote=True)}">'
+                               '<label>Restart schedule (empty clears) '
+                               '<input name="schedule" maxlength="256"></label>'
+                               '<label>Type exact server UUID to confirm '
+                               '<input name="confirm_server_id" required></label>'
+                               '<button type="submit">Update server restart schedule</button></form>')
+                    body = render_document('Confirm server restart schedule update', content)
+                elif method == 'POST':
+                    origin = urlsplit(environ.get('HTTP_ORIGIN', ''))
+                    if (origin.scheme != 'http' or origin.netloc != host or
+                            origin.path or origin.query or origin.fragment):
+                        raise ValueError('Invalid mutation origin')
+                    if environ.get('CONTENT_TYPE', '').split(';', 1)[0] != 'application/x-www-form-urlencoded':
+                        raise ValueError('Invalid mutation content type')
+                    length = int(environ.get('CONTENT_LENGTH', '-1'))
+                    if not 0 <= length <= 4096:
+                        raise ValueError('Invalid mutation body length')
+                    raw_body = environ['wsgi.input'].read(length)
+                    if len(raw_body) != length:
+                        raise ValueError('Incomplete mutation body')
+                    fields = parse_qs(raw_body.decode('utf-8', errors='strict'),
+                                      keep_blank_values=True, strict_parsing=True)
+                    if (set(fields) != {'csrf_token', 'confirm_server_id', 'schedule'} or
+                            any(len(values) != 1 for values in fields.values()) or
+                            not hmac.compare_digest(fields['csrf_token'][0], csrf_token) or
+                            fields['confirm_server_id'][0] != str(server)):
+                        raise ValueError('Invalid mutation confirmation')
+                    schedule = fields['schedule'][0]
+                    RacClient._validate_schedule(schedule)
+                    async def update_server_schedule():
+                        async with client_factory() as client:
+                            return await client.update_server_restart_schedule(cluster, server, schedule)
+                    result = asyncio.run(update_server_schedule())
+                    body = render_page('Verified server restart schedule update', [result], '')
+                else:
+                    start_response('405 Method Not Allowed', [('Allow', 'GET, POST'),
+                                                              ('Content-Type', 'text/plain')])
+                    return [b'Method not allowed']
+            except (RacError, ValueError, OSError, TimeoutError, UnicodeError, RuntimeError):
+                start_response('403 Forbidden' if method == 'POST' else '503 Service Unavailable',
+                               [('Content-Type', 'text/plain; charset=utf-8'), ('Cache-Control', 'no-store'),
+                                ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')])
+                return [b'Server restart schedule update not verified' if method == 'POST' else b'RAC unavailable']
+            start_response('200 OK', headers)
+            return [body.encode('utf-8')]
+        schedule_update = re.fullmatch(r'/clusters/([0-9a-fA-F-]{36})/restart-schedule', path)
+        if schedule_update and allow_cluster_restart_schedule_update:
+            headers = [('Content-Type', 'text/html; charset=utf-8'),
+                       ('Cache-Control', 'no-store'), ('X-Content-Type-Options', 'nosniff'),
+                       ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')]
+            try:
+                cluster = UUID(schedule_update.group(1))
+                host = environ.get('HTTP_HOST', '')
+                if (host not in ('localhost', '127.0.0.1', '[::1]') and
+                        not re.fullmatch(r'(localhost|127\.0\.0\.1|\[::1\]):[0-9]{1,5}', host)):
+                    raise ValueError('Invalid mutation host')
+                if environ.get('REMOTE_ADDR') not in ('127.0.0.1', '::1'):
+                    raise ValueError('Mutation requires loopback peer')
+                if method == 'GET':
+                    async def schedule_info():
+                        async with client_factory() as client:
+                            return await client.get_cluster(cluster)
+                    row = asyncio.run(schedule_info())
+                    content = (render_section('Cluster', [row], '') +
+                               f'<form method="post" action="{html.escape(path, quote=True)}">'
+                               f'<input type="hidden" name="csrf_token" value="{html.escape(csrf_token, quote=True)}">'
+                               '<label>Restart schedule (empty clears) '
+                               '<input name="schedule" maxlength="256"></label>'
+                               '<label>Type exact cluster UUID to confirm '
+                               '<input name="confirm_cluster_id" required></label>'
+                               '<button type="submit">Update cluster restart schedule</button></form>')
+                    body = render_document('Confirm cluster restart schedule update', content)
+                elif method == 'POST':
+                    origin = urlsplit(environ.get('HTTP_ORIGIN', ''))
+                    if (origin.scheme != 'http' or origin.netloc != host or
+                            origin.path or origin.query or origin.fragment):
+                        raise ValueError('Invalid mutation origin')
+                    if environ.get('CONTENT_TYPE', '').split(';', 1)[0] != 'application/x-www-form-urlencoded':
+                        raise ValueError('Invalid mutation content type')
+                    length = int(environ.get('CONTENT_LENGTH', '-1'))
+                    if not 0 <= length <= 4096:
+                        raise ValueError('Invalid mutation body length')
+                    raw_body = environ['wsgi.input'].read(length)
+                    if len(raw_body) != length:
+                        raise ValueError('Incomplete mutation body')
+                    fields = parse_qs(raw_body.decode('utf-8', errors='strict'),
+                                      keep_blank_values=True, strict_parsing=True)
+                    if (set(fields) != {'csrf_token', 'confirm_cluster_id', 'schedule'} or
+                            any(len(values) != 1 for values in fields.values()) or
+                            not hmac.compare_digest(fields['csrf_token'][0], csrf_token) or
+                            fields['confirm_cluster_id'][0] != str(cluster)):
+                        raise ValueError('Invalid mutation confirmation')
+                    schedule = fields['schedule'][0]
+                    RacClient._validate_schedule(schedule)
+                    async def update_schedule():
+                        async with client_factory() as client:
+                            return await client.update_restart_schedule(cluster, schedule)
+                    result = asyncio.run(update_schedule())
+                    body = render_page('Verified cluster restart schedule update', [result], '')
+                else:
+                    start_response('405 Method Not Allowed', [('Allow', 'GET, POST'),
+                                                              ('Content-Type', 'text/plain')])
+                    return [b'Method not allowed']
+            except (RacError, ValueError, OSError, TimeoutError, UnicodeError, RuntimeError):
+                start_response('403 Forbidden' if method == 'POST' else '503 Service Unavailable',
+                               [('Content-Type', 'text/plain; charset=utf-8'), ('Cache-Control', 'no-store'),
+                                ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')])
+                return [b'Cluster restart schedule update not verified' if method == 'POST' else b'RAC unavailable']
+            start_response('200 OK', headers)
+            return [body.encode('utf-8')]
+        ping_update = re.fullmatch(r'/clusters/([0-9a-fA-F-]{36})/ping', path)
+        if ping_update and allow_cluster_ping_update:
+            headers = [('Content-Type', 'text/html; charset=utf-8'),
+                       ('Cache-Control', 'no-store'), ('X-Content-Type-Options', 'nosniff'),
+                       ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')]
+            try:
+                cluster = UUID(ping_update.group(1))
+                host = environ.get('HTTP_HOST', '')
+                if (host not in ('localhost', '127.0.0.1', '[::1]') and
+                        not re.fullmatch(r'(localhost|127\.0\.0\.1|\[::1\]):[0-9]{1,5}', host)):
+                    raise ValueError('Invalid mutation host')
+                if environ.get('REMOTE_ADDR') not in ('127.0.0.1', '::1'):
+                    raise ValueError('Mutation requires loopback peer')
+                if method == 'GET':
+                    async def ping_info():
+                        async with client_factory() as client:
+                            return await client.get_cluster(cluster)
+                    row = asyncio.run(ping_info())
+                    content = (render_section('Cluster', [row], '') +
+                               f'<form method="post" action="{html.escape(path, quote=True)}">'
+                               f'<input type="hidden" name="csrf_token" value="{html.escape(csrf_token, quote=True)}">'
+                               '<label>Ping period <input name="period" type="number" min="0" '
+                               'max="2147483647" required></label>'
+                               '<label>Ping timeout <input name="timeout" type="number" min="0" '
+                               'max="2147483647" required></label>'
+                               '<label>Type exact cluster UUID to confirm '
+                               '<input name="confirm_cluster_id" required></label>'
+                               '<button type="submit">Update cluster ping</button></form>')
+                    body = render_document('Confirm cluster ping update', content)
+                elif method == 'POST':
+                    origin = urlsplit(environ.get('HTTP_ORIGIN', ''))
+                    if (origin.scheme != 'http' or origin.netloc != host or
+                            origin.path or origin.query or origin.fragment):
+                        raise ValueError('Invalid mutation origin')
+                    if environ.get('CONTENT_TYPE', '').split(';', 1)[0] != 'application/x-www-form-urlencoded':
+                        raise ValueError('Invalid mutation content type')
+                    length = int(environ.get('CONTENT_LENGTH', '-1'))
+                    if not 0 <= length <= 4096:
+                        raise ValueError('Invalid mutation body length')
+                    raw_body = environ['wsgi.input'].read(length)
+                    if len(raw_body) != length:
+                        raise ValueError('Incomplete mutation body')
+                    fields = parse_qs(raw_body.decode('utf-8', errors='strict'),
+                                      keep_blank_values=True, strict_parsing=True)
+                    if (set(fields) != {'csrf_token', 'confirm_cluster_id', 'period', 'timeout'} or
+                            any(len(values) != 1 for values in fields.values()) or
+                            not hmac.compare_digest(fields['csrf_token'][0], csrf_token) or
+                            fields['confirm_cluster_id'][0] != str(cluster) or
+                            not re.fullmatch(r'(0|[1-9][0-9]{0,9})', fields['period'][0]) or
+                            not re.fullmatch(r'(0|[1-9][0-9]{0,9})', fields['timeout'][0])):
+                        raise ValueError('Invalid mutation confirmation')
+                    period, timeout = int(fields['period'][0]), int(fields['timeout'][0])
+                    if not ((period == 0 and timeout == 0) or
+                            (0 < period < timeout <= 2_147_483_647)):
+                        raise ValueError('Invalid cluster ping period/timeout pair')
+                    async def update_ping():
+                        async with client_factory() as client:
+                            return await client.update_cluster_ping(cluster, period, timeout)
+                    result = asyncio.run(update_ping())
+                    body = render_page('Verified cluster ping update', [result], '')
+                else:
+                    start_response('405 Method Not Allowed', [('Allow', 'GET, POST'),
+                                                              ('Content-Type', 'text/plain')])
+                    return [b'Method not allowed']
+            except (RacError, ValueError, OSError, TimeoutError, UnicodeError, RuntimeError):
+                start_response('403 Forbidden' if method == 'POST' else '503 Service Unavailable',
+                               [('Content-Type', 'text/plain; charset=utf-8'), ('Cache-Control', 'no-store'),
+                                ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')])
+                return [b'Cluster ping update not verified' if method == 'POST' else b'RAC unavailable']
+            start_response('200 OK', headers)
+            return [body.encode('utf-8')]
+        audit_update = re.fullmatch(r'/clusters/([0-9a-fA-F-]{36})/audit', path)
+        if audit_update and allow_cluster_audit_update:
+            headers = [('Content-Type', 'text/html; charset=utf-8'),
+                       ('Cache-Control', 'no-store'), ('X-Content-Type-Options', 'nosniff'),
+                       ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')]
+            try:
+                cluster = UUID(audit_update.group(1))
+                host = environ.get('HTTP_HOST', '')
+                if (host not in ('localhost', '127.0.0.1', '[::1]') and
+                        not re.fullmatch(r'(localhost|127\.0\.0\.1|\[::1\]):[0-9]{1,5}', host)):
+                    raise ValueError('Invalid mutation host')
+                if environ.get('REMOTE_ADDR') not in ('127.0.0.1', '::1'):
+                    raise ValueError('Mutation requires loopback peer')
+                if method == 'GET':
+                    async def audit_info():
+                        async with client_factory() as client:
+                            return await client.get_cluster(cluster)
+                    row = asyncio.run(audit_info())
+                    content = (render_section('Cluster', [row], '') +
+                               f'<form method="post" action="{html.escape(path, quote=True)}">'
+                               f'<input type="hidden" name="csrf_token" value="{html.escape(csrf_token, quote=True)}">'
+                               '<label>Access-right audit recording <select name="enabled">'
+                               '<option value="on">on</option><option value="off">off</option></select></label>'
+                               '<label>Type exact cluster UUID to confirm '
+                               '<input name="confirm_cluster_id" required></label>'
+                               '<button type="submit">Update cluster audit</button></form>')
+                    body = render_document('Confirm cluster audit update', content)
+                elif method == 'POST':
+                    origin = urlsplit(environ.get('HTTP_ORIGIN', ''))
+                    if (origin.scheme != 'http' or origin.netloc != host or
+                            origin.path or origin.query or origin.fragment):
+                        raise ValueError('Invalid mutation origin')
+                    if environ.get('CONTENT_TYPE', '').split(';', 1)[0] != 'application/x-www-form-urlencoded':
+                        raise ValueError('Invalid mutation content type')
+                    length = int(environ.get('CONTENT_LENGTH', '-1'))
+                    if not 0 <= length <= 4096:
+                        raise ValueError('Invalid mutation body length')
+                    raw_body = environ['wsgi.input'].read(length)
+                    if len(raw_body) != length:
+                        raise ValueError('Incomplete mutation body')
+                    fields = parse_qs(raw_body.decode('utf-8', errors='strict'),
+                                      keep_blank_values=True, strict_parsing=True)
+                    if (set(fields) != {'csrf_token', 'confirm_cluster_id', 'enabled'} or
+                            any(len(values) != 1 for values in fields.values()) or
+                            not hmac.compare_digest(fields['csrf_token'][0], csrf_token) or
+                            fields['confirm_cluster_id'][0] != str(cluster) or
+                            fields['enabled'][0] not in ('on', 'off')):
+                        raise ValueError('Invalid mutation confirmation')
+                    async def update_audit():
+                        async with client_factory() as client:
+                            return await client.update_cluster_audit(cluster, fields['enabled'][0] == 'on')
+                    result = asyncio.run(update_audit())
+                    body = render_page('Verified cluster audit update', [result], '')
+                else:
+                    start_response('405 Method Not Allowed', [('Allow', 'GET, POST'),
+                                                              ('Content-Type', 'text/plain')])
+                    return [b'Method not allowed']
+            except (RacError, ValueError, OSError, TimeoutError, UnicodeError, RuntimeError):
+                start_response('403 Forbidden' if method == 'POST' else '503 Service Unavailable',
+                               [('Content-Type', 'text/plain; charset=utf-8'), ('Cache-Control', 'no-store'),
+                                ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')])
+                return [b'Cluster audit update not verified' if method == 'POST' else b'RAC unavailable']
+            start_response('200 OK', headers)
+            return [body.encode('utf-8')]
+        memory_update = re.fullmatch(r'/clusters/([0-9a-fA-F-]{36})/kill-by-memory-with-dump', path)
+        if memory_update and allow_cluster_kill_by_memory_with_dump_update:
+            headers = [('Content-Type', 'text/html; charset=utf-8'),
+                       ('Cache-Control', 'no-store'), ('X-Content-Type-Options', 'nosniff'),
+                       ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')]
+            try:
+                cluster = UUID(memory_update.group(1))
+                host = environ.get('HTTP_HOST', '')
+                if (host not in ('localhost', '127.0.0.1', '[::1]') and
+                        not re.fullmatch(r'(localhost|127\.0\.0\.1|\[::1\]):[0-9]{1,5}', host)):
+                    raise ValueError('Invalid mutation host')
+                if environ.get('REMOTE_ADDR') not in ('127.0.0.1', '::1'):
+                    raise ValueError('Mutation requires loopback peer')
+                if method == 'GET':
+                    async def memory_info():
+                        async with client_factory() as client:
+                            return await client.get_cluster(cluster)
+                    row = asyncio.run(memory_info())
+                    content = (render_section('Cluster', [row], '') +
+                               f'<form method="post" action="{html.escape(path, quote=True)}">'
+                               f'<input type="hidden" name="csrf_token" value="{html.escape(csrf_token, quote=True)}">'
+                               '<label>Kill by memory with dump <select name="enabled">'
+                               '<option value="on">on</option><option value="off">off</option></select></label>'
+                               '<label>Type exact cluster UUID to confirm '
+                               '<input name="confirm_cluster_id" required></label>'
+                               '<button type="submit">Update cluster kill-by-memory dump</button></form>')
+                    body = render_document('Confirm cluster kill-by-memory dump update', content)
+                elif method == 'POST':
+                    origin = urlsplit(environ.get('HTTP_ORIGIN', ''))
+                    if (origin.scheme != 'http' or origin.netloc != host or
+                            origin.path or origin.query or origin.fragment):
+                        raise ValueError('Invalid mutation origin')
+                    if environ.get('CONTENT_TYPE', '').split(';', 1)[0] != 'application/x-www-form-urlencoded':
+                        raise ValueError('Invalid mutation content type')
+                    length = int(environ.get('CONTENT_LENGTH', '-1'))
+                    if not 0 <= length <= 4096:
+                        raise ValueError('Invalid mutation body length')
+                    raw_body = environ['wsgi.input'].read(length)
+                    if len(raw_body) != length:
+                        raise ValueError('Incomplete mutation body')
+                    fields = parse_qs(raw_body.decode('utf-8', errors='strict'),
+                                      keep_blank_values=True, strict_parsing=True)
+                    if (set(fields) != {'csrf_token', 'confirm_cluster_id', 'enabled'} or
+                            any(len(values) != 1 for values in fields.values()) or
+                            not hmac.compare_digest(fields['csrf_token'][0], csrf_token) or
+                            fields['confirm_cluster_id'][0] != str(cluster) or
+                            fields['enabled'][0] not in ('on', 'off')):
+                        raise ValueError('Invalid mutation confirmation')
+                    async def update_memory():
+                        async with client_factory() as client:
+                            return await client.update_cluster_kill_by_memory_with_dump(
+                                cluster, fields['enabled'][0] == 'on')
+                    result = asyncio.run(update_memory())
+                    body = render_page('Verified cluster kill-by-memory dump update', [result], '')
+                else:
+                    start_response('405 Method Not Allowed', [('Allow', 'GET, POST'),
+                                                              ('Content-Type', 'text/plain')])
+                    return [b'Method not allowed']
+            except (RacError, ValueError, OSError, TimeoutError, UnicodeError, RuntimeError):
+                start_response('403 Forbidden' if method == 'POST' else '503 Service Unavailable',
+                               [('Content-Type', 'text/plain; charset=utf-8'), ('Cache-Control', 'no-store'),
+                                ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')])
+                return [b'Cluster kill-by-memory dump update not verified'
+                        if method == 'POST' else b'RAC unavailable']
+            start_response('200 OK', headers)
+            return [body.encode('utf-8')]
+        kill_policy_update = re.fullmatch(r'/clusters/([0-9a-fA-F-]{36})/kill-problem-processes', path)
+        if kill_policy_update and allow_cluster_kill_problem_processes_update:
+            headers = [('Content-Type', 'text/html; charset=utf-8'),
+                       ('Cache-Control', 'no-store'), ('X-Content-Type-Options', 'nosniff'),
+                       ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')]
+            try:
+                cluster = UUID(kill_policy_update.group(1))
+                host = environ.get('HTTP_HOST', '')
+                if (host not in ('localhost', '127.0.0.1', '[::1]') and
+                        not re.fullmatch(r'(localhost|127\.0\.0\.1|\[::1\]):[0-9]{1,5}', host)):
+                    raise ValueError('Invalid mutation host')
+                if environ.get('REMOTE_ADDR') not in ('127.0.0.1', '::1'):
+                    raise ValueError('Mutation requires loopback peer')
+                if method == 'GET':
+                    async def policy_info():
+                        async with client_factory() as client:
+                            return await client.get_cluster(cluster)
+                    row = asyncio.run(policy_info())
+                    content = (render_section('Cluster', [row], '') +
+                               f'<form method="post" action="{html.escape(path, quote=True)}">'
+                               f'<input type="hidden" name="csrf_token" value="{html.escape(csrf_token, quote=True)}">'
+                               '<label>Terminate problem processes <select name="enabled">'
+                               '<option value="on">on</option><option value="off">off</option></select></label>'
+                               '<label>Type exact cluster UUID to confirm '
+                               '<input name="confirm_cluster_id" required></label>'
+                               '<button type="submit">Update cluster problem-process policy</button></form>')
+                    body = render_document('Confirm cluster problem-process policy update', content)
+                elif method == 'POST':
+                    origin = urlsplit(environ.get('HTTP_ORIGIN', ''))
+                    if (origin.scheme != 'http' or origin.netloc != host or
+                            origin.path or origin.query or origin.fragment):
+                        raise ValueError('Invalid mutation origin')
+                    if environ.get('CONTENT_TYPE', '').split(';', 1)[0] != 'application/x-www-form-urlencoded':
+                        raise ValueError('Invalid mutation content type')
+                    length = int(environ.get('CONTENT_LENGTH', '-1'))
+                    if not 0 <= length <= 4096:
+                        raise ValueError('Invalid mutation body length')
+                    raw_body = environ['wsgi.input'].read(length)
+                    if len(raw_body) != length:
+                        raise ValueError('Incomplete mutation body')
+                    fields = parse_qs(raw_body.decode('utf-8', errors='strict'),
+                                      keep_blank_values=True, strict_parsing=True)
+                    if (set(fields) != {'csrf_token', 'confirm_cluster_id', 'enabled'} or
+                            any(len(values) != 1 for values in fields.values()) or
+                            not hmac.compare_digest(fields['csrf_token'][0], csrf_token) or
+                            fields['confirm_cluster_id'][0] != str(cluster) or
+                            fields['enabled'][0] not in ('on', 'off')):
+                        raise ValueError('Invalid mutation confirmation')
+                    async def update_policy():
+                        async with client_factory() as client:
+                            return await client.update_cluster_kill_problem_processes(
+                                cluster, fields['enabled'][0] == 'on')
+                    result = asyncio.run(update_policy())
+                    body = render_page('Verified cluster problem-process policy update', [result], '')
+                else:
+                    start_response('405 Method Not Allowed', [('Allow', 'GET, POST'),
+                                                              ('Content-Type', 'text/plain')])
+                    return [b'Method not allowed']
+            except (RacError, ValueError, OSError, TimeoutError, UnicodeError, RuntimeError):
+                start_response('403 Forbidden' if method == 'POST' else '503 Service Unavailable',
+                               [('Content-Type', 'text/plain; charset=utf-8'), ('Cache-Control', 'no-store'),
+                                ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')])
+                return [b'Cluster problem-process policy update not verified'
+                        if method == 'POST' else b'RAC unavailable']
+            start_response('200 OK', headers)
+            return [body.encode('utf-8')]
+        balancing_update = re.fullmatch(r'/clusters/([0-9a-fA-F-]{36})/load-balancing-mode', path)
+        if balancing_update and allow_cluster_load_balancing_mode_update:
+            headers = [('Content-Type', 'text/html; charset=utf-8'),
+                       ('Cache-Control', 'no-store'), ('X-Content-Type-Options', 'nosniff'),
+                       ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')]
+            try:
+                cluster = UUID(balancing_update.group(1))
+                host = environ.get('HTTP_HOST', '')
+                if (host not in ('localhost', '127.0.0.1', '[::1]') and
+                        not re.fullmatch(r'(localhost|127\.0\.0\.1|\[::1\]):[0-9]{1,5}', host)):
+                    raise ValueError('Invalid mutation host')
+                if environ.get('REMOTE_ADDR') not in ('127.0.0.1', '::1'):
+                    raise ValueError('Mutation requires loopback peer')
+                if method == 'GET':
+                    async def balancing_info():
+                        async with client_factory() as client:
+                            return await client.get_cluster(cluster)
+                    row = asyncio.run(balancing_info())
+                    content = (render_section('Cluster', [row], '') +
+                               f'<form method="post" action="{html.escape(path, quote=True)}">'
+                               f'<input type="hidden" name="csrf_token" value="{html.escape(csrf_token, quote=True)}">'
+                               '<label>Load balancing mode <select name="mode">'
+                               '<option value="performance">performance</option>'
+                               '<option value="memory">memory</option></select></label>'
+                               '<label>Type exact cluster UUID to confirm '
+                               '<input name="confirm_cluster_id" required></label>'
+                               '<button type="submit">Update cluster load balancing mode</button></form>')
+                    body = render_document('Confirm cluster load balancing mode update', content)
+                elif method == 'POST':
+                    origin = urlsplit(environ.get('HTTP_ORIGIN', ''))
+                    if (origin.scheme != 'http' or origin.netloc != host or
+                            origin.path or origin.query or origin.fragment):
+                        raise ValueError('Invalid mutation origin')
+                    if environ.get('CONTENT_TYPE', '').split(';', 1)[0] != 'application/x-www-form-urlencoded':
+                        raise ValueError('Invalid mutation content type')
+                    length = int(environ.get('CONTENT_LENGTH', '-1'))
+                    if not 0 <= length <= 4096:
+                        raise ValueError('Invalid mutation body length')
+                    raw_body = environ['wsgi.input'].read(length)
+                    if len(raw_body) != length:
+                        raise ValueError('Incomplete mutation body')
+                    fields = parse_qs(raw_body.decode('utf-8', errors='strict'),
+                                      keep_blank_values=True, strict_parsing=True)
+                    if (set(fields) != {'csrf_token', 'confirm_cluster_id', 'mode'} or
+                            any(len(values) != 1 for values in fields.values()) or
+                            not hmac.compare_digest(fields['csrf_token'][0], csrf_token) or
+                            fields['confirm_cluster_id'][0] != str(cluster) or
+                            fields['mode'][0] not in ('performance', 'memory')):
+                        raise ValueError('Invalid mutation confirmation')
+                    async def update_balancing():
+                        async with client_factory() as client:
+                            return await client.update_cluster_load_balancing_mode(cluster, fields['mode'][0])
+                    result = asyncio.run(update_balancing())
+                    body = render_page('Verified cluster load balancing mode update', [result], '')
+                else:
+                    start_response('405 Method Not Allowed', [('Allow', 'GET, POST'),
+                                                              ('Content-Type', 'text/plain')])
+                    return [b'Method not allowed']
+            except (RacError, ValueError, OSError, TimeoutError, UnicodeError, RuntimeError):
+                start_response('403 Forbidden' if method == 'POST' else '503 Service Unavailable',
+                               [('Content-Type', 'text/plain; charset=utf-8'), ('Cache-Control', 'no-store'),
+                                ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')])
+                return [b'Cluster load balancing mode update not verified'
+                        if method == 'POST' else b'RAC unavailable']
+            start_response('200 OK', headers)
+            return [body.encode('utf-8')]
+        fault_tolerance_update = re.fullmatch(
+            r'/clusters/([0-9a-fA-F-]{36})/session-fault-tolerance-level', path)
+        if fault_tolerance_update and allow_cluster_session_fault_tolerance_level_update:
+            headers = [('Content-Type', 'text/html; charset=utf-8'),
+                       ('Cache-Control', 'no-store'), ('X-Content-Type-Options', 'nosniff'),
+                       ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')]
+            try:
+                cluster = UUID(fault_tolerance_update.group(1))
+                host = environ.get('HTTP_HOST', '')
+                if (host not in ('localhost', '127.0.0.1', '[::1]') and
+                        not re.fullmatch(r'(localhost|127\.0\.0\.1|\[::1\]):[0-9]{1,5}', host)):
+                    raise ValueError('Invalid mutation host')
+                if environ.get('REMOTE_ADDR') not in ('127.0.0.1', '::1'):
+                    raise ValueError('Mutation requires loopback peer')
+                if method == 'GET':
+                    async def fault_tolerance_info():
+                        async with client_factory() as client:
+                            return await client.get_cluster(cluster)
+                    row = asyncio.run(fault_tolerance_info())
+                    content = (render_section('Cluster', [row], '') +
+                               f'<form method="post" action="{html.escape(path, quote=True)}">'
+                               f'<input type="hidden" name="csrf_token" value="{html.escape(csrf_token, quote=True)}">'
+                               '<label>Session fault tolerance level '
+                               '<input name="level" type="number" min="0" max="2147483647" required></label>'
+                               '<label>Type exact cluster UUID to confirm '
+                               '<input name="confirm_cluster_id" required></label>'
+                               '<button type="submit">Update cluster session fault tolerance level</button></form>')
+                    body = render_document('Confirm cluster session fault tolerance level update', content)
+                elif method == 'POST':
+                    origin = urlsplit(environ.get('HTTP_ORIGIN', ''))
+                    if (origin.scheme != 'http' or origin.netloc != host or
+                            origin.path or origin.query or origin.fragment):
+                        raise ValueError('Invalid mutation origin')
+                    if environ.get('CONTENT_TYPE', '').split(';', 1)[0] != 'application/x-www-form-urlencoded':
+                        raise ValueError('Invalid mutation content type')
+                    length = int(environ.get('CONTENT_LENGTH', '-1'))
+                    if not 0 <= length <= 4096:
+                        raise ValueError('Invalid mutation body length')
+                    raw_body = environ['wsgi.input'].read(length)
+                    if len(raw_body) != length:
+                        raise ValueError('Incomplete mutation body')
+                    fields = parse_qs(raw_body.decode('utf-8', errors='strict'),
+                                      keep_blank_values=True, strict_parsing=True)
+                    if (set(fields) != {'csrf_token', 'confirm_cluster_id', 'level'} or
+                            any(len(values) != 1 for values in fields.values()) or
+                            not hmac.compare_digest(fields['csrf_token'][0], csrf_token) or
+                            fields['confirm_cluster_id'][0] != str(cluster) or
+                            not re.fullmatch(r'(0|[1-9][0-9]{0,9})', fields['level'][0])):
+                        raise ValueError('Invalid mutation confirmation')
+                    level = int(fields['level'][0])
+                    if level > 2_147_483_647:
+                        raise ValueError('Invalid cluster session fault tolerance level')
+                    async def update_fault_tolerance():
+                        async with client_factory() as client:
+                            return await client.update_cluster_session_fault_tolerance_level(cluster, level)
+                    result = asyncio.run(update_fault_tolerance())
+                    body = render_page('Verified cluster session fault tolerance level update', [result], '')
+                else:
+                    start_response('405 Method Not Allowed', [('Allow', 'GET, POST'),
+                                                              ('Content-Type', 'text/plain')])
+                    return [b'Method not allowed']
+            except (RacError, ValueError, OSError, TimeoutError, UnicodeError, RuntimeError):
+                start_response('403 Forbidden' if method == 'POST' else '503 Service Unavailable',
+                               [('Content-Type', 'text/plain; charset=utf-8'), ('Cache-Control', 'no-store'),
+                                ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')])
+                return [b'Cluster session fault tolerance update not verified'
+                        if method == 'POST' else b'RAC unavailable']
+            start_response('200 OK', headers)
+            return [body.encode('utf-8')]
+        security_update = re.fullmatch(r'/clusters/([0-9a-fA-F-]{36})/security-level', path)
+        if security_update and allow_cluster_security_level_update:
+            headers = [('Content-Type', 'text/html; charset=utf-8'),
+                       ('Cache-Control', 'no-store'), ('X-Content-Type-Options', 'nosniff'),
+                       ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')]
+            try:
+                cluster = UUID(security_update.group(1))
+                host = environ.get('HTTP_HOST', '')
+                if (host not in ('localhost', '127.0.0.1', '[::1]') and
+                        not re.fullmatch(r'(localhost|127\.0\.0\.1|\[::1\]):[0-9]{1,5}', host)):
+                    raise ValueError('Invalid mutation host')
+                if environ.get('REMOTE_ADDR') not in ('127.0.0.1', '::1'):
+                    raise ValueError('Mutation requires loopback peer')
+                if method == 'GET':
+                    async def security_info():
+                        async with client_factory() as client:
+                            return await client.get_cluster(cluster)
+                    row = asyncio.run(security_info())
+                    content = (render_section('Cluster', [row], '') +
+                               f'<form method="post" action="{html.escape(path, quote=True)}">'
+                               f'<input type="hidden" name="csrf_token" value="{html.escape(csrf_token, quote=True)}">'
+                               '<label>Security level '
+                               '<input name="level" type="number" min="0" max="2147483647" required></label>'
+                               '<label>Type exact cluster UUID to confirm '
+                               '<input name="confirm_cluster_id" required></label>'
+                               '<button type="submit">Update cluster security level</button></form>')
+                    body = render_document('Confirm cluster security level update', content)
+                elif method == 'POST':
+                    origin = urlsplit(environ.get('HTTP_ORIGIN', ''))
+                    if (origin.scheme != 'http' or origin.netloc != host or
+                            origin.path or origin.query or origin.fragment):
+                        raise ValueError('Invalid mutation origin')
+                    if environ.get('CONTENT_TYPE', '').split(';', 1)[0] != 'application/x-www-form-urlencoded':
+                        raise ValueError('Invalid mutation content type')
+                    length = int(environ.get('CONTENT_LENGTH', '-1'))
+                    if not 0 <= length <= 4096:
+                        raise ValueError('Invalid mutation body length')
+                    raw_body = environ['wsgi.input'].read(length)
+                    if len(raw_body) != length:
+                        raise ValueError('Incomplete mutation body')
+                    fields = parse_qs(raw_body.decode('utf-8', errors='strict'),
+                                      keep_blank_values=True, strict_parsing=True)
+                    if (set(fields) != {'csrf_token', 'confirm_cluster_id', 'level'} or
+                            any(len(values) != 1 for values in fields.values()) or
+                            not hmac.compare_digest(fields['csrf_token'][0], csrf_token) or
+                            fields['confirm_cluster_id'][0] != str(cluster) or
+                            not re.fullmatch(r'(0|[1-9][0-9]{0,9})', fields['level'][0])):
+                        raise ValueError('Invalid mutation confirmation')
+                    level = int(fields['level'][0])
+                    if level > 2_147_483_647:
+                        raise ValueError('Invalid cluster security level')
+                    async def update_security():
+                        async with client_factory() as client:
+                            return await client.update_cluster_security_level(cluster, level)
+                    result = asyncio.run(update_security())
+                    body = render_page('Verified cluster security level update', [result], '')
+                else:
+                    start_response('405 Method Not Allowed', [('Allow', 'GET, POST'),
+                                                              ('Content-Type', 'text/plain')])
+                    return [b'Method not allowed']
+            except (RacError, ValueError, OSError, TimeoutError, UnicodeError, RuntimeError):
+                start_response('403 Forbidden' if method == 'POST' else '503 Service Unavailable',
+                               [('Content-Type', 'text/plain; charset=utf-8'), ('Cache-Control', 'no-store'),
+                                ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')])
+                return [b'Cluster security level update not verified'
+                        if method == 'POST' else b'RAC unavailable']
+            start_response('200 OK', headers)
+            return [body.encode('utf-8')]
+        timeout_update = re.fullmatch(r'/clusters/([0-9a-fA-F-]{36})/expiration-timeout', path)
+        if timeout_update and allow_cluster_expiration_timeout_update:
+            headers = [('Content-Type', 'text/html; charset=utf-8'),
+                       ('Cache-Control', 'no-store'), ('X-Content-Type-Options', 'nosniff'),
+                       ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')]
+            try:
+                cluster = UUID(timeout_update.group(1))
+                host = environ.get('HTTP_HOST', '')
+                if (host not in ('localhost', '127.0.0.1', '[::1]') and
+                        not re.fullmatch(r'(localhost|127\.0\.0\.1|\[::1\]):[0-9]{1,5}', host)):
+                    raise ValueError('Invalid mutation host')
+                if environ.get('REMOTE_ADDR') not in ('127.0.0.1', '::1'):
+                    raise ValueError('Mutation requires loopback peer')
+                if method == 'GET':
+                    async def timeout_info():
+                        async with client_factory() as client:
+                            return await client.get_cluster(cluster)
+                    row = asyncio.run(timeout_info())
+                    content = (render_section('Cluster', [row], '') +
+                               f'<form method="post" action="{html.escape(path, quote=True)}">'
+                               f'<input type="hidden" name="csrf_token" value="{html.escape(csrf_token, quote=True)}">'
+                               '<label>Expiration timeout (seconds) '
+                               '<input name="seconds" type="number" min="0" max="2147483647" required></label>'
+                               '<label>Type exact cluster UUID to confirm '
+                               '<input name="confirm_cluster_id" required></label>'
+                               '<button type="submit">Update cluster expiration timeout</button></form>')
+                    body = render_document('Confirm cluster expiration timeout update', content)
+                elif method == 'POST':
+                    origin = urlsplit(environ.get('HTTP_ORIGIN', ''))
+                    if (origin.scheme != 'http' or origin.netloc != host or
+                            origin.path or origin.query or origin.fragment):
+                        raise ValueError('Invalid mutation origin')
+                    if environ.get('CONTENT_TYPE', '').split(';', 1)[0] != 'application/x-www-form-urlencoded':
+                        raise ValueError('Invalid mutation content type')
+                    length = int(environ.get('CONTENT_LENGTH', '-1'))
+                    if not 0 <= length <= 4096:
+                        raise ValueError('Invalid mutation body length')
+                    raw_body = environ['wsgi.input'].read(length)
+                    if len(raw_body) != length:
+                        raise ValueError('Incomplete mutation body')
+                    fields = parse_qs(raw_body.decode('utf-8', errors='strict'),
+                                      keep_blank_values=True, strict_parsing=True)
+                    if (set(fields) != {'csrf_token', 'confirm_cluster_id', 'seconds'} or
+                            any(len(values) != 1 for values in fields.values()) or
+                            not hmac.compare_digest(fields['csrf_token'][0], csrf_token) or
+                            fields['confirm_cluster_id'][0] != str(cluster) or
+                            not re.fullmatch(r'(0|[1-9][0-9]{0,9})', fields['seconds'][0])):
+                        raise ValueError('Invalid mutation confirmation')
+                    seconds = int(fields['seconds'][0])
+                    if seconds > 2_147_483_647:
+                        raise ValueError('Invalid cluster expiration timeout')
+                    async def update_timeout():
+                        async with client_factory() as client:
+                            return await client.update_cluster_expiration_timeout(cluster, seconds)
+                    result = asyncio.run(update_timeout())
+                    body = render_page('Verified cluster expiration timeout update', [result], '')
+                else:
+                    start_response('405 Method Not Allowed', [('Allow', 'GET, POST'),
+                                                              ('Content-Type', 'text/plain')])
+                    return [b'Method not allowed']
+            except (RacError, ValueError, OSError, TimeoutError, UnicodeError, RuntimeError):
+                start_response('403 Forbidden' if method == 'POST' else '503 Service Unavailable',
+                               [('Content-Type', 'text/plain; charset=utf-8'), ('Cache-Control', 'no-store'),
+                                ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')])
+                return [b'Cluster expiration timeout update not verified'
+                        if method == 'POST' else b'RAC unavailable']
+            start_response('200 OK', headers)
+            return [body.encode('utf-8')]
+        rename = re.fullmatch(r'/clusters/([0-9a-fA-F-]{36})/rename', path)
+        if rename and allow_cluster_name_update:
+            headers = [('Content-Type', 'text/html; charset=utf-8'),
+                       ('Cache-Control', 'no-store'), ('X-Content-Type-Options', 'nosniff'),
+                       ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')]
+            try:
+                cluster = UUID(rename.group(1))
+                host = environ.get('HTTP_HOST', '')
+                if (host not in ('localhost', '127.0.0.1', '[::1]') and
+                        not re.fullmatch(r'(localhost|127\.0\.0\.1|\[::1\]):[0-9]{1,5}', host)):
+                    raise ValueError('Invalid mutation host')
+                if environ.get('REMOTE_ADDR') not in ('127.0.0.1', '::1'):
+                    raise ValueError('Mutation requires loopback peer')
+                if method == 'GET':
+                    async def info():
+                        async with client_factory() as client:
+                            return await client.get_cluster(cluster)
+                    row = asyncio.run(info())
+                    content = (render_section('Cluster', [row], '') +
+                               f'<form method="post" action="{html.escape(path, quote=True)}">'
+                               f'<input type="hidden" name="csrf_token" value="{html.escape(csrf_token, quote=True)}">'
+                               '<label>New name <input name="name"></label>'
+                               '<label>Type exact cluster UUID to confirm '
+                               '<input name="confirm_cluster_id" required></label>'
+                               '<button type="submit">Rename cluster</button></form>')
+                    body = render_document('Confirm cluster name update', content)
+                elif method == 'POST':
+                    origin = urlsplit(environ.get('HTTP_ORIGIN', ''))
+                    if (origin.scheme != 'http' or origin.netloc != host or
+                            origin.path or origin.query or origin.fragment):
+                        raise ValueError('Invalid mutation origin')
+                    if environ.get('CONTENT_TYPE', '').split(';', 1)[0] != 'application/x-www-form-urlencoded':
+                        raise ValueError('Invalid mutation content type')
+                    length = int(environ.get('CONTENT_LENGTH', '-1'))
+                    if not 0 <= length <= 4096:
+                        raise ValueError('Invalid mutation body length')
+                    raw_body = environ['wsgi.input'].read(length)
+                    if len(raw_body) != length:
+                        raise ValueError('Incomplete mutation body')
+                    fields = parse_qs(raw_body.decode('utf-8', errors='strict'),
+                                      keep_blank_values=True, strict_parsing=True)
+                    if (set(fields) != {'csrf_token', 'confirm_cluster_id', 'name'} or
+                            any(len(values) != 1 for values in fields.values()) or
+                            not hmac.compare_digest(fields['csrf_token'][0], csrf_token) or
+                            fields['confirm_cluster_id'][0] != str(cluster)):
+                        raise ValueError('Invalid mutation confirmation')
+                    name = fields['name'][0]
+                    if (name and not name.strip()) or '\x00' in name or len(name.encode('utf-8')) > 256:
+                        raise ValueError('Invalid cluster name')
+                    async def update():
+                        async with client_factory() as client:
+                            return await client.update_cluster_name(cluster, name)
+                    result = asyncio.run(update())
+                    body = render_page('Verified cluster name update', [result], '')
+                else:
+                    start_response('405 Method Not Allowed', [('Allow', 'GET, POST'),
+                                                              ('Content-Type', 'text/plain')])
+                    return [b'Method not allowed']
+            except (RacError, ValueError, OSError, TimeoutError, UnicodeError, RuntimeError):
+                start_response('403 Forbidden' if method == 'POST' else '503 Service Unavailable',
+                               [('Content-Type', 'text/plain; charset=utf-8'), ('Cache-Control', 'no-store'),
+                                ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')])
+                return [b'Cluster name update not verified' if method == 'POST' else b'RAC unavailable']
+            start_response('200 OK', headers)
+            return [body.encode('utf-8')]
+        mutation = re.fullmatch(
+            r'/clusters/([0-9a-fA-F-]{36})/processes/([0-9a-fA-F-]{36})/turn-off', path)
+        if mutation and allow_process_turn_off:
+            headers = [('Content-Type', 'text/html; charset=utf-8'),
+                       ('Cache-Control', 'no-store'), ('X-Content-Type-Options', 'nosniff'),
+                       ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')]
+            try:
+                cluster, process = (UUID(part) for part in mutation.groups())
+                # A token-bearing GET must not leak to a nonlocal peer or an
+                # arbitrary Host header (DNS rebinding / cross-origin framing).
+                host = environ.get('HTTP_HOST', '')
+                if (host not in ('localhost', '127.0.0.1', '[::1]') and
+                        not re.fullmatch(r'(localhost|127\.0\.0\.1|\[::1\]):[0-9]{1,5}', host)):
+                    raise ValueError('Invalid mutation host')
+                if environ.get('REMOTE_ADDR') not in ('127.0.0.1', '::1'):
+                    raise ValueError('Mutation requires loopback peer')
+                if method == 'GET':
+                    async def info():
+                        return await ReadService(client_factory).process(cluster, process)
+                    row = asyncio.run(info())
+                    content = (render_section('Working process', [row], '') +
+                               f'<form method="post" action="{html.escape(path, quote=True)}">'
+                               f'<input type="hidden" name="csrf_token" value="{html.escape(csrf_token, quote=True)}">'
+                               '<label>Type exact process UUID to confirm '
+                               '<input name="confirm_process_id" required></label>'
+                               '<button type="submit">Turn off process</button></form>')
+                    body = render_document('Confirm process turn-off', content)
+                elif method == 'POST':
+                    # Host is untrusted: only known loopback names/ports, an exact
+                    # same-origin Origin header and a loopback peer may submit.
+                    origin = urlsplit(environ.get('HTTP_ORIGIN', ''))
+                    if (origin.scheme != 'http' or origin.netloc != host or
+                            origin.path or origin.query or origin.fragment):
+                        raise ValueError('Invalid mutation origin')
+                    if environ.get('CONTENT_TYPE', '').split(';', 1)[0] != 'application/x-www-form-urlencoded':
+                        raise ValueError('Invalid mutation content type')
+                    length = int(environ.get('CONTENT_LENGTH', '-1'))
+                    if not 0 <= length <= 4096:
+                        raise ValueError('Invalid mutation body length')
+                    raw_body = environ['wsgi.input'].read(length)
+                    if len(raw_body) != length:
+                        raise ValueError('Incomplete mutation body')
+                    payload = raw_body.decode('utf-8', errors='strict')
+                    fields = parse_qs(payload, keep_blank_values=True, strict_parsing=True)
+                    if (set(fields) != {'csrf_token', 'confirm_process_id'} or
+                            any(len(values) != 1 for values in fields.values()) or
+                            not hmac.compare_digest(fields['csrf_token'][0], csrf_token) or
+                            fields['confirm_process_id'][0] != str(process)):
+                        raise ValueError('Invalid mutation confirmation')
+                    async def turn_off():
+                        async with client_factory() as client:
+                            return await client.turn_off_process(cluster, process)
+                    rows = asyncio.run(turn_off())
+                    body = render_page('Verified process turn-off', rows, '')
+                else:
+                    start_response('405 Method Not Allowed', [('Allow', 'GET, POST'),
+                                                              ('Content-Type', 'text/plain')])
+                    return [b'Method not allowed']
+            except (RacError, ValueError, OSError, TimeoutError, UnicodeError, RuntimeError):
+                start_response('403 Forbidden' if method == 'POST' else '503 Service Unavailable',
+                               [('Content-Type', 'text/plain; charset=utf-8'), ('Cache-Control', 'no-store'),
+                                ('Referrer-Policy', 'no-referrer'), ('X-Frame-Options', 'DENY')])
+                return [b'Process turn-off not verified' if method == 'POST' else b'RAC unavailable']
+            start_response('200 OK', headers)
+            return [body.encode('utf-8')]
+        if method != 'GET':
+            start_response('405 Method Not Allowed', [('Allow', 'GET'), ('Content-Type', 'text/plain')])
+            return [b'Method not allowed']
+        async def collect():
+            service = ReadService(client_factory)
+            if path in ('/', '/clusters'):
+                page = render_section('Clusters', await service.clusters(), '/clusters',
+                                      allow_cluster_remove=allow_cluster_remove)
+                if allow_cluster_insert:
+                    page = '<nav><a href="/clusters/insert">Insert cluster</a></nav>' + page
+                return render_document('Clusters', page)
+            if path == '/agent/version':
+                version = await service.agent_version()
+                return render_document('Agent version',
+                                       '<section><h1>Agent version</h1><p>' +
+                                       html.escape(str(version)) + '</p></section>')
+            if path == '/agent/admins':
+                navigation = ('<nav><a href="/agent/admins/register">Register administrator</a></nav>'
+                              if allow_agent_admin_register else '')
+                rows = await service.agent_admins()
+                return render_document('Agent administrators', navigation +
+                                       render_section('Agent administrators', rows, '/agent/admins',
+                                                      allow_admin_remove=allow_agent_admin_remove))
+            match = re.fullmatch(r'/clusters/([0-9a-fA-F-]{36})/infobases/info-by-name', path)
+            if match:
+                raw_query = environ.get('QUERY_STRING', '')
+                if len(raw_query) > 4096:
+                    raise ValueError('Infobase lookup query too long')
+                parameters = parse_qs(raw_query, keep_blank_values=True, strict_parsing=True)
+                if set(parameters) != {'name'} or len(parameters['name']) != 1:
+                    raise ValueError('Invalid infobase lookup query')
+                row = await service.infobase_info_by_name(match.group(1), parameters['name'][0])
+                cluster, infobase = UUID(match.group(1)), UUID(str(row['infobase']))
+                navigation = (f'<nav><a href="/clusters/{cluster}/infobases/{infobase}/info">'
+                              'Infobase full info</a></nav>')
+                return render_document('Infobase full info by name', navigation +
+                                       render_section('Infobase full info by name', [row], ''))
+            match = re.fullmatch(r'/clusters/([0-9a-fA-F-]{36})/infobases/by-name', path)
+            if match:
+                raw_query = environ.get('QUERY_STRING', '')
+                if len(raw_query) > 4096:
+                    raise ValueError('Infobase lookup query too long')
+                parameters = parse_qs(raw_query, keep_blank_values=True, strict_parsing=True)
+                if set(parameters) != {'name'} or len(parameters['name']) != 1:
+                    raise ValueError('Invalid infobase lookup query')
+                row = await service.infobase_summary_by_name(match.group(1), parameters['name'][0])
+                cluster, infobase = UUID(match.group(1)), UUID(str(row['infobase']))
+                navigation = (f'<nav><a href="/clusters/{cluster}/infobases/{infobase}/summary">'
+                              'Infobase summary</a></nav>')
+                return render_document('Infobase by name', navigation +
+                                       render_section('Infobase by name', [row], ''))
+            match = re.fullmatch(r'/clusters/([0-9a-fA-F-]{36})/info', path)
+            if match:
+                row = await service.one(match.group(1), 'get_cluster')
+                navigation = (f'<nav><a href="/clusters/{UUID(match.group(1))}/rename">'
+                              'Rename cluster…</a></nav>' if allow_cluster_name_update else '')
+                if allow_rule_apply:
+                    navigation += (f'<nav><a href="/clusters/{UUID(match.group(1))}/rules/apply">'
+                                   'Apply assignment rules…</a></nav>')
+                if allow_cluster_expiration_timeout_update:
+                    navigation += (f'<nav><a href="/clusters/{UUID(match.group(1))}/expiration-timeout">'
+                                   'Update cluster expiration timeout…</a></nav>')
+                if allow_cluster_security_level_update:
+                    navigation += (f'<nav><a href="/clusters/{UUID(match.group(1))}/security-level">'
+                                   'Update cluster security level…</a></nav>')
+                if allow_cluster_session_fault_tolerance_level_update:
+                    navigation += (f'<nav><a href="/clusters/{UUID(match.group(1))}/session-fault-tolerance-level">'
+                                   'Update cluster session fault tolerance level…</a></nav>')
+                if allow_cluster_load_balancing_mode_update:
+                    navigation += (f'<nav><a href="/clusters/{UUID(match.group(1))}/load-balancing-mode">'
+                                   'Update cluster load balancing mode…</a></nav>')
+                if allow_cluster_kill_problem_processes_update:
+                    navigation += (f'<nav><a href="/clusters/{UUID(match.group(1))}/kill-problem-processes">'
+                                   'Update cluster problem-process policy…</a></nav>')
+                if allow_cluster_kill_by_memory_with_dump_update:
+                    navigation += (f'<nav><a href="/clusters/{UUID(match.group(1))}/kill-by-memory-with-dump">'
+                                   'Update cluster kill-by-memory dump…</a></nav>')
+                if allow_cluster_audit_update:
+                    navigation += (f'<nav><a href="/clusters/{UUID(match.group(1))}/audit">'
+                                   'Update cluster access-right audit recording…</a></nav>')
+                if allow_cluster_ping_update:
+                    navigation += (f'<nav><a href="/clusters/{UUID(match.group(1))}/ping">'
+                                   'Update cluster ping pair…</a></nav>')
+                if allow_cluster_restart_schedule_update:
+                    navigation += (f'<nav><a href="/clusters/{UUID(match.group(1))}/restart-schedule">'
+                                   'Update cluster restart schedule…</a></nav>')
+                return render_document('Cluster info', navigation + render_section('Cluster info', [row], ''))
+            match = re.fullmatch(
+                r'/clusters/([0-9a-fA-F-]{36})/admins', path)
+            if match:
+                navigation = (f'<nav><a href="/clusters/{UUID(match.group(1))}/admins/register">'
+                              'Register administrator</a></nav>' if allow_cluster_admin_register else '')
+                rows = await service.cluster_admins(match.group(1))
+                return render_document('Cluster administrators', navigation +
+                                       render_section('Cluster administrators', rows, path,
+                                                      allow_admin_remove=allow_cluster_admin_remove))
+            match = re.fullmatch(r'/clusters/([0-9a-fA-F-]{36})/profiles/overview', path)
+            if match:
+                raw_query = environ.get('QUERY_STRING', '')
+                if len(raw_query) > 4096:
+                    raise ValueError('Profile overview query too long')
+                parameters = parse_qs(raw_query, keep_blank_values=True, strict_parsing=True)
+                if set(parameters) != {'name'} or len(parameters['name']) != 1:
+                    raise ValueError('Invalid profile overview query')
+                result = await service.profile_overview(match.group(1), parameters['name'][0])
+                content = render_section('Security profile', [result['profile']], '')
+                content += ''.join(render_section(kind.title() + ' ACL', rows, '')
+                                   for kind, rows in result['acl'].items())
+                return render_document('Security profile overview', content)
+            match = re.fullmatch(r'/clusters/([0-9a-fA-F-]{36})/profiles/by-name', path)
+            if match:
+                raw_query = environ.get('QUERY_STRING', '')
+                if len(raw_query) > 4096:
+                    raise ValueError('Profile lookup query too long')
+                parameters = parse_qs(raw_query, keep_blank_values=True, strict_parsing=True)
+                if set(parameters) != {'name'} or len(parameters['name']) != 1:
+                    raise ValueError('Invalid profile lookup query')
+                row = await service.profile_by_name(match.group(1), parameters['name'][0])
+                cluster = UUID(match.group(1))
+                navigation = '<nav>' + ''.join(
+                    f'<a href="/clusters/{cluster}/profiles/{quote(row["name"], safe="")}/acl/{kind}">'
+                    f'{html.escape(kind.title())}</a> ' for kind in PROFILE_ACL_LISTS) + '</nav>'
+                return render_document('Security profile', navigation +
+                                       render_section('Security profile', [row], ''))
+            match = re.fullmatch(
+                r'/clusters/([0-9a-fA-F-]{36})/profiles/([^/]+)/acl/([a-z]+)', path)
+            if match:
+                kind = match.group(3)
+                if kind not in PROFILE_ACL_LISTS:
+                    return None
+                raw_query = environ.get('QUERY_STRING', '')
+                if len(raw_query) > 4096:
+                    raise InvalidAclQuery('ACL query too long')
+                try:
+                    parameters = (parse_qs(raw_query, keep_blank_values=True, strict_parsing=True)
+                                  if raw_query else {})
+                except ValueError as exc:
+                    raise InvalidAclQuery('Invalid ACL query') from exc
+                if set(parameters) - {'name'} or len(parameters.get('name', [''])) != 1:
+                    raise InvalidAclQuery('Invalid ACL query')
+                name = parameters.get('name', [''])[0]
+                if '\x00' in name or len(name.encode('utf-8')) > 1024:
+                    raise InvalidAclQuery('Invalid ACL name')
+                rows = await service.list_profile_acl(match.group(1), unquote(match.group(2)),
+                                                      kind, name)
+                form = ('<form method="get"><label>ACL name '
+                        f'<input name="name" value="{html.escape(name, quote=True)}">'
+                        '</label><button type="submit">Filter</button></form>')
+                return render_document(kind.title() + ' ACL', form +
+                                       render_section(kind.title() + ' ACL', rows, ''))
+            match = re.fullmatch(
+                r'/clusters/([0-9a-fA-F-]{36})/servers/([0-9a-fA-F-]{36})/processes', path)
+            if match:
+                cluster, server = (UUID(value) for value in match.groups())
+                rows = await service.processes_on_server(cluster, server)
+                return render_document('Server processes',
+                                       render_section('Server processes', rows, path))
+            match = re.fullmatch(
+                r'/clusters/([0-9a-fA-F-]{36})/servers/([0-9a-fA-F-]{36})', path)
+            if match:
+                row = await service.server(match.group(1), match.group(2))
+                cluster_id, server_id = (UUID(value) for value in match.groups())
+                navigation = (f'<nav><a href="/clusters/{cluster_id}/servers/{server_id}/processes">'
+                              'Processes</a></nav><nav>' + ''.join(
+                    f'<a href="/clusters/{cluster_id}/servers/{server_id}/{kind}">'
+                    f'{html.escape(kind.title())}</a> '
+                    for kind in SERVER_LISTS) + '</nav>')
+                if allow_server_restart_schedule_update:
+                    navigation += (f'<nav><a href="/clusters/{cluster_id}/servers/{server_id}/restart-schedule">'
+                                   'Update server restart schedule…</a></nav>')
+                if allow_server_infobases_limit_update:
+                    navigation += (f'<nav><a href="/clusters/{cluster_id}/servers/{server_id}/infobases-limit">'
+                                   'Update server infobases limit…</a></nav>')
+                if allow_server_connections_limit_update:
+                    navigation += (f'<nav><a href="/clusters/{cluster_id}/servers/{server_id}/connections-limit">'
+                                   'Update server connections limit…</a></nav>')
+                if allow_server_safe_call_memory_limit_update:
+                    navigation += (f'<nav><a href="/clusters/{cluster_id}/servers/{server_id}/safe-call-memory-limit">'
+                                   'Update server safe-call memory limit…</a></nav>')
+                if allow_server_critical_total_memory_update:
+                    navigation += (f'<nav><a href="/clusters/{cluster_id}/servers/{server_id}/critical-total-memory">'
+                                   'Update server critical total memory…</a></nav>')
+                if allow_server_temporary_total_memory_update:
+                    navigation += (f'<nav><a href="/clusters/{cluster_id}/servers/{server_id}/temporary-total-memory">'
+                                   'Update server temporary allowed total memory…</a></nav>')
+                if allow_server_temporary_memory_time_limit_update:
+                    navigation += (f'<nav><a href="/clusters/{cluster_id}/servers/{server_id}/temporary-memory-time-limit">'
+                                   'Update server temporary memory time limit…</a></nav>')
+                if allow_server_spn_update:
+                    navigation += (f'<nav><a href="/clusters/{cluster_id}/servers/{server_id}/spn">'
+                                   'Update server SPN…</a></nav>')
+                if allow_server_dedicate_managers_update:
+                    navigation += (f'<nav><a href="/clusters/{cluster_id}/servers/{server_id}/dedicate-managers">'
+                                   'Update server dedicated managers…</a></nav>')
+                if allow_server_port_ranges_update:
+                    navigation += (f'<nav><a href="/clusters/{cluster_id}/servers/{server_id}/port-ranges">'
+                                   'Update server port ranges…</a></nav>')
+                return render_document('Working server', navigation +
+                                       render_section('Working server', [row], ''))
+            match = re.fullmatch(
+                r'/clusters/([0-9a-fA-F-]{36})/processes/([0-9a-fA-F-]{36})', path)
+            if match:
+                row = await service.process(match.group(1), match.group(2))
+                cluster_id, process_id = (UUID(value) for value in match.groups())
+                navigation = (f'<nav><a href="/clusters/{cluster_id}/processes/{process_id}/connections">'
+                              'Connections</a></nav>')
+                if allow_process_turn_off:
+                    navigation += (f'<nav><a href="/clusters/{cluster_id}/processes/{process_id}/turn-off">'
+                                   'Turn off process…</a></nav>')
+                return render_document('Working process', navigation +
+                                       render_section('Working process', [row], ''))
+            match = re.fullmatch(
+                r'/clusters/([0-9a-fA-F-]{36})/sessions/([0-9a-fA-F-]{36})', path)
+            if match:
+                row = await service.session(match.group(1), match.group(2))
+                return render_page('Session', [row], '')
+            match = re.fullmatch(
+                r'/clusters/([0-9a-fA-F-]{36})/connections/([0-9a-fA-F-]{36})', path)
+            if match:
+                row = await service.connection(match.group(1), match.group(2))
+                cluster_id, connection_id = (UUID(value) for value in match.groups())
+                navigation = (f'<nav><a href="/clusters/{cluster_id}/connections/{connection_id}/locks">'
+                              'Locks</a></nav>')
+                return render_document('Connection', navigation +
+                                       render_section('Connection', [row], ''))
+            match = re.fullmatch(
+                r'/clusters/([0-9a-fA-F-]{36})/managers/([0-9a-fA-F-]{36})', path)
+            if match:
+                row = await service.manager(match.group(1), match.group(2))
+                return render_page('Manager', [row], '')
+            match = re.fullmatch(
+                r'/clusters/([0-9a-fA-F-]{36})/limits/([^/]+)', path)
+            if match:
+                row = await service.limit(match.group(1), unquote(match.group(2)))
+                return render_page('Limit', [row], '')
+            match = re.fullmatch(
+                r'/clusters/([0-9a-fA-F-]{36})/counters/([^/]+)/(values|accumulated-values)', path)
+            if match:
+                raw_query = environ.get('QUERY_STRING', '')
+                if len(raw_query) > 12288:
+                    raise ValueError('Counter query too long')
+                parameters = parse_qs(raw_query, keep_blank_values=True, strict_parsing=True)
+                if set(parameters) - {'object_filter'} or len(parameters.get('object_filter', [''])) != 1:
+                    raise ValueError('Invalid counter query')
+                object_filter = parameters.get('object_filter', [''])[0]
+                rows = await service.counter_values(match.group(1), unquote(match.group(2)), object_filter,
+                                                    accumulated=match.group(3) == 'accumulated-values')
+                form = ('<form method="get"><label>Object filter '
+                        f'<input name="object_filter" value="{html.escape(object_filter, quote=True)}">'
+                        '</label><button type="submit">Filter</button></form>')
+                return render_document('Counter ' + match.group(3), form +
+                                       render_section('Counter ' + match.group(3), rows, ''))
+            match = re.fullmatch(
+                r'/clusters/([0-9a-fA-F-]{36})/counters/([^/]+)', path)
+            if match:
+                row = await service.counter(match.group(1), unquote(match.group(2)))
+                base = f'/clusters/{UUID(match.group(1))}/counters/{quote(unquote(match.group(2)), safe="")}'
+                navigation = '<nav>' + ''.join(
+                    f'<a href="{base}/{kind}">{html.escape(kind.title())}</a> '
+                    for kind in ('values', 'accumulated-values')) + '</nav>'
+                return render_document('Counter', navigation + render_section('Counter', [row], ''))
+            match = re.fullmatch(
+                r'/clusters/([0-9a-fA-F-]{36})/(infobases|connections)/([0-9a-fA-F-]{36})/locks', path)
+            if match:
+                scope = {'infobases': 'infobase', 'connections': 'connection'}[match.group(2)]
+                rows = await service.filtered_locks(match.group(1), scope, match.group(3))
+                return render_page(scope.title() + ' locks', rows, '')
+            match = re.fullmatch(
+                r'/clusters/([0-9a-fA-F-]{36})/processes/([0-9a-fA-F-]{36})/connections', path)
+            if match:
+                rows = await service.connections_in_process(*match.groups())
+                return render_document('Process connections',
+                                       render_section('Process connections', rows, path))
+            match = re.fullmatch(
+                r'/clusters/([0-9a-fA-F-]{36})/infobases/([0-9a-fA-F-]{36})/connections', path)
+            if match:
+                rows = await service.connections_in_infobase(*match.groups())
+                return render_document('Infobase connections',
+                                       render_section('Infobase connections', rows, path))
+            match = re.fullmatch(
+                r'/clusters/([0-9a-fA-F-]{36})/infobases/([0-9a-fA-F-]{36})/sessions', path)
+            if match:
+                cluster = UUID(match.group(1))
+                rows = await service.sessions_in_infobase(*match.groups())
+                return render_document('Infobase sessions',
+                                       render_section('Infobase sessions', rows,
+                                                      f'/clusters/{cluster}/sessions'))
+            match = re.fullmatch(
+                r'/clusters/([0-9a-fA-F-]{36})/infobases/([0-9a-fA-F-]{36})/summary', path)
+            if match:
+                row = await service.infobase_summary(match.group(1), match.group(2))
+                cluster_id, infobase_id = (UUID(value) for value in match.groups())
+                base = f'/clusters/{cluster_id}/infobases/{infobase_id}'
+                navigation = '<nav>' + ''.join(
+                    f'<a href="{base}/{kind}">{html.escape(kind.title())}</a> '
+                    for kind in ('info', 'binary-storages', 'sessions', 'connections', 'locks')) + '</nav>'
+                return render_document('Infobase summary', navigation +
+                                       render_section('Infobase summary', [row], ''))
+            match = re.fullmatch(
+                r'/clusters/([0-9a-fA-F-]{36})/infobases/([0-9a-fA-F-]{36})/info', path)
+            if match:
+                row = await service.infobase_info(match.group(1), match.group(2))
+                return render_page('Infobase full info', [row], '')
+            match = re.fullmatch(
+                r'/clusters/([0-9a-fA-F-]{36})/infobases/([0-9a-fA-F-]{36})/binary-storages', path)
+            if match:
+                rows = await service.binary_storages(match.group(1), match.group(2))
+                return render_page('Binary data storages', rows, '')
+            match = re.fullmatch(
+                r'/clusters/([0-9a-fA-F-]{36})/servers/([0-9a-fA-F-]{36})/rules/([0-9a-fA-F-]{36})', path)
+            if match:
+                row = await service.rule(*match.groups())
+                return render_page('Assignment rule', [row], '')
+            match = re.fullmatch(
+                r'/clusters/([0-9a-fA-F-]{36})/servers/([0-9a-fA-F-]{36})/service-settings/([0-9a-fA-F-]{36})', path)
+            if match:
+                row = await service.service_setting(*match.groups())
+                return render_page('Service setting', [row], '')
+            match = re.fullmatch(
+                r'/clusters/([0-9a-fA-F-]{36})/servers/([0-9a-fA-F-]{36})/([a-z-]+)', path)
+            if match:
+                group = match.group(3)
+                if group not in SERVER_LISTS:
+                    return None
+                if group == 'transfer-directories':
+                    raw_query = environ.get('QUERY_STRING', '')
+                    if len(raw_query) > 4096:
+                        raise ValueError('Transfer query too long')
+                    parameters = parse_qs(raw_query, keep_blank_values=True, strict_parsing=True)
+                    if (set(parameters) - {'service_name'}
+                            or len(parameters.get('service_name', [''])) != 1):
+                        raise ValueError('Invalid transfer query')
+                    service_name = parameters.get('service_name', [''])[0]
+                    rows = await service.transfer_directories(match.group(1), match.group(2), service_name)
+                    form = ('<form method="get"><label>Service name '
+                            f'<input name="service_name" value="{html.escape(service_name, quote=True)}">'
+                            '</label><button type="submit">Filter</button></form>')
+                    return render_document('Transfer directories', form +
+                                           render_section('Transfer directories', rows, ''))
+                rows = await service.list_server_group(match.group(1), match.group(2), group)
+                if group == 'rules':
+                    return render_page('Rules', rows, path)
+                if group == 'service-settings':
+                    return render_page('Service settings', rows, path)
+                return render_page(group.title(), rows, '')
+            match = re.fullmatch(r'/clusters/([0-9a-fA-F-]{36})/([a-z-]+)', path)
+            if match:
+                group = match.group(2)
+                if group not in CLUSTER_LISTS:
+                    return None
+                ident = UUID(match.group(1))
+                rows = await service.list_group(ident, group)
+                if group == 'profiles':
+                    form = (f'<form action="/clusters/{ident}/profiles/by-name" method="get">'
+                            '<label>Profile name <input name="name"></label>'
+                            '<button type="submit">Find profile</button></form>'
+                            f'<form action="/clusters/{ident}/profiles/overview" method="get">'
+                            '<label>Profile name <input name="name"></label>'
+                            '<button type="submit">Find overview</button></form>')
+                    return render_document('Profiles', form +
+                                           render_section('Profiles', rows, f'/clusters/{ident}/profiles'))
+                if group == 'infobases':
+                    form = (f'<form action="/clusters/{ident}/infobases/by-name" method="get">'
+                            '<label>Infobase name <input name="name"></label>'
+                            '<button type="submit">Find summary</button></form>'
+                            f'<form action="/clusters/{ident}/infobases/info-by-name" method="get">'
+                            '<label>Infobase name <input name="name"></label>'
+                            '<button type="submit">Find full info</button></form>')
+                    return render_document('Infobases', form +
+                                           render_section('Infobases', rows,
+                                                          f'/clusters/{ident}/infobases'))
+                if group == 'servers':
+                    return render_document('Servers', render_section('Servers', rows,
+                                           f'/clusters/{ident}/servers'))
+                if group == 'processes':
+                    return render_document('Processes', render_section('Processes', rows,
+                                           f'/clusters/{ident}/processes'))
+                if group == 'sessions':
+                    return render_document('Sessions',
+                                           render_section('Sessions', rows,
+                                                          f'/clusters/{ident}/sessions'))
+                if group == 'connections':
+                    return render_page('Connections', rows, path)
+                if group == 'managers':
+                    return render_page('Managers', rows, path)
+                if group == 'limits':
+                    return render_page('Limits', rows, path)
+                if group == 'counters':
+                    return render_page('Counters', rows, path)
+                return render_page(group.title(), rows, '')
+            match = re.fullmatch(r'/clusters/([0-9a-fA-F-]{36})', path)
+            if not match:
+                return None
+            cluster_id = UUID(match.group(1))
+            view = await service.cluster(cluster_id, include_info=False)
+            sections = [view['servers'], view['processes'], view['infobases']]
+            labels = ('Working servers', 'Working processes', 'Infobases')
+            navigation = '<nav>' + ''.join(
+                f'<a href="/clusters/{cluster_id}/{group}">{html.escape(group.title())}</a> '
+                for group in CLUSTER_LISTS) + '</nav>'
+            navigation += (f'<nav><a href="/clusters/{cluster_id}/admins">'
+                           'Cluster administrators</a></nav>')
+            navigation += (f'<nav><a href="/clusters/{cluster_id}/info">'
+                           'Cluster info</a></nav>')
+            navigation += '<nav>' + ''.join(
+                f'<a href="/clusters/{cluster_id}/servers/{quote(str(UUID(row["server"])))}'
+                f'/{group}">{html.escape(group.title())} ({html.escape(str(row.get("name", "")))})</a> '
+                for row in view['servers'] for group in SERVER_LISTS) + '</nav>'
+            return render_document('Cluster ' + str(cluster_id), navigation + ''.join(
+                render_section(title, rows, f'/clusters/{cluster_id}'
+                               if title in ('Working servers', 'Working processes', 'Infobases') else '')
+                for title, rows in zip(labels, sections)))
+        async def bounded_collect():
+            async with asyncio.timeout(read_timeout):
+                return await collect()
+
+        try:
+            body = asyncio.run(bounded_collect())
+            if body is None:
+                start_response('404 Not Found', [('Content-Type', 'text/plain')])
+                return [b'Not found']
+        except InvalidAclQuery:
+            start_response('400 Bad Request', [('Content-Type', 'text/plain; charset=utf-8')])
+            return [b'Invalid ACL query']
+        except (RacError, ValueError, OSError, TimeoutError):
+            start_response('503 Service Unavailable', [('Content-Type', 'text/plain; charset=utf-8')])
+            return [b'RAC unavailable']
+        start_response('200 OK', [('Content-Type', 'text/html; charset=utf-8')])
+        return [body.encode('utf-8')]
+    return application