rucio 37.0.0rc1__py3-none-any.whl

rucio/transfertool/fts3_plugins.py

@@ -0,0 +1,152 @@
+# 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 json
+import sys
+from typing import TYPE_CHECKING, Any, Optional, TypeVar
+
+from rucio.common.config import config_get_int
+from rucio.common.exception import InvalidRequest
+from rucio.common.plugins import PolicyPackageAlgorithms
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+FTS3TapeMetadataPluginType = TypeVar('FTS3TapeMetadataPluginType', bound='FTS3TapeMetadataPlugin')
+
+
+class FTS3TapeMetadataPlugin(PolicyPackageAlgorithms):
+    """
+    Add a "archive_metadata" field to a file's transfer parameters.
+    Plugins are registered during initialization and called during a transfer with FTS3
+    """
+
+    ALGORITHM_NAME = "fts3_tape_metadata_plugins"
+    _INIT_FUNC_NAME = "fts3_plugins_init"
+    DEFAULT = "def"
+
+    def __init__(self, policy_algorithm: str) -> None:
+        """
+        :param policy_algorithm: policy algorithm identifier - choose from any of the policy package algorithms registered under the `fts3_tape_metadata_plugins` group.
+        """
+        super().__init__()
+        self.transfer_limit = config_get_int(
+            "transfers",
+            option="metadata_byte_limit",
+            raise_exception=False,
+            default=4096,
+        )
+
+        if not self._supports(self.ALGORITHM_NAME, policy_algorithm):
+            raise ValueError(f'Policy Algorithm {policy_algorithm} not found')
+
+        if self._supports(self._INIT_FUNC_NAME, policy_algorithm):
+            init_func = self._get_one_algorithm(self._INIT_FUNC_NAME, name=policy_algorithm)
+            init_func()
+
+        self.set_in_hints = self._get_one_algorithm(self.ALGORITHM_NAME, name=policy_algorithm)
+
+    @classmethod
+    def _module_init(cls: type[FTS3TapeMetadataPluginType]) -> None:
+        cls.register(cls.DEFAULT, func=lambda x: cls._default(cls, x))  # type: ignore
+
+    @classmethod
+    def register(cls: type[FTS3TapeMetadataPluginType], name: str, func: 'Callable', init_func: Optional['Callable'] = None) -> None:
+        """
+        Register a fts3 transfer plugin
+
+        :param name: name to register under
+        :param func: function called by the plugin
+        :param init_func: Initialization requirements for the plugin, defaults to None
+        """
+        super()._register(cls.ALGORITHM_NAME, algorithm_dict={name: func})
+        if init_func is not None:
+            super()._register(cls._INIT_FUNC_NAME, algorithm_dict={name: init_func})
+
+    @staticmethod
+    def _collocation(collocation_func: 'Callable', hints: dict[str, Any]) -> dict[str, dict]:
+        """
+        Wraps a 'collocation' style plugin for formatting
+
+        :param collocation_func: Function that defines the collocation rules
+        :param hints: kwargs utilized by the collocation rules
+        :return: Collocation hints produced by the collocation_func, wrapped
+        """
+        return {"collocation_hints": collocation_func(**hints)}
+
+    def _default(self, *hints: dict) -> dict:
+        return {}
+
+    def _verify_in_format(self, hint_dict: dict[str, Any]) -> None:
+        """Check the to-be-submitted file transfer params are both json encodable and under the size limit for transfer"""
+        try:
+            hints_json = json.dumps(hint_dict)
+            in_tranfer_limit = sys.getsizeof(hints_json) < self.transfer_limit
+
+        except TypeError as e:
+            raise InvalidRequest("Request malformed, cannot encode to JSON", e)
+
+        if not in_tranfer_limit:
+            raise InvalidRequest(
+                f"Request too large, decrease to less than {self.transfer_limit}"
+            )
+
+    def hints(self, hint_kwargs: dict) -> dict[str, Any]:
+        """
+        Produce "archive_metadata" hints for how a transfer should be executed by fts3.
+
+        :param hint_kwargs: Args passed forward to the plugin algorithm
+        :return: Archiving metadata in the format {archive_metadata: {<plugin produced hints>}}
+        """
+        hints = self.set_in_hints(hint_kwargs)
+        self._verify_in_format(hints)
+        return {"archive_metadata": hints}
+
+
+class ActivityBasedTransferPriorityPlugin(FTS3TapeMetadataPlugin):
+    def __init__(self, policy_algorithm: str = 'activity') -> None:
+        self.register(
+            policy_algorithm,
+            func=lambda x: self._get_activity_priority(x),
+            init_func=self._init_default_priority)
+        super().__init__(policy_algorithm)
+
+    def _init_default_priority(self) -> None:
+        self.default_priority = config_get_int(
+            "tape_priority",
+            option="default",
+            raise_exception=False,
+            default=20,
+        )
+
+    def _get_activity_priority(self, activity_kwargs: dict[str, str]) -> dict[str, dict]:
+        """ Activity Hints - assign a priority based on activity"""
+        if "activity" in activity_kwargs:
+            activity = activity_kwargs["activity"]
+        else:
+            raise InvalidRequest("`activity` field not found in passed metadata")
+
+        priority = config_get_int(
+            "tape_priority",
+            option=activity,
+            raise_exception=False,
+            default=self.default_priority,
+        )
+
+        return {"scheduling_hints": {"priority": priority}}
+
+
+# Register the policies
+FTS3TapeMetadataPlugin._module_init()
+ActivityBasedTransferPriorityPlugin()

rucio/transfertool/globus.py

@@ -0,0 +1,201 @@
+# 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.constants import RseAttr
+from rucio.common.utils import chunks
+from rucio.db.sqla.constants import RequestState
+from rucio.transfertool.transfertool import TransferStatusReport, Transfertool, TransferToolBuilder
+
+from .globus_library import bulk_check_xfers, bulk_submit_xfer, submit_xfer
+
+
+def bulk_group_transfers(transfer_paths, policy='single', group_bulk=200):
+    """
+    Group transfers in bulk based on certain criteria
+
+    :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 = (RseAttr.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': [transfer.source_url(s) for s in transfer.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[RseAttr.GLOBUS_ENDPOINT_ID],
+                    'dest_globus_endpoint_id': transfer.dst.rse.attributes[RseAttr.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,181 @@
+# 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']:
+    import yaml  # pylint: disable=import-error
+    from globus_sdk import DeleteData, NativeAppAuthClient, RefreshTokenAuthorizer, TransferClient, TransferData  # 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,89 @@
+# 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
+
+from rucio.db.sqla.constants import RequestState
+from rucio.transfertool.transfertool import TransferStatusReport, Transfertool, TransferToolBuilder
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Mapping, Sequence
+
+    from rucio.common.types import LoggerFunction
+    from rucio.core.request import DirectTransfer
+    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: "LoggerFunction" = logging.log) -> None:
+        pass
+
+    def get_monitor_msg_fields(self, session: "Session", logger: "LoggerFunction" = logging.log) -> dict[str, Any]:
+        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 = ()
+    supported_schemes = {'mock', 'file'}
+
+    def __init__(self, external_host: str, logger: "LoggerFunction" = logging.log):
+        super(MockTransfertool, self).__init__(external_host, logger)
+
+    @classmethod
+    def submission_builder_for_path(
+        cls,
+        transfer_path: list["DirectTransfer"],
+        logger: "LoggerFunction" = logging.log
+    ) -> tuple[list["DirectTransfer"], "TransferToolBuilder"]:
+        return transfer_path, TransferToolBuilder(cls, external_host='Mock Transfertool')
+
+    def group_into_submit_jobs(self, transfers: "Iterable[list[DirectTransfer]]") -> list[dict[str, Any]]:
+        return [{'transfers': list(itertools.chain.from_iterable(transfers)), 'job_params': {}}]
+
+    def submit(self, transfers: "Iterable[DirectTransfer]", job_params: dict[str, str], timeout: Optional[int] = None) -> str:
+        return str(uuid.uuid1())
+
+    def bulk_query(self, requests_by_eid: "Mapping[str, Mapping[str, Any]]", timeout: Optional[int] = None) -> dict[str, dict[str, MockTransferStatusReport]]:
+        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[int] = None) -> bool:
+        return True
+
+    def update_priority(self, transfer_id: str, priority: int, timeout: Optional[int] = None) -> bool:
+        return True