rucio 1.30.6__tar.gz → 1.30.7__tar.gz

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

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

{rucio-1.30.6 → 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.6 → 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.6 → 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.6 → 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.6 → 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.6 → 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.6 → 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.6 → 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

{rucio-1.30.6 → rucio-1.30.7}/lib/rucio/tests/test_judge_evaluator.py

@@ -21,17 +21,23 @@ from rucio.common.utils import generate_uuid as uuid
 from rucio.core.account import get_usage
 from rucio.core.account_limit import set_local_account_limit
 from rucio.core.did import add_did, attach_dids, detach_dids
-from rucio.core.lock import get_replica_locks, get_dataset_locks
+from rucio.core.lock import get_dataset_locks, get_replica_locks, get_replica_locks_for_rule_id
+from rucio.core.replica import add_replica
 from rucio.core.rse import add_rse_attribute
 from rucio.core.rule import add_rule, get_rule
 from rucio.daemons.abacus.account import account_update
 from rucio.daemons.judge.evaluator import re_evaluator
-from rucio.db.sqla.constants import DIDType
+from rucio.db.sqla.constants import DIDType, LockState
 from rucio.db.sqla.models import UpdatedDID
 from rucio.db.sqla.session import transactional_session
+from rucio.tests.common import RSE_namedtuple
 from rucio.tests.common_server import get_vo
 from rucio.tests.test_rule import create_files, tag_generator
 
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from rucio.tests.temp_factories import TemporaryDidFactory, TemporaryRSEFactory
+
 
 @pytest.fixture(scope="class")
 def setup_class(request, rse_factory_unittest):
@@ -372,3 +378,140 @@ class TestJudgeEvaluator:
         # Check if the Locks are created properly
         for file in more_files:
             assert len(get_replica_locks(scope=file['scope'], name=file['name'])) == 2
+
+
+def test_judge_double_rule_on_container(
+    did_factory: "TemporaryDidFactory",
+    rse_factory: "TemporaryRSEFactory",
+    root_account: "InternalAccount"
+):
+    """
+    JUDGE EVALUATOR:
+    Test the judge evaluator on a container with two rules. The order in which
+    rules and datasets are added is relevant to the testcase.
+
+    1. A container C is created and a first dataset D1 is added to C.
+    2. A first rule A is created on the container C.
+    3. Then another dataset D2 is added to the container C.
+    4. Then a rule B is created on the container C.
+    5. Run judge-evaluator.
+
+    NOTE I am unsure whether the judge-evaluator is expected to run here.
+
+    We assert that both rules must be in state OK. Both rules must be applied to
+    each DID that can be traced back to the parent container C.
+    """
+    # create RSE, setup
+    RSE = RSE_namedtuple(*rse_factory.make_mock_rse())
+    rsekey, rseval = tag_generator(), tag_generator()
+    add_rse_attribute(RSE.id, rsekey, rseval)
+
+    # 1. create container C, add dataset D1 (with file F1)
+    C = did_factory.make_container()
+    D1 = did_factory.make_dataset()
+    attach_dids(dids=[D1], account=root_account, **C)
+    F1 = did_factory.random_file_did()
+    add_replica(rse_id=RSE.id, account=root_account, bytes_=10, **F1)
+    attach_dids(dids=[F1], account=root_account, **D1)
+
+    # 2. Add rule A to container C
+    # > bind C to RSE using RSE name
+    A, = add_rule(
+        dids=[C],
+        account=root_account,
+        copies=1,
+        rse_expression=RSE.name,
+        grouping="DATASET",
+        weight=None,
+        lifetime=None,
+        locked=False,
+        subscription_id=None
+    )
+
+    # 3. Add dataset D2 to container C (with file F2)
+    D2 = did_factory.make_dataset()
+    attach_dids(dids=[D2], account=root_account, **C)
+    F2 = did_factory.random_file_did()
+    add_replica(rse_id=RSE.id, account=root_account, bytes_=10, **F2)
+    attach_dids(dids=[F2], account=root_account, **D2)
+
+    # 4. Add rule B to container C
+    # > bind C to RSE using RSE attribute
+    B, = add_rule(
+        dids=[C],
+        account=root_account,
+        copies=1,
+        rse_expression=f"{rsekey}={rseval}",
+        grouping="DATASET",
+        weight=None,
+        lifetime=None,
+        locked=False,
+        subscription_id=None
+    )
+
+    # 5. Run fake judge-evaluator
+    re_evaluator(once=True, did_limit=1000)
+
+    # Assertions
+    for ruleid in (A, B):
+        locks = get_replica_locks_for_rule_id(ruleid)
+        assert len(locks) == 2  # 2 locks
+        assert all([lock["state"] == LockState.OK for lock in locks])  # all OK
+
+
+def test_judge_double_container_with_existing_rule(
+    did_factory: "TemporaryDidFactory",
+    rse_factory: "TemporaryRSEFactory",
+    root_account: "InternalAccount"
+):
+    """
+    JUDGE EVALUATOR:
+    Test the judge in attaching to a file structure with two nested
+    containers. The root container has a rule.
+    """
+    RSE = RSE_namedtuple(*rse_factory.make_mock_rse())
+
+    # create container C1 with rule
+    C1 = did_factory.make_container()
+
+    add_rule(
+        dids=[C1],
+        account=root_account,
+        copies=1,
+        rse_expression=RSE.name,
+        grouping='DATASET',
+        weight=None,
+        lifetime=None,
+        locked=False,
+        subscription_id=None
+    )
+
+    # create setup: C2->D->F
+    C2 = did_factory.make_container()
+    D = did_factory.make_dataset()
+    F = did_factory.random_file_did()
+    add_replica(rse_id=RSE.id, account=root_account, bytes_=10, **F)
+
+    attach_dids(dids=[F], account=root_account, **D)
+    attach_dids(dids=[D], account=root_account, **C2)
+
+    # attach setup to C1 (result: C1->C2->D->F)
+    attach_dids(dids=[C2], account=root_account, **C1)
+
+    # fake judge
+    re_evaluator(once=True, did_limit=1000)
+
+    # assertions
+    replicalocks = get_replica_locks(**F)
+    assert len(replicalocks) == 1
+    assert replicalocks[0].state == LockState.OK
+    datasetlocks = list(get_dataset_locks(**D))
+    assert len(datasetlocks) == 1
+    assert datasetlocks[0]["state"] == LockState.OK
+
+    # detach again
+    detach_dids(dids=[C2], **C1)
+    re_evaluator(once=True, did_limit=1000)
+
+    assert not get_replica_locks(**F)
+    assert not get_replica_locks(**D)

{rucio-1.30.6 → rucio-1.30.7}/lib/rucio/tests/test_rse_protocol_xrootd.py

@@ -95,3 +95,6 @@ class TestRseXROOTD(MgrTestCases):
     def setup_obj(self, setup_rse_and_files, vo):
         rse_settings, tmpdir, user = setup_rse_and_files
         self.init(tmpdir=tmpdir, rse_settings=rse_settings, user=user, vo=vo)
+
+    def test_delete_mgr_ok_dir(self):
+        raise pytest.skip("Not implemented")

{rucio-1.30.6 → rucio-1.30.7}/lib/rucio/transfertool/fts3.py

@@ -583,7 +583,7 @@ class FTS3CompletionMessageTransferStatusReport(Fts3TransferStatusReport):
         reason = fts_message.get('t__error_message', None)
         # job_state = fts_message.get('t_final_transfer_state', None)
         new_state = None
-        if str(fts_message['t_final_transfer_state']) == FTS_COMPLETE_STATE.OK:  # pylint:disable=no-member
+        if str(fts_message['t_final_transfer_state']) == FTS_COMPLETE_STATE.OK and not fts_message.get('is_archiving'):  # pylint:disable=no-member
             new_state = RequestState.DONE
         elif str(fts_message['t_final_transfer_state']) == FTS_COMPLETE_STATE.ERROR:
             request = self.request(session)

{rucio-1.30.6 → rucio-1.30.7}/lib/rucio/vcsversion.py

@@ -4,8 +4,8 @@ This file is automatically generated; Do not edit it. :)
 '''
 VERSION_INFO = {
     'final': True,
-    'version': '1.30.6',
+    'version': '1.30.7',
     'branch_nick': 'release-1.30',
-    'revision_id': '82390181cf8dc300ec59afeb569ad0be93819e7f',
-    'revno': 12373
+    'revision_id': '93f5033cba845ef8ec0c0d52a014ffad79cf337c',
+    'revno': 12384
 }