rucio 32.8.6__py3-none-any.whl → 35.8.0__py3-none-any.whl

rucio/core/temporary_did.py

@@ -1,188 +0,0 @@
-# -*- coding: utf-8 -*-
-# 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.
-
-from datetime import datetime
-from typing import TYPE_CHECKING
-
-from sqlalchemy import and_, or_, func, delete
-from sqlalchemy.sql.expression import case, insert, update
-
-from rucio.core.did import attach_dids
-from rucio.core.replica import add_replica
-from rucio.db.sqla import models, filter_thread_work
-from rucio.db.sqla.session import read_session, transactional_session
-
-# from rucio.rse import rsemanager as rsemgr
-
-if TYPE_CHECKING:
-    from sqlalchemy.orm import Session
-
-
-@transactional_session
-def add_temporary_dids(dids, account, *, session: "Session"):
-    """
-    Bulk add temporary data identifiers.
-
-    :param dids: A list of dids.
-    :param account: The account owner.
-    :param session: The database session in use.
-    """
-    temporary_dids = []
-    for did in dids:
-
-        if did.get('pfn'):
-            did['path'] = did['pfn']
-            # In waiting to properly extract the path
-            # p = rsemgr.create_protocol(rse_settings=rsemgr.get_rse_info(rse, session=session), operation='write', scheme=scheme)
-            # if not replica_rse.deterministic:
-            #   pfns = p.parse_pfns(pfns=pfns)
-            #   tmp = pfns[file['pfn']]
-            # file['path'] = ''.join([tmp['path'], tmp['name']])
-
-        temporary_dids.append({'scope': did['scope'],
-                               'name': did['name'],
-                               'rse_id': did['rse_id'],
-                               'path': did.get('path'),
-                               'bytes': did.get('bytes'),
-                               'md5': did.get('md5'),
-                               'adler32': did.get('adler32'),
-                               'guid': did.get('guid'),
-                               'events': did.get('envents'),
-                               'parent_scope': did.get('parent_scope'),
-                               'parent_name': did.get('parent_name'),
-                               'offset': did.get('offset'),
-                               'expired_at': datetime.utcnow()})
-    try:
-        if temporary_dids:
-            session.execute(insert(models.TemporaryDataIdentifier), temporary_dids)
-    except:
-        raise
-
-
-@transactional_session
-def compose(scope, name, rse_id, bytes_, sources, account,
-            md5=None, adler32=None, pfn=None, meta={}, rules=[],
-            parent_scope=None, parent_name=None,
-            *, session: "Session"):
-    """
-    Concatenates a list of existing dids into a new file replica
-
-    :param scope: the scope name.
-    :param name: The data identifier name.
-    :param rse_id: the rse id.
-    :param bytes_: the size of the file.
-    :sources sources: The list of temporary DIDs.
-    :param account: The account owner.
-    :param md5: The md5 checksum.
-    :param adler32: The adler32 checksum.
-    :param pfn: Physical file name (for nondeterministic rse).
-    :param meta: Meta-data associated with the file. Represented as key/value pairs in a dictionary.
-    :param rules: Replication rules associated with the file. A list of dictionaries, e.g., [{'copies': 2, 'rse_expression': 'TIERS1'}, ].
-    :param parent_scope: Possible dataset scope.
-    :param parent_name: Possibe dataset name.
-    :param session: The database session in use.
-    """
-    # Create the new file did and replica
-    add_replica(rse_id=rse_id, scope=scope, name=name, bytes_=bytes_, account=account,
-                adler32=adler32, md5=md5, pfn=pfn, meta=meta, rules=rules,
-                session=session)
-
-    # Attach the file to a dataset
-    if parent_scope and parent_name:
-        attach_dids(scope=parent_scope, name=parent_name,
-                    dids=[{'scope': scope, 'name': name}], account=account,
-                    rse_id=None, session=session)
-
-    # Mark the merged dids as obsolete
-    now, expired_dids = datetime.utcnow(), []
-    for source in sources:
-        expired_dids.append({'scope': source['scope'],
-                             'name': source['name'],
-                             'expired_at': now})
-    if expired_dids:
-        session.execute(update(models.TemporaryDataIdentifier), expired_dids)
-
-
-@read_session
-def list_expired_temporary_dids(rse_id, limit, worker_number=None, total_workers=None,
-                                *, session: "Session"):
-    """
-    List expired temporary DIDs.
-
-    :param rse_id: the rse id.
-    :param limit: The maximum number of replicas returned.
-    :param worker_number:      id of the executing worker.
-    :param total_workers:      Number of total workers.
-    :param session: The database session in use.
-
-    :returns: a list of dictionary replica.
-    """
-    is_none = None
-    query = session.query(models.TemporaryDataIdentifier.scope,
-                          models.TemporaryDataIdentifier.name,
-                          models.TemporaryDataIdentifier.path,
-                          models.TemporaryDataIdentifier.bytes).\
-        with_hint(models.TemporaryDataIdentifier, "INDEX(tmp_dids TMP_DIDS_EXPIRED_AT_IDX)", 'oracle').\
-        filter(case((models.TemporaryDataIdentifier.expired_at != is_none, models.TemporaryDataIdentifier.rse_id)) == rse_id)
-
-    query = filter_thread_work(session=session, query=query, total_threads=total_workers, thread_id=worker_number, hash_variable='name')
-
-    return [{'path': path,
-             'rse_id': rse_id,
-             'scope': scope,
-             'name': name,
-             'bytes': bytes_}
-            for scope, name, path, bytes_ in query.limit(limit)]
-
-
-@transactional_session
-def delete_temporary_dids(dids, *, session: "Session"):
-    """
-    Delete temporary file replicas.
-
-    :param dids: the list of files to delete.
-    :param session
-    """
-    where_clause = []
-    for did in dids:
-        where_clause.append(and_(models.TemporaryDataIdentifier.scope == did['scope'],
-                                 models.TemporaryDataIdentifier.name == did['name']))
-
-    if where_clause:
-        stmt = delete(models.TemporaryDataIdentifier).\
-            prefix_with("/*+ INDEX(tmp_dids TMP_DIDS_PK) */", dialect='oracle').\
-            where(or_(*where_clause)).execution_options(synchronize_session=False)
-        result = session.execute(stmt)
-        return result.rowcount
-    return
-
-
-@read_session
-def get_count_of_expired_temporary_dids(rse_id, *, session: "Session"):
-    """
-    List expired temporary DIDs.
-
-    :param rse_id: the rse id.
-    :param session: The database session in use.
-
-    :returns: a count number.
-    """
-    is_none = None
-    count = session.query(func.count(models.TemporaryDataIdentifier.scope)).\
-        with_hint(models.TemporaryDataIdentifier, "INDEX(tmp_dids TMP_DIDS_EXPIRED_AT_IDX)", 'oracle').\
-        filter(case((models.TemporaryDataIdentifier.expired_at != is_none, models.TemporaryDataIdentifier.rse_id)) == rse_id).\
-        one()
-
-    return count[0] or 0

rucio/daemons/reaper/light_reaper.py

@@ -1,255 +0,0 @@
-# -*- coding: utf-8 -*-
-# 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.
-
-'''
-Light Reaper is a daemon to manage temporary object/file deletion.
-'''
-
-import hashlib
-import logging
-import os
-import random
-import socket
-import sys
-import threading
-import time
-import traceback
-from typing import TYPE_CHECKING
-
-import rucio.db.sqla.util
-from rucio.common.config import config_get_bool
-from rucio.common.exception import (SourceNotFound, DatabaseException, ServiceUnavailable,
-                                    RSEAccessDenied, RSENotFound, ResourceTemporaryUnavailable, VONotFound)
-from rucio.common.logging import setup_logging, formatted_logger
-from rucio.common.utils import daemon_sleep
-from rucio.core import rse as rse_core
-from rucio.core.heartbeat import live, die, sanity_check
-from rucio.core.message import add_message
-from rucio.core.rse_expression_parser import parse_expression
-from rucio.core.temporary_did import (list_expired_temporary_dids, delete_temporary_dids)
-from rucio.core.vo import list_vos
-from rucio.rse import rsemanager as rsemgr
-
-if TYPE_CHECKING:
-    from types import FrameType
-    from typing import Optional
-
-logging.getLogger("requests").setLevel(logging.CRITICAL)
-
-GRACEFUL_STOP = threading.Event()
-DAEMON_NAME = 'reaper'
-
-
-def reaper(rses=[], worker_number=0, total_workers=1, chunk_size=100, once=False, scheme=None, sleep_time=60):
-    """
-    Main loop to select and delete files.
-
-    :param rses: List of RSEs the reaper should work against. If empty, it considers all RSEs.
-    :param worker_number: The worker number.
-    :param total_workers:  The total number of workers.
-    :param chunk_size: the size of chunk for deletion.
-    :param once: If True, only runs one iteration of the main loop.
-    :param scheme: Force the reaper to use a particular protocol, e.g., mock.
-    :param sleep_time: Thread sleep time after each chunk of work.
-    """
-    logging.info('Starting Light Reaper %s-%s: Will work on RSEs: %s', worker_number, total_workers, ', '.join([rse['rse'] for rse in rses]))
-
-    pid = os.getpid()
-    thread = threading.current_thread()
-    hostname = socket.gethostname()
-    executable = ' '.join(sys.argv)
-    hash_executable = hashlib.sha256(sys.argv[0] + ''.join([rse['rse'] for rse in rses])).hexdigest()
-    sanity_check(executable=None, hostname=hostname)
-
-    while not GRACEFUL_STOP.is_set():
-        try:
-            # heartbeat
-            heartbeat = live(executable=executable, hostname=hostname, pid=pid, thread=thread, hash_executable=hash_executable)
-            prepend_str = 'light-reaper [%i/%i] : ' % (heartbeat['assign_thread'], heartbeat['nr_threads'])
-            logger = formatted_logger(logging.log, prepend_str + '%s')
-            logger(logging.INFO, 'Live gives %s', heartbeat)
-            nothing_to_do = True
-            start_time = time.time()
-
-            random.shuffle(rses)
-            for rse in rses:
-                rse_id = rse['id']
-                rse = rse['rse']
-                replicas = list_expired_temporary_dids(rse_id=rse_id,
-                                                       limit=chunk_size, worker_number=worker_number,
-                                                       total_workers=total_workers)
-
-                rse_info = rsemgr.get_rse_info(rse_id=rse_id)
-                prot = rsemgr.create_protocol(rse_info, 'delete', scheme=scheme)
-                deleted_replicas = []
-                try:
-                    prot.connect()
-                    for replica in replicas:
-                        nothing_to_do = False
-                        try:
-                            # pfn = str(rsemgr.lfns2pfns(rse_settings=rse_info,
-                            #                            lfns=[{'scope': replica['scope'].external, 'name': replica['name'], 'path': replica['path']}],
-                            #                            operation='delete', scheme=scheme).values()[0])
-                            pfn = 's3://%s%s%s' % (prot.attributes['hostname'], prot.attributes['prefix'], replica['name'])
-                            # logging.debug('Light Reaper %s-%s: Deletion ATTEMPT of %s:%s as %s on %s', worker_number, total_workers, replica['scope'], replica['name'], pfn, rse)
-                            start = time.time()
-                            prot.delete(pfn)
-                            duration = time.time() - start
-                            logger(logging.INFO, 'Deletion SUCCESS of %s:%s as %s on %s in %s seconds', replica['scope'], replica['name'], pfn, rse, duration)
-                            payload = {'scope': replica['scope'].external,
-                                       'name': replica['name'],
-                                       'rse': rse,
-                                       'rse_id': rse_id,
-                                       'file-size': replica.get('bytes') or 0,
-                                       'bytes': replica.get('bytes') or 0,
-                                       'url': pfn,
-                                       'duration': duration,
-                                       'protocol': prot.attributes['scheme']}
-                            if replica['scope'].vo != 'def':
-                                payload['vo'] = replica['scope'].vo
-                            add_message('deletion-done', payload)
-                            deleted_replicas.append(replica)
-                        except SourceNotFound:
-                            err_msg = 'Deletion NOTFOUND of %s:%s as %s on %s' % (replica['scope'], replica['name'], pfn, rse)
-                            logger(logging.WARNING, err_msg)
-                            deleted_replicas.append(replica)
-                        except (ServiceUnavailable, RSEAccessDenied, ResourceTemporaryUnavailable) as error:
-                            err_msg = 'Deletion NOACCESS of %s:%s as %s on %s: %s' % (replica['scope'], replica['name'], pfn, rse, str(error))
-                            logger(logging.WARNING, err_msg)
-                            payload = {'scope': replica['scope'].external,
-                                       'name': replica['name'],
-                                       'rse': rse,
-                                       'rse_id': rse_id,
-                                       'file-size': replica['bytes'] or 0,
-                                       'bytes': replica['bytes'] or 0,
-                                       'url': pfn,
-                                       'reason': str(error),
-                                       'protocol': prot.attributes['scheme']}
-                            if replica['scope'].vo != 'def':
-                                payload['vo'] = replica['scope'].vo
-                            add_message('deletion-failed', payload)
-
-                        except:
-                            logger(logging.CRITICAL, traceback.format_exc())
-                finally:
-                    prot.close()
-
-                delete_temporary_dids(dids=deleted_replicas)
-
-                if once:
-                    break
-
-            if once:
-                break
-
-            if nothing_to_do:
-                logger(logging.INFO, 'Nothing to do. I will sleep for 60s')
-                daemon_sleep(start_time=start_time, sleep_time=sleep_time, graceful_stop=GRACEFUL_STOP)
-
-        except DatabaseException as error:
-            logging.warning('Reaper:  %s', str(error))
-        except:
-            logging.critical(traceback.format_exc())
-
-    die(executable=executable, hostname=hostname, pid=pid, thread=thread, hash_executable=hash_executable)
-    logging.info('Graceful stop requested')
-    logging.info('Graceful stop done')
-    return
-
-
-def stop(signum: "Optional[int]" = None, frame: "Optional[FrameType]" = None) -> None:
-    """
-    Graceful exit.
-    """
-    GRACEFUL_STOP.set()
-
-
-def run(total_workers=1, chunk_size=100, once=False, rses=[], scheme=None,
-        exclude_rses=None, include_rses=None, vos=None, delay_seconds=0, sleep_time=60):
-    """
-    Starts up the reaper threads.
-
-    :param total_workers: The total number of workers.
-    :param chunk_size: the size of chunk for deletion.
-    :param once: If True, only runs one iteration of the main loop.
-    :param rses: List of RSEs the reaper should work against. If empty, it considers all RSEs. (Single-VO only)
-    :param scheme: Force the reaper to use a particular protocol/scheme, e.g., mock.
-    :param exclude_rses: RSE expression to exclude RSEs from the Reaper.
-    :param include_rses: RSE expression to include RSEs.
-    :param vos: VOs on which to look for RSEs. Only used in multi-VO mode.
-                If None, we either use all VOs if run from "def", or the current VO otherwise.
-    :param sleep_time: Thread sleep time after each chunk of work.
-    """
-    setup_logging(process_name=DAEMON_NAME)
-
-    if rucio.db.sqla.util.is_old_db():
-        raise DatabaseException('Database was not updated, daemon won\'t start')
-
-    logging.info('main: starting processes')
-
-    multi_vo = config_get_bool('common', 'multi_vo', raise_exception=False, default=False)
-    if not multi_vo:
-        if vos:
-            logging.warning('Ignoring argument vos, this is only applicable in a multi-VO setup.')
-        vos = ['def']
-    else:
-        if vos:
-            invalid = set(vos) - set([v['vo'] for v in list_vos()])
-            if invalid:
-                msg = 'VO{} {} cannot be found'.format('s' if len(invalid) > 1 else '', ', '.join([repr(v) for v in invalid]))
-                raise VONotFound(msg)
-        else:
-            vos = [v['vo'] for v in list_vos()]
-        logging.info('Light Reaper: This instance will work on VO%s: %s' % ('s' if len(vos) > 1 else '', ', '.join([v for v in vos])))
-
-    all_rses = []
-    for vo in vos:
-        all_rses.extend(rse_core.list_rses(filters={'vo': vo}))
-
-    if rses:
-        invalid = set(rses) - set([rse['rse'] for rse in all_rses])
-        if invalid:
-            msg = 'RSE{} {} cannot be found'.format('s' if len(invalid) > 1 else '',
-                                                    ', '.join([repr(rse) for rse in invalid]))
-            raise RSENotFound(msg)
-        rses = [rse for rse in all_rses if rse['rse'] in rses]
-    else:
-        rses = all_rses
-
-    if exclude_rses:
-        excluded_rses = parse_expression(exclude_rses)
-        rses = [rse for rse in rses if rse not in excluded_rses]
-
-    if include_rses:
-        included_rses = parse_expression(include_rses)
-        rses = [rse for rse in rses if rse in included_rses]
-
-    if not rses:
-        logging.error('Light Reaper: No RSEs found. Exiting.')
-        return
-
-    threads = []
-    for worker in range(total_workers):
-        kwargs = {'worker_number': worker,
-                  'total_workers': total_workers,
-                  'rses': rses,
-                  'once': once,
-                  'chunk_size': chunk_size,
-                  'scheme': scheme,
-                  'sleep_time': sleep_time}
-        threads.append(threading.Thread(target=reaper, kwargs=kwargs, name='Worker: %s, Total_Workers: %s' % (worker, total_workers)))
-    [t.start() for t in threads]
-    while threads[0].is_alive():
-        [t.join(timeout=3.14) for t in threads]

rucio/web/rest/flaskapi/v1/tmp_dids.py

@@ -1,115 +0,0 @@
-# -*- coding: utf-8 -*-
-# 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.
-
-from flask import Flask, request
-
-from rucio.api.temporary_did import add_temporary_dids
-from rucio.web.rest.flaskapi.authenticated_bp import AuthenticatedBlueprint
-from rucio.web.rest.flaskapi.v1.common import response_headers, ErrorHandlingMethodView, json_list
-
-
-class BulkDIDS(ErrorHandlingMethodView):
-
-    def post(self):
-        """
-        ---
-        summary: Add Temporary Data Identifiers
-        description: Bulk adds temporary data identifiers.
-        tags:
-          - Temporary Data Identifiers
-        requestBody:
-          content:
-            application/json:
-              schema:
-                description: A list of temporary dids.
-                type: array
-                items:
-                  description: A temporary did.
-                  properties:
-                    rse:
-                      description: The name of the RSE.
-                      type: string
-                    rse_id:
-                      description: The id of the RSE. Can be specified instead of the RSE name.
-                      type: string
-                    scope:
-                      description: The scope.
-                      type: string
-                    parent_scope:
-                      description: The parent scope.
-                      type: string
-                    name:
-                      description: The name of the DID.
-                      type: string
-                    path:
-                      description: The path of the DID.
-                      type: string
-                    pfn:
-                      description: The pfn of the DID.
-                      type: string
-                    bytes:
-                      description: The size of the DID in bytes.
-                      type: integer
-                    md5:
-                      description: The md5 checksum of the DID.
-                      type: string
-                    adler32:
-                      description: The adler32 checksum of the DID.
-                      type: string
-                    guid:
-                      description: The guid of the DID.
-                      type: string
-                    events:
-                      description: The events of the DID.
-                      type: string
-                    parent_name:
-                      description: The name of the parent.
-                      type: string
-                    offset:
-                      description: The offset of the DID.
-                      type: integer
-        responses:
-          201:
-            description: Created
-            content:
-              application/json:
-                schema:
-                  type: string
-                  enum: ["Created"]
-          401:
-            description: Invalid Auth Token
-          406:
-            description: Not acceptable
-        """
-        dids = json_list()
-        add_temporary_dids(dids=dids, issuer=request.environ.get('issuer'), vo=request.environ.get('vo'))
-        return 'Created', 201
-
-
-def blueprint():
-    bp = AuthenticatedBlueprint('tmp_dids', __name__, url_prefix='/tmp_dids')
-
-    bulk_dids_view = BulkDIDS.as_view('bulk_dids')
-    bp.add_url_rule('', view_func=bulk_dids_view, methods=['post', ])
-
-    bp.after_request(response_headers)
-    return bp
-
-
-def make_doc():
-    """ Only used for sphinx documentation """
-    doc_app = Flask(__name__)
-    doc_app.register_blueprint(blueprint())
-    return doc_app

rucio-32.8.6.data/data/rucio/requirements.txt

@@ -1,55 +0,0 @@
-# All dependencies needed to run rucio client (and server/daemons) should be defined here
-requests>=2.25.1,<=2.31.0                                   # Python HTTP for Humans.
-urllib3~=1.26.16                                            # HTTP library with thread-safe connection pooling, file post, etc.
-dogpile.cache~=1.2.2                                        # Caching API plugins (1.1.2 is the first version to support pymemcache)
-tabulate~=0.9.0                                             # Pretty-print tabular data
-jsonschema~=4.18.4                                          # For JSON schema validation (Policy modules)
-
-# All dependencies needed in extras for rucio client (and server/daemons) should be defined here
-paramiko~=3.4.0                                             # ssh_extras; SSH2 protocol library (also needed in the server)
-kerberos~=1.3.1                                             # kerberos_extras for client and server
-pykerberos~=1.2.4                                           # kerberos_extras for client and server
-requests-kerberos>=0.14.0                                   # kerberos_extras for client and server
-python-swiftclient~=4.3.0                                   # swift_extras
-argcomplete~=3.1.1                                          # argcomplete_extras; Bash tab completion for argparse
-python-magic~=0.4.27                                        # dumper_extras; File type identification using libmagic
-
-# All dependencies needed to run rucio server/daemons should be defined here
-SQLAlchemy==2.0.19                                          # DB backend
-alembic~=1.11.1                                             # Lightweight database migration tool for SQLAlchemy
-pymemcache==4.0.0                                           # A comprehensive, fast, pure-Python memcached client (Used by Dogpile)
-python-dateutil==2.8.2                                      # Extensions to the standard datetime module
-stomp.py==8.1.0                                             # ActiveMQ Messaging Protocol
-statsd==4.0.1                                               # Needed to log into graphite with more than 1 Hz
-geoip2==4.7.0                                               # GeoIP2 API (for IPv6 support)
-google-auth==2.22.0                                         # Google authentication library for Python
-redis==4.6.0                                                # Python client for Redis key-value store
-Flask==2.3.2                                                # Python web framework
-oic==1.6.1                                                  # for authentication via OpenID Connect protocol
-prometheus_client==0.17.1                                   # Python client for the Prometheus monitoring system
-boto3==1.28.5                                               # S3 boto protocol (new version)
-
-# All dependencies needed in extras for rucio server/daemons should be defined here
-cx_oracle==8.3.0                                            # oracle_extras
-psycopg2-binary==2.9.6                                      # postgresql_extras
-PyMySQL==1.1.0                                              # mysql_extras
-PyYAML==6.0.1                                               # globus_extras and used for reading test configuration files
-globus-sdk==3.24.0                                          # globus_extras
-python3-saml==1.15.0                                        # saml_extras
-pymongo==4.4.1                                              # pymongo (metadata plugin)
-
-# All dependencies needed to develop/test rucio should be defined here
-pytest==7.4.0
-pytest-xdist~=3.3.1                                         # Used for parallel testing
-pyflakes==3.0.1                                             # Passive checker of Python programs
-flake8==6.0.0                                               # Wrapper around PyFlakes&pep8; python_version < '3.9'
-pycodestyle==2.10.0                                         # New package replacing pep8; python_version < '3.9'
-pylint==3.0.0a7
-astroid==3.0.0a9
-virtualenv==20.24.0                                         # Virtual Python Environment builder
-xmltodict==0.13.0                                           # Makes working with XML feel like you are working with JSON
-pytz==2023.3                                                # World timezone definitions, modern and historical
-pydoc-markdown~=4.8.2                                       # Used for generating Markdown documentation for docusaurus
-sh~=2.0.4                                                   # Convenience library for running subprocesses in Python
-apispec==6.3.0                                              # Generate OpenApi definition out of pydoc comments
-apispec-webframeworks                                       # Integration of apispec in Flask

rucio-32.8.6.data/scripts/rucio-light-reaper

@@ -1,53 +0,0 @@
-#!python
-# -*- coding: utf-8 -*-
-# 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.
-
-"""
-Reaper is a daemon to manage sub-file deletion
-"""
-
-import argparse
-import signal
-
-from rucio.daemons.reaper.light_reaper import run, stop
-
-
-def get_parser():
-    """
-    Returns the argparse parser.
-    """
-    parser = argparse.ArgumentParser(description="The light-reaper is responsible of deletion of temporary files")
-    parser.add_argument("--run-once", action="store_true", default=False, help='One iteration only')
-    parser.add_argument("--total-workers", action="store", default=1, type=int, help='Total number of workers per process')
-    parser.add_argument("--chunk-size", action="store", default=10, type=int, help='Chunk size')
-    parser.add_argument("--scheme", action="store", default=None, type=str, help='Force the reaper to use a particular protocol, e.g., mock.')
-    parser.add_argument('--rses', nargs='+', type=str, help='List of RSEs')
-    parser.add_argument('--exclude-rses', action="store", default=None, type=str, help='RSEs expression to exclude RSEs')
-    parser.add_argument('--include-rses', action="store", default=None, type=str, help='RSEs expression to include RSEs')
-    parser.add_argument('--vos', nargs='+', type=str, help='Optional list of VOs to consider. Only used in multi-VO mode.')
-    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(total_workers=args.total_workers, chunk_size=args.chunk_size,
-            once=args.run_once, scheme=args.scheme, rses=args.rses,
-            exclude_rses=args.exclude_rses, include_rses=args.include_rses, vos=args.vos, sleep_time=args.sleep_time)
-    except KeyboardInterrupt:
-        stop()