rucio 35.7.0__py3-none-any.whl

rucio-35.7.0.data/scripts/rucio-dumper

@@ -0,0 +1,160 @@
+#!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 datetime
+import logging
+import sys
+
+import tabulate
+
+import rucio.common.dumper.consistency as consistency
+import rucio.common.dumper.data_models as data_models
+from rucio.common.dumper import error
+
+logger = logging.getLogger('rucio-dumper')
+libs_logger = logging.getLogger('dumper')
+logger.setLevel(logging.WARNING)
+libs_logger.setLevel(logging.WARNING)
+
+handler = logging.StreamHandler(sys.stderr)
+logger.addHandler(handler)
+libs_logger.addHandler(handler)
+
+formatter = logging.Formatter(
+    "%(asctime)s  %(name)-22s  %(levelname)-8s %(message)s"
+)
+handler.setFormatter(formatter)
+
+
+def get_parser():
+    """
+    Returns the argparse parser.
+    """
+    parser = argparse.ArgumentParser(description="This daemon is responsible to make file list dumps. The rucio-auditor daemon use these dumps to discover dark data and check Rucio database consistency.")
+    format_args = parser.add_mutually_exclusive_group(required=False)
+
+    fields_or_hide = parser.add_mutually_exclusive_group(required=False)
+    fields_or_hide.add_argument('--fields', help='Comma separated list of fields that should be printed')
+    fields_or_hide.add_argument('--hide', help='Comma separated list of fields that should not be printed')
+    fields_or_hide.add_argument('--group-by', help='Group records, according to the the indicated fields FIXME')
+
+    # FIXME: Check that --group-by is given in order to use sum
+    parser.add_argument('--sum', help='Summatory of the values of the given fields (only numerical fields and should be used in combination with --group-by)')
+
+    common_args = (
+        ('rse', 'Name of the RSE (Rucio endpoint)'),
+        ('--date', 'Date of the dump (format dd-mm-yyyy or "latest") [defaults to "latest"]'),
+        ('--filter', 'Filter by field value field=value,field2=value2,... (see --valid-fields)'),
+        ('--valid-fields', 'Prints the valid fields for the selected dump and exits'),
+    )
+
+    format_args.add_argument('--csv', action='store_true', help='Format the output as a CSV with headers')
+    format_args.add_argument('--csv-nohead', action='store_true', help='Format the output as a CSV without headers (default)', default=True)
+    format_args.add_argument('--tabulate', help='Format the output as a table (printing large tables can take several minutes)', choices=[str(fmt) for fmt in tabulate.tabulate_formats])
+
+    subparser = parser.add_subparsers(title='dump', help='dump data FIXME', dest='subcommand')
+
+    dds_parser = subparser.add_parser('dump-datasets', help='List the dump of all datasets for a given RSE')
+    dcdds_parser = subparser.add_parser('dump-complete-datasets', help='List the dump of all complete datasets for a given RSE')
+    dreplicas_parser = subparser.add_parser('dump-replicas', help='List the dump of all replicas for a given RSE')
+    consistency.populate_args(subparser)
+
+    for arg in common_args:
+        dds_parser.add_argument(arg[0], help=arg[1])
+        dcdds_parser.add_argument(arg[0], help=arg[1])
+        dreplicas_parser.add_argument(arg[0], help=arg[1])
+    return parser
+
+
+if __name__ == "__main__":
+    parser = get_parser()
+    args = parser.parse_args()
+
+    if 'date' in args:
+        if args.date is None or args.date == 'latest':
+            args.date = 'latest'
+        else:
+            args.date = datetime.datetime.strptime(args.date, '%d-%m-%Y')
+
+    if args.subcommand == 'dump-datasets':
+        record_type = data_models.Dataset
+    elif args.subcommand == 'dump-complete-datasets':
+        record_type = data_models.CompleteDataset
+    elif args.subcommand == 'dump-replicas':
+        record_type = data_models.Replica
+    elif args.subcommand in consistency.subcommands:
+        record_type = consistency.Consistency
+    else:
+        raise ValueError("Record type not set! Cannot dump files.")
+
+    if 'filter' in args and args.filter:
+        user_filter = data_models.Filter(args.filter, record_type).match
+    else:
+        user_filter = None
+
+    if args.subcommand.startswith('dump-'):
+        data = record_type.dump(args.rse, args.date, filter_=user_filter)
+    else:
+        args_dict = consistency.parse_args(args)
+        data = record_type.dump(**args_dict)
+
+    fields = set(record_type.get_fieldnames())
+
+    if 'group_by' in args and args.group_by:
+        if args.group_by not in fields:
+            raise ValueError("Group_by option %s not supported." % args.group_by)
+        fields = [args.group_by]
+        data_iter = data
+        data_dict = {}
+        for record in data_iter:
+            key = getattr(record, args.group_by)
+            if key not in data_dict:
+                data_dict[key] = []
+            data_dict[key].append(record)
+
+        if 'sum' in args and args.sum:
+            if args.sum not in set(record_type.get_fieldnames()):
+                raise ValueError("Sum option %s for record type %s not supported.\nChoice from %s" % (args.sum, args.record_type, set(record_type.get_fieldnames())))
+            fields.append(args.sum)
+            data = []
+            for key, value in data_dict.items():
+                total = sum(getattr(x, args.sum) for x in value)
+                # FIXME: Ugly hack to have some result
+                setattr(value[0], args.sum, total)
+                data.append(value[0])
+        else:
+            data = data_dict.values()
+
+    if args.fields:
+        _show_fields = args.fields.split(',')
+        if not all(f in fields for f in _show_fields):
+            error('Invalid field in --fields argument')
+        fields = _show_fields
+    elif args.hide:
+        _hide_fields = args.hide.split(',')
+        if not all(f in fields for f in _hide_fields):
+            error('Invalid field in --hide argument')
+        fields = [f for f in fields if f not in _hide_fields]
+
+    if args.csv:
+        print(record_type.csv_header(fields))
+        for record in data:
+            print(record.csv(fields))
+    elif args.csv_nohead:
+        for record in data:
+            print(record.csv(fields))
+    elif args.tabulate:
+        print(record_type.tabulate_from(data, format_=args.tabulate, fields=fields))

rucio-35.7.0.data/scripts/rucio-follower

@@ -0,0 +1,44 @@
+#!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.
+
+"""
+Follower is a daemon to aggregate all the events affecting the dids
+"""
+
+import argparse
+import signal
+
+from rucio.daemons.follower.follower import run, stop
+
+
+def get_parser():
+    """
+    Returns the argparse parser.
+    """
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--run-once", action="store_true", default=False, help='Runs one loop iteration')
+    parser.add_argument("--threads", action="store", default=1, type=int, help='Concurrency control: total number of threads on 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, threads=args.threads)
+    except KeyboardInterrupt:
+        stop()

rucio-35.7.0.data/scripts/rucio-hermes

@@ -0,0 +1,54 @@
+#!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.
+
+"""
+Hermes is a daemon that gets the messages and sends them to external services (influxDB, ES, ActiveMQ).
+"""
+
+import argparse
+import signal
+
+from rucio.daemons.hermes.hermes import run, stop
+
+
+def get_parser():
+    """
+    Returns the argparse parser.
+    """
+    parser = argparse.ArgumentParser(description="Hermes is a daemon that get the messages and sends them to external services (influxDB, ES, ActiveMQ).", formatter_class=argparse.RawDescriptionHelpFormatter, epilog='''
+Run the daemon::
+
+  $ rucio-hermes --run-once
+    ''')
+    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("--bulk", action="store", default=1000, type=int, help='Bulk control: number of requests per cycle')
+    parser.add_argument("--sleep-time", action="store", default=10, type=int, help='Delay control: second control per cycle')
+    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,
+            bulk=args.bulk,
+            sleep_time=args.sleep_time)
+    except KeyboardInterrupt:
+        stop()

rucio-35.7.0.data/scripts/rucio-judge-cleaner

@@ -0,0 +1,89 @@
+#!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.
+
+"""
+Judge-Cleaner is a daemon to clean expired replication rules.
+"""
+
+import argparse
+import signal
+
+from rucio.daemons.judge.cleaner import run, stop
+
+
+def get_parser():
+    """
+    Returns the argparse parser.
+    """
+    parser = argparse.ArgumentParser(description="The Judge-Cleaner daemon is responsible for cleaning expired replication rules. It deletes rules by checking if the 'expired_at' date property is older than the current timestamp. If the rule is expired, it will first remove one lock for the replica and parent datasets if the DID belongs to any. Then it will set a tombstone to the replica to mark it as deletable if there are no rules protecting the replica. After these steps, the rule gets deleted.", epilog='''
+Upload a file to your RSE::
+
+  $ rucio upload --rse MOCK --scope mock --name file filename.txt
+
+Set a replication rule for the file with a lifetime of one second::
+
+  $ rucio add-rule mock:file 1 MOCK2 --lifetime 1
+
+Check the replication rules and the replicas::
+
+  $ rucio list-rules mock:file
+  ID                                ACCOUNT    SCOPE:NAME    STATE[OK/REPL/STUCK]    RSE_EXPRESSION      COPIES  EXPIRES (UTC)        CREATED (UTC)
+  --------------------------------  ---------  ------------  ----------------------  ----------------  --------  -------------------  -------------------
+  c273c7ed75724143ad21c667e659456b  root       mock:file     REPLICATING[0/1/0]      MOCK2                    1  2018-12-03 09:53:09  2018-12-03 09:53:08
+  06f012771b0546dca0c908441c048964  root       mock:file     OK[1/0/0]               MOCK                     1                       2018-12-03 09:52:19
+
+  $ python
+  from rucio.db.sqla import session, models
+  from rucio.core.rse import get_rse_id
+  rse_id = get_rse_id('MOCK2')
+  session.get_session().query(models.RSEFileAssociation).filter_by(name='file', scope='mock', rse_id=rse_id).first().tombstone // None
+  session.get_session().query(models.RSEFileAssociation).filter_by(name='file', scope='mock', rse_id=rse_id).first().lock_cnt // 1
+
+The first rule was created with an expiration date of one second after the creation date.
+
+Run the daemon::
+
+  $ rucio-judge-cleaner --run-once
+
+Check the replication rules and the replicas::
+
+  $ rucio list-rules mock:file
+  ID                                ACCOUNT    SCOPE:NAME    STATE[OK/REPL/STUCK]    RSE_EXPRESSION      COPIES  EXPIRES (UTC)    CREATED (UTC)
+  --------------------------------  ---------  ------------  ----------------------  ----------------  --------  ---------------  -------------------
+  06f012771b0546dca0c908441c048964  root       mock:file     OK[1/0/0]               MOCK                     1                   2018-12-03 09:52:19
+
+  $ python
+  from rucio.db.sqla import session, models
+  from rucio.core.rse import get_rse_id
+  rse_id = get_rse_id('MOCK2')
+  session.get_session().query(models.RSEFileAssociation).filter_by(name='file', scope='mock', rse_id=rse_id).first().tombstone // datetime.datetime(1970, 1, 1, 0, 0)
+  session.get_session().query(models.RSEFileAssociation).filter_by(name='file', scope='mock', rse_id=rse_id).first().lock_cnt // 0
+
+The rule we created before was deleted and the replica of the file on RSE MOCK2 got a tombstone because there is no protecting rule anymore.
+    ''', formatter_class=argparse.RawDescriptionHelpFormatter)
+    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')
+    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, sleep_time=args.sleep_time)
+    except KeyboardInterrupt:
+        stop()

rucio-35.7.0.data/scripts/rucio-judge-evaluator

@@ -0,0 +1,137 @@
+#!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.
+
+"""
+Judge-Evaluator is a daemon to re-evaluate replication rules.
+"""
+
+import argparse
+import signal
+
+from rucio.daemons.judge.evaluator import run, stop
+
+
+def get_parser():
+    """
+    Returns the argparse parser.
+    """
+    parser = argparse.ArgumentParser(description="The Judge-Evaluator daemon is responsible for execution and reevaluation of replication rules.\
+ First it checks if there are DIDs that have changed content e.g. attached or detached DIDs.In case of a new attachment, the replication rule for\
+ the dataset has to be applied to the attached DID, too. If the attached DID has already a replica on a RSE that satisfies the RSE expression of the\
+ rule, then the lock counter of that replica gets increased. If it does not have any replica satisfying the rule, then a new replica has to be created.\
+ In case of a new detachment, the replica has to be removed or the lock counter of the replica has to be decreased, depending on which RSE the replica exist.\
+ If the DID is a dataset, its properties like size and length also get updated and also an entry is saved to mark a change for possible collection replicas which have to be updated by another daemon.", epilog='''
+Same RSEs:
+Create a dataset with a replication rule and upload a file to the same RSE. Then attach it to the dataset::
+
+  $ rucio add-dataset mock:dataset
+  $ rucio add-rule mock:dataset 1 MOCK
+  $ rucio upload --scope mock --rse MOCK --name file filename.txt
+  $ rucio attach mock:dataset mock:file
+
+Check the rules and locks for the dataset and the replica::
+
+  $ rucio list-rules mock:dataset
+  ID                                ACCOUNT    SCOPE:NAME    STATE[OK/REPL/STUCK]    RSE_EXPRESSION      COPIES  EXPIRES (UTC)    CREATED (UTC)
+  --------------------------------  ---------  ------------  ----------------------  ----------------  --------  ---------------  -------------------
+  e95941c165d54e38b6e46990de06d3d4  root       mock:dataset  OK[0/0/0]               MOCK                     1                   2018-12-03 12:35:43
+
+  $ rucio list-rule mock:file
+  ID                                ACCOUNT    SCOPE:NAME    STATE[OK/REPL/STUCK]    RSE_EXPRESSION      COPIES  EXPIRES (UTC)    CREATED (UTC)
+  --------------------------------  ---------  ------------  ----------------------  ----------------  --------  ---------------  -------------------
+  cfec9a944cdd4543b7267a34a2584631  root       mock:file     OK[1/0/0]               MOCK                     1                   2018-12-11 08:29:49
+
+  $ python
+  from rucio.db.sqla import session, models
+  from rucio.core.rse import get_rse_id
+  rse_id = get_rse_id('MOCK')
+  session.get_session().query(models.RSEFileAssociation).filter_by(name='file', scope='mock', rse_id=rse_id).first().lock_cnt // 1
+
+There is one rule for the dataset which we created before and one lock and one rule for the replica which got created with the upload of the file.
+
+Run the daemon::
+
+  $ rucio-judge-evaluator --run-once
+
+Check the locks for the replica again::
+
+  $ python
+  from rucio.db.sqla import session, models
+  from rucio.core.rse import get_rse_id
+  rse_id = get_rse_id('MOCK')
+  session.get_session().query(models.RSEFileAssociation).filter_by(name='file', scope='mock', rse_id=rse_id).first().lock_cnt // 2
+
+The replica of the DID mock:file has now 2 locks on RSE MOCK, because it is protected by the replication rule of the dataset and the first replication rule
+
+Different RSEs:
+Create a dataset with a replication rule and upload a file to another RSE. Then attach it to the dataset::
+
+  $ rucio add-dataset mock:dataset
+  $ rucio add-rule mock:dataset 1 MOCK
+  $ rucio upload --scope mock --rse MOCK2 --name file filename.txt
+  $ rucio attach mock:dataset mock:file
+
+Check the rules and locks for the dataset and the replica::
+
+  $ rucio list-rules mock:dataset
+  ID                                ACCOUNT    SCOPE:NAME    STATE[OK/REPL/STUCK]    RSE_EXPRESSION      COPIES  EXPIRES (UTC)    CREATED (UTC)
+  --------------------------------  ---------  ------------  ----------------------  ----------------  --------  ---------------  -------------------
+  e95941c165d54e38b6e46990de06d3d4  root       mock:dataset  OK[0/0/0]               MOCK                     1                   2018-12-03 12:35:43
+
+  $ rucio list-rule mock:file
+  ID                                ACCOUNT    SCOPE:NAME    STATE[OK/REPL/STUCK]    RSE_EXPRESSION      COPIES  EXPIRES (UTC)    CREATED (UTC)
+  --------------------------------  ---------  ------------  ----------------------  ----------------  --------  ---------------  -------------------
+  cfec9a944cdd4543b7267a34a2584631  root       mock:file     OK[1/0/0]               MOCK2                    1                   2018-12-11 08:29:49
+
+  $ python
+  from rucio.db.sqla import session, models
+  from rucio.core.rse import get_rse_id
+  rse_id = get_rse_id('MOCK2')
+  session.get_session().query(models.RSEFileAssociation).filter_by(name='file', scope='mock', rse_id=rse_id).first().lock_cnt // 1
+
+There is one rule for the dataset which we created before and one lock and one rule for the replica which got created with the upload of the file.
+
+Run the daemon::
+
+  $ rucio-judge-evaluator --run-once
+
+Check the replicas for the DID mock:file::
+
+  $ python
+  from rucio.db.sqla import session, models
+  session.get_session().query(models.RSEFileAssociation).filter_by(name='file', scope='mock').first()
+  // [{'name': 'file','lock_cnt': 1, 'state': COPYING, 'scope': 'mock', 'rse_id': 'f81f366593754c01b0c340fa5ea0ab90'},
+  //  {'scope': 'mock', 'rse_id': '1330d5daee37474c88ba888101d7b859', 'name': 'file', 'state': AVAILABLE, 'lock_cnt': 1}]
+
+The DID mock:file has now two replicas with one lock each.
+As the file replica is attached to the dataset and the rule for the dataset specifies another RSE MOCK instead of the upload RSE, it has to be replicated to this RSE.
+Therefore a second replica in state COPYING got created on RSE MOCK.
+    ''', formatter_class=argparse.RawDescriptionHelpFormatter)
+    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 for this process')
+    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("--did-limit", action="store", default=100, type=int, help='Maximum number of dids to evaluate')
+    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, sleep_time=args.sleep_time, did_limit=args.did_limit)
+    except KeyboardInterrupt:
+        stop()

rucio-35.7.0.data/scripts/rucio-judge-injector

@@ -0,0 +1,44 @@
+#!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.
+
+"""
+Judge-Injector is a daemon to asynchronously inject replication rules.
+"""
+
+import argparse
+import signal
+
+from rucio.daemons.judge.injector import run, stop
+
+
+def get_parser():
+    """
+    Returns the argparse parser.
+    """
+    parser = argparse.ArgumentParser(description="Judge-Injector is a daemon to asynchronously inject replication rules.")
+    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 for this process')
+    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__":
+    signal.signal(signal.SIGTERM, stop)
+    parser = get_parser()
+    args = parser.parse_args()
+    try:
+        run(once=args.run_once, threads=args.threads, sleep_time=args.sleep_time)
+    except KeyboardInterrupt:
+        stop()

rucio-35.7.0.data/scripts/rucio-judge-repairer

@@ -0,0 +1,44 @@
+#!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.
+
+"""
+Judge-Repairer is a daemon to repair stuck replication rules.
+"""
+
+import argparse
+import signal
+
+from rucio.daemons.judge.repairer import run, stop
+
+
+def get_parser():
+    """
+    Returns the argparse parser.
+    """
+    parser = argparse.ArgumentParser(description="The Judge-Repairer daemon is responsible for the repair of stuck replication rules.")
+    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 for this process')
+    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__":
+    signal.signal(signal.SIGTERM, stop)
+    parser = get_parser()
+    args = parser.parse_args()
+    try:
+        run(once=args.run_once, threads=args.threads, sleep_time=args.sleep_time)
+    except KeyboardInterrupt:
+        stop()

rucio-35.7.0.data/scripts/rucio-kronos

@@ -0,0 +1,43 @@
+#!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.
+"""
+Kronos is a daemon that consumes tracer messages and updates the replica atime accordingly.
+"""
+
+import argparse
+import signal
+
+from rucio.daemons.tracer.kronos import run, stop
+
+
+def get_parser():
+    """
+    Returns the argparse parser.
+    """
+    parser = argparse.ArgumentParser(description="Kronos is a daemon that consume tracer massages and update the replica accessed time accordingly.")
+    parser.add_argument("--threads", action="store", default=1, type=int, help='Concurrency control: number of threads')
+    parser.add_argument('--sleep-time-files', action="store", default=60, type=int, help='Seconds to sleep between two cycles for the file thread')
+    parser.add_argument('--sleep-time-datasets', action="store", default=60, type=int, help='Seconds to sleep between two cycles for the dataset thread')
+    return parser
+
+
+if __name__ == "__main__":
+    signal.signal(signal.SIGTERM, stop)
+    parser = get_parser()
+    args = parser.parse_args()
+    try:
+        run(threads=args.threads, sleep_time_files=args.sleep_time_files, sleep_time_datasets=args.sleep_time_datasets)
+    except KeyboardInterrupt:
+        stop()

rucio-35.7.0.data/scripts/rucio-minos

@@ -0,0 +1,53 @@
+#!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.
+
+'''
+Minos Daemon :
+Minos is the name of one of the judge on the underworld in the greek mythology.
+The role of the daemon is get as input the list of PFNs declared bad
+and to class them into 2 categories :
+- The ones temporary available
+- The ones that have a real problem and that will need to be recovered by the necromancer
+'''
+
+import argparse
+import signal
+
+from rucio.daemons.badreplicas.minos import run, stop
+
+
+def get_parser():
+    """
+    Returns the argparse parser.
+    """
+    parser = argparse.ArgumentParser(description="The role of the daemon is get as input the list of PFNs declared bad and to classify them into 2 categories: the temporary available ones, and the ones that have a real problem and that will need to be recovered by the necromancer.")  # noqa E501
+    parser.add_argument("--run-once", action="store_true", default=False, help='Runs one loop iteration')
+    parser.add_argument("--threads", action="store", default=1, type=int, help='Concurrency control: number of threads')
+    parser.add_argument("--bulk", action="store", default=1000, type=int, help='Bulk control: number of requests per cycle')
+    parser.add_argument('--sleep-time', action="store", default=60, type=int, help='Seconds to sleep if few requests')
+    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, bulk=args.bulk, once=args.run_once, sleep_time=args.sleep_time)
+    except KeyboardInterrupt:
+        stop()