synapse 2.215.0__py311-none-any.whl → 2.217.0__py311-none-any.whl

synapse/tests/test_cortex.py

@@ -8776,6 +8776,268 @@ class CortexBasicTest(s_t_utils.SynTest):
                 self.eq(core._test_pre_nexus_index, offs)
                 self.ge(core._test_post_nexus_index, core._test_pre_nexus_index)
 
+    async def test_cortex_safemode(self):
+        safemode = {'safemode': True}
+        nosafe = {'safemode': False}
+
+        # Cortex safemode disables the following functionality:
+        # - crons
+        # - triggers
+        # - dmons
+        # - storm package onloads
+        # - merge tasks (e.g. for quorum)
+        # - storm pools
+
+        # Make sure we're logging the message
+        with self.getStructuredAsyncLoggerStream('synapse.lib.cell', 'Booting cortex in safe-mode.') as stream:
+            async with self.getTestCore(conf=safemode) as core:
+                self.true(core.safemode)
+                self.true(await stream.wait(10))
+        msgs = stream.jsonlines()
+        self.len(1, msgs)
+        self.eq(msgs[0].get('message'), 'Booting cortex in safe-mode. Some functionality may be disabled.')
+        self.eq(msgs[0].get('level'), 'WARNING')
+
+        # Check crons, triggers, dmons in this section
+        with self.getTestDir() as dirn:
+
+            # Setup the cortex
+            async with self.getTestCore(dirn=dirn) as core:
+                await core.addCoreQueue('queue:safemode:done', {})
+                # Add a cron job and immediately disable it
+                q = '''
+                cron.add --minute +1 {
+                    $now = $lib.cast(time, now)
+                    $lib.log.warning(`SAFEMODE CRON: {$now}`)
+                    [ test:str=CRON :tick=$now ]
+                } |
+                $job = $lib.cron.list().0
+                cron.disable $job.iden
+                '''
+                await core.callStorm(q)
+                jobs = await core.listCronJobs()
+                self.len(1, jobs)
+                self.eq(jobs[0].get('enabled'), False)
+
+                # Add a regular trigger
+                q = '''
+                $lib.log.warning(`SAFEMODE TRIGGER: {$node}`)
+                $tick = :tick
+                $str = { [( test:str=TRIGGER :hehe=$tick )] }
+                $queue = $lib.queue.gen(queue:safemode)
+                $queue.put($tick)
+                '''
+                opts = {'vars': {'query': q}}
+                await core.callStorm(f'trigger.add prop:set --prop test:str:tick --query {{{q}}}')
+
+                # Add an async trigger
+                q = '''
+                $lib.log.warning(`SAFEMODE ATRIGGER: {$node}`)
+                $tick = :tick
+                $str = { [( test:str=ATRIGGER :hehe=$tick )] }
+                $queue = $lib.queue.gen(queue:safemode)
+                $queue.put($tick)
+                '''
+                opts = {'vars': {'query': q}}
+                await core.callStorm(f'trigger.add prop:set --prop test:str:tick --async --query {{{q}}}')
+
+                # Add a dmon
+                q = '''
+                $queue = $lib.queue.gen(queue:safemode)
+                $queue2 = $lib.queue.gen(queue:safemode:done)
+                while (true) {
+                    ($offs, $item) = $queue.get()
+                    $lib.log.warning(`SAFEMODE DMON: {$item}`)
+                    [ test:str=DMON :hehe=$item ]
+                    $queue2.put($item)
+                }
+                '''
+                await core.callStorm(f'$iden = $lib.dmon.add(${{{q}}}) $lib.dmon.start($iden)')
+
+                nodes = await core.nodes('test:str')
+                self.len(0, nodes)
+
+            # Run in safemode and verify cron, trigger, and dmons don't execute
+            with self.getLoggerStream('synapse.storm') as stream:
+                async with self.getTestCore(dirn=dirn, conf=safemode) as core:
+                    await core.callStorm('cron.enable $lib.cron.list().0.iden')
+                    # Increment the cron tick to get it to fire
+                    core.agenda._addTickOff(60)
+
+                    # Add a test:str:tick to get the trigger to fire
+                    await core.callStorm('[ test:str=newp :tick=1234 ]')
+
+                    # Check for test:strs
+                    nodes = await core.nodes('test:str')
+                    self.len(1, nodes)
+                    self.eq(nodes[0].repr(), 'newp')
+
+                    with self.raises(TimeoutError):
+                        await s_common.wait_for(core.coreQueueGet('queue:safemode:done', wait=True), timeout=2)
+
+                    # Add a dmon to make sure it doesn't start
+                    await core.addCoreQueue('queue:safemode:started', {})
+                    q = '''
+                    $queue = $lib.queue.gen(queue:safemode)
+                    $queue2 = $lib.queue.get(queue:safemode:started)
+                    while (true) {
+                        $queue2.put(foo)
+                        $lib.log.warning(`SAFEMODE DMON START`)
+                        ($offs, $item) = $queue.get()
+                    }
+                    '''
+                    await core.callStorm(f'$iden = $lib.dmon.add(${{{q}}}) $lib.dmon.start($iden)')
+
+                    with self.raises(TimeoutError):
+                        await s_common.wait_for(core.coreQueueGet('queue:safemode:started', wait=True), timeout=2)
+
+                stream.seek(0)
+                data = stream.read()
+                self.notin('SAFEMODE CRON', data)
+                self.notin('SAFEMODE TRIGGER', data)
+                self.notin('SAFEMODE ATRIGGER', data)
+                self.notin('SAFEMODE DMON', data)
+
+            with self.getLoggerStream('synapse.storm') as stream:
+                async with self.getTestCore(dirn=dirn) as core:
+                    core.agenda._addTickOff(60)
+
+                    item = await s_common.wait_for(core.coreQueueGet('queue:safemode:done', wait=True), timeout=5)
+                    self.len(2, item)
+
+                    nodes = await core.nodes('test:str')
+                    self.len(5, nodes)
+                    self.sorteq(
+                        ['newp', 'CRON', 'TRIGGER', 'DMON', 'ATRIGGER'],
+                        [k.repr() for k in nodes]
+                    )
+
+                stream.seek(0)
+                data = stream.read()
+                self.isin('SAFEMODE CRON', data)
+                self.isin('SAFEMODE TRIGGER', data)
+                self.isin('SAFEMODE ATRIGGER', data)
+                self.isin('SAFEMODE DMON', data)
+
+        # Check storm package onload handlers are not executed
+        with self.getTestDir() as dirn:
+            async with self.getTestCore(dirn=dirn, conf=safemode) as core:
+                pkgdef = {
+                    'name': 'foopkg',
+                    'version': (0, 0, 1),
+                    'onload': '$lib.import(foo.setup).onload()',
+                    'modules': (
+                        {
+                            'name': 'foo.setup',
+                            'storm': '''
+                                function onload() {
+                                    $lib.warn('foopkg onload')
+                                }
+                            ''',
+                        },
+                    )
+                }
+
+                waiter = core.waiter(1, 'core:pkg:onload:skipped')
+                await core.addStormPkg(pkgdef)
+                events = await waiter.wait(timeout=10)
+                self.nn(events)
+                self.len(1, events)
+                self.eq(events, (('core:pkg:onload:skipped', {'pkg': 'foopkg', 'reason': 'safemode'}),))
+
+            with self.getAsyncLoggerStream('synapse.cortex', 'foopkg onload output: foopkg onload') as stream:
+                async with self.getTestCore(dirn=dirn, conf=nosafe) as core:
+                    self.false(core.safemode)
+                    await stream.wait(timeout=10)
+
+        # Check merge tasks are not executed
+        with self.getTestDir() as dirn:
+            async with self.getTestCore(dirn=dirn, conf=safemode) as core:
+                alliden = core.auth.allrole.iden
+
+                blackout = await core.auth.addUser('blackout')
+                await blackout.allow(('view', 'read'))
+
+                await core.auth.rootuser.grant(alliden)
+
+                view = core.getView()
+                qnfo = {
+                    'count': 1,
+                    'roles': [alliden],
+                }
+                await view.setViewInfo('quorum', qnfo)
+
+                forkiden = (await view.fork()).get('iden')
+
+                opts = {'view': forkiden}
+
+                nodes = await core.nodes('[ test:str=fork ]', opts=opts)
+                self.len(1, nodes)
+
+                await core.callStorm('$lib.view.get().setMergeRequest()', opts=opts)
+                await core.callStorm('$lib.view.get().setMergeVote()', opts=opts | {'user': blackout.iden})
+
+                fork = core.getView(forkiden)
+
+                self.true(await fork.isMergeReady())
+                self.none(fork.mergetask)
+
+                self.len(0, await core.nodes('test:str'))
+
+            async with self.getTestCore(dirn=dirn, conf=nosafe) as core:
+                nodes = await core.nodes('test:str')
+                self.len(1, nodes)
+                self.eq(nodes[0].repr(), 'fork')
+
+        # Check storm pools are not enabled
+        async with self.getTestAha() as aha:
+
+            ahanet = aha.conf.req('aha:network')
+
+            async with await s_base.Base.anit() as base:
+
+                with self.getTestDir() as dirn:
+
+                    dirn00 = s_common.genpath(dirn, 'cell00')
+                    dirn01 = s_common.genpath(dirn, 'cell01')
+
+                    core00 = await base.enter_context(self.addSvcToAha(aha, '00.core', s_cortex.Cortex, dirn=dirn00,
+                                                                       conf=safemode))
+                    provinfo = {'mirror': 'core'}
+                    core01 = await base.enter_context(self.addSvcToAha(aha, '01.core', s_cortex.Cortex, dirn=dirn01,
+                                                                       provinfo=provinfo))
+
+                    msgs = await core01.stormlist('aha.pool.add pool00...')
+                    self.stormHasNoWarnErr(msgs)
+                    self.stormIsInPrint('Created AHA service pool: pool00.synapse', msgs)
+
+                    msgs = await core01.stormlist('aha.pool.svc.add pool00... 01.core...')
+                    self.stormHasNoWarnErr(msgs)
+                    self.stormIsInPrint('AHA service (01.core...) added to service pool (pool00.synapse)', msgs)
+
+                    msgs = await core00.stormlist('cortex.storm.pool.set --connection-timeout 1 --sync-timeout 1 aha://pool00...')
+                    self.stormHasNoWarnErr(msgs)
+                    self.stormIsInPrint('Storm pool configuration set.', msgs)
+
+                    # Make sure queries still work
+                    nodes = await core00.nodes('[ it:dev:str="stormpools!" ]', opts={'mirror': True})
+                    self.len(1, nodes)
+
+                    self.none(core00.stormpool)
+
+                    await core00.fini()
+
+                    # Now disable safemode and check that the stormpool is enabled
+                    core00 = await base.enter_context(self.getTestCore(dirn=dirn00, conf=nosafe))
+
+                    nodes = await core00.nodes('it:dev:str', opts={'mirror': True})
+                    self.len(1, nodes)
+
+                    self.nn(core00.stormpool)
+
+                    await core00.fini()
+                    await core01.fini()
+
     async def test_cortex_queue_mirror_authgates(self):
         async with self.getRegrCore('2.213.0-queue-authgates') as core:
             self.nn(await core.getAuthGate('queue:stillhere'))

synapse/tests/test_lib_auth.py

@@ -431,6 +431,8 @@ class AuthTest(s_test.SynTest):
                 await core.auth.allrole.setRules([(True, ('hehe', 'haha'), 'newp')])
             with self.raises(s_exc.SchemaViolation):
                 await core.auth.allrole.setRules([(True, )])
+            with self.raises(s_exc.SchemaViolation):
+                await core.auth.allrole.setRules([(True, '')])
 
     async def test_auth_archived_locked_interaction(self):
 

synapse/tests/test_lib_storm.py

@@ -101,7 +101,8 @@ class StormTest(s_t_utils.SynTest):
             with self.raises(s_exc.BadTypeValu):
                 await core.nodes('[ ou:org=({}) ]')
 
-            self.len(1, await core.nodes('[ ou:org=() ]'))
+            with self.raises(s_exc.BadTypeValu):
+                await core.nodes('[ ou:org=() ]')
 
             with self.raises(s_exc.BadTypeValu):
                 await core.nodes('[ ou:org=({}) ]')
@@ -293,6 +294,56 @@ class StormTest(s_t_utils.SynTest):
 
             self.len(0, await core.nodes('inet:service:platform:name=barplat'))
 
+            # Gutors work for props
+            nodes = await core.nodes('''[
+                test:str=guidprop
+                    :gprop=({'name': 'someprop', '$props': {'size': 5}})
+            ]''')
+            self.len(1, nodes)
+            node = nodes[0]
+            self.eq(node.ndef, ('test:str', 'guidprop'))
+            self.nn(node.get('gprop'))
+
+            nodes = await core.nodes('test:str=guidprop -> test:guid')
+            self.len(1, nodes)
+            node = nodes[0]
+            self.eq(node.get('name'), 'someprop')
+            self.eq(node.get('size'), 5)
+
+            with self.raises(s_exc.BadTypeValu) as cm:
+                nodes = await core.nodes('''[
+                    test:str=newpprop
+                        :gprop=({'size': 'newp'})
+                ]''')
+
+            self.eq(cm.exception.get('form'), 'test:guid')
+            self.eq(cm.exception.get('prop'), 'size')
+            self.true(cm.exception.get('mesg').startswith('Bad value for prop test:guid:size: invalid literal'))
+
+            nodes = await core.nodes('''[
+                test:str=newpprop
+                    :gprop?=({'size': 'newp'})
+            ]''')
+            self.len(1, nodes)
+            node = nodes[0]
+            self.eq(node.ndef, ('test:str', 'newpprop'))
+            self.none(node.get('gprop'))
+
+            nodes = await core.nodes('''
+                [ test:str=methset ]
+                $node.props.gprop = ({'name': 'someprop'})
+            ''')
+            self.len(1, nodes)
+            node = nodes[0]
+            self.eq(node.ndef, ('test:str', 'methset'))
+            self.nn(node.get('gprop'))
+
+            nodes = await core.nodes('test:str=methset -> test:guid')
+            self.len(1, nodes)
+            node = nodes[0]
+            self.eq(node.get('name'), 'someprop')
+            self.eq(node.get('size'), 5)
+
     async def test_lib_storm_jsonexpr(self):
         async with self.getTestCore() as core:
 

synapse/tests/test_lib_stormsvc.py

@@ -780,7 +780,7 @@ class StormSvcTest(s_test.SynTest):
                     }
                     with patchcore(core, 'setStormSvcEvents', badSetStormSvcEvents):
                         svci = await core.addStormSvc(sdef)
-                        self.true(await core.waitStormSvc('dead', timeout=6))
+                        self.true(await core.waitStormSvc('dead', timeout=12))
                         await core.delStormSvc(svci.get('iden'))
 
                     self.len(1, badiden)
@@ -792,7 +792,7 @@ class StormSvcTest(s_test.SynTest):
 
                     with patchcore(core, '_runStormSvcAdd', badRunStormSvcAdd):
                         svci = await core.addStormSvc(sdef)
-                        self.true(await core.waitStormSvc('dead', timeout=6))
+                        self.true(await core.waitStormSvc('dead', timeout=12))
                         await core.delStormSvc(svci.get('iden'))
                     self.len(1, badiden)
                     self.eq(svci.get('iden'), badiden[0])

synapse/tests/test_lib_types.py

@@ -316,6 +316,12 @@ class TypesTest(s_t_utils.SynTest):
         self.true(s_common.isguid(lnorm))
         self.eq(lnorm, tnorm)
 
+        with self.raises(s_exc.BadTypeValu) as exc:
+            model.type('guid').norm(())
+        self.eq(exc.exception.get('name'), 'guid')
+        self.eq(exc.exception.get('valu'), ())
+        self.eq(exc.exception.get('mesg'), 'Guid list values cannot be empty.')
+
     async def test_hex(self):
 
         async with self.getTestCore() as core:

synapse/tests/test_model_inet.py

@@ -1363,6 +1363,27 @@ class InetModelTest(s_t_utils.SynTest):
                 for p, v in props.items():
                     self.eq(node.get(p), v)
 
+            nodes = await core.nodes('[ inet:server=gre://::1 ]')
+            self.eq(nodes[0].get('proto'), 'gre')
+
+            nodes = await core.nodes('[ inet:server=gre://1.2.3.4 ]')
+            self.eq(nodes[0].get('proto'), 'gre')
+
+            with self.raises(s_exc.BadTypeValu) as ctx:
+                await core.nodes('[ inet:server=gre://1.2.3.4:99 ]')
+
+            self.eq(ctx.exception.get('mesg'), 'Protocol gre does not allow specifying ports.')
+
+            with self.raises(s_exc.BadTypeValu) as ctx:
+                await core.nodes('[ inet:server="gre://[::1]:99" ]')
+
+            self.eq(ctx.exception.get('mesg'), 'Protocol gre does not allow specifying ports.')
+
+            with self.raises(s_exc.BadTypeValu) as ctx:
+                await core.nodes('[ inet:server=newp://1.2.3.4:99 ]')
+
+            self.eq(ctx.exception.get('mesg'), 'inet:addr protocol must be one of: tcp,udp,icmp,host,gre')
+
     async def test_servfile(self):
         async with self.getTestCore() as core:
             valu = ('tcp://127.0.0.1:4040', 64 * 'f')
@@ -3017,6 +3038,8 @@ class InetModelTest(s_t_utils.SynTest):
             platinst = nodes[0]
             app00 = nodes[0].get('app')
 
+            self.len(1, await core.nodes('inet:service:instance:id=T2XK1223Y -> inet:service:app [ :provider=* :provider:name=vertex ] :provider -> ou:org'))
+
             q = '''
             [
                 (inet:service:account=(blackout, account, vertex, slack)

synapse/tests/test_tools_cryo_cat.py

@@ -93,14 +93,9 @@ class CryoCatTest(s_t_utils.SynTest):
             stdout.buffer = io.BytesIO()
 
             with mock.patch('sys.stdout', stdout):
-                with self.getLoggerStream('synapse.tools.cryo.cat') as stream:
-                    argv = ['--verbose', '--msgpack', '--size', '20', cryourl]
-                    retn, _ = await self.execToolMain(s_cryocat.main, argv)
-                    self.eq(0, retn)
-
-                stream.seek(0)
-                mesgs = stream.read()
-                self.isin(f'connecting to: {cryourl}', mesgs)
+                argv = ['--msgpack', '--size', '20', cryourl]
+                retn, _ = await self.execToolMain(s_cryocat.main, argv)
+                self.eq(0, retn)
 
             stdout.buffer.seek(0)
             outdata = list(msgpack.Unpacker(stdout.buffer, raw=False, use_list=False))

synapse/tests/test_tools_storm.py

@@ -62,7 +62,8 @@ class StormCliTest(s_test.SynTest):
 
             await core.addTagProp('foo', ('int', {}), {})
 
-            pars = s_t_storm.getArgParser()
+            outp = self.getTestOutp()
+            pars = s_t_storm.getArgParser(outp)
             opts = pars.parse_args(('woot',))
             self.eq('woot', opts.cortex)
             self.none(opts.view)
@@ -263,7 +264,7 @@ class StormCliTest(s_test.SynTest):
 
             url = core.getLocalUrl()
 
-            pars = s_t_storm.getArgParser()
+            pars = s_t_storm.getArgParser(self.getTestOutp())
             opts = pars.parse_args(('woot', '--view', '246e7d5dab883eb28d345a33abcdb577'))
             self.eq(opts.view, '246e7d5dab883eb28d345a33abcdb577')
 

synapse/tests/utils.py

@@ -439,6 +439,7 @@ testmodel = {
 
         ('test:guid', {}, (
             ('size', ('test:int', {}), {}),
+            ('name', ('test:str', {}), {}),
             ('tick', ('test:time', {}), {}),
             ('posneg', ('test:sub', {}), {}),
             ('posneg:isbig', ('bool', {}), {}),
@@ -459,6 +460,7 @@ testmodel = {
             ('hehe', ('str', {}), {}),
             ('ndefs', ('array', {'type': 'ndef'}), {}),
             ('somestr', ('test:str', {}), {}),
+            ('gprop', ('test:guid', {}), {}),
         )),
         ('test:strregex', {}, ()),
 

synapse/tools/aha/clone.py

@@ -1,11 +1,7 @@
-import sys
-import asyncio
-import argparse
-
 import synapse.exc as s_exc
 import synapse.telepath as s_telepath
 
-import synapse.lib.coro as s_coro
+import synapse.lib.cmd as s_cmd
 import synapse.lib.output as s_output
 
 descr = '''
@@ -19,8 +15,7 @@ Examples:
 
 async def main(argv, outp=s_output.stdout):
 
-    pars = argparse.ArgumentParser(prog='synapse.tools.aha.clone', description=descr,
-                        formatter_class=argparse.RawDescriptionHelpFormatter)
+    pars = s_cmd.Parser(prog='synapse.tools.aha.clone', outp=outp, description=descr)
 
     pars.add_argument('dnsname', help='The DNS name of the new AHA server.')
     pars.add_argument('--port', type=int, default=27492, help='The port that the new AHA server should listen on.')
@@ -49,10 +44,5 @@ async def main(argv, outp=s_output.stdout):
             outp.printf(f'ERROR: {mesg}')
             return 1
 
-async def _main(argv, outp=s_output.stdout):  # pragma: no cover
-    ret = await main(argv, outp=outp)
-    await asyncio.wait_for(s_coro.await_bg_tasks(), timeout=60)
-    return ret
-
 if __name__ == '__main__':  # pragma: no cover
-    sys.exit(asyncio.run(_main(sys.argv[1:])))
+    s_cmd.exitmain(main)

synapse/tools/aha/easycert.py

@@ -1,22 +1,15 @@
-import sys
-import asyncio
-import logging
-import argparse
-
 import cryptography.x509 as c_x509
 
 import synapse.common as s_common
 import synapse.telepath as s_telepath
 
-import synapse.lib.coro as s_coro
+import synapse.lib.cmd as s_cmd
 import synapse.lib.output as s_output
 import synapse.lib.certdir as s_certdir
 
 
-logger = logging.getLogger(__name__)
-
 async def main(argv, outp=s_output.stdout):
-    pars = getArgParser()
+    pars = getArgParser(outp)
     opts = pars.parse_args(argv)
 
     if opts.network:
@@ -56,9 +49,9 @@ async def main(argv, outp=s_output.stdout):
                 cdir.delUserCsr(name, outp=outp)
                 return 0
 
-def getArgParser():
+def getArgParser(outp):
     desc = 'CLI tool to generate simple x509 certificates from an Aha server.'
-    pars = argparse.ArgumentParser(prog='synapse.tools.aha.easycert', description=desc)
+    pars = s_cmd.Parser(prog='synapse.tools.aha.easycert', outp=outp, description=desc)
 
     pars.add_argument('-a', '--aha', required=True,  # type=str,
                       help='Aha server to connect too.')
@@ -77,11 +70,5 @@ def getArgParser():
 
     return pars
 
-async def _main(argv, outp=s_output.stdout):  # pragma: no cover
-    s_common.setlogging(logger, 'WARNING')
-    ret = await main(argv, outp=outp)
-    await asyncio.wait_for(s_coro.await_bg_tasks(), timeout=60)
-    return ret
-
 if __name__ == '__main__':  # pragma: no cover
-    sys.exit(asyncio.run(_main(sys.argv[1:])))
+    s_cmd.exitmain(main)

synapse/tools/aha/enroll.py

@@ -1,12 +1,9 @@
 import os
-import sys
-import asyncio
-import argparse
 
 import synapse.common as s_common
 import synapse.telepath as s_telepath
 
-import synapse.lib.coro as s_coro
+import synapse.lib.cmd as s_cmd
 import synapse.lib.output as s_output
 import synapse.lib.certdir as s_certdir
 import synapse.lib.msgpack as s_msgpack
@@ -22,9 +19,7 @@ Examples:
 
 async def main(argv, outp=s_output.stdout):
 
-    pars = argparse.ArgumentParser(prog='synapse.tools.aha.enroll', description=descr,
-                        formatter_class=argparse.RawDescriptionHelpFormatter)
-
+    pars = s_cmd.Parser(prog='synapse.tools.aha.enroll', outp=outp, description=descr)
     pars.add_argument('onceurl', help='The one-time use AHA user enrollment URL.')
     opts = pars.parse_args(argv)
 
@@ -103,10 +98,6 @@ async def main(argv, outp=s_output.stdout):
 
     return 0
 
-async def _main(argv, outp=s_output.stdout):  # pragma: no cover
-    ret = await main(argv, outp=outp)
-    await asyncio.wait_for(s_coro.await_bg_tasks(), timeout=60)
-    return ret
 
 if __name__ == '__main__':  # pragma: no cover
-    sys.exit(asyncio.run(_main(sys.argv[1:])))
+    s_cmd.exitmain(main)

synapse/tools/aha/list.py

@@ -1,17 +1,10 @@
-import sys
-import asyncio
-import logging
-
 import synapse.exc as s_exc
-import synapse.common as s_common
 import synapse.telepath as s_telepath
 
-import synapse.lib.coro as s_coro
+import synapse.lib.cmd as s_cmd
 import synapse.lib.output as s_output
 import synapse.lib.version as s_version
 
-logger = logging.getLogger(__name__)
-
 reqver = '>=2.11.0,<3.0.0'
 
 async def main(argv, outp=s_output.stdout):
@@ -74,11 +67,5 @@ async def main(argv, outp=s_output.stdout):
                 outp.printf(mesg)
             return 0
 
-async def _main(argv, outp=s_output.stdout):  # pragma: no cover
-    s_common.setlogging(logger, 'WARNING')
-    ret = await main(argv, outp=outp)
-    await asyncio.wait_for(s_coro.await_bg_tasks(), timeout=60)
-    return ret
-
 if __name__ == '__main__':  # pragma: no cover
-    sys.exit(asyncio.run(_main(sys.argv[1:])))
+    s_cmd.exitmain(main)

synapse/tools/aha/mirror.py

@@ -1,14 +1,9 @@
-import sys
-import asyncio
-import argparse
-
 import synapse.exc as s_exc
 import synapse.common as s_common
 import synapse.telepath as s_telepath
 
-import synapse.lib.coro as s_coro
+import synapse.lib.cmd as s_cmd
 import synapse.lib.output as s_output
-import synapse.lib.version as s_version
 
 descr = '''
 Query the Aha server for the service cluster status of mirrors.
@@ -87,8 +82,7 @@ def timeout_type(valu):
 
 async def main(argv, outp=s_output.stdout):
 
-    pars = argparse.ArgumentParser(prog='synapse.tools.aha.mirror', description=descr,
-                        formatter_class=argparse.RawDescriptionHelpFormatter)
+    pars = s_cmd.Parser(prog='synapse.tools.aha.mirror', outp=outp, description=descr)
 
     pars.add_argument('--url', default='cell:///vertex/storage', help='The telepath URL to connect to the AHA service.')
     pars.add_argument('--timeout', type=timeout_type, default=10, help='The timeout in seconds for individual service API calls')
@@ -192,10 +186,5 @@ async def main(argv, outp=s_output.stdout):
             outp.printf(f'ERROR: {mesg}')
             return 1
 
-async def _main(argv, outp=s_output.stdout):  # pragma: no cover
-    ret = await main(argv, outp=outp)
-    await asyncio.wait_for(s_coro.await_bg_tasks(), timeout=60)
-    return ret
-
 if __name__ == '__main__':  # pragma: no cover
-    sys.exit(asyncio.run(_main(sys.argv[1:])))
+    s_cmd.exitmain(main)