synapse 2.192.0__py311-none-any.whl → 2.194.0__py311-none-any.whl

synapse/lib/auth.py

@@ -1545,6 +1545,7 @@ class User(Ruler):
         # Prevent empty string or non-string values
         if passwd is None:
             shadow = None
+            enforce_policy = False
         elif passwd and isinstance(passwd, str):
             shadow = await s_passwd.getShadowV2(passwd=passwd)
         else:

synapse/lib/cell.py

@@ -2623,18 +2623,12 @@ class Cell(s_nexus.Pusher, s_telepath.Aware):
         walkpath(self.backdirn)
         return backups
 
-    async def iterBackupArchive(self, name, user):
-
-        success = False
-        loglevel = logging.WARNING
-
-        path = self._reqBackDirn(name)
-        cellguid = os.path.join(path, 'cell.guid')
-        if not os.path.isfile(cellguid):
-            mesg = 'Specified backup path has no cell.guid file.'
-            raise s_exc.BadArg(mesg=mesg, arg='path', valu=path)
-
+    async def _streamBackupArchive(self, path, user, name):
         link = s_scope.get('link')
+        if link is None:
+            mesg = 'Link not found in scope. This API must be called via a CellApi.'
+            raise s_exc.SynErr(mesg=mesg)
+
         linkinfo = await link.getSpawnInfo()
         linkinfo['logconf'] = await self._getSpawnLogConf()
 
@@ -2642,42 +2636,42 @@ class Cell(s_nexus.Pusher, s_telepath.Aware):
 
         ctx = multiprocessing.get_context('spawn')
 
-        proc = None
-        mesg = 'Streaming complete'
-
         def getproc():
             proc = ctx.Process(target=_iterBackupProc, args=(path, linkinfo))
             proc.start()
             return proc
 
+        mesg = 'Streaming complete'
+        proc = await s_coro.executor(getproc)
+        cancelled = False
         try:
-            proc = await s_coro.executor(getproc)
-
             await s_coro.executor(proc.join)
+            self.backlastuploaddt = datetime.datetime.now()
+            logger.debug(f'Backup streaming completed successfully for {name}')
 
-        except (asyncio.CancelledError, Exception) as e:
+        except asyncio.CancelledError:
+            logger.warning('Backup streaming was cancelled.')
+            cancelled = True
+            raise
 
-            # We want to log all exceptions here, an asyncio.CancelledError
-            # could be the result of a remote link terminating due to the
-            # backup stream being completed, prior to this function
-            # finishing.
+        except Exception as e:
             logger.exception('Error during backup streaming.')
-
-            if proc:
-                proc.terminate()
-
             mesg = repr(e)
             raise
 
-        else:
-            success = True
-            loglevel = logging.DEBUG
-            self.backlastuploaddt = datetime.datetime.now()
-
         finally:
-            phrase = 'successfully' if success else 'with failure'
-            logger.log(loglevel, f'iterBackupArchive completed {phrase} for {name}')
-            raise s_exc.DmonSpawn(mesg=mesg)
+            proc.terminate()
+
+            if not cancelled:
+                raise s_exc.DmonSpawn(mesg=mesg)
+
+    async def iterBackupArchive(self, name, user):
+        path = self._reqBackDirn(name)
+        cellguid = os.path.join(path, 'cell.guid')
+        if not os.path.isfile(cellguid):
+            mesg = 'Specified backup path has no cell.guid file.'
+            raise s_exc.BadArg(mesg=mesg, arg='path', valu=path)
+        await self._streamBackupArchive(path, user, name)
 
     async def iterNewBackupArchive(self, user, name=None, remove=False):
 
@@ -2688,9 +2682,6 @@ class Cell(s_nexus.Pusher, s_telepath.Aware):
             if remove:
                 self.backupstreaming = True
 
-            success = False
-            loglevel = logging.WARNING
-
             if name is None:
                 name = time.strftime('%Y%m%d%H%M%S', datetime.datetime.now().timetuple())
 
@@ -2699,10 +2690,6 @@ class Cell(s_nexus.Pusher, s_telepath.Aware):
                 mesg = 'Backup with name already exists'
                 raise s_exc.BadArg(mesg=mesg)
 
-            link = s_scope.get('link')
-            linkinfo = await link.getSpawnInfo()
-            linkinfo['logconf'] = await self._getSpawnLogConf()
-
             try:
                 await self.runBackup(name)
             except Exception:
@@ -2712,54 +2699,13 @@ class Cell(s_nexus.Pusher, s_telepath.Aware):
                     logger.debug(f'Removed {path}')
                 raise
 
-            await self.boss.promote('backup:stream', user=user, info={'name': name})
-
-            ctx = multiprocessing.get_context('spawn')
-
-            proc = None
-            mesg = 'Streaming complete'
-
-            def getproc():
-                proc = ctx.Process(target=_iterBackupProc, args=(path, linkinfo))
-                proc.start()
-                return proc
-
-            try:
-                proc = await s_coro.executor(getproc)
-
-                await s_coro.executor(proc.join)
-
-            except (asyncio.CancelledError, Exception) as e:
-
-                # We want to log all exceptions here, an asyncio.CancelledError
-                # could be the result of a remote link terminating due to the
-                # backup stream being completed, prior to this function
-                # finishing.
-                logger.exception('Error during backup streaming.')
-
-                if proc:
-                    proc.terminate()
-
-                mesg = repr(e)
-                raise
-
-            else:
-                success = True
-                loglevel = logging.DEBUG
-                self.backlastuploaddt = datetime.datetime.now()
-
-            finally:
-                if remove:
-                    logger.debug(f'Removing {path}')
-                    await s_coro.executor(shutil.rmtree, path, ignore_errors=True)
-                    logger.debug(f'Removed {path}')
-
-                phrase = 'successfully' if success else 'with failure'
-                logger.log(loglevel, f'iterNewBackupArchive completed {phrase} for {name}')
-                raise s_exc.DmonSpawn(mesg=mesg)
+            await self._streamBackupArchive(path, user, name)
 
         finally:
             if remove:
+                logger.debug(f'Removing {path}')
+                await s_coro.executor(shutil.rmtree, path, ignore_errors=True)
+                logger.debug(f'Removed {path}')
                 self.backupstreaming = False
 
     async def isUserAllowed(self, iden, perm, gateiden=None, default=False):

synapse/lib/cli.py

@@ -281,18 +281,26 @@ class Cli(s_base.Base):
 
         await self.fini()
 
-    async def addSignalHandlers(self):
+    async def addSignalHandlers(self):  # pragma: no cover
         '''
         Register SIGINT signal handler with the ioloop to cancel the currently running cmdloop task.
+        Removes the handler when the cli is fini'd.
         '''
-
         def sigint():
-            self.printf('<ctrl-c>')
             if self.cmdtask is not None:
                 self.cmdtask.cancel()
 
         self.loop.add_signal_handler(signal.SIGINT, sigint)
 
+        def onfini():
+            # N.B. This is reaches into some loop / handle internals but
+            # prevents us from removing a handler that overwrote our own.
+            hndl = self.loop._signal_handlers.get(signal.SIGINT, None)  # type: asyncio.Handle
+            if hndl is not None and hndl._callback is sigint:
+                self.loop.remove_signal_handler(signal.SIGINT)
+
+        self.onfini(onfini)
+
     def get(self, name, defval=None):
         return self.locs.get(name, defval)
 
@@ -324,8 +332,12 @@ class Cli(s_base.Base):
         if text is None:
             text = self.cmdprompt
 
-        with patch_stdout():
-            retn = await self.sess.prompt_async(text, vi_mode=self.vi_mode, enable_open_in_editor=True)
+        with patch_stdout():  # pragma: no cover
+            retn = await self.sess.prompt_async(text,
+                vi_mode=self.vi_mode,
+                enable_open_in_editor=True,
+                handle_sigint=False # We handle sigint in the loop
+            )
             return retn
 
     def printf(self, mesg, addnl=True, color=None):
@@ -390,7 +402,7 @@ class Cli(s_base.Base):
                 self.cmdtask = self.schedCoro(coro)
                 await self.cmdtask
 
-            except KeyboardInterrupt:
+            except (KeyboardInterrupt, asyncio.CancelledError):
 
                 if self.isfini:
                     return
@@ -408,11 +420,8 @@ class Cli(s_base.Base):
                 if self.cmdtask is not None:
                     self.cmdtask.cancel()
                     try:
-                        self.cmdtask.result()
-                    except asyncio.CancelledError:
-                        # Wait a beat to let any remaining nodes to print out before we print the prompt
-                        await asyncio.sleep(1)
-                    except Exception:
+                        await asyncio.wait_for(self.cmdtask, timeout=0.1)
+                    except (asyncio.CancelledError, asyncio.TimeoutError):
                         pass
 
     async def runCmdLine(self, line):

synapse/lib/parser.py

@@ -95,6 +95,7 @@ terminalEnglishMap = {
     'TRYSETPLUS': '?+=',
     'TRYSETMINUS': '?-=',
     'UNIVNAME': 'universal property',
+    'UNSET': 'unset',
     'EXPRUNIVNAME': 'universal property',
     'VARTOKN': 'variable',
     'EXPRVARTOKN': 'variable',
@@ -507,7 +508,7 @@ class Parser:
             origexc = e.orig_exc
             if not isinstance(origexc, s_exc.SynErr):
                 raise e.orig_exc # pragma: no cover
-            origexc.errinfo['text'] = self.text
+            origexc.set('text', self.text)
             return s_exc.BadSyntax(**origexc.errinfo)
 
         elif isinstance(e, lark.exceptions.UnexpectedCharacters):  # pragma: no cover
@@ -642,6 +643,8 @@ ruleClassMap = {
     'andexpr': s_ast.AndCond,
     'baresubquery': s_ast.SubQuery,
     'catchblock': s_ast.CatchBlock,
+    'condsetoper': s_ast.CondSetOper,
+    'condtrysetoper': lambda astinfo, kids: s_ast.CondSetOper(astinfo, kids, errok=True),
     'condsubq': s_ast.SubqCond,
     'dollarexpr': s_ast.DollarExpr,
     'edgeaddn1': s_ast.EditEdgeAdd,
@@ -657,6 +660,7 @@ ruleClassMap = {
     'formname': s_ast.FormName,
     'editpropdel': lambda astinfo, kids: s_ast.EditPropDel(astinfo, kids[1:]),
     'editpropset': s_ast.EditPropSet,
+    'editcondpropset': s_ast.EditCondPropSet,
     'edittagadd': s_ast.EditTagAdd,
     'edittagdel': lambda astinfo, kids: s_ast.EditTagDel(astinfo, kids[1:]),
     'edittagpropset': s_ast.EditTagPropSet,

synapse/lib/snap.py

@@ -362,10 +362,10 @@ class ProtoNode:
             try:
                 valu, norminfo = prop.type.norm(valu)
             except s_exc.BadTypeValu as e:
-                oldm = e.errinfo.get('mesg')
-                e.errinfo['prop'] = prop.name
-                e.errinfo['form'] = prop.form.name
-                e.errinfo['mesg'] = f'Bad prop value {prop.full}={valu!r} : {oldm}'
+                oldm = e.get('mesg')
+                e.update({'prop': prop.name,
+                          'form': prop.form.name,
+                          'mesg': f'Bad prop value {prop.full}={valu!r} : {oldm}'})
                 if self.ctx.snap.strict:
                     raise e
                 await self.ctx.snap.warn(e)
@@ -493,7 +493,7 @@ class SnapEditor:
             try:
                 valu, norminfo = form.type.norm(valu)
             except s_exc.BadTypeValu as e:
-                e.errinfo['form'] = form.name
+                e.set('form', form.name)
                 if self.snap.strict: raise e
                 await self.snap.warn(f'addNode() BadTypeValu {form.name}={valu} {e}')
                 return None
@@ -1404,25 +1404,54 @@ class Snap(s_base.Base):
 
         trycast = vals.pop('$try', False)
         addprops = vals.pop('$props', None)
-        if addprops is not None:
-            props.update(addprops)
 
-        try:
-            for name, valu in list(props.items()):
+        if not vals:
+            mesg = f'No values provided for form {form.full}'
+            raise s_exc.BadTypeValu(mesg=mesg)
+
+        for name, valu in list(props.items()):
+            try:
                 props[name] = form.reqProp(name).type.norm(valu)
+            except s_exc.BadTypeValu as e:
+                mesg = e.get('mesg')
+                e.update({
+                    'prop': name,
+                    'form': form.name,
+                    'mesg': f'Bad value for prop {form.name}:{name}: {mesg}',
+                })
+                raise e
 
-            for name, valu in vals.items():
+        if addprops is not None:
+            for name, valu in addprops.items():
+                try:
+                    props[name] = form.reqProp(name).type.norm(valu)
+                except s_exc.BadTypeValu as e:
+                    mesg = e.get("mesg")
+                    if not trycast:
+                        e.update({
+                            'prop': name,
+                            'form': form.name,
+                            'mesg': f'Bad value for prop {form.name}:{name}: {mesg}'
+                        })
+                        raise e
+                    await self.warn(f'Skipping bad value for prop {form.name}:{name}: {mesg}')
+
+        for name, valu in vals.items():
 
+            try:
                 prop = form.reqProp(name)
                 norm, norminfo = prop.type.norm(valu)
 
                 norms[name] = (prop, norm, norminfo)
                 proplist.append((name, norm))
-        except s_exc.BadTypeValu as e:
-            if not trycast: raise
-            mesg = e.errinfo.get('mesg')
-            await self.warn(f'Bad value for prop {name}: {mesg}')
-            return
+            except s_exc.BadTypeValu as e:
+                mesg = e.get('mesg')
+                e.update({
+                    'prop': name,
+                    'form': form.name,
+                    'mesg': f'Bad value for prop {form.name}:{name}: {mesg}',
+                })
+                raise e
 
         proplist.sort()
 

synapse/lib/storm.lark

@@ -39,7 +39,7 @@ _editblock: "[" _editoper* "]"
 
 // A single edit operation
 _editoper: editnodeadd
-            | editpropset | editunivset | edittagpropset | edittagadd
+            | editpropset | editunivset | edittagpropset | edittagadd | editcondpropset
             | editpropdel | editunivdel | edittagpropdel | edittagdel
             | editparens | edgeaddn1 | edgedeln1 | edgeaddn2 | edgedeln2
 
@@ -49,11 +49,13 @@ edittagadd: "+" [SETTAGOPER] tagname [(EQSPACE | EQNOSPACE) _valu]
 editunivdel: EXPRMINUS univprop
 edittagdel: EXPRMINUS tagname
 editpropset: relprop (EQSPACE | EQNOSPACE | MODSET | TRYSET | TRYSETPLUS | TRYSETMINUS) _valu
+editcondpropset: relprop condsetoper _valu
 editpropdel: EXPRMINUS relprop
 editunivset: univprop (EQSPACE | EQNOSPACE | MODSET | TRYSET | TRYSETPLUS | TRYSETMINUS) _valu
 editnodeadd: formname (EQSPACE | EQNOSPACE | MODSET | TRYSET | TRYSETPLUS | TRYSETMINUS) _valu
 edittagpropset: "+" tagprop (EQSPACE | EQNOSPACE | MODSET | TRYSET | TRYSETPLUS | TRYSETMINUS) _valu
 edittagpropdel: EXPRMINUS tagprop
+
 EQSPACE: /((?<=\s)=|=(?=\s))/
 MODSET.4: "+=" | "-="
 TRYSETPLUS.1: "?+="
@@ -61,6 +63,19 @@ TRYSETMINUS.1: "?-="
 TRYSET.1: "?="
 SETTAGOPER: "?"
 
+condsetoper: ("*" UNSET | _DEREF "$" _condvarvaluatom) "="
+    | ("*" UNSET | _DEREF "$" _condvarvaluatom) "?=" -> condtrysetoper
+UNSET: "unset"
+_condvarvaluatom: condvarvalue | condvarderef | condfunccall
+condvarvalue: VARTOKN -> varvalue
+
+!condvarderef: _condvarvaluatom "." (VARTOKN | "$" VARTOKN | _condderefexpr) -> varderef
+_condderefexpr: "$"? conddollarexpr
+conddollarexpr: "(" expror ")" -> dollarexpr
+
+condfunccall: _condvarvaluatom _condcallargs -> funccall
+_condcallargs: _LPARNOSPACE [(_valu | VARTOKN | (VARTOKN | NONQUOTEWORD) (EQSPACE | EQNOSPACE) _valu) ("," (_valu | VARTOKN | (VARTOKN | NONQUOTEWORD) (EQSPACE | EQNOSPACE) _valu))*] ","? ")"
+
 // The set of non-edit non-commands in storm
 
 _oper: stormfunc | initblock | emptyblock | finiblock | trycatch | subquery | _formpivot | formjoin

synapse/lib/storm.py

@@ -984,7 +984,9 @@ stormcmds = (
                 $ssl = $lib.true
                 if $cmdopts.ssl_noverify { $ssl = $lib.false }
 
-                $resp = $lib.inet.http.get($cmdopts.url, ssl_verify=$ssl)
+                $headers = ({'X-Synapse-Version': $lib.str.join('.', $lib.version.synapse())})
+
+                $resp = $lib.inet.http.get($cmdopts.url, ssl_verify=$ssl, headers=$headers)
 
                 if ($resp.code != 200) {
                     $lib.warn("pkg.load got HTTP code: {code} for URL: {url}", code=$resp.code, url=$cmdopts.url)
@@ -1603,7 +1605,7 @@ stormcmds = (
             function fetchnodes(url, ssl) {
                 $resp = $lib.inet.http.get($url, ssl_verify=$ssl)
                 if ($resp.code = 200) {
-                    $nodes = $lib.list()
+                    $nodes = ()
                     for $valu in $resp.msgpack() {
                         $nodes.append($valu)
                     }
@@ -3552,7 +3554,7 @@ class HelpCmd(Cmd):
                 await runt.printf(line)
 
         else:  # pragma: no cover
-            raise s_exc.StormRuntimeError(mesgf=f'Unknown bound method {func}')
+            raise s_exc.StormRuntimeError(mesg=f'Unknown bound method {func}')
 
     async def _handleStormLibMethod(self, func, runt: Runtime, verbose: bool =False):
         # Storm library methods must be derived from a library definition.
@@ -3583,7 +3585,7 @@ class HelpCmd(Cmd):
                 await runt.printf(line)
 
         else:  # pragma: no cover
-            raise s_exc.StormRuntimeError(mesgf=f'Unknown runtime lib method {func} {cls} {fname}')
+            raise s_exc.StormRuntimeError(mesg=f'Unknown runtime lib method {func} {cls} {fname}')
 
 class DiffCmd(Cmd):
     '''
@@ -5344,6 +5346,12 @@ class ParallelCmd(Cmd):
         inet:ipv4#foo | parallel { $place = $lib.import(foobar).lookup(:latlong) [ :place=$place ] }
 
     NOTE: Storm variables set within the parallel query pipelines do not interact.
+
+    NOTE: If there are inbound nodes to the parallel command, parallel pipelines will be created as each node
+          is processed, up to the number specified by --size. If the number of nodes in the pipeline is less
+          than the value specified by --size, additional pipelines with no inbound node will not be created.
+          If there are no inbound nodes to the parallel command, the number of pipelines specified by --size
+          will always be created.
     '''
     name = 'parallel'
     readonly = True
@@ -5400,19 +5408,33 @@ class ParallelCmd(Cmd):
             inq = asyncio.Queue(maxsize=size)
             outq = asyncio.Queue(maxsize=size)
 
-            async def pump():
-                try:
-                    async for pumpitem in genr:
-                        await inq.put(pumpitem)
-                    [await inq.put(None) for i in range(size)]
-                except asyncio.CancelledError:  # pragma: no cover
-                    raise
-                except Exception as e:
-                    await outq.put(e)
-
-            base.schedCoro(pump())
-            for i in range(size):
-                base.schedCoro(self.pipeline(runt, query, inq, outq))
+            tsks = 0
+            try:
+                while tsks < size:
+                    await inq.put(await genr.__anext__())
+                    base.schedCoro(self.pipeline(runt, query, inq, outq))
+                    tsks += 1
+            except StopAsyncIteration:
+                [await inq.put(None) for i in range(tsks)]
+
+            # If a full set of tasks were created, keep pumping nodes into the queue
+            if tsks == size:
+                async def pump():
+                    try:
+                        async for pumpitem in genr:
+                            await inq.put(pumpitem)
+                        [await inq.put(None) for i in range(size)]
+                    except Exception as e:
+                        await outq.put(e)
+
+                base.schedCoro(pump())
+
+            # If no tasks were created, make a full set
+            elif tsks == 0:
+                tsks = size
+                for i in range(size):
+                    base.schedCoro(self.pipeline(runt, query, inq, outq))
+                [await inq.put(None) for i in range(tsks)]
 
             exited = 0
             while True:
@@ -5423,7 +5445,7 @@ class ParallelCmd(Cmd):
 
                 if item is None:
                     exited += 1
-                    if exited == size:
+                    if exited == tsks:
                         return
                     continue
 
@@ -5566,9 +5588,6 @@ class TeeCmd(Cmd):
 
             await outq.put(None)
 
-        except asyncio.CancelledError:  # pragma: no cover
-            raise
-
         except Exception as e:
             await outq.put(e)
 

synapse/lib/storm_format.py

@@ -77,6 +77,7 @@ TerminalPygMap = {
     'TRYSETMINUS': p_t.Operator,
     'TRYSETPLUS': p_t.Operator,
     'UNIVNAME': p_t.Name,
+    'UNSET': p_t.Operator,
     'EXPRUNIVNAME': p_t.Name,
     'VARTOKN': p_t.Name.Variable,
     'EXPRVARTOKN': p_t.Name.Variable,

synapse/lib/stormctrl.py

@@ -1,9 +1,91 @@
 class StormCtrlFlow(Exception):
+    '''
+    Base class all StormCtrlFlow exceptions derive from.
+    '''
+    def __init__(self):
+        raise NotImplementedError
+
+class _SynErrMixin(Exception):
+    '''
+    An exception mixin to give some control flow classes functionality like SynErr.
+    '''
+    def __init__(self, *args, **info):
+        self.errinfo = info
+        Exception.__init__(self, self._getExcMsg())
+
+    def _getExcMsg(self):
+        props = sorted(self.errinfo.items())
+        displ = ' '.join(['%s=%r' % (p, v) for (p, v) in props])
+        return '%s: %s' % (self.__class__.__name__, displ)
+
+    def _setExcMesg(self):
+        '''Should be called when self.errinfo is modified.'''
+        self.args = (self._getExcMsg(),)
+
+    def __setstate__(self, state):
+        '''Pickle support.'''
+        super(StormCtrlFlow, self).__setstate__(state)
+        self._setExcMesg()
+
+    def items(self):
+        return {k: v for k, v in self.errinfo.items()}
+
+    def get(self, name, defv=None):
+        '''
+        Return a value from the errinfo dict.
+
+        Example:
+
+            try:
+                foothing()
+            except SynErr as e:
+                blah = e.get('blah')
+
+        '''
+        return self.errinfo.get(name, defv)
+
+    def set(self, name, valu):
+        '''
+        Set a value in the errinfo dict.
+        '''
+        self.errinfo[name] = valu
+        self._setExcMesg()
+
+    def setdefault(self, name, valu):
+        '''
+        Set a value in errinfo dict if it is not already set.
+        '''
+        if name in self.errinfo:
+            return
+        self.errinfo[name] = valu
+        self._setExcMesg()
+
+    def update(self, items: dict):
+        '''Update multiple items in the errinfo dict at once.'''
+        self.errinfo.update(items)
+        self._setExcMesg()
+
+class StormLoopCtrl(_SynErrMixin):
+    # Control flow statements for WHILE and FOR loop control
+    statement = ''
+
+class StormGenrCtrl(_SynErrMixin):
+    # Control flow statements for GENERATOR control
+    statement = ''
+
+class StormStop(StormGenrCtrl, StormCtrlFlow):
+    statement = 'stop'
+
+class StormBreak(StormLoopCtrl, StormCtrlFlow):
+    statement = 'break'
+
+class StormContinue(StormLoopCtrl, StormCtrlFlow):
+    statement = 'continue'
+
+class StormExit(_SynErrMixin, StormCtrlFlow): pass
+
+# StormReturn is kept thin since it is commonly used and just
+# needs to be the container for moving an item up a frame.
+class StormReturn(StormCtrlFlow):
     def __init__(self, item=None):
         self.item = item
-
-class StormExit(StormCtrlFlow): pass
-class StormStop(StormCtrlFlow): pass
-class StormBreak(StormCtrlFlow): pass
-class StormReturn(StormCtrlFlow): pass
-class StormContinue(StormCtrlFlow): pass

synapse/lib/stormlib/cache.py

@@ -172,8 +172,12 @@ class FixedCache(s_stormtypes.StormType):
                     await asyncio.sleep(0)
             except s_stormctrl.StormReturn as e:
                 return await s_stormtypes.toprim(e.item)
-            except s_stormctrl.StormCtrlFlow:
-                pass
+            except s_stormctrl.StormCtrlFlow as e:
+                name = e.__class__.__name__
+                if hasattr(e, 'statement'):
+                    name = e.statement
+                exc = s_exc.StormRuntimeError(mesg=f'Storm control flow "{name}" not allowed in cache callbacks.')
+                raise exc from None
 
     async def _reqKey(self, key):
         if s_stormtypes.ismutable(key):

synapse/lib/stormlib/json.py

@@ -93,6 +93,7 @@ class JsonLib(s_stormtypes.Lib):
          'type': {'type': 'function', '_funcname': '_jsonSave',
                   'args': (
                       {'name': 'item', 'type': 'any', 'desc': 'The item to be serialized as a JSON string.', },
+                      {'name': 'indent', 'type': 'int', 'desc': 'Specify a number of spaces to indent with.', 'default': None},
                   ),
                   'returns': {'type': 'str', 'desc': 'The JSON serialized object.', }}},
         {'name': 'schema', 'desc': 'Get a JS schema validation object.',
@@ -115,10 +116,12 @@ class JsonLib(s_stormtypes.Lib):
         }
 
     @s_stormtypes.stormfunc(readonly=True)
-    async def _jsonSave(self, item):
+    async def _jsonSave(self, item, indent=None):
+        indent = await s_stormtypes.toint(indent, noneok=True)
+
         try:
             item = await s_stormtypes.toprim(item)
-            return json.dumps(item)
+            return json.dumps(item, indent=indent)
         except Exception as e:
             mesg = f'Argument is not JSON compatible: {item}'
             raise s_exc.MustBeJsonSafe(mesg=mesg)