synapse 2.209.0__py311-none-any.whl → 2.210.0__py311-none-any.whl

synapse/tests/test_lib_json.py

@@ -1,7 +1,7 @@
 import io
 import json
 
-import orjson
+import yyjson
 
 import synapse.exc as s_exc
 import synapse.common as s_common
@@ -44,9 +44,9 @@ class JsonTest(s_test.SynTest):
         inval = '{"a": "😀\ud83d\ude47"}'
         outval = {'a': '😀\ud83d\ude47'}
 
-        # orjson.dumps fails because of the surrogate pairs
-        with self.raises(orjson.JSONDecodeError):
-            orjson.loads(inval)
+        # yyjson.loads fails because of the surrogate pairs
+        with self.raises(ValueError):
+            yyjson.loads(inval)
 
         # stdlib json.loads passes because of voodoo magic
         self.eq(outval, json.loads(inval))
@@ -63,9 +63,9 @@ class JsonTest(s_test.SynTest):
         inval = {'a': '😀\ud83d\ude47'}
         outval = b'{"a": "\\ud83d\\ude00\\ud83d\\ude47"}'
 
-        # orjson.dumps fails because of the surrogate pairs
-        with self.raises(TypeError):
-            orjson.dumps(inval)
+        # yyjson.dumps fails because of the surrogate pairs
+        with self.raises(UnicodeEncodeError):
+            yyjson.dumps(inval)
 
         # stdlib json.dumps passes because of voodoo magic
         self.eq(outval.decode(), json.dumps(inval))
@@ -85,15 +85,15 @@ class JsonTest(s_test.SynTest):
 
         with self.raises(s_exc.MustBeJsonSafe) as exc:
             s_json.dumps({}.items())
-        self.eq(exc.exception.get('mesg'), 'Type is not JSON serializable: dict_items')
+        self.eq(exc.exception.get('mesg'), "TypeError: Object of type 'dict_items' is not JSON serializable")
 
         with self.raises(s_exc.MustBeJsonSafe) as exc:
             s_json.dumps({1: 'foo'})
-        self.eq(exc.exception.get('mesg'), 'Dict key must be str')
+        self.eq(exc.exception.get('mesg'), "TypeError: Dictionary keys must be strings")
 
         with self.raises(s_exc.MustBeJsonSafe) as exc:
             s_json.dumps({'\ud83d\ude47': {}.items()})
-        self.eq(exc.exception.get('mesg'), 'Object of type dict_items is not JSON serializable')
+        self.eq(exc.exception.get('mesg'), "TypeError: Dictionary keys must be strings")
 
         self.eq(b'"dict_items([])"', s_json.dumps({}.items(), default=str))
 
@@ -111,6 +111,20 @@ class JsonTest(s_test.SynTest):
         s_json.dump({'c': 'd', 'a': 'b'}, buf)
         self.eq(b'{"c":"d","a":"b"}', buf.getvalue())
 
+    async def test_lib_json_large_integers(self):
+        valu = [
+            1, 2,
+            -1, -2,
+            1.0, 2.0,
+            -1.0, -2.0,
+            2**63, -2**63, -2**63 - 1,
+            2**64, -2**64, 2**64 + 1,
+            2**128, 2**128 + 1,
+            -2**128, -2**128 - 1,
+        ]
+
+        self.eq(valu, s_json.loads(s_json.dumps(valu)))
+
     async def test_jsload(self):
         with self.getTestDir() as dirn:
             with s_common.genfile(dirn, 'jsload.json') as fp:
@@ -147,41 +161,52 @@ class JsonTest(s_test.SynTest):
 
         buf = io.BytesIO()
 
+        msg = "Object of type '_io.BytesIO' is not JSON serializable"
         with self.raises(s_exc.MustBeJsonSafe) as exc:
             s_json.reqjsonsafe(buf)
-        self.isin('Type is not JSON serializable: _io.BytesIO', exc.exception.get('mesg'))
+        self.isin(msg, exc.exception.get('mesg'))
 
         with self.raises(s_exc.MustBeJsonSafe) as exc:
             s_json.reqjsonsafe({'foo': buf})
-        self.isin('Type is not JSON serializable: _io.BytesIO', exc.exception.get('mesg'))
+        self.isin(msg, exc.exception.get('mesg'))
 
         with self.raises(s_exc.MustBeJsonSafe) as exc:
             s_json.reqjsonsafe(['foo', buf])
-        self.isin('Type is not JSON serializable: _io.BytesIO', exc.exception.get('mesg'))
+        self.isin(msg, exc.exception.get('mesg'))
 
         items = (
             (None, None),
             (1234, None),
             ('1234', None),
+            ('1234"', None),
             ({'asdf': 'haha'}, None),
             ({'a': (1,), 'b': [{'': 4}, 56, None, {'t': True, 'f': False}, 'oh my']}, None),
             (b'1234', s_exc.MustBeJsonSafe),
+            (b'1234"', s_exc.MustBeJsonSafe),
+            ({'a': float('nan')}, s_exc.MustBeJsonSafe),
             ({'a': 'a', 2: 2}, s_exc.MustBeJsonSafe),
             ({'a', 'b', 'c'}, s_exc.MustBeJsonSafe),
             (s_common.novalu, s_exc.MustBeJsonSafe),
         )
         for (item, eret) in items:
             if eret is None:
-                self.none(s_json.reqjsonsafe(item))
+                self.none(s_json.reqjsonsafe(item), msg=item)
             else:
                 with self.raises(eret):
                     s_json.reqjsonsafe(item)
 
-        text = '😀\ud83d\ude47'
+        for text in ['😀', 'asdf', 'asdf"', '"asdf']:
+            s_json.reqjsonsafe(text)
+
+        text = ['😀\ud83d\ude47']
         s_json.reqjsonsafe(text)
         with self.raises(s_exc.MustBeJsonSafe) as exc:
             s_json.reqjsonsafe(text, strict=True)
-        self.eq(exc.exception.get('mesg'), 'str is not valid UTF-8: surrogates not allowed')
+        self.eq(exc.exception.get('mesg'), "'utf-8' codec can't encode characters in position 1-2: surrogates not allowed")
+
+        with self.raises(s_exc.MustBeJsonSafe) as exc:
+            s_json.reqjsonsafe(b'1234', strict=True)
+        self.eq(exc.exception.get('mesg'), 'Object of type bytes is not JSON serializable')
 
     async def test_lib_json_data_at_rest(self):
         async with self.getRegrCore('json-data') as core:

synapse/tests/test_model_entity.py

@@ -0,0 +1,21 @@
+import synapse.tests.utils as s_test
+
+class EntityModelTest(s_test.SynTest):
+
+    async def test_entity_relationship(self):
+
+        async with self.getTestCore() as core:
+
+            nodes = await core.nodes('''[
+                entity:relationship=*
+                    :type=tasks
+                    :period=(2022, ?)
+                    :source={[ ou:org=({"name": "China Ministry of State Security (MSS)"}) ]}
+                    :target={[ risk:threat=({"org:name": "APT34", "reporter:name": "vertex"}) ]}
+            ]''')
+
+            self.len(1, nodes)
+            self.eq(nodes[0].get('type'), 'tasks.')
+            self.eq(nodes[0].get('period'), (1640995200000, 9223372036854775807))
+            self.eq(nodes[0].get('source'), ('ou:org', '3332a704ed21dc3274d5731acc54a0ee'))
+            self.eq(nodes[0].get('target'), ('risk:threat', 'e15738ebae52273300b51c08eaad3a36'))

synapse/tests/test_model_gov_intl.py

@@ -1,6 +1,6 @@
-from synapse.tests.utils import SynTest
+import synapse.tests.utils as s_t_utils
 
-class IntlGovTest(SynTest):
+class IntlGovTest(s_t_utils.SynTest):
 
     async def test_models_intl(self):
 

synapse/tests/test_model_inet.py

@@ -3164,6 +3164,7 @@ class InetModelTest(s_t_utils.SynTest):
                 :creator=$visiiden
                 :platform=$platiden
                 :instance=$instiden
+                :topic=' My Topic   '
             ]
             '''
             opts = {'vars': {
@@ -3175,6 +3176,7 @@ class InetModelTest(s_t_utils.SynTest):
             self.len(1, nodes)
             self.eq(nodes[0].ndef, ('inet:service:channel', s_common.guid(('general', 'channel', 'vertex', 'slack'))))
             self.eq(nodes[0].get('name'), 'general')
+            self.eq(nodes[0].get('topic'), 'my topic')
             self.eq(nodes[0].get('period'), (1420070400000, 9223372036854775807))
             self.eq(nodes[0].get('creator'), visiacct.ndef[1])
             self.eq(nodes[0].get('platform'), platform.ndef[1])
@@ -3243,12 +3245,18 @@ class InetModelTest(s_t_utils.SynTest):
                     :group=$devsiden
                     :public=$lib.false
                     :repost=*
+                    :mentions=(
+                        (inet:service:group, $devsiden),
+                        (inet:service:account, $blckiden),
+                        (inet:service:account, $blckiden),
+                    )
                 )
 
                 (inet:service:message=(blackout, visi, 1715856900000, vertex, slack)
                     :type=chat.direct
                     :to=$visiiden
                     :public=$lib.false
+                    :mentions?=((inet:service:message:attachment, $atchiden),)
                 )
 
                 (inet:service:message=(blackout, general, 1715856900000, vertex, slack)
@@ -3296,10 +3304,15 @@ class InetModelTest(s_t_utils.SynTest):
             self.eq(nodes[0].get('group'), devsgrp.ndef[1])
             self.false(nodes[0].get('public'))
             self.eq(nodes[0].get('type'), 'chat.group.')
+            self.eq(
+                nodes[0].get('mentions'),
+                (('inet:service:account', blckacct.ndef[1]), ('inet:service:group', devsgrp.ndef[1]))
+            )
 
             self.eq(nodes[1].get('to'), visiacct.ndef[1])
             self.false(nodes[1].get('public'))
             self.eq(nodes[1].get('type'), 'chat.direct.')
+            self.none(nodes[1].get('mentions'))
 
             self.eq(nodes[2].get('channel'), gnrlchan.ndef[1])
             self.true(nodes[2].get('public'))
@@ -3397,6 +3410,7 @@ class InetModelTest(s_t_utils.SynTest):
             q = '''
             [ inet:service:message=(visi, says, relax)
                 :title="Hehe Haha"
+                :hashtags="#hehe,#haha,#hehe"
                 :thread={[
                     inet:service:thread=*
                         :title="Woot  Woot"
@@ -3410,6 +3424,7 @@ class InetModelTest(s_t_utils.SynTest):
             '''
             nodes = await core.nodes(q)
             self.len(1, nodes)
+            self.eq(['#haha', '#hehe'], nodes[0].get('hashtags'))
             self.len(1, await core.nodes('inet:service:message=(visi, says, hello) -> inet:service:thread:message'))
             self.len(1, await core.nodes('''
                 inet:service:message:title="hehe haha"

synapse/tests/test_model_media.py

@@ -1,5 +1,6 @@
 import logging
 
+import synapse.exc as s_exc
 import synapse.common as s_common
 
 import synapse.tests.utils as s_t_utils

synapse/tests/test_model_person.py

@@ -151,6 +151,10 @@ class PsModelTest(s_t_utils.SynTest):
                 'users': ('visi', 'invisigoth'),
                 'crypto:address': 'btc/1BvBMSEYstWetqTFn5Au4m4GFg7xJaNVN2',
                 'langs': (lang00 := s_common.guid(),),
+                'banner': file0,
+                'passwd': 'hunter2',
+                'website': 'https://blogs.vertex.link/brutus',
+                'websites': ('https://foo.com', 'https://bar.com', 'https://foo.com'),
             }
             opts = {'vars': {'valu': con0, 'p': props}}
             q = '''[(ps:contact=$valu
@@ -172,6 +176,10 @@ class PsModelTest(s_t_utils.SynTest):
                     :death:place=$p."death:place" :death:place:loc=$p."death:place:loc"
                     :death:place:name=$p."death:place:name"
                     :service:accounts=(*, *) :langs=$p.langs
+                    :banner=$p.banner
+                    :passwd=$p.passwd
+                    :website=$p.website
+                    :websites=$p.websites
                         )]'''
             nodes = await core.nodes(q, opts=opts)
             self.len(1, nodes)
@@ -215,6 +223,10 @@ class PsModelTest(s_t_utils.SynTest):
             self.eq(node.get('death:place:loc'), 'us.va.reston')
             self.eq(node.get('birth:place:name'), 'reston, va, usa, earth, sol, milkyway')
             self.eq(node.get('death:place:name'), 'reston, va, usa, earth, sol, milkyway')
+            self.eq(node.get('banner'), file0)
+            self.eq(node.get('passwd'), 'hunter2')
+            self.eq(node.get('website'), 'https://blogs.vertex.link/brutus')
+            self.eq(node.get('websites'), ('https://bar.com', 'https://foo.com'))
             self.len(1, await core.nodes('ps:contact :birth:place -> geo:place'))
             self.len(1, await core.nodes('ps:contact :death:place -> geo:place'))
             self.len(2, await core.nodes('ps:contact :service:accounts -> inet:service:account'))

synapse/tests/test_telepath.py

@@ -1,16 +1,16 @@
 import os
 import ssl
+import sys
 import socket
 import asyncio
 import logging
-import threading
+import multiprocessing
 
 from unittest import mock
 
 import cryptography.hazmat.primitives.hashes as c_hashes
 
 import synapse.exc as s_exc
-import synapse.glob as s_glob
 import synapse.common as s_common
 import synapse.daemon as s_daemon
 import synapse.telepath as s_telepath
@@ -189,6 +189,40 @@ class TeleAuth(s_telepath.Aware):
     def getFooBar(self, x, y):
         return x + y
 
+def run_telepath_sync_genr_break(url: str,
+                      evt1: multiprocessing.Event,
+                      evt2: multiprocessing.Event,):
+    '''
+    This is a Process target.
+    '''
+    with s_telepath.openurl(url) as prox:
+        form = 'test:int'
+
+        q = '[' + ' '.join([f'{form}={i}' for i in range(10)]) + ' ]'
+
+        # This puts a link into the link pool
+        emesg = 12
+        msgs = list(prox.storm(q, opts={'show': ('node', 'nodeedits')}))
+        assert len(msgs) == emesg, f'Got {len(msgs)} messages, expected {emesg}'
+
+        # Get the link from the pool, add the fini callback and put it back
+        # This involves reaching into the proxy internals to do so.
+        link = prox.links.popleft()
+        link.onfini(evt1.set)
+        prox.links.append(link)
+
+        # Break from the generator right away, causing a
+        # GeneratorExit in the GenrHelp object __iter__ method.
+        mesg = None
+        for mesg in prox.storm(q):
+            break
+        # Ensure the query did yield an object
+        assert mesg is not None, 'mesg was not recieved!'
+        assert link.isfini is True, 'link.fini was not set to true'
+
+        evt2.set()
+        sys.exit(137)
+
 class TeleTest(s_t_utils.SynTest):
 
     async def test_telepath_basics(self):
@@ -296,47 +330,20 @@ class TeleTest(s_t_utils.SynTest):
             async with await s_telepath.openurl('tcp://127.0.0.1/foo', port=dmon.addr[1]) as prox:
                 self.eq((10, 20, 30), await s_coro.executor(sync))
 
-    def test_telepath_sync_genr_break(self):
-
-        try:
-            acm = self.getTestCoreAndProxy()
-            core, proxy = s_glob.sync(acm.__aenter__())
-
-            form = 'test:int'
-
-            q = '[' + ' '.join([f'{form}={i}' for i in range(10)]) + ' ]'
-
-            # This puts a link into the link pool
-            msgs = list(proxy.storm(q, opts={'show': ('node',)}))
-            self.len(12, msgs)
+    async def test_telepath_sync_genr_break(self):
+        async with self.getTestCore() as core:
+            url = core.getLocalUrl()
 
-            evt = threading.Event()
+            ctx = multiprocessing.get_context('spawn')
+            evt1 = ctx.Event()
+            evt2 = ctx.Event()
+            proc = ctx.Process(target=run_telepath_sync_genr_break, args=(url, evt1, evt2))
+            proc.start()
 
-            # Get the link from the pool, add the fini callback and put it back
-            link = s_glob.sync(proxy.getPoolLink())
-            link.onfini(evt.set)
-            s_glob.sync(proxy._putPoolLink(link))
-
-            # Grab the fresh link from the pool so our original link is up next again
-            link2 = s_glob.sync(proxy.getPoolLink())
-            s_glob.sync(proxy._putPoolLink(link2))
-
-            q = f'{form} | sleep 0.1'
-
-            # Break from the generator right away, causing a
-            # GeneratorExit in the GenrHelp object __iter__ method.
-            mesg = None
-            for mesg in proxy.storm(q):
-                break
-            # Ensure the query did yield an object
-            self.nn(mesg)
-
-            # Ensure the link we have a reference too was torn down
-            self.true(evt.wait(4))
-            self.true(link.isfini)
-
-        finally:
-            s_glob.sync(acm.__aexit__(None, None, None))
+            self.true(await s_coro.executor(evt1.wait, timeout=30))
+            self.true(await s_coro.executor(evt2.wait, timeout=30))
+            proc.join(timeout=30)
+            self.eq(proc.exitcode, 137)
 
     async def test_telepath_no_sess(self):
 
@@ -1016,6 +1023,10 @@ class TeleTest(s_t_utils.SynTest):
                 self.len(1, await wait.wait(timeout=5))
                 self.len(12, prox.links)
 
+                # Cleanup our global state
+                prox2._all_proxies.remove(prox2)
+                await prox.fini()
+
     async def test_link_fini_breaking_tasks(self):
         foo = Foo()
 

synapse/tests/test_tools_aha.py

@@ -38,7 +38,7 @@ class AhaToolsTest(s_t_utils.SynTest):
                     self.true(await waiter.wait(timeout=6))
 
                     argv = [ahaurl]
-                    retn, outp = await self.execToolMain(s_a_list._main, argv)
+                    retn, outp = await self.execToolMain(s_a_list.main, argv)
                     self.eq(retn, 0)
 
                     outp.expect('''
@@ -48,7 +48,7 @@ class AhaToolsTest(s_t_utils.SynTest):
                     ''', whitespace=False)
 
                     argv = [ahaurl, 'demo.net']
-                    retn, outp = await self.execToolMain(s_a_list._main, argv)
+                    retn, outp = await self.execToolMain(s_a_list.main, argv)
                     self.eq(retn, 0)
                     outp.expect('Service              network', whitespace=False)
                     outp.expect('cell0                demo.net', whitespace=False)
@@ -56,7 +56,7 @@ class AhaToolsTest(s_t_utils.SynTest):
         async with self.getTestCore() as core:
             curl = core.getLocalUrl()
             argv = [curl]
-            retn, outp = await self.execToolMain(s_a_list._main, argv)
+            retn, outp = await self.execToolMain(s_a_list.main, argv)
             self.eq(1, retn)
             outp.expect(f'Service at {curl} is not an Aha server')
 
@@ -67,18 +67,17 @@ class AhaToolsTest(s_t_utils.SynTest):
                                          'dmon:listen': ephemeral_address}) as aha:
             _, port = aha.sockaddr
             ahaurl = f'tcp://root:root@127.0.0.1:{port}'
-
-            with self.getTestDir() as dirn:
+            with self.getTestSynDir() as syndir, self.getTestDir() as dirn:
                 argvbase = ['-a', ahaurl, '--certdir', dirn]
                 argv = argvbase + ['--ca', 'demo.net']
-                retn, outp = await self.execToolMain(s_a_easycert._main, argv)
+                retn, outp = await self.execToolMain(s_a_easycert.main, argv)
                 self.eq(retn, 0)
                 outp.expect('Saved CA cert')
                 outp.expect('cas/demo.net.crt')
 
                 argv = argvbase + ['--server', '--server-sans', 'DNS:beeper.demo.net,DNS:booper.demo.net',
                                    '--network', 'demo.net', 'beep.demo.net']
-                retn, outp = await self.execToolMain(s_a_easycert._main, argv)
+                retn, outp = await self.execToolMain(s_a_easycert.main, argv)
                 self.eq(retn, 0)
                 outp.expect('key saved')
                 outp.expect('hosts/beep.demo.net.key')
@@ -86,7 +85,7 @@ class AhaToolsTest(s_t_utils.SynTest):
                 outp.expect('hosts/beep.demo.net.crt')
 
                 argv = argvbase + ['--network', 'demo.net', 'mallory@demo.net']
-                retn, outp = await self.execToolMain(s_a_easycert._main, argv)
+                retn, outp = await self.execToolMain(s_a_easycert.main, argv)
                 self.eq(retn, 0)
                 outp.expect('key saved')
                 outp.expect('users/mallory@demo.net.key')

synapse/tests/utils.py

@@ -864,7 +864,7 @@ class HttpReflector(s_httpapi.Handler):
             for k, items in self.request.arguments.items():
                 for v in items:
                     d[k].append(v.decode())
-        return d
+        return dict(d)
 
     async def get(self):
         resp = {}

synapse/tools/aha/clone.py

@@ -5,6 +5,7 @@ import argparse
 import synapse.exc as s_exc
 import synapse.telepath as s_telepath
 
+import synapse.lib.coro as s_coro
 import synapse.lib.output as s_output
 
 descr = '''
@@ -48,5 +49,10 @@ 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:])))
+    sys.exit(asyncio.run(_main(sys.argv[1:])))

synapse/tools/aha/easycert.py

@@ -8,13 +8,14 @@ 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.output as s_output
 import synapse.lib.certdir as s_certdir
 
 
 logger = logging.getLogger(__name__)
 
-async def _main(argv, outp):
+async def main(argv, outp=s_output.stdout):
     pars = getArgParser()
     opts = pars.parse_args(argv)
 
@@ -22,36 +23,36 @@ async def _main(argv, outp):
         s_common.deprecated('--network option.', curv='v2.206.0')
 
     cdir = s_certdir.CertDir(path=opts.certdir)
-
-    async with await s_telepath.openurl(opts.aha) as prox:
-
-        name = opts.name
-
-        if opts.ca:
-            # A User may only have get permissions; so try get first
-            # before attempting to generate a new CA.
-            certbyts = await prox.getCaCert(name)
-            if not certbyts:
-                s_common.deprecated('AHA CA certificate generation.', curv='v2.206.0')
-                certbyts = await prox.genCaCert(name)
-            cert = c_x509.load_pem_x509_certificate(certbyts.encode())
-            path = cdir._saveCertTo(cert, 'cas', f'{name}.crt')
-            outp.printf(f'Saved CA cert to {path}')
-            return 0
-        elif opts.server:
-            csr = cdir.genHostCsr(name, outp=outp)
-            certbyts = await prox.signHostCsr(csr.decode(), signas=opts.network, sans=opts.server_sans)
-            cert = c_x509.load_pem_x509_certificate(certbyts.encode())
-            path = cdir._saveCertTo(cert, 'hosts', f'{name}.crt')
-            outp.printf(f'crt saved: {path}')
-            return 0
-        else:
-            csr = cdir.genUserCsr(name, outp=outp)
-            certbyts = await prox.signUserCsr(csr.decode(), signas=opts.network)
-            cert = c_x509.load_pem_x509_certificate(certbyts.encode())
-            path = cdir._saveCertTo(cert, 'users', f'{name}.crt')
-            outp.printf(f'crt saved: {path}')
-            return 0
+    async with s_telepath.withTeleEnv():
+        async with await s_telepath.openurl(opts.aha) as prox:
+
+            name = opts.name
+
+            if opts.ca:
+                # A User may only have get permissions; so try get first
+                # before attempting to generate a new CA.
+                certbyts = await prox.getCaCert(name)
+                if not certbyts:
+                    s_common.deprecated('AHA CA certificate generation.', curv='v2.206.0')
+                    certbyts = await prox.genCaCert(name)
+                cert = c_x509.load_pem_x509_certificate(certbyts.encode())
+                path = cdir._saveCertTo(cert, 'cas', f'{name}.crt')
+                outp.printf(f'Saved CA cert to {path}')
+                return 0
+            elif opts.server:
+                csr = cdir.genHostCsr(name, outp=outp)
+                certbyts = await prox.signHostCsr(csr.decode(), signas=opts.network, sans=opts.server_sans)
+                cert = c_x509.load_pem_x509_certificate(certbyts.encode())
+                path = cdir._saveCertTo(cert, 'hosts', f'{name}.crt')
+                outp.printf(f'crt saved: {path}')
+                return 0
+            else:
+                csr = cdir.genUserCsr(name, outp=outp)
+                certbyts = await prox.signUserCsr(csr.decode(), signas=opts.network)
+                cert = c_x509.load_pem_x509_certificate(certbyts.encode())
+                path = cdir._saveCertTo(cert, 'users', f'{name}.crt')
+                outp.printf(f'crt saved: {path}')
+                return 0
 
 def getArgParser():
     desc = 'CLI tool to generate simple x509 certificates from an Aha server.'
@@ -74,17 +75,11 @@ def getArgParser():
 
     return pars
 
-async def main(argv, outp=None):  # pragma: no cover
-
-    if outp is None:
-        outp = s_output.stdout
-
+async def _main(argv, outp=s_output.stdout):  # pragma: no cover
     s_common.setlogging(logger, 'WARNING')
-
-    async with s_telepath.withTeleEnv():
-        await _main(argv, outp)
-
-    return 0
+    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:])))
+    sys.exit(asyncio.run(_main(sys.argv[1:])))

synapse/tools/aha/enroll.py

@@ -6,6 +6,7 @@ import argparse
 import synapse.common as s_common
 import synapse.telepath as s_telepath
 
+import synapse.lib.coro as s_coro
 import synapse.lib.output as s_output
 import synapse.lib.certdir as s_certdir
 import synapse.lib.msgpack as s_msgpack
@@ -99,5 +100,10 @@ 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:])))
+    sys.exit(asyncio.run(_main(sys.argv[1:])))