rucio-clients 37.0.0rc1__py3-none-any.whl

rucio/client/exportclient.py

@@ -0,0 +1,44 @@
+# 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 typing import Any
+
+from requests.status_codes import codes
+
+from rucio.client.baseclient import BaseClient, choice
+from rucio.common.utils import build_url, parse_response
+
+
+class ExportClient(BaseClient):
+    """RSE client class for exporting data from Rucio"""
+
+    EXPORT_BASEURL = 'export'
+
+    def export_data(self, distance: bool = True) -> dict[str, Any]:
+        """
+        Export RSE data (RSE, settings, attributes and distance).
+        :param distance: To include the distance.
+
+        :returns: A dict containing data
+        """
+        payload = {'distance': distance}
+        path = '/'.join([self.EXPORT_BASEURL])
+        url = build_url(choice(self.list_hosts), path=path, params=payload)
+
+        r = self._send_request(url, type_='GET')
+        if r.status_code == codes.ok:
+            return parse_response(r.text)
+        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/fileclient.py

@@ -0,0 +1,50 @@
+# 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 typing import Any
+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 FileClient(BaseClient):
+    """Dataset client class for working with dataset"""
+
+    BASEURL = 'files'
+
+    def list_file_replicas(self, scope: str, lfn: str) -> list[dict[str, Any]]:
+        """
+        List file replicas.
+
+        :param scope: the scope.
+        :param lfn: the lfn.
+
+        :return: List of replicas.
+        """
+        path = '/'.join([self.BASEURL, quote_plus(scope), quote_plus(lfn), 'rses'])
+        url = build_url(choice(self.list_hosts), path=path)
+
+        r = self._send_request(url, type_='GET')
+
+        if r.status_code == codes.ok:
+            rses = loads(r.text)
+            return rses
+        else:
+            print(r.status_code)
+            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/importclient.py

@@ -0,0 +1,42 @@
+# 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 typing import Any
+
+from requests.status_codes import codes
+
+from rucio.client.baseclient import BaseClient, choice
+from rucio.common.utils import build_url, render_json
+
+
+class ImportClient(BaseClient):
+    """RSE client class for importing data into Rucio"""
+
+    IMPORT_BASEURL = 'import'
+
+    def import_data(self, data: dict[str, Any]) -> str:
+        """
+        Imports data into Rucio.
+
+        :param data: a dict containing data to be imported into Rucio.
+        """
+        path = '/'.join([self.IMPORT_BASEURL])
+        url = build_url(choice(self.list_hosts), path=path)
+
+        r = self._send_request(url, type_='POST', data=render_json(**data))
+        if r.status_code == codes.created:
+            return r.text
+        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/lifetimeclient.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 typing import TYPE_CHECKING, Any, Optional
+
+from requests.status_codes import codes
+
+from rucio.client.baseclient import BaseClient, choice
+from rucio.common.utils import build_url, render_json
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator, Sequence
+    from datetime import datetime
+
+    from rucio.db.sqla.constants import LifetimeExceptionsState
+
+
+class LifetimeClient(BaseClient):
+
+    """Lifetime client class for working with Lifetime Model exceptions"""
+
+    LIFETIME_BASEURL = 'lifetime_exceptions'
+
+    def list_exceptions(
+            self,
+            exception_id: Optional[str] = None,
+            states: Optional['Sequence[LifetimeExceptionsState]'] = None
+    ) -> 'Iterator[dict[str, Any]]':
+        """
+        List exceptions to Lifetime Model.
+
+        :param id:         The id of the exception
+        :param states:     The states to filter
+        """
+
+        path = self.LIFETIME_BASEURL + '/'
+        params = {}
+        if exception_id:
+            params['exception_id'] = exception_id
+        if states:
+            params['states'] = exception_id
+        url = build_url(choice(self.list_hosts), path=path, params=params)
+
+        result = self._send_request(url)
+        if result.status_code == codes.ok:
+            lifetime_exceptions = self._load_json_data(result)
+            return lifetime_exceptions
+        else:
+            exc_cls, exc_msg = self._get_exception(headers=result.headers, status_code=result.status_code)
+            raise exc_cls(exc_msg)
+
+    def add_exception(
+            self,
+            dids: list[dict[str, Any]],
+            account: str,
+            pattern: str,
+            comments: str,
+            expires_at: 'datetime'
+    ) -> dict[str, Any]:
+        """
+        Add exceptions to Lifetime Model.
+
+        :param dids:        The list of dids
+        :param account:     The account of the requester.
+        :param pattern:     The account.
+        :param comments:    The comments associated to the exception.
+        :param expires_at:  The expiration date of the exception.
+
+        returns:            The id of the exception.
+        """
+        path = self.LIFETIME_BASEURL + '/'
+        url = build_url(choice(self.list_hosts), path=path)
+        data = {'dids': dids, 'account': account, 'pattern': pattern, 'comments': comments, 'expires_at': expires_at}
+        result = self._send_request(url, type_='POST', data=render_json(**data))
+        if result.status_code == codes.created:
+            return loads(result.text)
+        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/lockclient.py

@@ -0,0 +1,109 @@
+# 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 typing import TYPE_CHECKING, Any
+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, render_json
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator, Mapping
+
+
+class LockClient(BaseClient):
+
+    """Lock client class for working with rucio locks"""
+
+    LOCKS_BASEURL = 'locks'
+
+    def get_dataset_locks(
+            self,
+            scope: str,
+            name: str
+    ) -> "Iterator[dict[str, Any]]":
+        """
+        Get a dataset locks of the specified dataset.
+
+        :param scope: the scope of the did of the locks to list.
+        :param name: the name of the did of the locks to list.
+        """
+
+        path = '/'.join([self.LOCKS_BASEURL, quote_plus(scope), quote_plus(name)])
+        url = build_url(choice(self.list_hosts), path=path, params={'did_type': 'dataset'})
+
+        result = self._send_request(url)
+        if result.status_code == codes.ok:   # pylint: disable-msg=E1101
+            locks = self._load_json_data(result)
+            return locks
+        else:
+            exc_cls, exc_msg = self._get_exception(headers=result.headers,
+                                                   status_code=result.status_code)
+            raise exc_cls(exc_msg)
+
+    def get_locks_for_dids(
+            self,
+            dids: list["Mapping[str, Any]"],
+            **filter_args: dict[str, Any]
+    ) -> list[dict[str, Any]]:
+        """
+        Get list of locks for for all the files found, recursively, in the listed datasets or containers.
+
+        :param dids: list of dictionaries {"scope":..., "name":..., "type":...}
+                     type can be either "dataset" or "container"
+                     type is optional, but if specified, improves the query performance
+        :returns:    list of dictionaries with lock info
+        """
+
+        # convert did list to list of dictionaries
+        if not all(did.get("type", "dataset") in ("dataset", "container") for did in dids):
+            raise ValueError("DID type can be either 'container' or 'dataset'")
+
+        path = '/'.join([self.LOCKS_BASEURL, "bulk_locks_for_dids"])
+        url = build_url(choice(self.list_hosts), path=path)
+
+        result = self._send_request(url, type_='POST', data=render_json(dids=dids))
+        if result.status_code == codes.ok:   # pylint: disable-msg=E1101
+            out = []
+            for lock in self._load_json_data(result):
+                filter_ok = (not filter_args) or all(lock.get(name) == value for name, value in filter_args.items())
+                if filter_ok:
+                    out.append(lock)
+            return out
+        else:
+            exc_cls, exc_msg = self._get_exception(headers=result.headers,
+                                                   status_code=result.status_code)
+            raise exc_cls(exc_msg)
+
+    def get_dataset_locks_by_rse(self, rse: str) -> "Iterator[dict[str, Any]]":
+        """
+        Get all dataset locks of the specified rse.
+
+        :param rse: the rse of the locks to list.
+        """
+
+        path = '/'.join([self.LOCKS_BASEURL, rse])
+        url = build_url(choice(self.list_hosts), path=path, params={'did_type': 'dataset'})
+
+        result = self._send_request(url)
+        if result.status_code == codes.ok:   # pylint: disable-msg=E1101
+            locks = self._load_json_data(result)
+            return locks
+        else:
+            exc_cls, exc_msg = self._get_exception(headers=result.headers,
+                                                   status_code=result.status_code)
+
+            raise exc_cls(exc_msg)

rucio/client/metaconventionsclient.py

@@ -0,0 +1,140 @@
+# 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, 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 rucio.db.sqla.constants import KeyType
+
+
+class MetaConventionClient(BaseClient):
+
+    """Metadata client class for working with data identifier attributes"""
+
+    META_BASEURL = 'meta_conventions'
+
+    def add_key(self, key: str, key_type: Union['KeyType', str], value_type: Optional[str] = None, value_regexp: Optional[str] = None) -> Optional[bool]:
+        """
+        Sends the request to add an allowed key for DID metadata (update the DID Metadata Conventions table with a new key).
+
+        :param key: the name for the new key.
+        :param key_type: the type of the key: all(container, dataset, file), collection(dataset or container), file, derived(compute from file for collection).
+        :param value_type: the type of the value, if defined.
+        :param value_regexp: the regular expression that values should match, if defined.
+
+        :return: True if key was created successfully.
+        :raises Duplicate: if key already exists.
+        """
+
+        path = '/'.join([self.META_BASEURL, quote_plus(key)])
+        url = build_url(choice(self.list_hosts), path=path)
+        data = dumps({'value_type': value_type and str(value_type),
+                      'value_regexp': value_regexp,
+                      'key_type': key_type})
+
+        r = self._send_request(url, type_='POST', data=data)
+
+        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_keys(self) -> Optional[list[str]]:
+        """
+        Sends the request to list all keys for DID Metadata Conventions.
+
+        :return: a list containing the names of all keys.
+        """
+        path = self.META_BASEURL + '/'
+        url = build_url(choice(self.list_hosts), path=path)
+        r = self._send_request(url)
+        if r.status_code == codes.ok:
+            keys = loads(r.text)
+            return keys
+        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_values(self, key: str) -> Optional[list[str]]:
+        """
+        Sends the request to lists all allowed values for a DID key (all values for a key in DID Metadata Conventions).
+.
+
+        :return: a list containing the names of all values for a key.
+        """
+        path = '/'.join([self.META_BASEURL, quote_plus(key)]) + '/'
+        url = build_url(choice(self.list_hosts), path=path)
+        r = self._send_request(url)
+        if r.status_code == codes.ok:
+            values = loads(r.text)
+            return values
+        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 add_value(self, key: str, value: str) -> Optional[bool]:
+        """
+        Sends the request to add a value for a key in DID Metadata Convention.
+
+        :param key: the name for key.
+        :param value: the value.
+
+        :return: True if value was created successfully.
+        :raises Duplicate: if valid already exists.
+        """
+
+        path = '/'.join([self.META_BASEURL, quote_plus(key)]) + '/'
+        data = dumps({'value': value})
+        url = build_url(choice(self.list_hosts), path=path)
+        r = self._send_request(url, type_='POST', data=data)
+        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 del_value(self, key, value):
+        """
+        Delete a key in the DID Metadata Conventions table.
+
+        :param key: the name for key.
+        :param value: the value.
+        """
+        pass
+
+    def del_key(self, key):
+        """
+        Delete an allowed key.
+
+        :param key: the name for key.
+        """
+        pass
+
+    def update_key(self, key, type_=None, regexp=None):
+        """
+        Update a key.
+
+        :param key: the name for key.
+        :param type_: the type of the value, if defined.
+        :param regexp: the regular expression that values should match, if defined.
+        """
+        pass

rucio/client/pingclient.py

@@ -0,0 +1,44 @@
+# 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 requests.status_codes import codes
+
+from rucio.client.baseclient import BaseClient
+from rucio.common.utils import build_url
+
+
+class PingClient(BaseClient):
+
+    """Ping client class"""
+
+    def ping(self):
+        """
+        Sends a ping request to the rucio server.
+
+        :return: Dictonnary with server information
+        """
+
+        headers = None
+        path = 'ping'
+        url = build_url(self.host, path=path)
+        r = self._send_request(url, headers=headers, type_='GET')
+
+        if r.status_code == codes.ok:
+            server_info = loads(r.text)
+            return server_info
+
+        exc_cls, exc_msg = self._get_exception(headers=r.headers, status_code=r.status_code, data=r.content)
+        raise exc_cls(exc_msg)