rucio-clients 37.0.0rc1__py3-none-any.whl

rucio/client/client.py

@@ -0,0 +1,120 @@
+# 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.
+
+"""
+Client class for callers of the Rucio system
+"""
+
+from rucio.client.accountclient import AccountClient
+from rucio.client.accountlimitclient import AccountLimitClient
+from rucio.client.configclient import ConfigClient
+from rucio.client.credentialclient import CredentialClient
+from rucio.client.didclient import DIDClient
+from rucio.client.diracclient import DiracClient
+from rucio.client.exportclient import ExportClient
+from rucio.client.importclient import ImportClient
+from rucio.client.lifetimeclient import LifetimeClient
+from rucio.client.lockclient import LockClient
+from rucio.client.metaconventionsclient import MetaConventionClient
+from rucio.client.pingclient import PingClient
+from rucio.client.replicaclient import ReplicaClient
+from rucio.client.requestclient import RequestClient
+from rucio.client.rseclient import RSEClient
+from rucio.client.ruleclient import RuleClient
+from rucio.client.scopeclient import ScopeClient
+from rucio.client.subscriptionclient import SubscriptionClient
+from rucio.client.touchclient import TouchClient
+
+
+class Client(AccountClient,
+             AccountLimitClient,
+             MetaConventionClient,
+             PingClient,
+             ReplicaClient,
+             RequestClient,
+             RSEClient,
+             ScopeClient,
+             DIDClient,
+             RuleClient,
+             SubscriptionClient,
+             LockClient,
+             ConfigClient,
+             TouchClient,
+             ImportClient,
+             ExportClient,
+             CredentialClient,
+             DiracClient,
+             LifetimeClient):
+
+    """
+        Main client class for accessing Rucio resources. Handles the authentication.
+
+        Note:
+            Used to access all client methods. Each entity client *can* be used to access methods, but using the main client class is recommended for ease of use.
+
+    For using general methods -
+
+
+    ```
+    from rucio.client import Client
+
+    client = Client()  # authenticate with config or environ settings
+    client.add_replication_rule(...)
+
+    client = Client(
+        rucio_host = "my_host",
+        auth_host = "my_auth_host",
+        account = "jdoe12345",
+        auth_type = "userpass",
+        creds = {
+            "username": "jdoe12345",
+            "password": "******",
+        }
+    ) # authenticate with kwargs
+    client.list_replicas(...)
+    ```
+
+    For using the upload and download clients -
+
+    ```
+    from rucio.client import Client
+    from rucio.client.uploadclient import UploadClient
+    from rucio.client.downloadclient import DownloadClient
+
+    client = Client(...) # Initialize a client using your preferred method
+
+    upload_client = UploadClient(client) # Pass forward the initialized client
+    upload_client.upload(items=...)
+
+    download_client = DownloadClient(client)
+    download_client.download_dids(items=...)
+    ```
+
+    """
+
+    def __init__(self, **args):
+        """
+        Constructor for the Rucio main client class.
+
+        :param rucio_host: the host of the rucio system.
+        :param auth_host: the host of the rucio authentication server.
+        :param account: the rucio account that should be used to interact with the rucio system.
+        :param ca_cert: the certificate to verify the server.
+        :param auth_type: the type of authentication to use (e.g. userpass, x509 ...)
+        :param creds: credentials needed for authentication.
+        :param timeout: Float describes the timeout of the request (in seconds).
+        :param vo: The vo that the client will interact with.
+        :param logger: Logger instance to use (optional)
+        """
+        super(Client, self).__init__(**args)

rucio/client/configclient.py

@@ -0,0 +1,126 @@
+# 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 Any, Optional
+
+from requests.status_codes import codes
+
+from rucio.client.baseclient import BaseClient, choice
+from rucio.common.utils import build_url
+
+
+class ConfigClient(BaseClient):
+
+    """Client class for working with the configuration"""
+
+    CONFIG_BASEURL = 'config'
+
+    def get_config(
+            self,
+            section: Optional[str] = None,
+            option: Optional[str] = None
+    ) -> dict[str, Any]:
+        """
+        Sends the request to get the matching configuration.
+
+        :param section: the optional name of the section.
+        :param option: the optional option within the section.
+        :return: dictionary containing the configuration.
+        """
+
+        if section is None and option is not None:
+            raise ValueError('--section not specified')
+
+        path = self.CONFIG_BASEURL
+        if section is not None and option is None:
+            path += '/' + section
+        elif section is not None and option is not None:
+            path += '/'.join(['', section, option])
+
+        url = build_url(choice(self.list_hosts), path=path)
+
+        r = self._send_request(url, type_='GET')
+        if r.status_code == codes.ok:
+            return r.json()
+        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 set_config_option(
+            self,
+            section: str,
+            option: str,
+            value: Any,
+            use_body_for_params: bool = True
+    ) -> bool:
+        """
+        Sends the request to create or set an option within a section. Missing sections will be created.
+
+        :param section: the name of the section.
+        :param option: the name of the option.
+        :param value: the value to set on the config option
+        :param use_body_for_params: send parameters in a json-encoded request body instead of url-encoded
+        TODO: remove this parameter
+        The format of the /config endpoint was recently changed. We migrated from performing a PUT on
+        "/config/<section>/<option>/<value>" to sending the parameters using a json-encoded body.
+        This was done to fix multiple un-wanted side effects related to how the middleware treats
+        values encoded in a path.
+        For a smooth transition, we allow both cases for now, but we should migrate to only passing
+        values via the request body.
+        :return: True if option was removed successfully. False otherwise.
+        """
+
+        if use_body_for_params:
+            url = build_url(choice(self.list_hosts), path=self.CONFIG_BASEURL)
+            data = dumps({
+                section: {
+                    option: value
+                }
+            })
+            r = self._send_request(url, type_='POST', data=data)
+        else:
+            path = '/'.join([self.CONFIG_BASEURL, section, option, value])
+            url = build_url(choice(self.list_hosts), path=path)
+            r = self._send_request(url, type_='PUT')
+
+        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 delete_config_option(
+            self,
+            section: str,
+            option: str
+    ) -> bool:
+        """
+        Sends the request to remove an option from a section
+
+        :param section: the name of the section.
+        :param option: the name of the option.
+        :return: True if option was removed successfully. False otherwise.
+        """
+
+        path = '/'.join([self.CONFIG_BASEURL, section, option])
+        url = build_url(choice(self.list_hosts), path=path)
+
+        r = self._send_request(url, type_='DEL')
+
+        if r.status_code == codes.ok:
+            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)

rucio/client/credentialclient.py

@@ -0,0 +1,59 @@
+# 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 requests.status_codes import codes
+
+from rucio.client.baseclient import BaseClient, choice
+from rucio.common.utils import build_url
+
+
+class CredentialClient(BaseClient):
+    """Credential client class for working with URL signing"""
+
+    CREDENTIAL_BASEURL = 'credentials'
+
+    def get_signed_url(
+            self,
+            rse: str,
+            service: str,
+            operation: str,
+            url: str,
+            lifetime: int = 3600
+    ) -> str:
+        """
+        Return a signed version of the given URL for the given operation.
+
+        :param rse: The name of the RSE the URL points to.
+        :param service: The service the URL points to (gcs, s3, swift)
+        :param operation: The desired operation (read, write, delete)
+        :param url: The URL to sign
+        :param lifetime: The desired lifetime of the URL in seconds
+
+        :return: The signed URL string
+        """
+        path = '/'.join([self.CREDENTIAL_BASEURL, 'signurl'])
+        params = {}
+        params['lifetime'] = lifetime
+        params['rse'] = rse
+        params['svc'] = service
+        params['op'] = operation
+        params['url'] = url
+        rurl = build_url(choice(self.list_hosts), path=path, params=params)
+        r = self._send_request(rurl, type_='GET')
+
+        if r.status_code == codes.ok:
+            return 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)