synapse 2.164.0__py311-none-any.whl → 2.166.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,7 +3,9 @@ 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
 import synapse.lib.stormlib.auth as slib_auth
 
@@ -85,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}`)
@@ -223,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'}}},
@@ -241,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):
@@ -256,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,
@@ -269,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,
@@ -291,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,
@@ -298,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):
@@ -315,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)
@@ -452,7 +483,7 @@ class HttpApi(s_stormtypes.StormType):
 @s_stormtypes.registry.registerType
 class HttpApiMethods(s_stormtypes.Prim):
     '''
-    Accessor dictionary for getting and setting Extened HTTP API methods.
+    Accessor dictionary for getting and setting Extended HTTP API methods.
 
     Notes:
         The Storm code used to run these methods will have a $request object
@@ -1054,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': (
@@ -1062,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': (
@@ -1110,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)
@@ -1124,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'))
@@ -1167,3 +1221,88 @@ class CortexHttpApi(s_stormtypes.Lib):
         iden = await s_stormtypes.tostr(iden)
         index = await s_stormtypes.toint(index)
         return await self.runt.snap.view.core.setHttpApiIndx(iden, index)
+
+class StormPoolSetCmd(s_storm.Cmd):
+    '''
+    Setup a Storm query offload mirror pool for the Cortex.
+    '''
+    name = 'cortex.storm.pool.set'
+    def getArgParser(self):
+        pars = s_storm.Cmd.getArgParser(self)
+        pars.add_argument('--connection-timeout', type='int', default=2,
+            help='The maximum amount of time to wait for a connection from the pool to become available.')
+        pars.add_argument('--sync-timeout', type='int', default=2,
+            help='The maximum amount of time to wait for the mirror to be in sync with the leader')
+        pars.add_argument('url', type='str', required=True, help='The telepath URL for the AHA service pool.')
+        return pars
+
+    async def execStormCmd(self, runt, genr):
+
+        if not self.runtsafe: # pragma: no cover
+            mesg = 'cortex.storm.pool.set arguments must be runtsafe.'
+            raise s_exc.StormRuntimeError(mesg=mesg)
+
+        mesg = 'cortex.storm.pool.set command requires global admin permissions.'
+        self.runt.reqAdmin(mesg=mesg)
+
+        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,
+        }
+
+        await self.runt.snap.core.setStormPool(self.opts.url, opts)
+        await self.runt.printf('Storm pool configuration set.')
+
+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'
+
+    async def execStormCmd(self, runt, genr):
+
+        mesg = 'cortex.storm.pool.del command requires global admin permissions.'
+        self.runt.reqAdmin(mesg=mesg)
+
+        async for node, path in genr: # pragma: no cover
+            yield node, path
+
+        await self.runt.snap.core.delStormPool()
+        await self.runt.printf('Storm pool configuration removed.')
+
+class StormPoolGetCmd(s_storm.Cmd):
+    '''
+    Display the current Storm query offload mirror pool configuration.
+    '''
+    name = 'cortex.storm.pool.get'
+
+    async def execStormCmd(self, runt, genr):
+
+        mesg = 'cortex.storm.pool.get command requires global admin permissions.'
+        self.runt.reqAdmin(mesg=mesg)
+
+        async for node, path in genr: # pragma: no cover
+            yield node, path
+
+        item = await self.runt.snap.core.getStormPool()
+        if item is None:
+            await self.runt.printf('No Storm pool configuration found.')
+            return
+
+        url, opts = item
+
+        await self.runt.printf(f'Storm Pool URL: {url}')
+        await self.runt.printf(f'Sync Timeout (secs): {opts.get("timeout:sync")}')
+        await self.runt.printf(f'Connection Timeout (secs): {opts.get("timeout:connection")}')

synapse/lib/stormlib/gen.py

@@ -46,12 +46,14 @@ class LibGen(s_stormtypes.Lib):
                       {'name': 'name', 'type': 'str', 'desc': 'The name of the software.'},
                   ),
                   'returns': {'type': 'node', 'desc': 'An it:prod:soft node with the given name.'}}},
-        {'name': 'vulnByCve', 'desc': 'Returns risk:vuln node by CVE, adding the node if it does not exist.',
+        {'name': 'vulnByCve', 'desc': 'Returns risk:vuln node by CVE and reporter, adding the node if it does not exist.',
          'type': {'type': 'function', '_funcname': '_storm_query',
                   'args': (
                       {'name': 'cve', 'type': 'str', 'desc': 'The CVE id.'},
                       {'name': 'try', 'type': 'boolean', 'default': False,
                        'desc': 'Type normalization will fail silently instead of raising an exception.'},
+                      {'name': 'reporter', 'type': 'str', 'default': None,
+                       'desc': 'The name of the organization which reported the vulnerability.'},
                   ),
                   'returns': {'type': 'node', 'desc': 'A risk:vuln node with the given CVE.'}}},
 
@@ -128,6 +130,12 @@ class LibGen(s_stormtypes.Lib):
                        'desc': 'Type normalization will fail silently instead of raising an exception.'},
                   ),
                   'returns': {'type': 'node', 'desc': 'An it:av:scan:result node.'}}},
+        {'name': 'geoPlaceByName', 'desc': 'Returns a geo:place node by name, adding the node if it does not exist.',
+         'type': {'type': 'function', '_funcname': '_storm_query',
+                  'args': (
+                      {'name': 'name', 'type': 'str', 'desc': 'The name of the place.'},
+                  ),
+                  'returns': {'type': 'node', 'desc': 'A geo:place node with the given name.'}}},
     )
     _storm_lib_path = ('gen',)
 
@@ -222,14 +230,27 @@ class LibGen(s_stormtypes.Lib):
             return($node)
         }
 
-        function vulnByCve(cve, try=$lib.false) {
+        function vulnByCve(cve, try=$lib.false, reporter=$lib.null) {
             ($ok, $cve) = $__maybeCast($try, it:sec:cve, $cve)
             if (not $ok) { return() }
 
             risk:vuln:cve=$cve
+            if $reporter {
+                +:reporter:name=$reporter
+                { -:reporter [ :reporter=$orgByName($reporter) ] }
+            }
             return($node)
 
-            [ risk:vuln=(gen, cve, $cve) :cve=$cve ]
+            $guid = (gen, cve, $cve)
+            if $reporter {
+                $reporter = $lib.cast(ou:name, $reporter)
+                $guid.append($reporter)
+            }
+
+            [ risk:vuln=$guid :cve=$cve ]
+            if $reporter {
+                [ :reporter:name=$reporter :reporter=$orgByName($reporter) ]
+            }
             return($node)
         }
 
@@ -394,6 +415,16 @@ class LibGen(s_stormtypes.Lib):
 
             return($node)
         }
+
+        function geoPlaceByName(name) {
+            $geoname = $lib.cast(geo:name, $name)
+
+            geo:name=$geoname -> geo:place
+            return($node)
+
+            [ geo:place=(gen, name, $geoname) :name=$geoname ]
+            return($node)
+        }
     '''
 
 stormcmds = (
@@ -483,14 +514,20 @@ stormcmds = (
     {
         'name': 'gen.risk.vuln',
         'descr': '''
-            Lift (or create) a risk:vuln node based on the CVE.
+            Lift (or create) a risk:vuln node based on the CVE and reporter name.
+
+            Examples:
+
+                // Yield a risk:vuln node for CVE-2012-0157 reported by Mandiant.
+                gen.risk.vuln CVE-2012-0157 Mandiant
         ''',
         'cmdargs': (
             ('cve', {'help': 'The CVE identifier.'}),
+            ('reporter', {'help': 'The name of the reporting organization.', 'nargs': '?'}),
             ('--try', {'help': 'Type normalization will fail silently instead of raising an exception.',
                        'action': 'store_true'}),
         ),
-        'storm': 'yield $lib.gen.vulnByCve($cmdopts.cve, try=$cmdopts.try)',
+        'storm': 'yield $lib.gen.vulnByCve($cmdopts.cve, try=$cmdopts.try, reporter=$cmdopts.reporter)',
     },
     {
         'name': 'gen.ou.industry',
@@ -594,5 +631,15 @@ stormcmds = (
             yield $lib.gen.itAvScanResultByTarget($cmdopts.form, $cmdopts.value, $cmdopts.signame,
                                                   scanner=$cmdopts.scanner_name, time=$cmdopts.time, try=$cmdopts.try)
         ''',
-    }
+    },
+    {
+        'name': 'gen.geo.place',
+        'descr': '''
+            Lift (or create) a geo:place node based on the name.
+        ''',
+        'cmdargs': (
+            ('name', {'help': 'The name of the place.'}),
+        ),
+        'storm': 'yield $lib.gen.geoPlaceByName($cmdopts.name)',
+    },
 )

synapse/lib/stormlib/math.py

@@ -10,7 +10,7 @@ class MathLib(s_stormtypes.Lib):
          'desc': '''
             Convert a value to a Storm Number object.
 
-            Storm Numbers are high precision fixed point decimals corresponding to the
+            Storm Numbers are high precision fixed point decimals corresponding to
             the hugenum storage type.
 
             This is not to be used for converting a string to an integer.

synapse/lib/stormlib/model.py

@@ -329,6 +329,7 @@ class LibModel(s_stormtypes.Lib):
     @s_cache.memoizemethod(size=100)
     @s_stormtypes.stormfunc(readonly=True)
     async def _methType(self, name):
+        name = await s_stormtypes.tostr(name)
         type_ = self.model.type(name)
         if type_ is not None:
             return ModelType(type_)
@@ -336,6 +337,7 @@ class LibModel(s_stormtypes.Lib):
     @s_cache.memoizemethod(size=100)
     @s_stormtypes.stormfunc(readonly=True)
     async def _methProp(self, name):
+        name = await s_stormtypes.tostr(name)
         prop = self.model.prop(name)
         if prop is not None:
             return ModelProp(prop)
@@ -343,6 +345,7 @@ class LibModel(s_stormtypes.Lib):
     @s_cache.memoizemethod(size=100)
     @s_stormtypes.stormfunc(readonly=True)
     async def _methForm(self, name):
+        name = await s_stormtypes.tostr(name)
         form = self.model.form(name)
         if form is not None:
             return ModelForm(form)
@@ -350,6 +353,7 @@ class LibModel(s_stormtypes.Lib):
     @s_cache.memoize(size=100)
     @s_stormtypes.stormfunc(readonly=True)
     async def _methTagProp(self, name):
+        name = await s_stormtypes.tostr(name)
         tagprop = self.model.getTagProp(name)
         if tagprop is not None:
             return ModelTagProp(tagprop)
@@ -394,7 +398,8 @@ class ModelForm(s_stormtypes.Prim):
         return ModelType(self.valu.type, path=path)
 
     @s_stormtypes.stormfunc(readonly=True)
-    def _getFormProp(self, name):
+    async def _getFormProp(self, name):
+        name = await s_stormtypes.tostr(name)
         prop = self.valu.prop(name)
         if prop is not None:
             return ModelProp(prop)
@@ -593,10 +598,12 @@ class LibModelEdge(s_stormtypes.Lib):
 
     @s_stormtypes.stormfunc(readonly=True)
     def _methValidKeys(self):
+        s_common.deprecated('model.edge.validkeys', curv='2.165.0')
         return self.validedgekeys
 
     @s_stormtypes.stormfunc(readonly=True)
     async def _methEdgeGet(self, verb):
+        s_common.deprecated('model.edge.get', curv='2.165.0')
         verb = await s_stormtypes.tostr(verb)
         await self._chkEdgeVerbInView(verb)
 
@@ -604,6 +611,7 @@ class LibModelEdge(s_stormtypes.Lib):
         return await self.runt.snap.core.getHiveKey(path) or {}
 
     async def _methEdgeSet(self, verb, key, valu):
+        s_common.deprecated('model.edge.set', curv='2.165.0')
         verb = await s_stormtypes.tostr(verb)
         await self._chkEdgeVerbInView(verb)
 
@@ -619,6 +627,7 @@ class LibModelEdge(s_stormtypes.Lib):
         await self.runt.snap.core.setHiveKey(path, kvdict)
 
     async def _methEdgeDel(self, verb, key):
+        s_common.deprecated('model.edge.del', curv='2.165.0')
         verb = await s_stormtypes.tostr(verb)
         await self._chkEdgeVerbInView(verb)
 
@@ -637,6 +646,7 @@ class LibModelEdge(s_stormtypes.Lib):
 
     @s_stormtypes.stormfunc(readonly=True)
     async def _methEdgeList(self):
+        s_common.deprecated('model.edge.list', curv='2.165.0')
         retn = []
         async for verb in self.runt.snap.view.getEdgeVerbs():
             path = self.hivepath + (verb, 'extprops')