rucio 35.7.0__py3-none-any.whl

rucio-35.7.0.data/scripts/rucio-atropos

@@ -0,0 +1,60 @@
+#!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.
+
+'''
+Atropos Daemon : End the life of the rules according to the Lifetime Model
+'''
+
+import argparse
+import datetime
+import signal
+
+from rucio.daemons.atropos.atropos import run, stop
+
+
+def get_parser() -> argparse.ArgumentParser:
+    """
+    Returns the argparse parser.
+    """
+    parser = argparse.ArgumentParser(description='The Atropos Daemon is responsible for the deletion of rules with expired eol_at (end the life at), according to the Lifetime Model. Once the rule is deleted, the replicas covered by the rule will not be protected anymore and eventually, will be deleted by another daemon.')  # noqa E501
+    parser.add_argument("--run-once", action="store_true", default=False, help='Runs one loop iteration')
+    parser.add_argument("--dry-run", action="store_true", default=False, help='Dry run mode')
+    parser.add_argument("--threads", action="store", default=1, type=int, help='Concurrency control: number of threads')
+    parser.add_argument("--grace-period", action="store", default=86400, type=int, help='Grace period for the rules. In seconds !!!')
+    parser.add_argument("--date-check", action="store", help='Date when the lifetime model will be applied. Cannot be used for a date in the future if dry-run is not enabled',
+                        default=datetime.datetime.utcnow(), type=lambda d: datetime.datetime.strptime(d, '%Y-%m-%d'))
+    parser.add_argument("--unlock-rules", action="store_true", default=False, help='Automatically unlock affected rules')
+    parser.add_argument("--spread-period", action="store", default=0, type=int, help='Set the rules to randomly expire over a period (in seconds). Uses a uniform distribution')
+    parser.add_argument("--purge-replicas", action="store_true", default=False, help='Set the replicas to be deleted instead of secondarised')
+    parser.add_argument('--sleep-time', action="store", default=60, 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()
+    try:
+        run(threads=args.threads, date_check=args.date_check,
+            dry_run=args.dry_run, grace_period=args.grace_period,
+            once=args.run_once, unlock=args.unlock_rules,
+            spread_period=args.spread_period,
+            purge_replicas=args.purge_replicas,
+            sleep_time=args.sleep_time)
+    except KeyboardInterrupt:
+        stop()

rucio-35.7.0.data/scripts/rucio-auditor

@@ -0,0 +1,205 @@
+#!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
+
+
+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):
+    RETRY_AFTER = 60 * 60 * 24 * 14  # Two weeks
+
+    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-35.7.0.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-35.7.0.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-35.7.0.data/scripts/rucio-c3po

@@ -0,0 +1,85 @@
+#!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.
+
+"""
+C-3PO is a dynamic data placement daemon.
+"""
+
+import argparse
+import signal
+
+from rucio.common.utils import StoreAndDeprecateWarningAction
+from rucio.daemons.c3po.c3po import run, stop
+
+
+def get_parser():
+    """
+    Returns the argparse parser.
+    """
+    parser = argparse.ArgumentParser(description="The C3PO daemon is responsible for dynamic data placement.")
+    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: number of threads')
+    parser.add_argument("--only-workload", action="store_true", default=False, help='Only run the workload collector')
+    parser.add_argument("--dry_run", "--dry-run", new_option_string="--dry-run", action=StoreAndDeprecateWarningAction, default=False, help='Do not create any rules')
+    parser.add_argument("--sampling", action="store_true", default=False, help='In the end flip a to decide to create a rule or not')
+    parser.add_argument("--algorithms", action="store", default="t2_free_space_only_pop_with_network", type=str, help='The placement algorithm or, if in dry_run, a comma separated list of algorithms')
+    parser.add_argument("--datatypes", action="store", default="NTUP,DAOD", type=str, help='Comma separated list of datatype that should trigger the placement')
+    parser.add_argument("--dest_rse_expr", "--dest-rse-expr", new_option_string="--dest-rse-expr", action=StoreAndDeprecateWarningAction, default="type=DATADISK", type=str, help='RSE expression defining the allowed destination RSEs')
+    parser.add_argument("--max_bytes_hour", "--max-bytes-hour", new_option_string="--max-bytes-hour", action=StoreAndDeprecateWarningAction, default=100000000000000, type=int, help='Max number of bytes that c3po is allow to replicate per hour')
+    parser.add_argument("--max_files_hour", "--max-files-hour", new_option_string="--max-files-hour", action=StoreAndDeprecateWarningAction, default=100000, type=int, help='Max number of files that c3po is allow to replicate per hour')
+    parser.add_argument("--max_bytes_hour_rse", "--max-bytes-hour-rse", new_option_string="--max-bytes-hour-rse", action=StoreAndDeprecateWarningAction, default=50000000000000, type=int, help='Max number of bytes that c3po is allow to replicate per hour per rse')  # NOQA: E501
+    parser.add_argument("--max_files_hour_rse", "--max-files-hour-rse", new_option_string="--max-files-hour-rse", action=StoreAndDeprecateWarningAction, default=10000, type=int, help='Max number of files that c3po is allow to replicate per hour prse_rse')
+    parser.add_argument("--min_popularity", "--min-popularity", new_option_string="--min-popularity", action=StoreAndDeprecateWarningAction, default=8, type=int, help='Min number of popularity accesses for a DID in the last 7 days to trigger')
+    parser.add_argument("--min_recent_requests", "--min-recent-requests", new_option_string="--min-recent-requests", action=StoreAndDeprecateWarningAction, default=5, type=int, help='Min number of times a DID has to be requested in the last hour to trigger')  # NOQA: E501
+    parser.add_argument("--max_replicas", "--max-replicas", new_option_string="--max-replicas", action=StoreAndDeprecateWarningAction, default=5, type=int, help='Max number of replicas above which not to trigger anymore')
+    parser.add_argument('--waiting-time-read-free-space', action="store", default=1800, type=int, help='Waiting time for reading free space')
+    parser.add_argument('--waiting-time-read-workload', action="store", default=1800, type=int, help='Waiting time for reading workload')
+    parser.add_argument('--waiting-time-print-workload', action="store", default=600, type=int, help='Waiting time for printing workload')
+    parser.add_argument('--waiting-time-read-dids', action="store", default=60, type=int, help='Waiting time for reading dids')
+    parser.add_argument('--waiting-time-place-replica', action="store", default=100, type=int, help='Waiting time for placing replicas')
+    parser.add_argument('--sleep-time', action="store", default=10, type=int, help='Concurrency control: thread sleep time after each chunk of work')
+    return parser
+
+
+if __name__ == "__main__":
+
+    signal.signal(signal.SIGTERM, stop)
+    parser = get_parser()
+    args = parser.parse_args()
+
+    try:
+        run(once=args.run_once,
+            threads=args.threads,
+            only_workload=args.only_workload,
+            dry_run=args.dry_run,
+            sampling=args.sampling,
+            algorithms=args.algorithms,
+            datatypes=args.datatypes,
+            dest_rse_expr=args.dest_rse_expr,
+            max_bytes_hour=args.max_bytes_hour,
+            max_files_hour=args.max_files_hour,
+            max_bytes_hour_rse=args.max_bytes_hour_rse,
+            max_files_hour_rse=args.max_files_hour_rse,
+            min_popularity=args.min_popularity,
+            min_recent_requests=args.min_recent_requests,
+            max_replicas=args.max_replicas,
+            waiting_time_read_free_space=args.waiting_time_read_free_space,
+            waiting_time_read_workload=args.waiting_time_read_workload,
+            waiting_time_print_workload=args.waiting_time_print_workload,
+            waiting_time_read_dids=args.waiting_time_read_dids,
+            waiting_time_place_replica=args.waiting_time_place_replica,
+            sleep_time=args.sleep_time)
+    except KeyboardInterrupt:
+        stop()

rucio-35.7.0.data/scripts/rucio-cache-client

@@ -0,0 +1,134 @@
+#!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, config_get_int
+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'
+        }
+"""
+    oparser = argparse.ArgumentParser(description="This daemons is used to populate information of replicas on volatile storage.",
+                                      prog=os.path.basename(sys.argv[0]), add_help=True)
+
+    # Main arguments
+    oparser.add_argument('-b', '--broker', dest='broker', default=config_get('messaging-cache', 'brokers').split(',')[0], help='Message broker name')
+    oparser.add_argument('-p', '--port', dest='port', default=config_get_int('messaging-cache', 'port'), help='Message broker port')
+    oparser.add_argument('-c', '--certificate', dest='ssl_cert_file', default=config_get('messaging-cache', 'ssl_cert_file'), help='Certificate file')
+    oparser.add_argument('-k', '--certificate-key', dest='ssl_key_file', default=config_get('messaging-cache', 'ssl_key_file'), help='Certificate key file')
+    oparser.add_argument('-d', '--destination', dest='destination', default=config_get('messaging-cache', '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-35.7.0.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()