rucio 1.30.5__tar.gz → 1.30.7__tar.gz

{rucio-1.30.5 → rucio-1.30.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rucio
-Version: 1.30.5
+Version: 1.30.7
 Summary: Rucio Package
 Home-page: https://rucio.cern.ch/
 Author: Rucio

{rucio-1.30.5 → rucio-1.30.7}/bin/rucio-conveyor-preparer

@@ -23,7 +23,7 @@ from rucio.daemons.conveyor.preparer import run, stop
 def main(args):
     signal.signal(signal.SIGTERM, stop)
     try:
-        run(once=args.run_once, threads=args.threads, sleep_time=args.sleep_time, bulk=args.bulk)
+        run(once=args.run_once, threads=args.threads, sleep_time=args.sleep_time, bulk=args.bulk, ignore_availability=args.ignore_availability)
     except KeyboardInterrupt:
         stop()
 
@@ -34,4 +34,5 @@ if __name__ == "__main__":
     parser.add_argument("--threads", action="store", default=1, type=int, help='Concurrency control: total number of threads on this process')
     parser.add_argument("--sleep-time", action="store", default=60, type=int, help='Concurrency control: thread sleep time after each chunk of work')
     parser.add_argument("--bulk", action="store", default=100, type=int, help='Limit of requests per chunk')
+    parser.add_argument('--ignore-availability', action="store_true", default=False, help='If True, will also try to submit transfers having blocklisted RSEs as sources')
     main(args=parser.parse_args())

{rucio-1.30.5 → rucio-1.30.7}/lib/rucio/api/rule.py

@@ -318,6 +318,9 @@ def move_replication_rule(rule_id, rse_expression, override, issuer, vo='def', *
     :param vo:                         The VO to act on.
     :raises:                           RuleNotFound, RuleReplaceFailed, InvalidRSEExpression, AccessDenied
     """
+    override = override.copy()
+    if 'account' in override:
+        override['account'] = InternalAccount(override['account'], vo=vo)
     kwargs = {
         'rule_id': rule_id,
         'rse_expression': rse_expression,

{rucio-1.30.5 → rucio-1.30.7}/lib/rucio/common/exception.py

@@ -1069,3 +1069,14 @@ class PolicyPackageVersionError(RucioException):
         super(PolicyPackageVersionError, self).__init__(*args, **kwargs)
         self._message = 'Policy package %s is not compatible with this Rucio version' % package
         self.error_code = 103
+
+
+class InvalidSourceReplicaExpression(RucioException):
+    """
+    Source Replica Expression Considered Invalid
+    """
+
+    def __init__(self, *args, **kwargs):
+        super(InvalidSourceReplicaExpression, self).__init__(*args, **kwargs)
+        self._message = 'Provided Source Replica expression is considered invalid.'
+        self.error_code = 104

{rucio-1.30.5 → rucio-1.30.7}/lib/rucio/common/schema/cms.py

@@ -445,21 +445,34 @@ def validate_cms_did(obj):
     Special checking for DIDs
     Most of the checking is done with JSON schema, but this check
     makes sure user LFNs are in the correct /store/user/rucio/USERNAME namespace
+    makes sure group LFNs are in the correct /store/group/rucio/GROUPNAME namespace
     """
     if not obj:
         return
 
-    lfn = obj['name']
     did_type = obj['type']
+    lfn = obj['name']
     scope = obj['scope']
-    if scope.startswith('user.') and did_type == 'FILE':
-        _, user = scope.split('.', 1)
-        if not lfn.startswith('/store/user/rucio/%s/' % user):
-            raise InvalidObject("Problem with LFN %(lfn)s : Not allowed for user %(user)s" % locals())
-    if lfn.startswith('/store/user') and not lfn.startswith('/store/user/rucio/'):
-        raise InvalidObject("Problem with LFN %(lfn)s : Legacy user files are not managed with Rucio")
-    if lfn.startswith('/store/user/rucio') and not scope.startswith('user.'):
-        raise InvalidObject("Problem with LFN %(lfn)s : Only user scopes allowed in /store/user/rucio")
-    if scope == 'logs' and did_type == 'FILE':
+
+    if did_type != "FILE":
+        return
+
+    verify_scope_lfn_match(lfn, scope, "user")
+    verify_scope_lfn_match(lfn, scope, "group")
+
+    if scope == 'logs':
         if not lfn.startswith('/store/logs/'):
             raise InvalidObject("Problem with LFN %(lfn)s : Logs must start with /store/logs" % locals())
+
+
+def verify_scope_lfn_match(lfn, scope, scope_type):
+    if lfn.startswith(f'/store/{scope_type}') and not lfn.startswith(f'/store/{scope_type}/rucio/'):
+        raise InvalidObject(f"Problem with LFN {lfn} : Legacy {scope_type} files are not managed with Rucio")
+
+    if lfn.startswith(f'/store/{scope_type}/rucio') and not scope.startswith(f'{scope_type}.'):
+        raise InvalidObject(f"Problem with LFN {lfn}: Only {scope_type} scopes allowed in /store/{scope_type}/rucio")
+
+    if scope.startswith(f'{scope_type}.'):
+        _, account = scope.split('.', 1)
+        if not lfn.startswith(f'/store/{scope_type}/rucio/{account}/'):
+            raise InvalidObject(f"Problem with LFN {lfn} : Not allowed for {scope_type} {account}")

{rucio-1.30.5 → rucio-1.30.7}/lib/rucio/core/replica.py

@@ -2731,7 +2731,8 @@ def list_and_mark_unlocked_replicas(limit, bytes_=None, rse_id=None, delay_secon
             replicas_alias,
             and_(models.RSEFileAssociation.scope == replicas_alias.scope,
                  models.RSEFileAssociation.name == replicas_alias.name,
-                 models.RSEFileAssociation.rse_id != replicas_alias.rse_id)
+                 models.RSEFileAssociation.rse_id != replicas_alias.rse_id,
+                 replicas_alias.state == ReplicaState.AVAILABLE)
         ).with_hint(
             models.Request, "INDEX(requests REQUESTS_SCOPE_NAME_RSE_IDX)", 'oracle'
         ).outerjoin(
@@ -2836,9 +2837,12 @@ def list_and_mark_unlocked_replicas_no_temp_table(limit, bytes_=None, rse_id=Non
         # Check if more than one replica is available
         replica_cnt = session.query(func.count(models.RSEFileAssociation.scope)).\
             with_hint(models.RSEFileAssociation, "index(REPLICAS REPLICAS_PK)", 'oracle').\
-            filter(and_(models.RSEFileAssociation.scope == scope, models.RSEFileAssociation.name == name, models.RSEFileAssociation.rse_id != rse_id)).one()
+            filter(and_(models.RSEFileAssociation.scope == scope,
+                        models.RSEFileAssociation.name == name,
+                        models.RSEFileAssociation.rse_id != rse_id,
+                        models.RSEFileAssociation.state == ReplicaState.AVAILABLE)).one()
 
-        if replica_cnt[0] > 1:
+        if replica_cnt[0] > 0:
             if tombstone != OBSOLETE and only_delete_obsolete:
                 break
 

{rucio-1.30.5 → rucio-1.30.7}/lib/rucio/core/request.py

@@ -1629,7 +1629,6 @@ def list_transfer_limits(
     )
     for limit in session.execute(stmt).scalars():
         dict_resp = limit.to_dict()
-        dict_resp.pop('_sa_instance_state')
         yield dict_resp
 
 

{rucio-1.30.5 → rucio-1.30.7}/lib/rucio/core/rule.py

@@ -47,7 +47,8 @@ from rucio.common.exception import (InvalidRSEExpression, InvalidReplicationRule
                                     ReplicationRuleCreationTemporaryFailed, InsufficientTargetRSEs, RucioException,
                                     InvalidRuleWeight, StagingAreaRuleRequiresLifetime, DuplicateRule,
                                     InvalidObject, RSEWriteBlocked, RuleReplaceFailed, RequestNotFound,
-                                    ManualRuleApprovalBlocked, UnsupportedOperation, UndefinedPolicy, InvalidValueForKey)
+                                    ManualRuleApprovalBlocked, UnsupportedOperation, UndefinedPolicy, InvalidValueForKey,
+                                    InvalidSourceReplicaExpression)
 from rucio.common.schema import validate_schema
 from rucio.common.types import InternalScope, InternalAccount
 from rucio.common.utils import str_to_date, sizefmt, chunks
@@ -151,7 +152,10 @@ def add_rule(dids, account, copies, rse_expression, grouping, weight, lifetime,
                         raise ManualRuleApprovalBlocked()
 
             if source_replica_expression:
-                source_rses = parse_expression(source_replica_expression, filter_={'vo': vo}, session=session)
+                try:
+                    source_rses = parse_expression(source_replica_expression, filter_={'vo': vo}, session=session)
+                except InvalidRSEExpression:
+                    raise InvalidSourceReplicaExpression
             else:
                 source_rses = []
 

{rucio-1.30.5 → rucio-1.30.7}/lib/rucio/core/transfer.py

@@ -400,15 +400,25 @@ def ensure_db_sources(
 
 
 @transactional_session
-def set_transfers_state(transfers, state, submitted_at, external_host, external_id, *, session: "Session", logger):
+def set_transfers_state(
+        transfers,
+        state: "RequestState",
+        submitted_at: datetime.datetime,
+        external_host: str,
+        external_id: str,
+        transfertool: str,
+        *,
+        session: "Session",
+        logger
+):
     """
     Update the transfer info of a request.
     :param transfers:  Dictionary containing request transfer info.
     :param session:    Database session to use.
     """
 
-    logger(logging.INFO, 'Setting state(%s), external_host(%s) and eid(%s) for transfers: %s',
-           state.name, external_host, external_id, ', '.join(t.rws.request_id for t in transfers))
+    logger(logging.INFO, 'Setting state(%s), transfertool(%s), external_host(%s) and eid(%s) for transfers: %s',
+           state.name, transfertool, external_host, external_id, ', '.join(t.rws.request_id for t in transfers))
     try:
         for transfer in transfers:
             rws = transfer.rws
@@ -422,11 +432,12 @@ def set_transfers_state(transfers, state, submitted_at, external_host, external_
                 synchronize_session=False
             ).values(
                 {
-                    'state': state,
-                    'external_id': external_id,
-                    'external_host': external_host,
-                    'source_rse_id': transfer.src.rse.id,
-                    'submitted_at': submitted_at,
+                    models.Request.state: state,
+                    models.Request.external_id: external_id,
+                    models.Request.external_host: external_host,
+                    models.Request.source_rse_id: transfer.src.rse.id,
+                    models.Request.submitted_at: submitted_at,
+                    models.Request.transfertool: transfertool,
                 }
             )
             rowcount = session.execute(stmt).rowcount

{rucio-1.30.5 → rucio-1.30.7}/lib/rucio/daemons/conveyor/common.py

@@ -493,8 +493,15 @@ def _submit_transfers(transfertool_obj, transfers, job_params, submitter='submit
 
     if state_to_set:
         try:
-            transfer_core.set_transfers_state(transfers, state=state_to_set, external_host=transfertool_obj.external_host,
-                                              external_id=eid, submitted_at=datetime.datetime.utcnow(), logger=logger)
+            transfer_core.set_transfers_state(
+                transfers,
+                state=state_to_set,
+                external_host=transfertool_obj.external_host,
+                external_id=eid,
+                submitted_at=datetime.datetime.utcnow(),
+                transfertool=transfertool_obj.external_name,
+                logger=logger
+            )
         except Exception:
             logger(logging.ERROR, 'Failed to register transfer state with error', exc_info=True)
             if eid is not None:

{rucio-1.30.5 → rucio-1.30.7}/lib/rucio/daemons/conveyor/preparer.py

@@ -47,7 +47,7 @@ def stop():
     graceful_stop.set()
 
 
-def run(once=False, threads=1, sleep_time=10, bulk=100):
+def run(once=False, threads=1, sleep_time=10, bulk=100, ignore_availability: bool = False):
     """
     Running the preparer daemon either once or by default in a loop until stop is called.
     """
@@ -58,7 +58,7 @@ def run(once=False, threads=1, sleep_time=10, bulk=100):
 
     def preparer_kwargs():
         # not sure if this is needed for threading.Thread, but it always returns a fresh dictionary
-        return {'once': once, 'sleep_time': sleep_time, 'bulk': bulk}
+        return {'once': once, 'sleep_time': sleep_time, 'bulk': bulk, 'ignore_availability': ignore_availability}
 
     threads = [threading.Thread(target=preparer, name=f'conveyor-preparer-{i}', kwargs=preparer_kwargs(), daemon=True) for i in range(threads)]
     for thr in threads:
@@ -84,7 +84,7 @@ def run(once=False, threads=1, sleep_time=10, bulk=100):
     logging.info('conveyor-preparer: stopped')
 
 
-def preparer(once, sleep_time, bulk, partition_wait_time=10):
+def preparer(once, sleep_time, bulk, ignore_availability: bool, partition_wait_time: int = 10):
     # Make an initial heartbeat so that all instanced daemons have the correct worker number on the next try
     logger_prefix = executable = 'conveyor-preparer'
     transfertools = config_get_list('conveyor', 'transfertool', False, None)
@@ -100,6 +100,7 @@ def preparer(once, sleep_time, bulk, partition_wait_time=10):
             run_once,
             transfertools=transfertools,
             bulk=bulk,
+            ignore_availability=ignore_availability,
         ),
         activities=None,
     )
@@ -110,6 +111,7 @@ def run_once(
         bulk: int = 100,
         heartbeat_handler: "Optional[HeartbeatHandler]" = None,
         session: "Optional[Session]" = None,
+        ignore_availability: bool = False,
         **kwargs
 ) -> bool:
     if heartbeat_handler:
@@ -124,14 +126,15 @@ def run_once(
     requests_handled = 0
     try:
         admin_accounts = list_transfer_admin_accounts()
-        topology = Topology.create_from_config(logger=logger)
+        topology = Topology.create_from_config(logger=logger, ignore_availability=ignore_availability)
         requests_with_sources = list_transfer_requests_and_source_replicas(
             total_workers=total_workers,
             worker_number=worker_number,
             limit=bulk,
             request_state=RequestState.PREPARING,
             request_type=[RequestType.TRANSFER, RequestType.STAGEIN],
-            session=session
+            session=session,
+            ignore_availability=ignore_availability
         )
         ret = build_transfer_paths(
             topology=topology,

{rucio-1.30.5 → rucio-1.30.7}/lib/rucio/rse/protocols/gfal.py

@@ -436,14 +436,16 @@ class Default(protocol.RSEProtocol):
         :raises RucioException: if it failed to copy the file.
         """
         ctx = self.__ctx
+        if transfer_timeout:
+            ctx.set_opt_integer("HTTP PLUGIN", "OPERATION_TIMEOUT", transfer_timeout)
+            ctx.set_opt_integer("SRM PLUGIN", "OPERATION_TIMEOUT", transfer_timeout)
+            ctx.set_opt_integer("GRIDFTP PLUGIN", "OPERATION_TIMEOUT", transfer_timeout)
+            watchdog = Timer(int(transfer_timeout) + 60, self.__gfal2_cancel)
         params = ctx.transfer_parameters()
         if src_spacetoken:
             params.src_spacetoken = str(src_spacetoken)
         if dest_spacetoken:
             params.dst_spacetoken = str(dest_spacetoken)
-        if transfer_timeout:
-            params.timeout = int(transfer_timeout)
-            watchdog = Timer(params.timeout + 60, self.__gfal2_cancel)
 
         if not (self.renaming and dest[:5] == 'https'):
             dir_name = os.path.dirname(dest)
@@ -458,6 +460,7 @@ class Default(protocol.RSEProtocol):
 
         try:
             if transfer_timeout:
+                params.timeout = int(transfer_timeout)
                 watchdog.start()
             ret = ctx.filecopy(params, str(src), str(dest))
             if transfer_timeout:

{rucio-1.30.5 → rucio-1.30.7}/lib/rucio/tests/common.py

@@ -13,6 +13,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from collections import namedtuple
 import contextlib
 import itertools
 import json
@@ -226,3 +227,6 @@ def load_test_conf_file(file_name):
     config_dir = next(filter(lambda d: os.path.exists(os.path.join(d, file_name)), get_config_dirs()))
     with open(os.path.join(config_dir, file_name)) as f:
         return json.load(f)
+
+
+RSE_namedtuple = namedtuple('RSE_namedtuple', ['name', 'id'])

{rucio-1.30.5 → rucio-1.30.7}/lib/rucio/tests/test_conveyor.py

@@ -12,7 +12,7 @@
 # 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 logging
 import threading
 import time
 from datetime import datetime, timedelta
@@ -41,7 +41,7 @@ from rucio.daemons.conveyor.preparer import preparer
 from rucio.daemons.conveyor.submitter import submitter
 from rucio.daemons.conveyor.stager import stager
 from rucio.daemons.conveyor.throttler import throttler
-from rucio.daemons.conveyor.receiver import receiver, graceful_stop as receiver_graceful_stop
+from rucio.daemons.conveyor.receiver import receiver, graceful_stop as receiver_graceful_stop, Receiver
 from rucio.daemons.reaper.reaper import reaper
 from rucio.db.sqla import models
 from rucio.db.sqla.constants import LockState, RequestState, RequestType, ReplicaState, RSEType, RuleState
@@ -599,6 +599,75 @@ def test_multihop_receiver_on_success(vo, did_factory, root_account, core_config
         receiver_graceful_stop.clear()
 
 
+@skip_rse_tests_with_accounts
+@pytest.mark.dirty(reason="leaves files in XRD containers")
+@pytest.mark.noparallel(reason="uses predefined RSEs; runs submitter and receiver")
+@pytest.mark.parametrize("caches_mock", [{"caches_to_mock": [
+    'rucio.core.rse.REGION',
+    'rucio.core.rse_expression_parser.REGION',
+    'rucio.core.config.REGION',
+    'rucio.rse.rsemanager.RSE_REGION',  # for RSE info
+]}], indirect=True)
+def test_receiver_archiving(vo, did_factory, root_account, caches_mock):
+    """
+    Ensure that receiver doesn't mark archiving requests as DONE
+    """
+
+    src_rse = 'XRD3'
+    src_rse_id = rse_core.get_rse_id(rse=src_rse, vo=vo)
+    dst_rse = 'XRD4'
+    dst_rse_id = rse_core.get_rse_id(rse=dst_rse, vo=vo)
+    all_rses = [src_rse_id, dst_rse_id]
+
+    received_messages = {}
+
+    class ReceiverWrapper(Receiver):
+        """
+        Wrap receiver to record the last handled message for each given request_id
+        """
+        def _perform_request_update(self, msg, *, session=None, logger=logging.log):
+            ret = super()._perform_request_update(msg, session=session, logger=logger)
+            received_messages[msg['file_metadata']['request_id']] = msg
+            return ret
+
+    with patch('rucio.daemons.conveyor.receiver.Receiver', ReceiverWrapper):
+        receiver_thread = threading.Thread(target=receiver, kwargs={'id_': 0, 'full_mode': True, 'all_vos': True, 'total_threads': 1})
+        receiver_thread.start()
+        # Fake that destination RSE is a tape
+        rse_core.update_rse(rse_id=dst_rse_id, parameters={'rse_type': RSEType.TAPE})
+        try:
+            rse_core.add_rse_attribute(dst_rse_id, 'archive_timeout', 60)
+
+            did = did_factory.upload_test_file(src_rse)
+            rule_core.add_rule(dids=[did], account=root_account, copies=1, rse_expression=dst_rse, grouping='ALL', weight=None, lifetime=None, locked=False, subscription_id=None)
+            submitter(once=True, rses=[{'id': rse_id} for rse_id in all_rses], group_bulk=2, partition_wait_time=0, transfertype='single', filter_transfertool=None)
+
+            # Wait for the reception of the FTS Completion message for the submitted request
+            request = request_core.get_request_by_did(rse_id=dst_rse_id, **did)
+            for i in range(MAX_POLL_WAIT_SECONDS):
+                if request['id'] in received_messages:
+                    break
+                if i == MAX_POLL_WAIT_SECONDS - 1:
+                    assert False  # Waited too long; fail the test
+                time.sleep(1)
+            assert __wait_for_fts_state(request, expected_state='ARCHIVING') == 'ARCHIVING'
+
+            # Receiver must not mark "ARCHIVING" requests as "DONE"
+            request = request_core.get_request_by_did(rse_id=dst_rse_id, **did)
+            assert request['state'] == RequestState.SUBMITTED
+            # Poller should also correctly handle "ARCHIVING" transfers and not mark them as DONE
+            poller(once=True, older_than=0, partition_wait_time=0)
+            request = request_core.get_request_by_did(rse_id=dst_rse_id, **did)
+            assert request['state'] == RequestState.SUBMITTED
+        finally:
+            rse_core.update_rse(rse_id=dst_rse_id, parameters={'rse_type': RSEType.DISK})
+            rse_core.del_rse_attribute(dst_rse_id, 'archive_timeout')
+
+            receiver_graceful_stop.set()
+            receiver_thread.join(timeout=5)
+            receiver_graceful_stop.clear()
+
+
 @skip_rse_tests_with_accounts
 @pytest.mark.noparallel(reason="runs multiple conveyor daemons")
 @pytest.mark.parametrize("file_config_mock", [{
@@ -640,7 +709,7 @@ def test_preparer_throttler_submitter(rse_factory, did_factory, root_account, fi
     submitter(once=True, rses=[{'id': rse_id} for rse_id in all_rses], group_bulk=2, partition_wait_time=0, transfertype='single', filter_transfertool=None)
 
     # One RSE has limits set: the requests will be moved to WAITING status; the other RSE has no limits: go directly to queued
-    preparer(once=True, sleep_time=1, bulk=100, partition_wait_time=0)
+    preparer(once=True, sleep_time=1, bulk=100, partition_wait_time=0, ignore_availability=False)
     request = request_core.get_request_by_did(rse_id=dst_rse_id1, **did1)
     assert request['state'] == RequestState.WAITING
     request = request_core.get_request_by_did(rse_id=dst_rse_id1, **did2)
@@ -1480,3 +1549,40 @@ def test_checksum_validation(rse_factory, did_factory, root_account):
     request = __wait_for_request_state(dst_rse_id=dst_rse3_id, state=RequestState.FAILED, **did)
     assert 'Source and destination checksums do not match' in request['err_msg']
     assert request['state'] == RequestState.FAILED
+
+
+@pytest.mark.noparallel(reason="runs multiple conveyor daemons")
+@pytest.mark.parametrize("file_config_mock", [{
+    "overrides": [('conveyor', 'use_preparer', 'true')]
+}], indirect=True)
+@pytest.mark.parametrize("caches_mock", [{"caches_to_mock": [
+    'rucio.core.topology.REGION',
+]}], indirect=True)
+def test_preparer_ignore_availability(rse_factory, did_factory, root_account, file_config_mock, caches_mock):
+    """
+    Integration test of the preparer/throttler workflow.
+    """
+
+    def __setup_test():
+        src_rse, src_rse_id = rse_factory.make_posix_rse()
+        dst_rse, dst_rse_id = rse_factory.make_posix_rse()
+
+        distance_core.add_distance(src_rse_id, dst_rse_id, distance=10)
+        for rse_id in [src_rse_id, dst_rse_id]:
+            rse_core.add_rse_attribute(rse_id, 'fts', TEST_FTS_HOST)
+        did = did_factory.upload_test_file(src_rse)
+        rule_core.add_rule(dids=[did], account=root_account, copies=1, rse_expression=dst_rse, grouping='ALL', weight=None, lifetime=None, locked=False, subscription_id=None)
+
+        rse_core.update_rse(src_rse_id, {'availability_read': False})
+
+        return src_rse_id, dst_rse_id, did
+
+    src_rse_id, dst_rse_id, did = __setup_test()
+    preparer(once=True, sleep_time=1, bulk=100, partition_wait_time=0, ignore_availability=False)
+    request = request_core.get_request_by_did(rse_id=dst_rse_id, **did)
+    assert request['state'] == RequestState.NO_SOURCES
+
+    src_rse_id, dst_rse_id, did = __setup_test()
+    preparer(once=True, sleep_time=1, bulk=100, partition_wait_time=0, ignore_availability=True)
+    request = request_core.get_request_by_did(rse_id=dst_rse_id, **did)
+    assert request['state'] == RequestState.QUEUED

{rucio-1.30.5 → rucio-1.30.7}/lib/rucio/tests/test_conveyor_submitter.py

@@ -209,7 +209,12 @@ def test_multihop_sources_created(rse_factory, did_factory, root_account, core_c
     'rucio.daemons.reaper.reaper.REGION',
     'rucio.core.rse_expression_parser.REGION',  # The list of multihop RSEs is retrieved by an expression
 ]}], indirect=True)
-def test_source_avoid_deletion(caches_mock, core_config_mock, rse_factory, did_factory, root_account):
+@pytest.mark.parametrize("file_config_mock", [
+    # Run test twice: with, and without, temp tables
+    {"overrides": [('core', 'use_temp_tables', 'True')]},
+    {"overrides": [('core', 'use_temp_tables', 'False')]},
+], indirect=True)
+def test_source_avoid_deletion(caches_mock, core_config_mock, rse_factory, did_factory, root_account, file_config_mock):
     """ Test that sources on a file block it from deletion """
 
     _, reaper_region, _ = caches_mock
@@ -299,6 +304,7 @@ def test_ignore_availability(rse_factory, did_factory, root_account, core_config
     submitter(once=True, rses=[{'id': rse_id} for rse_id in (src_rse_id, dst_rse_id)], partition_wait_time=None, transfertools=['mock'], transfertype='single', ignore_availability=True)
     request = request_core.get_request_by_did(rse_id=dst_rse_id, **did)
     assert request['state'] == RequestState.SUBMITTED
+    assert request['transfertool'] == 'mock'
 
 
 @pytest.mark.noparallel(reason="multiple submitters cannot be run in parallel due to partial job assignment by hash")
@@ -374,8 +380,10 @@ def test_globus(rse_factory, did_factory, root_account):
         assert job_did2['metadata']['name'] == did2['name']
     request = request_core.get_request_by_did(rse_id=rse2_id, **did1)
     assert request['state'] == RequestState.SUBMITTED
+    assert request['transfertool'] == 'globus'
     request = request_core.get_request_by_did(rse_id=rse4_id, **did2)
     assert request['state'] == RequestState.SUBMITTED
+    assert request['transfertool'] == 'globus'
 
 
 @pytest.mark.noparallel(reason="multiple submitters cannot be run in parallel due to partial job assignment by hash")