synapse 2.189.0__py311-none-any.whl → 2.191.0__py311-none-any.whl

synapse/models/inet.py

@@ -1530,7 +1530,8 @@ class InetModule(s_module.CoreModule):
                         'doc': 'An object status enumeration.'}),
 
                     ('inet:service:account', ('guid', {}), {
-                        'interfaces': ('inet:service:object',),
+                        'interfaces': ('inet:service:subscriber',),
+                        'template': {'service:base': 'account'},
                         'doc': 'An account within a service platform. Accounts may be instance specific.'}),
 
                     ('inet:service:relationship:type:taxonomy', ('taxonomy', {}), {
@@ -1539,6 +1540,7 @@ class InetModule(s_module.CoreModule):
 
                     ('inet:service:relationship', ('guid', {}), {
                         'interfaces': ('inet:service:object',),
+                        'template': {'service:base': 'relationship'},
                         'doc': 'A relationship between two service objects.'}),
 
                     ('inet:service:permission:type:taxonomy', ('taxonomy', {}), {
@@ -1547,10 +1549,12 @@ class InetModule(s_module.CoreModule):
 
                     ('inet:service:permission', ('guid', {}), {
                         'interfaces': ('inet:service:object',),
+                        'template': {'service:base': 'permission'},
                         'doc': 'A permission which may be granted to a service account or role.'}),
 
                     ('inet:service:rule', ('guid', {}), {
                         'interfaces': ('inet:service:object',),
+                        'template': {'service:base': 'rule'},
                         'doc': 'A rule which grants or denies a permission to a service account or role.'}),
 
                     ('inet:service:login', ('guid', {}), {
@@ -1563,26 +1567,32 @@ class InetModule(s_module.CoreModule):
 
                     ('inet:service:session', ('guid', {}), {
                         'interfaces': ('inet:service:object',),
+                        'template': {'service:base': 'session'},
                         'doc': 'An authenticated session.'}),
 
                     ('inet:service:group', ('guid', {}), {
                         'interfaces': ('inet:service:object',),
+                        'template': {'service:base': 'group'},
                         'doc': 'A group or role which contains member accounts.'}),
 
                     ('inet:service:group:member', ('guid', {}), {
                         'interfaces': ('inet:service:object',),
+                        'template': {'service:base': 'group membership'},
                         'doc': 'Represents a service account being a member of a group.'}),
 
                     ('inet:service:channel', ('guid', {}), {
                         'interfaces': ('inet:service:object',),
+                        'template': {'service:base': 'channel'},
                         'doc': 'A channel used to distribute messages.'}),
 
                     ('inet:service:thread', ('guid', {}), {
                         'interfaces': ('inet:service:object',),
+                        'template': {'service:base': 'thread'},
                         'doc': 'A message thread.'}),
 
                     ('inet:service:channel:member', ('guid', {}), {
                         'interfaces': ('inet:service:object',),
+                        'template': {'service:base': 'channel membership'},
                         'doc': 'Represents a service account being a member of a channel.'}),
 
                     ('inet:service:message', ('guid', {}), {
@@ -1601,26 +1611,47 @@ class InetModule(s_module.CoreModule):
 
                     ('inet:service:emote', ('guid', {}), {
                         'interfaces': ('inet:service:object',),
+                        'template': {'service:base': 'emote'},
                         'doc': 'An emote or reaction by an account.'}),
 
                     ('inet:service:access', ('guid', {}), {
                         'interfaces': ('inet:service:action',),
                         'doc': 'Represents a user access request to a service resource.'}),
 
+                    ('inet:service:tenant', ('guid', {}), {
+                        'interfaces': ('inet:service:subscriber',),
+                        'template': {'service:base': 'tenant'},
+                        'doc': 'A tenant which groups accounts and instances.'}),
+
+                    ('inet:service:subscription:level:taxonomy', ('taxonomy', {}), {
+                        'interfaces': ('meta:taxonomy',),
+                        'doc': 'A taxonomy of platform specific subscription levels.'}),
+
+                    ('inet:service:subscription', ('guid', {}), {
+                        'interfaces': ('inet:service:object',),
+                        'template': {'service:base': 'subscription'},
+                        'doc': 'A subscription to a service platform or instance.'}),
+
+                    ('inet:service:subscriber', ('ndef', {'interface': 'inet:service:subscriber'}), {
+                        'doc': 'A node which may subscribe to a service subscription.'}),
+
                     ('inet:service:resource:type:taxonomy', ('taxonomy', {}), {
                         'interfaces': ('meta:taxonomy',),
                         'doc': 'A taxonomy of inet service resource types.'}),
 
                     ('inet:service:resource', ('guid', {}), {
                         'interfaces': ('inet:service:object',),
+                        'template': {'service:base': 'resource'},
                         'doc': 'A generic resource provided by the service architecture.'}),
 
                     ('inet:service:bucket', ('guid', {}), {
                         'interfaces': ('inet:service:object',),
+                        'template': {'service:base': 'bucket'},
                         'doc': 'A file/blob storage object within a service architecture.'}),
 
                     ('inet:service:bucket:item', ('guid', {}), {
                         'interfaces': ('inet:service:object',),
+                        'template': {'service:base': 'bucket item'},
                         'doc': 'An individual file stored within a bucket.'}),
 
                     ('inet:tls:handshake', ('guid', {}), {
@@ -1676,16 +1707,17 @@ class InetModule(s_module.CoreModule):
 
                     ('inet:service:base', {
                         'doc': 'Properties common to most forms within a service platform.',
+                        'template': {'service:base': 'node'},
                         'props': (
 
                             ('id', ('str', {'strip': True}), {
-                                'doc': 'A platform specific ID.'}),
+                                'doc': 'A platform specific ID which identifies the {service:base}.'}),
 
                             ('platform', ('inet:service:platform', {}), {
-                                'doc': 'The platform which defines the node.'}),
+                                'doc': 'The platform which defines the {service:base}.'}),
 
                             ('instance', ('inet:service:instance', {}), {
-                                'doc': 'The platform instance which defines the node.'}),
+                                'doc': 'The platform instance which defines the {service:base}.'}),
                         ),
                     }),
 
@@ -1693,23 +1725,34 @@ class InetModule(s_module.CoreModule):
 
                         'doc': 'Properties common to objects within a service platform.',
                         'interfaces': ('inet:service:base',),
+                        'template': {'service:base': 'object'},
                         'props': (
 
                             ('status', ('inet:service:object:status', {}), {
-                                'doc': 'The status of this object.'}),
+                                'doc': 'The status of the {service:base}.'}),
 
                             ('period', ('ival', {}), {
-                                'doc': 'The period when the object existed.'}),
+                                'doc': 'The period when the {service:base} existed.'}),
 
                             ('creator', ('inet:service:account', {}), {
-                                'doc': 'The service account which created the object.'}),
+                                'doc': 'The service account which created the {service:base}.'}),
 
                             ('remover', ('inet:service:account', {}), {
-                                'doc': 'The service account which removed or decommissioned the object.'}),
+                                'doc': 'The service account which removed or decommissioned the {service:base}.'}),
 
                         ),
                     }),
 
+                    ('inet:service:subscriber', {
+                        'doc': 'Properties common to the nodes which subscribe to services.',
+                        'interfaces': ('inet:service:object',),
+                        'template': {'service:base': 'subscriber'},
+                        'props': (
+                            ('profile', ('ps:contact', {}), {
+                                'doc': 'The primary contact information for the {service:base}.'}),
+                        ),
+                    }),
+
                     ('inet:service:action', {
 
                         'doc': 'Properties common to events within a service platform.',
@@ -3590,21 +3633,21 @@ class InetModule(s_module.CoreModule):
 
                         ('owner', ('inet:service:account', {}), {
                             'doc': 'The service account which owns the instance.'}),
+
+                        ('tenant', ('inet:service:tenant', {}), {
+                            'doc': 'The tenant which contains the instance.'}),
                     )),
 
                     ('inet:service:account', {}, (
 
-                        ('id', ('str', {'strip': True}), {
-                            'doc': 'A platform specific ID used to identify the account.'}),
-
                         ('user', ('inet:user', {}), {
                             'doc': 'The current user name of the account.'}),
 
                         ('email', ('inet:email', {}), {
                             'doc': 'The current email address associated with the account.'}),
 
-                        ('profile', ('ps:contact', {}), {
-                            'doc': 'Current profile details associated with the account.'}),
+                        ('tenant', ('inet:service:tenant', {}), {
+                            'doc': 'The tenant which contains the account.'}),
                     )),
 
                     ('inet:service:relationship:type:taxonomy', {}, ()),
@@ -3621,10 +3664,7 @@ class InetModule(s_module.CoreModule):
                             'doc': 'The type of relationship between the source and the target.'}),
                     )),
 
-                    ('inet:service:group', {}, ( # inet:service:object
-
-                        ('id', ('str', {'strip': True}), {
-                            'doc': 'A platform specific ID used to identify the group.'}),
+                    ('inet:service:group', {}, (
 
                         ('name', ('inet:group', {}), {
                             'doc': 'The name of the group on this platform.'}),
@@ -3674,14 +3714,14 @@ class InetModule(s_module.CoreModule):
 
                     ('inet:service:session', {}, (
 
-                        ('id', ('str', {'strip': True}), {
-                            'doc': 'The service specific session id.'}),
-
                         ('creator', ('inet:service:account', {}), {
                             'doc': 'The account which authenticated to create the session.'}),
 
                         ('period', ('ival', {}), {
                             'doc': 'The period where the session was valid.'}),
+
+                        ('http:session', ('inet:http:session', {}), {
+                            'doc': 'The HTTP session associated with the service session.'}),
                     )),
 
                     ('inet:service:login', {}, (
@@ -3742,7 +3782,8 @@ class InetModule(s_module.CoreModule):
                             'doc': 'The name of the place that the message was sent from.'}),
 
                         ('client:address', ('inet:client', {}), {
-                            'doc': 'The client address that the message was sent from.'}),
+                            'deprecated': True,
+                            'doc': 'Deprecated. Please use :client'}),
 
                         ('client:software', ('it:prod:softver', {}), {
                             'doc': 'The client software version used to send the message.'}),
@@ -3864,6 +3905,22 @@ class InetModule(s_module.CoreModule):
                         ('type', ('int', {'enums': svcaccesstypes}), {
                             'doc': 'The type of access requested.'}),
                     )),
+
+                    ('inet:service:tenant', {}, ()),
+
+                    ('inet:service:subscription:level:taxonomy', {}, ()),
+
+                    ('inet:service:subscription', {}, (
+
+                        ('level', ('inet:service:subscription:level:taxonomy', {}), {
+                            'doc': 'A platform specific subscription level.'}),
+
+                        ('pay:instrument', ('econ:pay:instrument', {}), {
+                            'doc': 'The primary payment instrument used to pay for the subscription.'}),
+
+                        ('subscriber', ('inet:service:subscriber', {}), {
+                            'doc': 'The subscriber who owns the subscription.'}),
+                    )),
                 ),
             }),
         )

synapse/models/person.py

@@ -377,10 +377,12 @@ class PsModule(s_module.CoreModule):
                         'doc': 'The service accounts associated with this contact.'}),
 
                     ('web:acct', ('inet:web:acct', {}), {
-                        'doc': 'The social media account for this contact.',
+                        'deprecated': True,
+                        'doc': 'Deprecated. Use :service:accounts.',
                     }),
                     ('web:group', ('inet:web:group', {}), {
-                        'doc': 'A web group representing this contact.',
+                        'deprecated': True,
+                        'doc': 'Deprecated. Use inet:service:group:profile to link to a group.',
                     }),
                     ('birth:place', ('geo:place', {}), {
                         'doc': 'A fully resolved place of birth for this contact.',
@@ -463,7 +465,8 @@ class PsModule(s_module.CoreModule):
                         'doc': 'An array of secondary/associated email addresses.',
                     }),
                     ('web:accts', ('array', {'type': 'inet:web:acct', 'uniq': True, 'sorted': True}), {
-                        'doc': 'An array of secondary/associated web accounts.',
+                        'deprecated': True,
+                        'doc': 'Deprecated. Use :service:accounts.',
                     }),
                     ('id:numbers', ('array', {'type': 'ou:id:number', 'uniq': True, 'sorted': True}), {
                         'doc': 'An array of secondary/associated IDs.',
@@ -511,7 +514,11 @@ class PsModule(s_module.CoreModule):
                         'doc': 'The file from which the contact list was extracted.',
                     }),
                     ('source:acct', ('inet:web:acct', {}), {
-                        'doc': 'The web account from which the contact list was extracted.',
+                        'deprecated': True,
+                        'doc': 'Deprecated. Use :source:account.',
+                    }),
+                    ('source:account', ('inet:service:account', {}), {
+                        'doc': 'The service account from which the contact list was extracted.',
                     }),
                 )),
 

synapse/models/risk.py

@@ -279,6 +279,9 @@ class RiskModule(s_module.CoreModule):
                     ('active', ('ival', {}), {
                         'doc': 'An interval for when the threat cluster is assessed to have been active.'}),
 
+                    ('activity', ('meta:activity', {}), {
+                        'doc': 'The most recently assessed activity level of the threat cluster.'}),
+
                     ('reporter', ('ou:org', {}), {
                         'doc': 'The organization reporting on the threat cluster.'}),
 
@@ -1078,6 +1081,9 @@ class RiskModule(s_module.CoreModule):
                         'ex': 'nature.earthquake',
                         'doc': 'The outage cause type.'}),
 
+                    ('attack', ('risk:attack', {}), {
+                        'doc': 'An attack which caused the outage.'}),
+
                     ('provider', ('ou:org', {}), {
                         'doc': 'The organization which experienced the outage event.'}),
 

synapse/models/syn.py

@@ -83,23 +83,28 @@ class SynModule(s_module.CoreModule):
 
     async def _liftRuntSynCmd(self, full, valu=None, cmpr=None, view=None):
 
-        genr = self.core.stormcmds.values
+        def iterStormCmds():
+            for item in self.core.getStormCmds():
+                yield item[1]
 
-        async for node in self._doRuntLift(genr, full, valu, cmpr):
+        async for node in self._doRuntLift(iterStormCmds, full, valu, cmpr):
             yield node
 
     async def _liftRuntSynCron(self, full, valu=None, cmpr=None, view=None):
 
-        genr = self.core.agenda.appts.values
+        def iterAppts():
+            for item in self.core.agenda.list():
+                yield item[1]
 
-        async for node in self._doRuntLift(genr, full, valu, cmpr):
+        async for node in self._doRuntLift(iterAppts, full, valu, cmpr):
             yield node
 
     async def _liftRuntSynForm(self, full, valu=None, cmpr=None, view=None):
 
-        genr = self.model.forms.values
+        def getForms():
+            return list(self.model.forms.values())
 
-        async for node in self._doRuntLift(genr, full, valu, cmpr):
+        async for node in self._doRuntLift(getForms, full, valu, cmpr):
             yield node
 
     async def _liftRuntSynProp(self, full, valu=None, cmpr=None, view=None):
@@ -111,24 +116,29 @@ class SynModule(s_module.CoreModule):
 
     async def _liftRuntSynType(self, full, valu=None, cmpr=None, view=None):
 
-        genr = self.model.types.values
+        def getTypes():
+            return list(self.model.types.values())
 
-        async for node in self._doRuntLift(genr, full, valu, cmpr):
+        async for node in self._doRuntLift(getTypes, full, valu, cmpr):
             yield node
 
     async def _liftRuntSynTagProp(self, full, valu=None, cmpr=None, view=None):
 
-        genr = self.model.tagprops.values
+        def getTagProps():
+            return list(self.model.tagprops.values())
 
-        async for node in self._doRuntLift(genr, full, valu, cmpr):
+        async for node in self._doRuntLift(getTagProps, full, valu, cmpr):
             yield node
 
     async def _liftRuntSynTrigger(self, full, valu=None, cmpr=None, view=None):
 
         view = self.core.getView(iden=view)
-        genr = view.triggers.triggers.values
 
-        async for node in self._doRuntLift(genr, full, valu, cmpr):
+        def iterTriggers():
+            for item in view.triggers.list():
+                yield item[1]
+
+        async for node in self._doRuntLift(iterTriggers, full, valu, cmpr):
             yield node
 
     async def _doRuntLift(self, genr, full, valu=None, cmpr=None):

synapse/models/telco.py

@@ -376,7 +376,9 @@ class TelcoModule(s_module.CoreModule):
                     # User related data
                     ('name', ('ps:name', {}), {}),
                     ('email', ('inet:email', {}), {}),
-                    ('acct', ('inet:web:acct', {}), {}),
+                    ('acct', ('inet:web:acct', {}), {
+                        'doc': 'Deprecated, use :account.',
+                        'deprecated': True}),
 
                     ('account', ('inet:service:account', {}), {
                         'doc': 'The service account which is associated with the tracked device.'}),

synapse/tests/test_cortex.py

@@ -1,11 +1,9 @@
 import os
 import copy
-import json
 import time
 import asyncio
 import hashlib
 import logging
-import textwrap
 
 import regex
 
@@ -16,13 +14,13 @@ import synapse.common as s_common
 import synapse.cortex as s_cortex
 import synapse.telepath as s_telepath
 
-import synapse.lib.aha as s_aha
 import synapse.lib.base as s_base
 import synapse.lib.cell as s_cell
 import synapse.lib.coro as s_coro
 import synapse.lib.node as s_node
 import synapse.lib.time as s_time
 import synapse.lib.layer as s_layer
+import synapse.lib.storm as s_storm
 import synapse.lib.output as s_output
 import synapse.lib.msgpack as s_msgpack
 import synapse.lib.version as s_version
@@ -1114,8 +1112,7 @@ class CortexTest(s_t_utils.SynTest):
                 ''')
                 self.true(await stream.wait(6))
 
-            buf = stream.getvalue()
-            mesg = json.loads(buf.split('\n')[0])
+            mesg = stream.jsonlines()[0]
             self.eq(mesg.get('message'), f'Running dmon {iden}')
             self.eq(mesg.get('iden'), iden)
 
@@ -3365,8 +3362,7 @@ class CortexBasicTest(s_t_utils.SynTest):
                 await alist(core.storm('help foo', opts={'show': ('init', 'fini', 'print',)}))
                 self.true(await stream.wait(4))
 
-            buf = stream.getvalue()
-            mesg = json.loads(buf.split('\n')[0])
+            mesg = stream.jsonlines()[0]
             self.eq(mesg.get('view'), view)
 
     async def test_strict(self):
@@ -7901,8 +7897,7 @@ class CortexBasicTest(s_t_utils.SynTest):
                     self.eq('admin', whoami)
                     self.eq('lowuser', udef.get('name'))
 
-                raw_mesgs = [m for m in stream.getvalue().split('\n') if m]
-                msgs = [json.loads(m) for m in raw_mesgs]
+                msgs = stream.jsonlines()
                 mesg = [m for m in msgs if 'Added user' in m.get('message')][0]
                 self.eq('Added user=lowuser', mesg.get('message'))
                 self.eq('admin', mesg.get('username'))
@@ -7916,8 +7911,7 @@ class CortexBasicTest(s_t_utils.SynTest):
                         msgs.append(mesg)
                     self.stormHasNoWarnErr(msgs)
 
-                raw_mesgs = [m for m in stream.getvalue().split('\n') if m]
-                msgs = [json.loads(m) for m in raw_mesgs]
+                msgs = stream.jsonlines()
                 mesg = [m for m in msgs if 'Set admin' in m.get('message')][0]
                 self.isin('Set admin=True for lowuser', mesg.get('message'))
                 self.eq('admin', mesg.get('username'))
@@ -8072,6 +8066,8 @@ class CortexBasicTest(s_t_utils.SynTest):
 
         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:
@@ -8107,43 +8103,89 @@ class CortexBasicTest(s_t_utils.SynTest):
                     self.stormIsInPrint('Storm pool configuration set.', msgs)
 
                     await core00.fini()
+                    await core01.fini()
 
                     core00 = await base.enter_context(self.getTestCore(dirn=dirn00))
+                    core01 = await base.enter_context(self.getTestCore(dirn=dirn01, conf={'storm:log': True}))
 
                     await core00.stormpool.waitready(timeout=12)
 
-                    with self.getLoggerStream('synapse') as stream:
-                        msgs = await alist(core00.storm('inet:asn=0'))
+                    # storm()
+                    q = 'inet:asn=0'
+                    qhash = s_storm.queryhash(q)
+                    with self.getStructuredAsyncLoggerStream('synapse') as stream:
+                        msgs = await alist(core00.storm(q))
                         self.len(1, [m for m in msgs if m[0] == 'node'])
 
-                    stream.seek(0)
-                    data = stream.read()
-                    self.isin('Offloading Storm query', data)
+                    data = stream.getvalue()
                     self.notin('Timeout', data)
+                    msgs = stream.jsonlines()
+                    self.len(2, msgs)
 
-                    with self.getLoggerStream('synapse') as stream:
-                        self.true(await core00.callStorm('inet:asn=0 return($lib.true)'))
+                    self.eq(msgs[0].get('message'), f'Offloading Storm query to mirror 01.core.{ahanet}.')
+                    self.eq(msgs[0].get('hash'), qhash)
+                    self.eq(msgs[0].get('mirror'), f'01.core.{ahanet}')
 
-                    stream.seek(0)
-                    data = stream.read()
-                    self.isin('Offloading Storm query', data)
+                    self.eq(msgs[1].get('message'), f'Executing storm query {{{q}}} as [root]')
+                    self.eq(msgs[1].get('hash'), qhash)
+                    self.eq(msgs[1].get('pool:from'), f'00.core.{ahanet}')
+
+                    # callStorm()
+                    q = 'inet:asn=0 return($lib.true)'
+                    qhash = s_storm.queryhash(q)
+                    with self.getStructuredAsyncLoggerStream('synapse') as stream:
+                        self.true(await core00.callStorm(q))
+
+                    data = stream.getvalue()
                     self.notin('Timeout', data)
+                    msgs = stream.jsonlines()
+                    self.len(2, msgs)
 
-                    with self.getLoggerStream('synapse') as stream:
-                        self.len(1, await alist(core00.exportStorm('inet:asn=0')))
+                    self.eq(msgs[0].get('message'), f'Offloading Storm query to mirror 01.core.{ahanet}.')
+                    self.eq(msgs[0].get('hash'), qhash)
+                    self.eq(msgs[0].get('mirror'), f'01.core.{ahanet}')
 
-                    stream.seek(0)
-                    data = stream.read()
-                    self.isin('Offloading Storm query', data)
+                    self.eq(msgs[1].get('message'), f'Executing storm query {{{q}}} as [root]')
+                    self.eq(msgs[1].get('hash'), qhash)
+                    self.eq(msgs[1].get('pool:from'), f'00.core.{ahanet}')
+
+                    # exportStorm()
+                    q = 'inet:asn=0'
+                    qhash = s_storm.queryhash(q)
+                    with self.getStructuredAsyncLoggerStream('synapse') as stream:
+                        self.len(1, await alist(core00.exportStorm(q)))
+
+                    data = stream.getvalue()
                     self.notin('Timeout', data)
+                    msgs = stream.jsonlines()
+                    self.len(2, msgs)
 
-                    with self.getLoggerStream('synapse') as stream:
-                        self.eq(1, await core00.count('inet:asn=0'))
+                    self.eq(msgs[0].get('message'), f'Offloading Storm query to mirror 01.core.{ahanet}.')
+                    self.eq(msgs[0].get('hash'), qhash)
+                    self.eq(msgs[0].get('mirror'), f'01.core.{ahanet}')
 
-                    stream.seek(0)
-                    data = stream.read()
-                    self.isin('Offloading Storm query', data)
+                    self.eq(msgs[1].get('message'), f'Executing storm query {{{q}}} as [root]')
+                    self.eq(msgs[1].get('hash'), qhash)
+                    self.eq(msgs[1].get('pool:from'), f'00.core.{ahanet}')
+
+                    # count()
+                    q = 'inet:asn=0'
+                    qhash = s_storm.queryhash(q)
+                    with self.getStructuredAsyncLoggerStream('synapse') as stream:
+                        self.eq(1, await core00.count(q))
+
+                    data = stream.getvalue()
                     self.notin('Timeout', data)
+                    msgs = stream.jsonlines()
+                    self.len(2, msgs)
+
+                    self.eq(msgs[0].get('message'), f'Offloading Storm query to mirror 01.core.{ahanet}.')
+                    self.eq(msgs[0].get('hash'), qhash)
+                    self.eq(msgs[0].get('mirror'), f'01.core.{ahanet}')
+
+                    self.eq(msgs[1].get('message'), f'Executing storm query {{{q}}} as [root]')
+                    self.eq(msgs[1].get('hash'), qhash)
+                    self.eq(msgs[1].get('pool:from'), f'00.core.{ahanet}')
 
                     with patch('synapse.cortex.CoreApi.getNexsIndx', _hang):
 

synapse/tests/test_lib_agenda.py

@@ -1,4 +1,3 @@
-import json
 import asyncio
 import hashlib
 import datetime
@@ -9,8 +8,6 @@ import synapse.exc as s_exc
 import synapse.common as s_common
 import synapse.tests.utils as s_t_utils
 
-import synapse.lib.hive as s_hive
-import synapse.lib.lmdbslab as s_lmdbslab
 import synapse.tools.backup as s_tools_backup
 
 import synapse.lib.agenda as s_agenda
@@ -401,9 +398,7 @@ class AgendaTest(s_t_utils.SynTest):
                     self.eq((12, 'bar'), await asyncio.wait_for(core.callStorm('return($lib.queue.gen(visi).pop(wait=$lib.true))'), timeout=5))
                 core.stormlog = False
 
-                data = stream.getvalue()
-                raw_mesgs = [m for m in data.split('\n') if m]
-                msgs = [json.loads(m) for m in raw_mesgs]
+                msgs = stream.jsonlines()
                 msgs = [m for m in msgs if m['text'] == '$lib.queue.gen(visi).put(bar)']
                 self.gt(len(msgs), 0)
                 for m in msgs: