rucio-clients 36.1.0__tar.gz → 36.3.0__tar.gz

{rucio_clients-36.1.0 → rucio_clients-36.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rucio-clients
-Version: 36.1.0
+Version: 36.3.0
 Summary: Rucio Client Lite Package
 Home-page: https://rucio.cern.ch/
 Author: Rucio

{rucio_clients-36.1.0 → rucio_clients-36.3.0}/bin/rucio

@@ -15,28 +15,39 @@
 
 import argparse
 import sys
-from typing import Optional
+from typing import TYPE_CHECKING, Optional
 
 from rucio.client.commands.bin_legacy.rucio import main as main_legacy
 from rucio.client.commands.command import main
+from rucio.common.utils import setup_logger
 
+if TYPE_CHECKING:
+    from logging import Logger
 
-def make_warning():
-    base_warning = "\nWARNING: This method is being deprecated."
+
+def _get_first_command(args: list[str]) -> Optional[str]:
+    return next(
+        (
+            arg for arg in args
+            if arg != 'rucio' and (arg[0] != "-" or arg in ("-h", "--help", "--version"))
+        ),
+        None
+    )
+
+
+def make_warning(logger: "Logger") -> None:
+    base_warning = "This method is being deprecated."
     new_command = map_legacy_command()
     if new_command is not None:
-        warning = f"{base_warning}\nPlease replace your command with `rucio {' '.join(new_command)}`.\n"
+        warning = f"{base_warning} Please replace your command with `rucio {' '.join(new_command)}`"
     else:
-        warning = base_warning + "\nPlease view rucio -h for an updated help menu.\n"
+        warning = base_warning + " Please view rucio -h for an updated help menu."
 
-    return warning
+    logger.warning(warning)
 
 
 def map_legacy_command() -> Optional[list[str]]:
-    try:
-        command = [arg for arg in sys.argv if arg[0] != "-" or arg in ("-h", "--version")][1]
-    except IndexError:
-        command = None
+    command = _get_first_command(sys.argv[1:])
 
     new_command = None
     if command not in ("-h", "--version", None):
@@ -89,26 +100,26 @@ def map_legacy_command() -> Optional[list[str]]:
 
 if __name__ == "__main__":
     commands = ("-h", "--help", "--version", "account", "config", "did", "replica", "rse", "rule", "scope", "subscription", "ping", "whoami", "test-server", "lifetime-exception", "upload", "download")
-    first_command = [arg for arg in sys.argv if arg[0] != "-" or arg in ("-h", "--help", "--version")][1]
+    logger = setup_logger(module_name=__name__)
+    first_command = _get_first_command(sys.argv[1:])
+
     is_legacy = '--legacy' in sys.argv
 
     if (first_command in commands) and not is_legacy:
         main()
 
     elif is_legacy:
-        warning = make_warning()
-        print(warning)
+        make_warning(logger)
         sys.argv.pop(sys.argv.index('--legacy'))
         main_legacy()
 
     else:
-        warning = make_warning()
-        print(warning)
+        make_warning(logger)
         try:
             main_legacy()
         # Make a custom warning - show the new help menu when invalid commands are called.
         except argparse.ArgumentError:
-            print("Invalid argument(s) - %s " % sys.argv[1:])
+            logger.error("Invalid argument(s) - %s " % sys.argv[1:])
             command = map_legacy_command()
             if command is not None:
                 sys.argv = ["rucio"] + command + ["-h"]

{rucio_clients-36.1.0 → rucio_clients-36.3.0}/bin/rucio-admin

@@ -15,12 +15,18 @@
 import sys
 
 from rucio.client.commands.bin_legacy.rucio_admin import main as main_legacy
+from rucio.common.utils import setup_logger
 
 
 def make_warning():
-    base_warning = "\nWARNING: This method is being deprecated."
+    logger = setup_logger(module_name=__name__)
+
+    base_warning = "This method is being deprecated."
     args = [arg for arg in sys.argv if arg[0] != "-" or arg in ("-h", "--help", "--version")]
-    first_command = args[1]
+    try:
+        first_command = args[1]
+    except IndexError:
+        first_command = None
     try:
         second_command = args[2]
     except IndexError:
@@ -85,11 +91,11 @@ def make_warning():
         except KeyError:
             new_command = "-h"
 
-        warning = f"{base_warning}\nPlease replace your command with `rucio {new_command}`.\n"
+        warning = f"{base_warning} Please replace your command with `rucio {new_command}`"
     else:
-        warning = base_warning + "\nPlease view rucio -h for an updated help menu.\n"
+        warning = base_warning + " Please view rucio -h for an updated help menu."
 
-    print(warning)
+    logger.warning(warning)
 
 
 if __name__ == "__main__":

{rucio_clients-36.1.0 → rucio_clients-36.3.0}/lib/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_clients-36.1.0 → rucio_clients-36.3.0}/lib/rucio/client/baseclient.py

@@ -38,7 +38,7 @@ 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
 
@@ -157,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 auth_scheme != 'http' and auth_scheme != 'https':
-            raise ClientProtocolNotSupported('\'%s\' not supported' % auth_scheme)
+        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 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.')
@@ -519,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
@@ -573,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,
@@ -602,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")
@@ -694,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:
@@ -834,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:
@@ -870,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':
@@ -914,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_clients-36.1.0 → rucio_clients-36.3.0}/lib/rucio/client/commands/account.py

@@ -11,6 +11,7 @@
 # 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 argparse import SUPPRESS
 from typing import TYPE_CHECKING
 
@@ -60,20 +61,20 @@ class Account(CommandBase):
         parser.add_argument("--filters", dest="filters", action="store", help="Filter arguments in form `key=value,another_key=next_value`")
 
     def add_namespace(self, parser: "ArgumentParser") -> None:
-        parser.add_argument("--type", dest="accounttype", help="Account Type (USER, GROUP, SERVICE)", required=True)
+        parser.add_argument("--type", dest="account_type", help="Account Type", choices={"USER", "GROUP", "SERVICE"}, required=True)
         parser.add_argument("-a", "--account", dest="account", help="Account name", required=True)
-        parser.add_argument("--email", dest="accountemail", help="Add an email address associated with the account")
+        parser.add_argument("--email", dest="email", help="Add an email address associated with the account")
 
     def show_namespace(self, parser: "ArgumentParser") -> None:
         parser.add_argument("-a", "--account", dest="account", help="Account name", required=True)
 
     def update_namespace(self, parser: "ArgumentParser") -> None:
-        parser.add_argument("-a", "--account", help="Account name", required=True)
-        parser.add_argument("--email", help="Account email")
-        parser.add_argument("--ban", type=bool, choices=(True, False), help='Ban the account, to disable it. Use --ban False to unban.', default=None)
+        parser.add_argument("-a", "--account", dest="account", help="Account name", required=True)
+        parser.add_argument("--email", dest="email", help="Account email")
+        parser.add_argument("--ban", dest="ban", type=bool, choices=(True, False), help='Ban the account, to disable it. Use --ban False to unban.', default=None)
 
     def remove_namespace(self, parser: "ArgumentParser") -> None:
-        parser.add_argument("-a", "--account", dest="acnt", action="store", help="Account name", required=True)
+        parser.add_argument("-a", "--account", dest="account", action="store", help="Account name", required=True)
 
     def _operations(self) -> dict[str, "OperationDict"]:
         return {
@@ -120,7 +121,7 @@ class Attribute(Account):
         return {}
 
     def namespace(self, subparser):
-        subparser.add_argument("-a", "--account", help="Account name")
+        subparser.add_argument("-a", "--account", dest="account", help="Account name")
         subparser.add_argument("--key", dest="key", action="store", help="Attribute key")
         subparser.add_argument("--value", dest="value", action="store", help="Attribute value")
 
@@ -153,7 +154,7 @@ class Limit(Account):
         parser.add_argument("-a", "--account", dest="account", help="Account name", required=True)
         parser.add_argument("--rses", "--rse-exp", dest='rse', action="store", help="RSE expression")
         parser.add_argument("--bytes", action="store", help='Value can be specified in bytes ("10000"), with a storage unit ("10GB"), or "infinity"')
-        parser.add_argument("--locality", nargs="?", default="local", choices=["local", "global"], help="Global or local limit scope")
+        parser.add_argument("--locality", nargs="?", default="local", choices={"local", "global"}, help="Global or local limit scope")
         parser.add_argument("--human", default=True, help=SUPPRESS)
 
     def _operations(self) -> dict[str, "OperationDict"]:
@@ -186,10 +187,10 @@ class Identity(Account):
 
     def namespace(self, parser: "ArgumentParser") -> None:
         parser.add_argument("--account", dest="account", action="store", help="Account name", required=True)
-        parser.add_argument("--type", dest="authtype", action="store", choices=["X509", "GSS", "USERPASS", "SSH", "SAML", "OIDC"], help="Authentication type")
-        parser.add_argument("--id", dest="identity", action="store", help="Identity as a DNs for X509 IDs.")
+        parser.add_argument("--type", dest="authtype", action="store", choices={"X509", "GSS", "USERPASS", "SSH", "SAML", "OIDC"}, help="Authentication type")
+        parser.add_argument("--id", dest="identity", action="store", help="Identity as a DNs for X509 IDs")
         parser.add_argument("--email", dest="email", action="store", help="Email address associated with the identity")
-        parser.add_argument("--password", dest="password", action="store", help="Password if authtype is USERPASS")
+        parser.add_argument("--password", dest="password", action="store", help="Password if type is USERPASS")
         parser.add_argument("--human", default=True, help=SUPPRESS)
 
     def _operations(self) -> dict[str, "OperationDict"]:

{rucio_clients-36.1.0 → rucio_clients-36.3.0}/lib/rucio/client/commands/bin_legacy/rucio_admin.py

@@ -71,7 +71,6 @@ def get_scope(did, client):
         scopes = client.list_scopes()
         scope, name = extract_scope(did, scopes)
         return scope, name
-    return None, did
 
 
 @exception_handler
@@ -82,7 +81,7 @@ def add_account(args, client, logger, console, spinner):
     Adds a new account. Specify metadata fields as arguments.
 
     """
-    client.add_account(account=args.account, type_=args.accounttype, email=args.accountemail)
+    client.add_account(account=args.account, type_=args.account_type, email=args.email)
     print('Added new account: %s' % args.account)
     return SUCCESS
 
@@ -95,8 +94,8 @@ def delete_account(args, client, logger, console, spinner):
     Delete account.
 
     """
-    client.delete_account(args.acnt)
-    print('Deleted account: %s' % args.acnt)
+    client.delete_account(args.account)
+    print('Deleted account: %s' % args.account)
     return SUCCESS
 
 
@@ -418,7 +417,6 @@ def info_rse(args, client, logger, console, spinner):
     if cli_config == 'rich':
         table = generate_table(table_data, row_styles=['none'], col_alignments=['left', 'left'])
         output.append(table)
-        table_data = []
     else:
         print('Protocols:')
         print('==========')
@@ -430,6 +428,7 @@ def info_rse(args, client, logger, console, spinner):
         else:
             print('  ' + protocol['scheme'])
 
+        table_data = []
         for item in sorted(protocol):
             if cli_config == 'rich':
                 if item == 'domains':
@@ -447,10 +446,11 @@ def info_rse(args, client, logger, console, spinner):
                 else:
                     print('    ' + item + ': ' + str(protocol[item]))
 
-    if cli_config == 'rich':
-        table = generate_table(table_data, col_alignments=['left', 'left'], row_styles=['none'])
-        output.append(Padding.indent(table, 2))
+        if cli_config == 'rich':
+            table = generate_table(table_data, col_alignments=['left', 'left'], row_styles=['none'])
+            output.append(Padding.indent(table, 2))
 
+    if cli_config == 'rich':
         header = ['SOURCE', 'USED', 'FILES', 'FREE', 'TOTAL', 'UPDATED AT']
         key2id = {header[i].lower().replace(' ', '_'): i for i in range(len(header))}
         table_data = []
@@ -1523,8 +1523,8 @@ def get_parser():
                                                              '\n')
     add_account_parser.set_defaults(which='add_account')
     add_account_parser.add_argument('account', action='store', help='Account name')
-    add_account_parser.add_argument('--type', dest='accounttype', default='USER', help='Account Type (USER, GROUP, SERVICE)')
-    add_account_parser.add_argument('--email', dest='accountemail', action='store',
+    add_account_parser.add_argument('--type', dest='account_type', default='USER', help='Account Type (USER, GROUP, SERVICE)')
+    add_account_parser.add_argument('--email', dest='email', action='store',
                                     help='Email address associated with the account')
 
     # The disable_account command
@@ -1539,7 +1539,7 @@ def get_parser():
                                                                 '    Deleted account: jdoe-sister\n'
                                                                 '\n')
     delete_account_parser.set_defaults(which='delete_account')
-    delete_account_parser.add_argument('acnt', action='store', help='Account name')
+    delete_account_parser.add_argument('account', action='store', help='Account name')
 
     # The info_account command
     info_account_parser = account_subparser.add_parser('info',

{rucio_clients-36.1.0 → rucio_clients-36.3.0}/lib/rucio/client/commands/rse.py

@@ -62,7 +62,7 @@ class RSE(CommandBase):
     def usage_example(self) -> list[str]:
         return [
             "$ rucio rse list # Show all current RSEs, can also access with",
-            "$ rucio rse list --rses 'deterministic=True' # Show all RSEs that match the RSE Expression 'deterministic=True'",
+            "$ rucio rse list --rses 'deterministic=True'  # Show all RSEs that match the RSE Expression 'deterministic=True'",
             "$ rucio rse remove --rse RemoveThisRSE  # Disable an RSE by name",
             "$ rucio rse add --rse CreateANewRSE  # add a new RSE named CreateANewRSE",
             "$ rucio rse update --rse rse123456 --setting deterministic --value False  # Make an RSE Non-Deterministic",
@@ -125,8 +125,8 @@ class Attribute(RSE):
     def usage_example(self) -> list[str]:
         return [
             "$ rucio rse attribute list --rse ThisRSE  # Show all the attributes for a given RSE",
-            "$ rucio rse attribute list --rse ThisRSE --key name # Show all the attribute 'name' for a given RSE",
-            "$ rucio rse attribute add --rse ThisRSE --key given-attribute --value updated # Set the attribute 'given-attribute' to 'updated' for an RSE",
+            "$ rucio rse attribute list --rse ThisRSE --key name  # Show all the attribute 'name' for a given RSE",
+            "$ rucio rse attribute add --rse ThisRSE --key given-attribute --value updated  # Set the attribute 'given-attribute' to 'updated' for an RSE",
         ]
 
     def add(self):
@@ -148,10 +148,15 @@ class Distance(RSE):
 
     def _operations(self) -> dict[str, "OperationDict"]:
         return {
-            "list": {"call": self.list_, "docs": "Show distances between RSEs"},
-            "add": {"call": self.add, "docs": "Add or update a distance between RSEs"},
-            "remove": {"call": self.remove, "docs": "Delete the distance between a pair of RSEs. The mandatory parameters are source and destination"},
-            "set": {"call": self.set_, "docs": "Update the distance between a pair of RSE that already have a distance between them"},
+            "list": {"call": self.list_, "docs": "Show distances between RSEs",
+                     "namespace": self.list_namespace},
+            "add": {"call": self.add, "docs": "Add a distance between RSEs", "namespace": self.add_namespace},
+            "remove": {"call": self.remove,
+                       "docs": "Delete the distance between a pair of RSEs",
+                       "namespace": self.remove_namespace},
+            "set": {"call": self.set_,
+                    "docs": "Update the distance between a pair of RSE that already have a distance between them",
+                    "namespace": self.set_namespace},
         }
 
     def usage_example(self) -> list[str]:
@@ -162,11 +167,20 @@ class Distance(RSE):
             "$ rucio rse distance set --source rse1 --destination rse2 --distance 20  # Update an existing distance",
         ]
 
-    def namespace(self, parser: "ArgumentParser") -> None:
-        parser.add_argument("--source", dest="source", action="store", help="Source RSE name")
-        parser.add_argument("--destination", dest="destination", action="store", help="Destination RSE name")
+    def list_namespace(self, parser: "ArgumentParser") -> None:
+        parser.add_argument("--source", dest="source", help="Source RSE name")
+        parser.add_argument("--destination", dest="destination", help="Destination RSE name")
+
+    def remove_namespace(self, parser: "ArgumentParser") -> None:
+        self.list_namespace(parser)
+
+    def add_namespace(self, parser: "ArgumentParser") -> None:
+        self.list_namespace(parser)
         parser.add_argument("--distance", dest="distance", type=int, help="Distance between RSEs")
 
+    def set_namespace(self, parser: "ArgumentParser") -> None:
+        self.add_namespace(parser)
+
     def list_(self):
         get_distance_rses(self.args, self.client, self.logger, self.console, self.spinner)
 
@@ -258,7 +272,7 @@ class QOS(RSE):
         return [
             "$ rucio rse qospolicy list --rse JDOE_DATADISK  # List QoS Policy for a given RSE",
             "$ rucio rse qospolicy add --rse JDOE_DATADISK --policy SLOW_BUT_CHEAP  # Add a SLOW_BUT_CHEAP policy to the JDOE_DATADISK RSE",
-            "$ rucio rse qospolicy remove --rse  JDOE_DATADISK --policy SLOW_BUT_CHEAP  # Remove the same policy",
+            "$ rucio rse qospolicy remove --rse JDOE_DATADISK --policy SLOW_BUT_CHEAP  # Remove the same policy",
         ]
 
     def add(self):

{rucio_clients-36.1.0 → rucio_clients-36.3.0}/lib/rucio/client/commands/utils.py

@@ -51,6 +51,9 @@ if TYPE_CHECKING:
         docs: NotRequired[str]
         namespace: NotRequired[Callable]
 
+SUCCESS = 0
+FAILURE = 1
+
 
 def exception_handler(function):
     verbosity = ("-v" in sys.argv) or ("--verbose" in sys.argv)
@@ -58,8 +61,6 @@ def exception_handler(function):
 
     @wraps(function)
     def new_funct(*args, **kwargs):
-        SUCCESS = 0
-        FAILURE = 1
         try:
             return function(*args, **kwargs)
         except NotImplementedError as error:

{rucio_clients-36.1.0 → rucio_clients-36.3.0}/lib/rucio/client/downloadclient.py

@@ -1675,8 +1675,8 @@ class DownloadClient:
         num_successful = 0
         num_failed = 0
         for item in output_items:
-            clientState = item.get('clientState', FileDownloadState.FAILED)
-            if clientState in success_states:
+            client_state = item.get('clientState', FileDownloadState.FAILED)
+            if client_state in success_states:
                 num_successful += 1
             else:
                 num_failed += 1

{rucio_clients-36.1.0 → rucio_clients-36.3.0}/lib/rucio/common/checksum.py

@@ -137,8 +137,8 @@ def crc32(file: "FileDescriptorOrPath") -> str:
     :returns: string of 32 hexadecimal digits
     """
     prev = 0
-    for eachLine in open(file, "rb"):
-        prev = zlib.crc32(eachLine, prev)
+    for each_line in open(file, "rb"):
+        prev = zlib.crc32(each_line, prev)
     return "%X" % (prev & 0xFFFFFFFF)
 
 

{rucio_clients-36.1.0 → rucio_clients-36.3.0}/lib/rucio/common/config.py

@@ -17,10 +17,11 @@
 import configparser
 import json
 import os
+from functools import cache
 from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union, overload
 
 from rucio.common import exception
-from rucio.common.exception import ConfigNotFound, DatabaseException
+from rucio.common.exception import ConfigLoadingError, ConfigNotFound, DatabaseException
 
 _T = TypeVar('_T')
 _U = TypeVar('_U')
@@ -30,6 +31,9 @@ if TYPE_CHECKING:
 
     from sqlalchemy.orm import Session
 
+LEGACY_SECTION_NAME = {}
+LEGACY_OPTION_NAME = {}
+
 
 def convert_to_any_type(value: str) -> Union[bool, int, float, str]:
     if value.lower() in ['true', 'yes', 'on']:
@@ -224,8 +228,6 @@ def get_legacy_config(section: str, option: str):
     :param option: The option of the new config.
     :returns: The string value of the legacy option if one is found, None otherwise.
     """
-    LEGACY_SECTION_NAME = {}
-    LEGACY_OPTION_NAME = {}
 
     section = LEGACY_SECTION_NAME.get(section, section)
     option = LEGACY_OPTION_NAME.get(option, option)
@@ -656,7 +658,6 @@ def __config_get_table(
     :raises ConfigNotFound
     :raises DatabaseException
     """
-    global __CONFIG
     try:
         from rucio.core.config import get as core_config_get
         return core_config_get(section, option, default=default, session=session, use_cache=use_cache,
@@ -665,7 +666,7 @@ def __config_get_table(
         if raise_exception and default is None:
             raise err
         if clean_cached:
-            __CONFIG = None
+            clean_cached_config()
         return default
 
 
@@ -753,21 +754,15 @@ def get_rse_credentials(path_to_credentials_file: Optional[Union[str, os.PathLik
     return credentials
 
 
-__CONFIG = None
-
-
+@cache
 def get_config() -> configparser.ConfigParser:
     """Factory function for the configuration class. Returns the ConfigParser instance."""
-    global __CONFIG
-    if __CONFIG is None:
-        __CONFIG = Config()
-    return __CONFIG.parser
+    return Config().parser
 
 
 def clean_cached_config() -> None:
     """Deletes the cached config singleton instance."""
-    global __CONFIG
-    __CONFIG = None
+    get_config.cache_clear()
 
 
 class Config:
@@ -790,7 +785,4 @@ class Config:
                     '\n\t' + '\n\t'.join(configs))
 
         if not self.parser.read(self.configfile) == [self.configfile]:
-            raise ConfigNotFound(
-                'Could not load Rucio configuration file. '
-                'Rucio tried loading the following configuration file:'
-                '\n\t' + self.configfile)
+            raise ConfigLoadingError(self.configfile)

{rucio_clients-36.1.0 → rucio_clients-36.3.0}/lib/rucio/common/exception.py

@@ -20,6 +20,8 @@
 
 """
 
+from typing import Optional
+
 from rucio.common.constraints import AUTHORIZED_VALUE_TYPES
 
 
@@ -93,11 +95,12 @@ class ClientParameterMismatch(RucioException):
 
 class ClientProtocolNotSupported(RucioException):
     """
-    RucioException
+    Client protocol not supported
     """
-    def __init__(self, *args):
+
+    def __init__(self, host: str, protocol: str, protocols_allowed: Optional[list[str]] = None, *args):
         super(ClientProtocolNotSupported, self).__init__(*args)
-        self._message = "Client protocol not supported."
+        self._message = f"Client protocol '{protocol}' not supported when connecting to host '{host}'.{' Allowed protocols: ' + ', '.join(protocols_allowed) if protocols_allowed else ''}"
         self.error_code = 6
 
 
@@ -1167,3 +1170,29 @@ class ChecksumCalculationError(RucioException):
         self.filepath = filepath
         self._message = 'An error occurred while calculating the %s checksum of file %s.' % (self.algorithm_name, self.filepath)
         self.error_code = 111
+
+
+class ConfigLoadingError(RucioException):
+    """
+    An error occurred while loading the configuration.
+    """
+    def __init__(
+            self,
+            config_file: str,
+            *args,
+            **kwargs
+    ):
+        super(ConfigLoadingError, self).__init__(*args, **kwargs)
+        self._message = 'Could not load Rucio configuration file. Rucio tried loading the following configuration file:\n\t %s' % (config_file)
+        self.error_code = 112
+
+
+class ClientProtocolNotFound(RucioException):
+    """
+    Missing protocol in client configuration (e.g. no http/https in url).
+    """
+
+    def __init__(self, host: str, protocols_allowed: Optional[list[str]] = None, *args):
+        super(ClientProtocolNotFound, self).__init__(*args)
+        self._message = f"Client protocol missing when connecting to host '{host}'.{' Allowed protocols: ' + ', '.join(protocols_allowed) if protocols_allowed else ''}"
+        self.error_code = 113