rucio 32.8.6__py3-none-any.whl

rucio/transfertool/globus.py

@@ -0,0 +1,200 @@
+# -*- 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.
+
+import logging
+
+from rucio.common.utils import chunks
+from rucio.db.sqla.constants import RequestState
+from rucio.transfertool.transfertool import Transfertool, TransferToolBuilder, TransferStatusReport
+from .globus_library import bulk_submit_xfer, submit_xfer, bulk_check_xfers
+
+
+def bulk_group_transfers(transfer_paths, policy='single', group_bulk=200):
+    """
+    Group transfers in bulk based on certain criterias
+
+    :param transfer_paths:  List of (potentially multihop) transfer paths to group. Each path is a list of single-hop transfers.
+    :param policy:          Policy to use to group.
+    :param group_bulk:      Bulk sizes.
+    :return:                List of transfer groups
+    """
+    if policy == 'single':
+        group_bulk = 1
+
+    grouped_jobs = []
+    for chunk in chunks(transfer_paths, group_bulk):
+        # Globus doesn't support multihop. Get the first hop only.
+        transfers = [transfer_path[0] for transfer_path in chunk]
+
+        grouped_jobs.append({
+            'transfers': transfers,
+            # Job params are not used by globus transfertool, but are needed for further common fts/globus code
+            'job_params': {}
+        })
+
+    return grouped_jobs
+
+
+class GlobusTransferStatusReport(TransferStatusReport):
+
+    supported_db_fields = [
+        'state',
+        'external_id',
+    ]
+
+    def __init__(self, request_id, external_id, globus_response):
+        super().__init__(request_id)
+
+        if globus_response == 'FAILED':
+            new_state = RequestState.FAILED
+        elif globus_response == 'SUCCEEDED':
+            new_state = RequestState.DONE
+        else:
+            new_state = RequestState.SUBMITTED
+
+        self.state = new_state
+        self.external_id = None
+        if new_state in [RequestState.FAILED, RequestState.DONE]:
+            self.external_id = external_id
+
+    def initialize(self, session, logger=logging.log):
+        pass
+
+    def get_monitor_msg_fields(self, session, logger=logging.log):
+        return {'protocol': 'globus'}
+
+
+class GlobusTransferTool(Transfertool):
+    """
+    Globus implementation of Transfertool abstract base class
+    """
+
+    external_name = 'globus'
+    required_rse_attrs = ('globus_endpoint_id', )
+
+    def __init__(self, external_host, logger=logging.log, group_bulk=200, group_policy='single'):
+        """
+        Initializes the transfertool
+
+        :param external_host:   The external host where the transfertool API is running
+        """
+        if not external_host:
+            external_host = 'Globus Online Transfertool'
+        super().__init__(external_host, logger)
+        self.group_bulk = group_bulk
+        self.group_policy = group_policy
+        # TODO: initialize vars from config file here
+
+    @classmethod
+    def submission_builder_for_path(cls, transfer_path, logger=logging.log):
+        hop = transfer_path[0]
+        if not cls.can_perform_transfer(hop.src.rse, hop.dst.rse):
+            logger(logging.WARNING, "Source or destination globus_endpoint_id not set. Skipping {}".format(hop))
+            return [], None
+
+        return [hop], TransferToolBuilder(cls, external_host='Globus Online Transfertool')
+
+    def group_into_submit_jobs(self, transfer_paths):
+        jobs = bulk_group_transfers(transfer_paths, policy=self.group_policy, group_bulk=self.group_bulk)
+        return jobs
+
+    def submit_one(self, files, timeout=None):
+        """
+        Submit transfers to globus API
+
+        :param files:        List of dictionaries describing the file transfers.
+        :param job_params:   Dictionary containing key/value pairs, for all transfers.
+        :param timeout:      Timeout in seconds.
+        :returns:            Globus transfer identifier.
+        """
+
+        source_path = files[0]['sources'][0]
+        self.logger(logging.INFO, 'source_path: %s' % source_path)
+
+        source_endpoint_id = files[0]['metadata']['source_globus_endpoint_id']
+
+        # TODO: use prefix from rse_protocol to properly construct destination url
+        # parse and assemble dest_path for Globus endpoint
+        dest_path = files[0]['destinations'][0]
+        self.logger(logging.INFO, 'dest_path: %s' % dest_path)
+
+        # TODO: rucio.common.utils.construct_url logic adds unnecessary '/other' into file path
+        # s = dest_path.split('/') # s.remove('other') # dest_path = '/'.join(s)
+
+        destination_endpoint_id = files[0]['metadata']['dest_globus_endpoint_id']
+        job_label = files[0]['metadata']['request_id']
+
+        task_id = submit_xfer(source_endpoint_id, destination_endpoint_id, source_path, dest_path, job_label, recursive=False, logger=self.logger)
+
+        return task_id
+
+    def submit(self, transfers, job_params, timeout=None):
+        """
+        Submit a bulk transfer to globus API
+
+        :param transfers:    List of dictionaries describing the file transfers.
+        :param job_params:   Not used by Globus Transfsertool
+        :param timeout:      Timeout in seconds.
+        :returns:            Globus transfer identifier.
+        """
+
+        # TODO: support passing a recursive parameter to Globus
+        submitjob = [
+            {
+                # Some dict elements are not needed by globus transfertool, but are accessed by further common fts/globus code
+                'sources': [s[1] for s in transfer.legacy_sources],
+                'destinations': [transfer.dest_url],
+                'metadata': {
+                    'src_rse': transfer.src.rse.name,
+                    'dst_rse': transfer.dst.rse.name,
+                    'scope': str(transfer.rws.scope),
+                    'name': transfer.rws.name,
+                    'source_globus_endpoint_id': transfer.src.rse.attributes['globus_endpoint_id'],
+                    'dest_globus_endpoint_id': transfer.dst.rse.attributes['globus_endpoint_id'],
+                    'filesize': transfer.rws.byte_count,
+                },
+            }
+            for transfer in transfers
+        ]
+        self.logger(logging.DEBUG, '... Starting globus xfer ...')
+        self.logger(logging.DEBUG, 'job_files: %s' % submitjob)
+        task_id = bulk_submit_xfer(submitjob, recursive=False, logger=self.logger)
+
+        return task_id
+
+    def bulk_query(self, requests_by_eid, timeout=None):
+        """
+        Query the status of a bulk of transfers in globus API
+
+        :param requests_by_eid: dictionary {external_id1: {request_id1: request1, ...}, ...}
+        :returns: Transfer status information as a dictionary.
+        """
+
+        job_responses = bulk_check_xfers(requests_by_eid, logger=self.logger)
+
+        response = {}
+        for transfer_id, requests in requests_by_eid.items():
+            for request_id in requests:
+                response.setdefault(transfer_id, {})[request_id] = GlobusTransferStatusReport(request_id, transfer_id, job_responses[transfer_id])
+        return response
+
+    def bulk_update(self, resps, request_ids):
+        pass
+
+    def cancel(self):
+        pass
+
+    def update_priority(self):
+        pass

rucio/transfertool/globus_library.py

@@ -0,0 +1,182 @@
+# -*- 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.
+
+import datetime
+import logging
+import os
+
+from rucio.common.config import config_get, config_get_int, get_config_dirs
+from rucio.common.extra import import_extras
+from rucio.core.monitor import MetricManager
+
+EXTRA_MODULES = import_extras(['globus_sdk'])
+
+if EXTRA_MODULES['globus_sdk']:
+    from globus_sdk import NativeAppAuthClient, RefreshTokenAuthorizer, TransferClient, TransferData, DeleteData  # pylint: disable=import-error
+    import yaml  # pylint: disable=import-error
+
+METRICS = MetricManager(module=__name__)
+
+GLOBUS_AUTH_APP = config_get('conveyor', 'globus_auth_app', False, None)
+
+
+def load_config(cfg_file='globus-config.yml', logger=logging.log):
+    config = None
+    config_dir = get_config_dirs()[0]
+    if os.path.isfile(os.path.join(config_dir, cfg_file)):
+        config = os.path.join(config_dir, cfg_file)
+    else:
+        logger(logging.ERROR, 'Could not find globus config file')
+        raise Exception
+    return yaml.safe_load(open(config).read())
+
+
+def get_transfer_client(logger=logging.log):
+    cfg = load_config(logger=logger)
+    # cfg = yaml.safe_load(open("/opt/rucio/lib/rucio/transfertool/config.yml"))
+    client_id = cfg['globus']['apps'][GLOBUS_AUTH_APP]['client_id']
+    auth_client = NativeAppAuthClient(client_id)
+    refresh_token = cfg['globus']['apps'][GLOBUS_AUTH_APP]['refresh_token']
+    logger(logging.INFO, 'authorizing token...')
+    authorizer = RefreshTokenAuthorizer(refresh_token=refresh_token, auth_client=auth_client)
+    logger(logging.INFO, 'initializing TransferClient...')
+    tc = TransferClient(authorizer=authorizer)
+    return tc
+
+
+def auto_activate_endpoint(tc, ep_id, logger=logging.log):
+    r = tc.endpoint_autoactivate(ep_id, if_expires_in=3600)
+    if r['code'] == 'AutoActivationFailed':
+        logger(logging.CRITICAL, 'Endpoint({}) Not Active! Error! Source message: {}'.format(ep_id, r['message']))
+        # sys.exit(1) # TODO: don't want to exit; hook into graceful exit
+    elif r['code'] == 'AutoActivated.CachedCredential':
+        logger(logging.INFO, 'Endpoint({}) autoactivated using a cached credential.'.format(ep_id))
+    elif r['code'] == 'AutoActivated.GlobusOnlineCredential':
+        logger(logging.INFO, ('Endpoint({}) autoactivated using a built-in Globus credential.').format(ep_id))
+    elif r['code'] == 'AlreadyActivated':
+        logger(logging.INFO, 'Endpoint({}) already active until at least {}'.format(ep_id, 3600))
+    return r['code']
+
+
+def submit_xfer(source_endpoint_id, destination_endpoint_id, source_path, dest_path, job_label, recursive=False, logger=logging.log):
+    tc = get_transfer_client(logger=logger)
+    # as both endpoints are expected to be Globus Server endpoints, send auto-activate commands for both globus endpoints
+    auto_activate_endpoint(tc, source_endpoint_id, logger=logger)
+    auto_activate_endpoint(tc, destination_endpoint_id, logger=logger)
+
+    # from Globus... sync_level=checksum means that before files are transferred, Globus will compute checksums on the source and
+    # destination files, and only transfer files that have different checksums are transferred. verify_checksum=True means that after
+    # a file is transferred, Globus will compute checksums on the source and destination files to verify that the file was transferred
+    # correctly.  If the checksums do not match, it will redo the transfer of that file.
+    # tdata = TransferData(tc, source_endpoint_id, destination_endpoint_id, label=job_label, sync_level="checksum", verify_checksum=True)
+    tdata = TransferData(tc, source_endpoint_id, destination_endpoint_id, label=job_label,
+                         sync_level="checksum", notify_on_succeeded=False, notify_on_failed=False)
+    tdata.add_item(source_path, dest_path, recursive=recursive)
+
+    # logging.info('submitting transfer...')
+    transfer_result = tc.submit_transfer(tdata)
+    # logging.info("task_id =", transfer_result["task_id"])
+
+    return transfer_result["task_id"]
+
+
+def bulk_submit_xfer(submitjob, recursive=False, logger=logging.log):
+    cfg = load_config(logger=logger)
+    client_id = cfg['globus']['apps'][GLOBUS_AUTH_APP]['client_id']
+    auth_client = NativeAppAuthClient(client_id)
+    refresh_token = cfg['globus']['apps'][GLOBUS_AUTH_APP]['refresh_token']
+    source_endpoint_id = submitjob[0].get('metadata').get('source_globus_endpoint_id')
+    destination_endpoint_id = submitjob[0].get('metadata').get('dest_globus_endpoint_id')
+    authorizer = RefreshTokenAuthorizer(refresh_token=refresh_token, auth_client=auth_client)
+    tc = TransferClient(authorizer=authorizer)
+
+    # make job_label for task a timestamp
+    now = datetime.datetime.utcnow()
+    job_label = now.strftime('%Y%m%d%H%M%s')
+
+    # retrieve globus_task_deadline value to enforce time window to complete transfers
+    # default is 2880 minutes or 48 hours
+    globus_task_deadline = config_get_int('conveyor', 'globus_task_deadline', False, 2880)
+    deadline = now + datetime.timedelta(minutes=globus_task_deadline)
+
+    # from Globus... sync_level=checksum means that before files are transferred, Globus will compute checksums on the source
+    # and destination files, and only transfer files that have different checksums are transferred. verify_checksum=True means
+    # that after a file is transferred, Globus will compute checksums on the source and destination files to verify that the
+    # file was transferred correctly.  If the checksums do not match, it will redo the transfer of that file.
+    tdata = TransferData(tc, source_endpoint_id, destination_endpoint_id, label=job_label, sync_level="checksum", deadline=str(deadline))
+
+    for file in submitjob:
+        source_path = file.get('sources')[0]
+        dest_path = file.get('destinations')[0]
+        filesize = file['metadata']['filesize']
+        # TODO: support passing a recursive parameter to Globus
+        # md5 = file['metadata']['md5']
+        # tdata.add_item(source_path, dest_path, recursive=False, external_checksum=md5)
+        tdata.add_item(source_path, dest_path, recursive=False)
+        METRICS.counter('submit.filesize').inc(filesize)
+
+    # logging.info('submitting transfer...')
+    transfer_result = tc.submit_transfer(tdata)
+    logger(logging.INFO, "transfer_result: %s" % transfer_result)
+
+    return transfer_result["task_id"]
+
+
+def check_xfer(task_id, logger=logging.log):
+    tc = get_transfer_client(logger=logger)
+    transfer = tc.get_task(task_id)
+    status = str(transfer["status"])
+    return status
+
+
+def bulk_check_xfers(task_ids, logger=logging.log):
+    tc = get_transfer_client(logger=logger)
+
+    logger(logging.DEBUG, 'task_ids: %s' % task_ids)
+
+    responses = {}
+
+    for task_id in task_ids:
+        transfer = tc.get_task(str(task_id))
+        logger(logging.DEBUG, 'transfer: %s' % transfer)
+        status = str(transfer["status"])
+        if status == 'SUCCEEDED':
+            METRICS.counter('bytes_transferred').inc(transfer['bytes_transferred'])
+            METRICS.counter('effective_bytes_per_second').inc(transfer['effective_bytes_per_second'])
+        responses[str(task_id)] = status
+
+    logger(logging.DEBUG, 'responses: %s' % responses)
+
+    return responses
+
+
+def send_delete_task(endpoint_id=None, path=None, logger=logging.log):
+    tc = get_transfer_client(logger=logger)
+    ddata = DeleteData(tc, endpoint_id, recursive=True)
+    ddata.add_item(path)
+    delete_result = tc.submit_delete(ddata)
+
+    return delete_result
+
+
+def send_bulk_delete_task(endpoint_id=None, pfns=None, logger=logging.log):
+    tc = get_transfer_client(logger=logger)
+    ddata = DeleteData(tc, endpoint_id, recursive=True)
+    for pfn in pfns:
+        logger(logging.DEBUG, 'pfn: %s' % pfn)
+        ddata.add_item(pfn)
+    bulk_delete_result = tc.submit_delete(ddata)
+
+    return bulk_delete_result

rucio/transfertool/mock.py

@@ -0,0 +1,81 @@
+# -*- 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.
+
+import itertools
+import logging
+import uuid
+from typing import TYPE_CHECKING, Any, Optional, Sequence
+
+from rucio.db.sqla.constants import RequestState
+from rucio.transfertool.transfertool import Transfertool, TransferToolBuilder, TransferStatusReport
+
+if TYPE_CHECKING:
+    from rucio.db.sqla.session import Session
+
+
+class MockTransferStatusReport(TransferStatusReport):
+
+    supported_db_fields = [
+        'state',
+        'external_id'
+    ]
+
+    def __init__(self, request_id: str, external_id: str):
+        super().__init__(request_id)
+        self.state = RequestState.DONE
+        self.external_id = external_id
+
+    def initialize(self, session: "Session", logger=logging.log):
+        pass
+
+    def get_monitor_msg_fields(self, session: "Session", logger=logging.log):
+        return {}
+
+
+class MockTransfertool(Transfertool):
+    """
+    Mock implementation of a Rucio transfertool
+
+    This is not actually used anywhere at the moment
+    """
+
+    external_name = 'mock'
+    required_rse_attrs = ()
+
+    def __init__(self, external_host: str, logger=logging.log):
+        super(MockTransfertool, self).__init__(external_host, logger)
+
+    @classmethod
+    def submission_builder_for_path(cls, transfer_path, logger=logging.log):
+        return transfer_path, TransferToolBuilder(cls, external_host='Mock Transfertool')
+
+    def group_into_submit_jobs(self, transfers):
+        return [{'transfers': list(itertools.chain.from_iterable(transfers)), 'job_params': {}}]
+
+    def submit(self, files, job_params, timeout=None):
+        return str(uuid.uuid1())
+
+    def bulk_query(self, requests_by_eid: dict[str, dict[str, dict[str, Any]]], timeout: Optional[float] = None):
+        response = {}
+        for transfer_id, requests in requests_by_eid.items():
+            for request_id in requests:
+                response.setdefault(transfer_id, {})[request_id] = MockTransferStatusReport(request_id, transfer_id)
+        return response
+
+    def cancel(self, transfer_ids: Sequence[str], timeout: Optional[float] = None):
+        return True
+
+    def update_priority(self, transfer_id: str, priority: int, timeout: Optional[float] = None):
+        return True

rucio/transfertool/transfertool.py

@@ -0,0 +1,212 @@
+# -*- 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.
+
+import logging
+from abc import ABCMeta, abstractmethod
+from typing import TYPE_CHECKING
+
+from rucio.core.request import get_request
+
+if TYPE_CHECKING:
+    from rucio.core.rse import RseData
+
+
+class TransferToolBuilder(object):
+    """
+    Builder for Transfertool objects.
+    Stores the parameters needed to create the Transfertool object of the given type/class.
+
+    Implements __hash__ and __eq__ to allow using it as key in dictionaries and group transfers
+    by common transfertool.
+    """
+    def __init__(self, transfertool_class, **kwargs):
+        self.transfertool_class = transfertool_class
+        self.fixed_kwargs = frozenset(kwargs.items())
+
+    def __str__(self):
+        return self.transfertool_class.__name__
+
+    def __hash__(self):
+        return hash(frozenset(self.__dict__.items()))
+
+    def __eq__(self, other):
+        return self.__class__ == other.__class__ and self.__dict__ == other.__dict__
+
+    def make_transfertool(self, **additional_kwargs):
+        all_kwargs = dict(self.fixed_kwargs)
+        all_kwargs.update(additional_kwargs)
+        return self.transfertool_class(**all_kwargs)
+
+
+class TransferStatusReport(object, metaclass=ABCMeta):
+    """
+    Allows to compute the changes which have to be applied to the database
+    to reflect the current status reported by the external transfertool into
+    the database.
+    """
+
+    supported_db_fields = [
+        'state',
+    ]
+
+    def __init__(self, request_id, request=None):
+        self.request_id = request_id
+        self.__request = request  # Optional: DB request. If provided, saves us a database call to fetch it by request_id
+        self.__initialized = False
+
+        # Supported db fields bellow
+        self.state = None
+
+    @abstractmethod
+    def initialize(self, session, logger=logging.log):
+        """
+        Initialize all fields from self.supported_update_fields
+        """
+        pass
+
+    @abstractmethod
+    def get_monitor_msg_fields(self, session, logger=logging.log):
+        """
+        Return the fields which will be included in the message sent to hermes.
+        """
+        pass
+
+    def ensure_initialized(self, session, logger=logging.log):
+        if not self.__initialized:
+            self.initialize(session, logger)
+            self.__initialized = True
+
+    def request(self, session):
+        """
+        Fetch the request by request_id if needed.
+        """
+        if not self.__request:
+            self.__request = get_request(self.request_id, session=session)
+        return self.__request
+
+    def get_db_fields_to_update(self, session, logger=logging.log):
+        """
+        Returns the fields which have to be updated in the request
+        """
+        self.ensure_initialized(session, logger)
+
+        updates = {}
+        for field in self.supported_db_fields:
+            field_value = getattr(self, field)
+            if field_value:
+                updates[field] = field_value
+        return updates
+
+
+class Transfertool(object, metaclass=ABCMeta):
+    """
+    Interface definition of the Rucio transfertool
+    """
+
+    external_name = ''
+    required_rse_attrs = ('globus_endpoint_id', )
+
+    def __init__(self, external_host, logger=logging.log):
+        """
+        Initializes the transfertool
+
+        :param external_host:   The external host where the transfertool API is running
+        """
+
+        self.external_host = external_host
+        self.logger = logger
+
+    def __str__(self):
+        return self.external_host if self.external_host is not None else self.__class__.__name__
+
+    @classmethod
+    def can_perform_transfer(cls, source_rse: "RseData", dest_rse: "RseData"):
+        """
+        Return True if this transfertool is able to perform a transfer between the given source and destination rses
+        """
+        if (
+                all(source_rse.attributes.get(attribute) is not None for attribute in cls.required_rse_attrs)
+                and all(dest_rse.attributes.get(attribute) is not None for attribute in cls.required_rse_attrs)
+        ):
+            return True
+        return False
+
+    @classmethod
+    def submission_builder_for_path(cls, transfer_path, logger=logging.log):
+        """
+        Analyze the transfer path. If this transfertool class can submit the given transfers, return
+        a TransferToolBuilder instance capable to build transfertool objects configured for this
+        particular submission.
+        :param transfer_path:  List of DirectTransferDefinitions
+        :param logger: logger instance
+        :return: a tuple: a sub-path starting at the first node from transfer_path, and a TransfertoolBuilder instance
+        capable to submit this sub-path. Returns ([], None) if submission is impossible.
+        """
+        pass
+
+    @abstractmethod
+    def group_into_submit_jobs(self, transfer_paths):
+        """
+        Takes an iterable over transfer paths, and create groups which can be submitted in one call to submit()
+
+        :param transfer_paths: Iterable over (potentially multihop) transfer paths.
+        :return: list of dicts of the form {"transfers": <transfer list>, "job_params": <data blob>}
+        """
+        pass
+
+    @abstractmethod
+    def submit(self, transfers, job_params, timeout=None):
+        """
+        Submit transfers to the transfertool.
+
+        :param transfers:    List of dictionaries describing the file transfers.
+        :param job_params:   Dictionary containing key/value pairs, for all transfers.
+        :param timeout:      Timeout in seconds.
+        :returns:            Transfertool internal identifiers.
+        """
+        pass
+
+    @abstractmethod
+    def bulk_query(self, requests_by_eid, timeout=None) -> dict[str, dict[str, TransferStatusReport]]:
+        """
+        Query the status of a bulk of transfers in FTS3 via JSON.
+
+        :param requests_by_eid: dictionary {external_id1: {request_id1: request1, ...}, ...} of request to be queried
+        :returns: Transfer status information as a dictionary.
+        """
+        pass
+
+    @abstractmethod
+    def cancel(self, transfer_ids, timeout=None):
+        """
+        Cancel transfers that have been submitted to the transfertool.
+
+        :param transfer_ids: Transfertool internal transfer identifiers as list of strings.
+        :param timeout:      Timeout in seconds.
+        :returns:            True if cancellation was successful.
+        """
+        pass
+
+    @abstractmethod
+    def update_priority(self, transfer_id, priority, timeout=None):
+        """
+        Update the priority of a transfer that has been submitted to the transfertool.
+
+        :param transfer_id: Transfertool internal transfer identifier as a string.
+        :param priority:    Job priority as an integer from 1 to 5.
+        :param timeout:     Timeout in seconds.
+        :returns:           True if update was successful.
+        """
+        pass

rucio/vcsversion.py

@@ -0,0 +1,11 @@
+
+'''
+This file is automatically generated; Do not edit it. :)
+'''
+VERSION_INFO = {
+    'final': True,
+    'version': '32.8.6',
+    'branch_nick': 'release-32-LTS',
+    'revision_id': 'ce0d5e6a899547293697ca2d6b5f6d40467c9d8e',
+    'revno': 12667
+}