synapse 2.175.0__tar.gz → 2.176.0__tar.gz

{synapse-2.175.0/synapse.egg-info → synapse-2.176.0}/PKG-INFO

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

{synapse-2.175.0 → synapse-2.176.0}/pyproject.toml

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

{synapse-2.175.0 → synapse-2.176.0}/synapse/cortex.py

@@ -4027,6 +4027,7 @@ class Cortex(s_oauth.OAuthMixin, s_cell.Cell):  # type: ignore
         self.addStormCmd(s_storm.MoveNodesCmd)
         self.addStormCmd(s_storm.BackgroundCmd)
         self.addStormCmd(s_stormlib_macro.MacroExecCmd)
+        self.addStormCmd(s_stormlib_storm.StormExecCmd)
         self.addStormCmd(s_stormlib_stats.StatsCountByCmd)
         self.addStormCmd(s_stormlib_cortex.StormPoolDelCmd)
         self.addStormCmd(s_stormlib_cortex.StormPoolGetCmd)

{synapse-2.175.0 → synapse-2.176.0}/synapse/lib/ast.py

@@ -284,7 +284,7 @@ class Search(Query):
         view = runt.snap.view
 
         if not view.core.stormiface_search:
-            await runt.snap.warn('Storm search interface is not enabled!')
+            await runt.snap.warn('Storm search interface is not enabled!', log=False)
             return
 
         async def searchgenr():
@@ -2389,7 +2389,7 @@ class FormPivot(PivotOper):
                 items = e.items()
                 mesg = items.pop('mesg', '')
                 mesg = ': '.join((f'{e.__class__.__qualname__} [{repr(node.ndef[1])}] during pivot', mesg))
-                await runt.snap.warn(mesg, **items)
+                await runt.snap.warn(mesg, log=False, **items)
 
 class PropPivotOut(PivotOper):
     '''
@@ -2428,7 +2428,7 @@ class PropPivotOut(PivotOper):
                 if runt.model.forms.get(fname) is None:
                     if not warned:
                         mesg = f'The source property "{name}" array type "{fname}" is not a form. Cannot pivot.'
-                        await runt.snap.warn(mesg)
+                        await runt.snap.warn(mesg, log=False)
                         warned = True
                     continue
 
@@ -2452,7 +2452,8 @@ class PropPivotOut(PivotOper):
             fname = prop.type.name
             if prop.modl.form(fname) is None:
                 if warned is False:
-                    await runt.snap.warn(f'The source property "{name}" type "{fname}" is not a form. Cannot pivot.')
+                    await runt.snap.warn(f'The source property "{name}" type "{fname}" is not a form. Cannot pivot.',
+                                         log=False)
                     warned = True
                 continue
 
@@ -2574,7 +2575,7 @@ class PropPivot(PivotOper):
                 items = e.items()
                 mesg = items.pop('mesg', '')
                 mesg = ': '.join((f'{e.__class__.__qualname__} [{repr(valu)}] during pivot', mesg))
-                await runt.snap.warn(mesg, **items)
+                await runt.snap.warn(mesg, log=False, **items)
 
 class Value(AstNode):
     '''

{synapse-2.175.0 → synapse-2.176.0}/synapse/lib/storm.py

@@ -1874,6 +1874,14 @@ class Runtime(s_base.Base):
                     valu.incref()
             self.vars.update(varz)
 
+        self._initRuntVars(query)
+
+        self.proxies = {}
+
+        self.onfini(self._onRuntFini)
+
+    def _initRuntVars(self, query):
+
         # declare path builtins as non-runtsafe
         self.runtvars = {
             'node': False,
@@ -1882,17 +1890,14 @@ class Runtime(s_base.Base):
 
         # inherit runtsafe vars from our root
         if self.root is not None:
-            self.runtvars.update(root.runtvars)
+            self.runtvars.update(self.root.runtvars)
             self.runtvars.update({k: True for k in self.root.getScopeVars().keys()})
 
         # all vars/ctors are de-facto runtsafe
         self.runtvars.update({k: True for k in self.vars.keys()})
         self.runtvars.update({k: True for k in self.ctors.keys()})
 
-        self.proxies = {}
-
         self._loadRuntVars(query)
-        self.onfini(self._onRuntFini)
 
     def getScopeVars(self):
         '''

synapse-2.176.0/synapse/lib/stormlib/storm.py

@@ -0,0 +1,178 @@
+import logging
+
+import synapse.exc as s_exc
+import synapse.common as s_common
+
+import synapse.lib.storm as s_storm
+import synapse.lib.stormtypes as s_stormtypes
+
+evaldesc = '''\
+Evaluate a Storm runtime value and optionally cast/coerce it.
+
+Note:
+    If Storm logging is enabled, the expression being evaluated will be logged
+    separately.
+'''
+
+rundesc = '''
+Run a Storm query and yield the messages output by the Storm interpreter.
+
+Note:
+    If Storm logging is enabled, the query being run will be logged separately.
+'''
+
+stormlogger = logging.getLogger('synapse.storm')
+
+class StormExecCmd(s_storm.Cmd):
+    '''
+    Execute text or an embedded query object as Storm in the current pipeline.
+
+    NOTE: It is recommended to avoid using this where possible to avoid potential
+    query injection risks. If you must use this, take care to ensure any values
+    being executed have been properly sanitized.
+
+    Examples:
+
+        // Add nodes using text in a variable
+        $query = '[ inet:fqdn=foo.com inet:fqdn=bar.net ]'
+        storm.exec $query
+
+        // Filter nodes in the pipeline using text in a variable
+        $filter = '-:asn=10'
+        inet:ipv4:asn
+        storm.exec $filter
+
+        // Pivot using an embedded query
+        $pivot = ${ -> inet:asn }
+        inet:ipv4:asn
+        storm.exec $pivot
+    '''
+    name = 'storm.exec'
+    def getArgParser(self):
+        pars = s_storm.Cmd.getArgParser(self)
+        pars.add_argument('query', help='The Storm to execute.')
+        return pars
+
+    async def execStormCmd(self, runt, genr):
+
+        if self.runtsafe:
+
+            text = await s_stormtypes.tostr(self.opts.query)
+            query = await runt.getStormQuery(text)
+
+            extra = await self.runt.snap.core.getLogExtra(text=text, view=self.runt.snap.view.iden)
+            stormlogger.info(f'Executing storm query via storm.exec {{{text}}} as [{self.runt.user.name}]', extra=extra)
+
+            async with runt.getSubRuntime(query) as subr:
+                async for subp in subr.execute(genr=genr):
+                    yield subp
+
+        else:
+
+            item = None
+            async for item in genr:
+                break
+
+            text = await s_stormtypes.tostr(self.opts.query)
+            query = await runt.getStormQuery(text)
+
+            extra = await self.runt.snap.core.getLogExtra(text=text, view=self.runt.snap.view.iden)
+            stormlogger.info(f'Executing storm query via storm.exec {{{text}}} as [{self.runt.user.name}]', extra=extra)
+
+            async with runt.getSubRuntime(query) as subr:
+                async for subp in subr.execute(genr=s_common.agen(item)):
+                    yield subp
+
+                async for item in genr:
+                    text = await s_stormtypes.tostr(self.opts.query)
+                    query = await runt.getStormQuery(text)
+
+                    subr.runtvars.clear()
+                    subr.query = query
+                    subr._initRuntVars(query)
+
+                    extra = await self.runt.snap.core.getLogExtra(text=text, view=self.runt.snap.view.iden)
+                    stormlogger.info(f'Executing storm query via storm.exec {{{text}}} as [{self.runt.user.name}]', extra=extra)
+
+                    async for subp in subr.execute(genr=s_common.agen(item)):
+                        yield subp
+
+@s_stormtypes.registry.registerLib
+class LibStorm(s_stormtypes.Lib):
+    '''
+    A Storm library for evaluating dynamic storm expressions.
+    '''
+    _storm_locals = (
+        {'name': 'eval', 'desc': evaldesc,
+         'type': {'type': 'function', '_funcname': '_evalStorm',
+                  'args': (
+                      {'name': 'text', 'type': 'str', 'desc': 'A storm expression string.'},
+                      {'name': 'cast', 'type': 'str', 'desc': 'A type to cast the result to.', 'default': None},
+                  ),
+                  'returns': {'type': 'any', 'desc': 'The value of the expression and optional cast.'}}},
+        {'name': 'run', 'desc': rundesc,
+         'type': {'type': 'function', '_funcname': '_runStorm',
+                  'args': (
+                      {'name': 'query', 'type': 'str', 'desc': 'A Storm query string.'},
+                      {'name': 'opts', 'type': 'dict', 'desc': 'Storm options dictionary.', 'default': None},
+                  ),
+                  'returns': {'name': 'yields', 'type': 'list', 'desc': 'The output messages from the Storm runtime.'}}},
+    )
+    _storm_lib_path = ('storm',)
+
+    def getObjLocals(self):
+        return {
+            'run': self._runStorm,
+            'eval': self._evalStorm,
+        }
+
+    async def _runStorm(self, query, opts=None):
+
+        opts = await s_stormtypes.toprim(opts)
+        query = await s_stormtypes.tostr(query)
+
+        if opts is None:
+            opts = {}
+
+        user = opts.get('user')
+        if user is None:
+            user = opts['user'] = self.runt.user.iden
+
+        if user != self.runt.user.iden:
+            self.runt.confirm(('impersonate',))
+
+        opts.setdefault('view', self.runt.snap.view.iden)
+
+        async for mesg in self.runt.snap.view.core.storm(query, opts=opts):
+            yield mesg
+
+    @s_stormtypes.stormfunc(readonly=True)
+    async def _evalStorm(self, text, cast=None):
+
+        text = await s_stormtypes.tostr(text)
+        cast = await s_stormtypes.tostr(cast, noneok=True)
+
+        if self.runt.snap.core.stormlog:
+            extra = await self.runt.snap.core.getLogExtra(text=text, view=self.runt.snap.view.iden)
+            stormlogger.info(f'Executing storm query via $lib.storm.eval() {{{text}}} as [{self.runt.user.name}]', extra=extra)
+
+        casttype = None
+        if cast:
+
+            casttype = self.runt.model.type(cast)
+            if casttype is None:
+                castprop = self.runt.model.prop(cast)
+                if castprop is not None:
+                    casttype = castprop.type
+
+            if casttype is None:
+                mesg = f'No type or property found for name: {cast}'
+                raise s_exc.NoSuchType(mesg=mesg)
+
+        asteval = await self.runt.snap.core._getStormEval(text)
+        valu = await asteval.compute(self.runt, None)
+
+        if casttype:
+            valu, _ = casttype.norm(valu)
+
+        return valu

{synapse-2.175.0 → synapse-2.176.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, 175, 0)
+version = (2, 176, 0)
 verstring = '.'.join([str(x) for x in version])
-commit = 'c331c50ef1e7b2234be997c4b791fb8b8bed7cf2'
+commit = '16ee721a6b7221344eaf946c3ab4602dda546b1a'

{synapse-2.175.0 → synapse-2.176.0}/synapse/models/inet.py

@@ -1519,6 +1519,7 @@ class InetModule(s_module.CoreModule):
                         'doc': 'An object status enumeration.'}),
 
                     ('inet:service:account', ('guid', {}), {
+                        'interfaces': ('inet:service:object',),
                         'doc': 'An account within a service platform. Accounts may be instance specific.'}),
 
                     ('inet:service:permission:type:taxonomy', ('taxonomy', {}), {
@@ -1557,6 +1558,10 @@ class InetModule(s_module.CoreModule):
                         'interfaces': ('inet:service:object',),
                         'doc': 'A channel used to distribute messages.'}),
 
+                    ('inet:service:thread', ('guid', {}), {
+                        'interfaces': ('inet:service:object',),
+                        'doc': 'A message thread.'}),
+
                     ('inet:service:channel:member', ('guid', {}), {
                         'interfaces': ('inet:service:object',),
                         'doc': 'Represents a service account being a member of a channel.'}),
@@ -3657,9 +3662,15 @@ class InetModule(s_module.CoreModule):
                         ('channel', ('inet:service:channel', {}), {
                             'doc': 'The channel that the message was sent to.'}),
 
+                        ('thread', ('inet:service:thread', {}), {
+                            'doc': 'The thread which contains the message.'}),
+
                         ('public', ('bool', {}), {
                             'doc': 'Set to true if the message is publicly visible.'}),
 
+                        ('title', ('str', {'lower': True, 'onespace': True}), {
+                            'doc': 'The message title.'}),
+
                         ('text', ('str', {}), {
                             'disp': {'hint': 'text'},
                             'doc': 'The text body of the message.'}),
@@ -3725,6 +3736,18 @@ class InetModule(s_module.CoreModule):
                             'doc': 'The time period where the channel was available.'}),
                     )),
 
+                    ('inet:service:thread', {}, (
+
+                        ('title', ('str', {'lower': True, 'onespace': True}), {
+                            'doc': 'The title of the thread.'}),
+
+                        ('channel', ('inet:service:channel', {}), {
+                            'doc': 'The channel that contains the thread.'}),
+
+                        ('message', ('inet:service:message', {}), {
+                            'doc': 'The message which initiated the thread.'}),
+                    )),
+
                     ('inet:service:channel:member', {}, (
 
                         ('channel', ('inet:service:channel', {}), {

synapse-2.176.0/synapse/tests/test_lib_stormlib_storm.py

@@ -0,0 +1,144 @@
+import synapse.exc as s_exc
+import synapse.lib.parser as s_parser
+
+import synapse.tests.utils as s_test
+
+class LibStormTest(s_test.SynTest):
+
+    async def test_lib_stormlib_storm_eval(self):
+        async with self.getTestCore() as core:
+
+            opts = {'vars': {'text': '(10)'}}
+            self.eq(10, await core.callStorm('return($lib.storm.eval($text))', opts=opts))
+
+            opts = {'vars': {'text': '10'}}
+            self.eq('10', await core.callStorm('return($lib.storm.eval($text))', opts=opts))
+
+            opts = {'vars': {'text': '10'}}
+            self.eq(10, await core.callStorm('return($lib.storm.eval($text, cast=int))', opts=opts))
+
+            opts = {'vars': {'text': 'WOOT.COM'}}
+            self.eq('woot.com', await core.callStorm('return($lib.storm.eval($text, cast=inet:dns:a:fqdn))', opts=opts))
+
+            opts = {'vars': {'text': '(10 + 20)', 'cast': 'inet:port'}}
+            self.eq(30, await core.callStorm('return($lib.storm.eval($text, cast=$cast))', opts=opts))
+
+            with self.raises(s_exc.NoSuchType):
+                await core.callStorm('return($lib.storm.eval(foo, cast=newp))')
+
+            # for coverage of forked call...
+            self.nn(s_parser.parseEval('woot'))
+
+            # Readonly functionality is sane
+            msgs = await core.stormlist('$lib.print($lib.storm.eval( "{$lib.print(wow)}" ))')
+            self.stormIsInPrint('wow', msgs)
+            self.stormIsInPrint('$lib.null', msgs)
+
+            with self.raises(s_exc.IsReadOnly):
+                await core.callStorm('$lib.storm.eval( "{$lib.auth.users.add(readonly)}" )', opts={'readonly': True})
+
+            with self.getLoggerStream('synapse.storm') as stream:
+                q = '''{
+                    $lib.log.info(hehe)
+                    [test:str=omg]
+                    $lib.log.info($node)
+                    fini { return(wow) }
+                }
+                '''
+
+                core.stormlog = True
+                opts = {'vars': {'q': q}}
+                ret = await core.callStorm('return( $lib.storm.eval($q) )', opts=opts)
+                self.eq(ret, 'wow')
+                self.len(1, await core.nodes('test:str=omg'))
+
+                # Check that we saw the logs
+                stream.seek(0)
+                data = stream.read()
+
+                mesg = 'Executing storm query {return( $lib.storm.eval($q) )} as [root]'
+                self.isin(mesg, data)
+
+                mesg = f'Executing storm query via $lib.storm.eval() {{{q}}} as [root]'
+                self.isin(mesg, data)
+
+    async def test_lib_stormlib_storm(self):
+
+        async with self.getTestCore() as core:
+
+            q = '''
+            $query = '[ inet:fqdn=foo.com inet:fqdn=bar.com ]'
+            storm.exec $query
+            '''
+            self.len(2, await core.nodes(q))
+
+            q = '''[
+            (inet:ipv4=1.2.3.4 :asn=4)
+            (inet:ipv4=1.2.3.5 :asn=5)
+            (inet:ipv4=1.2.3.6 :asn=10)
+            ]'''
+            await core.nodes(q)
+
+            q = '''
+            $filter = '-:asn=10'
+            inet:ipv4:asn
+            storm.exec $filter
+            '''
+            nodes = await core.nodes(q)
+            self.len(2, nodes)
+            for node in nodes:
+                self.ne(node.get('asn'), 10)
+
+            q = '''
+            $pivot = ${ -> inet:asn }
+            inet:ipv4:asn
+            storm.exec $pivot
+            '''
+            nodes = await core.nodes(q)
+            self.len(3, nodes)
+            for node in nodes:
+                self.eq(node.form.name, 'inet:asn')
+
+            # Exec a non-runtsafe query
+            q = '''
+            inet:ipv4:asn
+            $filter = `+:asn={$node.repr().split('.').'-1'}`
+            storm.exec $filter
+            '''
+            nodes = await core.nodes(q)
+            self.len(2, nodes)
+            for node in nodes:
+                self.ne(node.get('asn'), 10)
+
+            iden = await core.callStorm('return($lib.view.get().fork().iden)')
+            msgs = await core.stormlist('''
+                $query = "[inet:fqdn=vertex.link +#haha] $lib.print(woot)"
+                $opts = ({"view": $view})
+                for $mesg in $lib.storm.run($query, opts=$opts) {
+                    if ($mesg.0 = "print") { $lib.print($mesg.1.mesg) }
+                }
+            ''', opts={'vars': {'view': iden}})
+            self.stormIsInPrint('woot', msgs)
+            self.len(1, await core.nodes('inet:fqdn#haha', opts={'view': iden}))
+
+            visi = await core.auth.addUser('visi')
+            msgs = await core.stormlist('''
+                $opts=({"user": $lib.auth.users.byname(root).iden})
+                for $mesg in $lib.storm.run("$lib.print(lolz)", opts=$opts) {
+                    if ($mesg.0 = "err") { $lib.print($mesg) }
+                    if ($mesg.0 = "print") { $lib.print($mesg) }
+                }
+            ''', opts={'user': visi.iden})
+            self.stormIsInErr('must have permission impersonate', msgs)
+            self.stormNotInPrint('lolz', msgs)
+
+            # no opts provided
+            msgs = await core.stormlist('''
+                $q = ${ $lib.print('hello') }
+                for $mesg in $lib.storm.run($q) {
+                    if ( $mesg.0 = 'print' ) {
+                        $lib.print(`mesg={$mesg.1.mesg}`)
+                    }
+                }
+            ''')
+            self.stormIsInPrint('mesg=hello', msgs)

{synapse-2.175.0 → synapse-2.176.0}/synapse/tests/test_model_inet.py

@@ -3300,3 +3300,34 @@ class InetModelTest(s_t_utils.SynTest):
             self.eq(nodes[0].get('resource'), resource.ndef[1])
             self.true(nodes[0].get('success'))
             self.eq(nodes[0].get('time'), 1715856900000)
+
+            q = '''
+            [ inet:service:message=(visi, says, relax)
+                :title="Hehe Haha"
+                :thread={[
+                    inet:service:thread=*
+                        :title="Woot  Woot"
+                        :message=(visi, says, hello)
+                        :channel={[
+                            inet:service:channel=(synapse, subreddit)
+                                :name="/r/synapse"
+                        ]}
+                ]}
+            ]
+            '''
+            nodes = await core.nodes(q)
+            self.len(1, nodes)
+            self.len(1, await core.nodes('inet:service:message=(visi, says, hello) -> inet:service:thread:message'))
+            self.len(1, await core.nodes('''
+                inet:service:message:title="hehe haha"
+                :thread -> inet:service:thread
+                +:title="woot woot"
+            '''))
+            self.len(2, await core.nodes('inet:service:thread -> inet:service:message'))
+
+            self.len(1, await core.nodes('''
+                inet:service:message:title="hehe haha"
+                :thread -> inet:service:thread
+                :channel -> inet:service:channel
+                +:name="/r/synapse"
+            '''))

{synapse-2.175.0 → synapse-2.176.0/synapse.egg-info}/PKG-INFO

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

synapse-2.175.0/synapse/lib/stormlib/storm.py

@@ -1,66 +0,0 @@
-import logging
-
-import synapse.exc as s_exc
-
-import synapse.lib.stormtypes as s_stormtypes
-
-evaldesc = '''\
-Evaluate a storm runtime value and optionally cast/coerce it.
-
-NOTE: If storm logging is enabled, the expression being evaluated will be logged
-separately.
-'''
-
-stormlogger = logging.getLogger('synapse.storm')
-
-@s_stormtypes.registry.registerLib
-class LibStorm(s_stormtypes.Lib):
-    '''
-    A Storm library for evaluating dynamic storm expressions.
-    '''
-    _storm_locals = (
-        {'name': 'eval', 'desc': evaldesc,
-         'type': {'type': 'function', '_funcname': '_evalStorm',
-                  'args': (
-                      {'name': 'text', 'type': 'str', 'desc': 'A storm expression string.'},
-                      {'name': 'cast', 'type': 'str', 'desc': 'A type to cast the result to.', 'default': None},
-                  ),
-                  'returns': {'type': 'any', 'desc': 'The value of the expression and optional cast.', }}},
-    )
-    _storm_lib_path = ('storm',)
-
-    def getObjLocals(self):
-        return {
-            'eval': self._evalStorm,
-        }
-
-    @s_stormtypes.stormfunc(readonly=True)
-    async def _evalStorm(self, text, cast=None):
-
-        text = await s_stormtypes.tostr(text)
-        cast = await s_stormtypes.tostr(cast, noneok=True)
-
-        if self.runt.snap.core.stormlog:
-            extra = await self.runt.snap.core.getLogExtra(text=text)
-            stormlogger.info(f'Executing storm query via $lib.storm.eval() {{{text}}} as [{self.runt.user.name}]', extra=extra)
-
-        casttype = None
-        if cast:
-
-            casttype = self.runt.model.type(cast)
-            if casttype is None:
-                castprop = self.runt.model.prop(cast)
-                if castprop is not None:
-                    casttype = castprop.type
-
-            if casttype is None:
-                mesg = f'No type or property found for name: {cast}'
-                raise s_exc.NoSuchType(mesg=mesg)
-
-        asteval = await self.runt.snap.core._getStormEval(text)
-        valu = await asteval.compute(self.runt, None)
-
-        if casttype:
-            valu, _ = casttype.norm(valu)
-
-        return valu

synapse-2.175.0/synapse/tests/test_lib_stormlib_storm.py

@@ -1,63 +0,0 @@
-import synapse.exc as s_exc
-import synapse.lib.parser as s_parser
-
-import synapse.tests.utils as s_test
-
-class LibStormTest(s_test.SynTest):
-
-    async def test_lib_stormlib_storm(self):
-        async with self.getTestCore() as core:
-
-            opts = {'vars': {'text': '(10)'}}
-            self.eq(10, await core.callStorm('return($lib.storm.eval($text))', opts=opts))
-
-            opts = {'vars': {'text': '10'}}
-            self.eq('10', await core.callStorm('return($lib.storm.eval($text))', opts=opts))
-
-            opts = {'vars': {'text': '10'}}
-            self.eq(10, await core.callStorm('return($lib.storm.eval($text, cast=int))', opts=opts))
-
-            opts = {'vars': {'text': 'WOOT.COM'}}
-            self.eq('woot.com', await core.callStorm('return($lib.storm.eval($text, cast=inet:dns:a:fqdn))', opts=opts))
-
-            opts = {'vars': {'text': '(10 + 20)', 'cast': 'inet:port'}}
-            self.eq(30, await core.callStorm('return($lib.storm.eval($text, cast=$cast))', opts=opts))
-
-            with self.raises(s_exc.NoSuchType):
-                await core.callStorm('return($lib.storm.eval(foo, cast=newp))')
-
-            # for coverage of forked call...
-            self.nn(s_parser.parseEval('woot'))
-
-            # Readonly functionality is sane
-            msgs = await core.stormlist('$lib.print($lib.storm.eval( "{$lib.print(wow)}" ))')
-            self.stormIsInPrint('wow', msgs)
-            self.stormIsInPrint('$lib.null', msgs)
-
-            with self.raises(s_exc.IsReadOnly):
-                await core.callStorm('$lib.storm.eval( "{$lib.auth.users.add(readonly)}" )', opts={'readonly': True})
-
-            with self.getLoggerStream('synapse.storm') as stream:
-                q = '''{
-                    $lib.log.info(hehe)
-                    [test:str=omg]
-                    $lib.log.info($node)
-                    fini { return(wow) }
-                }
-                '''
-
-                core.stormlog = True
-                opts = {'vars': {'q': q}}
-                ret = await core.callStorm('return( $lib.storm.eval($q) )', opts=opts)
-                self.eq(ret, 'wow')
-                self.len(1, await core.nodes('test:str=omg'))
-
-                # Check that we saw the logs
-                stream.seek(0)
-                data = stream.read()
-
-                mesg = 'Executing storm query {return( $lib.storm.eval($q) )} as [root]'
-                self.isin(mesg, data)
-
-                mesg = f'Executing storm query via $lib.storm.eval() {{{q}}} as [root]'
-                self.isin(mesg, data)