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

synapse/lib/stormlib/cache.py

@@ -0,0 +1,202 @@
+import asyncio
+
+import synapse.exc as s_exc
+
+import synapse.lib.ast as s_ast
+import synapse.lib.cache as s_cache
+import synapse.lib.stormctrl as s_stormctrl
+import synapse.lib.stormtypes as s_stormtypes
+
+CACHE_SIZE_MAX = 10_000
+CACHE_SIZE_DEFAULT = 10_000
+
+@s_stormtypes.registry.registerLib
+class LibCache(s_stormtypes.Lib):
+    '''
+    A Storm Library for interacting with Cache Objects.
+    '''
+    _storm_locals = (
+        {'name': 'fixed', 'desc': '''
+            Get a new Fixed Cache object.
+
+            On a cache-miss when calling .get(), the callback Storm query is executed in a sub-runtime
+            in the current execution context. A special variable, $cache_key, will be set
+            to the key argument provided to .get().
+
+            The callback Storm query must contain a return statement, and if it does not return a value
+            when executed with the input, $lib.null will be set as the value.
+
+            The fixed cache uses FIFO to evict items once the maximum size is reached.
+
+            Examples:
+
+                // Use a callback query with a function that modifies the outer runtime,
+                // since it will run in the scope where it was defined.
+                $test = foo
+
+                function callback(key) {
+                    $test = $key // this will modify $test in the outer runtime
+                    return(`{$key}-val`)
+                }
+
+                $cache = $lib.cache.fixed(${ return($callback($cache_key)) })
+                $value = $cache.get(bar)
+                $lib.print($test) // this will equal "bar"
+
+                // Use a callback query that will not modify the outer runtime,
+                // except for variables accessible as references.
+                $test = foo
+                $tests = ([])
+
+                $cache = $lib.cache.fixed(${
+                    $test = $cache_key        // this will *not* modify $test in the outer runtime
+                    $tests.append($cache_key) // this will modify $tests in the outer runtime
+                    return(`{$cache_key}-val`)
+                })
+
+                $value = $cache.get(bar)
+                $lib.print($test)  // this will equal "foo"
+                $lib.print($tests) // this will equal (foo,)
+            ''',
+         'type': {'type': 'function', '_funcname': '_methFixedCache',
+                  'args': (
+                      {'name': 'callback', 'type': ['str', 'storm:query'],
+                       'desc': 'A Storm query that will return a value for $cache_key on a cache miss.', },
+                      {'name': 'size', 'type': 'int', 'default': CACHE_SIZE_DEFAULT,
+                       'desc': 'The maximum size of the cache.', },
+                  ),
+                  'returns': {'type': 'cache:fixed', 'desc': 'A new ``cache:fixed`` object.'}}},
+    )
+    _storm_lib_path = ('cache',)
+
+    def getObjLocals(self):
+        return {
+            'fixed': self._methFixedCache,
+        }
+
+    @s_stormtypes.stormfunc(readonly=True)
+    async def _methFixedCache(self, callback, size=CACHE_SIZE_DEFAULT):
+        size = await s_stormtypes.toint(size)
+        callback = await s_stormtypes.tostr(callback)
+
+        if size < 1 or size > CACHE_SIZE_MAX:
+            raise s_exc.BadArg(mesg=f'Cache size must be between 1-{CACHE_SIZE_MAX}')
+
+        try:
+            query = await self.runt.getStormQuery(callback)
+        except s_exc.BadSyntax as e:
+            raise s_exc.BadArg(mesg=f'Invalid callback query: {e.errinfo.get("mesg")}')
+
+        if not query.hasAstClass(s_ast.Return):
+            raise s_exc.BadArg(mesg='Callback query must return a value')
+
+        return FixedCache(self.runt, query, size=size)
+
+@s_stormtypes.registry.registerType
+class FixedCache(s_stormtypes.StormType):
+    '''
+    A StormLib API instance of a Storm Fixed Cache.
+    '''
+    _storm_locals = (
+        {'name': 'query', 'desc': 'Get the callback Storm query as string.',
+         'type': {'type': 'gtor', '_gtorfunc': '_gtorQuery',
+                  'returns': {'type': 'str', 'desc': 'The callback Storm query text.', }}},
+        {'name': 'get', 'desc': 'Get an item from the cache by key.',
+         'type': {'type': 'function', '_funcname': '_methGet',
+                  'args': (
+                      {'name': 'key', 'type': 'any', 'desc': 'The key to lookup.'},
+                  ),
+                  'returns': {'type': 'any',
+                              'desc': 'The value from the cache, or the callback query if it does not exist', }}},
+        {'name': 'pop', 'desc': 'Pop an item from the cache.',
+         'type': {'type': 'function', '_funcname': '_methPop',
+                  'args': (
+                      {'name': 'key', 'type': 'any', 'desc': 'The key to pop.'},
+                  ),
+                  'returns': {'type': 'any',
+                              'desc': 'The value from the cache, or $lib.null if it does not exist', }}},
+        {'name': 'put', 'desc': 'Put an item into the cache.',
+         'type': {'type': 'function', '_funcname': '_methPut',
+                  'args': (
+                      {'name': 'key', 'type': 'any', 'desc': 'The key put in the cache.'},
+                      {'name': 'value', 'type': 'any', 'desc': 'The value to assign to the key.'},
+                  ),
+                  'returns': {'type': 'null', }}},
+        {'name': 'clear', 'desc': 'Clear all items from the cache.',
+         'type': {'type': 'function', '_funcname': '_methClear',
+                  'returns': {'type': 'null', }}},
+    )
+    _storm_typename = 'cache:fixed'
+    _ismutable = False
+
+    def __init__(self, runt, query, size=CACHE_SIZE_DEFAULT):
+        s_stormtypes.StormType.__init__(self)
+        self.runt = runt
+        self.size = size
+        self.query = query
+        self.locls.update(self.getObjLocals())
+        self.gtors.update({
+            'query': self._gtorQuery,
+        })
+
+        self.cache = s_cache.FixedCache(self._runCallback, size=size)
+
+    def __len__(self):
+        return len(self.cache)
+
+    async def stormrepr(self):
+        if len(qtext := self.query.text) > 100:
+            qtext = qtext[:100] + '...'
+        return f'{self._storm_typename}: size={self.size} query="{qtext}"'
+
+    def getObjLocals(self):
+        return {
+            'pop': self._methPop,
+            'put': self._methPut,
+            'get': self._methGet,
+            'clear': self._methClear,
+        }
+
+    async def _gtorQuery(self):
+        return self.query.text
+
+    async def _runCallback(self, key):
+
+        varz = self.runt.getScopeVars()
+        varz['cache_key'] = key
+
+        opts = {'vars': varz}
+        async with self.runt.getCmdRuntime(self.query, opts=opts) as runt:
+            try:
+                async for _ in runt.execute():
+                    await asyncio.sleep(0)
+            except s_stormctrl.StormReturn as e:
+                return await s_stormtypes.toprim(e.item)
+            except s_stormctrl.StormCtrlFlow:
+                pass
+
+    async def _reqKey(self, key):
+        if s_stormtypes.ismutable(key):
+            mesg = 'Mutable values are not allowed as cache keys'
+            raise s_exc.BadArg(mesg=mesg, name=await s_stormtypes.torepr(key))
+        return await s_stormtypes.toprim(key)
+
+    @s_stormtypes.stormfunc(readonly=True)
+    async def _methPop(self, key):
+        key = await self._reqKey(key)
+        return self.cache.pop(key)
+
+    @s_stormtypes.stormfunc(readonly=True)
+    async def _methPut(self, key, value):
+        key = await self._reqKey(key)
+        val = await s_stormtypes.toprim(value)
+        self.cache.put(key, val)
+
+    @s_stormtypes.stormfunc(readonly=True)
+    async def _methGet(self, key):
+        key = await self._reqKey(key)
+        return await self.cache.aget(key)
+
+    @s_stormtypes.stormfunc(readonly=True)
+    async def _methClear(self):
+        self.cache.clear()

synapse/lib/stormlib/cortex.py

@@ -3,6 +3,7 @@ import json
 import logging
 
 import synapse.exc as s_exc
+import synapse.telepath as s_telepath
 
 import synapse.lib.storm as s_storm
 import synapse.lib.stormtypes as s_stormtypes
@@ -86,6 +87,7 @@ stormcmds = [
             $lib.print(`!View: No view found ({$err.info.iden})`)
         }
         $lib.print(`Readonly: {$api.readonly}`)
+        $lib.print(`Pool enabled: {$api.pool}`)
         $lib.print(`Authenticated: {$api.authenticated}`)
         $lib.print(`Name: {$api.name}`)
         $lib.print(`Description: {$api.desc}`)
@@ -224,6 +226,9 @@ class HttpApi(s_stormtypes.StormType):
         ''',
          'type': {'type': ['stor', 'gtor'], '_storfunc': '_storPath', '_gtorfunc': '_gtorPath',
                   'returns': {'type': 'str'}}},
+        {'name': 'pool', 'desc': 'Boolean value indicating if the handler responses may be executed as part of a Storm pool.',
+         'type': {'type': ['stor', 'gtor'], '_storfunc': '_storPool', '_gtorfunc': '_gtorPool',
+                  'returns': {'type': 'boolean'}}},
         {'name': 'vars', 'desc': 'The Storm runtime variables specific for the API instance.',
          'type': {'type': ['stor', 'ctor'], '_storfunc': '_storVars', '_ctorfunc': '_ctorVars',
                   'returns': {'type': 'http:api:vars'}}},
@@ -242,6 +247,8 @@ class HttpApi(s_stormtypes.StormType):
         {'name': 'authenticated', 'desc': 'Boolean value indicating if the Extended HTTP API requires an authenticated user or session.',
          'type': {'type': ['stor', 'gtor'], '_storfunc': '_storAuthenticated', '_gtorfunc': '_gtorAuthenticated',
                   'returns': {'type': 'boolean'}}},
+        {'name': 'methods', 'desc': 'The dictionary containing the Storm code used to implement the HTTP methods.',
+         'type': {'type': ['ctor'], '_ctorfunc': '_ctorMethods', 'returns': {'type': 'http:api:methods'}}}
     )
 
     def __init__(self, runt, info):
@@ -257,6 +264,7 @@ class HttpApi(s_stormtypes.StormType):
             'name': self._storName,
             'desc': self._storDesc,
             'path': self._storPath,
+            'pool': self._storPool,
             'vars': self._storVars,
             'view': self._storView,
             'runas': self._storRunas,
@@ -270,6 +278,7 @@ class HttpApi(s_stormtypes.StormType):
             'name': self._gtorName,
             'desc': self._gtorDesc,
             'path': self._gtorPath,
+            'pool': self._gtorPool,
             'view': self._gtorView,
             'runas': self._gtorRunas,
             'owner': self._gtorOwner,
@@ -292,6 +301,13 @@ class HttpApi(s_stormtypes.StormType):
             'created': self.info.get('created'),
         })
 
+    async def stormrepr(self):
+        name = await self._gtorName()
+        if not name:
+            name = '<no name>'
+        path = await self._gtorPath()
+        return f'{self._storm_typename}: {name} ({self.iden}), path={path}'
+
     def getObjLocals(self):
         return {
             'pack': self._methPack,
@@ -299,7 +315,10 @@ class HttpApi(s_stormtypes.StormType):
 
     @s_stormtypes.stormfunc(readonly=True)
     async def _methPack(self):
-        return copy.deepcopy(self.info)
+        # TODO: Remove this when we've migrated the HTTPAPI data to set this value.
+        ret = copy.deepcopy(self.info)
+        ret.setdefault('pool', False)
+        return ret
 
     @s_stormtypes.stormfunc(readonly=True)
     def _ctorMethods(self, path=None):
@@ -316,6 +335,17 @@ class HttpApi(s_stormtypes.StormType):
     async def _gtorPath(self):
         return self.info.get('path')
 
+    async def _storPool(self, pool):
+        s_stormtypes.confirm(('storm', 'lib', 'cortex', 'httpapi', 'set'))
+        pool = await s_stormtypes.tobool(pool)
+        adef = await self.runt.snap.core.modHttpExtApi(self.iden, 'pool', pool)
+        self.info['pool'] = pool
+        self.info['updated'] = adef.get('updated')
+
+    @s_stormtypes.stormfunc(readonly=True)
+    async def _gtorPool(self):
+        return self.info.get('pool')
+
     async def _storName(self, name):
         s_stormtypes.confirm(('storm', 'lib', 'cortex', 'httpapi', 'set'))
         name = await s_stormtypes.tostr(name)
@@ -1055,7 +1085,7 @@ class CortexHttpApi(s_stormtypes.Lib):
                       {'name': 'readonly', 'type': 'boolean',
                        'desc': 'Run the Extended HTTP Storm methods in readonly mode.', 'default': False},
                   ),
-                  'returns': {'type': 'http:api', 'desc': 'A new http:api object.'}}},
+                  'returns': {'type': 'http:api', 'desc': 'A new ``http:api`` object.'}}},
         {'name': 'del', 'desc': 'Delete an Extended HTTP API endpoint.',
          'type': {'type': 'function', '_funcname': 'delHttpApi',
                   'args': (
@@ -1063,16 +1093,29 @@ class CortexHttpApi(s_stormtypes.Lib):
                        'desc': 'The iden of the API to delete.'},
                   ),
                   'returns': {'type': 'null'}}},
-        {'name': 'get', 'desc': 'Get an Extended HTTP API object.',
+        {'name': 'get', 'desc': 'Get an Extended ``http:api`` object.',
          'type': {'type': 'function', '_funcname': 'getHttpApi',
                   'args': (
                       {'name': 'iden', 'type': 'string',
-                       'desc': 'The iden of the API to retreive.'},
+                       'desc': 'The iden of the API to retrieve.'},
+                  ),
+                  'returns': {'type': 'http:api', 'desc': 'The ``http:api`` object.'}}},
+        {'name': 'getByPath', 'desc': '''
+        Get an Extended ``http:api`` object by path.
+
+        Notes:
+            The path argument is evaluated as a regular expression input, and will be
+            used to get the first HTTP API handler whose path value has a match.
+        ''',
+         'type': {'type': 'function', '_funcname': 'getHttpApiByPath',
+                  'args': (
+                      {'name': 'path', 'type': 'string',
+                       'desc': 'Path to use to retrieve an object.'},
                   ),
-                  'returns': {'type': 'http:api', 'desc': 'The http:api object.'}}},
-        {'name': 'list', 'desc': 'Get all the Extneded HTTP APIs on the Cortex',
+                  'returns': {'type': ['http:api', 'null'], 'desc': 'The ``http:api`` object or ``$lib.null`` if there is no match.'}}},
+        {'name': 'list', 'desc': 'Get all the Extended HTTP APIs on the Cortex',
          'type': {'type': 'function', '_funcname': 'listHttpApis', 'args': (),
-                  'returns': {'type': 'list', 'desc': 'A list of http:api objects'}}},
+                 'returns': {'type': 'list', 'desc': 'A list of ``http:api`` objects'}}},
         {'name': 'index', 'desc': 'Set the index for a given Extended HTTP API.',
          'type': {'type': 'function', '_funcname': 'setHttpApiIndx',
                   'args': (
@@ -1111,6 +1154,7 @@ class CortexHttpApi(s_stormtypes.Lib):
             'list': self.listHttpApis,
             'index': self.setHttpApiIndx,
             'response': self.makeHttpResponse,
+            'getByPath': self.getHttpApiByPath,
         }
 
     @s_stormtypes.stormfunc(readonly=True)
@@ -1125,6 +1169,15 @@ class CortexHttpApi(s_stormtypes.Lib):
         adef = await self.runt.snap.core.getHttpExtApi(iden)
         return HttpApi(self.runt, adef)
 
+    @s_stormtypes.stormfunc(readonly=True)
+    async def getHttpApiByPath(self, path):
+        s_stormtypes.confirm(('storm', 'lib', 'cortex', 'httpapi', 'get'))
+        path = await s_stormtypes.tostr(path)
+        adef, _ = await self.runt.snap.core.getHttpExtApiByPath(path)
+        if adef is None:
+            return None
+        return HttpApi(self.runt, adef)
+
     @s_stormtypes.stormfunc(readonly=True)
     async def listHttpApis(self):
         s_stormtypes.confirm(('storm', 'lib', 'cortex', 'httpapi', 'get'))
@@ -1195,6 +1248,11 @@ class StormPoolSetCmd(s_storm.Cmd):
         async for node, path in genr: # pragma: no cover
             yield node, path
 
+        try:
+            s_telepath.chopurl(self.opts.url)
+        except s_exc.BadUrl as e:
+            raise s_exc.BadArg(mesg=f'Unable to set Storm pool URL from url={self.opts.url} : {e.get("mesg")}') from None
+
         opts = {
             'timeout:sync': self.opts.sync_timeout,
             'timeout:connection': self.opts.connection_timeout,
@@ -1206,6 +1264,10 @@ class StormPoolSetCmd(s_storm.Cmd):
 class StormPoolDelCmd(s_storm.Cmd):
     '''
     Remove a Storm query offload mirror pool configuration.
+
+    Notes:
+        This will result in tearing down any Storm queries currently being serviced by the Storm pool.
+        This may result in this command raising an exception if it was offloaded to a pool member. That would be an expected behavior.
     '''
     name = 'cortex.storm.pool.del'
 

synapse/lib/stormlib/macro.py

@@ -34,7 +34,7 @@ stormcmds = [
         'name': 'macro.del',
         'descr': macro_del_descr,
         'cmdargs': (
-            ('name', {'help': 'The name of the macro to delete.'}),
+            ('name', {'type': 'str', 'help': 'The name of the macro to delete.'}),
         ),
         'storm': '''
             $lib.macro.del($cmdopts.name)
@@ -45,7 +45,7 @@ stormcmds = [
         'name': 'macro.set',
         'descr': macro_set_descr,
         'cmdargs': (
-            ('name', {'help': 'The name of the macro to set.'}),
+            ('name', {'type': 'str', 'help': 'The name of the macro to set.'}),
             ('storm', {'help': 'The storm command string or embedded query to set.'}),
         ),
         'storm': '''
@@ -57,7 +57,7 @@ stormcmds = [
         'name': 'macro.get',
         'descr': macro_get_descr,
         'cmdargs': (
-            ('name', {'help': 'The name of the macro to display.'}),
+            ('name', {'type': 'str', 'help': 'The name of the macro to display.'}),
         ),
         'storm': '''
             $mdef = $lib.macro.get($cmdopts.name)
@@ -74,8 +74,14 @@ stormcmds = [
         'storm': '''
             $count = $(0)
             for ($name, $mdef) in $lib.macro.list() {
-                $user = $lib.auth.users.get($mdef.user)
-                $lib.print('{name} (owner: {user})', name=$name.ljust(20), user=$user.name)
+                $user = $lib.auth.users.get($mdef.creator)
+                $username = $lib.null
+                if (not $user) {
+                    $username = `User not found ({$mdef.creator})`
+                } else {
+                    $username = $user.name
+                }
+                $lib.print('{name} (owner: {user})', name=$name.ljust(20), user=$username)
                 $count = $($count + 1)
             }
             $lib.print('{count} macros found', count=$count)
@@ -185,27 +191,17 @@ class LibMacro(s_stormtypes.Lib):
     async def _funcMacroGet(self, name):
         name = await s_stormtypes.tostr(name)
 
-        if len(name) > 491:
-            raise s_exc.BadArg(mesg='Macro names may only be up to 491 chars.')
-
         return self.runt.snap.core.getStormMacro(name, user=self.runt.user)
 
     async def _funcMacroDel(self, name):
-
         name = await s_stormtypes.tostr(name)
 
-        if len(name) > 491:
-            raise s_exc.BadArg(mesg='Macro names may only be up to 491 chars.')
-
         return await self.runt.snap.core.delStormMacro(name, user=self.runt.user)
 
     async def _funcMacroSet(self, name, storm):
         name = await s_stormtypes.tostr(name)
         storm = await s_stormtypes.tostr(storm)
 
-        if len(name) > 491:
-            raise s_exc.BadArg(mesg='Macro names may only be up to 491 chars.')
-
         await self.runt.getStormQuery(storm)
 
         if self.runt.snap.core.getStormMacro(name) is None:
@@ -220,9 +216,6 @@ class LibMacro(s_stormtypes.Lib):
         name = await s_stormtypes.tostr(name)
         info = await s_stormtypes.toprim(info)
 
-        if len(name) > 491:
-            raise s_exc.BadArg(mesg='Macro names may only be up to 491 chars.')
-
         if not isinstance(info, dict):
             raise s_exc.BadArg(mesg='Macro info must be a dictionary object.')
 

synapse/lib/stormlib/spooled.py

@@ -0,0 +1,109 @@
+import synapse.exc as s_exc
+import synapse.lib.msgpack as s_msgpack
+import synapse.lib.spooled as s_spooled
+import synapse.lib.stormtypes as s_stormtypes
+
+@s_stormtypes.registry.registerLib
+class LibSpooled(s_stormtypes.Lib):
+    '''
+    A Storm Library for interacting with Spooled Objects.
+    '''
+    _storm_locals = (
+        {'name': 'set', 'desc': '''
+            Get a Spooled Storm Set object.
+
+            A Spooled Storm Set object is memory-safe to grow to extraordinarily large sizes,
+            as it will fallback to file backed storage, with two restrictions. First
+            is that all items in the set can be serialized to a file if the set grows too large,
+            so all items added must be a serializable Storm primitive. Second is that when an
+            item is added to the Set, because it could be immediately written disk,
+            do not hold any references to it outside of the Set itself, as the two objects could
+            differ.
+            ''',
+         'type': {'type': 'function', '_funcname': '_methSet',
+                  'args': (
+                      {'name': '*vals', 'type': 'any', 'desc': 'Initial values to place in the set.', },
+                  ),
+                  'returns': {'type': 'set', 'desc': 'The new set.'}}},
+    )
+    _storm_lib_path = ('spooled',)
+
+    def getObjLocals(self):
+        return {
+            'set': self._methSet,
+        }
+
+    @s_stormtypes.stormfunc(readonly=True)
+    async def _methSet(self, *vals):
+        core = self.runt.snap.core
+        spool = await s_spooled.Set.anit(dirn=core.dirn, cell=core, size=1000)
+
+        valu = list(vals)
+        for item in valu:
+            if s_stormtypes.ismutable(item):
+                mesg = f'{await s_stormtypes.torepr(item)} is mutable and cannot be used in a set.'
+                raise s_exc.StormRuntimeError(mesg=mesg)
+
+            if not s_msgpack.isok(item):
+                mesg = f'{await s_stormtypes.torepr(item)} is not safe to be used in a SpooledSet.'
+                raise s_exc.StormRuntimeError(mesg=mesg)
+
+            await spool.add(item)
+
+        return SpooledSet(spool)
+
+@s_stormtypes.registry.registerType
+class SpooledSet(s_stormtypes.Set):
+    '''
+    A StormLib API instance of a Storm Set object that can fallback to lmdb.
+    '''
+    _storm_typename = 'spooled:set'
+    _ismutable = True
+
+    def __init__(self, valu, path=None):
+
+        s_stormtypes.Prim.__init__(self, valu, path=path)
+        self.locls.update(self.getObjLocals())
+
+    async def iter(self):
+        async for item in self.valu:
+            yield item
+
+    @s_stormtypes.stormfunc(readonly=True)
+    async def _methSetAdd(self, *items):
+        for i in items:
+            if s_stormtypes.ismutable(i):
+                mesg = f'{await s_stormtypes.torepr(i)} is mutable and cannot be used in a set.'
+                raise s_exc.StormRuntimeError(mesg=mesg)
+
+            if not s_msgpack.isok(i):
+                mesg = f'{await s_stormtypes.torepr(i)} is not safe to be used in a SpooledSet.'
+                raise s_exc.StormRuntimeError(mesg=mesg)
+
+            await self.valu.add(i)
+
+    @s_stormtypes.stormfunc(readonly=True)
+    async def _methSetAdds(self, *items):
+        for item in items:
+            async for i in s_stormtypes.toiter(item):
+                if s_stormtypes.ismutable(i):
+                    mesg = f'{await s_stormtypes.torepr(i)} is mutable and cannot be used in a set.'
+                    raise s_exc.StormRuntimeError(mesg=mesg)
+
+                if not s_msgpack.isok(i):
+                    mesg = f'{await s_stormtypes.torepr(i)} is not safe to be used in a SpooledSet.'
+                    raise s_exc.StormRuntimeError(mesg=mesg)
+
+                await self.valu.add(i)
+
+    @s_stormtypes.stormfunc(readonly=True)
+    async def _methSetList(self):
+        return [x async for x in self.valu]
+
+    async def stormrepr(self):
+        reprs = [await s_stormtypes.torepr(k) async for k in self.valu]
+        rval = ', '.join(reprs)
+        return f'{{{rval}}}'
+
+    async def value(self):
+        return set([x async for x in self.valu])

synapse/lib/stormlib/stix.py

@@ -585,7 +585,7 @@ def validateStix(bundle, version='2.1'):
         'result': {},
     }
     bundle = json.loads(json.dumps(bundle))
-    opts = stix2validator.ValidationOptions(strict=True, version=version, no_cache=True)
+    opts = stix2validator.ValidationOptions(strict=True, version=version)
     try:
         results = stix2validator.validate_parsed_json(bundle, options=opts)
     except stix2validator.ValidationError as e: