synapse 2.253.0__tar.gz → 2.255.0__tar.gz

{synapse-2.253.0/synapse.egg-info → synapse-2.255.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synapse
-Version: 2.253.0
+Version: 2.255.0
 Summary: Synapse Intelligence Analysis Framework
 Author-email: The Vertex Project LLC <root@vertex.link>
 License-Expression: Apache-2.0

{synapse-2.253.0 → synapse-2.255.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = 'setuptools.build_meta'
 
 [project]
 name = 'synapse'
-version = '2.253.0'
+version = '2.255.0'
 authors = [
     { name = 'The Vertex Project LLC', email = 'root@vertex.link'},
 ]

{synapse-2.253.0 → synapse-2.255.0}/synapse/axon.py

@@ -918,12 +918,15 @@ class Axon(s_cell.Cell):
         self.onfini(self.blobslab.fini)
 
         if self.inaugural:
-            self._setStorVers(1)
+            self._setStorVers(2)
 
         storvers = self._getStorVers()
         if storvers < 1:
             storvers = await self._setStorVers01()
 
+        if storvers < 2:
+            storvers = await self._setStorVers02()
+
     async def _setStorVers01(self):
 
         logger.warning('Updating Axon storage version (adding offset index). This may take a while.')
@@ -948,6 +951,69 @@ class Axon(s_cell.Cell):
 
         return self._setStorVers(1)
 
+    async def _setStorVers02(self):
+
+        logger.warning('Updating Axon storage version (removing stale offset index entries). This may take a while.')
+
+        cursha = None
+
+        # deletes bump the outer scan and rewritten rows sort before its resume key
+        for lkey in self.blobslab.scanKeys(db=self.offsets):
+
+            await asyncio.sleep(0)
+
+            offssha = lkey[:32]
+            if offssha == cursha:
+                continue
+
+            if cursha is not None:
+                await self._fixBlobOffs(cursha)
+
+            cursha = offssha
+
+        if cursha is not None:
+            await self._fixBlobOffs(cursha)
+
+        return self._setStorVers(2)
+
+    async def _fixBlobOffs(self, sha256):
+        '''
+        Merge walk the offset rows expected from the blobs against the existing ones,
+        removing stale rows and putting missing or incorrect ones.
+        '''
+        def expected():
+            offs = 0
+            for lkey, byts in self.blobslab.scanByPref(sha256, db=self.blobs):
+                offs += len(byts)
+                yield sha256 + offs.to_bytes(8, 'big'), lkey[32:]
+
+        genr = expected()
+        item = next(genr, None)
+
+        # deletes bump the scan and puts only add keys before its current key
+        for lkey, lval in self.blobslab.scanByPref(sha256, db=self.offsets):
+
+            await asyncio.sleep(0)
+
+            while item is not None and item[0] < lkey:
+                self.blobslab.put(item[0], item[1], db=self.offsets)
+                item = next(genr, None)
+                await asyncio.sleep(0)
+
+            if item is None or lkey < item[0]:
+                self.blobslab.delete(lkey, db=self.offsets)
+                continue
+
+            if lval != item[1]:
+                self.blobslab.put(lkey, item[1], db=self.offsets)
+
+            item = next(genr, None)
+
+        while item is not None:
+            self.blobslab.put(item[0], item[1], db=self.offsets)
+            item = next(genr, None)
+            await asyncio.sleep(0)
+
     def _getStorVers(self):
         byts = self.blobslab.get(b'version', db=self.metadata)
         if not byts:
@@ -1319,6 +1385,9 @@ class Axon(s_cell.Cell):
             if first:
                 first = False
                 delt = boff - offs
+                if delt == 0:
+                    continue
+
                 yield byts[-delt:]
                 continue
 
@@ -1391,7 +1460,7 @@ class Axon(s_cell.Cell):
     async def _delBlobByts(self, sha256):
 
         # remove the offset indexes...
-        for lkey in self.blobslab.scanKeysByPref(sha256, db=self.blobs):
+        for lkey in self.blobslab.scanKeysByPref(sha256, db=self.offsets):
             self.blobslab.delete(lkey, db=self.offsets)
             await asyncio.sleep(0)
 

{synapse-2.253.0 → synapse-2.255.0}/synapse/lib/aha.py

@@ -742,26 +742,38 @@ class AhaCell(s_cell.Cell):
     async def getAhaSvcsByIden(self, iden, online=True, skiprun=None):
 
         runs = set()
+        aliases = {}
         async for svcdef in self.getAhaSvcs():
             await asyncio.sleep(0)
 
+            svcinfo = svcdef['svcinfo']
+
             # TODO services by iden indexes (SYN-8467)
-            if svcdef['svcinfo'].get('iden') != iden:
+            if svcinfo.get('iden') != iden:
                 continue
 
-            if online and svcdef['svcinfo'].get('online') is None:
+            if online and svcinfo.get('online') is None:
                 continue
 
-            svcrun = svcdef['svcinfo'].get('run')
+            svcrun = svcinfo.get('run')
             if svcrun in runs:
                 continue
 
             if skiprun == svcrun:
                 continue
 
+            # prefer the real service entry over the leader alias for a run
+            if svcdef.get('svcname') == svcinfo.get('leader'):
+                aliases.setdefault(svcrun, svcdef)
+                continue
+
             runs.add(svcrun)
             yield svcdef
 
+        for svcrun, svcdef in aliases.items():
+            if svcrun not in runs:
+                yield svcdef
+
     def getAhaSvcUrl(self, svcdef, user='root'):
         svcfull = svcdef.get('name')
         svcnetw = svcdef.get('svcnetw')

{synapse-2.253.0 → synapse-2.255.0}/synapse/lib/cell.py

@@ -1063,7 +1063,8 @@ class Cell(s_nexus.Pusher, s_telepath.Aware):
             'type': 'string',
         },
         'aha:promotable': {
-            'description': 'Set to false to prevent this service from being promoted to leader.',
+            'description': 'Set to false to exclude this service from automatic leader selection when the leader demotes, '
+                           'including during a graceful shutdown. It does not prevent an explicit promotion.',
             'type': 'boolean',
             'default': True,
         },
@@ -2639,7 +2640,7 @@ class Cell(s_nexus.Pusher, s_telepath.Aware):
         retn = []
         async for svcdef in ahaproxy.getAhaSvcsByIden(self.iden, skiprun=self.runid):
 
-            if not svcdef['svcinfo'].get('promotable'): # pragma: no cover
+            if not svcdef['svcinfo'].get('promotable'):
                 continue
 
             retn.append(svcdef)
@@ -2688,7 +2689,7 @@ class Cell(s_nexus.Pusher, s_telepath.Aware):
                     logger.warning('...no suitable services discovered. Aborting demotion.', extra=extra)
                     return False
 
-                for svcindx, svcproxy in sorted(cands):
+                for svcindx, svcproxy in sorted(cands, key=lambda c: c[0], reverse=True):
 
                     try:
                         await svcproxy.promote(graceful=True)
@@ -5011,7 +5012,7 @@ class Cell(s_nexus.Pusher, s_telepath.Aware):
         # we can ignore the yielded aha names because we embed it in the task
         async for (ahasvc, (ok, retn)) in self.callPeerGenr(todo, timeout=timeout):
 
-            if not ok: # pragma: no cover
+            if not ok:
                 logger.warning(f'getTasks() on {ahasvc} failed: {retn}')
                 continue
 

{synapse-2.253.0 → synapse-2.255.0}/synapse/lib/nexus.py

@@ -718,7 +718,10 @@ class NexsRoot(s_base.Base):
                     except Exception as e:
                         if respfutu is not None:
                             assert not respfutu.done()
-                            respfutu.set_exception(e)
+
+                            # the head of the traceback is our own still running frame
+                            # and the caller may clear the frames of the traceback it gets.
+                            respfutu.set_exception(e.with_traceback(e.__traceback__.tb_next))
                         else:  # pragma: no cover
                             logger.exception(e)
 

{synapse-2.253.0 → synapse-2.255.0}/synapse/lib/stormlib/model.py

@@ -1,3 +1,5 @@
+import asyncio
+
 import synapse.exc as s_exc
 import synapse.common as s_common
 
@@ -5,6 +7,7 @@ import synapse.lib.node as s_node
 import synapse.lib.time as s_time
 import synapse.lib.cache as s_cache
 import synapse.lib.layer as s_layer
+import synapse.lib.storm as s_storm
 import synapse.lib.stormtypes as s_stormtypes
 
 RISK_HASVULN_VULNPROPS = (
@@ -917,6 +920,61 @@ class LibModelMigration(s_stormtypes.Lib, MigrationEditorMixin):
                       {'name': 'dst', 'type': 'node', 'desc': 'The node to merge into (will be kept).', },
                   ),
                   'returns': {'type': 'null', }}},
+        {'name': 'loop', 'desc': '''
+            Run a migration callback once for every view, and optionally for every layer which is
+            not the write layer of a view, in the Cortex.
+
+            Callbacks are embedded Storm queries (``${ ... }``) or query strings, rather than Storm
+            functions. Variables from the calling scope, including any captured by an embedded
+            query, are not available to them, and nodes are not passed in. Messages from
+            ``$lib.print()``, ``$lib.warn()``, ``$lib.fire()`` and ``$lib.csv.emit()`` in a callback
+            are passed through to the caller.
+
+            - The ``onview`` callback runs in each view, and can use ``$lib.view.get()`` to access it.
+            - The optional ``onlayer`` callback runs in the calling view, with ``$layer`` set to the
+              iden of that layer, and can use ``$lib.layer.get($layer)`` to access it. It only runs
+              for layers which are not the write layer of a view, such as a layer which is only
+              lower in the layer stack of a view, or a layer in no view, since ``onview`` already
+              migrated each view's write layer.
+
+            Each pass runs ``onview`` for every view, with parent views before their children, then
+            ``onlayer`` for every layer which is not the write layer of a view. A view or layer
+            created by a callback is picked up by a further pass, and passes repeat until one finds
+            nothing new. Each view and layer is visited at most once.
+
+            The loop does not fail because a view or layer changed underneath it. It emits a
+            warning naming the view or layer and continues with the next one when:
+
+            - A view or layer is deleted before its callback runs, or while its callback runs.
+            - A layer, or the write layer of a view, is read-only. These are skipped unless
+              ``readonly`` is true, which is intended for migrations which only lift nodes.
+            - A layer, or the write layer of a view, becomes read-only while its callback runs.
+
+            Any other error raised by a callback is raised to the caller.
+
+            The caller must be a global admin.
+
+            Examples:
+                Replace a tag on nodes in every view and print each layer which is not the write
+                layer of a view::
+
+                    $lib.model.migration.loop(
+                        ${ inet:fqdn#old.tag [ -#old.tag +#new.tag ] },
+                        onlayer=${ $lib.print(`migrating layer {$layer}`) },
+                    )
+            ''',
+         'type': {'type': 'function', '_funcname': '_methLoop',
+                  'args': (
+                      {'name': 'onview', 'type': ['str', 'storm:query'],
+                       'desc': 'A Storm query to run in each view.', },
+                      {'name': 'onlayer', 'type': ['null', 'str', 'storm:query'], 'default': None,
+                       'desc': 'A Storm query to run for each layer which is not the write layer of a view, '
+                               'with ``$layer`` set to the layer iden.', },
+                      {'name': 'readonly', 'type': 'boolean', 'default': False,
+                       'desc': 'Include read-only layers, and views with a read-only write layer, '
+                               'rather than skipping them with a warning.', },
+                  ),
+                  'returns': {'type': 'null', }}},
     )
     _storm_lib_path = ('model', 'migration')
 
@@ -927,6 +985,7 @@ class LibModelMigration(s_stormtypes.Lib, MigrationEditorMixin):
             'copyTags': self._methCopyTags,
             'copyExtProps': self._methCopyExtProps,
             'fuse': self._methFuse,
+            'loop': self._methLoop,
         }
 
     async def _methCopyData(self, src, dst, overwrite=False):
@@ -1027,6 +1086,147 @@ class LibModelMigration(s_stormtypes.Lib, MigrationEditorMixin):
             mesg += ', '.join([f'{iden} ({errm})' for iden, errm in failed])
             raise s_exc.SynErr(mesg=mesg, layers=[iden for iden, _ in failed])
 
+    async def _methLoop(self, onview, onlayer=None, readonly=False):
+
+        self.runt.reqAdmin(mesg='$lib.model.migration.loop() requires global admin.')
+
+        if onview is None:
+            raise s_exc.BadArg(mesg='$lib.model.migration.loop() requires an onview query.')
+
+        readonly = await s_stormtypes.tobool(readonly)
+
+        runt = self.runt
+        core = runt.snap.core
+
+        async def getQuery(valu):
+
+            text = await s_stormtypes.tostr(valu, noneok=True)
+            if text is None:
+                return None
+
+            return await runt.getStormQuery(text)
+
+        async def runQuery(query, snap, opts=None):
+
+            # not a sub-runtime, so the caller's variables are not visible
+            async with await s_storm.Runtime.anit(query, snap, user=runt.user, opts=opts) as subr:
+                subr.debug = runt.debug
+                subr.asroot = runt.asroot
+                subr.readonly = runt.readonly
+
+                if subr.snap is not runt.snap:
+                    subr.snap._warnonce_keys = runt.snap._warnonce_keys
+                    for evnt in ('print', 'warn', 'storm:fire', 'csv:row'):
+                        await subr.enter_context(subr.snap.onWith(evnt, runt.snap.dist))
+
+                async for _ in subr.execute():
+                    await asyncio.sleep(0)
+
+        def getDesc(iden, name):
+            if name is None:
+                return iden
+
+            return f'{iden} ({name})'
+
+        def isWriteLayer(iden):
+            if iden in wlyrs:
+                return True
+
+            return any(view.layers[0].iden == iden for view in core.views.values())
+
+        viewq = await getQuery(onview)
+        layrq = await getQuery(onlayer)
+
+        seen = set()
+        wlyrs = set()
+
+        while True:
+
+            found = False
+
+            for vdef in await core.getViewDefs(deporder=True):
+
+                iden = vdef.get('iden')
+                if iden in seen:
+                    continue
+
+                seen.add(iden)
+                found = True
+
+                desc = getDesc(iden, vdef.get('name'))
+
+                view = core.views.get(iden)
+                if view is None or view.isfini:
+                    await runt.warn(f'View {desc} was deleted before it could be migrated.')
+                    continue
+
+                wlyrs.add(view.layers[0].iden)
+
+                wasro = view.layers[0].readonly
+                if wasro and not readonly:
+                    await runt.warn(f'View {desc} has a read-only write layer and was skipped.')
+                    continue
+
+                try:
+                    await runQuery(viewq, await view.snap(runt.user))
+
+                except s_exc.SynErr as e:
+
+                    view = core.views.get(iden)
+                    if view is None or view.isfini:
+                        await runt.warn(f'View {desc} was deleted while being migrated.')
+                        continue
+
+                    if isinstance(e, s_exc.IsReadOnly) and not wasro and view.layers[0].readonly:
+                        await runt.warn(f'View {desc} became read-only while being migrated.')
+                        continue
+
+                    raise
+
+            if layrq is not None:
+
+                for layr in list(core.listLayers()):
+
+                    iden = layr.iden
+                    if iden in seen or isWriteLayer(iden):
+                        continue
+
+                    seen.add(iden)
+                    found = True
+
+                    desc = getDesc(iden, layr.layrinfo.get('name'))
+
+                    layr = core.layers.get(iden)
+                    if layr is None or layr.isfini:
+                        await runt.warn(f'Layer {desc} was deleted before it could be migrated.')
+                        continue
+
+                    wasro = layr.readonly
+                    if wasro and not readonly:
+                        await runt.warn(f'Layer {desc} is read-only and was skipped.')
+                        continue
+
+                    opts = {'vars': {'layer': iden}}
+
+                    try:
+                        await runQuery(layrq, runt.snap, opts)
+
+                    except s_exc.SynErr as e:
+
+                        layr = core.layers.get(iden)
+                        if layr is None or layr.isfini:
+                            await runt.warn(f'Layer {desc} was deleted while being migrated.')
+                            continue
+
+                        if isinstance(e, s_exc.IsReadOnly) and not wasro and layr.readonly:
+                            await runt.warn(f'Layer {desc} became read-only while being migrated.')
+                            continue
+
+                        raise
+
+            if not found:
+                break
+
 @s_stormtypes.registry.registerLib
 class LibModelMigrations(s_stormtypes.Lib, MigrationEditorMixin):
     '''
@@ -1085,11 +1285,47 @@ class LibModelMigrations(s_stormtypes.Lib, MigrationEditorMixin):
                       {'name': 'n', 'type': 'node', 'desc': 'The inet:sevice:message node to migrate.'},
                  ),
                  'returns': {'type': 'null'}}},
+        {'name': 'inetServiceInstanceToPlatform', 'desc': '''
+            Create an inet:service:platform node from the provided inet:service:instance node.
+
+            Edits will be made in the current write layer.
+
+            The inet:service:platform node is created with the same guid as the
+            inet:service:instance node and its :parent property is set to the
+            :platform of the instance. If the :platform of the instance has the same
+            guid as the instance, :parent is not set and a warning is emitted.
+            The :owner and :app properties are stored in node data under the keys
+            'migration:inet:service:instance:owner' and
+            'migration:inet:service:instance:app'. Extended properties on the
+            inet:service:instance node are not copied to the inet:service:platform node.
+
+            Tags, tag properties, edges, and node data will be copied
+            to the inet:service:platform node. However, existing tag properties and
+            node data will not be overwritten.
+
+            Nodes in the current view which reference the instance using a
+            :instance or :service:instance property are updated to use the
+            :platform or :service:platform property instead. If that property is
+            already set to a platform other than the new platform or the :parent,
+            the existing value is kept and the instance is stored in node data
+            under the key 'migration:<form>:<prop>'. Extended properties are only
+            updated if a matching inet:service:platform property exists.
+
+            The inet:service:instance node is not deleted and may be removed
+            once the migration has been verified.
+        ''',
+        'type': {'type': 'function', '_funcname': '_storm_query',
+                 'args': (
+                      {'name': 'n', 'type': 'node', 'desc': 'The inet:service:instance node to migrate.'},
+                      {'name': 'nodata', 'type': 'boolean', 'default': False,
+                       'desc': 'Do not copy nodedata to the inet:service:platform node.'},
+                 ),
+                 'returns': {'type': 'node', 'desc': 'The inet:service:platform node.'}}},
 
     )
     _storm_lib_path = ('model', 'migration', 's')
     _storm_query = '''
-        function inetSslCertToTlsServerCert(n, nodata=$lib.false) {
+        function inetSslCertToTlsServerCert(n, nodata=(false)) {
             $form = $n.form()
             if ($form != 'inet:ssl:cert') {
                 $mesg = `$lib.model.migration.s.inetSslCertToTlsServerCert() only accepts inet:ssl:cert nodes, not {$form}`
@@ -1117,10 +1353,10 @@ class LibModelMigrations(s_stormtypes.Lib, MigrationEditorMixin):
 
             [ .seen ?= $n.props.".seen" ]
 
-            $lib.model.migration.copyTags($n, $node, overwrite=$lib.false)
+            $lib.model.migration.copyTags($n, $node, overwrite=(false))
             $lib.model.migration.copyEdges($n, $node)
             if (not $nodata) {
-                $lib.model.migration.copyData($n, $node, overwrite=$lib.false)
+                $lib.model.migration.copyData($n, $node, overwrite=(false))
             }
 
             return($node)
@@ -1147,6 +1383,64 @@ class LibModelMigrations(s_stormtypes.Lib, MigrationEditorMixin):
 
             return()
         }
+
+        function inetServiceInstanceToPlatform(n, nodata=(false)) {
+            if (not $n.isform(inet:service:instance)) {
+                $mesg = `$lib.model.migration.s.inetServiceInstanceToPlatform() only accepts inet:service:instance nodes, not {$n.form()}`
+                $lib.raise(BadArg, $mesg)
+            }
+
+            $iden = $n.value()
+            $parent = $n.props.platform
+
+            $plat = {[ inet:service:platform=$iden ]}
+
+            if ($parent = $iden) {
+                $lib.warn(`The :platform of inet:service:instance={$iden} has the same guid as the instance, so :parent was not set on the inet:service:platform.`)
+            } elif ($parent != null) {
+                $plat.props.set(parent, $parent)
+            }
+
+            for $name in (id, url, name, desc, period, status, creator, tenant, ".seen") {
+                $valu = $n.props.$name
+                if ($valu != null) { $plat.props.set($name, $valu) }
+            }
+
+            for $name in (owner, app) {
+                $valu = $n.props.$name
+                if ($valu != null) { $plat.data.set(`migration:inet:service:instance:{$name}`, $valu) }
+            }
+
+            $lib.model.migration.copyTags($n, $plat, overwrite=(false))
+            $lib.model.migration.copyEdges($n, $plat)
+            if (not $nodata) {
+                $lib.model.migration.copyData($n, $plat, overwrite=(false))
+            }
+
+            yield $n <- *
+
+            $refform = $node.form()
+            for ($name, $valu) in $node.props {
+                if ($valu != $iden) { continue }
+
+                if ($lib.model.prop(`{$refform}:{$name}`).type.name != 'inet:service:instance') { continue }
+
+                $pname = $lib.regex.replace('instance$', 'platform', $name)
+                $pprop = $lib.model.prop(`{$refform}:{$pname}`)
+                if ($pprop = null or $pprop.type.name != 'inet:service:platform') { continue }
+
+                $curv = $node.props.$pname
+                if ($curv = null or $curv = $parent or $curv = $iden) {
+                    $node.props.set($pname, $iden)
+                } else {
+                    $node.data.set(`migration:{$refform}:{$name}`, $valu)
+                }
+
+                $node.props.set($name, $lib.undef)
+            }
+
+            fini { return($plat) }
+        }
     '''
 
     def getObjLocals(self):

{synapse-2.253.0 → synapse-2.255.0}/synapse/lib/stormlib/task.py

@@ -11,10 +11,12 @@ stormcmds = [
         'descr': 'List running tasks on the Cortex and any mirrors.',
         'cmdargs': (
             ('--verbose', {'default': False, 'action': 'store_true', 'help': 'Enable verbose output.'}),
+            ('--timeout', {'type': 'int', 'default': None,
+                           'help': 'The timeout in seconds to wait for each peer to respond.'}),
         ),
         'storm': '''
             $tcnt = (0)
-            for $task in $lib.task.list() {
+            for $task in $lib.task.list(timeout=$cmdopts.timeout) {
                 $lib.print(`task iden: {$task.iden}`)
                 $lib.print(`    name: {$task.name}`)
                 $lib.print(`    user: {$task.username}`)
@@ -41,9 +43,11 @@ stormcmds = [
         'descr': 'Kill a running task on the Cortex or a mirror.',
         'cmdargs': (
             ('iden', {'help': 'Any prefix that matches exactly one valid task iden is accepted.'}),
+            ('--timeout', {'type': 'int', 'default': None,
+                           'help': 'The timeout in seconds to wait for each peer to respond.'}),
         ),
         'storm': '''
-            $kild = $lib.task.kill($cmdopts.iden)
+            $kild = $lib.task.kill($cmdopts.iden, timeout=$cmdopts.timeout)
             $lib.print("kill status: {kild}", kild=$kild)
         ''',
     },
@@ -56,13 +60,17 @@ class LibTask(s_stormtypes.Lib):
     '''
     _storm_locals = (
         {'name': 'list', 'desc': 'List tasks the current user can access on the Cortex and its mirrors.',
-         'type': {'type': 'function', '_funcname': '_methTaskList', 'args': (),
+         'type': {'type': 'function', '_funcname': '_methTaskList', 'args': (
+                      {'name': 'timeout', 'type': 'int', 'default': None,
+                       'desc': 'The number of seconds to wait for each peer to respond.'},),
                   'returns': {'name': 'yields', 'type': 'dict', 'desc': 'Task definitions.'}}},
         {'name': 'kill', 'desc': 'Stop a running task on the Cortex or a mirror.',
          'type': {'type': 'function', '_funcname': '_methTaskKill', 'args': (
                       {'name': 'prefix', 'type': 'str',
                        'desc': 'The prefix of the task to stop. '
-                               'Tasks will only be stopped if there is a single prefix match.'},),
+                               'Tasks will only be stopped if there is a single prefix match.'},
+                      {'name': 'timeout', 'type': 'int', 'default': None,
+                       'desc': 'The number of seconds to wait for each peer to respond.'},),
                   'returns': {'type': 'boolean', 'desc': 'True if the task was cancelled, False otherwise.'}}},
     )
     _storm_lib_path = ('task',)
@@ -82,25 +90,27 @@ class LibTask(s_stormtypes.Lib):
         }
 
     @s_stormtypes.stormfunc(readonly=True)
-    async def _methTaskList(self):
+    async def _methTaskList(self, timeout=None):
         useriden = self.runt.user.iden
         isallowed = self.runt.allowed(('task', 'get'))
+        timeout = await s_stormtypes.toint(timeout, noneok=True)
 
-        async for task in self.runt.snap.core.getTasks():
+        async for task in self.runt.snap.core.getTasks(timeout=timeout):
             if isallowed or task['user'] == useriden:
                 yield task
 
-    async def _methTaskKill(self, prefix):
+    async def _methTaskKill(self, prefix, timeout=None):
         useriden = self.runt.user.iden
         isallowed = self.runt.allowed(('task', 'del'))
 
         prefix = await s_stormtypes.tostr(prefix)
+        timeout = await s_stormtypes.toint(timeout, noneok=True)
         if not prefix:
             mesg = 'An empty task iden prefix is not allowed.'
             raise s_exc.StormRuntimeError(mesg=mesg, iden=prefix)
 
         iden = None
-        async for task in self.runt.snap.core.getTasks():
+        async for task in self.runt.snap.core.getTasks(timeout=timeout):
             taskiden = task['iden']
             if (isallowed or task['user'] == useriden) and taskiden.startswith(prefix):
                 if iden is None:
@@ -113,4 +123,4 @@ class LibTask(s_stormtypes.Lib):
             mesg = 'Provided iden does not match any tasks.'
             raise s_exc.StormRuntimeError(mesg=mesg, iden=prefix)
 
-        return await self.runt.snap.core.killTask(iden)
+        return await self.runt.snap.core.killTask(iden, timeout=timeout)

{synapse-2.253.0 → synapse-2.255.0}/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, 253, 0)
+version = (2, 255, 0)
 verstring = '.'.join([str(x) for x in version])
-commit = '781db4966ec712dbffc9552eeba5d61a272662e9'
+commit = '8918c39dde3b16ab2ba0f9c6331550cf7ff5e2c6'