python-rac 0.2.0__py3-none-any.whl

pyrac/cli.py

@@ -0,0 +1,921 @@
+"""Command-line adapter around the library; no wire format handling here."""
+import argparse
+import asyncio
+from pprint import pprint
+from uuid import UUID
+from . import client as client_module
+from .client import RacClient, RacError, UnsupportedFeatureError
+
+
+# Version negotiation is allowed only for commands that cannot mutate either RAS.
+# Keep an explicit allowlist so adding a new CLI action fails closed.
+AUTO_READ_ACTIONS = {
+    'agent': frozenset({'version', 'admin'}),
+    'cluster': frozenset({'list', 'info', 'admin'}),
+    'manager': frozenset({'list', 'info'}),
+    'service': frozenset({'list'}),
+    'session': frozenset({'list', 'info'}),
+    'profile': frozenset({'list', 'acl'}),
+    'counter': frozenset({'list', 'info', 'values', 'accumulated-values'}),
+    'limit': frozenset({'list', 'info'}),
+    'connection': frozenset({'list', 'info'}),
+    'service-setting': frozenset({'list', 'info', 'get-service-data-dirs-for-transfer'}),
+    'lock': frozenset({'list'}),
+    'rule': frozenset({'list', 'info'}),
+    'server': frozenset({'list', 'info'}),
+    'process': frozenset({'list', 'info'}),
+    'infobase': frozenset({'info', 'summary'}),
+    'binary-data-storage': frozenset({'list'}),
+}
+
+
+def _auto_read_only(args):
+    if args.action not in AUTO_READ_ACTIONS.get(args.command, ()):
+        return False
+    if args.command in ('agent', 'cluster') and args.action == 'admin':
+        return args.detail == 'list'
+    if args.command == 'profile' and args.action == 'acl':
+        return args.acl_action == 'list'
+    if args.command == 'infobase' and args.action == 'summary':
+        return args.detail in ('list', 'info')
+    return True
+
+
+def build_parser():
+    parser = argparse.ArgumentParser(description='1C RAC administration client')
+    parser.add_argument('--ras-host', default='localhost')
+    parser.add_argument('--ras-port', type=int, default=1545)
+    parser.add_argument('--protocol', choices=['10.0', '16.0', 'auto'], default='16.0')
+    parser.add_argument('--agent-user')
+    sub = parser.add_subparsers(dest='command', required=True)
+    agent = sub.add_parser('agent')
+    agent_actions = agent.add_subparsers(dest='action', required=True)
+    agent_actions.add_parser('version')
+    agent_admin_actions = agent_actions.add_parser('admin').add_subparsers(dest='detail', required=True)
+    agent_admin_actions.add_parser('list')
+    register = agent_admin_actions.add_parser('register')
+    register.add_argument('--name', required=True)
+    register.add_argument('--os-user', required=True)
+    register.add_argument('--descr', default='')
+    agent_admin_actions.add_parser('remove').add_argument('--name', required=True)
+    for name in ('manager', 'service', 'session', 'profile', 'counter', 'limit', 'connection'):
+        group = sub.add_parser(name)
+        group.add_argument('--cluster', required=True)
+        actions = group.add_subparsers(dest='action', required=True)
+        listing = actions.add_parser('list')
+        if name == 'profile':
+            update = actions.add_parser('update')
+            update.add_argument('--name', required=True)
+            update.add_argument('--descr')
+            update.add_argument('--config', choices=('yes', 'no'))
+            priv_options = update.add_mutually_exclusive_group()
+            priv_options.add_argument('--priv', choices=('yes', 'no'))
+            priv_options.add_argument('--full-privileged-mode', choices=('yes', 'no'))
+            update.add_argument('--crypto', choices=('yes', 'no'))
+            update.add_argument('--directory-access', choices=('list', 'full'))
+            update.add_argument('--com-access', choices=('list', 'full'))
+            update.add_argument('--addin-access', choices=('list', 'full'))
+            update.add_argument('--module-access', choices=('list', 'full'))
+            update.add_argument('--app-access', choices=('list', 'full'))
+            update.add_argument('--inet-access', choices=('list', 'full'))
+            update.add_argument('--right-extension', choices=('yes', 'no'))
+            update.add_argument('--all-modules-extension', choices=('yes', 'no'))
+            update.add_argument('--right-extension-definition-roles')
+            update.add_argument('--privileged-mode-roles')
+            update.add_argument('--modules-available-for-extension')
+            update.add_argument('--modules-not-available-for-extension')
+            actions.add_parser('remove').add_argument('--name', required=True)
+            acl = actions.add_parser('acl')
+            acl_types = acl.add_subparsers(dest='acl_type', required=True)
+            for acl_type in ('directory', 'com', 'addin', 'module', 'app', 'inet'):
+                acl_group = acl_types.add_parser(acl_type)
+                acl_actions = acl_group.add_subparsers(dest='acl_action', required=True)
+                acl_actions.add_parser('list').add_argument('--name', required=True)
+                if acl_type == 'directory':
+                    directory_update = acl_actions.add_parser('update')
+                    directory_update.add_argument('--name', required=True)
+                    directory_update.add_argument('--alias', required=True)
+                    directory_update.add_argument('--physicalPath')
+                    directory_update.add_argument('--descr')
+                    directory_update.add_argument('--allowedRead', choices=('yes', 'no'))
+                    directory_update.add_argument('--allowedWrite', choices=('yes', 'no'))
+                if acl_type == 'app':
+                    app_update = acl_actions.add_parser('update')
+                    app_update.add_argument('--name', required=True)
+                    app_update.add_argument('--item-name', required=True)
+                    app_update.add_argument('--wild')
+                    app_update.add_argument('--descr')
+                if acl_type == 'addin':
+                    addin_update = acl_actions.add_parser('update')
+                    addin_update.add_argument('--name', required=True)
+                    addin_update.add_argument('--item-name', required=True)
+                    addin_update.add_argument('--hash')
+                    addin_update.add_argument('--descr')
+                if acl_type == 'module':
+                    module_update = acl_actions.add_parser('update')
+                    module_update.add_argument('--name', required=True)
+                    module_update.add_argument('--item-name', required=True)
+                    module_update.add_argument('--hash')
+                    module_update.add_argument('--descr')
+                if acl_type == 'com':
+                    com_update = acl_actions.add_parser('update')
+                    com_update.add_argument('--name', required=True)
+                    com_update.add_argument('--item-name', required=True)
+                    for field in ('fileName', 'id', 'host', 'descr'):
+                        com_update.add_argument('--' + field)
+                if acl_type == 'inet':
+                    inet_update = acl_actions.add_parser('update')
+                    inet_update.add_argument('--name', required=True)
+                    inet_update.add_argument('--item-name', required=True)
+                    inet_update.add_argument('--url')
+                    inet_update.add_argument('--port', type=int)
+                    inet_update.add_argument('--protocol', dest='inet_protocol')
+                    inet_update.add_argument('--descr')
+                if acl_type in ('app', 'module', 'addin', 'inet', 'com', 'directory'):
+                    remove = acl_actions.add_parser('remove')
+                    remove.add_argument('--name', required=True)
+                    if acl_type == 'directory':
+                        remove.add_argument('--alias', required=True)
+                    else:
+                        remove.add_argument('--item-name', required=True)
+        if name in ('session', 'connection'):
+            listing.add_argument('--infobase')
+        if name == 'connection':
+            listing.add_argument('--process')
+        if name == 'session':
+            actions.add_parser('info').add_argument('--session', required=True)
+        if name in ('manager', 'connection'):
+            actions.add_parser('info').add_argument('--' + name, required=True)
+        if name == 'limit':
+            actions.add_parser('remove').add_argument('--name', required=True)
+            limit_update = actions.add_parser('update')
+            limit_update.add_argument('--name', required=True)
+            limit_update.add_argument('--action', dest='limit_action', choices=(
+                'none', 'set-low-priority-thread', 'interrupt-current-call',
+                'interrupt-session'))
+            limit_update.add_argument('--counter')
+            limit_update.add_argument('--error-message')
+            limit_update.add_argument('--descr')
+            for field in ('duration', 'cpu-time', 'memory', 'read', 'write',
+                          'duration-dbms', 'dbms-bytes', 'service', 'call',
+                          'number-of-active-sessions', 'number-of-sessions'):
+                limit_update.add_argument('--' + field, type=int)
+            actions.add_parser('info').add_argument('--limit', required=True)
+        if name == 'counter':
+            clear = actions.add_parser('clear')
+            clear.add_argument('--counter', required=True)
+            clear.add_argument('--object', default='')
+            actions.add_parser('remove').add_argument('--name', required=True)
+            counter_update = actions.add_parser('update')
+            counter_update.add_argument('--name', required=True)
+            counter_update.add_argument('--collection-time', type=int)
+            counter_update.add_argument('--group', choices=('users', 'data-separation'))
+            counter_update.add_argument('--filter-type', choices=('all-selected', 'all-but-selected', 'all'))
+            counter_update.add_argument('--filter')
+            counter_update.add_argument('--descr')
+            for field in ('duration', 'cpu-time', 'memory', 'read', 'write', 'duration-dbms',
+                          'dbms-bytes', 'service', 'call', 'number-of-active-sessions',
+                          'number-of-sessions'):
+                counter_update.add_argument('--' + field, choices=('analyze', 'not-analyze'))
+            actions.add_parser('info').add_argument('--counter', required=True)
+            for action in ('values', 'accumulated-values'):
+                values = actions.add_parser(action)
+                values.add_argument('--counter', required=True)
+                values.add_argument('--object', default='')
+    setting = sub.add_parser('service-setting')
+    setting.add_argument('--cluster', required=True)
+    setting.add_argument('--server', required=True)
+    setting_actions = setting.add_subparsers(dest='action', required=True)
+    setting_actions.add_parser('list')
+    insert = setting_actions.add_parser('insert')
+    insert.add_argument('--service-name', required=True)
+    insert.add_argument('--infobase-name', default='')
+    insert.add_argument('--service-data-dir', default='')
+    setting_update = setting_actions.add_parser('update')
+    setting_update.add_argument('--setting', required=True)
+    setting_update.add_argument('--service-data-dir', required=True)
+    setting_actions.add_parser('remove').add_argument('--setting', required=True)
+    setting_actions.add_parser('apply')
+    setting_actions.add_parser('info').add_argument('--setting', required=True)
+    transfer = setting_actions.add_parser('get-service-data-dirs-for-transfer')
+    transfer.add_argument('--service-name', default='')
+    lock = sub.add_parser('lock')
+    lock.add_argument('--cluster', required=True)
+    lock_list = lock.add_subparsers(dest='action', required=True).add_parser('list')
+    lock_filters = lock_list.add_mutually_exclusive_group()
+    for field in ('infobase', 'connection', 'session'):
+        lock_filters.add_argument('--' + field)
+    rule = sub.add_parser('rule')
+    rule.add_argument('--cluster', required=True)
+    rule_actions = rule.add_subparsers(dest='action', required=True)
+    rule_actions.add_parser('list').add_argument('--server', required=True)
+    rule_info = rule_actions.add_parser('info')
+    rule_info.add_argument('--server', required=True)
+    rule_info.add_argument('--rule', required=True)
+    rule_insert = rule_actions.add_parser('insert')
+    rule_insert.add_argument('--server', required=True)
+    rule_insert.add_argument('--position', type=int, required=True)
+    rule_insert.add_argument('--object-type', default='')
+    rule_insert.add_argument('--infobase-name', default='')
+    rule_insert.add_argument('--rule-type', choices=('never', 'auto', 'always'), default='auto')
+    rule_insert.add_argument('--application-ext', default='')
+    rule_insert.add_argument('--priority', type=int, default=0)
+    rule_remove = rule_actions.add_parser('remove')
+    rule_remove.add_argument('--server', required=True)
+    rule_remove.add_argument('--rule', required=True)
+    rule_update = rule_actions.add_parser('update')
+    rule_update.add_argument('--server', required=True)
+    rule_update.add_argument('--rule', required=True)
+    rule_update.add_argument('--position', type=int, required=True)
+    rule_update.add_argument('--object-type')
+    rule_update.add_argument('--infobase-name')
+    rule_update.add_argument('--rule-type', choices=('never', 'auto', 'always'))
+    rule_update.add_argument('--application-ext')
+    rule_update.add_argument('--priority', type=int)
+    rule_apply = rule_actions.add_parser('apply')
+    apply_mode = rule_apply.add_mutually_exclusive_group()
+    apply_mode.add_argument('--full', dest='full', action='store_true', default=True)
+    apply_mode.add_argument('--partial', dest='full', action='store_false')
+    cluster = sub.add_parser('cluster')
+    cluster_sub = cluster.add_subparsers(dest='action', required=True)
+    cluster_sub.add_parser('list')
+    cluster_sub.add_parser('remove').add_argument('--cluster', required=True)
+    cluster_insert = cluster_sub.add_parser('insert')
+    cluster_insert.add_argument('--host', required=True)
+    cluster_insert.add_argument('--port', type=int, required=True)
+    cluster_insert.add_argument('--name', default='')
+    cluster_insert.add_argument('--expiration-timeout', type=int)
+    cluster_insert.add_argument('--security-level', type=int)
+    cluster_insert.add_argument('--session-fault-tolerance-level', type=int)
+    cluster_insert.add_argument('--load-balancing-mode', choices=('performance', 'memory'))
+    cluster_insert.add_argument('--kill-problem-processes', choices=('yes', 'no'))
+    cluster_insert.add_argument('--kill-by-memory-with-dump', choices=('yes', 'no'))
+    cluster_insert.add_argument('--allow-access-right-audit-events-recording', choices=('yes', 'no'))
+    cluster_insert.add_argument('--restart-schedule')
+    cluster_insert.add_argument('--ping-period', type=int)
+    cluster_insert.add_argument('--ping-timeout', type=int)
+    cluster_admin = cluster_sub.add_parser('admin')
+    cluster_admin.add_argument('--cluster', required=True)
+    cluster_admin.add_argument('--cluster-user')
+    cluster_admin_actions = cluster_admin.add_subparsers(dest='detail', required=True)
+    cluster_admin_actions.add_parser('list')
+    register = cluster_admin_actions.add_parser('register')
+    register.add_argument('--name', required=True)
+    register.add_argument('--os-user', required=True)
+    register.add_argument('--descr', default='')
+    cluster_admin_actions.add_parser('remove').add_argument('--name', required=True)
+    for action in ('info', 'update'):
+        target = cluster_sub.add_parser(action)
+        target.add_argument('--cluster', required=True)
+        if action == 'update':
+            updates = target.add_mutually_exclusive_group(required=True)
+            updates.add_argument('--restart-schedule')
+            updates.add_argument('--name')
+            updates.add_argument('--expiration-timeout', type=int)
+            updates.add_argument('--security-level', type=int)
+            updates.add_argument('--session-fault-tolerance-level', type=int)
+            updates.add_argument('--load-balancing-mode', choices=('performance', 'memory'))
+            updates.add_argument('--kill-problem-processes', choices=('yes', 'no'))
+            updates.add_argument('--kill-by-memory-with-dump', choices=('yes', 'no'))
+            updates.add_argument('--allow-access-right-audit-events-recording', choices=('yes', 'no'))
+            updates.add_argument('--ping-period', type=int)
+            target.add_argument('--ping-timeout', type=int)
+    server = sub.add_parser('server')
+    process = sub.add_parser('process')
+    infobase = sub.add_parser('infobase')
+    for group in (server, process):
+        group.add_argument('--cluster', required=True)
+        group.add_argument('--cluster-user')
+        group.add_argument('--cluster-pwd')
+        actions = group.add_subparsers(dest='action', required=True)
+        actions.add_parser('list')
+        if group is process:
+            actions.choices['list'].add_argument('--server')
+            actions.add_parser('info').add_argument('--process', required=True)
+            actions.add_parser('turn-off').add_argument('--process', required=True)
+        if group is server:
+            info = actions.add_parser('info')
+            info.add_argument('--server', required=True)
+            update = actions.add_parser('update')
+            update.add_argument('--server', required=True)
+            updates = update.add_mutually_exclusive_group(required=True)
+            updates.add_argument('--restart-schedule')
+            updates.add_argument('--infobases-limit', type=int)
+            updates.add_argument('--connections-limit', type=int)
+            updates.add_argument('--safe-call-memory-limit', type=int)
+            updates.add_argument('--service-principal-name')
+            updates.add_argument('--critical-total-memory', type=int)
+            updates.add_argument('--temporary-allowed-total-memory', type=int)
+            updates.add_argument('--temporary-allowed-total-memory-time-limit', type=int)
+            updates.add_argument('--dedicate-managers', choices=['all', 'none'])
+            updates.add_argument('--port-range', action='append', dest='port_ranges')
+    infobase.add_argument('--cluster', required=True)
+    infobase.add_argument('--cluster-user')
+    infobase.add_argument('--cluster-pwd')
+    infobase_actions = infobase.add_subparsers(dest='action', required=True)
+    infobase_info = infobase_actions.add_parser('info')
+    info_selector = infobase_info.add_mutually_exclusive_group(required=True)
+    info_selector.add_argument('--infobase')
+    info_selector.add_argument('--name')
+    infobase_update = infobase_actions.add_parser('update')
+    infobase_update.add_argument('--infobase', required=True)
+    updates = infobase_update.add_mutually_exclusive_group(required=True)
+    updates.add_argument('--descr')
+    updates.add_argument('--security-profile-name')
+    updates.add_argument('--safe-mode-security-profile-name')
+    updates.add_argument('--scheduled-jobs-deny', choices=('on', 'off'))
+    updates.add_argument('--sessions-deny', choices=('on', 'off'))
+    updates.add_argument('--license-distribution', choices=('allow', 'deny'))
+    updates.add_argument('--denied-message')
+    updates.add_argument('--reserve-working-processes', choices=('yes', 'no'))
+    updates.add_argument('--external-session-manager-required', choices=('yes', 'no'))
+    updates.add_argument('--disable-local-speech-to-text', choices=('yes', 'no'))
+    updates.add_argument('--configuration-unload-delay-by-working-process-without-active-users',
+                         type=int)
+    updates.add_argument('--minimum-scheduled-jobs-start-period-without-active-users', type=int)
+    updates.add_argument('--maximum-scheduled-jobs-start-shift-without-active-users', type=int)
+    infobase_create = infobase_actions.add_parser('create')
+    for option in ('name', 'db-name', 'db-server', 'db-user', 'locale'):
+        infobase_create.add_argument('--' + option, required=True)
+    infobase_create.add_argument('--descr', default='')
+    infobase_create.add_argument('--scheduled-jobs-deny', choices=('on', 'off'), default='off')
+    infobase_create.add_argument('--license-distribution', choices=('allow', 'deny'), default='deny')
+    infobase_create.add_argument('--date-offset', type=int, choices=(0, 2000), default=0)
+    infobase_create.add_argument('--security-level', type=int, choices=(0, 1), default=0)
+    database_policy_create = infobase_create.add_mutually_exclusive_group(required=True)
+    database_policy_create.add_argument('--create-database', action='store_true')
+    database_policy_create.add_argument('--use-existing-database', action='store_false',
+                                        dest='create_database')
+    infobase_drop = infobase_actions.add_parser('drop')
+    infobase_drop.add_argument('--infobase', required=True)
+    database_policy = infobase_drop.add_mutually_exclusive_group(required=True)
+    database_policy.add_argument('--drop-database', action='store_true')
+    database_policy.add_argument('--keep-database', action='store_true')
+    database_policy.add_argument('--clear-database', action='store_true')
+    summary = infobase_actions.add_parser('summary')
+    summary_actions = summary.add_subparsers(dest='detail', required=True)
+    summary_actions.add_parser('list')
+    summary_info = summary_actions.add_parser('info')
+    summary_selector = summary_info.add_mutually_exclusive_group(required=True)
+    summary_selector.add_argument('--infobase')
+    summary_selector.add_argument('--name')
+    summary_update = summary_actions.add_parser('update')
+    summary_update.add_argument('--infobase', required=True)
+    summary_update.add_argument('--descr', required=True)
+    storage = sub.add_parser('binary-data-storage')
+    storage.add_argument('--cluster', required=True)
+    storage.add_argument('--cluster-user')
+    storage.add_argument('--cluster-pwd')
+    storage.add_subparsers(dest='action', required=True).add_parser('list').add_argument(
+        '--infobase', required=True)
+    return parser
+
+
+async def run(args):
+    if args.protocol == 'auto' and not _auto_read_only(args):
+        raise UnsupportedFeatureError('Protocol auto is read-only in the CLI; select 16.0 explicitly for mutations')
+    if args.protocol in ('16.0', 'auto') and any(getattr(args, key, None) is not None
+                                       for key in ('cluster_pwd', 'agent_pwd')):
+        raise UnsupportedFeatureError('Password arguments are not accepted by the 16.0/auto CLI')
+    if (args.command == 'cluster' and args.action in ('insert', 'update')
+            and (args.ping_period is None) != (args.ping_timeout is None)):
+        raise ValueError('Cluster ping-period and ping-timeout must be supplied together')
+    if (args.command == 'cluster' and args.action == 'update'
+            and args.ping_period is not None
+            and not (args.ping_period == args.ping_timeout == 0
+                     or 0 < args.ping_period < args.ping_timeout < 2**31)):
+        raise ValueError('Invalid cluster ping period/timeout pair')
+    # Parse every UUID selector before entering the context: 16.0 opens a TCP
+    # endpoint in __aenter__, so a malformed selector must not reach RAS.
+    for field in ('cluster', 'server', 'process', 'infobase', 'connection',
+                  'session', 'manager', 'setting', 'rule'):
+        if (value := getattr(args, field, None)) is not None:
+            UUID(value)
+    if args.command == 'infobase' and args.action == 'create':
+        for field in ('name', 'db_name', 'db_server', 'db_user', 'locale'):
+            value = getattr(args, field)
+            if not value or '\x00' in value or len(value.encode('utf-8')) > 255:
+                raise ValueError('Invalid infobase ' + field)
+        if '\x00' in args.descr or len(args.descr.encode('utf-8')) > 1024:
+            raise ValueError('Invalid infobase description')
+    if args.command == 'infobase' and (args.action == 'update' or
+                                      args.action == 'summary' and args.detail == 'update'):
+        for field in ('descr', 'security_profile_name', 'safe_mode_security_profile_name',
+                      'denied_message'):
+            value = getattr(args, field, None)
+            if value is not None and ('\x00' in value or
+                                      field != 'denied_message' and len(value.encode('utf-8')) > 1024):
+                raise ValueError('Invalid infobase update field')
+        for field, maximum in (
+                ('configuration_unload_delay_by_working_process_without_active_users', 0xffffffff),
+                ('minimum_scheduled_jobs_start_period_without_active_users', 0xffffffff),
+                ('maximum_scheduled_jobs_start_shift_without_active_users', 255)):
+            value = getattr(args, field, None)
+            if value is not None and not 0 <= value <= maximum:
+                raise ValueError('Invalid infobase update numeric field')
+    if args.command == 'infobase' and (args.action == 'info' or
+                                      args.action == 'summary' and args.detail == 'info'):
+        name = args.name
+        if name is not None and (not name.strip() or '\x00' in name
+                                 or len(name.encode('utf-8')) > 1024):
+            raise ValueError('Invalid infobase name')
+    if args.command == 'profile' and args.action == 'acl' and args.acl_action == 'list':
+        name = args.name
+        if not name.strip() or '\x00' in name or len(name.encode('utf-8')) > 1024:
+            raise ValueError('Invalid security profile name')
+    if (args.command == 'service-setting' and
+            args.action == 'get-service-data-dirs-for-transfer'):
+        name = args.service_name
+        if '\x00' in name or len(name.encode('utf-8')) > 1024:
+            raise ValueError('Invalid service name')
+    if (args.command in ('agent', 'cluster') and args.action == 'admin'
+            and args.detail == 'register'):
+        for label, value in (('name', args.name), ('OS user', args.os_user),
+                             ('description', args.descr)):
+            if ((label != 'description' and not value) or '\x00' in value
+                    or len(value.encode('utf-8')) > 1024):
+                raise ValueError('Invalid administrator ' + label)
+    if ((args.command in ('agent', 'cluster') and args.action == 'admin'
+         and args.detail == 'remove') or
+        (args.command in ('profile', 'counter', 'limit') and args.action == 'remove')):
+        name = args.name
+        if not name.strip() or '\x00' in name or len(name.encode('utf-8')) > 1024:
+            raise ValueError('Invalid removal name')
+    if args.command == 'profile' and args.action == 'update':
+        if (not args.name.strip() or '\x00' in args.name
+                or len(args.name.encode('utf-8')) > 1024):
+            raise ValueError('Invalid security profile name')
+        for field in ('descr', 'right_extension_definition_roles', 'privileged_mode_roles',
+                      'modules_available_for_extension', 'modules_not_available_for_extension'):
+            value = getattr(args, field)
+            if value is not None and ('\x00' in value or len(value.encode('utf-8')) > 1024):
+                raise ValueError('Invalid security profile field')
+    if args.command == 'profile' and args.action == 'acl' and args.acl_action in ('update', 'remove'):
+        item = args.alias if args.acl_type == 'directory' else args.item_name
+        for value in (args.name, item):
+            if not value.strip() or '\x00' in value or len(value.encode('utf-8')) > 1024:
+                raise ValueError('Invalid profile ACL selector')
+        if args.acl_action == 'update':
+            fields = {
+                'directory': ('physicalPath', 'descr'),
+                'app': ('wild', 'descr'),
+                'addin': ('hash', 'descr'),
+                'module': ('hash', 'descr'),
+                'com': ('fileName', 'id', 'host', 'descr'),
+                'inet': ('url', 'inet_protocol', 'descr'),
+            }[args.acl_type]
+            for field in fields:
+                value = getattr(args, field)
+                if value is not None and ('\x00' in value or len(value.encode('utf-8')) > 1024):
+                    raise ValueError('Invalid profile ACL field')
+            if args.acl_type == 'inet':
+                acl_port = args.port
+                if acl_port is not None and not 0 <= acl_port <= 65535:
+                    raise ValueError('Invalid profile internet ACL port')
+    if (args.command == 'cluster' and args.action == 'insert'
+            and not 1 <= args.port <= 65535):
+        raise ValueError('Invalid cluster port')
+    if args.command == 'cluster' and args.action == 'insert':
+        if (not args.host or '\x00' in args.host or len(args.host.encode('utf-8')) > 255
+                or '\x00' in args.name or len(args.name.encode('utf-8')) > 256):
+            raise ValueError('Invalid cluster insert parameters')
+        if any(value is not None and not 0 <= value < 2**31 for value in (
+                args.expiration_timeout, args.security_level,
+                args.session_fault_tolerance_level)):
+            raise ValueError('Invalid cluster insert numeric setting')
+        if (args.restart_schedule is not None and
+                ('\x00' in args.restart_schedule or
+                 (args.restart_schedule and
+                  (len(args.restart_schedule.encode('utf-8')) > 256 or
+                   len(args.restart_schedule.split()) != 6 or
+                   any(not part.isascii() or not part.isdecimal()
+                       for part in args.restart_schedule.split()))))):
+            raise ValueError('Invalid cluster restart schedule')
+        period = args.ping_period if args.ping_period is not None else 0
+        timeout = args.ping_timeout if args.ping_timeout is not None else 0
+        if not (period == timeout == 0 or 0 < period < timeout < 2**31):
+            raise ValueError('Invalid cluster ping period/timeout pair')
+    if args.command == 'cluster' and args.action == 'update':
+        if (args.name is not None and
+                ('\x00' in args.name or (args.name and not args.name.strip())
+                 or len(args.name.encode('utf-8')) > 256)):
+            raise ValueError('Invalid cluster name')
+        if any(value is not None and not 0 <= value < 2**31 for value in (
+                args.expiration_timeout, args.security_level,
+                args.session_fault_tolerance_level)):
+            raise ValueError('Invalid cluster numeric setting')
+        if args.restart_schedule is not None:
+            client_module.RacClient._validate_schedule(args.restart_schedule)
+    if args.command == 'rule' and args.action in ('insert', 'update'):
+        if not 0 <= args.position < 2**31:
+            raise ValueError('Invalid rule position')
+        if args.priority is not None and not -(2**31) <= args.priority < 2**31:
+            raise ValueError('Invalid rule priority')
+        for field in ('object_type', 'infobase_name', 'application_ext'):
+            value = getattr(args, field)
+            if value is not None and ('\x00' in value or len(value.encode('utf-8')) > 1024):
+                raise ValueError('Invalid rule field')
+    if args.command == 'service-setting' and args.action in ('insert', 'update'):
+        fields = ('service_name', 'infobase_name', 'service_data_dir') if args.action == 'insert' else (
+            'service_data_dir',)
+        for field in fields:
+            value = getattr(args, field)
+            if ('\x00' in value or len(value.encode('utf-8')) > 1024
+                    or field == 'service_name' and not value.strip()):
+                raise ValueError('Invalid service setting field')
+    if args.command in ('counter', 'limit') and args.action in ('update', 'clear'):
+        name = args.counter if args.action == 'clear' else args.name
+        if (not isinstance(name, str) or not name.strip() or '\x00' in name
+                or len(name.encode('utf-8')) > 1024):
+            raise ValueError('Invalid counter or limit name')
+        if args.command == 'counter':
+            if args.action == 'clear':
+                if '\x00' in args.object or len(args.object.encode('utf-8')) > 4096:
+                    raise ValueError('Invalid counter object filter')
+            else:
+                if args.collection_time is not None and not 0 <= args.collection_time < 2**63:
+                    raise ValueError('Invalid collection time')
+                for field in ('filter', 'descr'):
+                    value = getattr(args, field)
+                    if value is not None and ('\x00' in value or len(value.encode('utf-8')) > 1024):
+                        raise ValueError('Invalid counter field')
+        else:
+            for field in ('counter', 'error_message', 'descr'):
+                value = getattr(args, field)
+                if value is not None and ('\x00' in value or len(value.encode('utf-8')) > 1024):
+                    raise ValueError('Invalid limit field')
+            for field in ('duration', 'cpu_time', 'memory', 'read', 'write',
+                          'duration_dbms', 'dbms_bytes', 'service', 'call',
+                          'number_of_active_sessions', 'number_of_sessions'):
+                value = getattr(args, field)
+                if value is not None and not 0 <= value < 2**63:
+                    raise ValueError('Invalid limit threshold')
+    if (args.command == 'counter' and args.action in ('info', 'values', 'accumulated-values')
+            or args.command == 'limit' and args.action == 'info'):
+        name = args.counter if args.command == 'counter' else args.limit
+        if not name.strip() or '\x00' in name or len(name.encode('utf-8')) > 1024:
+            raise ValueError('Invalid counter or limit selector')
+        if args.command == 'counter' and args.action in ('values', 'accumulated-values'):
+            if '\x00' in args.object or len(args.object.encode('utf-8')) > 4096:
+                raise ValueError('Invalid counter object filter')
+    if args.command == 'server' and args.action == 'update':
+        for field, bits in (
+                ('infobases_limit', 31), ('connections_limit', 31),
+                ('safe_call_memory_limit', 63), ('critical_total_memory', 63),
+                ('temporary_allowed_total_memory', 63),
+                ('temporary_allowed_total_memory_time_limit', 63)):
+            value = getattr(args, field)
+            if value is not None and not 0 <= value < 2**bits:
+                raise ValueError('Invalid server numeric setting')
+        name = args.service_principal_name
+        if name is not None and ('\x00' in name or len(name.encode('utf-8')) > 256):
+            raise ValueError('Invalid server service principal name')
+        if args.restart_schedule is not None:
+            client_module.RacClient._validate_schedule(args.restart_schedule)
+    ranges = None
+    if (args.command == 'server' and args.action == 'update'
+            and getattr(args, 'port_ranges', None) is not None):
+        try:
+            ranges = [tuple(map(int, value.split(':'))) for value in args.port_ranges]
+        except ValueError as exc:
+            raise ValueError('Invalid server port range') from exc
+        if (not ranges or len(ranges) > 64
+                or any(len(pair) != 2 or any(not 1 <= port <= 65535 for port in pair)
+                       or pair[0] > pair[1] for pair in ranges)):
+            raise ValueError('Invalid server port ranges')
+        ordered = sorted(ranges)
+        if any(left[1] >= right[0] for left, right in zip(ordered, ordered[1:])):
+            raise ValueError('Overlapping server port ranges')
+    async with RacClient(args.ras_host, args.ras_port, args.protocol,
+                         cluster_user=getattr(args, 'cluster_user', None),
+                         cluster_password=getattr(args, 'cluster_pwd', None),
+                         agent_user=getattr(args, 'agent_user', None)) as client:
+        if args.command == 'agent':
+            if args.action == 'version':
+                return await client.agent_version()
+            if args.detail == 'register':
+                return await client.register_agent_admin(args.name, args.os_user, descr=args.descr)
+            if args.detail == 'remove':
+                return await client.remove_agent_admin(args.name)
+            return await client.list_agent_admins()
+        if args.command == 'manager':
+            if args.action == 'info':
+                return await client.get_manager(UUID(args.cluster), UUID(args.manager))
+            return await client.list_managers(UUID(args.cluster))
+        if args.command == 'service':
+            return await client.list_services(UUID(args.cluster))
+        if args.command == 'connection':
+            if args.action == 'info':
+                return await client.get_connection(UUID(args.cluster), UUID(args.connection))
+            return await client.list_connections(
+                UUID(args.cluster), UUID(args.infobase) if args.infobase else None,
+                process_id=UUID(args.process) if args.process else None)
+        if args.command == 'service-setting':
+            if args.action == 'apply':
+                return await client.apply_service_settings(UUID(args.cluster), UUID(args.server))
+            if args.action == 'remove':
+                return await client.remove_service_setting(
+                    UUID(args.cluster), UUID(args.server), UUID(args.setting))
+            if args.action == 'update':
+                return await client.update_service_setting(
+                    UUID(args.cluster), UUID(args.server), UUID(args.setting), args.service_data_dir)
+            if args.action == 'insert':
+                return await client.insert_service_setting(
+                    UUID(args.cluster), UUID(args.server), args.service_name,
+                    infobase_name=args.infobase_name, service_data_dir=args.service_data_dir)
+            cluster, server = UUID(args.cluster), UUID(args.server)
+            if args.action == 'list':
+                return await client.list_service_settings(cluster, server)
+            if args.action == 'info':
+                return await client.get_service_setting(cluster, server, UUID(args.setting))
+            return await client.list_service_data_dirs_for_transfer(cluster, server, args.service_name)
+        if args.command == 'lock':
+            return await client.list_locks(
+                UUID(args.cluster), **{field + '_id': UUID(value) for field in
+                                       ('infobase', 'connection', 'session')
+                                       if (value := getattr(args, field)) is not None})
+        if args.command == 'rule':
+            if args.action == 'apply':
+                return await client.apply_rules(UUID(args.cluster), full=args.full)
+            if args.action == 'update':
+                return await client.update_rule(
+                    UUID(args.cluster), UUID(args.server), UUID(args.rule), args.position,
+                    **{field: value for field in ('object_type', 'infobase_name',
+                        'rule_type', 'application_ext', 'priority')
+                       if (value := getattr(args, field)) is not None})
+            if args.action == 'remove':
+                return await client.remove_rule(UUID(args.cluster), UUID(args.server), UUID(args.rule))
+            if args.action == 'insert':
+                return await client.insert_rule(
+                    UUID(args.cluster), UUID(args.server), args.position,
+                    object_type=args.object_type, infobase_name=args.infobase_name,
+                    rule_type=args.rule_type, application_ext=args.application_ext,
+                    priority=args.priority)
+            if args.action == 'info':
+                return await client.get_rule(UUID(args.cluster), UUID(args.server), UUID(args.rule))
+            return await client.list_rules(UUID(args.cluster), UUID(args.server))
+        if args.command in ('session', 'profile', 'counter', 'limit'):
+            if args.command == 'profile' and args.action == 'update':
+                return await client.update_profile(UUID(args.cluster), args.name, descr=args.descr,
+                                                   config=None if args.config is None else args.config == 'yes',
+                                                   priv=None if args.priv is None else args.priv == 'yes',
+                                                   full_privileged_mode=None if args.full_privileged_mode is None else args.full_privileged_mode == 'yes',
+                                                   crypto=None if args.crypto is None else args.crypto == 'yes',
+                                                   right_extension=None if args.right_extension is None else args.right_extension == 'yes',
+                                                   all_modules_extension=None if args.all_modules_extension is None else args.all_modules_extension == 'yes',
+                                                   right_extension_definition_roles=args.right_extension_definition_roles,
+                                                   privileged_mode_roles=args.privileged_mode_roles,
+                                                   modules_available_for_extension=args.modules_available_for_extension,
+                                                   modules_not_available_for_extension=args.modules_not_available_for_extension,
+                                                   directory_access=None if args.directory_access is None else args.directory_access == 'full',
+                                                   com_access=None if args.com_access is None else args.com_access == 'full',
+                                                   addin_access=None if args.addin_access is None else args.addin_access == 'full',
+                                                   module_access=None if args.module_access is None else args.module_access == 'full',
+                                                   app_access=None if args.app_access is None else args.app_access == 'full',
+                                                   inet_access=None if args.inet_access is None else args.inet_access == 'full')
+            if args.command == 'profile' and args.action == 'remove':
+                return await client.remove_profile(UUID(args.cluster), args.name)
+            if args.command == 'profile' and args.action == 'acl':
+                if args.acl_type == 'inet' and args.acl_action == 'update':
+                    return await client.update_profile_inet(
+                        UUID(args.cluster), args.name, args.item_name,
+                        url=args.url, port=args.port, protocol=args.inet_protocol, descr=args.descr)
+                if args.acl_type == 'com' and args.acl_action == 'update':
+                    return await client.update_profile_com_class(
+                        UUID(args.cluster), args.name, args.item_name,
+                        file_name=args.fileName, class_id=args.id, host=args.host, descr=args.descr)
+                if args.acl_type == 'module' and args.acl_action == 'update':
+                    return await client.update_profile_module(UUID(args.cluster), args.name,
+                                                              args.item_name, hash_value=args.hash, descr=args.descr)
+                if args.acl_type == 'addin' and args.acl_action == 'update':
+                    return await client.update_profile_addin(UUID(args.cluster), args.name,
+                                                             args.item_name, hash_value=args.hash, descr=args.descr)
+                if args.acl_type == 'app' and args.acl_action == 'update':
+                    return await client.update_profile_app(UUID(args.cluster), args.name,
+                                                           args.item_name, wild=args.wild, descr=args.descr)
+                if args.acl_type == 'directory' and args.acl_action == 'update':
+                    return await client.update_profile_directory(
+                        UUID(args.cluster), args.name, args.alias,
+                        physical_path=args.physicalPath, descr=args.descr,
+                        allowed_read=None if args.allowedRead is None else args.allowedRead == 'yes',
+                        allowed_write=None if args.allowedWrite is None else args.allowedWrite == 'yes')
+                if args.acl_action == 'remove':
+                    if args.acl_type == 'directory':
+                        return await client.remove_profile_directory(UUID(args.cluster), args.name, args.alias)
+                    method = {'app': client.remove_profile_app,
+                              'module': client.remove_profile_module,
+                              'addin': client.remove_profile_addin,
+                              'inet': client.remove_profile_inet,
+                              'com': client.remove_profile_com_class}[args.acl_type]
+                    return await method(UUID(args.cluster), args.name, args.item_name)
+                method = {'directory': client.list_profile_directories,
+                          'com': client.list_profile_com_classes,
+                          'addin': client.list_profile_addins,
+                          'module': client.list_profile_modules,
+                          'app': client.list_profile_apps,
+                          'inet': client.list_profile_inet}[args.acl_type]
+                return await method(UUID(args.cluster), args.name)
+            if args.command == 'session' and args.action == 'info':
+                return await client.get_session(UUID(args.cluster), UUID(args.session))
+            if args.command == 'session' and args.action == 'list':
+                return await client.list_sessions(UUID(args.cluster), UUID(args.infobase) if args.infobase else None)
+            if args.command == 'limit' and args.action == 'info':
+                return await client.get_limit(UUID(args.cluster), args.limit)
+            if args.command == 'limit' and args.action == 'remove':
+                return await client.remove_limit(UUID(args.cluster), args.name)
+            if args.command == 'limit' and args.action == 'update':
+                aliases = {'service': 'duration_service', 'call': 'calls',
+                           'number_of_active_sessions': 'active_sessions',
+                           'number_of_sessions': 'sessions'}
+                fields = ('duration', 'cpu_time', 'memory', 'read', 'write',
+                          'duration_dbms', 'dbms_bytes', 'service', 'call',
+                          'number_of_active_sessions', 'number_of_sessions')
+                return await client.update_limit(
+                    UUID(args.cluster), args.name, action=args.limit_action,
+                    counter=args.counter, error_message=args.error_message,
+                    descr=args.descr,
+                    **{aliases.get(key, key): getattr(args, key) for key in fields
+                       if getattr(args, key) is not None})
+            if args.command == 'counter' and args.action != 'list':
+                if args.action == 'clear':
+                    return await client.clear_counter(UUID(args.cluster), args.counter,
+                                                      object_filter=args.object)
+                if args.action == 'remove':
+                    return await client.remove_counter(UUID(args.cluster), args.name)
+                if args.action == 'update':
+                    flags = ('duration', 'cpu_time', 'memory', 'read', 'write',
+                             'duration_dbms', 'dbms_bytes', 'service', 'call',
+                             'number_of_active_sessions', 'number_of_sessions')
+                    return await client.update_counter(
+                        UUID(args.cluster), args.name, collection_time=args.collection_time,
+                        group=args.group, filter_type=args.filter_type, filter=args.filter,
+                        descr=args.descr, **{key: getattr(args, key) == 'analyze' for key in flags
+                                             if getattr(args, key) is not None})
+                if args.action == 'info':
+                    return await client.get_counter(UUID(args.cluster), args.counter)
+                if args.action == 'values':
+                    return await client.list_counter_values(UUID(args.cluster), args.counter, args.object)
+                return await client.list_accumulated_counter_values(UUID(args.cluster), args.counter, args.object)
+            return await getattr(client, 'list_' + args.command + 's')(UUID(args.cluster))
+        if args.command == 'cluster':
+            if args.action == 'remove':
+                return await client.remove_cluster(UUID(args.cluster))
+            if args.action == 'insert':
+                options = {key: getattr(args, key) for key in (
+                    'expiration_timeout', 'security_level', 'session_fault_tolerance_level',
+                    'load_balancing_mode', 'restart_schedule', 'ping_period', 'ping_timeout')
+                    if getattr(args, key) is not None}
+                for key in ('kill_problem_processes', 'kill_by_memory_with_dump'):
+                    if getattr(args, key) is not None:
+                        options[key] = getattr(args, key) == 'yes'
+                if args.allow_access_right_audit_events_recording is not None:
+                    options['audit'] = args.allow_access_right_audit_events_recording == 'yes'
+                return await client.insert_cluster(args.host, args.port, args.name, **options)
+            if args.action == 'update' and args.ping_period is not None:
+                return await client.update_cluster_ping(UUID(args.cluster), args.ping_period, args.ping_timeout)
+            if args.action == 'admin':
+                if args.detail == 'register':
+                    return await client.register_cluster_admin(
+                        UUID(args.cluster), args.name, args.os_user, descr=args.descr)
+                if args.detail == 'remove':
+                    return await client.remove_cluster_admin(UUID(args.cluster), args.name)
+                return await client.list_cluster_admins(UUID(args.cluster))
+            if args.action == 'list':
+                return await client.list_clusters()
+            if args.action == 'info':
+                return await client.get_cluster(UUID(args.cluster))
+            if args.name is not None:
+                return await client.update_cluster_name(UUID(args.cluster), args.name)
+            if args.expiration_timeout is not None:
+                return await client.update_cluster_expiration_timeout(UUID(args.cluster), args.expiration_timeout)
+            if args.security_level is not None:
+                return await client.update_cluster_security_level(UUID(args.cluster), args.security_level)
+            if args.session_fault_tolerance_level is not None:
+                return await client.update_cluster_session_fault_tolerance_level(
+                    UUID(args.cluster), args.session_fault_tolerance_level)
+            if args.load_balancing_mode is not None:
+                return await client.update_cluster_load_balancing_mode(
+                    UUID(args.cluster), args.load_balancing_mode)
+            if args.kill_problem_processes is not None:
+                return await client.update_cluster_kill_problem_processes(
+                    UUID(args.cluster), args.kill_problem_processes == 'yes')
+            if args.kill_by_memory_with_dump is not None:
+                return await client.update_cluster_kill_by_memory_with_dump(
+                    UUID(args.cluster), args.kill_by_memory_with_dump == 'yes')
+            if args.allow_access_right_audit_events_recording is not None:
+                return await client.update_cluster_audit(
+                    UUID(args.cluster), args.allow_access_right_audit_events_recording == 'yes')
+            return await client.update_restart_schedule(UUID(args.cluster), args.restart_schedule)
+        cluster = UUID(args.cluster)
+        if args.command == 'server':
+            if args.action == 'info':
+                return await client.get_server(cluster, UUID(args.server))
+            if args.action == 'update':
+                if args.port_ranges is not None:
+                    return await client.update_server_port_ranges(cluster, UUID(args.server), ranges)
+                if args.dedicate_managers is not None:
+                    return await client.update_server_dedicate_managers(
+                        cluster, UUID(args.server), args.dedicate_managers)
+                if args.temporary_allowed_total_memory_time_limit is not None:
+                    return await client.update_server_temporary_allowed_total_memory_time_limit(
+                        cluster, UUID(args.server), args.temporary_allowed_total_memory_time_limit)
+                if args.temporary_allowed_total_memory is not None:
+                    return await client.update_server_temporary_allowed_total_memory(
+                        cluster, UUID(args.server), args.temporary_allowed_total_memory)
+                if args.critical_total_memory is not None:
+                    return await client.update_server_critical_total_memory(
+                        cluster, UUID(args.server), args.critical_total_memory)
+                if args.service_principal_name is not None:
+                    return await client.update_server_service_principal_name(
+                        cluster, UUID(args.server), args.service_principal_name)
+                if args.safe_call_memory_limit is not None:
+                    return await client.update_server_safe_call_memory_limit(
+                        cluster, UUID(args.server), args.safe_call_memory_limit)
+                if args.connections_limit is not None:
+                    return await client.update_server_connections_limit(cluster, UUID(args.server),
+                                                                      args.connections_limit)
+                if args.infobases_limit is not None:
+                    return await client.update_server_infobases_limit(cluster, UUID(args.server),
+                                                                     args.infobases_limit)
+                return await client.update_server_restart_schedule(cluster, UUID(args.server), args.restart_schedule)
+            return await client.list_servers(cluster)
+        if args.command == 'process':
+            if args.action == 'info':
+                return await client.get_process(cluster, UUID(args.process))
+            if args.action == 'turn-off':
+                return await client.turn_off_process(cluster, UUID(args.process))
+            return await client.list_processes(cluster, UUID(args.server) if args.server else None)
+        if args.command == 'binary-data-storage':
+            return await client.list_binary_storages(cluster, UUID(args.infobase))
+        if args.command == 'infobase' and args.action == 'update':
+            if args.safe_mode_security_profile_name is not None:
+                return await client.update_infobase_safe_mode_security_profile(
+                    cluster, UUID(args.infobase), args.safe_mode_security_profile_name)
+            if args.security_profile_name is not None:
+                return await client.update_infobase_security_profile(
+                    cluster, UUID(args.infobase), args.security_profile_name)
+            if args.maximum_scheduled_jobs_start_shift_without_active_users is not None:
+                return await client.update_infobase_maximum_scheduled_jobs_start_shift(
+                    cluster, UUID(args.infobase),
+                    args.maximum_scheduled_jobs_start_shift_without_active_users)
+            if args.minimum_scheduled_jobs_start_period_without_active_users is not None:
+                return await client.update_infobase_minimum_scheduled_jobs_start_period(
+                    cluster, UUID(args.infobase),
+                    args.minimum_scheduled_jobs_start_period_without_active_users)
+            if args.configuration_unload_delay_by_working_process_without_active_users is not None:
+                return await client.update_infobase_configuration_unload_delay(
+                    cluster, UUID(args.infobase),
+                    args.configuration_unload_delay_by_working_process_without_active_users)
+            if args.disable_local_speech_to_text is not None:
+                return await client.update_infobase_disable_local_speech_to_text(
+                    cluster, UUID(args.infobase), args.disable_local_speech_to_text == 'yes')
+            if args.external_session_manager_required is not None:
+                return await client.update_infobase_external_session_manager_required(
+                    cluster, UUID(args.infobase), args.external_session_manager_required == 'yes')
+            if args.reserve_working_processes is not None:
+                return await client.update_infobase_reserve_working_processes(
+                    cluster, UUID(args.infobase), args.reserve_working_processes == 'yes')
+            if args.denied_message is not None:
+                return await client.update_infobase_denied_message(
+                    cluster, UUID(args.infobase), args.denied_message)
+            if args.license_distribution is not None:
+                return await client.update_infobase_license_distribution(
+                    cluster, UUID(args.infobase), args.license_distribution)
+            if args.sessions_deny is not None:
+                return await client.update_infobase_sessions_deny(
+                    cluster, UUID(args.infobase), args.sessions_deny == 'on')
+            if args.scheduled_jobs_deny is not None:
+                return await client.update_infobase_scheduled_jobs_deny(
+                    cluster, UUID(args.infobase), args.scheduled_jobs_deny == 'on')
+            return await client.update_infobase_description(
+                cluster, UUID(args.infobase), args.descr)
+        if args.command == 'infobase' and args.action == 'create':
+            return await client.create_infobase(cluster, name=args.name,
+                db_name=args.db_name, db_server=args.db_server, db_user=args.db_user,
+                locale=args.locale, create_database=args.create_database, descr=args.descr,
+                scheduled_jobs_denied=args.scheduled_jobs_deny == 'on',
+                license_distribution=args.license_distribution, date_offset=args.date_offset,
+                security_level=args.security_level)
+        if args.command == 'infobase' and args.action == 'drop':
+            return await client.drop_infobase(cluster, UUID(args.infobase),
+                                              drop_database=args.drop_database,
+                                              clear_database=args.clear_database)
+        if args.command == 'infobase' and args.action == 'info':
+            return await client.get_infobase_info(
+                cluster, UUID(args.infobase) if args.infobase else None, name=args.name)
+        if args.command == 'infobase' and args.detail == 'update':
+            return await client.update_infobase_summary_description(
+                cluster, UUID(args.infobase), args.descr)
+        if args.command == 'infobase' and args.detail == 'info':
+            return await client.get_infobase_summary(
+                cluster, UUID(args.infobase) if args.infobase else None, name=args.name)
+        return await client.list_infobases(cluster)
+
+
+def main(argv=None):
+    args = build_parser().parse_args(argv)
+    try:
+        pprint(asyncio.run(run(args)))
+    except (RacError, ValueError) as exc:
+        # Errors from native rac are deliberately not echoed; may include credentials.
+        build_parser().exit(1, 'RAC request failed: ' + str(exc) + '\n')