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

rucio_clients-35.7.0.data/scripts/rucio-admin → rucio/cli/bin_legacy/rucio_admin.py

@@ -1,4 +1,4 @@
-#!python
+#!/usr/bin/env python
 # Copyright European Organization for Nuclear Research (CERN) since 2012
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,46 +15,33 @@
 
 import argparse
 import datetime
-import errno
 import json
-import logging
 import math
 import os
 import signal
 import sys
 import time
-import traceback
-from configparser import NoOptionError, NoSectionError
-from functools import wraps
 from textwrap import dedent
 
+from rich.console import Console
+from rich.padding import Padding
+from rich.status import Status
+from rich.text import Text
+from rich.theme import Theme
+from rich.traceback import install
+from rich.tree import Tree
 from tabulate import tabulate
 
 from rucio import version
-from rucio.client import Client
-from rucio.common.config import config_get
+from rucio.cli.utils import exception_handler, get_client, setup_gfal2_logger, signal_handler
+from rucio.client.richclient import MAX_TRACEBACK_WIDTH, MIN_CONSOLE_WIDTH, CLITheme, generate_table, get_cli_config, get_pager, print_output, setup_rich_logger
 from rucio.common.constants import RseAttr
 from rucio.common.exception import (
-    AccessDenied,
-    AccountNotFound,
-    CannotAuthenticate,
-    ConfigNotFound,
-    DataIdentifierAlreadyExists,
-    DataIdentifierNotFound,
-    Duplicate,
-    DuplicateContent,
-    InputValidationError,
-    InvalidObject,
-    InvalidRSEExpression,
-    ReplicaIsLocked,
     ReplicaNotFound,
-    RSENotFound,
     RSEOperationNotSupported,
-    RuleNotFound,
-    ScopeNotFound,
 )
 from rucio.common.extra import import_extras
-from rucio.common.utils import StoreAndDeprecateWarningAction, chunks, clean_pfns, construct_non_deterministic_pfn, extract_scope, get_bytes_value_from_string, parse_response, render_json, sizefmt
+from rucio.common.utils import StoreAndDeprecateWarningAction, chunks, clean_pfns, construct_non_deterministic_pfn, extract_scope, get_bytes_value_from_string, parse_response, render_json, setup_logger, sizefmt
 from rucio.rse import rsemanager as rsemgr
 
 EXTRA_MODULES = import_extras(['argcomplete'])
@@ -71,170 +58,9 @@ SUCCESS = 0
 FAILURE = 1
 DEFAULT_PORT = 443
 
-logger = logging.getLogger("user")
 
 tablefmt = 'psql'
-
-
-def setup_logger(logger):
-    logger.setLevel(logging.DEBUG)
-    hdlr = logging.StreamHandler()
-
-    def emit_decorator(fcn):
-        def func(*args):
-            formatter = logging.Formatter("%(message)s")
-            hdlr.setFormatter(formatter)
-            return fcn(*args)
-        return func
-    hdlr.emit = emit_decorator(hdlr.emit)
-    logger.addHandler(hdlr)
-
-
-setup_logger(logger)
-
-
-def signal_handler(signal, frame):
-    logger.warning('You pressed Ctrl+C! Exiting gracefully')
-    sys.exit(1)
-
-
-signal.signal(signal.SIGINT, signal_handler)
-
-
-def exception_handler(function):
-    @wraps(function)
-    def new_funct(*args, **kwargs):
-        try:
-            return function(*args, **kwargs)
-        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 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 AccountNotFound as error:
-            logger.error(error)
-            logger.debug('This means that the specified account cannot be found.')
-            return error.error_code
-        except NotImplementedError as error:
-            logger.error(error)
-            logger.debug('This means that the method is not implemented yet.')
-            return FAILURE
-        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 ReplicaIsLocked as error:
-            logger.error(error)
-            logger.error('This means that the replica has a lock and is therefore protected.')
-            return FAILURE
-        except ReplicaNotFound as error:
-            logger.error(error)
-            logger.error('This means that the replica does not exist.')
-            return FAILURE
-        except ConfigNotFound as error:
-            logger.error(error)
-            logger.error('This means that the configuration section you are looking for does not exist.')
-            return FAILURE
-        except ScopeNotFound as error:
-            logger.error(error)
-            logger.error('This means that no scopes were found for the specified account ID.')
-            return FAILURE
-        except InputValidationError as error:
-            logger.error(error)
-            logger.error('This means that the input you provided did not meet all the requirements.')
-            return FAILURE
-        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.error(error)
-            logger.error('Rucio exited with an unexpected/unknown error, please provide the traceback below to the developers.')
-            logger.debug(traceback.format_exc())
-            return FAILURE
-    return new_funct
-
-
-def get_client(args):
-    """
-    Returns a new client object.
-    """
-    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(FAILURE)
-    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}
-    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, vo=args.vo)
-    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(FAILURE)
-    return client
+cli_config = get_cli_config()
 
 
 def get_scope(did, client):
@@ -245,135 +71,145 @@ def get_scope(did, client):
         scopes = client.list_scopes()
         scope, name = extract_scope(did, scopes)
         return scope, name
-    return None, did
 
 
 @exception_handler
-def add_account(args):
+def add_account(args, client, logger, console, spinner):
     """
     %(prog)s add [options] <field1=value1 field2=value2 ...>
 
     Adds a new account. Specify metadata fields as arguments.
 
     """
-    client = get_client(args)
-    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
 
 
 @exception_handler
-def delete_account(args):
+def delete_account(args, client, logger, console, spinner):
     """
     %(prog)s disable [options] <field1=value1 field2=value2 ...>
 
     Delete account.
 
     """
-    client = get_client(args)
-    client.delete_account(args.acnt)
-    print('Deleted account: %s' % args.acnt)
+    client.delete_account(args.account)
+    print('Deleted account: %s' % args.account)
     return SUCCESS
 
 
 @exception_handler
-def update_account(args):
+def update_account(args, client, logger, console, spinner):
     """
     %(prog)s update [options] <field1=value1 field2=value2 ...>
 
     Update an account.
 
     """
-    client = get_client(args)
     client.update_account(account=args.account, key=args.key, value=args.value)
     print('%s of account %s changed to %s' % (args.key, args.account, args.value))
     return SUCCESS
 
 
 @exception_handler
-def ban_account(args):
+def ban_account(args, client, logger, console, spinner):
     """
     %(prog)s ban [options] <field1=value1 field2=value2 ...>
 
     Ban an account.
 
     """
-    client = get_client(args)
     client.update_account(account=args.account, key='status', value='SUSPENDED')
     print('Account %s banned' % args.account)
     return SUCCESS
 
 
 @exception_handler
-def unban_account(args):
+def unban_account(args, client, logger, console, spinner):
     """
     %(prog)s unban [options] <field1=value1 field2=value2 ...>
 
     Unban a banned account.
 
     """
-    client = get_client(args)
     client.update_account(account=args.account, key='status', value='ACTIVE')
     print('Account %s unbanned' % args.account)
     return SUCCESS
 
 
 @exception_handler
-def list_accounts(args):
+def list_accounts(args, client, logger, console, spinner):
     """
     %(prog)s list [options] <field1=value1 field2=value2 ...>
 
     List accounts.
 
     """
-    client = get_client(args)
     filters = {}
     if args.filters:
         for key, value in [(_.split('=')[0], _.split('=')[1]) for _ in args.filters.split(',')]:
             filters[key] = value
     accounts = client.list_accounts(identity=args.identity, account_type=args.account_type, filters=filters)
-    for account in accounts:
-        print(account['account'])
+    if args.csv:
+        print(*(account['account'] for account in accounts), sep=',')
+    elif cli_config == 'rich':
+        table = generate_table([[account['account']] for account in accounts], headers=['ACCOUNT'], col_alignments=['left'])
+        spinner.stop()
+        print_output(table, console=console, no_pager=args.no_pager)
+    else:
+        for account in accounts:
+            print(account['account'])
     return SUCCESS
 
 
 @exception_handler
-def info_account(args):
+def info_account(args, client, logger, console, spinner):
     """
     %(prog)s show [options] <field1=value1 field2=value2 ...>
 
     Show extended information of a given account
 
     """
-    client = get_client(args)
     info = client.get_account(account=args.account)
-    for k in info:
-        print(k.ljust(10) + ' : ' + str(info[k]))
+    if cli_config == 'rich':
+        keyword_style = {**CLITheme.ACCOUNT_STATUS, **CLITheme.ACCOUNT_TYPE}
+        table_data = [(k, Text(str(v), style=keyword_style.get(str(v), 'default'))) for k, v in sorted(info.items())]
+        table = generate_table(table_data, row_styles=['none'], col_alignments=['left', 'left'])
+        print_output(table, console=console, no_pager=args.no_pager)
+    else:
+        for k in info:
+            print(k.ljust(10) + ' : ' + str(info[k]))
     return SUCCESS
 
 
 @exception_handler
-def list_identities(args):
+def list_identities(args, client, logger, console, spinner):
     """
     %(prog)s list-identities [options] <field1=value1 field2=value2 ...>
 
     List all identities on an account.
     """
-    client = get_client(args)
+    table_data = []
     identities = client.list_identities(account=args.account)
     for identity in identities:
-        print('Identity: %(identity)s,\ttype: %(type)s' % identity)
+        if cli_config == 'rich':
+            table_data.append([identity['identity'], identity['type']])
+        else:
+            print('Identity: %(identity)s,\ttype: %(type)s' % identity)
+    if cli_config == 'rich':
+        table = generate_table(table_data, headers=['IDENTITY', 'TYPE'], col_alignments=['left', 'left'])
+        print_output(table, console=console, no_pager=args.no_pager)
     return SUCCESS
 
 
 @exception_handler
-def set_limits(args):
+def set_limits(args, client, logger, console, spinner):
     """
     %(prog)s set [options] <field1=value1 field2=value2 ...>
 
     Set account limit for an account and rse.
     """
-    client = get_client(args)
     locality = args.locality.lower()
     byte_limit = None
     limit_input = args.bytes.lower()
@@ -395,14 +231,13 @@ def set_limits(args):
 
 
 @exception_handler
-def get_limits(args):
+def get_limits(args, client, logger, console, spinner):
     """
     %(prog)s get-limits [options] <field1=value1 field2=value2 ...>
 
     Grant an identity access to an account.
 
     """
-    client = get_client(args)
     locality = args.locality.lower()
     limits = client.get_account_limits(account=args.account, rse_expression=args.rse, locality=locality)
     for rse in limits:
@@ -411,27 +246,25 @@ def get_limits(args):
 
 
 @exception_handler
-def delete_limits(args):
+def delete_limits(args, client, logger, console, spinner):
     """
     %(prog)s delete [options] <field1=value1 field2=value2 ...>
 
     Delete account limit for an account and rse.
     """
-    client = get_client(args)
     client.delete_account_limit(account=args.account, rse=args.rse, locality=args.locality)
     print('Deleted account limit for account %s and RSE %s' % (args.account, args.rse))
     return SUCCESS
 
 
 @exception_handler
-def identity_add(args):
+def identity_add(args, client, logger, console, spinner):
     """
     %(prog)s del [options] <field1=value1 field2=value2 ...>
 
     Grant an identity access to an account.
 
     """
-    client = get_client(args)
     if args.email == "":
         logger.error('Error: --email argument can\'t be an empty string. Failed to grant an identity access to an account')
         return FAILURE
@@ -446,63 +279,71 @@ def identity_add(args):
 
 
 @exception_handler
-def identity_delete(args):
+def identity_delete(args, client, logger, console, spinner):
     """
     %(prog)s delete [options] <field1=value1 field2=value2 ...>
 
     Revoke an identity's access to an account.
 
     """
-    client = get_client(args)
     client.del_identity(args.account, args.identity, authtype=args.authtype)
     print('Deleted identity: %s' % args.identity)
     return SUCCESS
 
 
 @exception_handler
-def add_rse(args):
+def add_rse(args, client, logger, console, spinner):
     """
     %(prog)s add [options] <field1=value1 field2=value2 ...>
 
     Adds a new RSE. Specify metadata fields as arguments.
 
     """
-    client = get_client(args)
     client.add_rse(args.rse, deterministic=not args.non_deterministic)
     print('Added new %sdeterministic RSE: %s' % ('non-' if args.non_deterministic else '', args.rse))
     return SUCCESS
 
 
 @exception_handler
-def disable_rse(args):
+def disable_rse(args, client, logger, console, spinner):
     """
     %(prog)s del [options] <field1=value1 field2=value2 ...>
 
     Disable RSE.
 
     """
-    client = get_client(args)
     client.delete_rse(args.rse)
     return SUCCESS
 
 
 @exception_handler
-def list_rses(args):
+def list_rses(args, client, logger, console, spinner):
     """
     %(prog)s list [options] <field1=value1 field2=value2 ...>
 
     List RSEs.
 
     """
-    client = get_client(args)
+    if cli_config == 'rich':
+        spinner.update(status='Fetching RSEs')
+        spinner.start()
+
     rses = client.list_rses()
-    for rse in rses:
-        print('%(rse)s' % rse)
+    if args.csv:
+        print(*(rse['rse'] for rse in rses), sep='\n')
+    elif cli_config == 'rich':
+        table_data = [[rse['rse']] for rse in sorted(rses, key=lambda elem: elem['rse'])]
+        table = generate_table(table_data, headers=['RSE'], col_alignments=['left'])
+        spinner.stop()
+        print_output(table, console=console, no_pager=args.no_pager)
+    else:
+        for rse in rses:
+            print(rse['rse'])
     return SUCCESS
 
 
 @exception_handler
-def update_rse(args):
+def update_rse(args, client, logger, console, spinner):
     """
     %(prog)s update [options] <field1=value1 field2=value2 ...>
 
@@ -514,7 +355,6 @@ def update_rse(args):
     Use '', 'None' or 'null' to wipe the value of following RSE settings:
       qos_class
     """
-    client = get_client(args)
     if args.value in ['true', 'True', 'TRUE', '1']:
         args.value = True
     if args.value in ['false', 'False', 'FALSE', '0']:
@@ -530,102 +370,192 @@ def update_rse(args):
 
 
 @exception_handler
-def info_rse(args):
+def info_rse(args, client, logger, console, spinner):
     """
     %(prog)s info [options] <field1=value1 field2=value2 ...>
 
     Show extended information of a given RSE
 
     """
-    client = get_client(args)
+    if cli_config == 'rich':
+        spinner.update(status='Fetching RSE info')
+        spinner.start()
+
     rseinfo = client.get_rse(rse=args.rse)
     attributes = client.list_rse_attributes(rse=args.rse)
     usage = client.get_rse_usage(rse=args.rse)
     rse_limits = client.get_rse_limits(args.rse)
-    print('Settings:')
-    print('=========')
-    for key in sorted(rseinfo):
-        if key != 'protocols':
-            print('  ' + key + ': ' + str(rseinfo[key]))
-    print('Attributes:')
-    print('===========')
-    for attribute in sorted(attributes):
-        print('  ' + attribute + ': ' + str(attributes[attribute]))
-    print('Protocols:')
-    print('==========')
-    for protocol in sorted(rseinfo['protocols'], key=lambda x: x['scheme']):
-        print('  ' + protocol['scheme'])
+
+    if cli_config == 'rich':
+        keyword_styles = {**CLITheme.BOOLEAN, **CLITheme.RSE_TYPE}
+        output = []
+        table_data = []
+    else:
+        print('Settings:')
+        print('=========')
+    for i, key in enumerate(sorted(rseinfo)):
+        if cli_config == 'rich':
+            if i == 0:
+                output.append('[b]Settings:[/]')
+            if key != 'protocols':
+                table_data.append([key, Text(str(rseinfo[key]), style=keyword_styles.get(str(rseinfo[key]), 'default'))])
+        else:
+            if key != 'protocols':
+                print('  ' + key + ': ' + str(rseinfo[key]))
+
+    if cli_config == 'rich':
+        table = generate_table(table_data, row_styles=['none'], col_alignments=['left', 'left'])
+        output.append(table)
+        table_data = []
+    else:
+        print('Attributes:')
+        print('===========')
+    for i, attribute in enumerate(sorted(attributes)):
+        if cli_config == 'rich':
+            if i == 0:
+                output.append('\n[b]Attributes:[/]')
+            table_data.append([attribute, Text(str(attributes[attribute]), style=keyword_styles.get(str(attributes[attribute]), 'default'))])
+        else:
+            print('  ' + attribute + ': ' + str(attributes[attribute]))
+
+    if cli_config == 'rich':
+        table = generate_table(table_data, row_styles=['none'], col_alignments=['left', 'left'])
+        output.append(table)
+    else:
+        print('Protocols:')
+        print('==========')
+    for i, protocol in enumerate(sorted(rseinfo['protocols'], key=lambda x: x['scheme'])):
+        if cli_config == 'rich':
+            if i == 0:
+                output.append('\n[b]Protocols:[/]')
+            output.append(Padding.indent(Text(protocol['scheme'], style=CLITheme.SUBHEADER_HIGHLIGHT), 2))
+        else:
+            print('  ' + protocol['scheme'])
+
+        table_data = []
         for item in sorted(protocol):
-            if item == 'domains':
-                print('    ' + item + ': \'' + json.dumps(protocol[item]) + '\'')
+            if cli_config == 'rich':
+                if item == 'domains':
+                    tree = Tree('')
+                    for domain, values in protocol[item].items():
+                        branch = tree.add(f'[{CLITheme.JSON_STR}]{domain}')
+                        for k, v in values.items():
+                            branch.add(f'[{CLITheme.JSON_STR}]{k}[/]: [{CLITheme.JSON_NUM}]{v}[/]')
+                    table_data.append([item, tree])
+                else:
+                    table_data.append([item, Text(str(protocol[item]), style=keyword_styles.get(protocol[item], 'default'))])
             else:
-                print('    ' + item + ': ' + str(protocol[item]))
-    print('Usage:')
-    print('======')
-    for elem in sorted(usage, key=lambda x: x['source']):
-        print('  ' + elem['source'])
-        for item in sorted(elem):
-            print('    ' + item + ': ' + str(elem[item]))
-    print('RSE limits:')
-    print('===========')
-    for limit in rse_limits:
-        print('  ' + limit + ': ' + str(rse_limits[limit]) + ' B')
+                if item == 'domains':
+                    print('    ' + item + ': \'' + json.dumps(protocol[item]) + '\'')
+                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':
+        header = ['SOURCE', 'USED', 'FILES', 'FREE', 'TOTAL', 'UPDATED AT']
+        key2id = {header[i].lower().replace(' ', '_'): i for i in range(len(header))}
+        table_data = []
+    else:
+        print('Usage:')
+        print('======')
+    for i, elem in enumerate(sorted(usage, key=lambda x: x['source'])):
+        if cli_config == 'rich':
+            if i == 0:
+                output.append('\n[b]Usage:[/]')
+
+            row = [''] * len(header)
+            row[0] = elem['source']
+            for item in sorted(elem):
+                if item in ['used', 'free', 'total']:
+                    row[key2id[item]] = sizefmt(elem[item], True)
+                elif item != 'source' and item in key2id:
+                    row[key2id[item]] = str(elem[item])
+            table_data.append(row)
+        else:
+            print('  ' + elem['source'])
+            for item in sorted(elem):
+                print('    ' + item + ': ' + str(elem[item]))
+
+    if cli_config == 'rich':
+        if len(table_data) > 0:
+            usage_table = generate_table(table_data, headers=header, col_alignments=['left', 'right', 'right', 'right', 'right', 'left'])
+            output.append(usage_table)
+        table_data = []
+    else:
+        print('RSE limits:')
+        print('===========')
+    for i, limit in enumerate(rse_limits):
+        if cli_config == 'rich':
+            if i == 0:
+                output.append('\n[b]RSE limits:[/]')
+            table_data.append([limit, str(rse_limits[limit]) + ' B'])
+        else:
+            print('  ' + limit + ': ' + str(rse_limits[limit]) + ' B')
+
+    if cli_config == 'rich':
+        if len(table_data) > 0:
+            table = generate_table(table_data, row_styles=['none'], col_alignments=['left', 'right'])
+            output.append(table)
+        spinner.stop()
+        print_output(*output, console=console, no_pager=args.no_pager)
     return SUCCESS
 
 
 @exception_handler
-def set_attribute_rse(args):
+def set_attribute_rse(args, client, logger, console, spinner):
     """
     %(prog)s set-attribute [options] <field1=value1 field2=value2 ...>
 
     Set RSE attributes.
 
     """
-    client = get_client(args)
     client.add_rse_attribute(rse=args.rse, key=args.key, value=args.value)
     print('Added new RSE attribute for %s: %s-%s ' % (args.rse, args.key, args.value))
     return SUCCESS
 
 
 @exception_handler
-def get_attribute_rse(args):
+def get_attribute_rse(args, client, logger, console, spinner):
     """
     %(prog)s get-attribute [options] <field1=value1 field2=value2 ...>
 
     Get RSE attributes.
 
     """
-    client = get_client(args)
     attributes = client.list_rse_attributes(rse=args.rse)
-    for k in attributes:
-        print(k + ': ' + str(attributes[k]))
-
+    if cli_config == 'rich':
+        table_data = [(k, Text(str(v), style=CLITheme.BOOLEAN.get(str(v), 'default'))) for k, v in sorted(attributes.items())]
+        table = generate_table(table_data, row_styles=['none'], col_alignments=['left', 'left'])
+        print_output(table, console=console, no_pager=args.no_pager)
+    else:
+        for k in attributes:
+            print(k + ': ' + str(attributes[k]))
     return SUCCESS
 
 
 @exception_handler
-def delete_attribute_rse(args):
+def delete_attribute_rse(args, client, logger, console, spinner):
     """
     %(prog)s delete-attribute [options] <field1=value1 field2=value2 ...>
 
     Delete RSE attributes.
 
     """
-    client = get_client(args)
     client.delete_rse_attribute(rse=args.rse, key=args.key)
     print('Deleted RSE attribute for %s: %s-%s ' % (args.rse, args.key, args.value))
     return SUCCESS
 
 
 @exception_handler
-def add_distance_rses(args):
+def add_distance_rses(args, client, logger, console, spinner):
     """
     %(prog)s add-distance [options] SOURCE_RSE DEST_RSE
 
     Set the distance between two RSEs.
     """
-    client = get_client(args)
     params = {'distance': args.distance}
     client.add_distance(args.source, args.destination, params)
     print('Set distance from %s to %s to %d' % (args.source, args.destination, args.distance))
@@ -633,29 +563,35 @@ def add_distance_rses(args):
 
 
 @exception_handler
-def get_distance_rses(args):
+def get_distance_rses(args, client, logger, console, spinner):
     """
     %(prog)s get-distance SOURCE_RSE DEST_RSE
 
     Retrieve the existing distance information between two RSEs.
     """
-    client = get_client(args)
     distance_info = client.get_distance(args.source, args.destination)
-    if distance_info:
-        print('Distance information from %s to %s: distance=%d' % (args.source, args.destination, distance_info[0]['distance']))
+    if cli_config == 'rich':
+        if distance_info:
+            table = generate_table([[args.source, args.destination, str(distance_info[0]['distance'])]], headers=['SOURCE', 'DESTINATION', 'DISTANCE'],
+                                   col_alignments=['left', 'left', 'right'])
+            print_output(table, console=console, no_pager=args.no_pager)
+        else:
+            print(f"No distance set from {args.source} to {args.destination}")
     else:
-        print("No distance set from %s to %s" % (args.source, args.destination))
+        if distance_info:
+            print('Distance information from %s to %s: distance=%d' % (args.source, args.destination, distance_info[0]['distance']))
+        else:
+            print("No distance set from %s to %s" % (args.source, args.destination))
     return SUCCESS
 
 
 @exception_handler
-def update_distance_rses(args):
+def update_distance_rses(args, client, logger, console, spinner):
     """
     %(prog)s update-distance [options] SOURCE_RSE DEST_RSE
 
     Update the existing distance entry between two RSEs.
     """
-    client = get_client(args)
     params = {}
     if args.distance is not None:
         params['distance'] = args.distance
@@ -669,26 +605,24 @@ def update_distance_rses(args):
 
 
 @exception_handler
-def delete_distance_rses(args):
+def delete_distance_rses(args, client, logger, console, spinner):
     """
     %(prog)s delete-distance [options] SOURCE_RSE DEST_RSE
 
     Update the existing distance entry between two RSEs.
     """
-    client = get_client(args)
     client.delete_distance(args.source, args.destination)
     print('Deleted distance information from %s to %s.' % (args.source, args.destination))
     return SUCCESS
 
 
 @exception_handler
-def add_protocol_rse(args):
+def add_protocol_rse(args, client, logger, console, spinner):
     """
     %(prog)s add-protocol-rse [options] <rse>
 
     Add a new protocol handler for an RSE
     """
-    client = get_client(args)
     proto = {'hostname': args.hostname,
              'scheme': args.scheme,
              'port': args.port,
@@ -714,13 +648,12 @@ def add_protocol_rse(args):
 
 
 @exception_handler
-def del_protocol_rse(args):
+def del_protocol_rse(args, client, logger, console, spinner):
     """
     %(prog)s delete-protocol-rse [options] <rse>
 
     Remove a protocol handler for a RSE
     """
-    client = get_client(args)
     kwargs = {}
     if args.port:
         kwargs['port'] = args.port
@@ -730,53 +663,59 @@ def del_protocol_rse(args):
 
 
 @exception_handler
-def add_qos_policy(args):
+def add_qos_policy(args, client, logger, console, spinner):
     """
     %(prog)s add-qos-policy <rse> <qos_policy>
 
     Add a QoS policy to an RSE.
     """
-    client = get_client(args)
     client.add_qos_policy(args.rse, args.qos_policy)
     print('Added QoS policy to RSE %s: %s' % (args.rse, args.qos_policy))
     return SUCCESS
 
 
 @exception_handler
-def delete_qos_policy(args):
+def delete_qos_policy(args, client, logger, console, spinner):
     """
     %(prog)s delete-qos-policy <rse> <qos_policy>
 
     Delete a QoS policy from an RSE.
     """
-    client = get_client(args)
     client.delete_qos_policy(args.rse, args.qos_policy)
     print('Deleted QoS policy from RSE %s: %s' % (args.rse, args.qos_policy))
     return SUCCESS
 
 
 @exception_handler
-def list_qos_policies(args):
+def list_qos_policies(args, client, logger, console, spinner):
     """
     %(prog)s list-qos-policies <rse>
 
     List all QoS policies of an RSE.
     """
-    client = get_client(args)
+    if cli_config == 'rich':
+        spinner.update(status='Fetching QoS policies')
+        spinner.start()
+
     qos_policies = client.list_qos_policies(args.rse)
-    for qos_policy in sorted(qos_policies):
-        print(qos_policy)
+    if cli_config == 'rich':
+        qos_policies = [[qos_policy] for qos_policy in sorted(qos_policies)]
+        table = generate_table(qos_policies, headers=['QOS POLICY'], col_alignments=['left'])
+        spinner.stop()
+        print_output(table, console=console, no_pager=args.no_pager)
+    else:
+        for qos_policy in sorted(qos_policies):
+            print(qos_policy)
     return SUCCESS
 
 
 @exception_handler
-def set_limit_rse(args):
+def set_limit_rse(args, client, logger, console, spinner):
     """
     %(prog)s set-limit <rse> <name> <value>
 
     Set the RSE limit given the rse name and the name and value of the limit
     """
-    client = get_client(args)
     try:
         args.value = int(args.value)
         if client.set_rse_limits(args.rse, args.name, args.value):
@@ -788,13 +727,12 @@ def set_limit_rse(args):
 
 
 @exception_handler
-def delete_limit_rse(args):
+def delete_limit_rse(args, client, logger, console, spinner):
     """
     %(prog)s delete-limit <rse> <name>
 
     Delete the RSE limit given the rse name and the name of the limit
     """
-    client = get_client(args)
     limits = client.get_rse_limits(args.rse)
     if args.name not in limits.keys():
         logger.error('Limit %s not defined in RSE %s' % (args.name, args.rse))
@@ -806,46 +744,53 @@ def delete_limit_rse(args):
 
 
 @exception_handler
-def add_scope(args):
+def add_scope(args, client, logger, console, spinner):
     """
     %(prog)s add [options] <field1=value1 field2=value2 ...>
 
     Add scope.
 
     """
-    client = get_client(args)
     client.add_scope(account=args.account, scope=args.scope)
     print('Added new scope to account: %s-%s' % (args.scope, args.account))
     return SUCCESS
 
 
 @exception_handler
-def list_scopes(args):
+def list_scopes(args, client, logger, console, spinner):
     """
     %(prog)s list [options] <field1=value1 field2=value2 ...>
 
     List scopes.
 
     """
-    client = get_client(args)
+    if cli_config == 'rich':
+        spinner.update(status='Fetching scopes')
+        spinner.start()
+
     if args.account:
         scopes = client.list_scopes_for_account(args.account)
     else:
         scopes = client.list_scopes()
-    for scope in scopes:
-        if 'mock' not in scope:
-            print(scope)
+    if cli_config == 'rich':
+        scopes = [[scope] for scope in sorted(scopes) if 'mock' not in scope]
+        table = generate_table(scopes, headers=['SCOPE'], col_alignments=['left'])
+        spinner.stop()
+        print_output(table, console=console, no_pager=args.no_pager)
+    else:
+        for scope in scopes:
+            if 'mock' not in scope:
+                print(scope)
     return SUCCESS
 
 
 @exception_handler
-def get_config(args):
+def get_config(args, client, logger, console, spinner):
     """
     %(prog)s get [options] <field1=value1 field2=value2 ...>
 
     Get the configuration. Either everything, or matching the given section/option.
     """
-    client = get_client(args)
     res = client.get_config(section=args.section, option=args.option)
     if not isinstance(res, dict):
         print('[%s]\n%s=%s' % (args.section, args.option, str(res)))
@@ -867,26 +812,24 @@ def get_config(args):
 
 
 @exception_handler
-def set_config_option(args):
+def set_config_option(args, client, logger, console, spinner):
     """
     %(prog)s set [options] <field1=value1 field2=value2 ...>
 
     Set the configuration value for a matching section/option. Missing section/option will be created.
     """
-    client = get_client(args)
     client.set_config_option(section=args.section, option=args.option, value=args.value)
     print('Set configuration: %s.%s=%s' % (args.section, args.option, args.value))
     return SUCCESS
 
 
 @exception_handler
-def delete_config_option(args):
+def delete_config_option(args, client, logger, console, spinner):
     """
     %(prog)s delete [options] <field1=value1 field2=value2 ...>
 
     Delete a configuration option from a section
     """
-    client = get_client(args)
     if client.delete_config_option(section=args.section, option=args.option):
         print('Deleted section \'%s\' option \'%s\'' % (args.section, args.option))
     else:
@@ -895,14 +838,13 @@ def delete_config_option(args):
 
 
 @exception_handler
-def add_subscription(args):
+def add_subscription(args, client, logger, console, spinner):
     """
     %(prog)s add [options] name Filter replication_rules
 
     Add subscription.
 
     """
-    client = get_client(args)
     if args.subs_account:
         account = args.subs_account
     elif args.issuer:
@@ -916,39 +858,85 @@ def add_subscription(args):
 
 
 @exception_handler
-def list_subscriptions(args):
+def list_subscriptions(args, client, logger, console, spinner):
     """
     %(prog)s list [options] [name]
 
     List subscriptions.
 
     """
-    client = get_client(args)
     if args.subs_account:
         account = args.subs_account
     elif args.issuer:
         account = args.issuer
     else:
         account = client.account
+
+    if cli_config == 'rich':
+        spinner.update(status='Fetching subscriptions')
+        spinner.start()
+        keyword_styles = {**CLITheme.SUBSCRIPTION_STATE, **CLITheme.BOOLEAN}
+
     subs = client.list_subscriptions(name=args.name, account=account)
     for sub in subs:
+        table_data = []
         if args.long:
-            print('\n'.join('%s: %s' % (str(k), str(v)) for (k, v) in list(sub.items())))
-            print()
+            if cli_config == 'rich':
+                for k, v in sorted(sub.items()):
+                    if k == 'filter':
+                        filter_tree = Tree('')
+                        for filter, values in json.loads(sub['filter']).items():
+                            values_str = ', '.join(values)
+                            filter_tree.add(f'[{CLITheme.JSON_STR}]{filter}[/]: {values_str}')
+                        table_data.append(['filter', filter_tree])
+                    elif k == 'replication_rules':
+                        rule_tree = Tree('')
+                        for i, rule in enumerate(json.loads(sub['replication_rules'])):
+                            branch = rule_tree.add(Text('rule:', style='default'))
+                            for k, v in rule.items():
+                                branch.add(f'[{CLITheme.JSON_STR}]{k}[/]: {v}')
+                        table_data.append(['replication_rules', rule_tree])
+                    else:
+                        table_data.append([str(k), Text(str(v), style=keyword_styles.get(str(v), 'default'))])
+            else:
+                print('\n'.join('%s: %s' % (str(k), str(v)) for (k, v) in list(sub.items())))
+                print()
         else:
-            print("%s: %s %s\n  priority: %s\n  filter: %s\n  rules: %s\n  comments: %s" % (sub['account'], sub['name'], sub['state'], sub['policyid'], sub['filter'], sub['replication_rules'], sub.get('comments', '')))
+            if cli_config == 'rich':
+                table_data.append(['account', sub['account']])
+                table_data.append(['comments', sub.get('comments', '')])
+                filter_tree = Tree('')
+                for filter, values in json.loads(sub['filter']).items():
+                    values_str = ', '.join(values)
+                    filter_tree.add(f'[green]{filter}[/]: {values_str}')
+                table_data.append(['filter', filter_tree])
+                table_data.append(['name', sub['name']])
+                table_data.append(['policyid', str(sub['policyid'])])
+                rule_tree = Tree('')
+                for i, rule in enumerate(json.loads(sub['replication_rules'])):
+                    branch = rule_tree.add(Text('rule:', style='default'))
+                    for k, v in rule.items():
+                        branch.add(f'[{CLITheme.JSON_STR}]{k}[/]: {v}')
+                table_data.append(['replication_rules', rule_tree])
+                table_data.append(['state', Text(str(sub['state']), keyword_styles.get(str(sub['state']), 'default'))])
+            else:
+                print("%s: %s %s\n  priority: %s\n  filter: %s\n  rules: %s\n  comments: %s" % (sub['account'], sub['name'], sub['state'], sub['policyid'], sub['filter'], sub['replication_rules'], sub.get('comments', '')))
+
+        if cli_config == 'rich':
+            table = generate_table(table_data, row_styles=['none'], col_alignments=['left', 'left'])
+            spinner.stop()
+            print_output(table, console=console, no_pager=args.no_pager)
     return SUCCESS
 
 
 @exception_handler
-def update_subscription(args):
+def update_subscription(args, client, logger, console, spinner):
     """
     %(prog)s update [options] name filter replication_rules
 
     Update a subscription.
 
     """
-    client = get_client(args)
     if args.subs_account:
         account = args.subs_account
     elif args.issuer:
@@ -961,14 +949,13 @@ def update_subscription(args):
 
 
 @exception_handler
-def reevaluate_did_for_subscription(args):
+def reevaluate_did_for_subscription(args, client, logger, console, spinner):
     """
     %(prog)s reevaulate [options] dids
 
     Reevaluate a list of DIDs against all active subscriptions.
 
     """
-    client = get_client(args)
     for did in args.dids.split(','):
         scope, name = get_scope(did, client)
         client.set_metadata(scope, name, 'is_new', True)
@@ -976,56 +963,57 @@ def reevaluate_did_for_subscription(args):
 
 
 @exception_handler
-def list_account_attributes(args):
+def list_account_attributes(args, client, logger, console, spinner):
     """
     %(prog)s show [options] <field1=value1 field2=value2 ...>
 
     List the attributes for an account.
 
     """
-    client = get_client(args)
     account = args.account or client.account
     attributes = next(client.list_account_attributes(account))
-    table = []
+    table_data = []
     for attr in attributes:
-        table.append([attr['key'], attr['value']])
-    print(tabulate(table, tablefmt=tablefmt, headers=['Key', 'Value']))
+        table_data.append([attr['key'], attr['value']])
+
+    if cli_config == 'rich':
+        table = generate_table(table_data, headers=['Key', 'Value'], col_alignments=['left', 'left'])
+        print_output(table, console=console, no_pager=args.no_pager)
+    else:
+        print(tabulate(table_data, tablefmt=tablefmt, headers=['Key', 'Value']))
     return SUCCESS
 
 
 @exception_handler
-def add_account_attribute(args):
+def add_account_attribute(args, client, logger, console, spinner):
     """
     %(prog)s show [options] <field1=value1 field2=value2 ...>
 
     Add attribute for an account.
 
     """
-    client = get_client(args)
     client.add_account_attribute(account=args.account, key=args.key, value=args.value)
     return SUCCESS
 
 
 @exception_handler
-def delete_account_attribute(args):
+def delete_account_attribute(args, client, logger, console, spinner):
     """
     %(prog)s show [options] <field1=value1 field2=value2 ...>
 
     Delete attribute for an account.
 
     """
-    client = get_client(args)
     client.delete_account_attribute(account=args.account, key=args.key)
     return SUCCESS
 
 
 @exception_handler
-def quarantine_replicas(args):
+def quarantine_replicas(args, client, logger, console, spinner):
     """
     %(prog)s quarantine --rse <rse> (--paths <file with replica paths>|<path> ...)
     Quarantine replicas
     """
-    client = get_client(args)
     chunk = []
 
     # send requests in chunks
@@ -1049,7 +1037,7 @@ def quarantine_replicas(args):
     return SUCCESS
 
 
-def __declare_bad_file_replicas_by_lfns(args: object) -> object:
+def __declare_bad_file_replicas_by_lfns(args: object, client) -> object:
     """
     Declare a list of bad replicas using RSE name, scope and list of LFNs.
     """
@@ -1059,7 +1047,6 @@ def __declare_bad_file_replicas_by_lfns(args: object) -> object:
     reason = args.reason
     scope = args.scope
     rse = args.rse
-    client = get_client(args)
     replicas = []
 
     # send requests in chunks
@@ -1084,7 +1071,7 @@ def __declare_bad_file_replicas_by_lfns(args: object) -> object:
 
 
 @exception_handler
-def declare_bad_file_replicas(args):
+def declare_bad_file_replicas(args, client, logger, console, spinner):
     """
 
     Declare replicas as bad.
@@ -1092,9 +1079,7 @@ def declare_bad_file_replicas(args):
     """
 
     if args.lfns:
-        return __declare_bad_file_replicas_by_lfns(args)
-
-    client = get_client(args)
+        return __declare_bad_file_replicas_by_lfns(args, client)
 
     if args.inputfile:
         with open(args.inputfile) as infile:
@@ -1175,14 +1160,13 @@ def declare_bad_file_replicas(args):
 
 
 @exception_handler
-def declare_temporary_unavailable_replicas(args):
+def declare_temporary_unavailable_replicas(args, client, logger, console, spinner):
     """
     %(prog)s show [options] <field1=value1 field2=value2 ...>
 
     Declare a list of temporary unavailable replicas.
 
     """
-    client = get_client(args)
     bad_files = []
     if args.inputfile:
         with open(args.inputfile) as infile:
@@ -1218,14 +1202,13 @@ def declare_temporary_unavailable_replicas(args):
 
 
 @exception_handler
-def list_pfns(args):
+def list_pfns(args, client, logger, console, spinner):
     """
     %(prog)s list [options] <field1=value1 field2=value2 ...>
 
     List the possible PFN for a file at a site.
 
     """
-    client = get_client(args)
     dids = args.dids.split(',')
     rse = args.rse
     protocol = args.protocol
@@ -1271,71 +1254,104 @@ def list_pfns(args):
 
 
 @exception_handler
-def import_data(args):
+def import_data(args, client, logger, console, spinner):
     """
     %(prog)s list [options] <field1=value1 field2=value2 ...>
 
     Import data from JSON file to Rucio.
 
     """
-    client = get_client(args)
     import_file_path = args.file_path
     data = None
-    print('Start reading file.')
+    if cli_config == 'rich':
+        spinner.update(status='Reading file')
+        spinner.start()
+
     try:
         with open(import_file_path) as import_file:
             data_string = import_file.read()
             data = parse_response(data_string)
     except ValueError as error:
-        print('There was problem with decoding your file.')
-        print(error)
+        if cli_config == 'rich':
+            spinner.stop()
+            print_output(f'{CLITheme.FAILURE_ICON} There was problem with decoding your file.', console=console, no_pager=True)
+            logger.error(error)
+        else:
+            print('There was problem with decoding your file.')
+            print(error)
         return FAILURE
     except OSError as error:
-        print('There was a problem with reading your file.')
-        print(error)
+        if cli_config == 'rich':
+            spinner.stop()
+            print_output(f'{CLITheme.FAILURE_ICON} There was a problem with reading your file.', console=console, no_pager=True)
+            logger.error(error)
+        else:
+            print('There was a problem with reading your file.')
+            print(error)
         return FAILURE
 
     if data:
         client.import_data(data)
-        print('Data successfully imported.')
+        if cli_config == 'rich':
+            spinner.stop()
+            print_output(f'{CLITheme.SUCCESS_ICON} Data successfully imported.', console=console, no_pager=True)
+        else:
+            print('Data successfully imported.')
         return SUCCESS
     else:
-        print('Nothing to import.')
+        if cli_config == 'rich':
+            spinner.stop()
+            print_output('Nothing to import.', console=console, no_pager=True)
+        else:
+            print('Nothing to import.')
         return FAILURE
 
 
 @exception_handler
-def export_data(args):
+def export_data(args, client, logger, console, spinner):
     """
     %(prog)s list [options] <field1=value1 field2=value2 ...>
 
     Export data from Rucio to JSON file.
 
     """
-    client = get_client(args)
     destination_file_path = args.file_path
-    print('Start querying data.')
+    if cli_config == 'rich':
+        spinner.update(status='Querying data')
+        spinner.start()
+    else:
+        print('Start querying data.')
+
     data = client.export_data()
     try:
         with open(destination_file_path, 'w+') as destination_file:
             destination_file.write(render_json(**data))
-            print('File successfully written.')
-        print('Data successfully exported to %s' % args.file_path)
+            if cli_config != 'rich':
+                print('File successfully written.')
+        if cli_config == 'rich':
+            spinner.stop()
+            print_output(f'{CLITheme.SUCCESS_ICON} Data successfully exported to {args.file_path}', console=console, no_pager=True)
+        else:
+            print('Data successfully exported to %s' % args.file_path)
         return SUCCESS
     except OSError as error:
-        print('There was a problem with reading your file.')
-        print(error)
+        if cli_config == 'rich':
+            spinner.stop()
+            print_output(f'{CLITheme.FAILURE_ICON} There was a problem with reading your file.', console=console, no_pager=True)
+            logger.error(error)
+        else:
+            print('There was a problem with reading your file.')
+            print(error)
         return FAILURE
 
 
 @exception_handler
-def set_tombstone(args):
+def set_tombstone(args, client, logger, console, spinner):
     """
     %(prog)s list [options] <field1=value1 field2=value2 ...>
 
     Set a tombstone on a list of replicas.
     """
-    client = get_client(args)
     dids = args.dids
     rse = args.rse
     dids = [dids] if ',' not in dids else dids.split(',')
@@ -1367,7 +1383,9 @@ def get_parser():
     oparser.add_argument('-a', '--account', dest="issuer", metavar="ACCOUNT", help="Rucio account to use")
     oparser.add_argument('-S', '--auth-strategy', dest="auth_strategy", default=None, help="Authentication strategy (userpass, x509, ssh ...)")
     oparser.add_argument('-T', '--timeout', dest="timeout", type=float, default=None, help="Set all timeout values to SECONDS")
+    oparser.add_argument('--user-agent', '-U', dest="user_agent", default='rucio-clients', action='store', help="Rucio User Agent")
     oparser.add_argument('--vo', dest="vo", metavar="VO", default=None, help="VO to authenticate at. Only used in multi-VO mode.")
+    oparser.add_argument("--no-pager", dest="no_pager", default=False, action='store_true', help=argparse.SUPPRESS)
 
     # Options for the userpass auth_strategy
     oparser.add_argument('-u', '--user', dest='username', default=None, help='username')
@@ -1391,6 +1409,7 @@ def get_parser():
 
     # Options for the x509  auth_strategy
     oparser.add_argument('--certificate', dest='certificate', default=None, help='Client certificate file')
+    oparser.add_argument('--client-key', dest='client_key', default=None, help='Client key for x509 Authentication.')
     oparser.add_argument('--ca-certificate', dest='ca_certificate', default=None, help='CA certificate to verify peer against (SSL)')
 
     # The import export subparser
@@ -1440,6 +1459,7 @@ def get_parser():
     list_account_parser.add_argument('--type', dest='account_type', action='store', help='Account Type (USER, GROUP, SERVICE)')
     list_account_parser.add_argument('--id', dest='identity', action='store', help='Identity (e.g. DN)')
     list_account_parser.add_argument('--filters', dest='filters', action='store', help='Filter arguments in form `key=value,another_key=next_value`')
+    list_account_parser.add_argument("--csv", action='store_true', help='List result as a csv')
     list_account_parser.set_defaults(which='list_accounts')
 
     # The list_account_attributes command
@@ -1508,8 +1528,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
@@ -1524,7 +1544,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',
@@ -1738,6 +1758,7 @@ def get_parser():
                                                       '\n'
                                                       '    $ rucio list-rses --rses \"tier=2&type=DATADISK\"\n'
                                                       '\n')
+    list_rse_parser.add_argument("--csv", action='store_true', help='Output a list of RSEs as a csv')
     list_rse_parser.set_defaults(which='list_rses')
 
     # The add_rse command
@@ -2368,7 +2389,7 @@ def get_parser():
     return oparser
 
 
-if __name__ == '__main__':
+def main():
     oparser = get_parser()
     if EXTRA_MODULES['argcomplete']:
         argcomplete.autocomplete(oparser)
@@ -2382,66 +2403,98 @@ if __name__ == '__main__':
     if not hasattr(args, 'which'):
         oparser.print_help()
         sys.exit(FAILURE)
+    else:
+        commands = {'add_account': add_account,
+                    'list_accounts': list_accounts,
+                    'list_account_attributes': list_account_attributes,
+                    'add_account_attribute': add_account_attribute,
+                    'delete_account_attribute': delete_account_attribute,
+                    'delete_account': delete_account,
+                    'info_account': info_account,
+                    'ban_account': ban_account,
+                    'unban_account': unban_account,
+                    'update_account': update_account,
+                    'get_limits': get_limits,
+                    'set_limits': set_limits,
+                    'delete_limits': delete_limits,
+                    'list_identities': list_identities,
+                    'identity_add': identity_add,
+                    'identity_delete': identity_delete,
+                    'add_rse': add_rse,
+                    'update_rse': update_rse,
+                    'set_attribute_rse': set_attribute_rse,
+                    'get_attribute_rse': get_attribute_rse,
+                    'delete_attribute_rse': delete_attribute_rse,
+                    'add_distance_rses': add_distance_rses,
+                    'update_distance_rses': update_distance_rses,
+                    'get_distance_rses': get_distance_rses,
+                    'delete_distance_rses': delete_distance_rses,
+                    'add_protocol_rse': add_protocol_rse,
+                    'del_protocol_rse': del_protocol_rse,
+                    'list_rses': list_rses,
+                    'disable_rse': disable_rse,
+                    'add_qos_policy': add_qos_policy,
+                    'delete_qos_policy': delete_qos_policy,
+                    'list_qos_policies': list_qos_policies,
+                    'add_scope': add_scope,
+                    'list_scopes': list_scopes,
+                    'info_rse': info_rse,
+                    'get_config': get_config,
+                    'set_config_option': set_config_option,
+                    'delete_config_option': delete_config_option,
+                    'add_subscription': add_subscription,
+                    'list_subscriptions': list_subscriptions,
+                    'update_subscription': update_subscription,
+                    'reevaluate_did_for_subscription': reevaluate_did_for_subscription,
+                    'declare_bad_file_replicas': declare_bad_file_replicas,
+                    'quarantine_replicas': quarantine_replicas,
+                    'declare_temporary_unavailable_replicas': declare_temporary_unavailable_replicas,
+                    'list_pfns': list_pfns,
+                    'import': import_data,
+                    'export': export_data,
+                    'set_tombstone': set_tombstone,
+                    'set_limit_rse': set_limit_rse,
+                    'delete_limit_rse': delete_limit_rse,
+                    }
+
+        pager = get_pager()
+        console = Console(theme=Theme(CLITheme.LOG_THEMES), soft_wrap=True)
+        console.width = max(MIN_CONSOLE_WIDTH, console.width)
+
+        cli_config = get_cli_config()
+        spinner = Status('Initializing spinner', spinner=CLITheme.SPINNER, spinner_style=CLITheme.SPINNER_STYLE, console=console)
+
+        if cli_config == 'rich':
+            install(console=console, word_wrap=True, width=min(console.width, MAX_TRACEBACK_WIDTH))  # Make rich exception tracebacks the default.
+            logger = setup_rich_logger(module_name=__name__, logger_name='user', verbose=args.verbose, console=console)
+        else:
+            logger = setup_logger(module_name=__name__, logger_name='user', verbose=args.verbose)
+
+        signal.signal(signal.SIGINT, lambda sig, frame: signal_handler(sig, frame, logger))
+        setup_gfal2_logger()
+        start_time = time.time()
+        command = commands.get(args.which)
+        client = get_client(args, logger)
+        result = command(args, client, logger, console, spinner)  # type: ignore
+
+        end_time = time.time()
+        if cli_config == 'rich':
+            spinner.stop()
+        if console.is_terminal and not args.no_pager:
+            command_output = console.end_capture()
+            if command_output == '' and args.verbose:
+                print("Completed in %-0.4f sec." % (end_time - start_time))
+            else:
+                if args.verbose:
+                    command_output += "Completed in %-0.4f sec." % (end_time - start_time)
+                # Ignore SIGINT during pager execution.
+                signal.signal(signal.SIGINT, signal.SIG_IGN)
+                pager(command_output)
+        else:
+            if args.verbose:
+                print("Completed in %-0.4f sec." % (end_time - start_time))
+        sys.exit(result)
 
-    commands = {'add_account': add_account,
-                'list_accounts': list_accounts,
-                'list_account_attributes': list_account_attributes,
-                'add_account_attribute': add_account_attribute,
-                'delete_account_attribute': delete_account_attribute,
-                'delete_account': delete_account,
-                'info_account': info_account,
-                'ban_account': ban_account,
-                'unban_account': unban_account,
-                'update_account': update_account,
-                'get_limits': get_limits,
-                'set_limits': set_limits,
-                'delete_limits': delete_limits,
-                'list_identities': list_identities,
-                'identity_add': identity_add,
-                'identity_delete': identity_delete,
-                'add_rse': add_rse,
-                'update_rse': update_rse,
-                'set_attribute_rse': set_attribute_rse,
-                'get_attribute_rse': get_attribute_rse,
-                'delete_attribute_rse': delete_attribute_rse,
-                'add_distance_rses': add_distance_rses,
-                'update_distance_rses': update_distance_rses,
-                'get_distance_rses': get_distance_rses,
-                'delete_distance_rses': delete_distance_rses,
-                'add_protocol_rse': add_protocol_rse,
-                'del_protocol_rse': del_protocol_rse,
-                'list_rses': list_rses,
-                'disable_rse': disable_rse,
-                'add_qos_policy': add_qos_policy,
-                'delete_qos_policy': delete_qos_policy,
-                'list_qos_policies': list_qos_policies,
-                'add_scope': add_scope,
-                'list_scopes': list_scopes,
-                'info_rse': info_rse,
-                'get_config': get_config,
-                'set_config_option': set_config_option,
-                'delete_config_option': delete_config_option,
-                'add_subscription': add_subscription,
-                'list_subscriptions': list_subscriptions,
-                'update_subscription': update_subscription,
-                'reevaluate_did_for_subscription': reevaluate_did_for_subscription,
-                'declare_bad_file_replicas': declare_bad_file_replicas,
-                'quarantine_replicas': quarantine_replicas,
-                'declare_temporary_unavailable_replicas': declare_temporary_unavailable_replicas,
-                'list_pfns': list_pfns,
-                'import': import_data,
-                'export': export_data,
-                'set_tombstone': set_tombstone,
-                'set_limit_rse': set_limit_rse,
-                'delete_limit_rse': delete_limit_rse,
-                }
 
-    if args.verbose:
-        logger.setLevel(logging.DEBUG)
-    start_time = time.time()
-    command = commands.get(args.which)
-    result = command(args)
-    end_time = time.time()
-    if args.verbose:
-        print("Completed in %-0.4f sec." % (end_time - start_time))
-    sys.exit(result)
+if __name__ == '__main__':
+    main()