rucio-clients 37.0.0rc1__py3-none-any.whl

rucio/client/ruleclient.py

@@ -0,0 +1,294 @@
+# 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 json import dumps, loads
+from typing import TYPE_CHECKING, Any, Literal, Optional, Union
+from urllib.parse import quote_plus
+
+from requests.status_codes import codes
+
+from rucio.client.baseclient import BaseClient, choice
+from rucio.common.utils import build_url
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator, Mapping, Sequence
+
+
+class RuleClient(BaseClient):
+
+    """RuleClient class for working with replication rules"""
+
+    RULE_BASEURL = 'rules'
+
+    def add_replication_rule(
+        self,
+        dids: "Sequence[dict[str, str]]",
+        copies: int,
+        rse_expression: str,
+        priority: int = 3,
+        lifetime: Optional[int] = None,
+        grouping: str = 'DATASET',
+        notify: str = 'N',
+        source_replica_expression: Optional[str] = None,
+        activity: Optional[str] = None,
+        account: Optional[str] = None,
+        meta: Optional[str] = None,
+        ignore_availability: bool = False,
+        purge_replicas: bool = False,
+        ask_approval: bool = False,
+        asynchronous: bool = False,
+        locked: bool = False,
+        delay_injection: Optional[int] = None,
+        comment: Optional[str] = None,
+        weight: Optional[int] = None,
+    ) -> Any:
+        """
+        :param dids:                       The data identifier set.
+        :param copies:                     The number of replicas.
+        :param rse_expression:             Boolean string expression to give the list of RSEs.
+        :param priority:                   Priority of the transfers.
+        :param lifetime:                   The lifetime of the replication rules (in seconds).
+        :param grouping:                   ALL -  All files will be replicated to the same RSE.
+                                           DATASET - All files in the same dataset will be replicated to the same RSE.
+                                           NONE - Files will be completely spread over all allowed RSEs without any grouping considerations at all.
+        :param notify:                     Notification setting for the rule (Y, N, C).
+        :param source_replica_expression:  RSE Expression for RSEs to be considered for source replicas.
+        :param activity:                   Transfer Activity to be passed to FTS.
+        :param account:                    The account owning the rule.
+        :param meta:                       Metadata, as dictionary.
+        :param ignore_availability:        Option to ignore the availability of RSEs.
+        :param purge_replicas:             When the rule gets deleted purge the associated replicas immediately.
+        :param ask_approval:               Ask for approval of this replication rule.
+        :param asynchronous:               Create rule asynchronously by judge-injector.
+        :param locked:                     If the rule is locked, it cannot be deleted.
+        :param delay_injection:
+        :param comment:                    Comment about the rule.
+        :param weight:                     If the weighting option of the replication rule is used, the choice of RSEs takes their weight into account.
+        """
+        path = self.RULE_BASEURL + '/'
+        url = build_url(choice(self.list_hosts), path=path)
+        # TODO remove the subscription_id from the client; It will only be used by the core;
+        data = dumps({'dids': dids, 'copies': copies, 'rse_expression': rse_expression,
+                      'weight': weight, 'lifetime': lifetime, 'grouping': grouping,
+                      'account': account, 'locked': locked, 'source_replica_expression': source_replica_expression,
+                      'activity': activity, 'notify': notify, 'purge_replicas': purge_replicas,
+                      'ignore_availability': ignore_availability, 'comment': comment, 'ask_approval': ask_approval,
+                      'asynchronous': asynchronous, 'delay_injection': delay_injection, 'priority': priority, 'meta': meta})
+        r = self._send_request(url, type_='POST', data=data)
+        if r.status_code == codes.created:
+            return loads(r.text)
+        exc_cls, exc_msg = self._get_exception(headers=r.headers, status_code=r.status_code, data=r.content)
+        raise exc_cls(exc_msg)
+
+    def delete_replication_rule(
+        self, rule_id: str, purge_replicas: Optional[bool] = None
+    ) -> Literal[True]:
+        """
+        Deletes a replication rule and all associated locks.
+
+        :param rule_id:         The id of the rule to be deleted
+        :param purge_replicas:  Immediately delete the replicas.
+        :raises:                RuleNotFound, AccessDenied
+        """
+
+        path = self.RULE_BASEURL + '/' + rule_id
+        url = build_url(choice(self.list_hosts), path=path)
+
+        data = dumps({'purge_replicas': purge_replicas})
+
+        r = self._send_request(url, type_='DEL', data=data)
+
+        if r.status_code == codes.ok:
+            return True
+        exc_cls, exc_msg = self._get_exception(headers=r.headers, status_code=r.status_code, data=r.content)
+        raise exc_cls(exc_msg)
+
+    def get_replication_rule(self, rule_id: str) -> Any:
+        """
+        Get a replication rule.
+
+        :param rule_id:  The id of the rule to be retrieved.
+        :raises:         RuleNotFound
+        """
+        path = self.RULE_BASEURL + '/' + rule_id
+        url = build_url(choice(self.list_hosts), path=path)
+        r = self._send_request(url, type_='GET')
+        if r.status_code == codes.ok:
+            return next(self._load_json_data(r))
+        else:
+            exc_cls, exc_msg = self._get_exception(headers=r.headers, status_code=r.status_code, data=r.content)
+            raise exc_cls(exc_msg)
+
+    def update_replication_rule(self, rule_id: str, options: dict[str, Any]) -> Literal[True]:
+        """
+        :param rule_id:   The id of the rule to be retrieved.
+        :param options:   Options dictionary.
+        :raises:          RuleNotFound
+        """
+        path = self.RULE_BASEURL + '/' + rule_id
+        url = build_url(choice(self.list_hosts), path=path)
+        data = dumps({'options': options})
+        r = self._send_request(url, type_='PUT', data=data)
+        if r.status_code == codes.ok:
+            return True
+        exc_cls, exc_msg = self._get_exception(headers=r.headers, status_code=r.status_code, data=r.content)
+        raise exc_cls(exc_msg)
+
+    def reduce_replication_rule(
+        self,
+        rule_id: str,
+        copies: int,
+        exclude_expression: Optional[str] = None
+    ) -> Any:
+        """
+        :param rule_id:             Rule to be reduced.
+        :param copies:              Number of copies of the new rule.
+        :param exclude_expression:  RSE Expression of RSEs to exclude.
+        :raises:                    RuleReplaceFailed, RuleNotFound
+        """
+
+        path = self.RULE_BASEURL + '/' + rule_id + '/reduce'
+        url = build_url(choice(self.list_hosts), path=path)
+        data = dumps({'copies': copies, 'exclude_expression': exclude_expression})
+        r = self._send_request(url, type_='POST', data=data)
+        if r.status_code == codes.ok:
+            return loads(r.text)
+        exc_cls, exc_msg = self._get_exception(headers=r.headers, status_code=r.status_code, data=r.content)
+        raise exc_cls(exc_msg)
+
+    def move_replication_rule(
+        self,
+        rule_id: str,
+        rse_expression: str,
+        override: "Mapping[str, Any]"
+    ) -> Any:
+        """
+        Move a replication rule to another RSE and, once done, delete the original one.
+
+        :param rule_id:                    Rule to be moved.
+        :param rse_expression:             RSE expression of the new rule.
+        :param override:                   Configurations to update for the new rule.
+        :raises:                           RuleNotFound, RuleReplaceFailed
+        """
+
+        path = self.RULE_BASEURL + '/' + rule_id + '/move'
+        url = build_url(choice(self.list_hosts), path=path)
+        data = dumps({
+            'rule_id': rule_id,
+            'rse_expression': rse_expression,
+            'override': override,
+        })
+        r = self._send_request(url, type_='POST', data=data)
+        if r.status_code == codes.created:
+            return loads(r.text)
+        exc_cls, exc_msg = self._get_exception(headers=r.headers, status_code=r.status_code, data=r.content)
+        raise exc_cls(exc_msg)
+
+    def approve_replication_rule(self, rule_id: str) -> Literal[True]:
+        """
+        :param rule_id:             Rule to be approved.
+        :raises:                    RuleNotFound
+        """
+
+        path = self.RULE_BASEURL + '/' + rule_id
+        url = build_url(choice(self.list_hosts), path=path)
+        data = dumps({'options': {'approve': True}})
+        r = self._send_request(url, type_='PUT', data=data)
+        if r.status_code == codes.ok:
+            return True
+        exc_cls, exc_msg = self._get_exception(headers=r.headers, status_code=r.status_code, data=r.content)
+        raise exc_cls(exc_msg)
+
+    def deny_replication_rule(self, rule_id: str, reason: Optional[str] = None) -> Literal[True]:
+        """
+        :param rule_id:             Rule to be denied.
+        :param reason:              Reason for denying the rule.
+        :raises:                    RuleNotFound
+        """
+
+        path = self.RULE_BASEURL + '/' + rule_id
+        url = build_url(choice(self.list_hosts), path=path)
+        options: dict[str, Union[bool, str]] = {'approve': False}
+        if reason:
+            options['comment'] = reason
+        data = dumps({'options': options})
+        r = self._send_request(url, type_='PUT', data=data)
+        if r.status_code == codes.ok:
+            return True
+        exc_cls, exc_msg = self._get_exception(headers=r.headers, status_code=r.status_code, data=r.content)
+        raise exc_cls(exc_msg)
+
+    def list_replication_rule_full_history(
+            self, scope: Union[str, bytes], name: Union[str, bytes]
+    ) -> "Iterator[dict[str, Any]]":
+        """
+        List the rule history of a DID.
+
+        :param scope: The scope of the DID.
+        :param name: The name of the DID.
+        """
+        path = '/'.join([self.RULE_BASEURL, quote_plus(scope), quote_plus(name), 'history'])
+        url = build_url(choice(self.list_hosts), path=path)
+        r = self._send_request(url, type_='GET')
+        if r.status_code == codes.ok:
+            return self._load_json_data(r)
+        exc_cls, exc_msg = self._get_exception(r.headers, r.status_code)
+        raise exc_cls(exc_msg)
+
+    def examine_replication_rule(self, rule_id: str) -> Any:
+        """
+        Examine a replication rule for errors during transfer.
+
+        :param rule_id:             Rule to be denied.
+        :raises:                    RuleNotFound
+        """
+        path = self.RULE_BASEURL + '/' + rule_id + '/analysis'
+        url = build_url(choice(self.list_hosts), path=path)
+        r = self._send_request(url, type_='GET')
+        if r.status_code == codes.ok:
+            return next(self._load_json_data(r))
+        exc_cls, exc_msg = self._get_exception(r.headers, r.status_code)
+        raise exc_cls(exc_msg)
+
+    def list_replica_locks(self, rule_id: str) -> Any:
+        """
+        List details of all replica locks for a rule.
+
+        :param rule_id:             Rule to be denied.
+        :raises:                    RuleNotFound
+        """
+        path = self.RULE_BASEURL + '/' + rule_id + '/locks'
+        url = build_url(choice(self.list_hosts), path=path)
+        r = self._send_request(url, type_='GET')
+        if r.status_code == codes.ok:
+            return self._load_json_data(r)
+        exc_cls, exc_msg = self._get_exception(r.headers, r.status_code)
+        raise exc_cls(exc_msg)
+
+    def list_replication_rules(self, filters: Optional[dict[str, Any]] = None) -> "Iterator[dict[str, Any]]":
+        """
+        List all replication rules which match a filter
+        :param filters: dictionary of attributes by which the rules should be filtered
+
+        :returns: True if successful, otherwise false.
+        """
+        filters = filters or {}
+        path = self.RULE_BASEURL + '/'
+        url = build_url(choice(self.list_hosts), path=path)
+        r = self._send_request(url, type_='GET', params=filters)
+        if r.status_code == codes.ok:
+            return self._load_json_data(r)
+        else:
+            exc_cls, exc_msg = self._get_exception(headers=r.headers, status_code=r.status_code, data=r.content)
+            raise exc_cls(exc_msg)

rucio/client/scopeclient.py

@@ -0,0 +1,90 @@
+# 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 json import loads
+from urllib.parse import quote_plus
+
+from requests.status_codes import codes
+
+from rucio.client.baseclient import BaseClient, choice
+from rucio.common.utils import build_url
+
+
+class ScopeClient(BaseClient):
+
+    """Scope client class for working with rucio scopes"""
+
+    SCOPE_BASEURL = 'accounts'
+
+    def add_scope(
+            self,
+            account: str,
+            scope: str
+    ) -> bool:
+        """
+        Sends the request to add a new scope.
+
+        :param account: the name of the account to add the scope to.
+        :param scope: the name of the new scope.
+        :return: True if scope was created successfully.
+        :raises Duplicate: if scope already exists.
+        :raises AccountNotFound: if account doesn't exist.
+        """
+
+        path = '/'.join([self.SCOPE_BASEURL, account, 'scopes', quote_plus(scope)])
+        url = build_url(choice(self.list_hosts), path=path)
+        r = self._send_request(url, type_='POST')
+        if r.status_code == codes.created:
+            return True
+        else:
+            exc_cls, exc_msg = self._get_exception(headers=r.headers, status_code=r.status_code, data=r.content)
+            raise exc_cls(exc_msg)
+
+    def list_scopes(self) -> list[str]:
+        """
+        Sends the request to list all scopes.
+
+        :return: a list containing the names of all scopes.
+        """
+
+        path = '/'.join(['scopes/'])
+        url = build_url(choice(self.list_hosts), path=path)
+        r = self._send_request(url)
+        if r.status_code == codes.ok:
+            scopes = loads(r.text)
+            return scopes
+        else:
+            exc_cls, exc_msg = self._get_exception(headers=r.headers, status_code=r.status_code, data=r.content)
+            raise exc_cls(exc_msg)
+
+    def list_scopes_for_account(self, account: str) -> list[str]:
+        """
+        Sends the request to list all scopes for a rucio account.
+
+        :param account: the rucio account to list scopes for.
+        :return: a list containing the names of all scopes for a rucio account.
+        :raises AccountNotFound: if account doesn't exist.
+        :raises ScopeNotFound: if no scopes exist for account.
+        """
+
+        path = '/'.join([self.SCOPE_BASEURL, account, 'scopes/'])
+        url = build_url(choice(self.list_hosts), path=path)
+
+        r = self._send_request(url)
+        if r.status_code == codes.ok:
+            scopes = loads(r.text)
+            return scopes
+        else:
+            exc_cls, exc_msg = self._get_exception(headers=r.headers, status_code=r.status_code, data=r.content)
+            raise exc_cls(exc_msg)

rucio/client/subscriptionclient.py

@@ -0,0 +1,173 @@
+# 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 json import dumps
+from typing import TYPE_CHECKING, Any, Literal, Optional, Union
+
+from requests.status_codes import codes
+
+from rucio.client.baseclient import BaseClient, choice
+from rucio.common.utils import build_url
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+
+class SubscriptionClient(BaseClient):
+
+    """SubscriptionClient class for working with subscriptions"""
+
+    SUB_BASEURL = 'subscriptions'
+
+    def add_subscription(
+            self,
+            name: str,
+            account: str,
+            filter_: dict[str, Any],
+            replication_rules: dict[str, Any],
+            comments: str,
+            lifetime: Union[int, Literal[False]],
+            retroactive: bool,
+            dry_run: bool,
+            priority: int = 3
+    ) -> str:
+        """
+        Adds a new subscription which will be verified against every new added file and dataset
+
+        :param name: Name of the subscription
+        :param account: Account identifier
+        :param filter_: Dictionary of attributes by which the input data should be filtered
+                       **Example**: ``{'dsn': 'data11_hi*.express_express.*,data11_hi*physics_MinBiasOverlay*', 'account': 'tzero'}``
+        :param replication_rules: Replication rules to be set : Dictionary with keys copies, rse_expression, weight, rse_expression
+        :param comments: Comments for the subscription
+        :param lifetime: Subscription's lifetime (days); False if subscription has no lifetime
+        :param retroactive: Flag to know if the subscription should be applied on previous data
+        :param dry_run: Just print the subscriptions actions without actually executing them (Useful if retroactive flag is set)
+        :param priority: The priority of the subscription (3 by default)
+        """
+        path = self.SUB_BASEURL + '/' + account + '/' + name
+        url = build_url(choice(self.list_hosts), path=path)
+        if retroactive:
+            raise NotImplementedError('Retroactive mode is not implemented')
+        if filter_ and not isinstance(filter_, dict):
+            raise TypeError('filter should be a dict')
+        if replication_rules and not isinstance(replication_rules, list):
+            raise TypeError('replication_rules should be a list')
+        data = dumps({'options': {'filter': filter_, 'replication_rules': replication_rules, 'comments': comments,
+                                  'lifetime': lifetime, 'retroactive': retroactive, 'dry_run': dry_run, 'priority': priority}})
+        result = self._send_request(url, type_='POST', data=data)
+        if result.status_code == codes.created:   # pylint: disable=no-member
+            return result.text
+        else:
+            exc_cls, exc_msg = self._get_exception(headers=result.headers, status_code=result.status_code, data=result.content)
+            raise exc_cls(exc_msg)
+
+    def list_subscriptions(
+            self,
+            name: Optional[str] = None,
+            account: Optional[dict[str, Any]] = None
+    ) -> Union["Iterator[dict[str, Any]]", list]:
+        """
+        Returns a dictionary with the subscription information :
+        Examples: ``{'status': 'INACTIVE/ACTIVE/BROKEN', 'last_modified_date': ...}``
+
+        :param name: Name of the subscription
+        :param account: Account identifier
+        :returns: Dictionary containing subscription parameter
+        :raises: exception.NotFound if subscription is not found
+        """
+        path = self.SUB_BASEURL
+        if account:
+            path += '/%s' % (account)
+            if name:
+                path += '/%s' % (name)
+        elif name:
+            path += '/name/%s' % (name)
+        else:
+            path += '/'
+        url = build_url(choice(self.list_hosts), path=path)
+        result = self._send_request(url, type_='GET')
+        if result.status_code == codes.ok:   # pylint: disable=no-member
+            return self._load_json_data(result)
+        if result.status_code == codes.not_found:
+            return []
+        exc_cls, exc_msg = self._get_exception(headers=result.headers, status_code=result.status_code, data=result.content)
+        raise exc_cls(exc_msg)
+
+    def update_subscription(
+            self,
+            name,
+            account: Optional[str] = None,
+            filter_: Optional[dict[str, Any]] = None,
+            replication_rules: Optional[dict[str, Any]] = None,
+            comments: Optional[str] = None,
+            lifetime: Optional[Union[int, Literal[False]]] = None,
+            retroactive: Optional[bool] = None,
+            dry_run: Optional[bool] = None,
+            priority: Optional[int] = None
+    ) -> Literal[True]:
+        """
+        Updates a subscription
+
+        :param name: Name of the subscription
+        :param account: Account identifier
+        :param filter_: Dictionary of attributes by which the input data should be filtered
+                       **Example**: ``{'dsn': 'data11_hi*.express_express.*,data11_hi*physics_MinBiasOverlay*', 'account': 'tzero'}``
+        :param replication_rules: Replication rules to be set : Dictionary with keys copies, rse_expression, weight, rse_expression
+        :param comments: Comments for the subscription
+        :param lifetime: Subscription's lifetime (days); False if subscription has no lifetime
+        :param retroactive: Flag to know if the subscription should be applied on previous data
+        :param dry_run: Just print the subscriptions actions without actually executing them (Useful if retroactive flag is set)
+        :param priority: The priority of the subscription
+        :raises: exception.NotFound if subscription is not found
+        """
+        if not account:
+            account = self.account
+        if retroactive:
+            raise NotImplementedError('Retroactive mode is not implemented')
+        path = self.SUB_BASEURL + '/' + account + '/' + name  # type: ignore
+        url = build_url(choice(self.list_hosts), path=path)
+        if filter_ and not isinstance(filter_, dict):
+            raise TypeError('filter should be a dict')
+        if replication_rules and not isinstance(replication_rules, list):
+            raise TypeError('replication_rules should be a list')
+        data = dumps({'options': {'filter': filter_, 'replication_rules': replication_rules, 'comments': comments,
+                                  'lifetime': lifetime, 'retroactive': retroactive, 'dry_run': dry_run, 'priority': priority}})
+        result = self._send_request(url, type_='PUT', data=data)
+        if result.status_code == codes.created:   # pylint: disable=no-member
+            return True
+        else:
+            exc_cls, exc_msg = self._get_exception(headers=result.headers, status_code=result.status_code, data=result.content)
+            raise exc_cls(exc_msg)
+
+    def list_subscription_rules(
+            self,
+            account: str,
+            name: str
+    ) -> "Iterator[dict[str, Any]]":
+        """
+        List the associated rules of a subscription.
+
+        :param account: Account of the subscription.
+        :param name:    Name of the subscription.
+        """
+
+        path = '/'.join([self.SUB_BASEURL, account, name, 'rules'])
+        url = build_url(choice(self.list_hosts), path=path)
+        result = self._send_request(url, type_='GET')
+        if result.status_code == codes.ok:   # pylint: disable=no-member
+            return self._load_json_data(result)
+        else:
+            exc_cls, exc_msg = self._get_exception(headers=result.headers, status_code=result.status_code, data=result.content)
+            raise exc_cls(exc_msg)

rucio/client/touchclient.py

@@ -0,0 +1,82 @@
+# 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 json import dumps
+from typing import Optional
+
+from requests import post
+
+from rucio.client.baseclient import BaseClient, choice
+from rucio.common.exception import RucioException, UnsupportedDIDType
+
+
+class TouchClient(BaseClient):
+
+    """
+    Touch client class to send a trace that can be used to
+    update accessed_at for file or dataset DIDs
+    """
+
+    DIDS_BASEURL = 'dids'
+    TRACES_BASEURL = 'traces'
+
+    def touch(
+            self,
+            scope: str,
+            name: str,
+            rse: Optional[str] = None
+    ) -> None:
+        """
+        Sends a touch trace for a given file or dataset.
+
+        :param scope: the scope of the file/dataset to update.
+        :param name: the name of file/dataset to update.
+        :param rse: optional parameter if a specific replica should be touched.
+        :raises DataIdentifierNotFound: if given dids does not exist.
+        :raises RSENotFound: if rse is not None and given rse does not exist.
+        :raises UnsupportedDIDType: if type of the given DID is not FILE or DATASET.
+        :raises RucioException: if trace could not be sent successfully.
+        """
+
+        trace = {}
+
+        trace['eventType'] = 'touch'
+        trace['clientState'] = 'DONE'
+        trace['account'] = self.account
+        if self.vo != 'def':
+            trace['vo'] = self.vo
+
+        if rse:
+            self.get_rse(rse)  # pylint: disable=no-member
+
+            trace['localSite'] = trace['remoteSite'] = rse
+
+        info = self.get_did(scope, name)  # pylint: disable=no-member
+
+        if info['type'] == 'CONTAINER':
+            raise UnsupportedDIDType("%s:%s is a container." % (scope, name))
+
+        if info['type'] == 'FILE':
+            trace['scope'] = scope
+            trace['filename'] = name
+        elif info['type'] == 'DATASET':
+            trace['datasetScope'] = scope
+            trace['dataset'] = name
+
+        url = '%s/%s/' % (choice(self.list_hosts), self.TRACES_BASEURL)
+
+        try:
+            post(url, verify=False, data=dumps(trace))
+        except Exception as error:
+            raise RucioException("Could not send trace. " + str(error))