synapse 2.165.0__py311-none-any.whl → 2.167.0__py311-none-any.whl

synapse/lib/agenda.py

@@ -16,7 +16,6 @@ import synapse.common as s_common
 
 import synapse.lib.base as s_base
 import synapse.lib.coro as s_coro
-import synapse.lib.provenance as s_provenance
 
 # Agenda: manages running one-shot and periodic tasks in the future ("appointments")
 
@@ -259,6 +258,7 @@ class _Appt:
     _synced_attrs = {
         'doc',
         'name',
+        'pool',
         'created',
         'enabled',
         'errcount',
@@ -271,10 +271,11 @@ class _Appt:
         'lastfinishtime',
     }
 
-    def __init__(self, stor, iden, recur, indx, query, creator, recs, nexttime=None, view=None, created=None):
+    def __init__(self, stor, iden, recur, indx, query, creator, recs, nexttime=None, view=None, created=None, pool=False):
         self.doc = ''
         self.name = ''
         self.stor = stor
+        self.pool = pool
         self.iden = iden
         self.recur = recur  # does this appointment repeat
         self.indx = indx  # incremented for each appt added ever.  Used for nexttime tiebreaking for stable ordering
@@ -339,6 +340,7 @@ class _Appt:
             'ver': 1,
             'doc': self.doc,
             'name': self.name,
+            'pool': self.pool,
             'enabled': self.enabled,
             'recur': self.recur,
             'iden': self.iden,
@@ -366,6 +368,7 @@ class _Appt:
         appt = cls(stor, val['iden'], val['recur'], val['indx'], val['query'], val['creator'], recs, nexttime=val['nexttime'], view=val.get('view'))
         appt.doc = val.get('doc', '')
         appt.name = val.get('name', '')
+        appt.pool = val.get('pool', False)
         appt.created = val.get('created', None)
         appt.laststarttime = val['laststarttime']
         appt.lastfinishtime = val['lastfinishtime']
@@ -562,6 +565,8 @@ class Agenda(s_base.Base):
         view = cdef.get('view')
         created = cdef.get('created')
 
+        pool = cdef.get('pool', False)
+
         recur = incunit is not None
         indx = self._next_indx
         self._next_indx += 1
@@ -602,7 +607,7 @@ class Agenda(s_base.Base):
                 incvals = (incvals, )
             recs.extend(ApptRec(rd, incunit, v) for (rd, v) in itertools.product(reqdicts, incvals))
 
-        appt = _Appt(self, iden, recur, indx, query, creator, recs, nexttime=nexttime, view=view, created=created)
+        appt = _Appt(self, iden, recur, indx, query, creator, recs, nexttime=nexttime, view=view, created=created, pool=pool)
         self._addappt(iden, appt)
 
         appt.doc = cdef.get('doc', '')
@@ -698,6 +703,13 @@ class Agenda(s_base.Base):
         self.tickoff += offs
         self._wake_event.set()
 
+    async def clearRunningStatus(self):
+        '''Used for clearing the running state at startup or change of leadership.'''
+        for appt in list(self.appts.values()):
+            if appt.isrunning:
+                logger.debug(f'Clearing the isrunning flag for {appt.iden}')
+                await self.core.addCronEdits(appt.iden, {'isrunning': False})
+
     async def runloop(self):
         '''
         Task loop to issue query tasks at the right times.
@@ -808,57 +820,75 @@ class Agenda(s_base.Base):
         }
         await self.core.addCronEdits(appt.iden, edits)
 
-        with s_provenance.claim('cron', iden=appt.iden):
-            logger.info(f'Agenda executing for iden={appt.iden}, name={appt.name} user={user.name}, view={appt.view}, query={appt.query}',
-                        extra={'synapse': {'iden': appt.iden, 'name': appt.name, 'user': user.iden, 'text': appt.query,
-                                           'username': user.name, 'view': appt.view}})
-            starttime = self._getNowTick()
-            success = False
-            try:
-                opts = {'user': user.iden, 'view': appt.view, 'vars': {'auto': {'iden': appt.iden, 'type': 'cron'}}}
-                opts = self.core._initStormOpts(opts)
-                view = self.core._viewFromOpts(opts)
-                # Yes, this isn't technically on the bottom half of a nexus transaction
-                # But because the scheduling loop only runs on non-mirrors, we can kinda skirt by all that
-                # and be relatively okay. The only catch is that the nexus offset will correspond to the
-                # last nexus transaction, and not the start/stop
-                await self.core.feedBeholder('cron:start', {'iden': appt.iden})
-                async for node in view.eval(appt.query, opts=opts, log_info={'cron': appt.iden}):
+        logger.info(f'Agenda executing for iden={appt.iden}, name={appt.name} user={user.name}, view={appt.view}, query={appt.query}',
+                    extra={'synapse': {'iden': appt.iden, 'name': appt.name, 'user': user.iden, 'text': appt.query,
+                                       'username': user.name, 'view': appt.view}})
+        starttime = self._getNowTick()
+        success = False
+        try:
+            opts = {
+                'user': user.iden,
+                'view': appt.view,
+                'mirror': appt.pool,
+                'vars': {'auto': {'iden': appt.iden, 'type': 'cron'}},
+            }
+            opts = self.core._initStormOpts(opts)
+
+            await self.core.feedBeholder('cron:start', {'iden': appt.iden})
+
+            async for mesg in self.core.storm(appt.query, opts=opts):
+
+                if mesg[0] == 'node':
                     count += 1
-            except asyncio.CancelledError:
-                result = 'cancelled'
-                raise
-            except Exception as e:
-                result = f'raised exception {e}'
-                logger.exception(f'Agenda job {appt.iden} {appt.name} raised exception',
-                                 extra={'synapse': {'iden': appt.iden, 'name': appt.name}}
-                                 )
-            else:
-                success = True
-                result = f'finished successfully with {count} nodes'
-            finally:
-                finishtime = self._getNowTick()
-                if not success:
-                    appt.lasterrs.append(result)
-                    edits = {
-                        'errcount': appt.errcount + 1,
-                        # we only care about the last five errors
-                        'lasterrs': list(appt.lasterrs[-5:]),
-                    }
-                    await self.core.addCronEdits(appt.iden, edits)
 
-                took = finishtime - starttime
-                mesg = f'Agenda completed query for iden={appt.iden} name={appt.name} with result "{result}" ' \
-                       f'took {took:.3f}s'
-                logger.info(mesg, extra={'synapse': {'iden': appt.iden, 'name': appt.name, 'user': user.iden,
-                                                     'result': result, 'username': user.name, 'took': took}})
+                elif mesg[0] == 'err':
+                    excname, errinfo = mesg[1]
+                    errinfo.pop('eline', None)
+                    errinfo.pop('efile', None)
+                    excctor = getattr(s_exc, excname, s_exc.SynErr)
+                    raise excctor(**errinfo)
+
+        except asyncio.CancelledError:
+            result = 'cancelled'
+            raise
+
+        except Exception as e:
+            result = f'raised exception {e}'
+            logger.exception(f'Agenda job {appt.iden} {appt.name} raised exception',
+                             extra={'synapse': {'iden': appt.iden, 'name': appt.name}}
+                             )
+        else:
+            success = True
+            result = f'finished successfully with {count} nodes'
+
+        finally:
+            finishtime = self._getNowTick()
+            if not success:
+                appt.lasterrs.append(result)
                 edits = {
-                    'lastfinishtime': finishtime,
-                    'isrunning': False,
-                    'lastresult': result,
+                    'errcount': appt.errcount + 1,
+                    # we only care about the last five errors
+                    'lasterrs': list(appt.lasterrs[-5:]),
                 }
+
+                if self.core.isactive:
+                    await self.core.addCronEdits(appt.iden, edits)
+
+            took = finishtime - starttime
+            mesg = f'Agenda completed query for iden={appt.iden} name={appt.name} with result "{result}" ' \
+                   f'took {took:.3f}s'
+            if not self.core.isactive:
+                mesg = mesg + ' Agenda status will not be saved since the Cortex is no longer the leader.'
+            logger.info(mesg, extra={'synapse': {'iden': appt.iden, 'name': appt.name, 'user': user.iden,
+                                                 'result': result, 'username': user.name, 'took': took}})
+            edits = {
+                'lastfinishtime': finishtime,
+                'isrunning': False,
+                'lastresult': result,
+            }
+            if self.core.isactive:
                 await self.core.addCronEdits(appt.iden, edits)
 
-                if not self.isfini:
-                    # fire beholder event before invoking nexus change (in case readonly)
-                    await self.core.feedBeholder('cron:stop', {'iden': appt.iden})
+            if not self.isfini:
+                # fire beholder event before invoking nexus change (in case readonly)
+                await self.core.feedBeholder('cron:stop', {'iden': appt.iden})

synapse/lib/aha.py

@@ -782,6 +782,8 @@ class AhaCell(s_cell.Cell):
 
         svcname, svcnetw, svcfull = self._nameAndNetwork(name, network)
 
+        logger.info(f'Deleting service [{svcfull}].', extra=await self.getLogExtra(name=svcname, netw=svcnetw))
+
         full = ('aha', 'svcfull', svcfull)
         path = ('aha', 'services', svcnetw, svcname)
 

synapse/lib/ast.py

@@ -24,7 +24,6 @@ import synapse.lib.scrape as s_scrape
 import synapse.lib.msgpack as s_msgpack
 import synapse.lib.spooled as s_spooled
 import synapse.lib.stormctrl as s_stormctrl
-import synapse.lib.provenance as s_provenance
 import synapse.lib.stormtypes as s_stormtypes
 
 from synapse.lib.stormtypes import tobool, toint, toprim, tostr, tonumber, tocmprvalu, undef
@@ -1180,33 +1179,32 @@ class CmdOper(Oper):
             mesg = f'Command ({name}) is not marked safe for readonly use.'
             raise self.addExcInfo(s_exc.IsReadOnly(mesg=mesg))
 
-        with s_provenance.claim('stormcmd', name=name):
-            async def genx():
+        async def genx():
 
-                async for node, path in genr:
-                    argv = await self.kids[1].compute(runt, path)
-                    if not await scmd.setArgv(argv):
-                        raise s_stormctrl.StormExit()
+            async for node, path in genr:
+                argv = await self.kids[1].compute(runt, path)
+                if not await scmd.setArgv(argv):
+                    raise s_stormctrl.StormExit()
 
-                    yield node, path
+                yield node, path
 
-            # must pull through the genr to get opts set
-            # ( many commands expect self.opts is set at run() )
-            genr, empty = await pullone(genx())
+        # must pull through the genr to get opts set
+        # ( many commands expect self.opts is set at run() )
+        genr, empty = await pullone(genx())
 
-            try:
-                if runtsafe:
-                    argv = await self.kids[1].compute(runt, None)
-                    if not await scmd.setArgv(argv):
-                        raise s_stormctrl.StormExit()
-
-                if runtsafe or not empty:
-                    async with contextlib.aclosing(scmd.execStormCmd(runt, genr)) as agen:
-                        async for item in agen:
-                            yield item
+        try:
+            if runtsafe:
+                argv = await self.kids[1].compute(runt, None)
+                if not await scmd.setArgv(argv):
+                    raise s_stormctrl.StormExit()
+
+            if runtsafe or not empty:
+                async with contextlib.aclosing(scmd.execStormCmd(runt, genr)) as agen:
+                    async for item in agen:
+                        yield item
 
-            finally:
-                await genr.aclose()
+        finally:
+            await genr.aclose()
 
 class SetVarOper(Oper):
 

synapse/lib/base.py

@@ -143,6 +143,7 @@ class Base:
         self._fini_atexit = False
         self._active_tasks = None       # the set of free running tasks associated with me
         self._context_managers = None   # the set of context managers i must fini
+        self._syn_signal_tasks = None   # initialized as a Set when addSignalHandlers is called.
 
     async def postAnit(self):
         '''
@@ -477,8 +478,6 @@ class Base:
             asyncio.Task: An asyncio.Task object.
 
         '''
-        import synapse.lib.provenance as s_provenance  # avoid import cycle
-
         if __debug__:
             assert inspect.isawaitable(coro)
             import synapse.lib.threads as s_threads  # avoid import cycle
@@ -491,10 +490,6 @@ class Base:
 
         s_scope.clone(task)
 
-        # In rare cases, (Like this function being triggered from call_soon_threadsafe), there's no task context
-        if asyncio.current_task():
-            s_provenance.dupstack(task)
-
         def taskDone(task):
             self._active_tasks.remove(task)
             try:
@@ -565,14 +560,20 @@ class Base:
         '''
         Register SIGTERM/SIGINT signal handlers with the ioloop to fini this object.
         '''
+        if self._syn_signal_tasks is None:
+            self._syn_signal_tasks = set()
 
         def sigterm():
-            print('Caught SIGTERM, shutting down.')
-            asyncio.create_task(self.fini())
+            logger.warning('Caught SIGTERM, shutting down.')
+            task = asyncio.create_task(self.fini())
+            self._syn_signal_tasks.add(task)
+            task.add_done_callback(self._syn_signal_tasks.discard)
 
         def sigint():
-            print('Caught SIGINT, shutting down.')
-            asyncio.create_task(self.fini())
+            logger.warning('Caught SIGINT, shutting down.')
+            task = asyncio.create_task(self.fini())
+            self._syn_signal_tasks.add(task)
+            task.add_done_callback(self._syn_signal_tasks.discard)
 
         loop = asyncio.get_running_loop()
         loop.add_signal_handler(signal.SIGINT, sigint)

synapse/lib/cell.py

@@ -668,26 +668,32 @@ class CellApi(s_base.Base):
 
     @adminapi()
     async def listHiveKey(self, path=None):
+        s_common.deprecated('CellApi.listHiveKey', curv='2.167.0')
         return await self.cell.listHiveKey(path=path)
 
     @adminapi(log=True)
     async def getHiveKeys(self, path):
+        s_common.deprecated('CellApi.getHiveKeys', curv='2.167.0')
         return await self.cell.getHiveKeys(path)
 
     @adminapi(log=True)
     async def getHiveKey(self, path):
+        s_common.deprecated('CellApi.getHiveKey', curv='2.167.0')
         return await self.cell.getHiveKey(path)
 
     @adminapi(log=True)
     async def setHiveKey(self, path, valu):
+        s_common.deprecated('CellApi.setHiveKey', curv='2.167.0')
         return await self.cell.setHiveKey(path, valu)
 
     @adminapi(log=True)
     async def popHiveKey(self, path):
+        s_common.deprecated('CellApi.popHiveKey', curv='2.167.0')
         return await self.cell.popHiveKey(path)
 
     @adminapi(log=True)
     async def saveHiveTree(self, path=()):
+        s_common.deprecated('CellApi.saveHiveTree', curv='2.167.0')
         return await self.cell.saveHiveTree(path=path)
 
     @adminapi()
@@ -1419,7 +1425,6 @@ class Cell(s_nexus.Pusher, s_telepath.Aware):
         if ahaurl is not None:
 
             info = await s_telepath.addAhaUrl(ahaurl)
-            self.ahaclient = info.get('client')
             if self.ahaclient is None:
                 self.ahaclient = await s_telepath.Client.anit(info.get('url'))
                 self.ahaclient._fini_atexit = True
@@ -1560,32 +1565,22 @@ class Cell(s_nexus.Pusher, s_telepath.Aware):
 
         self.ahasvcname = f'{ahaname}.{ahanetw}'
 
-        async def onlink(proxy):
-            while not proxy.isfini:
-                info = await self.getAhaInfo()
+        async def _runAhaRegLoop():
+
+            while not self.isfini:
                 try:
+                    proxy = await self.ahaclient.proxy()
+                    info = await self.getAhaInfo()
                     await proxy.addAhaSvc(ahaname, info, network=ahanetw)
                     if self.isactive and ahalead is not None:
                         await proxy.addAhaSvc(ahalead, info, network=ahanetw)
+                except Exception as e:
+                    logger.exception(f'Error registering service {self.ahasvcname} with AHA: {e}')
+                    await self.waitfini(1)
+                else:
+                    await proxy.waitfini()
 
-                    return
-
-                except asyncio.CancelledError:  # pragma: no cover
-                    raise
-
-                except Exception:
-                    logger.exception('Error in _initAhaService() onlink')
-
-                await proxy.waitfini(1)
-
-        async def fini():
-            await self.ahaclient.offlink(onlink)
-
-        async def init():
-            await self.ahaclient.onlink(onlink)
-            self.onfini(fini)
-
-        self.schedCoro(init())
+        self.schedCoro(_runAhaRegLoop())
 
     async def initServiceRuntime(self):
         pass
@@ -2905,6 +2900,7 @@ class Cell(s_nexus.Pusher, s_telepath.Aware):
         if isnew:
             path = os.path.join(self.dirn, 'hiveboot.yaml')
             if os.path.isfile(path):
+                s_common.deprdate('Initial hive config from hiveboot.yaml', '2024-05-05')
                 logger.debug(f'Loading cell hive from {path}')
                 tree = s_common.yamlload(path)
                 if tree is not None:
@@ -3694,7 +3690,8 @@ class Cell(s_nexus.Pusher, s_telepath.Aware):
 
         await self.ahaclient.waitready()
 
-        mirrors = await self.ahaclient.getAhaSvcMirrors(self.ahasvcname)
+        proxy = await self.ahaclient.proxy(timeout=5)
+        mirrors = await proxy.getAhaSvcMirrors(self.ahasvcname)
         if mirrors is None:
             mesg = 'Service must be configured with AHA to enumerate mirror URLs'
             raise s_exc.NoSuchName(mesg=mesg, name=self.ahasvcname)
@@ -4088,7 +4085,10 @@ class Cell(s_nexus.Pusher, s_telepath.Aware):
         await s_base.Base.addSignalHandlers(self)
 
         def sighup():
-            asyncio.create_task(self.reload())
+            logger.info('Caught SIGHUP, running reloadable subsystems.')
+            task = asyncio.create_task(self.reload())
+            self._syn_signal_tasks.add(task)
+            task.add_done_callback(self._syn_signal_tasks.discard)
 
         loop = asyncio.get_running_loop()
         loop.add_signal_handler(signal.SIGHUP, sighup)

synapse/lib/hive.py

@@ -473,12 +473,15 @@ class HiveApi(s_base.Base):
         self.onfini(self._onHapiFini)
 
     async def loadHiveTree(self, tree, path=(), trim=False):
+        s_common.deprecated('HiveApi.loadHiveTree', curv='2.167.0')
         return await self.hive.loadHiveTree(tree, path=path, trim=trim)
 
     async def saveHiveTree(self, path=()):
+        s_common.deprecated('HiveApi.saveHiveTree', curv='2.167.0')
         return await self.hive.saveHiveTree(path=path)
 
     async def treeAndSync(self, path, iden):
+        s_common.deprecated('HiveApi.treeAndSync', curv='2.167.0')
 
         node = await self.hive.open(path)
 
@@ -510,16 +513,22 @@ class HiveApi(s_base.Base):
         return
 
     async def setAndSync(self, path, valu, iden, nexs=False):
+        s_common.deprecated('HiveApi.setAndSync', curv='2.167.0')
+
         valu = await self.hive.set(path, valu, nexs=nexs)
         await self.msgq.put(('hive:sync', {'iden': iden}))
         return valu
 
     async def addAndSync(self, path, valu, iden):
+        s_common.deprecated('HiveApi.addAndSync', curv='2.167.0')
+
         valu = await self.hive.add(path, valu)
         await self.msgq.put(('hive:sync', {'iden': iden}))
         return valu
 
     async def popAndSync(self, path, iden, nexs=False):
+        s_common.deprecated('HiveApi.popAndSync', curv='2.167.0')
+
         valu = await self.hive.pop(path, nexs=nexs)
         await self.msgq.put(('hive:sync', {'iden': iden}))
         return valu
@@ -531,9 +540,11 @@ class HiveApi(s_base.Base):
         self.msgq.put_nowait(mesg)
 
     async def get(self, full):
+        s_common.deprecated('HiveApi.get', curv='2.167.0')
         return await self.hive.get(full)
 
     async def edits(self):
+        s_common.deprecated('HiveApi.edits', curv='2.167.0')
 
         while not self.isfini:
 

synapse/lib/httpapi.py

@@ -1344,6 +1344,7 @@ class ExtApiHandler(StormHandler):
         varz['_http_request_info'] = info
 
         opts = {
+            'mirror': adef.get('pool', False),
             'readonly': adef.get('readonly'),
             'show': (
                 'http:resp:body',

synapse/lib/nexus.py

@@ -589,10 +589,11 @@ class NexsRoot(s_base.Base):
 
         try:
             await self.cell.ahaclient.waitready(timeout=5)
-            ahainfo = await self.cell.ahaclient.getCellInfo()
+            proxy = await self.cell.ahaclient.proxy(timeout=5)
+            ahainfo = await proxy.getCellInfo()
             ahavers = ahainfo['synapse']['version']
             if self.cell.ahasvcname is not None and ahavers >= (2, 95, 0):
-                await self.cell.ahaclient.modAhaSvcInfo(self.cell.ahasvcname, {'ready': status})
+                await proxy.modAhaSvcInfo(self.cell.ahasvcname, {'ready': status})
 
         except asyncio.CancelledError:  # pragma: no cover  TODO:  remove once >= py 3.8 only
             raise

synapse/lib/node.py

@@ -472,10 +472,12 @@ class Node:
                                    form=self.form.full, tag=tag)
 
         pref = name + '.'
+        exists = self.tags.get(name, s_common.novalu) is not s_common.novalu
 
         todel = [(len(t), t) for t in self.tags.keys() if t.startswith(pref)]
 
-        if len(path) > 1:
+        # only prune when we're actually deleting a tag
+        if len(path) > 1 and exists:
 
             parent = '.'.join(path[:-1])
 
@@ -511,7 +513,7 @@ class Node:
             edits.append((s_layer.EDIT_TAG_DEL, (subtag, None), ()))
 
         edits.extend(self._getTagPropDel(name))
-        if self.getTag(name, defval=s_common.novalu) is not s_common.novalu:
+        if exists:
             edits.append((s_layer.EDIT_TAG_DEL, (name, None), ()))
 
         return edits

synapse/lib/schemas.py

@@ -40,6 +40,7 @@ _HttpExtAPIConfSchema = {
         'name': {'type': 'string', 'default': ''},
         'desc': {'type': 'string', 'default': ''},
         'path': {'type': 'string', 'minlen': 1},
+        'pool': {'type': 'boolean', 'default': False},
         'view': {'type': 'string', 'pattern': s_config.re_iden},
         'runas': {'type': 'string', 'pattern': '^(owner|user)$'},
         'owner': {'type': 'string', 'pattern': s_config.re_iden},
@@ -93,6 +94,7 @@ _CronJobSchema = {
         'iden': {'type': 'string', 'pattern': s_config.re_iden},
         'view': {'type': 'string', 'pattern': s_config.re_iden},
         'name': {'type': 'string'},
+        'pool': {'type': 'boolean'},
         'doc': {'type': 'string'},
         'incunit': {
             'oneOf': [
@@ -170,7 +172,7 @@ reqValidView = s_config.getJsValidator({
         'parent': {'type': ['string', 'null'], 'pattern': s_config.re_iden},
         'creator': {'type': 'string', 'pattern': s_config.re_iden},
         'created': {'type': 'integer', 'minimum': 0},
-        'nomerge': {'type': 'boolean'},
+        'protected': {'type': 'boolean', 'default': False},
         'merging': {'type': 'boolean'},
         'layers': {
             'type': 'array',

synapse/lib/snap.py

@@ -209,6 +209,27 @@ class ProtoNode:
         if tagnode is not s_common.novalu:
             return self.ctx.loadNode(tagnode)
 
+        # check for an :isnow tag redirection in our hierarchy...
+        toks = info.get('toks')
+        for i in range(len(toks)):
+
+            toktag = '.'.join(toks[:i + 1])
+            toknode = await self.ctx.snap.getTagNode(toktag)
+            if toknode is s_common.novalu:
+                continue
+
+            tokvalu = toknode.ndef[1]
+            if tokvalu == toktag:
+                continue
+
+            realnow = tokvalu + norm[len(toktag):]
+            tagnode = await self.ctx.snap.getTagNode(realnow)
+            if tagnode is not s_common.novalu:
+                return self.ctx.loadNode(tagnode)
+
+            norm, info = await self.ctx.snap.getTagNorm(realnow)
+            break
+
         return await self.ctx.addNode('syn:tag', norm, norminfo=info)
 
     def getTag(self, tag):
@@ -657,6 +678,33 @@ class Snap(s_base.Base):
         self.onfini(runt)
         return runt
 
+    async def _joinEmbedStor(self, storage, embeds):
+        for nodePath, relProps in embeds.items():
+            await asyncio.sleep(0)
+            iden = relProps.get('*')
+            if not iden:
+                continue
+
+            stor = await self.view.getStorNodes(s_common.uhex(iden))
+            for relProp in relProps.keys():
+                await asyncio.sleep(0)
+                if relProp == '*':
+                    continue
+
+                for idx, layrstor in enumerate(stor):
+                    await asyncio.sleep(0)
+                    props = layrstor.get('props')
+                    if not props:
+                        continue
+
+                    if relProp not in props:
+                        continue
+
+                    if 'embeds' not in storage[idx]:
+                        storage[idx]['embeds'] = {}
+
+                    storage[idx]['embeds'][f'{nodePath}::{relProp}'] = props[relProp]
+
     async def iterStormPodes(self, text, opts, user=None):
         '''
         Yield packed node tuples for the given storm query text.
@@ -699,6 +747,8 @@ class Snap(s_base.Base):
                 embdef = embeds.get(node.form.name)
                 if embdef is not None:
                     pode[1]['embeds'] = await node.getEmbeds(embdef)
+                    if show_storage:
+                        await self._joinEmbedStor(pode[1]['storage'], pode[1]['embeds'])
 
             yield pode