rucio-clients 35.7.0__py3-none-any.whl → 37.0.0__py3-none-any.whl

rucio/cli/scope.py

@@ -0,0 +1,40 @@
+# 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 click
+
+from rucio.cli.bin_legacy.rucio_admin import add_scope, list_scopes
+from rucio.cli.utils import Arguments
+
+
+@click.group()
+def scope():
+    """Interact with scopes - a logical grouping of DIDs"""
+
+
+@scope.command("add")
+@click.argument("scope-name")
+@click.option("-a", "--account", help="Associated account", required=True)
+@click.pass_context
+def add_(ctx, account, scope_name):
+    """Add a new scope with name [SCOPE-NAME]"""
+    args = Arguments({"scope": scope_name, "account": account})
+    add_scope(args, ctx.obj.client, ctx.obj.logger, ctx.obj.console, ctx.obj.spinner)
+
+
+@scope.command("list")
+@click.option("-a", "--account", help="Filter by associated account", required=False)
+@click.pass_context
+def list_(ctx, account):
+    """List existing scopes"""
+    list_scopes(Arguments({"account": account}), ctx.obj.client, ctx.obj.logger, ctx.obj.console, ctx.obj.spinner)

rucio/cli/subscription.py

@@ -0,0 +1,73 @@
+# 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 click
+
+from rucio.cli.bin_legacy.rucio_admin import add_subscription, list_subscriptions, reevaluate_did_for_subscription, update_subscription
+from rucio.cli.utils import Arguments
+
+
+@click.group()
+def subscription():
+    "The methods for automated and regular processing of some specific rules"
+
+
+@subscription.command("show")
+@click.option("-a", "--account", help="Account associated with the subscription")
+@click.option("--long", default=False, is_flag=True, help="Show extended information about the subscription")
+@click.argument("subscription-name")
+@click.pass_context
+def list_(ctx, subscription_name, account, long):
+    """Show the attributes of a subscription [SUBSCRIPTION-NAME]"""
+    args = Arguments({"subs_account": account, "name": subscription_name, "long": long})
+    list_subscriptions(args, ctx.obj.client, ctx.obj.logger, ctx.obj.console, ctx.obj.spinner)
+
+
+@subscription.command("update")
+@click.argument("subscription-name")
+@click.option("--filter", "did_filter", help='Json serializable DID filter (eg \'{"scope": ["tests"], "project": ["data12_8TeV"]}\')', required=True)
+@click.option("--rule", help='List of replication rules (eg \'[{"activity": "Functional Tests", "copies": 2, "rse_expression": "tier=2", "lifetime": 3600, "weight": "mou"}]\')', required=True)
+@click.option("--comment", help="Comments on subscription")
+@click.option("--lifetime", type=int, help="Subscription lifetime (in days)")
+@click.option("--account", help="Account name")
+@click.option("--priority", help="The priority of the subscription")
+@click.pass_context
+def update(ctx, subscription_name, did_filter, rule, comment, lifetime, account, priority):
+    """Update a subscription [SUBSCRIPTION-NAME] to have new properties"""
+    args = Arguments({"name": subscription_name, "filter": did_filter, "replication_rules": rule, "comments": comment, "lifetime": lifetime, "subs_account": account, "priority": priority})
+    update_subscription(args, ctx.obj.client, ctx.obj.logger, ctx.obj.console, ctx.obj.spinner)
+
+
+@subscription.command("add")
+@click.argument("subscription-name")
+@click.option("--filter", "did_filter", help='Json serializable DID filter (eg \'{"scope": ["tests"], "project": ["data12_8TeV"]}\')', required=True)
+@click.option("--rule", help='List of replication rules (eg \'[{"activity": "Functional Tests", "copies": 2, "rse_expression": "tier=2", "lifetime": 3600, "weight": "mou"}]\')', required=True)
+@click.option("--comment", help="Comments on subscription")
+@click.option("--lifetime", type=int, help="Subscription lifetime (in days)")
+@click.option("--account", help="Account name")
+@click.option("--priority", help="The priority of the subscription")
+@click.pass_context
+def add_(ctx, subscription_name, did_filter, rule, comment, lifetime, account, priority):
+    """Create a new subscription with the name [SUBSCRIPTION-NAME]"""
+    args = Arguments({"name": subscription_name, "filter": did_filter, "replication_rules": rule, "comments": comment, "lifetime": lifetime, "subs_account": account, "priority": priority})
+    add_subscription(args, ctx.obj.client, ctx.obj.logger, ctx.obj.console, ctx.obj.spinner)
+
+
+@subscription.command("touch")
+@click.argument("dids", nargs=-1)
+@click.pass_context
+def touch(ctx, dids):
+    """Reevaluate list of DIDs against all active subscriptions"""
+    # TODO make reeval accept dids as a list
+    dids = ",".join(dids)
+    reevaluate_did_for_subscription(Arguments({"dids": dids}), ctx.obj.client, ctx.obj.logger, ctx.obj.console, ctx.obj.spinner)

rucio/cli/upload.py

@@ -0,0 +1,60 @@
+# 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 click
+
+from rucio.cli.bin_legacy.rucio import upload
+from rucio.cli.utils import Arguments
+from rucio.common.config import config_get_float
+
+
+@click.command("upload")
+@click.argument("file-paths", nargs=-1)
+@click.option("--rse", "--rse-name", help="Rucio Storage Element (RSE) name", required=True)
+@click.option("--lifetime", type=int, help="Lifetime of the rule in seconds")
+@click.option("--expiration-date", help="The date when the rule expires in UTC, format: <year>-<month>-<day>-<hour>:<minute>:<second>. E.g. 2022-10-20-20:00:00")
+@click.option("--scope", help="Scope name.")
+@click.option("--impl", type=click.Choice([]), help="Transfer protocol implementation to use (e.g: xrootd, gfal.NoRename, webdav, ssh.Rsync, rclone)")
+# The --no-register option is hidden. This is pilot ONLY. Users should not use this. Will lead to unregistered data on storage!
+@click.option("--no-register", is_flag=True, default=False, hidden=True)
+@click.option("--register-after-upload", is_flag=True, default=False, help="Register the file _only_ after successful upload")
+@click.option("--summary", is_flag=True, default=False, help="Create rucio_upload.json summary file")
+@click.option("--guid", help="Manually specify the GUID for the file.")
+@click.option("--protocol", help="Force the protocol to use")
+@click.option("--pfn", help="Specify the exact PFN for the upload")
+@click.option("--lfn", help="Specify the exact LFN for the upload")
+@click.option("--transfer-timeout", type=float, default=config_get_float("upload", "transfer_timeout", False, 360), help="Transfer timeout (in seconds)")
+@click.option("-r", "--recursive", is_flag=True, default=False, help="Convert recursively the folder structure into collections")
+@click.pass_context
+def upload_command(ctx, file_paths, rse, lifetime, expiration_date, scope, impl, no_register, register_after_upload, summary, guid, protocol, pfn, lfn, transfer_timeout, recursive):
+    """Upload file(s) to a Rucio RSE"""
+    args = Arguments(
+        {
+            "args": file_paths,
+            "rse": rse,
+            "lifetime": lifetime,
+            "expiration_date": expiration_date,
+            "scope": scope,
+            "impl": impl,
+            "no_register": no_register,
+            "register_after_upload": register_after_upload,
+            "protocol": protocol,
+            "summary": summary,
+            "guid": guid,
+            "pfn": pfn,
+            "name": lfn,
+            "transfer_timeout": transfer_timeout,
+            "recursive": recursive,
+        }
+    )
+    upload(args, ctx.obj.client, ctx.obj.logger, ctx.obj.console, ctx.obj.spinner)

rucio/cli/utils.py

@@ -0,0 +1,226 @@
+# 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 errno
+import logging
+import os
+import signal
+import subprocess
+import sys
+import traceback
+from configparser import NoOptionError, NoSectionError
+from functools import wraps
+
+from rucio.client.client import Client
+from rucio.common.config import config_get
+from rucio.common.exception import (
+    AccessDenied,
+    CannotAuthenticate,
+    DataIdentifierAlreadyExists,
+    DataIdentifierNotFound,
+    Duplicate,
+    DuplicateContent,
+    InvalidObject,
+    InvalidRSEExpression,
+    MissingDependency,
+    RSENotFound,
+    RucioException,
+    RuleNotFound,
+    UnsupportedOperation,
+)
+from rucio.common.utils import setup_logger
+
+SUCCESS = 0
+FAILURE = 1
+
+
+def exception_handler(function):
+    verbosity = ("-v" in sys.argv) or ("--verbose" in sys.argv)
+    logger = setup_logger(module_name=__name__, logger_name="user", verbose=verbosity)
+
+    @wraps(function)
+    def new_funct(*args, **kwargs):
+        try:
+            return function(*args, **kwargs)
+        except NotImplementedError as error:
+            logger.error(f"Cannot run that operation/command combination {error}")
+            return FAILURE
+        except InvalidObject as error:
+            logger.error(error)
+            return error.error_code
+        except DataIdentifierNotFound as error:
+            logger.error(error)
+            logger.debug("This means that the Data IDentifier you provided is not known by Rucio.")
+            return error.error_code
+        except AccessDenied as error:
+            logger.error(error)
+            logger.debug("This error is a permission issue. You cannot run this command with your account.")
+            return error.error_code
+        except DataIdentifierAlreadyExists as error:
+            logger.error(error)
+            logger.debug("This means that the Data IDentifier you try to add is already registered in Rucio.")
+            return error.error_code
+        except RSENotFound as error:
+            logger.error(error)
+            logger.debug("This means that the Rucio Storage Element you provided is not known by Rucio.")
+            return error.error_code
+        except InvalidRSEExpression as error:
+            logger.error(error)
+            logger.debug("This means the RSE expression you provided is not syntactically correct.")
+            return error.error_code
+        except DuplicateContent as error:
+            logger.error(error)
+            logger.debug("This means that the DID you want to attach is already in the target DID.")
+            return error.error_code
+        except Duplicate as error:
+            logger.error(error)
+            logger.debug("This means that you are trying to add something that already exists.")
+            return error.error_code
+        except TypeError as error:
+            logger.error(error)
+            logger.debug("This means the parameter you passed has a wrong type.")
+            return FAILURE
+        except RuleNotFound as error:
+            logger.error(error)
+            logger.debug("This means the rule you specified does not exist.")
+            return error.error_code
+        except UnsupportedOperation as error:
+            logger.error(error)
+            logger.debug("This means you cannot change the status of the DID.")
+            return error.error_code
+        except MissingDependency as error:
+            logger.error(error)
+            logger.debug("This means one dependency is missing.")
+            return error.error_code
+        except KeyError as error:
+            if "x-rucio-auth-token" in str(error):
+                used_account = None
+                try:  # get the configured account from the configuration file
+                    used_account = "%s (from rucio.cfg)" % config_get("client", "account")
+                except Exception:
+                    pass
+                try:  # are we overriden by the environment?
+                    used_account = "%s (from RUCIO_ACCOUNT)" % os.environ["RUCIO_ACCOUNT"]
+                except Exception:
+                    pass
+                logger.error("Specified account %s does not have an associated identity." % used_account)
+
+            else:
+                logger.debug(traceback.format_exc())
+                contact = config_get("policy", "support", raise_exception=False)
+                support = ("Please follow up with all relevant information at: " + contact) if contact else ""
+                logger.error("\nThe object is missing this property: %s\n" 'This should never happen. Please rerun the last command with the "-v" option to gather more information.\n' "%s" % (str(error), support))
+            return FAILURE
+        except RucioException as error:
+            logger.error(error)
+            return error.error_code
+        except Exception as error:
+            if isinstance(error, IOError) and getattr(error, "errno", None) == errno.EPIPE:
+                # Ignore Broken Pipe
+                # While in python3 we can directly catch 'BrokenPipeError', in python2 it doesn't exist.
+
+                # Python flushes standard streams on exit; redirect remaining output
+                # to devnull to avoid another BrokenPipeError at shutdown
+                devnull = os.open(os.devnull, os.O_WRONLY)
+                os.dup2(devnull, sys.stdout.fileno())
+                return SUCCESS
+            logger.debug(traceback.format_exc())
+            logger.error(error)
+            contact = config_get("policy", "support", raise_exception=False)
+            support = ("If it's a problem concerning your experiment or if you're unsure what to do, please follow up at: %s\n" % contact) if contact else ""
+            contact = config_get("policy", "support_rucio", default="https://github.com/rucio/rucio/issues")
+            support += "If you're sure there is a problem with Rucio itself, please follow up at: " + contact
+            logger.error("\nRucio exited with an unexpected/unknown error.\n" 'Please rerun the last command with the "-v" option to gather more information.\n' "%s" % support)
+            return FAILURE
+
+    return new_funct
+
+
+def get_client(args, logger):
+    """
+    Returns a new client object.
+    """
+    if hasattr(args, "config") and (args.config is not None):
+        os.environ["RUCIO_CONFIG"] = args.config
+
+    if logger is None:
+        logger = setup_logger(module_name=__name__, logger_name="user", verbose=args.verbose)
+
+    if not args.auth_strategy:
+        if "RUCIO_AUTH_TYPE" in os.environ:
+            auth_type = os.environ["RUCIO_AUTH_TYPE"].lower()
+        else:
+            try:
+                auth_type = config_get("client", "auth_type").lower()
+            except (NoOptionError, NoSectionError):
+                logger.error("Cannot get AUTH_TYPE")
+                sys.exit(1)
+    else:
+        auth_type = args.auth_strategy.lower()
+
+    if auth_type in ["userpass", "saml"] and args.username is not None and args.password is not None:
+        creds = {"username": args.username, "password": args.password}
+    elif auth_type == "oidc":
+        if args.oidc_issuer:
+            args.oidc_issuer = args.oidc_issuer.lower()
+        creds = {
+            "oidc_auto": args.oidc_auto,
+            "oidc_scope": args.oidc_scope,
+            "oidc_audience": args.oidc_audience,
+            "oidc_polling": args.oidc_polling,
+            "oidc_refresh_lifetime": args.oidc_refresh_lifetime,
+            "oidc_issuer": args.oidc_issuer,
+            "oidc_username": args.oidc_username,
+            "oidc_password": args.oidc_password,
+        }
+    elif auth_type == "x509":
+        creds = {"client_cert": args.certificate, "client_key": args.client_key}
+    else:
+        creds = None
+
+    try:
+        client = Client(rucio_host=args.host, auth_host=args.auth_host, account=args.issuer, auth_type=auth_type, creds=creds, ca_cert=args.ca_certificate, timeout=args.timeout, user_agent=args.user_agent, vo=args.vo, logger=logger)
+    except CannotAuthenticate as error:
+        logger.error(error)
+        if "alert certificate expired" in str(error):
+            logger.error("The server certificate expired.")
+        elif auth_type.lower() == "x509_proxy":
+            logger.error("Please verify that your proxy is still valid and renew it if needed.")
+        sys.exit(1)
+    return client
+
+
+def signal_handler(sig, frame, logger):
+    logger.warning("You pressed Ctrl+C! Exiting gracefully")
+    child_processes = subprocess.Popen("ps -o pid --ppid %s --noheaders" % os.getpid(), shell=True, stdout=subprocess.PIPE)
+    child_processes = child_processes.stdout.read()  # type: ignore
+    for pid in child_processes.split("\n")[:-1]:  # type: ignore
+        try:
+            os.kill(int(pid), signal.SIGTERM)
+        except Exception:
+            print("Cannot kill child process")
+    sys.exit(1)
+
+
+def setup_gfal2_logger():
+    gfal2_logger = logging.getLogger("gfal2")
+    gfal2_logger.setLevel(logging.CRITICAL)
+    gfal2_logger.addHandler(logging.StreamHandler())
+
+
+class Arguments(dict):
+    """dot.notation access to dictionary attributes"""
+
+    __getattr__ = dict.get
+    __setattr__ = dict.__setitem__
+    __delattr__ = dict.__delitem__

rucio/client/accountclient.py

@@ -200,7 +200,6 @@ class AccountClient(BaseClient):
         :param account: The account name.
         :param identity: The identity key name. For example x509 DN, or a username.
         :param authtype: The type of the authentication (x509, gss, userpass).
-        :param default: If True, the account should be used by default with the provided identity.
         """
 
         data = dumps({'identity': identity, 'authtype': authtype})

rucio/client/baseclient.py

@@ -22,13 +22,11 @@ import os
 import secrets
 import sys
 import time
-from collections.abc import Generator
 from configparser import NoOptionError, NoSectionError
-from logging import Logger
 from os import environ, fdopen, geteuid, makedirs, path
 from shutil import move
 from tempfile import mkstemp
-from typing import Any, Optional
+from typing import TYPE_CHECKING, Any, Optional
 from urllib.parse import urlparse
 
 import requests
@@ -40,10 +38,14 @@ from requests.status_codes import codes
 from rucio import version
 from rucio.common import exception
 from rucio.common.config import config_get, config_get_bool, config_get_int
-from rucio.common.exception import CannotAuthenticate, ClientProtocolNotSupported, ConfigNotFound, MissingClientParameter, MissingModuleException, NoAuthInformation, ServerConnectionException
+from rucio.common.exception import CannotAuthenticate, ClientProtocolNotFound, ClientProtocolNotSupported, ConfigNotFound, MissingClientParameter, MissingModuleException, NoAuthInformation, ServerConnectionException
 from rucio.common.extra import import_extras
 from rucio.common.utils import build_url, get_tmp_dir, my_key_generator, parse_response, setup_logger, ssh_sign
 
+if TYPE_CHECKING:
+    from collections.abc import Generator
+    from logging import Logger
+
 EXTRA_MODULES = import_extras(['requests_kerberos'])
 
 if EXTRA_MODULES['requests_kerberos']:
@@ -90,7 +92,7 @@ class BaseClient:
                  timeout: Optional[int] = 600,
                  user_agent: Optional[str] = 'rucio-clients',
                  vo: Optional[str] = None,
-                 logger: Logger = LOG) -> None:
+                 logger: 'Logger' = LOG) -> None:
         """
         Constructor of the BaseClient.
         :param rucio_host: The address of the rucio server, if None it is read from the config file.
@@ -155,11 +157,18 @@ class BaseClient:
         rucio_scheme = urlparse(self.host).scheme
         auth_scheme = urlparse(self.auth_host).scheme
 
-        if rucio_scheme != 'http' and rucio_scheme != 'https':
-            raise ClientProtocolNotSupported('\'%s\' not supported' % rucio_scheme)
+        rucio_scheme_allowed = ['http', 'https']
+        auth_scheme_allowed = ['http', 'https']
+
+        if not rucio_scheme:
+            raise ClientProtocolNotFound(host=self.host, protocols_allowed=rucio_scheme_allowed)
+        elif rucio_scheme not in rucio_scheme_allowed:
+            raise ClientProtocolNotSupported(host=self.host, protocol=rucio_scheme, protocols_allowed=rucio_scheme_allowed)
 
-        if auth_scheme != 'http' and auth_scheme != 'https':
-            raise ClientProtocolNotSupported('\'%s\' not supported' % auth_scheme)
+        if not auth_scheme:
+            raise ClientProtocolNotFound(host=self.auth_host, protocols_allowed=auth_scheme_allowed)
+        elif auth_scheme not in auth_scheme_allowed:
+            raise ClientProtocolNotSupported(host=self.auth_host, protocol=auth_scheme, protocols_allowed=auth_scheme_allowed)
 
         if (rucio_scheme == 'https' or auth_scheme == 'https') and ca_cert is None:
             self.logger.debug('HTTPS is required, but no ca_cert was passed. Trying to get it from X509_CERT_DIR.')
@@ -364,7 +373,7 @@ class BaseClient:
         else:
             return exception.RucioException, "%s: %s" % (exc_cls, exc_msg)
 
-    def _load_json_data(self, response: requests.Response) -> Generator[Any, Any, Any]:
+    def _load_json_data(self, response: requests.Response) -> 'Generator[Any, Any, Any]':
         """
         Helper method to correctly load json data based on the content type of the http response.
 
@@ -517,7 +526,7 @@ class BaseClient:
         self.auth_token = result.headers['x-rucio-auth-token']
         return True
 
-    def __refresh_token_OIDC(self) -> bool:
+    def __refresh_token_oidc(self) -> bool:
         """
         Checks if there is active refresh token and if so returns
         either active token with expiration timestamp or requests a new
@@ -571,7 +580,7 @@ class BaseClient:
                    \nRucio Auth Server when attempting token refresh.")
             return False
 
-    def __get_token_OIDC(self) -> bool:
+    def __get_token_oidc(self) -> bool:
         """
         First authenticates the user via a Identity Provider server
         (with user's username & password), by specifying oidc_scope,
@@ -600,14 +609,14 @@ class BaseClient:
         request_auth_url = build_url(self.auth_host, path='auth/oidc')
         # requesting authorization URL specific to the user & Rucio OIDC Client
         self.logger.debug("Initial auth URL request headers %s to files" % str(headers))
-        OIDC_auth_res = self._send_request(request_auth_url, headers=headers, get_token=True)
-        self.logger.debug("Response headers %s and text %s" % (str(OIDC_auth_res.headers), str(OIDC_auth_res.text)))
+        oidc_auth_res = self._send_request(request_auth_url, headers=headers, get_token=True)
+        self.logger.debug("Response headers %s and text %s" % (str(oidc_auth_res.headers), str(oidc_auth_res.text)))
         # with the obtained authorization URL we will contact the Identity Provider to get to the login page
-        if 'X-Rucio-OIDC-Auth-URL' not in OIDC_auth_res.headers:
+        if 'X-Rucio-OIDC-Auth-URL' not in oidc_auth_res.headers:
             print("Rucio Client did not succeed to get AuthN/Z URL from the Rucio Auth Server. \
                                    \nThis could be due to wrongly requested/configured scope, audience or issuer.")
             return False
-        auth_url = OIDC_auth_res.headers['X-Rucio-OIDC-Auth-URL']
+        auth_url = oidc_auth_res.headers['X-Rucio-OIDC-Auth-URL']
         if not self.creds['oidc_auto']:
             print("\nPlease use your internet browser, go to:")
             print("\n    " + auth_url + "    \n")
@@ -692,7 +701,7 @@ class BaseClient:
             with fdopen(file_d, "w") as f_exp_epoch:
                 f_exp_epoch.write(str(self.token_exp_epoch))
             move(file_n, self.token_exp_epoch_file)
-            self.__refresh_token_OIDC()
+            self.__refresh_token_oidc()
         return True
 
     def __get_token_x509(self) -> bool:
@@ -832,11 +841,11 @@ class BaseClient:
         url = build_url(self.auth_host, path='auth/saml')
 
         result = None
-        SAML_auth_result = self._send_request(url, get_token=True)
-        if SAML_auth_result.headers['X-Rucio-Auth-Token']:
-            return SAML_auth_result.headers['X-Rucio-Auth-Token']
-        SAML_auth_url = SAML_auth_result.headers['X-Rucio-SAML-Auth-URL']
-        result = self._send_request(SAML_auth_url, type_='POST', data=userpass, verify=False)
+        saml_auth_result = self._send_request(url, get_token=True)
+        if saml_auth_result.headers['X-Rucio-Auth-Token']:
+            return saml_auth_result.headers['X-Rucio-Auth-Token']
+        saml_auth_url = saml_auth_result.headers['X-Rucio-SAML-Auth-URL']
+        result = self._send_request(saml_auth_url, type_='POST', data=userpass, verify=False)
         result = self._send_request(url, get_token=True)
 
         if not result:
@@ -868,7 +877,7 @@ class BaseClient:
                     raise CannotAuthenticate('x509 authentication failed for account=%s with identity=%s' % (self.account,
                                                                                                              self.creds))
             elif self.auth_type == 'oidc':
-                if not self.__get_token_OIDC():
+                if not self.__get_token_oidc():
                     raise CannotAuthenticate('OIDC authentication failed for account=%s' % self.account)
 
             elif self.auth_type == 'gss':
@@ -912,7 +921,7 @@ class BaseClient:
         except Exception:
             raise
         if self.auth_oidc_refresh_active and self.auth_type == 'oidc':
-            self.__refresh_token_OIDC()
+            self.__refresh_token_oidc()
         self.logger.debug('got token from file')
         return True
 

rucio/client/client.py

@@ -57,7 +57,51 @@ class Client(AccountClient,
              DiracClient,
              LifetimeClient):
 
-    """Main client class for accessing Rucio resources. Handles the authentication."""
+    """
+        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):
         """

rucio/client/didclient.py

@@ -538,14 +538,16 @@ class DIDClient(BaseClient):
     def get_metadata_bulk(
             self,
             dids: "Sequence[Mapping[str, Any]]",
-            inherit: bool = False
+            inherit: bool = False,
+            plugin: str = "JSON",
     ) -> "Iterator[dict[str, Any]]":
         """
         Bulk get data identifier metadata
-        :param inherit:            A boolean. If set to true, the metadata of the parent are concatenated.
         :param dids:               A list of dids.
+        :param inherit:            A boolean. If set to true, the metadata of the parent are concatenated.
+        :param plugin:             The metadata plugin to query, 'ALL' for all available plugins
         """
-        data = {'dids': dids, 'inherit': inherit}
+        data = {'dids': dids, 'inherit': inherit, 'plugin': plugin}
         path = '/'.join([self.DIDS_BASEURL, 'bulkmeta'])
         url = build_url(choice(self.list_hosts), path=path)
         r = self._send_request(url, type_='POST', data=dumps(data))