synapse 2.224.0__py311-none-any.whl → 2.225.0__py311-none-any.whl

synapse/tools/service/healthcheck.py

@@ -0,0 +1,109 @@
+import socket
+import asyncio
+
+import synapse.exc as s_exc
+import synapse.common as s_common
+import synapse.telepath as s_telepath
+
+import synapse.lib.cmd as s_cmd
+import synapse.lib.json as s_json
+import synapse.lib.output as s_output
+import synapse.lib.health as s_health
+import synapse.lib.urlhelp as s_urlhelp
+
+def serialize(ret):
+    return s_json.dumps(ret).decode()
+
+def format_component(e, mesg: str) -> dict:
+    d = {
+        'name': 'error',
+        'status': s_health.FAILED,
+        'mesg': mesg,
+        'data': {
+            'errname': e.__class__.__name__,
+            'errmesg': str(e),
+        }
+    }
+
+    return d
+
+async def main(argv, outp=s_output.stdout):
+    pars = getArgParser(outp)
+    try:
+        opts = pars.parse_args(argv)
+    except s_exc.ParserExit as e:  # pragma: no cover
+        return e.get('status')
+
+    url = opts.cell
+    sanitized_url = s_urlhelp.sanitizeUrl(url)
+
+    try:
+        async with s_telepath.withTeleEnv():
+
+            prox = await s_common.wait_for(s_telepath.openurl(url),
+                                           timeout=opts.timeout)
+    except (s_exc.LinkErr, s_exc.NoSuchPath, socket.gaierror) as e:
+        mesg = f'Unable to connect to cell @ {sanitized_url}.'
+        ret = {'status': 'failed',
+               'iden': opts.cell,
+               'components': [format_component(e, mesg)],
+               }
+        outp.printf(serialize(ret))
+        return 1
+    except s_exc.SynErr as e:
+        mesg = 'Synapse error encountered.'
+        ret = {'status': s_health.FAILED,
+               'iden': opts.cell,
+               'components': [format_component(e, mesg)],
+               }
+        outp.printf(serialize(ret))
+        return 1
+    except asyncio.TimeoutError as e:  # pragma: no cover
+        mesg = 'Timeout connecting to cell'
+        ret = {'status': s_health.FAILED,
+               'iden': opts.cell,
+               'components': [format_component(e, mesg)],
+               }
+        outp.printf(serialize(ret))
+        return 1
+
+    try:
+        ret = await s_common.wait_for(prox.getHealthCheck(),
+                                      timeout=opts.timeout)
+    except s_exc.SynErr as e:
+        mesg = 'Synapse error encountered.'
+        ret = {'status': s_health.FAILED,
+               'iden': opts.cell,
+               'components': [format_component(e, mesg)],
+               }
+
+    except asyncio.TimeoutError as e:
+        mesg = 'Timeout getting health information from cell.'
+        ret = {'status': s_health.FAILED,
+               'iden': opts.cell,
+               'components': [format_component(e, mesg)],
+               }
+
+    finally:
+        await prox.fini()
+
+    retval = 1
+    if ret.get('status') in (s_health.NOMINAL, s_health.DEGRADED):
+        retval = 0
+
+    outp.printf(serialize(ret))
+    return retval
+
+def getArgParser(outp):
+    desc = '''
+    synapse healthcheck tool
+    '''
+    pars = s_cmd.Parser(prog='synapse.tools.service.healthcheck', outp=outp, description=desc)
+    pars.add_argument('--cell', '-c', required=True, type=str,
+                      help='Telepath path to the cell to check.')
+    pars.add_argument('--timeout', '-t', default=10, type=float,
+                      help='Connection and call timeout')
+    return pars
+
+if __name__ == '__main__':  # pragma: no cover
+    s_cmd.exitmain(main)

synapse/tools/service/livebackup.py

@@ -0,0 +1,34 @@
+import synapse.telepath as s_telepath
+
+import synapse.lib.cmd as s_cmd
+import synapse.lib.output as s_output
+
+descr = '''
+Generate a new backup of a running Synapse service.
+
+Examples:
+
+    # Generate a backup from inside a Synapse service container
+    python -m synapse.tools.service.livebackup
+
+'''
+
+async def main(argv, outp=s_output.stdout):
+
+    pars = s_cmd.Parser(prog='synapse.tools.service.livebackup', outp=outp, description=descr)
+
+    pars.add_argument('--url', default='cell:///vertex/storage', help='The telepath URL of the Synapse service.')
+    pars.add_argument('--name', default=None, help='Specify a name for the backup.  Defaults to an automatically generated timestamp.')
+
+    opts = pars.parse_args(argv)
+
+    async with s_telepath.withTeleEnv():
+
+        async with await s_telepath.openurl(opts.url) as cell:
+            outp.printf(f'Running backup of: {opts.url}')
+            name = await cell.runBackup(name=opts.name)
+            outp.printf(f'...backup created: {name}')
+    return 0
+
+if __name__ == '__main__':  # pragma: no cover
+    s_cmd.exitmain(main)

synapse/tools/service/modrole.py

@@ -0,0 +1,116 @@
+import synapse.common as s_common
+import synapse.telepath as s_telepath
+
+import synapse.lib.cmd as s_cmd
+import synapse.lib.output as s_output
+
+descr = '''
+Add or modify a role in a Synapse service.
+'''
+
+def printrole(role, outp):
+
+    outp.printf(f'Role: {role.get("name")} ({role.get("iden")})')
+    outp.printf('')
+    outp.printf('  Rules:')
+    for indx, rule in enumerate(role.get('rules')):
+        outp.printf(f'    [{str(indx).ljust(3)}] - {s_common.reprauthrule(rule)}')
+
+    outp.printf('')
+    outp.printf('  Gates:')
+    for gateiden, gateinfo in role.get('authgates', {}).items():
+        outp.printf(f'    {gateiden}')
+        outp.printf(f'      Admin: {gateinfo.get("admin") == True}')
+        for indx, rule in enumerate(gateinfo.get('rules', ())):
+            outp.printf(f'      [{str(indx).ljust(3)}] - {s_common.reprauthrule(rule)}')
+
+async def main(argv, outp=s_output.stdout):
+
+    pars = s_cmd.Parser(prog='synapse.tools.service.modrole', outp=outp, description=descr)
+    pars.add_argument('--svcurl', default='cell:///vertex/storage', help='The telepath URL of the Synapse service.')
+    pars.add_argument('--add', default=False, action='store_true', help='Add the role if they do not already exist.')
+    pars.add_argument('--del', dest='delete', default=False, action='store_true', help='Delete the role if it exists.')
+    pars.add_argument('--list', default=False, action='store_true',
+                      help='List existing roles, or rules of a specific role.')
+    pars.add_argument('--allow', default=[], action='append', help='A permission string to allow for the role.')
+    pars.add_argument('--deny', default=[], action='append', help='A permission string to deny for the role.')
+    pars.add_argument('--gate', default=None, help='The iden of an auth gate to add/del rules on.')
+    pars.add_argument('rolename', nargs='?', help='The rolename to add/edit.')
+
+    opts = pars.parse_args(argv)
+
+    if opts.add and opts.delete:
+        outp.printf('ERROR: Cannot specify --add and --del together.')
+        return 1
+
+    async with s_telepath.withTeleEnv():
+
+        async with await s_telepath.openurl(opts.svcurl) as cell:
+
+            if opts.list:
+                if opts.rolename:
+                    role = await cell.getRoleDefByName(opts.rolename)
+                    if role is None:
+                        outp.printf(f'ERROR: Role not found: {opts.rolename}')
+                        return 1
+
+                    printrole(role, outp)
+
+                else:
+                    outp.printf('Roles:')
+                    for role in await cell.getRoleDefs():
+                        outp.printf(f'  {role.get("iden")} - {role.get("name")}')
+
+                return 0
+            elif opts.rolename is None:
+                outp.printf(f'ERROR: A rolename argument is required when --list is not specified.')
+                return 1
+
+            if opts.gate:
+                gate = await cell.getAuthGate(opts.gate)
+                if gate is None:
+                    outp.printf(f'ERROR: No auth gate found with iden: {opts.gate}')
+                    return 1
+
+            role = await cell.getRoleDefByName(opts.rolename)
+            if role is not None:
+                outp.printf(f'Modifying role: {opts.rolename}')
+
+            if role is None:
+                if not opts.add:
+                    outp.printf(f'ERROR: Role not found (need --add?): {opts.rolename}')
+                    return 1
+
+                outp.printf(f'Adding role: {opts.rolename}')
+                role = await cell.addRole(opts.rolename)
+
+            roleiden = role.get('iden')
+
+            if opts.delete:
+                outp.printf(f'...deleting role: {opts.rolename}')
+                await cell.delRole(roleiden)
+                return 0
+
+            for allow in opts.allow:
+                perm = allow.lower().split('.')
+                mesg = f'...adding allow rule: {allow}'
+                if opts.gate:
+                    mesg += f' on gate {opts.gate}'
+
+                outp.printf(mesg)
+                if not await cell.isRoleAllowed(roleiden, perm, gateiden=opts.gate):
+                    await cell.addRoleRule(roleiden, (True, perm), indx=0, gateiden=opts.gate)
+
+            for deny in opts.deny:
+                perm = deny.lower().split('.')
+                mesg = f'...adding deny rule: {deny}'
+                if opts.gate:
+                    mesg += f' on gate {opts.gate}'
+
+                outp.printf(mesg)
+                if await cell.isRoleAllowed(roleiden, perm, gateiden=opts.gate):
+                    await cell.addRoleRule(roleiden, (False, perm), indx=0, gateiden=opts.gate)
+    return 0
+
+if __name__ == '__main__':  # pragma: no cover
+    s_cmd.exitmain(main)

synapse/tools/service/moduser.py

@@ -0,0 +1,184 @@
+import synapse.common as s_common
+import synapse.telepath as s_telepath
+
+import synapse.lib.cmd as s_cmd
+import synapse.lib.output as s_output
+
+descr = '''
+Add, modify, or list users of a Synapse service.
+'''
+
+def printuser(user, outp):
+
+    outp.printf(f'User: {user.get("name")} ({user.get("iden")})')
+    outp.printf('')
+    outp.printf(f'  Locked: {user.get("locked")}')
+    outp.printf(f'  Admin: {user.get("admin")}')
+    outp.printf(f'  Email: {user.get("email")}')
+    outp.printf('  Rules:')
+    for indx, rule in enumerate(user.get('rules')):
+        outp.printf(f'    [{str(indx).ljust(3)}] - {s_common.reprauthrule(rule)}')
+
+    outp.printf('')
+    outp.printf('  Roles:')
+    for role in user.get('roles'):
+        outp.printf(f'    {role.get("iden")} - {role.get("name")}')
+
+    outp.printf('')
+    outp.printf('  Gates:')
+    for gateiden, gateinfo in user.get('authgates', {}).items():
+        outp.printf(f'    {gateiden}')
+        outp.printf(f'      Admin: {gateinfo.get("admin") == True}')
+        for indx, rule in enumerate(gateinfo.get('rules', ())):
+            outp.printf(f'      [{str(indx).ljust(3)}] - {s_common.reprauthrule(rule)}')
+
+async def main(argv, outp=s_output.stdout):
+
+    pars = s_cmd.Parser(prog='synapse.tools.service.moduser', outp=outp, description=descr)
+    pars.add_argument('--svcurl', default='cell:///vertex/storage', help='The telepath URL of the Synapse service.')
+    pars.add_argument('--add', default=False, action='store_true', help='Add the user if they do not already exist.')
+    pars.add_argument('--del', dest='delete', default=False, action='store_true', help='Delete the user if they exist.')
+    pars.add_argument('--list', default=False, action='store_true',
+                      help='List existing users of the service, or details of a specific user.')
+    pars.add_argument('--admin', choices=('true', 'false'), default=None, help='Set the user admin status.')
+    pars.add_argument('--passwd', action='store', type=str, help='A password to set for the user.')
+    pars.add_argument('--email', action='store', type=str, help='An email to set for the user.')
+    pars.add_argument('--locked', choices=('true', 'false'), default=None, help='Set the user locked status.')
+    pars.add_argument('--grant', default=[], action='append', help='A role to grant to the user.')
+    pars.add_argument('--revoke', default=[], action='append', help='A role to revoke from the user.')
+    pars.add_argument('--allow', default=[], action='append', help='A permission string to allow for the user.')
+    pars.add_argument('--deny', default=[], action='append', help='A permission string to deny for the user.')
+    pars.add_argument('--gate', default=None, help='The iden of an auth gate to add/del rules or set admin status on.')
+    pars.add_argument('username', nargs='?', help='The username to add/edit or show details.')
+
+    opts = pars.parse_args(argv)
+
+    if opts.add and opts.delete:
+        outp.printf('ERROR: Cannot specify --add and --del together.')
+        return 1
+
+    async with s_telepath.withTeleEnv():
+
+        async with await s_telepath.openurl(opts.svcurl) as cell:
+
+            if opts.list:
+                if opts.username:
+                    user = await cell.getUserDefByName(opts.username)
+                    if user is None:
+                        outp.printf(f'ERROR: User not found: {opts.username}')
+                        return 1
+
+                    printuser(user, outp)
+
+                else:
+                    outp.printf('Users:')
+                    for user in await cell.getUserDefs():
+                        outp.printf(f'  {user.get("name")}')
+
+                return 0
+
+            elif opts.username is None:
+                outp.printf(f'ERROR: A username argument is required when --list is not specified.')
+                return 1
+
+            if opts.gate:
+                gate = await cell.getAuthGate(opts.gate)
+                if gate is None:
+                    outp.printf(f'ERROR: No auth gate found with iden: {opts.gate}')
+                    return 1
+
+            grants = []
+            revokes = []
+
+            for rolename in opts.grant:
+                role = await cell.getRoleDefByName(rolename)
+                if role is None:
+                    outp.printf(f'ERROR: Role not found: {rolename}')
+                    return 1
+                grants.append(role)
+
+            for rolename in opts.revoke:
+                role = await cell.getRoleDefByName(rolename)
+                if role is None:
+                    outp.printf(f'ERROR: Role not found: {rolename}')
+                    return 1
+                revokes.append(role)
+
+            user = await cell.getUserDefByName(opts.username)
+
+            if user is None:
+                if not opts.add:
+                    outp.printf(f'ERROR: User not found (need --add?): {opts.username}')
+                    return 1
+
+                outp.printf(f'Adding user: {opts.username}')
+                user = await cell.addUser(opts.username)
+
+            else:
+                outp.printf(f'Modifying user: {opts.username}')
+
+            useriden = user.get('iden')
+            if not s_common.isguid(useriden):  # pragma: no cover
+                outp.printf(f'ERROR: Invalid useriden: {useriden}')
+                return 1
+
+            if opts.delete:
+                outp.printf(f'...deleting user: {opts.username}')
+                await cell.delUser(useriden)
+                return 0
+
+            if opts.admin is not None:
+                admin = s_common.yamlloads(opts.admin)
+                mesg = f'...setting admin: {opts.admin}'
+                if opts.gate:
+                    mesg += f' on gate {opts.gate}'
+
+                outp.printf(mesg)
+                await cell.setUserAdmin(useriden, admin, gateiden=opts.gate)
+
+            if opts.locked is not None:
+                locked = s_common.yamlloads(opts.locked)
+                outp.printf(f'...setting locked: {opts.locked}')
+                await cell.setUserLocked(useriden, locked)
+
+            if opts.passwd is not None:
+                outp.printf(f'...setting passwd: {opts.passwd}')
+                await cell.setUserPasswd(useriden, opts.passwd)
+
+            if opts.email is not None:
+                outp.printf(f'...setting email: {opts.email}')
+                await cell.setUserEmail(useriden, opts.email)
+
+            for role in grants:
+                rolename = role.get('name')
+                outp.printf(f'...granting role: {rolename}')
+                await cell.addUserRole(useriden, role.get('iden'))
+
+            for role in revokes:
+                rolename = role.get('name')
+                outp.printf(f'...revoking role: {rolename}')
+                await cell.delUserRole(useriden, role.get('iden'))
+
+            for allow in opts.allow:
+                perm = allow.lower().split('.')
+                mesg = f'...adding allow rule: {allow}'
+                if opts.gate:
+                    mesg += f' on gate {opts.gate}'
+
+                outp.printf(mesg)
+                if not await cell.isUserAllowed(useriden, perm, gateiden=opts.gate):
+                    await cell.addUserRule(useriden, (True, perm), indx=0, gateiden=opts.gate)
+
+            for deny in opts.deny:
+                perm = deny.lower().split('.')
+                mesg = f'...adding deny rule: {deny}'
+                if opts.gate:
+                    mesg += f' on gate {opts.gate}'
+
+                outp.printf(mesg)
+                if await cell.isUserAllowed(useriden, perm, gateiden=opts.gate):
+                    await cell.addUserRule(useriden, (False, perm), indx=0, gateiden=opts.gate)
+    return 0
+
+if __name__ == '__main__':  # pragma: no cover
+    s_cmd.exitmain(main)

synapse/tools/service/promote.py

@@ -0,0 +1,48 @@
+import synapse.exc as s_exc
+
+import synapse.telepath as s_telepath
+
+import synapse.lib.cmd as s_cmd
+import synapse.lib.output as s_output
+import synapse.lib.urlhelp as s_urlhelp
+
+descr = '''
+Promote a mirror to the leader.
+
+Example (being run from a Cortex mirror docker container):
+    python -m synapse.tools.service.promote
+'''
+
+async def main(argv, outp=s_output.stdout):
+
+    pars = s_cmd.Parser(prog='synapse.tools.service.promote', outp=outp, description=descr)
+
+    pars.add_argument('--svcurl', default='cell:///vertex/storage',
+                      help='The telepath URL of the Synapse service.')
+
+    pars.add_argument('--failure', default=False, action='store_true',
+                      help='Promotion is due to leader being offline. Graceful handoff is not possible.')
+
+    opts = pars.parse_args(argv)
+
+    async with s_telepath.withTeleEnv():
+
+        async with await s_telepath.openurl(opts.svcurl) as cell:
+
+            graceful = not opts.failure
+
+            outp.printf(f'Promoting to leader: {opts.svcurl}')
+            try:
+                await cell.promote(graceful=graceful)
+            except s_exc.BadState as e:
+                mesg = f'Failed to promote service to being a leader; {e.get("mesg")}'
+                outp.printf(mesg)
+                return 1
+            except s_exc.SynErr as e:
+                outp.printf(f'Failed to promote service {s_urlhelp.sanitizeUrl(opts.svcurl)}: {e}')
+                return 1
+
+    return 0
+
+if __name__ == '__main__':  # pragma: no cover
+    s_cmd.exitmain(main)

synapse/tools/service/reload.py

@@ -0,0 +1,68 @@
+import synapse.telepath as s_telepath
+
+import synapse.lib.cmd as s_cmd
+import synapse.lib.output as s_output
+import synapse.lib.urlhelp as s_urlhelp
+
+descr = '''
+List or execute reload subsystems on a Synapse service.
+'''
+
+async def main(argv, outp=s_output.stdout):
+
+    pars = getArgParser(outp)
+    opts = pars.parse_args(argv)
+
+    async with s_telepath.withTeleEnv():
+
+        async with await s_telepath.openurl(opts.svcurl) as cell:
+
+            if opts.cmd == 'list':
+                names = await cell.getReloadableSystems()
+                if names:
+                    outp.printf(f'Cell at {s_urlhelp.sanitizeUrl(opts.svcurl)} has the following reload subsystems:')
+                    for name in names:
+                        outp.printf(name)
+                else:
+                    outp.printf(f'Cell at {s_urlhelp.sanitizeUrl(opts.svcurl)} has no registered reload subsystems.')
+
+            if opts.cmd == 'reload':
+                outp.printf(f'Reloading cell at {s_urlhelp.sanitizeUrl(opts.svcurl)}')
+                try:
+                    ret = await cell.reload(subsystem=opts.name)
+                except Exception as e:
+                    outp.printf(f'Error reloading cell: {e}')
+                    return 1
+
+                if not ret:
+                    outp.printf('No subsystems reloaded.')
+                else:
+                    outp.printf(f'{"Name:".ljust(40)}{"Result:".ljust(10)}Value:')
+                    for name, (isok, valu) in ret.items():
+                        if isok:
+                            mesg = str(valu)
+                            result = 'Success'
+                        else:
+                            mesg = valu[1].get('mesg')
+                            if mesg is None:
+                                mesg = valu[0]
+                            result = 'Failed'
+
+                        outp.printf(f'{name.ljust(40)}{result.ljust(10)}{mesg}')
+    return 0
+
+def getArgParser(outp):
+    pars = s_cmd.Parser(prog='synapse.tools.service.reload', outp=outp, description=descr)
+    pars.add_argument('--svcurl', default='cell:///vertex/storage', help='The telepath URL of the Synapse service.')
+
+    subpars = pars.add_subparsers(required=True,
+                                  title='subcommands',
+                                  dest='cmd',)
+    pars_list = subpars.add_parser('list', help='List subsystems which can be reloaded.')
+    reld_list = subpars.add_parser('reload', help='Reload registered subsystems.')
+    reld_list.add_argument('-n', '--name', type=str, help='Name of a subsystem to reload.')
+
+    return pars
+
+if __name__ == '__main__':  # pragma: no cover
+    s_cmd.exitmain(main)

synapse/tools/service/shutdown.py

@@ -0,0 +1,51 @@
+import synapse.exc as s_exc
+import synapse.telepath as s_telepath
+
+import synapse.lib.cmd as s_cmd
+import synapse.lib.output as s_output
+
+desc = '''
+Initiate a graceful shutdown of a service.
+
+This tool is designed to put the service into a state where
+any non-background tasks will be allowed to complete while ensuring
+no new tasks are created. Without a timeout, it can block forever if
+tasks do not exit.
+
+The command exits with code 0 if the graceful shutdown was successful and
+exit code 1 if a timeout was specified and was hit. Upon hitting the timeout
+the system resumes normal operation.
+
+NOTE: This will also demote the service if run on a leader with mirrors.
+'''
+
+async def main(argv, outp=s_output.stdout):
+
+    pars = s_cmd.Parser(prog='synapse.tools.service.shutdown', outp=outp, description=desc)
+
+    pars.add_argument('--url', default='cell:///vertex/storage',
+                        help='The telepath URL to connect to the service.')
+
+    pars.add_argument('--timeout', default=None, type=int,
+                        help='An optional timeout in seconds. If timeout is reached, the shutdown is aborted.')
+
+    opts = pars.parse_args(argv)
+
+    async with s_telepath.withTeleEnv():
+
+        try:
+
+            async with await s_telepath.openurl(opts.url) as proxy:
+
+                if await proxy.shutdown(timeout=opts.timeout):
+                    return 0
+
+                return 1
+
+        except Exception as e: # pragma: no cover
+            text = s_exc.reprexc(e)
+            outp.printf(f'Error while attempting graceful shutdown: {text}')
+            return 1
+
+if __name__ == '__main__': # pragma: no cover
+    s_cmd.exitmain(main)

synapse/tools/service/snapshot.py

@@ -0,0 +1,64 @@
+import logging
+import synapse.exc as s_exc
+import synapse.telepath as s_telepath
+
+import synapse.lib.cmd as s_cmd
+import synapse.lib.output as s_output
+
+logger = logging.getLogger(__name__)
+
+desc = '''
+Command line tool to freeze/resume service operations to allow
+system admins to generate a transactionally consistent volume
+snapshot using 3rd party tools.
+
+The use pattern should be::
+
+    python -m synapse.tools.service.snapshot freeze
+
+    <generate volume snapshot using 3rd party tools>
+
+    python -m synapse.tools.service.snapshot resume
+
+The tool will set the process exit code to 0 on success.
+'''
+
+async def main(argv, outp=s_output.stdout):
+
+    pars = s_cmd.Parser(prog='synapse.tools.service.snapshot', outp=outp, description=desc)
+
+    subs = pars.add_subparsers(required=True, title='commands', dest='cmd')
+
+    freeze = subs.add_parser('freeze', help='Suspend edits and sync changes to disk.')
+    freeze.add_argument('--timeout', type=int, default=120,
+                        help='Maximum time to wait for the nexus lock.')
+
+    freeze.add_argument('--svcurl', default='cell:///vertex/storage',
+                        help='The telepath URL of the Synapse service.')
+
+    resume = subs.add_parser('resume', help='Resume edits and continue normal operation.')
+    resume.add_argument('--svcurl', default='cell:///vertex/storage',
+                        help='The telepath URL of the Synapse service.')
+
+    opts = pars.parse_args(argv)
+
+    try:
+        async with s_telepath.withTeleEnv():
+
+            async with await s_telepath.openurl(opts.svcurl) as proxy:
+
+                if opts.cmd == 'freeze':
+                    await proxy.freeze(timeout=opts.timeout)
+                    return 0
+
+                if opts.cmd == 'resume':
+                    await proxy.resume()
+                    return 0
+
+    except s_exc.SynErr as e:
+        mesg = e.errinfo.get('mesg')
+        outp.printf(f'ERROR {e.__class__.__name__}: {mesg}')
+        return 1
+
+if __name__ == '__main__':  # pragma: no cover
+    s_cmd.exitmain(main)