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

synapse/lib/version.py

@@ -223,6 +223,6 @@ def reqVersion(valu, reqver,
 ##############################################################################
 # The following are touched during the release process by bumpversion.
 # Do not modify these directly.
-version = (2, 224, 0)
+version = (2, 226, 0)
 verstring = '.'.join([str(x) for x in version])
-commit = '7c6e619bf5fd9c5801891b489b11bbee7fdbebd0'
+commit = '90a28a430a0b2b1f8cc74af240f55bfcf717b582'

synapse/models/base.py

@@ -176,6 +176,9 @@ class BaseModule(s_module.CoreModule):
                 ((None, 'refs', None), {
                     'doc': 'The source node contains a reference to the target node.'}),
 
+                ((None, 'linked', None), {
+                    'doc': 'The source node is linked to the target node.'}),
+
                 (('meta:source', 'seen', None), {
                     'doc': 'The meta:source observed the target node.'}),
 

synapse/models/inet.py

@@ -1550,13 +1550,23 @@ class InetModule(s_module.CoreModule):
                     ('inet:ssl:jarmsample', ('comp', {'fields': (('server', 'inet:server'), ('jarmhash', 'inet:ssl:jarmhash'))}), {
                         'doc': 'A JARM hash sample taken from a server.'}),
 
+                    ('inet:service:platform:type:taxonomy', ('taxonomy', {}), {
+                        'interfaces': ('meta:taxonomy',),
+                        'doc': 'A service platform type taxonomy.'}),
+
                     ('inet:service:platform', ('guid', {}), {
                         'doc': 'A network platform which provides services.'}),
 
+                    ('inet:service:agent', ('guid', {}), {
+                        'interfaces': ('inet:service:object',),
+                        'template': {'service:base': 'agent'},
+                        'doc': 'An instance of a deployed agent or software integration which is part of the service architecture.'}),
+
                     ('inet:service:app', ('guid', {}), {
                         'interfaces': ('inet:service:object',),
                         'template': {'service:base': 'application'},
-                        'doc': 'An application which is part of a service architecture.'}),
+                        'deprecated': True,
+                        'doc': 'Deprecated. Please use inet:service:agent for autonomous agents.'}),
 
                     ('inet:service:instance', ('guid', {}), {
                         'doc': 'An instance of the platform such as Slack or Discord instances.'}),
@@ -1795,7 +1805,8 @@ class InetModule(s_module.CoreModule):
                                 'doc': 'The service account which removed or decommissioned the {service:base}.'}),
 
                             ('app', ('inet:service:app', {}), {
-                                'doc': 'The app which contains the {service:base}.'}),
+                                'deprecated': True,
+                                'doc': 'Deprecated. Objects are no longer scoped to an application or agent.'}),
                         ),
                     }),
 
@@ -1816,7 +1827,11 @@ class InetModule(s_module.CoreModule):
                         'props': (
 
                             ('app', ('inet:service:app', {}), {
-                                'doc': 'The app which handled the action.'}),
+                                'deprecated': True,
+                                'doc': 'Deprecated. Please use :agent / inet:service:agent.'}),
+
+                            ('agent', ('inet:service:agent', {}), {
+                                'doc': 'The service agent which performed the action potentially on behalf of an account.'}),
 
                             ('time', ('time', {}), {
                                 'doc': 'The time that the account initiated the action.'}),
@@ -1851,8 +1866,12 @@ class InetModule(s_module.CoreModule):
                             ('client:host', ('it:host', {}), {
                                 'doc': 'The client host which initiated the action.'}),
 
+                            ('client:software', ('it:prod:softver', {}), {
+                                'doc': 'The client software used to initiate the action.'}),
+
                             ('client:app', ('inet:service:app', {}), {
-                                'doc': 'The client service app which initiated the action.'}),
+                                'deprecated': True,
+                                'doc': 'Deprecated. Please use :client:software.'}),
 
                             ('server', ('inet:server', {}), {
                                 'doc': 'The network address of the server which handled the action.'}),
@@ -3698,6 +3717,8 @@ class InetModule(s_module.CoreModule):
                             'ro': True,
                             'doc': 'The x509 certificate sent by the client.'})
                     )),
+
+                    ('inet:service:platform:type:taxonomy', {}, ()),
                     ('inet:service:platform', {}, (
 
                         ('id', ('str', {'strip': True}), {
@@ -3732,6 +3753,12 @@ class InetModule(s_module.CoreModule):
                             'disp': {'hint': 'text'},
                             'doc': 'A description of the service platform.'}),
 
+                        ('type', ('inet:service:platform:type:taxonomy', {}), {
+                            'doc': 'The type of service platform.'}),
+
+                        ('family', ('str', {'onespace': True, 'lower': True}), {
+                            'doc': 'A family designation for use with instanced platforms such as Slack, Discord, or Mastodon.'}),
+
                         ('parent', ('inet:service:platform', {}), {
                             'doc': 'A parent platform which owns this platform.'}),
 
@@ -3752,6 +3779,9 @@ class InetModule(s_module.CoreModule):
 
                         ('provider:name', ('ou:name', {}), {
                             'doc': 'The name of the organization which operates the platform.'}),
+
+                        ('software', ('it:prod:softver', {}), {
+                            'doc': 'The latest known software version that the platform is running.'}),
                     )),
 
                     ('inet:service:instance', {}, (
@@ -3791,7 +3821,8 @@ class InetModule(s_module.CoreModule):
                             'doc': 'The tenant which contains the instance.'}),
 
                         ('app', ('inet:service:app', {}), {
-                            'doc': 'The app which contains the instance.'}),
+                            'deprecated': True,
+                            'doc': 'Deprecated. Instances are no longer scoped to applications.'}),
                     )),
 
                     ('inet:service:app', {}, (
@@ -3816,11 +3847,34 @@ class InetModule(s_module.CoreModule):
                             'doc': 'The name of the organization which provides the application.'}),
                     )),
 
+                    ('inet:service:agent', {}, (
+
+                        ('name', ('str', {'lower': True, 'onespace': True}), {
+                            'alts': ('names',),
+                            'doc': 'The name of the service agent instance.'}),
+
+                        ('names', ('array', {'type': 'str',
+                                             'typeopts': {'onespace': True, 'lower': True},
+                                             'sorted': True, 'uniq': True}), {
+                            'doc': 'An array of alternate names for the service agent instance.'}),
+
+                        ('desc', ('str', {}), {
+                            'disp': {'hint': 'text'},
+                            'doc': 'A description of the deployed service agent instance.'}),
+
+                        ('software', ('it:prod:softver', {}), {
+                            'doc': 'The latest known software version running on the service agent instance.'}),
+                    )),
+
                     ('inet:service:account', {}, (
 
                         ('user', ('inet:user', {}), {
+                            'alts': ('users',),
                             'doc': 'The current user name of the account.'}),
 
+                        ('users', ('array', {'type': 'inet:user', 'sorted': True, 'uniq': True}), {
+                            'doc': 'An array of alternate user names for this account.'}),
+
                         ('parent', ('inet:service:account', {}), {
                             'doc': 'A parent account which owns this account.'}),
 
@@ -3907,6 +3961,9 @@ class InetModule(s_module.CoreModule):
 
                     ('inet:service:login', {}, (
 
+                        ('url', ('inet:url', {}), {
+                            'doc': 'The URL of the login endpoint used for this login attempt.'}),
+
                         ('method', ('inet:service:login:method:taxonomy', {}), {
                             'doc': 'The type of authentication used for the login. For example "password" or "multifactor.sms".'}),
 

synapse/models/infotech.py

@@ -803,6 +803,9 @@ class ItModule(s_module.CoreModule):
                 ('it:dev:repo:diff', ('guid', {}), {
                     'doc': 'A diff of a file being applied in a single commit.',
                 }),
+                ('it:dev:repo:entry', ('guid', {}), {
+                    'doc': 'A file included in a repository.',
+                }),
                 ('it:dev:repo:issue:label', ('guid', {}), {
                     'interfaces': ('inet:service:object',),
                     'template': {'service:base': 'repository issue label'},
@@ -1119,6 +1122,10 @@ class ItModule(s_module.CoreModule):
                     'doc': 'The YARA rule is intended for use in detecting the target node.'}),
                 (('it:dev:repo', 'has', 'inet:url'), {
                     'doc': 'The repo has content hosted at the URL.'}),
+                (('it:dev:repo:commit', 'has', 'it:dev:repo:entry'), {
+                    'doc': 'The file entry is present in the commit version of the repository.'}),
+                (('it:log:event', 'about', None), {
+                    'doc': 'The it:log:event is about the target node.'}),
             ),
             'forms': (
                 ('it:hostname', {}, ()),
@@ -2001,6 +2008,17 @@ class ItModule(s_module.CoreModule):
                         'doc': 'The URL where the diff is hosted.'}),
                 )),
 
+                ('it:dev:repo:entry', {}, (
+
+                    ('repo', ('it:dev:repo', {}), {
+                        'doc': 'The repository which contains the file.'}),
+
+                    ('file', ('file:bytes', {}), {
+                        'doc': 'The file which the repository contains.'}),
+
+                    ('path', ('file:path', {}), {
+                        'doc': 'The path to the file in the repository.'}),
+                )),
                 ('it:dev:repo:issue', {}, (
 
                     ('repo', ('it:dev:repo', {}), {

synapse/models/media.py

@@ -35,6 +35,10 @@ class MediaModule(s_module.CoreModule):
                     'disp': {'hint': 'text'},
                     'doc': 'A brief summary of the news item.'}),
 
+                ('body', ('str', {}), {
+                    'disp': {'hint': 'text', 'syntax': 'markdown'},
+                    'doc': 'The body of the news item.'}),
+
                 ('publisher', ('ou:org', {}), {
                     'doc': 'The organization which published the news.'}),
 

synapse/models/risk.py

@@ -420,6 +420,9 @@ class RiskModule(s_module.CoreModule):
                     ('type', ('risk:mitigation:type:taxonomy', {}), {
                         'doc': 'A taxonomy type entry for the mitigation.'}),
 
+                    ('id', ('str', {'strip': True}), {
+                        'doc': 'An identifier for the mitigation.'}),
+
                     ('desc', ('str', {}), {
                         'disp': {'hint': 'text'},
                         'doc': 'A description of the mitigation approach for the vulnerability.'}),

synapse/tests/test_cortex.py

@@ -28,8 +28,8 @@ import synapse.lib.version as s_version
 import synapse.lib.modelrev as s_modelrev
 import synapse.lib.stormsvc as s_stormsvc
 
-import synapse.tools.backup as s_tools_backup
-import synapse.tools.promote as s_tools_promote
+import synapse.tools.service.backup as s_tools_backup
+import synapse.tools.service.promote as s_tools_promote
 
 import synapse.tests.utils as s_t_utils
 from synapse.tests.utils import alist
@@ -9093,3 +9093,116 @@ class CortexBasicTest(s_t_utils.SynTest):
         async with self.getRegrCore('2.213.0-queue-authgates') as core:
             self.nn(await core.getAuthGate('queue:stillhere'))
             self.none(await core.getAuthGate('queue:authtest'))
+
+    async def test_cortex_prop_copy(self):
+        async with self.getTestCore() as core:
+            q = '[test:arrayprop=(ap0,) :strs=(foo, bar, baz)]'
+            self.len(1, await core.nodes(q))
+
+            q = 'test:arrayprop=(ap0,) $l=:strs $r=$l.rem(baz) return(($r, $l))'
+            valu = await core.callStorm(q)
+            self.true(valu[0])
+            self.sorteq(valu[1], ['foo', 'bar'])
+
+            # modifying the property value shouldn't update the node
+            nodes = await core.nodes('test:arrayprop=(ap0,) $l=:strs $l.rem(baz)')
+            self.len(1, nodes)
+            self.sorteq(nodes[0].get('strs'), ['foo', 'bar', 'baz'])
+
+            data = {
+                'str': 'strval',
+                'int': 1,
+                'dict': {'dictkey': 'dictval'},
+                'list': ('listval0', 'listval1'),
+                'tuple': ('tupleval0', 'tupleval1'),
+            }
+
+            opts = {
+                'vars': {
+                    'data': data,
+                }
+            }
+            q = '''
+                [ test:guid=(d0,)
+                    :data=$data
+                    :comp=(1, foo)
+                    :mutcomp=(foo, (1, 2, 3))
+                ]
+            '''
+            self.len(1, await core.nodes(q, opts=opts))
+
+            q = '''
+                test:guid=(d0,)
+                $d=:data
+                $d.list.rem(listval0)
+                $d.str = foo
+                $d.int = ($d.int + 1)
+                $d.dict.foo = bar
+                $d.tuple.append(tupleval2)
+                return($d)
+            '''
+            valu = await core.callStorm(q)
+            self.eq(valu, {
+                    'str': 'foo',
+                    'int': 2,
+                    'dict': {'dictkey': 'dictval', 'foo': 'bar'},
+                    'list': ('listval1',),
+                    'tuple': ('tupleval0', 'tupleval1', 'tupleval2'),
+            })
+
+            # modifying the property value shouldn't update the node
+            q = '''
+                test:guid=(d0,)
+                $d=:data
+                $d.dict = $lib.undef
+            '''
+            nodes = await core.nodes(q)
+            self.len(1, nodes)
+            self.eq(nodes[0].get('data')['dict'], {'dictkey': 'dictval'})
+
+            q = '''
+                test:guid=(d0,)
+                $c=:comp
+                $c.rem((1))
+                $m=:mutcomp
+                $m.1.rem((3))
+                return(($c, :comp, $m, :mutcomp))
+            '''
+            valu = await core.callStorm(q)
+            self.eq(valu, (
+                (1, 'foo'),
+                (1, 'foo'),
+                ('foo', (1, 2)),
+                ('foo', (1, 2, 3)),
+            ))
+
+            # Nodeprops could have mutable types in them so make sure modifying
+            # them doesn't cause modifications to the node
+            q = '''
+                $data = { test:guid=(d0,) return(:data) }
+                [ test:str=foobar :baz=(test:guid:data, $data) ]
+                ($prop, $valu) = :baz
+                $valu.list.rem(listval0)
+                return((:baz, $valu))
+            '''
+            valu = await core.callStorm(q)
+
+            exp = {
+                'str': 'strval',
+                'int': 1,
+                'dict': {'dictkey': 'dictval'},
+                'list': ('listval1',),
+                'tuple': ('tupleval0', 'tupleval1'),
+            }
+
+            self.eq(valu, (('test:guid:data', data), exp))
+
+            # Make sure $node.props aren't modifiable either
+            nodes = await core.nodes('test:str=foobar $node.props.baz.1.list.rem(listval0)')
+            self.len(1, nodes)
+            self.eq(nodes[0].get('baz'), ('test:guid:data', data))
+
+            # Dereferencing mutable types from $node.props should
+            # return mutable instances without mutating the original prop valu
+            valu = await core.callStorm('test:str=foobar ($prop, $valu) = :baz $valu.list.rem(listval0) return((:baz, $valu))')
+            self.eq(valu, (('test:guid:data', data), exp))

synapse/tests/test_lib_agenda.py

@@ -9,7 +9,7 @@ import synapse.exc as s_exc
 import synapse.common as s_common
 import synapse.tests.utils as s_t_utils
 
-import synapse.tools.backup as s_tools_backup
+import synapse.tools.service.backup as s_tools_backup
 
 import synapse.lib.agenda as s_agenda
 from synapse.lib.agenda import TimeUnit as s_tu
@@ -295,7 +295,7 @@ class AgendaTest(s_t_utils.SynTest):
 
                 # Cancel the Wednesday/Friday appt
                 await agenda.delete(guid)
-                await self.asyncraises(s_exc.NoSuchIden, agenda.delete(b'1234'))
+                await self.asyncraises(s_exc.NoSuchIden, agenda.delete('1234'))
 
                 # Then Dec 25
                 unixtime = datetime.datetime(year=2018, month=12, day=25, hour=10, minute=16, tzinfo=tz.utc).timestamp()
@@ -1205,32 +1205,6 @@ class AgendaTest(s_t_utils.SynTest):
                     self.false(cron01[0].get('isrunning'))
                     self.eq(cron01[0].get('lasterrs')[0], 'aborted')
 
-    async def test_agenda_clear_running_none_nexttime(self):
-
-        async with self.getTestCore() as core:
-
-            cdef = {
-                'creator': core.auth.rootuser.iden,
-                'iden': s_common.guid(),
-                'storm': '$lib.log.info("test")',
-                'reqs': {},
-                'incunit': 'minute',
-                'incvals': 1
-            }
-            await core.addCronJob(cdef)
-
-            appt = core.agenda.appts[cdef['iden']]
-            self.true(appt in core.agenda.apptheap)
-
-            appt.isrunning = True
-            appt.nexttime = None
-
-            await core.agenda.clearRunningStatus()
-            self.false(appt in core.agenda.apptheap)
-
-            crons = await core.callStorm('return($lib.cron.list())')
-            self.len(1, crons)
-
     async def test_agenda_lasterrs(self):
 
         async with self.getTestCore() as core:
@@ -1262,3 +1236,142 @@ class AgendaTest(s_t_utils.SynTest):
             appt = await core.agenda.get('test')
             self.true(isinstance(appt.lasterrs, list))
             self.eq(appt.lasterrs, ['error1', 'error2'])
+
+    async def test_cron_at_mirror_cleanup(self):
+
+        with self.getTestDir() as dirn:
+
+            dirn00 = s_common.genpath(dirn, 'core00')
+            dirn01 = s_common.genpath(dirn, 'core01')
+
+            async with self.getTestAha() as aha:
+
+                conf = {'aha:provision': await aha.addAhaSvcProv('00.cortex')}
+                core00 = await aha.enter_context(self.getTestCore(conf=conf, dirn=dirn00))
+
+                conf = {'aha:provision': await aha.addAhaSvcProv('01.cortex', {'mirror': 'cortex'})}
+                core01 = await aha.enter_context(self.getTestCore(conf=conf, dirn=dirn01))
+
+                msgs = await core00.stormlist('cron.at --minute +1 { $lib.log.info(cronran) }')
+                await core01.sync()
+
+                with self.getAsyncLoggerStream('synapse.storm.log', 'cronran') as stream:
+                    core00.agenda._addTickOff(60)
+                    self.true(await stream.wait(timeout=12))
+
+                await core01.sync()
+
+                # appt.recs should be cleared on both leader and mirror
+                appt = list(core00.agenda.appts.values())[0]
+                self.len(0, appt.recs)
+
+                appt = list(core01.agenda.appts.values())[0]
+                self.len(0, appt.recs)
+
+                # apptheap should also now be empty on both
+                self.len(0, core00.agenda.apptheap)
+                self.len(0, core01.agenda.apptheap)
+
+                await core00.fini()
+                core00 = await aha.enter_context(self.getTestCore(dirn=dirn00))
+
+                await core01.fini()
+                core01 = await aha.enter_context(self.getTestCore(dirn=dirn01))
+
+                # Job still exists on leader and mirror, wasn't removed due to being invalid
+                cron00 = await core00.listCronJobs()
+                cron01 = await core01.listCronJobs()
+                self.len(1, cron00)
+                self.eq(cron00, cron01)
+
+                await core00.delCronJob(cron00[0]['iden'])
+
+                # Add a job that is past due that will be deleted on startup
+                xmas = {'dayofmonth': 25, 'month': 12, 'year': 2099}
+                cdef = {'creator': core00.auth.rootuser.iden,
+                        'storm': '#happyholidays',
+                        'reqs': (xmas,)}
+                guid = s_common.guid()
+                cdef['iden'] = guid
+
+                await core00.addCronJob(cdef)
+                await core01.sync()
+
+                # Move the year back to the past
+                apptdef = core01.agenda.apptdefs.get(guid)
+                apptdef['recs'][0][0]['year'] = 1999
+
+                core00.agenda.apptdefs.set(guid, apptdef)
+                core01.agenda.apptdefs.set(guid, apptdef)
+
+                with self.getAsyncLoggerStream('synapse.lib.agenda', 'This appointment will be removed') as stream:
+                    await core01.fini()
+                    core01 = await aha.enter_context(self.getTestCore(dirn=dirn01))
+                    self.true(await stream.wait(timeout=12))
+
+                # Mirror warns about the invalid appointment but does not remove it
+                self.nn(core01.agenda.apptdefs.get(guid))
+                self.nn(await core01.getAuthGate(guid))
+
+                with self.getAsyncLoggerStream('synapse.lib.agenda', 'Removing invalid appointment') as stream:
+                    await core00.fini()
+                    core00 = await aha.enter_context(self.getTestCore(dirn=dirn00))
+                    self.true(await stream.wait(timeout=12))
+
+                await core01.sync()
+
+                # Leader removes the appointment via delCronJob which cleans up properly
+                self.none(core00.agenda.apptdefs.get(guid))
+                self.none(core01.agenda.apptdefs.get(guid))
+
+                self.none(await core00.getAuthGate(guid))
+                self.none(await core01.getAuthGate(guid))
+
+                # Add a job with iden mismatch for coverage
+                cdef = {'creator': core00.auth.rootuser.iden,
+                        'storm': '#happyholidays',
+                        'reqs': (xmas,)}
+                guid = s_common.guid()
+                cdef['iden'] = guid
+
+                await core00.addCronJob(cdef)
+                await core01.sync()
+
+                apptdef = core01.agenda.apptdefs.get(guid)
+                apptdef['iden'] = s_common.guid()
+
+                core00.agenda.apptdefs.set(guid, apptdef)
+                core01.agenda.apptdefs.set(guid, apptdef)
+
+                with self.getAsyncLoggerStream('synapse.lib.agenda', 'Removing invalid appointment') as stream:
+                    await core00.fini()
+                    core00 = await aha.enter_context(self.getTestCore(dirn=dirn00))
+
+                    await core01.fini()
+                    core01 = await aha.enter_context(self.getTestCore(dirn=dirn01))
+                    self.true(await stream.wait(timeout=12))
+
+                await core01.sync()
+
+                self.none(core00.agenda.apptdefs.get(guid))
+                self.none(core01.agenda.apptdefs.get(guid))
+
+                with self.getAsyncLoggerStream('synapse.storm.log', 'I AM A ERROR') as stream:
+                    q = "cron.at --now ${ while((true)) { $lib.log.error('I AM A ERROR') $lib.time.sleep(6) }  }"
+                    await core00.nodes(q)
+                    self.true(await stream.wait(timeout=12))
+                await core01.sync()
+
+                await core01.promote(graceful=True)
+                await core00.sync()
+
+                cron00 = await core00.listCronJobs()
+                cron01 = await core01.listCronJobs()
+
+                self.len(1, cron00)
+                self.false(cron00[0].get('isrunning'))
+                self.eq(cron00[0].get('lasterrs')[0], 'aborted')
+                self.eq(cron00, cron01)
+
+                self.len(0, core00.agenda.apptheap)
+                self.len(0, core01.agenda.apptheap)

synapse/tests/test_lib_cell.py

@@ -38,7 +38,7 @@ import synapse.lib.lmdbslab as s_lmdbslab
 import synapse.lib.crypto.passwd as s_passwd
 import synapse.lib.platforms.linux as s_linux
 
-import synapse.tools.backup as s_tools_backup
+import synapse.tools.service.backup as s_tools_backup
 
 import synapse.tests.utils as s_t_utils
 

synapse/tests/test_lib_certdir.py

@@ -9,7 +9,7 @@ import synapse.common as s_common
 import synapse.lib.certdir as s_certdir
 import synapse.lib.msgpack as s_msgpack
 import synapse.tests.utils as s_t_utils
-import synapse.tools.genpkg as s_genpkg
+import synapse.tools.storm.pkg.gen as s_genpkg
 
 import cryptography.x509 as c_x509
 import cryptography.exceptions as c_exc

synapse/tests/test_lib_httpapi.py

@@ -5,7 +5,7 @@ import aiohttp
 import aiohttp.client_exceptions as a_exc
 
 import synapse.common as s_common
-import synapse.tools.backup as s_backup
+import synapse.tools.service.backup as s_backup
 
 import synapse.exc as s_exc
 import synapse.lib.coro as s_coro

synapse/tests/test_lib_layer.py

@@ -13,7 +13,7 @@ import synapse.lib.layer as s_layer
 import synapse.lib.msgpack as s_msgpack
 import synapse.lib.spooled as s_spooled
 
-import synapse.tools.backup as s_tools_backup
+import synapse.tools.service.backup as s_tools_backup
 
 import synapse.tests.utils as s_t_utils
 

synapse/tests/test_lib_lmdbslab.py

@@ -369,7 +369,9 @@ class LmdbSlabTest(s_t_utils.SynTest):
                 'vm.dirty_expire_centisecs',
                 'vm.dirty_writeback_centisecs',
                 'vm.dirty_background_ratio',
+                'vm.dirty_background_bytes',
                 'vm.dirty_ratio',
+                'vm.dirty_bytes',
             ], msgs[0].get('sysctls', {}).keys())
 
     async def test_lmdbslab_commit_over_max_xactops(self):

synapse/tests/test_lib_multislabseqn.py

@@ -226,6 +226,28 @@ class MultiSlabSeqn(s_t_utils.SynTest):
                 # Iterator exhausted: should have just the cache slab (10) and the tail slab (20)
                 self.len(2, msqn._openslabs)
 
+    async def test_multislabseqn_retnpack(self):
+
+        with self.getTestDir() as dirn:
+
+            async with await s_multislabseqn.MultiSlabSeqn.anit(dirn) as msqn:
+
+                self.eq((0, b'\xa4foo1'), await msqn.addWithPackRetn('foo1'))
+                self.eq((1, b'\xa4foo2'), await msqn.addWithPackRetn('foo2'))
+                self.eq((0, b'\xa4foo3'), await msqn.addWithPackRetn('foo3', indx=0))
+
+                await msqn.addWithPackRetn('foo4', indx=10)
+                await msqn.rotate()
+                await msqn.addWithPackRetn('foo5')
+                await msqn.addWithPackRetn('foo6', indx=7)
+
+                self.true(await msqn.cull(10))
+
+                with self.raises(s_exc.BadIndxValu):
+                    await msqn.addWithPackRetn('foo7', indx=7)
+
+                self.eq((12, b'\xa4foo8'), msqn.tailseqn.addWithPackRetn('foo8'))
+
     async def test_multislabseqn_cull(self):
 
         with self.getTestDir() as dirn: