rucio 37.0.0rc1__py3-none-any.whl

rucio-37.0.0rc1.data/scripts/rucio-auditor

@@ -0,0 +1,206 @@
+#!python
+# 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 argparse
+import logging
+import logging.handlers
+import os
+import signal
+import sys
+import textwrap
+import time
+from configparser import NoSectionError
+from datetime import datetime
+from functools import partial
+from multiprocessing import Event, Pipe, Process, Queue
+
+import rucio.common.config as config
+import rucio.common.dumper as dumper
+import rucio.daemons.auditor
+from rucio.client.rseclient import RSEClient
+from rucio.common.exception import RSENotFound
+
+RETRY_AFTER = 60 * 60 * 24 * 14  # Two weeks
+
+
+def setup_pipe_logger(pipe, loglevel):
+    logger = logging.getLogger('auditor')
+    logger.setLevel(loglevel)
+    handler = dumper.LogPipeHandler(pipe)
+    logger.addHandler(handler)
+
+    formatter = logging.Formatter(
+        "%(asctime)s  %(name)-22s  %(levelname)-8s %(message)s"
+    )
+    handler.setFormatter(formatter)
+    return logger
+
+
+def main(args):
+
+    nprocs = args.nprocs
+    if nprocs < 1:
+        raise RuntimeError("No Processes to Run")
+
+    if args.rses is None:
+        rses_gen = RSEClient().list_rses()
+    else:
+        rses_gen = RSEClient().list_rses(args.rses)
+
+    rses = [entry['rse'] for entry in rses_gen]
+    if len(rses) <= 0:
+        raise RSENotFound("No RSEs found to audit.")
+
+    procs = []
+    queue = Queue()
+    retry = Queue()
+    terminate = Event()
+    logpipes = []
+
+    loglevel = logging.getLevelName(config.config_get('common', 'loglevel'))
+
+    mainlogr, mainlogw = Pipe(duplex=False)
+    logpipes.append(mainlogr)
+    logger = setup_pipe_logger(mainlogw, loglevel)
+
+    if not config.config_has_section('auditor'):
+        raise NoSectionError("Auditor section required in config to run the auditor daemon.")
+
+    cache_dir = config.config_get('auditor', 'cache')
+    results_dir = config.config_get('auditor', 'results')
+
+    logfilename = os.path.join(config.config_get('common', 'logdir'), 'auditor.log')
+    logger.info('Starting auditor')
+
+    def termhandler(sign, trace):
+        logger.error('Main process received signal %d, terminating child processes', sign)
+        terminate.set()
+        for proc in procs:
+            proc.join()
+
+    signal.signal(signal.SIGTERM, termhandler)
+
+    for n in range(nprocs):
+        logpiper, logpipew = Pipe(duplex=False)
+        p = Process(
+            target=partial(
+                rucio.daemons.auditor.check,
+                queue,
+                retry,
+                terminate,
+                logpipew,
+                cache_dir,
+                results_dir,
+                args.keep_dumps,
+                args.delta,
+            ),
+            name='auditor-worker'
+        )
+        p.start()
+        procs.append(p)
+        logpipes.append(logpiper)
+
+    p = Process(
+        target=partial(
+            rucio.daemons.auditor.activity_logger,
+            logpipes,
+            logfilename,
+            terminate
+        ),
+        name='auditor-logger'
+    )
+    p.start()
+    procs.append(p)
+
+    last_run_month = None  # Don't check more than once per month. FIXME: Save on DB or file...
+
+    try:
+        while all(p.is_alive() for p in procs):
+            while last_run_month == datetime.utcnow().month:
+                time.sleep(60 * 60 * 24)
+
+            for rse in rses:
+                queue.put((rse, 1))
+
+            time.sleep(RETRY_AFTER)
+
+            # Avoid infinite loop if an alternative check() implementation doesn't
+            # decrement the number of attempts and keeps pushing failed checks.
+            tmp_list = []
+            while not retry.empty():
+                tmp_list.append(retry.get())
+
+            for each in tmp_list:
+                queue.put(each)
+
+    except:
+        logging.error('Main process failed: %s', sys.exc_info()[0])
+
+    terminate.set()
+    for proc in procs:
+        proc.join()
+
+
+def get_parser():
+    """
+    Returns the argparse parser.
+    """
+    parser = argparse.ArgumentParser(description="The auditor daemon is the one responsible for the detection of inconsistencies on storage, i.e.: dark data discovery.",
+                                     formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument(
+        '--nprocs',
+        help='Number subprocess, each subprocess check a fraction of the DDM '
+             'Endpoints in sequence (default: 1).',
+        default=1,
+        type=int,
+    )
+    parser.add_argument(
+        '--rses',
+        help='RSEs to check specified as a RSE expression, defaults to check '
+             'all the RSEs known to Rucio (default: check all RSEs).',
+        default=None,
+        type=str,
+    )
+    parser.add_argument(
+        '--keep-dumps',
+        help='Keep RSE and Rucio Replica Dumps on cache '
+             '(default: False).',
+        action='store_true',
+    )
+    parser.add_argument(
+        '--delta',
+        help='How many days older/newer than the RSE dump must the Rucio replica dumps be '
+             '(default: 3).',
+        default=3,
+        type=int,
+    )
+    parser.epilog = textwrap.dedent(r"""
+        examples:
+            # Check all RSEs using only 1 subprocess
+            %(prog)s
+
+            # Check all SCRATCHDISKs with 4 subprocesses
+            %(prog)s --nprocs 4 --rses "type=SCRATCHDISK"
+
+            # Check all Tier 2 DATADISKs, except "BLUE_DATADISK" and "RED_DATADISK"
+            %(prog)s --rses "tier=1&type=DATADISK\(BLUE_DATADISK|RED_DATADISK)"
+    """)
+    return parser
+
+
+if __name__ == '__main__':
+    parser = get_parser()
+    args = parser.parse_args()
+    main(args)

rucio-37.0.0rc1.data/scripts/rucio-automatix

@@ -0,0 +1,50 @@
+#!python
+# 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.
+
+"""
+Automatix (Dataset injector) Daemon
+"""
+
+import argparse
+import signal
+
+from rucio.daemons.automatix.automatix import run, stop
+
+
+def get_parser():
+    """
+    Returns the argparse parser.
+    """
+    parser = argparse.ArgumentParser(description="Automatix is a daemon used to inject random generated files to an RSE. It is used to continuously check that an RSE is reachable and operating as expected.")
+    parser.add_argument("--run-once", action="store_true", default=False, help='Runs one loop iteration')
+    parser.add_argument("--input-file", action="store", default="/opt/rucio/etc/automatix.json", type=str, help='Automatix configuration')
+    parser.add_argument("--threads-per-process", action="store", default=1, type=int, help='Total number of workers per process')
+    parser.add_argument('--sleep-time', action="store", default=-1, type=int, help='Concurrency control: thread sleep time after each chunk of work')
+    return parser
+
+
+if __name__ == "__main__":
+
+    # Bind our callback to the SIGTERM signal and run the daemon:
+    signal.signal(signal.SIGTERM, stop)
+
+    parser = get_parser()
+    args = parser.parse_args()
+    print('Start Automatix')
+    try:
+        run(total_workers=args.threads_per_process, once=args.run_once, inputfile=args.input_file,
+            sleep_time=args.sleep_time)
+    except KeyboardInterrupt:
+        stop()

rucio-37.0.0rc1.data/scripts/rucio-bb8

@@ -0,0 +1,57 @@
+#!python
+# 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.
+
+"""
+BB8 is a daemon to rebalance data.
+"""
+
+import argparse
+
+from rucio.daemons.bb8.bb8 import run
+from rucio.daemons.bb8.common import rebalance_rse
+
+
+def get_parser():
+    """
+    Returns the argparse parser.
+    """
+    parser = argparse.ArgumentParser(description='The BB8 daemon is responsible for rebalancing data between RSEs.')
+    parser.add_argument('--rse', action='store', help='RSE to rebalance. Can be either a RSE or RSE expression.')
+    parser.add_argument('--bytes', action='store', type=int, help='Number of bytes to expected to be rebalanced. It is a goal without guarantees')
+    parser.add_argument("--run-once", action="store_true", default=False, help='One iteration only')
+    parser.add_argument('--sleep-time', action="store", default=30, type=int, help='Concurrency control: thread sleep time after each chunk of work')
+    parser.add_argument("--threads", action="store", default=1, type=int, help='Concurrency control: total number of threads for this process')
+    parser.add_argument('--dry-run', action='store_true', default=False, help='Only run in dry-run mode')
+    parser.add_argument('--exclude-expression', action='store', help='Exclude these rse_expression from being destinations')
+    parser.add_argument('--comment', action='store', help='Add a comment to the new rules')
+    parser.add_argument('--force-expression', action='store', help='For this rse_expression for rebalanced rules instead of letting BB8 decide')
+    parser.add_argument('--decommission', action='store_true', help='Run BB8 in decommission mode')
+    parser.add_argument('--priority', action='store', help='Priority for the newly created rules', type=int, default=3)
+    parser.add_argument('--source-replica-expression', action='store', help='Source replica expression for the newly created rules')
+    return parser
+
+
+if __name__ == "__main__":
+    parser = get_parser()
+    args = parser.parse_args()
+
+    if args.decommission:
+        rebalance_rse(rse_id=args.rse, max_bytes=args.bytes, dry_run=args.dry_run,
+                      comment=args.comment, force_expression=args.force_expression,
+                      priority=args.priority,
+                      source_replica_expression=args.source_replica_expression,
+                      mode='decommission')
+    else:
+        run(once=args.run_once, rse_expression=args.rse, move_subscriptions=False, use_dump=False, sleep_time=args.sleep_time, threads=args.threads, dry_run=args.dry_run)

rucio-37.0.0rc1.data/scripts/rucio-cache-client

@@ -0,0 +1,141 @@
+#!python
+# 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.
+
+"""
+Rucio Cache client.
+"""
+
+import argparse
+import json
+import os
+import secrets
+import ssl
+import sys
+
+import stomp
+from jsonschema import validate
+
+from rucio.client.didclient import DIDClient
+from rucio.client.rseclient import RSEClient
+from rucio.common.config import config_get_items, config_has_section
+from rucio.common.exception import DataIdentifierNotFound
+from rucio.common.schema import get_schema_value
+
+SUCCESS = 0
+FAILURE = 1
+
+
+def validate_files(files):
+    """ validate files metadata"""
+    client = DIDClient()
+    for file in files:
+        try:
+            metadata = client.get_metadata(file["scope"], file["name"])
+        except DataIdentifierNotFound:
+            err = "%s:%s not found in rucio catalog" % (file["scope"], file["name"])
+            raise Exception(err)
+        if int(metadata["bytes"]) != int(file["bytes"]) or metadata["adler32"] != file["adler32"]:
+            err = "%s:%s(bytes:%s, adler32:%s) has different size or checksum with metadata(bytes:%s, adler32:%s)" % (file["scope"], file["name"], file["bytes"], file["adler32"], metadata["bytes"], metadata["adler32"])
+            raise Exception(err)
+
+
+def validate_rse(rse):
+    """ validate rse"""
+    # the rse should be volatile
+    client = RSEClient()
+    try:
+        rse_attributes = client.get_rse(rse)
+    except Exception as error:
+        raise Exception(error)
+
+    if not rse_attributes["volatile"]:
+        err = "%s volatile is not True, Rucio Cache should not update it." % (rse)
+        raise Exception(err)
+
+
+def cache_operation(args):
+    """ cache operation"""
+    payload = json.loads(args.message)
+    validate(payload, get_schema_value('MESSAGE_OPERATION'))
+    validate_rse(payload["rse"])
+    if payload["operation"] == "add_replicas":
+        validate(payload, get_schema_value('CACHE_ADD_REPLICAS'))
+        validate_files(payload["files"])
+    else:
+        validate(payload, get_schema_value('CACHE_DELETE_REPLICAS'))
+    conn = stomp.Connection([(args.broker, args.port)])
+    conn.set_ssl(key_file=args.ssl_key_file, cert_file=args.ssl_cert_file, ssl_version=ssl.PROTOCOL_TLSv1)
+
+    conn.connect()
+    message = {'id': secrets.randbelow(1001), 'payload': payload}
+    conn.send(destination=args.destination, body=json.dumps(message), id='rucio-cache-messaging', ack='auto', headers={'vo': 'atlas'})
+    conn.disconnect()
+
+
+def get_parser():
+    """
+    Returns the argparse parser.
+    """
+
+    message_help = """
+    Add replicas message:
+        {'files': [{'scope': scope, 'name': name, 'bytes': 1L, 'adler32': ''},
+                  {'scope': scope, 'name': name, 'bytes': 1L, 'adler32': ''}, ...],
+         'rse': rse_cache_name,
+         'lifetime': seconds,
+         'operation': 'add_replicas'
+        }
+
+    Delete replicas message:
+        {'files': [{'scope': scope, 'name': name}, {'scope': scope, 'name': name}, ...],
+         'rse': rse_cache_name,
+         'operation': 'delete_replicas'
+        }
+"""
+    description = "This daemon is used to populate information of replicas on volatile storage."
+
+    if not config_has_section("message-cache"):
+        defaults = {}
+        message_append = "WARNING: section 'messaging-cache' not present in config! All arguments must be manually set!\n"
+        description = message_append + description
+    else:
+        defaults = config_get_items("message-cache")
+
+    oparser = argparse.ArgumentParser(description=description, prog=os.path.basename(sys.argv[0]), add_help=True)
+
+    # Main arguments
+    oparser.add_argument('-b', '--broker', dest='broker', default=defaults.get('brokers', '').split(',')[0], help='Message broker name')
+    oparser.add_argument('-p', '--port', dest='port', type=int, default=defaults.get('port'), help='Message broker port')
+    oparser.add_argument('-c', '--certificate', dest='ssl_cert_file', default=defaults.get('ssl_cert_file'), help='Certificate file')
+    oparser.add_argument('-k', '--certificate-key', dest='ssl_key_file', default=defaults.get('ssl_key_file'), help='Certificate key file')
+    oparser.add_argument('-d', '--destination', dest='destination', default=defaults.get('destination'), help="Message broker topic")
+    oparser.add_argument('-m', '--message', dest='message', default=None, help=message_help)
+    return oparser
+
+
+if __name__ == '__main__':
+
+    oparser = get_parser()
+    if len(sys.argv) == 1:
+        oparser.print_help()
+        sys.exit(FAILURE)
+
+    args = oparser.parse_args(sys.argv[1:])
+    try:
+        result = cache_operation(args)
+        sys.exit(result)
+    except (RuntimeError, NotImplementedError) as e:
+        print("ERROR: ", e, file=sys.stderr)
+        sys.exit(FAILURE)

rucio-37.0.0rc1.data/scripts/rucio-cache-consumer

@@ -0,0 +1,42 @@
+#!python
+# 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.
+
+"""
+Rucio Cache Consumer is a daemon to add/delete cache replicas to Rucio catalog.
+"""
+
+import argparse
+import signal
+
+from rucio.daemons.cache.consumer import run, stop
+
+
+def get_parser():
+    """
+    Returns the argparse parser.
+    """
+    parser = argparse.ArgumentParser(description="Rucio Cache Consumer is a daemon to add/delete cache replicas to Rucio catalog.")
+    parser.add_argument("--num-thread", action="store", default=1, type=int, help='Concurrency control: threads number')
+    return parser
+
+
+if __name__ == "__main__":
+    signal.signal(signal.SIGTERM, stop)
+    parser = get_parser()
+    args = parser.parse_args()
+    try:
+        run(args.num_thread)
+    except KeyboardInterrupt:
+        stop()

rucio-37.0.0rc1.data/scripts/rucio-conveyor-finisher

@@ -0,0 +1,58 @@
+#!python
+# 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.
+
+"""
+Conveyor is a daemon to manage file transfers.
+"""
+
+import argparse
+import signal
+
+from rucio.daemons.conveyor.finisher import run, stop
+
+
+def get_parser():
+    """
+    Returns the argparse parser.
+    """
+    parser = argparse.ArgumentParser(description="Conveyor is a group of daemons to manage file transfers. The conveyor-finisher is the responsible to update Rucio internal state after the transfer has finished.")
+    parser.add_argument("--run-once", action="store_true", default=False,
+                        help='One iteration only')
+    parser.add_argument("--total-threads", action="store", default=1, type=int,
+                        help='Concurrency control: total number of threads per process')
+    parser.add_argument("--db-bulk", action="store", default=1000, type=int,
+                        help='Bulk control: number of transfers per db query')
+    parser.add_argument("--bulk", action="store", default=100, type=int,
+                        help='Bulk control: number of requests')
+    parser.add_argument('--sleep-time', action="store", default=30, type=int,
+                        help='Seconds to sleep if few requests')
+    parser.add_argument('--activities', nargs='+', type=str,
+                        help='Explicit list of activities to include')
+    return parser
+
+
+if __name__ == "__main__":
+    signal.signal(signal.SIGTERM, stop)
+    parser = get_parser()
+    args = parser.parse_args()
+    try:
+        run(once=args.run_once,
+            total_threads=args.total_threads,
+            sleep_time=args.sleep_time,
+            activities=args.activities,
+            db_bulk=args.db_bulk,
+            bulk=args.bulk)
+    except KeyboardInterrupt:
+        stop()

rucio-37.0.0rc1.data/scripts/rucio-conveyor-poller

@@ -0,0 +1,66 @@
+#!python
+# 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.
+
+"""
+Conveyor is a daemon to manage file transfers.
+"""
+
+import argparse
+import signal
+
+from rucio.daemons.conveyor.poller import run, stop
+
+
+def get_parser():
+    """
+    Returns the argparse parser.
+    """
+    parser = argparse.ArgumentParser(description="Conveyor is a daemon to manage file transfers. The conveyor-poller is in charge of poll the transfer tool to check if the submitted transfers are already done.")
+    parser.add_argument("--run-once", action="store_true", default=False,
+                        help='One iteration only')
+    parser.add_argument("--fts-bulk", action="store", default=100, type=int,
+                        help='Bulk control: number of transfers per FTS query')
+    parser.add_argument("--db-bulk", action="store", default=1000, type=int,
+                        help='Bulk control: number of transfers per db query')
+    parser.add_argument("--older-than", action="store", default=60, type=int,
+                        help='Poll control: older request more than this value to poll')
+    parser.add_argument('--sleep-time', action="store", default=300, type=int,
+                        help='Seconds to sleep if few requests')
+    parser.add_argument('--activities', nargs='+', type=str,
+                        help='Explicit list of activities to include')
+    parser.add_argument('--activity-shares', action='store', default=None, type=str,
+                        help='JSON-encoded string of an activity shares dictionary {"act_1": 0.2, "act_2": 0.4, ...}')
+    parser.add_argument('--total-threads', action="store", default=1, type=int,
+                        help='Concurrency control: total number of threads for this process')
+
+    return parser
+
+
+if __name__ == "__main__":
+
+    signal.signal(signal.SIGTERM, stop)
+    parser = get_parser()
+    args = parser.parse_args()
+    try:
+        run(once=args.run_once,
+            fts_bulk=args.fts_bulk,
+            db_bulk=args.db_bulk,
+            older_than=args.older_than,
+            sleep_time=args.sleep_time,
+            activities=args.activities,
+            activity_shares=args.activity_shares,
+            total_threads=args.total_threads)
+    except KeyboardInterrupt:
+        stop()

rucio-37.0.0rc1.data/scripts/rucio-conveyor-preparer

@@ -0,0 +1,37 @@
+#!python
+# 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 argparse
+import signal
+
+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, ignore_availability=args.ignore_availability)
+    except KeyboardInterrupt:
+        stop()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--run-once", action="store_true", default=False, help='One iteration only')
+    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())