rucio 32.8.6__py3-none-any.whl

rucio/core/scope.py

@@ -0,0 +1,152 @@
+# -*- coding: utf-8 -*-
+# Copyright European Organization for Nuclear Research (CERN) since 2012
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from re import match
+from traceback import format_exc
+from typing import TYPE_CHECKING
+
+from sqlalchemy.exc import IntegrityError
+
+from rucio.common.exception import AccountNotFound, Duplicate, RucioException, VONotFound
+from rucio.core.vo import vo_exists
+from rucio.db.sqla import models
+from rucio.db.sqla.constants import AccountStatus, ScopeStatus
+from rucio.db.sqla.session import read_session, transactional_session
+
+if TYPE_CHECKING:
+    from sqlalchemy.orm import Session
+
+
+@transactional_session
+def add_scope(scope, account, *, session: "Session"):
+    """ add a scope for the given account name.
+
+    :param scope: the name for the new scope.
+    :param account: the account to add the scope to.
+    :param session: The database session in use.
+    """
+
+    if not vo_exists(vo=scope.vo, session=session):
+        raise VONotFound('VO {} not found'.format(scope.vo))
+
+    result = session.query(models.Account).filter_by(account=account, status=AccountStatus.ACTIVE).first()
+    if result is None:
+        raise AccountNotFound('Account ID \'%s\' does not exist' % account)
+
+    new_scope = models.Scope(scope=scope, account=account, status=ScopeStatus.OPEN)
+    try:
+        new_scope.save(session=session)
+    except IntegrityError as e:
+        if match('.*IntegrityError.*ORA-00001: unique constraint.*SCOPES_PK.*violated.*', e.args[0]) \
+                or match('.*IntegrityError.*Duplicate entry.*for key.*', e.args[0]) \
+                or match('.*IntegrityError.*UNIQUE constraint failed: scopes.scope.*', e.args[0]) \
+                or match('.*IntegrityError.*duplicate key value violates unique constraint.*', e.args[0]) \
+                or match('.*UniqueViolation.*duplicate key value violates unique constraint.*', e.args[0]) \
+                or match('.*IntegrityError.*columns? .*not unique.*', e.args[0]):
+            raise Duplicate('Scope \'%s\' already exists!' % scope)
+        else:
+            raise RucioException(e)
+    except:
+        raise RucioException(str(format_exc()))
+
+
+@read_session
+def bulk_add_scopes(scopes, account, skipExisting=False, *, session: "Session"):
+    """ add a group of scopes, this call should not be exposed to users.
+
+    :param scopes: a list of scopes to be added.
+    :param account: the account associated to the scopes.
+    :param session: The database session in use.
+    """
+
+    for scope in scopes:
+        try:
+            add_scope(scope, account, session=session)
+        except Duplicate:
+            if not skipExisting:
+                raise
+
+
+@read_session
+def list_scopes(filter_={}, *, session: "Session"):
+    """
+    Lists all scopes.
+    :param filter_: Dictionary of attributes by which the input data should be filtered
+    :param session: The database session in use.
+
+    :returns: A list containing all scopes.
+    """
+    scope_list = []
+    query = session.query(models.Scope).filter(models.Scope.status != ScopeStatus.DELETED)
+    for filter_type in filter_:
+        if filter_type == 'scope':
+            if '*' in filter_['scope'].internal:
+                scope_str = filter_['scope'].internal.replace('*', '%')
+                query = query.filter(models.Scope.scope.like(scope_str))
+            else:
+                query = query.filter_by(scope=filter_['scope'])
+
+    for s in query:
+        scope_list.append(s.scope)
+    return scope_list
+
+
+@read_session
+def get_scopes(account, *, session: "Session"):
+    """ get all scopes defined for an account.
+
+    :param account: the account name to list the scopes of.
+    :param session: The database session in use.
+
+    :returns: a list of all scope names for this account.
+    """
+
+    result = session.query(models.Account).filter_by(account=account).first()
+
+    if result is None:
+        raise AccountNotFound('Account ID \'%s\' does not exist' % account)
+
+    scope_list = []
+
+    for s in session.query(models.Scope).filter_by(account=account).filter(models.Scope.status != ScopeStatus.DELETED):
+        scope_list.append(s.scope)
+
+    return scope_list
+
+
+@read_session
+def check_scope(scope_to_check, *, session: "Session"):
+    """ check to see if scope exists.
+
+    :param scope: the scope to check.
+    :param session: The database session in use.
+
+    :returns: True or false
+    """
+
+    return True if session.query(models.Scope).filter_by(scope=scope_to_check).first() else False
+
+
+@read_session
+def is_scope_owner(scope, account, *, session: "Session"):
+    """ check to see if account owns the scope.
+
+    :param scope: the scope to check.
+    :param account: the account to check.
+    :param session: The database session in use.
+
+    :returns: True or false
+    """
+    return True if session.query(models.Scope).filter_by(scope=scope, account=account).first() else False

rucio/core/subscription.py

@@ -0,0 +1,316 @@
+# -*- coding: utf-8 -*-
+# Copyright European Organization for Nuclear Research (CERN) since 2012
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import datetime
+import logging
+import re
+from configparser import NoOptionError, NoSectionError
+from json import dumps
+from typing import TYPE_CHECKING
+
+from sqlalchemy import func
+from sqlalchemy.exc import IntegrityError, StatementError
+from sqlalchemy.orm import aliased
+from sqlalchemy.orm.exc import NoResultFound
+
+from rucio.common.config import config_get
+from rucio.common.exception import SubscriptionNotFound, SubscriptionDuplicate, RucioException
+from rucio.db.sqla import models
+from rucio.db.sqla.constants import SubscriptionState
+from rucio.db.sqla.session import transactional_session, stream_session, read_session
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Iterator
+    from typing import Any, Optional
+    from sqlalchemy.orm import Session
+    from rucio.common.types import InternalAccount
+    LoggerFunction = Callable[..., Any]
+    SubscriptionType = dict
+
+
+@transactional_session
+def add_subscription(name: str,
+                     account: "InternalAccount",
+                     filter_: str,
+                     replication_rules: str,
+                     comments: str,
+                     lifetime: "Optional[int]" = None,
+                     retroactive: "Optional[bool]" = False,
+                     dry_run: "Optional[bool]" = False,
+                     priority: "Optional[int]" = 3,
+                     *, session: "Session") -> str:
+    """
+    Adds a new subscription which will be verified against every new added file and dataset
+
+    :param account:            Account identifier
+    :type account:             String
+    :param name:               Name of the subscription
+    :type name:                String
+    :param filter_:             Dictionary of attributes by which the input data should be filtered
+                               **Example**: ``{'dsn': 'data11_hi*.express_express.*,data11_hi*physics_MinBiasOverlay*', 'account': 'tzero'}``
+    :type filter_:              Dict
+    :param replication_rules:  Replication rules to be set : Dictionary with keys copies, rse_expression, weight, rse_expression
+    :type replication_rules:   Dict
+    :param comments:           Comments for the subscription
+    :type comments:            String
+    :param lifetime:           Subscription's lifetime (days)
+    :type lifetime:            Integer or None
+    :param retroactive:        Flag to know if the subscription should be applied on previous data
+    :type retroactive:         Boolean
+    :param dry_run:            Just print the subscriptions actions without actually executing them (Useful if retroactive flag is set)
+    :type dry_run:             Boolean
+    :param priority:           The priority of the subscription
+    :type priority:            Integer
+    :param session:            The database session in use.
+
+    :returns:                  The subscriptionid
+    """
+    try:
+        keep_history = config_get('subscriptions', 'keep_history')
+    except (NoOptionError, NoSectionError, RuntimeError):
+        keep_history = False
+
+    SubscriptionHistory = models.SubscriptionHistory
+    retroactive = bool(retroactive)  # Force boolean type, necessary for strict SQL
+    state = SubscriptionState.ACTIVE
+    if retroactive:
+        state = SubscriptionState.NEW
+    if lifetime:
+        date_lifetime = datetime.datetime.utcnow() + datetime.timedelta(days=lifetime)
+    else:
+        date_lifetime = None
+    new_subscription = models.Subscription(name=name,
+                                           filter=filter_,
+                                           account=account,
+                                           replication_rules=replication_rules,
+                                           state=state,
+                                           lifetime=date_lifetime,
+                                           retroactive=retroactive,
+                                           policyid=priority, comments=comments)
+    if keep_history:
+        subscription_history = SubscriptionHistory(id=new_subscription.id,
+                                                   name=new_subscription.name,
+                                                   filter=new_subscription.filter,
+                                                   account=new_subscription.account,
+                                                   replication_rules=new_subscription.replication_rules,
+                                                   state=new_subscription.state,
+                                                   lifetime=new_subscription.lifetime,
+                                                   retroactive=new_subscription.retroactive,
+                                                   policyid=new_subscription.policyid,
+                                                   comments=new_subscription.comments)
+    try:
+        new_subscription.save(session=session)
+        if keep_history:
+            subscription_history.save(session=session)
+    except IntegrityError as error:
+        if re.match('.*IntegrityError.*ORA-00001: unique constraint.*SUBSCRIPTIONS_PK.*violated.*', error.args[0])\
+           or re.match(".*IntegrityError.*UNIQUE constraint failed: subscriptions.name, subscriptions.account.*", error.args[0])\
+           or re.match('.*IntegrityError.*columns? name.*account.*not unique.*', error.args[0]) \
+           or re.match('.*IntegrityError.*ORA-00001: unique constraint.*SUBSCRIPTIONS_NAME_ACCOUNT_UQ.*violated.*', error.args[0])\
+           or re.match('.*IntegrityError.*1062.*Duplicate entry.*', error.args[0]) \
+           or re.match('.*IntegrityError.*duplicate key value violates unique constraint.*', error.args[0]) \
+           or re.match('.*UniqueViolation.*duplicate key value violates unique constraint.*', error.args[0]):
+            raise SubscriptionDuplicate('Subscription \'%s\' owned by \'%s\' already exists!' % (name, account))
+        raise RucioException(error.args)
+    return str(new_subscription.id)
+
+
+@transactional_session
+def update_subscription(name: str,
+                        account: "InternalAccount",
+                        metadata: dict,
+                        *, session: "Session") -> None:
+    """
+    Updates a subscription
+
+    :param name:               Name of the subscription
+    :type name:                String
+    :param account:            Account identifier
+    :type account:             String
+    :param metadata:           Dictionary of metadata to update. Supported keys : filter, replication_rules, comments, lifetime, retroactive, dry_run, priority, last_processed
+    :type metadata:            Dict
+    :param session:            The database session in use.
+
+    :raises: SubscriptionNotFound if subscription is not found
+    """
+    try:
+        keep_history = config_get('subscriptions', 'keep_history')
+    except (NoOptionError, NoSectionError, RuntimeError):
+        keep_history = False
+    values = {'state': SubscriptionState.UPDATED}
+    if 'filter' in metadata and metadata['filter']:
+        values['filter'] = dumps(metadata['filter'])
+    if 'replication_rules' in metadata and metadata['replication_rules']:
+        values['replication_rules'] = dumps(metadata['replication_rules'])
+    if 'lifetime' in metadata and metadata['lifetime']:
+        values['lifetime'] = datetime.datetime.utcnow() + datetime.timedelta(days=float(metadata['lifetime']))
+    if 'retroactive' in metadata and metadata['retroactive']:
+        values['retroactive'] = metadata['retroactive']
+    if 'dry_run' in metadata and metadata['dry_run']:
+        values['dry_run'] = metadata['dry_run']
+    if 'comments' in metadata and metadata['comments']:
+        values['comments'] = metadata['comments']
+    if 'priority' in metadata and metadata['priority']:
+        values['policyid'] = metadata['priority']
+    if 'last_processed' in metadata and metadata['last_processed']:
+        values['last_processed'] = metadata['last_processed']
+    if 'state' in metadata and metadata['state'] == SubscriptionState.INACTIVE:
+        values['state'] = SubscriptionState.INACTIVE
+        values['expired_at'] = datetime.datetime.utcnow()
+
+    SubscriptionHistory = models.SubscriptionHistory
+    try:
+        subscription = session.query(models.Subscription).filter_by(account=account, name=name).one()
+
+        # To avoid update in the subscription history table whenever last processed field is changed
+        current_subscription_state = subscription.to_dict()
+        new_subscription_state = values.copy()
+
+        for key in ["updated_at", "last_processed"]:
+            new_subscription_state.pop(key, "None")
+            current_subscription_state.pop(key, "None")
+
+        subscription.update(values)
+        if keep_history and current_subscription_state != new_subscription_state:
+            subscription_history = SubscriptionHistory(id=subscription.id,
+                                                       name=subscription.name,
+                                                       filter=subscription.filter,
+                                                       account=subscription.account,
+                                                       replication_rules=subscription.replication_rules,
+                                                       state=subscription.state,
+                                                       lifetime=subscription.lifetime,
+                                                       retroactive=subscription.retroactive,
+                                                       policyid=subscription.policyid,
+                                                       comments=subscription.comments,
+                                                       last_processed=subscription.last_processed,
+                                                       expired_at=subscription.expired_at,
+                                                       updated_at=subscription.updated_at,
+                                                       created_at=subscription.created_at)
+            subscription_history.save(session=session)
+    except NoResultFound:
+        raise SubscriptionNotFound(f"Subscription for account '{account}' named '{name}' not found")
+
+
+@stream_session
+def list_subscriptions(name: "Optional[str]" = None,
+                       account: "Optional[InternalAccount]" = None,
+                       state: "Optional[SubscriptionState]" = None,
+                       *, session: "Session",
+                       logger: "LoggerFunction" = logging.log) -> "Iterator[SubscriptionType]":
+    """
+    Returns a dictionary with the subscription information :
+    Examples: ``{'status': 'INACTIVE/ACTIVE/BROKEN', 'last_modified_date': ...}``
+
+    :param name:               Name of the subscription
+    :type name:                String
+    :param account:            Account identifier
+    :type account:             String
+    :param session:            The database session in use.
+    :param logger:             Optional decorated logger that can be passed from the calling daemons or servers.
+
+    :returns:                  Dictionary containing subscription parameter
+    :rtype:                    Dict
+    :raises:                   exception.NotFound if subscription is not found
+    """
+    query = session.query(models.Subscription)
+    try:
+        if name:
+            query = query.filter_by(name=name)
+        if account:
+            if '*' in account.internal:
+                account_str = account.internal.replace('*', '%')
+                query = query.filter(models.Subscription.account.like(account_str))
+            else:
+                query = query.filter_by(account=account)
+        if state:
+            query = query.filter_by(state=state)
+    except IntegrityError as error:
+        logger(logging.ERROR, str(error))
+        raise RucioException(error.args)
+    found = False
+    for row in query:
+        found = True
+        yield row.to_dict()
+    if not found:
+        raise SubscriptionNotFound(f"Subscription for account '{account}' named '{name}' not found")
+
+
+@transactional_session
+def delete_subscription(subscription_id: str, *, session: "Session") -> None:
+    """
+    Deletes a subscription
+
+    :param subscription_id: Subscription identifier
+    :type subscription_id:  String
+    """
+    session.query(models.Subscription).filter_by(id=subscription_id).delete()
+
+
+@stream_session
+def list_subscription_rule_states(name=None, account=None, *, session: "Session", logger=logging.log):
+    """Returns a list of with the number of rules per state for a subscription.
+
+    :param name:               Name of the subscription
+    :param account:            Account identifier
+    :param session:            The database session in use.
+    :param logger:             Optional decorated logger that can be passed from the calling daemons or servers.
+    :returns:                  List with tuple (account, name, state, count)
+    """
+    subscription = aliased(models.Subscription)
+    rule = aliased(models.ReplicationRule)
+    # count needs a label to allow conversion to dict (label name can be changed)
+    query = session.query(
+        subscription.account, subscription.name, rule.state, func.count().label('count')).join(
+        rule, subscription.id == rule.subscription_id)
+
+    try:
+        if name:
+            query = query.filter(subscription.name == name)
+
+        if account:
+            if '*' in account.internal:
+                account_str = account.internal.replace('*', '%')
+                query = query.filter(subscription.account.like(account_str))
+            else:
+                query = query.filter(subscription.account == account)
+
+    except IntegrityError as error:
+        logger(logging.ERROR, str(error))
+        raise RucioException(error.args)
+
+    query = query.group_by(subscription.account, subscription.name, rule.state)
+
+    for row in query:
+        yield row
+
+
+@read_session
+def get_subscription_by_id(subscription_id, *, session: "Session"):
+    """
+    Get a specific subscription by id.
+
+    :param subscription_id:    The subscription_id to select.
+    :param session:            The database session in use.
+
+    :raises:                   SubscriptionNotFound if no Subscription can be found.
+    """
+
+    try:
+        subscription = session.query(models.Subscription).filter_by(id=subscription_id).one()
+        return subscription.to_dict()
+    except NoResultFound:
+        raise SubscriptionNotFound('No subscription with the id %s found' % (subscription_id))
+    except StatementError:
+        raise RucioException('Badly formatted subscription id (%s)' % (subscription_id))

rucio/core/temporary_did.py

@@ -0,0 +1,188 @@
+# -*- coding: utf-8 -*-
+# Copyright European Organization for Nuclear Research (CERN) since 2012
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+from sqlalchemy import and_, or_, func, delete
+from sqlalchemy.sql.expression import case, insert, update
+
+from rucio.core.did import attach_dids
+from rucio.core.replica import add_replica
+from rucio.db.sqla import models, filter_thread_work
+from rucio.db.sqla.session import read_session, transactional_session
+
+# from rucio.rse import rsemanager as rsemgr
+
+if TYPE_CHECKING:
+    from sqlalchemy.orm import Session
+
+
+@transactional_session
+def add_temporary_dids(dids, account, *, session: "Session"):
+    """
+    Bulk add temporary data identifiers.
+
+    :param dids: A list of dids.
+    :param account: The account owner.
+    :param session: The database session in use.
+    """
+    temporary_dids = []
+    for did in dids:
+
+        if did.get('pfn'):
+            did['path'] = did['pfn']
+            # In waiting to properly extract the path
+            # p = rsemgr.create_protocol(rse_settings=rsemgr.get_rse_info(rse, session=session), operation='write', scheme=scheme)
+            # if not replica_rse.deterministic:
+            #   pfns = p.parse_pfns(pfns=pfns)
+            #   tmp = pfns[file['pfn']]
+            # file['path'] = ''.join([tmp['path'], tmp['name']])
+
+        temporary_dids.append({'scope': did['scope'],
+                               'name': did['name'],
+                               'rse_id': did['rse_id'],
+                               'path': did.get('path'),
+                               'bytes': did.get('bytes'),
+                               'md5': did.get('md5'),
+                               'adler32': did.get('adler32'),
+                               'guid': did.get('guid'),
+                               'events': did.get('envents'),
+                               'parent_scope': did.get('parent_scope'),
+                               'parent_name': did.get('parent_name'),
+                               'offset': did.get('offset'),
+                               'expired_at': datetime.utcnow()})
+    try:
+        if temporary_dids:
+            session.execute(insert(models.TemporaryDataIdentifier), temporary_dids)
+    except:
+        raise
+
+
+@transactional_session
+def compose(scope, name, rse_id, bytes_, sources, account,
+            md5=None, adler32=None, pfn=None, meta={}, rules=[],
+            parent_scope=None, parent_name=None,
+            *, session: "Session"):
+    """
+    Concatenates a list of existing dids into a new file replica
+
+    :param scope: the scope name.
+    :param name: The data identifier name.
+    :param rse_id: the rse id.
+    :param bytes_: the size of the file.
+    :sources sources: The list of temporary DIDs.
+    :param account: The account owner.
+    :param md5: The md5 checksum.
+    :param adler32: The adler32 checksum.
+    :param pfn: Physical file name (for nondeterministic rse).
+    :param meta: Meta-data associated with the file. Represented as key/value pairs in a dictionary.
+    :param rules: Replication rules associated with the file. A list of dictionaries, e.g., [{'copies': 2, 'rse_expression': 'TIERS1'}, ].
+    :param parent_scope: Possible dataset scope.
+    :param parent_name: Possibe dataset name.
+    :param session: The database session in use.
+    """
+    # Create the new file did and replica
+    add_replica(rse_id=rse_id, scope=scope, name=name, bytes_=bytes_, account=account,
+                adler32=adler32, md5=md5, pfn=pfn, meta=meta, rules=rules,
+                session=session)
+
+    # Attach the file to a dataset
+    if parent_scope and parent_name:
+        attach_dids(scope=parent_scope, name=parent_name,
+                    dids=[{'scope': scope, 'name': name}], account=account,
+                    rse_id=None, session=session)
+
+    # Mark the merged dids as obsolete
+    now, expired_dids = datetime.utcnow(), []
+    for source in sources:
+        expired_dids.append({'scope': source['scope'],
+                             'name': source['name'],
+                             'expired_at': now})
+    if expired_dids:
+        session.execute(update(models.TemporaryDataIdentifier), expired_dids)
+
+
+@read_session
+def list_expired_temporary_dids(rse_id, limit, worker_number=None, total_workers=None,
+                                *, session: "Session"):
+    """
+    List expired temporary DIDs.
+
+    :param rse_id: the rse id.
+    :param limit: The maximum number of replicas returned.
+    :param worker_number:      id of the executing worker.
+    :param total_workers:      Number of total workers.
+    :param session: The database session in use.
+
+    :returns: a list of dictionary replica.
+    """
+    is_none = None
+    query = session.query(models.TemporaryDataIdentifier.scope,
+                          models.TemporaryDataIdentifier.name,
+                          models.TemporaryDataIdentifier.path,
+                          models.TemporaryDataIdentifier.bytes).\
+        with_hint(models.TemporaryDataIdentifier, "INDEX(tmp_dids TMP_DIDS_EXPIRED_AT_IDX)", 'oracle').\
+        filter(case((models.TemporaryDataIdentifier.expired_at != is_none, models.TemporaryDataIdentifier.rse_id)) == rse_id)
+
+    query = filter_thread_work(session=session, query=query, total_threads=total_workers, thread_id=worker_number, hash_variable='name')
+
+    return [{'path': path,
+             'rse_id': rse_id,
+             'scope': scope,
+             'name': name,
+             'bytes': bytes_}
+            for scope, name, path, bytes_ in query.limit(limit)]
+
+
+@transactional_session
+def delete_temporary_dids(dids, *, session: "Session"):
+    """
+    Delete temporary file replicas.
+
+    :param dids: the list of files to delete.
+    :param session
+    """
+    where_clause = []
+    for did in dids:
+        where_clause.append(and_(models.TemporaryDataIdentifier.scope == did['scope'],
+                                 models.TemporaryDataIdentifier.name == did['name']))
+
+    if where_clause:
+        stmt = delete(models.TemporaryDataIdentifier).\
+            prefix_with("/*+ INDEX(tmp_dids TMP_DIDS_PK) */", dialect='oracle').\
+            where(or_(*where_clause)).execution_options(synchronize_session=False)
+        result = session.execute(stmt)
+        return result.rowcount
+    return
+
+
+@read_session
+def get_count_of_expired_temporary_dids(rse_id, *, session: "Session"):
+    """
+    List expired temporary DIDs.
+
+    :param rse_id: the rse id.
+    :param session: The database session in use.
+
+    :returns: a count number.
+    """
+    is_none = None
+    count = session.query(func.count(models.TemporaryDataIdentifier.scope)).\
+        with_hint(models.TemporaryDataIdentifier, "INDEX(tmp_dids TMP_DIDS_EXPIRED_AT_IDX)", 'oracle').\
+        filter(case((models.TemporaryDataIdentifier.expired_at != is_none, models.TemporaryDataIdentifier.rse_id)) == rse_id).\
+        one()
+
+    return count[0] or 0