rucio-clients 36.0.0__tar.gz → 36.0.0.post1__tar.gz

{rucio_clients-36.0.0 → rucio_clients-36.0.0.post1}/PKG-INFO

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

{rucio_clients-36.0.0 → rucio_clients-36.0.0.post1}/bin/rucio

@@ -88,7 +88,7 @@ def map_legacy_command() -> Optional[list[str]]:
 
 
 if __name__ == "__main__":
-    commands = ("-h", "--version", "account", "config", "did", "replica", "rse", "rule", "scope", "subscription", "ping", "whoami", "test-server", "lifetime-exception", "upload", "download")
+    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]
     is_legacy = '--legacy' in sys.argv
 

rucio_clients-36.0.0.post1/lib/rucio/client/commands/__init__.py

@@ -0,0 +1,25 @@
+# Copyright European Organization for Nuclear Research (CERN) since 2012
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from rucio.client.commands.account import Account  # noqa: F401
+from rucio.client.commands.command_base import CommandBase  # noqa: F401
+from rucio.client.commands.config import Config  # noqa: F401
+from rucio.client.commands.did import DID  # noqa: F401
+from rucio.client.commands.download import Download  # noqa: F401
+from rucio.client.commands.lifetime_exception import LifetimeException  # noqa: F401
+from rucio.client.commands.replica import Replica  # noqa: F401
+from rucio.client.commands.rse import RSE  # noqa: F401
+from rucio.client.commands.rule import Rule  # noqa: F401
+from rucio.client.commands.scope import Scope  # noqa: F401
+from rucio.client.commands.subscription import Subscription  # noqa: F401
+from rucio.client.commands.upload import Upload  # noqa: F401

rucio_clients-36.0.0.post1/lib/rucio/client/commands/account.py

@@ -0,0 +1,219 @@
+# Copyright European Organization for Nuclear Research (CERN) since 2012
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from argparse import SUPPRESS
+from typing import TYPE_CHECKING
+
+from rucio.client.commands.bin_legacy.rucio import list_account_usage
+from rucio.client.commands.bin_legacy.rucio_admin import (
+    add_account,
+    add_account_attribute,
+    ban_account,
+    delete_account,
+    delete_account_attribute,
+    delete_limits,
+    identity_add,
+    identity_delete,
+    info_account,
+    list_account_attributes,
+    list_accounts,
+    list_identities,
+    set_limits,
+    unban_account,
+    update_account,
+)
+from rucio.client.commands.command_base import CommandBase
+
+if TYPE_CHECKING:
+    from argparse import ArgumentParser
+
+    from rucio.client.commands.utils import OperationDict
+
+
+class Account(CommandBase):
+    def module_help(self) -> str:
+        return "Methods to add or change accounts for users, groups, and services. Used to assign privileges."
+
+    def usage_example(self) -> list[str]:
+        return [
+            "$ rucio account list # List all accounts on the instance",
+            "$ rucio account add --account user_jdoe --type USER  # Create a new user account",
+            "$ rucio account update --account user_jdoe --email jdoe@cern.ch  # Update jdoe's email",
+            "$ rucio account update --account jdoe --ban True  # Ban jdoe",
+            "$ rucio account history --account root  # Show all the usage history for the account root",
+        ]
+
+    def list_namespace(self, parser: "ArgumentParser") -> None:
+        parser.add_argument("--type", dest="account_type", help="Account Type", choices={"USER", "GROUP", "SERVICE"})
+        parser.add_argument("-a", "--account", dest="account", help="Account name")
+        parser.add_argument("--id", dest="identity", action="store", help="Identity (e.g. DN)")
+        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("-a", "--account", dest="account", help="Account name", required=True)
+        parser.add_argument("--email", dest="accountemail", 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)
+
+    def remove_namespace(self, parser: "ArgumentParser") -> None:
+        parser.add_argument("-a", "--account", dest="acnt", action="store", help="Account name", required=True)
+
+    def _operations(self) -> dict[str, "OperationDict"]:
+        return {
+            "list": {"call": self.list_, "docs": "List accounts", "namespace": self.list_namespace},
+            "add": {"call": self.add, "docs": "Add a new account", "namespace": self.add_namespace},
+            "show": {"call": self.show, "docs": "Get all stats on an account, including status, account type, and dates of creation and updates", "namespace": self.show_namespace},
+            "remove": {"call": self.remove, "docs": "Delete an account", "namespace": self.remove_namespace},
+            "update": {"call": self.update, "docs": "Change the basic account settings", "namespace": self.update_namespace},
+        }
+
+    def implemented_subcommands(self) -> dict[str, type[CommandBase]]:
+        return {"attribute": Attribute, "limit": Limit, "identity": Identity}
+
+    def list_(self):
+        list_accounts(self.args, self.client, self.logger, self.console, self.spinner)
+
+    def add(self):
+        add_account(self.args, self.client, self.logger, self.console, self.spinner)
+
+    def remove(self):
+        delete_account(self.args, self.client, self.logger, self.console, self.spinner)
+
+    def show(self):
+        info_account(self.args, self.client, self.logger, self.console, self.spinner)
+
+    def update(self):
+        if self.args.ban is not None:
+            if self.args.ban:
+                ban_account(self.args, self.client, self.logger, self.console, self.spinner)
+            else:
+                unban_account(self.args, self.client, self.logger, self.console, self.spinner)
+        else:
+            # Temp fix to allow specific kwargs
+            self.args.key = "email"
+            self.args.value = self.args.email
+            update_account(self.args, self.client, self.logger, self.console, self.spinner)
+
+
+class Attribute(Account):
+    def module_help(self) -> str:
+        return "Add additional key/value pairs associated with an account."
+
+    def implemented_subcommands(self) -> dict[str, type[CommandBase]]:
+        return {}
+
+    def namespace(self, subparser):
+        subparser.add_argument("-a", "--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")
+
+    def usage_example(self) -> list[str]:
+        return ["$ rucio account attribute list --account jdoe  # Show all attributes for jdoe",
+                "$ rucio -v account attribute add --account jdoe --key test_key --value true  # Set test_key = true for jdoe"]
+
+    def _operations(self) -> dict[str, "OperationDict"]:
+        return {
+            "list": {"call": self.list_, "docs": "List all account attributes"},
+            "add": {"call": self.add, "docs": "Add a new attribute to an account or update an existing one"},
+            "remove": {"call": self.remove, "docs": "Remove an existing account attribute"},
+        }
+
+    def list_(self):
+        list_account_attributes(self.args, self.client, self.logger, self.console, self.spinner)
+
+    def add(self):
+        add_account_attribute(self.args, self.client, self.logger, self.console, self.spinner)
+
+    def remove(self):
+        delete_account_attribute(self.args, self.client, self.logger, self.console, self.spinner)
+
+
+class Limit(Account):
+    def module_help(self) -> str:
+        return "Manage storage limits for an account at a given RSE."
+
+    def namespace(self, parser: "ArgumentParser") -> None:
+        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("--human", default=True, help=SUPPRESS)
+
+    def _operations(self) -> dict[str, "OperationDict"]:
+        return {
+            "list": {"call": self.list_, "docs": "Show limits and current utilization for an account at a given RSE", "namespace": self.namespace},
+            "add": {"call": self.add, "docs": "Add or update limits for an account", "namespace": self.namespace},  # TODO Add and update should become different operations
+            "remove": {"call": self.remove, "docs": "Remove all limits for given account/rse/locality", "namespace": self.namespace},
+        }
+
+    def implemented_subcommands(self) -> dict[str, type[CommandBase]]:
+        return {}
+
+    def usage_example(self) -> list[str]:
+        return super().usage_example()
+
+    def list_(self):
+        self.args.usage_account = self.args.account
+        list_account_usage(self.args, self.client, self.logger, self.console, self.spinner)
+
+    def add(self):
+        set_limits(self.args, self.client, self.logger, self.console, self.spinner)
+
+    def remove(self):
+        delete_limits(self.args, self.client, self.logger, self.console, self.spinner)
+
+
+class Identity(Account):
+    def module_help(self) -> str:
+        return "Manage identities on an 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("--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("--human", default=True, help=SUPPRESS)
+
+    def _operations(self) -> dict[str, "OperationDict"]:
+        return {
+            "list": {"call": self.list_, "docs": "Display existing identities for an account", "namespace": self.namespace},
+            "add": {"call": self.add, "docs": "Grant identity access to an account", "namespace": self.namespace},
+            "remove": {"call": self.remove, "docs": "Revoke identity access for an account", "namespace": self.namespace},
+        }
+
+    def usage_example(self) -> list[str]:
+        return [
+            "$ rucio account identity list --account jdoe  # List all auth identities for jdoe",
+            "$ rucio account identity add --account jdoe --type GSS --email jdoe@cern.ch --id jdoe@fnal.ch  # Add a new GSS auth",
+            "$ rucio account identity add --account jdoe --type X509 --id 'CN=Joe Doe,CN=707658,CN=jdoe,OU=Users,OU=Organic Units,DC=cern,DC=ch' --email jdoe@cern.ch  # Add a new X509 auth",
+        ]
+
+    def implemented_subcommands(self) -> dict[str, type[CommandBase]]:
+        return {}
+
+    def list_(self):
+        list_identities(self.args, self.client, self.logger, self.console, self.spinner)
+
+    def add(self):
+        identity_add(self.args, self.client, self.logger, self.console, self.spinner)
+
+    def remove(self):
+        identity_delete(self.args, self.client, self.logger, self.console, self.spinner)

rucio_clients-36.0.0.post1/lib/rucio/client/commands/command.py

@@ -0,0 +1,258 @@
+# Copyright European Organization for Nuclear Research (CERN) since 2012
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import argparse
+import os
+import signal
+import sys
+import time
+from typing import TYPE_CHECKING, Optional
+
+from rich.console import Console
+from rich.status import Status
+from rich.theme import Theme
+from rich.traceback import install
+
+import rucio.client.commands as commands
+from rucio import version
+from rucio.client.commands.bin_legacy.rucio import get_client, ping, test_server, whoami_account
+from rucio.client.commands.command_base import CommandBase
+from rucio.client.commands.utils import exception_handler, setup_gfal2_logger, signal_handler
+from rucio.client.richclient import MAX_TRACEBACK_WIDTH, MIN_CONSOLE_WIDTH, CLITheme, get_cli_config, get_pager, setup_rich_logger
+from rucio.common.extra import import_extras
+from rucio.common.utils import setup_logger
+
+if TYPE_CHECKING:
+    from argparse import Namespace
+    from logging import Logger
+
+    from rucio.client.client import Client
+
+EXTRA_MODULES = import_extras(["argcomplete"])
+
+if EXTRA_MODULES["argcomplete"]:
+    import argcomplete  # pylint: disable=E0401
+
+SUCCESS, FAILURE = 0, 1
+
+
+class Commands:
+    def __init__(self, logger: "Logger", client: "Client", args: "Namespace", console: Console, spinner: Status) -> None:
+        self.logger = logger
+        self.args = args
+        self.client = client
+        self.console = console
+        self.spinner = spinner
+
+    @staticmethod
+    def _all_commands() -> dict[str, type[commands.CommandBase]]:
+        # Look for all the CommandBase'd child classes in this folder and add their parsers and child parsers
+        command_map = {child.__name__.lower(): child for child in commands.CommandBase.__subclasses__() if child.__name__ != "LifetimeException"}
+        command_map["lifetime-exception"] = commands.LifetimeException
+        command_map["ping"] = Ping
+        command_map["whoami"] = Whoami
+        command_map["test-server"] = TestServer
+        return command_map
+
+    @staticmethod
+    def _add_parsers() -> argparse.ArgumentParser:
+        parser = argparse.ArgumentParser(description='CLI Rucio Client. (Use --legacy to view CLI from <36.0)')
+        Commands._main_parser(parser)
+
+        subparsers = parser.add_subparsers(dest="command", help="Command to execute, see `{command} -h` for more details and subcommands.")
+        for command in Commands._all_commands().values():
+            command(None, None, None, None, None).parser(subparsers)  # type: ignore
+
+        return parser
+
+    @staticmethod
+    def _main_parser(parser: argparse.ArgumentParser) -> None:
+        main_args = parser.add_argument_group("Main Arguments")
+
+        main_args.add_argument("--version", action="version", version="%(prog)s " + version.version_string())
+
+        main_args.add_argument("--config", help="The Rucio configuration file to use.")
+        main_args.add_argument("--verbose", "-v", default=False, action="store_true", help="Print more verbose output.")
+        main_args.add_argument("-H", "--host", metavar="ADDRESS", help="The Rucio API host.")
+        main_args.add_argument("--auth-host", metavar="ADDRESS", help="The Rucio Authentication host.")
+        main_args.add_argument("-a", "--account", dest="issuer", help="Rucio account to use.")
+        main_args.add_argument("-S", "--auth-strategy", help="Authentication strategy (userpass, x509...)")
+        main_args.add_argument("-T", "--timeout", type=float, help="Set all timeout values to seconds.")
+        main_args.add_argument("--user-agent", "-U", dest="user_agent", default="rucio-clients", help="Rucio User Agent")
+        main_args.add_argument("--vo", metavar="VO", help="VO to authenticate at. Only used in multi-VO mode.")
+        main_args.add_argument("--no-pager", dest="no_pager", default=False, action='store_true', help=argparse.SUPPRESS)
+
+        auth_args = parser.add_argument_group("Authentication Settings")
+
+        auth_args.add_argument("-u", "--user", dest="username", help="username")
+        auth_args.add_argument("-pwd", "--password", help="password")
+        # Options for defining remaining OIDC parameters
+        auth_args.add_argument("--oidc-user", dest="oidc_username", help="OIDC username")
+        auth_args.add_argument("--oidc-password", help="OIDC password")
+        auth_args.add_argument(
+            "--oidc-scope",
+            default="openid profile",
+            help="""
+                Defines which (OIDC) information user will share with Rucio. Rucio requires at least -sc='openid profile'.
+                To request refresh token for Rucio, scope must include 'openid offline_access' and there must be no active
+                access token saved on the side of the currently used Rucio Client.
+            """
+        )
+        auth_args.add_argument("--oidc-audience", help="Defines which audience are tokens requested for.")
+        auth_args.add_argument(
+            "--oidc-auto",
+            default=False,
+            action="store_true",
+            help="""
+                If not specified, username and password credentials are not required and users will be given a URL to use in their browser.
+                If specified, the users explicitly trust Rucio with their IdP credentials.
+             """
+        )
+        auth_args.add_argument(
+            "--oidc-polling",
+            default=False,
+            action="store_true",
+            help="""
+                If not specified, user will be asked to enter a code returned by the browser to the command line.
+                If --polling is set, Rucio Client should get the token without any further interaction of the user.
+                This option is active only if --auto is *not* specified.
+            """
+        )
+        auth_args.add_argument(
+            "--oidc-refresh-lifetime",
+            help="""
+                Max lifetime in hours for this access token; the token will be refreshed by an asynchronous Rucio daemon.
+                If not specified, refresh will be stopped after 4 days.
+                This option is effective only if --oidc-scope includes offline_access scope for a refresh token to be granted to Rucio.
+            """
+        )
+        auth_args.add_argument("--oidc-issuer", help="Defines which Identity Provider is going to be used. The issuer string must correspond to the keys configured in the /etc/idpsecrets.json auth server configuration file.")  # NOQA: W503
+
+        # Options for the x509  auth_strategy
+        auth_args.add_argument("--certificate", help="Client certificate file.")
+        auth_args.add_argument('--client-key', dest='client_key', default=None, help='Client key for x509 Authentication.')
+        auth_args.add_argument("--ca-certificate", help="CA certificate to verify peer against (SSL).")
+
+    def _run_command(self) -> Optional[int]:
+        try:
+            command_class = Commands._all_commands()[self.args.command]
+        except KeyError as e:
+            if self.args.command is not None:
+                self.logger.error(f"Cannot find command {self.args.command}: {e}")
+            sys.exit(FAILURE)
+
+        return exception_handler(command_class(self.client, self.args, self.logger, self.console, self.spinner))()
+
+    def __call__(self) -> None:
+        self.logger.debug("Running a command with the following arguments: %s" % vars(self.args))
+        start_time = time.time()
+        self._run_command()
+        end_time = time.time()
+
+        self.logger.debug("Completed in %-0.4f sec." % (end_time - start_time))
+
+
+class Ping(CommandBase):
+    def _operations(self):
+        return {}
+
+    def module_help(self) -> str:
+        return ""
+
+    def usage_example(self) -> list[str]:
+        return []
+
+    def parser(self, subparser):
+        command_parser = subparser.add_parser("ping", description="Ping the server", formatter_class=argparse.RawDescriptionHelpFormatter)
+        return command_parser
+
+    def __call__(self):
+        ping(self.args, self.client, self.logger, self.console, self.spinner)
+
+
+class Whoami(CommandBase):
+    def _operations(self):
+        return {}
+
+    def module_help(self) -> str:
+        return ""
+
+    def usage_example(self) -> list[str]:
+        return []
+
+    def parser(self, subparser):
+        command_parser = subparser.add_parser("whoami", description="See login information, test credentials", formatter_class=argparse.RawDescriptionHelpFormatter)
+        return command_parser
+
+    def __call__(self):
+        whoami_account(self.args, self.client, self.logger, self.console, self.spinner)
+
+
+class TestServer(CommandBase):
+    def _operations(self):
+        return {}
+
+    def module_help(self) -> str:
+        return ""
+
+    def usage_example(self) -> list[str]:
+        return []
+
+    def parser(self, subparser):
+        command_parser = subparser.add_parser("test-server", description="Test client against the server", formatter_class=argparse.RawDescriptionHelpFormatter)
+        return command_parser
+
+    def __call__(self):
+        test_server(self.args, self.client, self.logger, self.console, self.spinner)
+
+
+def main():
+    cli_config = get_cli_config()
+    console = Console(theme=Theme(CLITheme.LOG_THEMES), soft_wrap=True)
+    console.width = max(MIN_CONSOLE_WIDTH, console.width)
+
+    spinner = Status('Initializing spinner', spinner=CLITheme.SPINNER, spinner_style=CLITheme.SPINNER_STYLE, console=console)
+    pager = get_pager()
+
+    parser_object = Commands._add_parsers()
+    if EXTRA_MODULES["argcomplete"]:
+        argcomplete.autocomplete(parser_object)
+    args = parser_object.parse_args()
+    if args.config is not None:
+        os.environ["RUCIO_CONFIG"] = args.config
+    if args.command is None:
+        parser_object.print_help()
+        sys.exit(FAILURE)
+
+    setup_gfal2_logger()
+
+    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)
+
+    client = get_client(args, logger)
+    signal.signal(signal.SIGINT, lambda sig, frame: signal_handler(sig, frame, logger))
+
+    Commands(logger, client, args, console, spinner)()
+
+    if cli_config == 'rich':
+        spinner.stop()
+
+    if console.is_terminal and not args.no_pager:
+        command_output = console.end_capture()
+        if command_output != '':
+            signal.signal(signal.SIGINT, signal.SIG_IGN)  # Do not allow the user to stop the program while sending to pager
+            pager(command_output)