rucio 32.8.6__py3-none-any.whl → 35.8.0__py3-none-any.whl

rucio/core/rse.py

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 # Copyright European Organization for Nuclear Research (CERN) since 2012
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -14,28 +13,28 @@
 # limitations under the License.
 
 import json
-from collections.abc import Iterator, Iterable
+from collections.abc import Iterable, Iterator
 from datetime import datetime
 from io import StringIO
 from re import match
-from typing import Any, Generic, Optional, TypeVar, Union, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Generic, Optional, TypeVar, Union
 
 import sqlalchemy
 from dogpile.cache.api import NO_VALUE
 from sqlalchemy.exc import DatabaseError, IntegrityError, OperationalError
 from sqlalchemy.orm import aliased
 from sqlalchemy.orm.exc import FlushError
-from sqlalchemy.sql.expression import or_, and_, desc, true, false, func, select, delete
+from sqlalchemy.sql.expression import and_, delete, desc, false, func, or_, select, true
 
-from rucio.common import exception, utils
+from rucio.common import exception, types, utils
 from rucio.common.cache import make_region_memcached
 from rucio.common.config import get_lfn2pfn_algorithm_default
-from rucio.common import types
+from rucio.common.constants import RSE_SUPPORTED_PROTOCOL_OPERATIONS, RseAttr
 from rucio.common.utils import CHECKSUM_KEY, GLOBALLY_SUPPORTED_CHECKSUMS, Availability
 from rucio.core.rse_counter import add_counter, get_counter
 from rucio.db.sqla import models
-from rucio.db.sqla.constants import RSEType, ReplicaState
-from rucio.db.sqla.session import read_session, transactional_session, stream_session
+from rucio.db.sqla.constants import ReplicaState, RSEType
+from rucio.db.sqla.session import read_session, stream_session, transactional_session
 from rucio.db.sqla.util import temp_table_mngr
 
 if TYPE_CHECKING:
@@ -84,7 +83,7 @@ class RseData:
         return self._attributes
 
     @property
-    def info(self) -> dict[str, Any]:
+    def info(self) -> types.RSESettingsDict:
         if self._info is None:
             raise ValueError(f'info not loaded for rse {self}')
         return self._info
@@ -121,12 +120,12 @@ class RseData:
         return self.id == other.id
 
     def is_tape(self):
-        if self.info['rse_type'] == RSEType.TAPE or self.info['rse_type'] == 'TAPE':
+        if self.info['rse_type'] == RSEType.TAPE or self.info['rse_type'] == 'TAPE' or self.attributes.get(RseAttr.STAGING_REQUIRED, False):
             return True
         return False
 
     def is_tape_or_staging_required(self):
-        if self.is_tape() or self.attributes.get('staging_required', False):
+        if self.is_tape() or self.attributes.get(RseAttr.STAGING_REQUIRED, False):
             return True
         return False
 
@@ -153,8 +152,18 @@ class RseData:
 
     @staticmethod
     @read_session
-    def bulk_load(rse_id_to_data: "dict[str, RseData]", load_name=False, load_columns=False, load_attributes=False,
-                  load_info=False, load_usage=False, load_limits=False, *, session: "Session"):
+    def bulk_load(
+            rse_id_to_data: "dict[str, RseData]",
+            load_name: bool = False,
+            load_columns: bool = False,
+            load_attributes: bool = False,
+            load_info: bool = False,
+            load_usage: bool = False,
+            load_limits: bool = False,
+            include_deleted: bool = False,
+            *,
+            session: "Session"
+    ):
         """
         Given a dict of RseData objects indexed by rse_id, ensure that the desired fields are initialised
         in all objects from the input.
@@ -195,16 +204,18 @@ class RseData:
         # query, but this seems wasteful under normal operation: the caller of the current function probably
         # got the list of RSE IDs from list_rses (or another source which checks for deleted rses).
         #
-        # Instead, directly fetch all RSEs, which allows to reduce the number (and complexity) of other queries bellow
+        # Instead, directly fetch all RSEs, which allows to reduce the number (and complexity) of other queries below
         stmt = select(
             models.RSE
         ).join_from(
             temp_table,
             models.RSE,
             models.RSE.id == temp_table.id
-        ).where(
-            models.RSE.deleted == false()
         )
+        if not include_deleted:
+            stmt = stmt.where(
+                models.RSE.deleted == false()
+            )
         db_rses_by_id = {str(db_rse.id): db_rse for db_rse in session.execute(stmt).scalars()}
 
         if len(db_rses_by_id) != len(rse_ids_to_load):
@@ -231,11 +242,11 @@ class RseData:
         if load_info:
             stmt = select(
                 temp_table.id,
-                models.RSEProtocols
+                models.RSEProtocol
             ).outerjoin_from(
                 temp_table,
-                models.RSEProtocols,
-                models.RSEProtocols.rse_id == temp_table.id
+                models.RSEProtocol,
+                models.RSEProtocol.rse_id == temp_table.id
             ).order_by(
                 temp_table.id,
             )
@@ -330,6 +341,7 @@ class RseCollection(Generic[T]):
             load_info: bool = False,
             load_usage: bool = False,
             load_limits: bool = False,
+            include_deleted: bool = False,
             *,
             session: "Session",
     ):
@@ -341,6 +353,7 @@ class RseCollection(Generic[T]):
             load_info=load_info,
             load_usage=load_usage,
             load_limits=load_limits,
+            include_deleted=include_deleted,
             session=session,
         )
 
@@ -446,10 +459,8 @@ def rse_exists(rse, vo='def', include_deleted=False, *, session: "Session"):
     stmt = select(
         models.RSE
     ).where(
-        and_(
-            models.RSE.rse == rse,
-            models.RSE.vo == vo
-        )
+        and_(models.RSE.rse == rse,
+             models.RSE.vo == vo)
     )
     if not include_deleted:
         stmt = stmt.where(models.RSE.deleted == false())
@@ -469,8 +480,8 @@ def del_rse(rse_id, *, session: "Session"):
         stmt = select(
             models.RSE
         ).where(
-            models.RSE.id == rse_id,
-            models.RSE.deleted == false()
+            and_(models.RSE.id == rse_id,
+                 models.RSE.deleted == false())
         )
         db_rse = session.execute(stmt).scalar_one()
         rse_name = db_rse.rse
@@ -498,8 +509,8 @@ def restore_rse(rse_id, *, session: "Session"):
         stmt = select(
             models.RSE
         ).where(
-            models.RSE.id == rse_id,
-            models.RSE.deleted == true()
+            and_(models.RSE.id == rse_id,
+                 models.RSE.deleted == true())
         )
         db_rse = session.execute(stmt).scalar_one()
     except sqlalchemy.orm.exc.NoResultFound:
@@ -565,13 +576,14 @@ def get_rse(rse_id, *, session: "Session"):
     :raises RSENotFound: If referred RSE was not found in the database.
     """
 
-    false_value = False  # To make pep8 checker happy ...
     try:
-        tmp = session.query(models.RSE).\
-            filter(sqlalchemy.and_(models.RSE.deleted == false_value,
-                                   models.RSE.id == rse_id))\
-            .one()
-        return _format_get_rse(tmp, session=session)
+        stmt = select(
+            models.RSE
+        ).where(
+            and_(models.RSE.deleted == false(),
+                 models.RSE.id == rse_id)
+        )
+        return _format_get_rse(session.execute(stmt).scalar_one(), session=session)
     except sqlalchemy.orm.exc.NoResultFound:
         raise exception.RSENotFound('RSE with id \'%s\' cannot be found' % rse_id)
 
@@ -603,8 +615,8 @@ def get_rse_id(rse, vo='def', include_deleted=True, *, session: "Session"):
         stmt = select(
             models.RSE.id
         ).where(
-            models.RSE.rse == rse,
-            models.RSE.vo == vo
+            and_(models.RSE.rse == rse,
+                 models.RSE.vo == vo)
         )
         if not include_deleted:
             stmt = stmt.where(models.RSE.deleted == false())
@@ -687,7 +699,7 @@ def get_rse_vo(rse_id: str, include_deleted: bool = True, *, session: "Session")
 
 
 @read_session
-def list_rses(filters={}, *, session: "Session"):
+def list_rses(filters: Optional[dict[str, Any]] = None, *, session: "Session") -> list[dict[str, Any]]:
     """
     Returns a list of all RSEs.
 
@@ -697,7 +709,7 @@ def list_rses(filters={}, *, session: "Session"):
     :returns: a list of dictionaries.
     """
 
-    rse_list = []
+    filters = filters or {}
     filters = filters.copy()  # Make a copy, so we can pop() without affecting the object `filters` outside this function
 
     stmt = select(
@@ -726,21 +738,15 @@ def list_rses(filters={}, *, session: "Session"):
                 attr_assoc_alias = aliased(models.RSEAttrAssociation)
                 stmt = stmt.join(
                     attr_assoc_alias,
-                    and_(
-                        attr_assoc_alias.rse_id == models.RSE.id,
-                        attr_assoc_alias.key == k,
-                        attr_assoc_alias.value == v,
-                    )
+                    and_(attr_assoc_alias.rse_id == models.RSE.id,
+                         attr_assoc_alias.key == k,
+                         attr_assoc_alias.value == v)
                 )
-    else:
-        stmt = stmt.order_by(
-            models.RSE.rse
-        )
-
-    for row in session.execute(stmt).scalars():
-        rse_list.append(row.to_dict())
+    stmt = stmt.order_by(
+        models.RSE.rse
+    )
 
-    return rse_list
+    return [row.to_dict() for row in session.execute(stmt).scalars()]
 
 
 @transactional_session
@@ -780,8 +786,8 @@ def del_rse_attribute(rse_id, key, *, session: "Session"):
         stmt = select(
             models.RSEAttrAssociation
         ).where(
-            models.RSEAttrAssociation.rse_id == rse_id,
-            models.RSEAttrAssociation.key == key
+            and_(models.RSEAttrAssociation.rse_id == rse_id,
+                 models.RSEAttrAssociation.key == key)
         )
         rse_attr = session.execute(stmt).scalar_one()
     except sqlalchemy.orm.exc.NoResultFound:
@@ -870,8 +876,8 @@ def has_rse_attribute(rse_id, key, *, session: "Session"):
     stmt = select(
         models.RSEAttrAssociation.value
     ).where(
-        models.RSEAttrAssociation.rse_id == rse_id,
-        models.RSEAttrAssociation.key == key
+        and_(models.RSEAttrAssociation.rse_id == rse_id,
+             models.RSEAttrAssociation.key == key)
     )
     if session.execute(stmt).scalar():
         return True
@@ -896,10 +902,8 @@ def get_rses_with_attribute(key, *, session: "Session"):
         models.RSE.deleted == false()
     ).join(
         models.RSEAttrAssociation,
-        and_(
-            models.RSEAttrAssociation.rse_id == models.RSE.id,
-            models.RSEAttrAssociation.key == key
-        )
+        and_(models.RSEAttrAssociation.rse_id == models.RSE.id,
+             models.RSEAttrAssociation.key == key)
     )
 
     for db_rse in session.execute(stmt).scalars():
@@ -933,15 +937,13 @@ def get_rses_with_attribute_value(key, value, vo='def', *, session: "Session"):
             models.RSE.id,
             models.RSE.rse,
         ).where(
-            models.RSE.deleted == false(),
-            models.RSE.vo == vo
+            and_(models.RSE.deleted == false(),
+                 models.RSE.vo == vo)
         ).join(
             models.RSEAttrAssociation,
-            and_(
-                models.RSEAttrAssociation.rse_id == models.RSE.id,
-                models.RSEAttrAssociation.key == key,
-                models.RSEAttrAssociation.value == value
-            )
+            and_(models.RSEAttrAssociation.rse_id == models.RSE.id,
+                 models.RSEAttrAssociation.key == key,
+                 models.RSEAttrAssociation.value == value)
         )
 
         for row in session.execute(stmt):
@@ -979,8 +981,8 @@ def get_rse_attribute(rse_id: str, key: str, use_cache: bool = True, *, session:
     stmt = select(
         models.RSEAttrAssociation.value
     ).where(
-        models.RSEAttrAssociation.rse_id == rse_id,
-        models.RSEAttrAssociation.key == key
+        and_(models.RSEAttrAssociation.rse_id == rse_id,
+             models.RSEAttrAssociation.key == key)
     )
     value = session.execute(stmt).scalar_one_or_none()
 
@@ -1199,10 +1201,8 @@ def get_rse_transfer_limits(rse_id, activity=None, *, session: "Session"):
         )
         if activity:
             stmt = stmt.where(
-                or_(
-                    models.TransferLimit.activity == activity,
-                    models.TransferLimit.activity == 'all_activities',
-                )
+                or_(models.TransferLimit.activity == activity,
+                    models.TransferLimit.activity == 'all_activities')
             )
 
         limits = {}
@@ -1255,7 +1255,7 @@ def add_protocol(
     parameter: dict[str, Any],
     *,
     session: "Session"
-) -> models.RSEProtocols:
+) -> models.RSEProtocol:
     """
     Add a protocol to an existing RSE.
 
@@ -1289,7 +1289,7 @@ def add_protocol(
             if domain not in utils.rse_supported_protocol_domains():
                 raise exception.RSEProtocolDomainNotSupported(f"The protocol domain '{domain}' is not defined in the schema.")
             for op in parameter['domains'][domain]:
-                if op not in utils.rse_supported_protocol_operations():
+                if op not in RSE_SUPPORTED_PROTOCOL_OPERATIONS:
                     raise exception.RSEOperationNotSupported(f"Operation '{op}' not defined in schema.")
                 op_name = op if op.startswith('third_party_copy') else f'{op}_{domain}'.lower()
                 priority = parameter['domains'][domain][op]
@@ -1309,7 +1309,7 @@ def add_protocol(
             raise exception.InvalidObject('Missing values! For SRM, extended_attributes and web_service_path must be specified')
 
     try:
-        new_protocol = models.RSEProtocols()
+        new_protocol = models.RSEProtocol()
         new_protocol.update(parameter)
         new_protocol.save(session=session)
     except (IntegrityError, FlushError, OperationalError) as error:
@@ -1351,14 +1351,14 @@ def get_rse_protocols(rse_id, schemes=None, *, session: "Session") -> types.RSES
     if not _rse:
         raise exception.RSENotFound('RSE with id \'%s\' not found' % rse_id)
 
-    terms = [models.RSEProtocols.rse_id == rse_id]
+    terms = [models.RSEProtocol.rse_id == rse_id]
     if schemes:
         if not type(schemes) is list:
             schemes = [schemes]
-        terms.extend([models.RSEProtocols.scheme.in_(schemes)])
+        terms.extend([models.RSEProtocol.scheme.in_(schemes)])
 
     stmt = select(
-        models.RSEProtocols
+        models.RSEProtocol
     ).where(
         *terms
     )
@@ -1369,16 +1369,16 @@ def get_rse_protocols(rse_id, schemes=None, *, session: "Session") -> types.RSES
 
 def _format_get_rse_protocols(
         rse: "models.RSE | dict[str, Any]",
-        db_protocols: Iterable[models.RSEProtocols],
+        db_protocols: Iterable[models.RSEProtocol],
         rse_attributes: Optional[dict[str, Any]] = None,
         *,
         session: "Session"
 ) -> types.RSESettingsDict:
     _rse = rse
     if rse_attributes:
-        lfn2pfn_algorithm = rse_attributes.get('lfn2pfn_algorithm')
+        lfn2pfn_algorithm = rse_attributes.get(RseAttr.LFN2PFN_ALGORITHM)
     else:
-        lfn2pfn_algorithm = get_rse_attribute(_rse['id'], 'lfn2pfn_algorithm', session=session)
+        lfn2pfn_algorithm = get_rse_attribute(_rse['id'], RseAttr.LFN2PFN_ALGORITHM, session=session)
     # Resolve LFN2PFN default algorithm as soon as possible.  This way, we can send back the actual
     # algorithm name in response to REST queries.
     if not lfn2pfn_algorithm:
@@ -1386,15 +1386,15 @@ def _format_get_rse_protocols(
 
     # Copy verify_checksum from the attributes, later: assume True if not specified
     if rse_attributes:
-        verify_checksum = rse_attributes.get('verify_checksum')
+        verify_checksum = rse_attributes.get(RseAttr.VERIFY_CHECKSUM)
     else:
-        verify_checksum = get_rse_attribute(_rse['id'], 'verify_checksum', session=session)
+        verify_checksum = get_rse_attribute(_rse['id'], RseAttr.VERIFY_CHECKSUM, session=session)
 
     # Copy sign_url from the attributes
     if rse_attributes:
-        sign_url = rse_attributes.get('sign_url')
+        sign_url = rse_attributes.get(RseAttr.SIGN_URL)
     else:
-        sign_url = get_rse_attribute(_rse['id'], 'sign_url', session=session)
+        sign_url = get_rse_attribute(_rse['id'], RseAttr.SIGN_URL, session=session)
 
     info = {'availability_delete': _rse['availability_delete'],
             'availability_read': _rse['availability_read'],
@@ -1413,7 +1413,7 @@ def _format_get_rse_protocols(
             'verify_checksum': verify_checksum if verify_checksum is not None else True,
             'volatile': _rse['volatile']}
 
-    for op in utils.rse_supported_protocol_operations():
+    for op in RSE_SUPPORTED_PROTOCOL_OPERATIONS:
         info['%s_protocol' % op] = 1  # 1 indicates the default protocol
 
     for row in db_protocols:
@@ -1500,7 +1500,7 @@ def update_protocols(
             if domain not in utils.rse_supported_protocol_domains():
                 raise exception.RSEProtocolDomainNotSupported(f"The protocol domain '{domain}' is not defined in the schema.")
             for op in data['domains'][domain]:
-                if op not in utils.rse_supported_protocol_operations():
+                if op not in RSE_SUPPORTED_PROTOCOL_OPERATIONS:
                     raise exception.RSEOperationNotSupported(f"Operation '{op}' not defined in schema.")
                 op_name = op if op.startswith('third_party_copy') else f'{op}_{domain}'.lower()
                 priority = data['domains'][domain][op]
@@ -1520,14 +1520,14 @@ def update_protocols(
     except exception.RSENotFound:
         raise exception.RSENotFound('RSE with id \'%s\' not found' % rse_id)
 
-    terms = [models.RSEProtocols.rse_id == rse_id,
-             models.RSEProtocols.scheme == scheme,
-             models.RSEProtocols.hostname == hostname,
-             models.RSEProtocols.port == port]
+    terms = [models.RSEProtocol.rse_id == rse_id,
+             models.RSEProtocol.scheme == scheme,
+             models.RSEProtocol.hostname == hostname,
+             models.RSEProtocol.port == port]
 
     try:
         stmt = select(
-            models.RSEProtocols
+            models.RSEProtocol
         ).where(
             *terms
         )
@@ -1575,13 +1575,13 @@ def del_protocols(
         rse_name = get_rse_name(rse_id=rse_id, session=session, include_deleted=False)
     except exception.RSENotFound:
         raise exception.RSENotFound('RSE \'%s\' not found' % rse_id)
-    terms = [models.RSEProtocols.rse_id == rse_id, models.RSEProtocols.scheme == scheme]
+    terms = [models.RSEProtocol.rse_id == rse_id, models.RSEProtocol.scheme == scheme]
     if hostname is not None:
-        terms.append(models.RSEProtocols.hostname == hostname)
+        terms.append(models.RSEProtocol.hostname == hostname)
         if port is not None:
-            terms.append(models.RSEProtocols.port == port)
+            terms.append(models.RSEProtocol.port == port)
     stmt = select(
-        models.RSEProtocols
+        models.RSEProtocol
     ).where(
         *terms
     )
@@ -1771,8 +1771,8 @@ def delete_qos_policy(rse_id, qos_policy, *, session: "Session"):
         stmt = delete(
             models.RSEQoSAssociation
         ).where(
-            models.RSEQoSAssociation.rse_id == rse_id,
-            models.RSEQoSAssociation.qos_policy == qos_policy
+            and_(models.RSEQoSAssociation.rse_id == rse_id,
+                 models.RSEQoSAssociation.qos_policy == qos_policy)
         )
         session.execute(stmt)
     except DatabaseError as error:
@@ -1820,12 +1820,14 @@ def fill_rse_expired(rse_id, *, session: "Session"):
         func.sum(models.RSEFileAssociation.bytes).label("bytes"),
         func.count().label("length")
     ).with_hint(
-        models.RSEFileAssociation, "INDEX(REPLICAS REPLICAS_RSE_ID_TOMBSTONE_IDX)", 'oracle'
+        models.RSEFileAssociation,
+        'INDEX(REPLICAS REPLICAS_RSE_ID_TOMBSTONE_IDX)',
+        'oracle'
     ).where(
-        models.RSEFileAssociation.tombstone < datetime.utcnow(),
-        models.RSEFileAssociation.lock_cnt == 0,
-        models.RSEFileAssociation.rse_id == rse_id,
-        models.RSEFileAssociation.state.in_((ReplicaState.AVAILABLE, ReplicaState.UNAVAILABLE, ReplicaState.BAD))
+        and_(models.RSEFileAssociation.tombstone < datetime.utcnow(),
+             models.RSEFileAssociation.lock_cnt == 0,
+             models.RSEFileAssociation.rse_id == rse_id,
+             models.RSEFileAssociation.state.in_((ReplicaState.AVAILABLE, ReplicaState.UNAVAILABLE, ReplicaState.BAD)))
     )
 
     sum_bytes, sum_files = session.execute(stmt).one()
@@ -1833,3 +1835,41 @@ def fill_rse_expired(rse_id, *, session: "Session"):
                     used=sum_bytes,
                     files=sum_files,
                     source='expired').save(session=session)
+
+
+def determine_audience_for_rse(rse_id: str) -> str:
+    """Construct the Audience claim for an RSE."""
+    rse_protocols = get_rse_protocols(rse_id)
+    # FIXME: At the time of writing, there does not appear to be a common
+    # agreement on how sites will configure their storages.  Rucio had requested
+    # that the protocol hostname be sufficient, but this may not come to pass.
+    filtered_hostnames = {p['hostname']
+                          for p in rse_protocols['protocols']
+                          if p['scheme'] == 'davs'}
+    return ' '.join(sorted(filtered_hostnames))
+
+
+def determine_scope_for_rse(
+    rse_id: str,
+    scopes: Iterable[str],
+    extra_scopes: Optional[Iterable[str]] = None,
+) -> str:
+    """Construct the Scope claim for an RSE."""
+    if extra_scopes is None:
+        extra_scopes = []
+    rse_protocols = get_rse_protocols(rse_id)
+    filtered_prefixes = set()
+    for protocol in rse_protocols['protocols']:
+        # Token support is exclusive to WebDAV.
+        if protocol['scheme'] != 'davs':
+            continue
+        # Remove base path from prefix.  Storages typically map an issuer (i.e.
+        # a VO) to a particular area.  If so, then the path to that area acts as
+        # a base which should be removed from the prefix (in order for '/' to
+        # mean the entire resource associated with that issuer).
+        prefix = protocol['prefix']
+        if base_path := get_rse_attribute(rse_id, RseAttr.OIDC_BASE_PATH):
+            prefix = prefix.removeprefix(base_path)
+        filtered_prefixes.add(prefix)
+    all_scopes = [f'{s}:{p}' for s in scopes for p in filtered_prefixes] + list(extra_scopes)
+    return ' '.join(sorted(all_scopes))

rucio/core/rse_counter.py

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 # Copyright European Organization for Nuclear Research (CERN) since 2012
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -14,10 +13,11 @@
 # limitations under the License.
 from typing import TYPE_CHECKING
 
-from sqlalchemy.orm.exc import NoResultFound
+from sqlalchemy import and_, delete, select
+from sqlalchemy.exc import NoResultFound
 
 from rucio.common.exception import CounterNotFound
-from rucio.db.sqla import models, filter_thread_work
+from rucio.db.sqla import filter_thread_work, models
 from rucio.db.sqla.session import read_session, transactional_session
 
 if TYPE_CHECKING:
@@ -72,8 +72,15 @@ def del_counter(rse_id, *, session: "Session"):
     :param session: The database session in use.
     """
 
-    session.query(models.RSEUsage).filter_by(rse_id=rse_id, source='rucio').\
-        delete(synchronize_session=False)
+    stmt = delete(
+        models.RSEUsage
+    ).where(
+        and_(models.RSEUsage.rse_id == rse_id,
+             models.RSEUsage.source == 'rucio')
+    ).execution_options(
+        synchronize_session=False
+    )
+    session.execute(stmt)
 
 
 @read_session
@@ -89,11 +96,20 @@ def get_counter(rse_id, *, session: "Session"):
     """
 
     try:
-        counter = session.query(models.RSEUsage).\
-            filter_by(rse_id=rse_id, source='rucio').one()
-        return {'bytes': counter.used,
-                'files': counter.files,
-                'updated_at': counter.updated_at}
+        stmt = select(
+            models.RSEUsage.used,
+            models.RSEUsage.files,
+            models.RSEUsage.updated_at
+        ).where(
+            and_(models.RSEUsage.rse_id == rse_id,
+                 models.RSEUsage.source == 'rucio')
+        )
+        usage_bytes, usage_files, usage_updated_at = session.execute(stmt).one()
+        return {
+            'bytes': usage_bytes,
+            'files': usage_files,
+            'updated_at': usage_updated_at
+        }
     except NoResultFound:
         raise CounterNotFound()
 
@@ -108,12 +124,13 @@ def get_updated_rse_counters(total_workers, worker_number, *, session: "Session"
     :param session:            Database session in use.
     :returns:                  List of rse_ids whose rse_counters need to be updated.
     """
-    query = session.query(models.UpdatedRSECounter.rse_id).\
-        distinct(models.UpdatedRSECounter.rse_id)
+    stmt = select(
+        models.UpdatedRSECounter.rse_id
+    ).distinct(
+    )
 
-    query = filter_thread_work(session=session, query=query, total_threads=total_workers, thread_id=worker_number, hash_variable='rse_id')
-    results = query.all()
-    return [result.rse_id for result in results]
+    stmt = filter_thread_work(session=session, query=stmt, total_threads=total_workers, thread_id=worker_number, hash_variable='rse_id')
+    return session.execute(stmt).scalars().all()
 
 
 @transactional_session
@@ -125,12 +142,23 @@ def update_rse_counter(rse_id, *, session: "Session"):
     :param session:  Database session in use.
     """
 
-    updated_rse_counters = session.query(models.UpdatedRSECounter).filter_by(rse_id=rse_id).all()
+    stmt = select(
+        models.UpdatedRSECounter
+    ).where(
+        models.UpdatedRSECounter.rse_id == rse_id
+    )
+    updated_rse_counters = session.execute(stmt).scalars().all()
     sum_bytes = sum([updated_rse_counter.bytes for updated_rse_counter in updated_rse_counters])
     sum_files = sum([updated_rse_counter.files for updated_rse_counter in updated_rse_counters])
 
     try:
-        rse_counter = session.query(models.RSEUsage).filter_by(rse_id=rse_id, source='rucio').one()
+        stmt = select(
+            models.RSEUsage
+        ).where(
+            and_(models.RSEUsage.rse_id == rse_id,
+                 models.RSEUsage.source == 'rucio')
+        )
+        rse_counter = session.execute(stmt).scalar_one()
         rse_counter.used = (rse_counter.used or 0) + sum_bytes
         rse_counter.files = (rse_counter.files or 0) + sum_files
     except NoResultFound:
@@ -151,5 +179,8 @@ def fill_rse_counter_history_table(*, session: "Session"):
     :param session: Database session in use.
     """
     RSEUsageHistory = models.RSEUsageHistory
-    for usage in session.query(models.RSEUsage).all():
+    stmt = select(
+        models.RSEUsage
+    )
+    for usage in session.execute(stmt).scalars().all():
         RSEUsageHistory(rse_id=usage['rse_id'], used=usage['used'], files=usage['files'], source=usage['source']).save(session=session)